activities: Removed hungarian variable name notation.

src/main/java/com/owncloud/android/ui/activities/ActivitiesPresenter.java

@@ -32,34 +32,34 @@ import java.util.List;
 
 public class ActivitiesPresenter implements ActivitiesContract.ActionListener {
 
-    private final ActivitiesContract.View mActivitiesView;
-    private final ActivitiesRepository mActivitiesRepository;
-    private final FilesRepository mFilesRepository;
+    private final ActivitiesContract.View activitiesView;
+    private final ActivitiesRepository activitiesRepository;
+    private final FilesRepository filesRepository;
 
 
     public ActivitiesPresenter(@NonNull ActivitiesRepository activitiesRepository,
                                @NonNull FilesRepository filesRepository,
                                @NonNull ActivitiesContract.View activitiesView) {
-        mActivitiesRepository = activitiesRepository;
-        mActivitiesView = activitiesView;
-        mFilesRepository = filesRepository;
+        this.activitiesRepository = activitiesRepository;
+        this.activitiesView = activitiesView;
+        this.filesRepository = filesRepository;
     }
 
     @Override
     public void loadActivities(String pageUrl) {
-        mActivitiesView.setProgressIndicatorState(true);
-        mActivitiesRepository.getActivities(pageUrl, new ActivitiesRepository.LoadActivitiesCallback() {
+        activitiesView.setProgressIndicatorState(true);
+        activitiesRepository.getActivities(pageUrl, new ActivitiesRepository.LoadActivitiesCallback() {
             @Override
             public void onActivitiesLoaded(List<Object> activities, OwnCloudClient client,
                                           String nextPageUrl) {
-                mActivitiesView.setProgressIndicatorState(false);
-                mActivitiesView.showActivities(activities, client, nextPageUrl);
+                activitiesView.setProgressIndicatorState(false);
+                activitiesView.showActivities(activities, client, nextPageUrl);
             }
 
             @Override
             public void onActivitiesLoadedError(String error) {
-                mActivitiesView.setProgressIndicatorState(false);
-                mActivitiesView.showActivitiesLoadError(error);
+                activitiesView.setProgressIndicatorState(false);
+                activitiesView.showActivitiesLoadError(error);
             }
         });
 
@@ -68,23 +68,23 @@ public class ActivitiesPresenter implements ActivitiesContract.ActionListener {
 
     @Override
     public void openActivity(String fileUrl, BaseActivity baseActivity, boolean isSharingSupported) {
-        mActivitiesView.setProgressIndicatorState(true);
-        mFilesRepository.readRemoteFile(fileUrl, baseActivity, isSharingSupported,
+        activitiesView.setProgressIndicatorState(true);
+        filesRepository.readRemoteFile(fileUrl, baseActivity, isSharingSupported,
                 new FilesRepository.ReadRemoteFileCallback() {
                     @Override
                     public void onFileLoaded(@Nullable OCFile ocFile) {
-                        mActivitiesView.setProgressIndicatorState(false);
+                        activitiesView.setProgressIndicatorState(false);
                         if (ocFile != null) {
-                            mActivitiesView.showActivityDetailUI(ocFile);
+                            activitiesView.showActivityDetailUI(ocFile);
                         } else {
-                            mActivitiesView.showActivityDetailUIIsNull();
+                            activitiesView.showActivityDetailUIIsNull();
                         }
                     }
 
                     @Override
                     public void onFileLoadError(String error) {
-                        mActivitiesView.setProgressIndicatorState(false);
-                        mActivitiesView.showActivityDetailError(error);
+                        activitiesView.setProgressIndicatorState(false);
+                        activitiesView.showActivityDetailError(error);
                     }
                 });
     }

src/main/java/com/owncloud/android/ui/activities/data/activities/ActivitiesServiceApiImpl.java

@@ -52,17 +52,17 @@ public class ActivitiesServiceApiImpl implements ActivitiesServiceApi {
 
     private static class GetActivityListTask extends AsyncTask<Void, Void, Boolean> {
 
-        private final ActivitiesServiceCallback<List<Object>> mCallback;
-        private List<Object> mActivities;
-        private String mPageUrl;
+        private final ActivitiesServiceCallback<List<Object>> callback;
+        private List<Object> activities;
+        private String pageUrl;
         private String noResultsMessage = "no results";
         private String errorMessage;
         private OwnCloudClient ownCloudClient;
 
         private GetActivityListTask(String pageUrl, ActivitiesServiceCallback<List<Object>> callback) {
-            mPageUrl = pageUrl;
-            mCallback = callback;
-            mActivities = new ArrayList<>();
+            this.pageUrl = pageUrl;
+            this.callback = callback;
+            activities = new ArrayList<>();
         }
 
 
@@ -78,17 +78,17 @@ public class ActivitiesServiceApiImpl implements ActivitiesServiceApi {
                 ownCloudClient.setOwnCloudVersion(AccountUtils.getServerVersion(currentAccount));
 
                 GetRemoteActivitiesOperation getRemoteNotificationOperation = new GetRemoteActivitiesOperation();
-                if (mPageUrl != null) {
-                    getRemoteNotificationOperation.setNextUrl(mPageUrl);
+                if (pageUrl != null) {
+                    getRemoteNotificationOperation.setNextUrl(pageUrl);
                 }
 
                 final RemoteOperationResult result = getRemoteNotificationOperation.execute(ownCloudClient);
 
                 if (result.isSuccess() && result.getData() != null) {
                     final ArrayList<Object> data = result.getData();
-                    mActivities = (ArrayList) data.get(0);
+                    activities = (ArrayList) data.get(0);
 
-                    mPageUrl = (String) data.get(1);
+                    pageUrl = (String) data.get(1);
                     return true;
                 } else {
                     Log_OC.d(TAG, result.getLogMessage());
@@ -121,9 +121,9 @@ public class ActivitiesServiceApiImpl implements ActivitiesServiceApi {
         protected void onPostExecute(Boolean success) {
             super.onPostExecute(success);
             if (success) {
-                mCallback.onLoaded(mActivities, ownCloudClient,  mPageUrl);
+                callback.onLoaded(activities, ownCloudClient, pageUrl);
             } else {
-                mCallback.onError(errorMessage);
+                callback.onError(errorMessage);
             }
         }
     }

src/main/java/com/owncloud/android/ui/activities/data/activities/RemoteActivitiesRepository.java

@@ -26,16 +26,16 @@ import java.util.List;
 
 public class RemoteActivitiesRepository implements ActivitiesRepository {
 
-    private final ActivitiesServiceApi mActivitiesServiceApi;
+    private final ActivitiesServiceApi activitiesServiceApi;
 
     public RemoteActivitiesRepository(@NonNull ActivitiesServiceApi activitiesServiceApi) {
-        mActivitiesServiceApi = activitiesServiceApi;
+        this.activitiesServiceApi = activitiesServiceApi;
     }
 
 
     @Override
     public void getActivities(String pageUrl, @NonNull LoadActivitiesCallback callback) {
-        mActivitiesServiceApi.getAllActivities(pageUrl, new ActivitiesServiceApi.ActivitiesServiceCallback<List<Object>>() {
+        activitiesServiceApi.getAllActivities(pageUrl, new ActivitiesServiceApi.ActivitiesServiceCallback<List<Object>>() {
             @Override
             public void onLoaded(List<Object> activities, OwnCloudClient client,
                                  String nextPageUrl) {

src/main/java/com/owncloud/android/ui/activities/data/files/FilesServiceApiImpl.java

@@ -57,21 +57,21 @@ public class FilesServiceApiImpl implements FilesServiceApi {
     }
 
     private static class ReadRemoteFileTask extends AsyncTask<Void, Object, Boolean> {
-        private final FilesServiceCallback<OCFile> mCallback;
+        private final FilesServiceCallback<OCFile> callback;
         private OCFile remoteOcFile;
         private String errorMessage;
         // TODO: Figure out a better way to do this than passing a BaseActivity reference.
-        private final BaseActivity mBaseActivity;
-        private final boolean mIsSharingSupported;
-        private final String mFileUrl;
+        private final BaseActivity baseActivity;
+        private final boolean isSharingSupported;
+        private final String fileUrl;
 
         private ReadRemoteFileTask(String fileUrl, BaseActivity baseActivity,
                                    boolean isSharingSupported,
                                    FilesServiceCallback<OCFile> callback) {
-            mCallback = callback;
-            mBaseActivity = baseActivity;
-            mIsSharingSupported = isSharingSupported;
-            mFileUrl = fileUrl;
+            this.callback = callback;
+            this.baseActivity = baseActivity;
+            this.isSharingSupported = isSharingSupported;
+            this.fileUrl = fileUrl;
         }
 
         @Override
@@ -86,21 +86,21 @@ public class FilesServiceApiImpl implements FilesServiceApi {
                         getClientFor(ocAccount, MainApp.getAppContext());
                 ownCloudClient.setOwnCloudVersion(AccountUtils.getServerVersion(currentAccount));
                 // always update file as it could be an old state saved in database
-                ReadRemoteFileOperation operation = new ReadRemoteFileOperation(mFileUrl);
+                ReadRemoteFileOperation operation = new ReadRemoteFileOperation(fileUrl);
                 RemoteOperationResult resultRemoteFileOp = operation.execute(ownCloudClient);
                 if (resultRemoteFileOp.isSuccess()) {
                     OCFile temp = FileStorageUtils.fillOCFile((RemoteFile) resultRemoteFileOp.getData().get(0));
-                    remoteOcFile = mBaseActivity.getStorageManager().saveFileWithParent(temp, context);
+                    remoteOcFile = baseActivity.getStorageManager().saveFileWithParent(temp, context);
 
                     if (remoteOcFile.isFolder()) {
                         // perform folder synchronization
                         RemoteOperation synchFolderOp = new RefreshFolderOperation(remoteOcFile,
                                 System.currentTimeMillis(),
                                 false,
-                                mIsSharingSupported,
+                                isSharingSupported,
                                 true,
-                                mBaseActivity.getStorageManager(),
-                                mBaseActivity.getAccount(),
+                                baseActivity.getStorageManager(),
+                                baseActivity.getAccount(),
                                 context);
                         synchFolderOp.execute(ownCloudClient);
                     }
@@ -127,13 +127,13 @@ public class FilesServiceApiImpl implements FilesServiceApi {
         protected void onPostExecute(Boolean success) {
             super.onPostExecute(success);
             if (success && remoteOcFile != null) {
-                mCallback.onLoaded(remoteOcFile);
+                callback.onLoaded(remoteOcFile);
                 return;
             } else if (success) {
                 errorMessage = "File not found";
             }
 
-            mCallback.onError(errorMessage);
+            callback.onError(errorMessage);
         }
     }
 

src/main/java/com/owncloud/android/ui/activities/data/files/RemoteFilesRepository.java

@@ -25,16 +25,16 @@ import com.owncloud.android.ui.activity.BaseActivity;
 
 class RemoteFilesRepository implements FilesRepository {
 
-    private final FilesServiceApi mFilesServiceApi;
+    private final FilesServiceApi filesServiceApi;
 
     public RemoteFilesRepository(@NonNull FilesServiceApi filesServiceApi) {
-        mFilesServiceApi = filesServiceApi;
+        this.filesServiceApi = filesServiceApi;
     }
 
 
     @Override
     public void readRemoteFile(String path, BaseActivity activity, boolean isSharingSupported, @NonNull ReadRemoteFileCallback callback) {
-        mFilesServiceApi.readRemoteFile(path, activity, isSharingSupported,
+        filesServiceApi.readRemoteFile(path, activity, isSharingSupported,
                 new FilesServiceApi.FilesServiceCallback<OCFile>() {
                     @Override
                     public void onLoaded(OCFile ocFile) {