data:files Added file repository classes and interfaces.

This provides a centralized asynchronous repository for all remote File operations. Currently only supports ReadRemoteFile as required by the activities activity.

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

@@ -0,0 +1,16 @@
+package com.owncloud.android.ui.activities.data.files;
+
+import android.support.annotation.NonNull;
+
+public class FileRepositories {
+
+    private FileRepositories() {
+        // No instance
+    }
+
+    private static FilesRepository repository = null;
+
+    public static synchronized FilesRepository getRepository(@NonNull FilesServiceApi filesServiceApi) {
+        return new RemoteFilesRepository(filesServiceApi);
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.owncloud.android.ui.activities.data.files;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.ui.activity.BaseActivity;
+
+/**
+ * Main entry point for accessing remote files
+ */
+public interface FilesRepository {
+    interface ReadRemoteFileCallback {
+        void onFileLoaded(@Nullable OCFile ocFile);
+        void onFileLoadError(String error);
+    }
+
+    void readRemoteFile(String path, BaseActivity activity, boolean isSharingSupported,
+                        @NonNull ReadRemoteFileCallback callback);
+}

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

@@ -0,0 +1,19 @@
+package com.owncloud.android.ui.activities.data.files;
+
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.ui.activity.BaseActivity;
+
+/**
+ * Defines an interface to the Files service API. All {{@link OCFile}} remote data requests
+ * should be piped through this interface.
+ */
+public interface FilesServiceApi {
+
+    interface FilesServiceCallback<T> {
+        void onLoaded(OCFile ocFile);
+        void onError(String error);
+    }
+
+    void readRemoteFile(String fileUrl, BaseActivity activity, boolean isSharingSupported,
+                        FilesServiceApi.FilesServiceCallback<OCFile> callback);
+}

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

@@ -0,0 +1,118 @@
+package com.owncloud.android.ui.activities.data.files;
+
+import android.accounts.Account;
+import android.accounts.AuthenticatorException;
+import android.accounts.OperationCanceledException;
+import android.content.Context;
+import android.os.AsyncTask;
+
+import com.owncloud.android.MainApp;
+import com.owncloud.android.authentication.AccountUtils;
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.lib.common.OwnCloudAccount;
+import com.owncloud.android.lib.common.OwnCloudClient;
+import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
+import com.owncloud.android.lib.common.operations.RemoteOperation;
+import com.owncloud.android.lib.common.operations.RemoteOperationResult;
+import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.lib.resources.files.ReadRemoteFileOperation;
+import com.owncloud.android.lib.resources.files.RemoteFile;
+import com.owncloud.android.operations.RefreshFolderOperation;
+import com.owncloud.android.ui.activity.BaseActivity;
+import com.owncloud.android.utils.FileStorageUtils;
+
+import java.io.IOException;
+
+/**
+ * Implementation of the Files service API that communicates with the NextCloud remote server.
+ */
+public class FilesServiceApiImpl implements FilesServiceApi {
+
+    private static final String TAG = FilesServiceApiImpl.class.getSimpleName();
+
+    @Override
+    public void readRemoteFile(String fileUrl, BaseActivity activity,
+                               boolean isSharingSupported, FilesServiceCallback<OCFile> callback) {
+        ReadRemoteFileTask readRemoteFileTask = new ReadRemoteFileTask(fileUrl, activity,
+                isSharingSupported, callback);
+        readRemoteFileTask.execute();
+    }
+
+    private static class ReadRemoteFileTask extends AsyncTask<Void, Object, Boolean> {
+        private final FilesServiceCallback<OCFile> mCallback;
+        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;
+
+        @Override
+        protected void onPostExecute(Boolean success) {
+            super.onPostExecute(success);
+            if (success && remoteOcFile != null) {
+                mCallback.onLoaded(remoteOcFile);
+            } else {
+                mCallback.onError(errorMessage);
+            }
+        }
+
+        private ReadRemoteFileTask(String fileUrl, BaseActivity baseActivity,
+                                   boolean isSharingSupported,
+                                   FilesServiceCallback<OCFile> callback) {
+            mCallback = callback;
+            mBaseActivity = baseActivity;
+            mIsSharingSupported = isSharingSupported;
+            mFileUrl = fileUrl;
+        }
+
+        @Override
+        protected Boolean doInBackground(Void... voids) {
+            final Account currentAccount = AccountUtils.getCurrentOwnCloudAccount(MainApp.getAppContext());
+            final Context context = MainApp.getAppContext();
+            OwnCloudAccount ocAccount;
+            OwnCloudClient ownCloudClient;
+            try {
+                ocAccount = new OwnCloudAccount(currentAccount, context);
+                ownCloudClient = OwnCloudClientManagerFactory.getDefaultSingleton().
+                        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);
+                RemoteOperationResult resultRemoteFileOp = operation.execute(ownCloudClient);
+                if (resultRemoteFileOp.isSuccess()) {
+                    OCFile temp = FileStorageUtils.fillOCFile((RemoteFile) resultRemoteFileOp.getData().get(0));
+                    remoteOcFile = mBaseActivity.getStorageManager().saveFileWithParent(temp, context);
+
+                    if (remoteOcFile.isFolder()) {
+                        // perform folder synchronization
+                        RemoteOperation synchFolderOp = new RefreshFolderOperation(remoteOcFile,
+                                System.currentTimeMillis(),
+                                false,
+                                mIsSharingSupported,
+                                true,
+                                mBaseActivity.getStorageManager(),
+                                mBaseActivity.getAccount(),
+                                context);
+                        synchFolderOp.execute(ownCloudClient);
+                    }
+                }
+                return true;
+            } catch (com.owncloud.android.lib.common.accounts.AccountUtils.AccountNotFoundException e) {
+                Log_OC.e(TAG, "Account not found", e);
+                errorMessage = "Account not found";
+            } catch (IOException e) {
+                Log_OC.e(TAG, "IO error", e);
+                errorMessage = "IO error";
+            } catch (OperationCanceledException e) {
+                Log_OC.e(TAG, "Operation has been canceled", e);
+                errorMessage = "Operation has been canceled";
+            } catch (AuthenticatorException e) {
+                Log_OC.e(TAG, "Authentication Exception", e);
+                errorMessage = "Authentication Exception";
+            }
+
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.owncloud.android.ui.activities.data.files;
+
+import android.support.annotation.NonNull;
+
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.ui.activity.BaseActivity;
+
+class RemoteFilesRepository implements FilesRepository {
+
+    private final FilesServiceApi mFilesServiceApi;
+
+    public RemoteFilesRepository(@NonNull FilesServiceApi filesServiceApi) {
+        mFilesServiceApi = filesServiceApi;
+    }
+
+
+    @Override
+    public void readRemoteFile(String path, BaseActivity activity, boolean isSharingSupported, @NonNull ReadRemoteFileCallback callback) {
+        mFilesServiceApi.readRemoteFile(path, activity, isSharingSupported,
+                new FilesServiceApi.FilesServiceCallback<OCFile>() {
+                    @Override
+                    public void onLoaded(OCFile ocFile) {
+                        callback.onFileLoaded(ocFile);
+                    }
+
+                    @Override
+                    public void onError(String error) {
+                        callback.onFileLoadError(error);
+                    }
+                });
+    }
+}