X-Git-Url: http://git.linex4red.de/pub/Android/ownCloud.git/blobdiff_plain/f6f1c7e6291edf9aa5e240773daf4235eaf9ecb2..cc77ea37de47ecf8d0261978aa9de924c917deec:/src/com/owncloud/android/services/OperationsService.java diff --git a/src/com/owncloud/android/services/OperationsService.java b/src/com/owncloud/android/services/OperationsService.java index 2538be6b..385306dd 100644 --- a/src/com/owncloud/android/services/OperationsService.java +++ b/src/com/owncloud/android/services/OperationsService.java @@ -26,6 +26,8 @@ import java.util.concurrent.ConcurrentMap; import com.owncloud.android.MainApp; import com.owncloud.android.R; import com.owncloud.android.datamodel.FileDataStorageManager; +import com.owncloud.android.datamodel.OCFile; +import com.owncloud.android.files.services.FileDownloader; import com.owncloud.android.lib.common.OwnCloudAccount; import com.owncloud.android.lib.common.OwnCloudClient; import com.owncloud.android.lib.common.OwnCloudClientManagerFactory; @@ -50,6 +52,7 @@ import com.owncloud.android.operations.RenameFileOperation; import com.owncloud.android.operations.SynchronizeFileOperation; import com.owncloud.android.operations.SynchronizeFolderOperation; import com.owncloud.android.operations.UnshareLinkOperation; +import com.owncloud.android.utils.FileStorageUtils; import android.accounts.Account; import android.accounts.AccountsException; @@ -82,7 +85,8 @@ public class OperationsService extends Service { public static final String EXTRA_SYNC_FILE_CONTENTS = "SYNC_FILE_CONTENTS"; public static final String EXTRA_RESULT = "RESULT"; public static final String EXTRA_NEW_PARENT_PATH = "NEW_PARENT_PATH"; - + public static final String EXTRA_FILE = "FILE"; + // TODO review if ALL OF THEM are necessary public static final String EXTRA_SUCCESS_IF_ABSENT = "SUCCESS_IF_ABSENT"; public static final String EXTRA_USERNAME = "USERNAME"; @@ -134,7 +138,7 @@ public class OperationsService extends Service { private ServiceHandler mOperationsHandler; private OperationsServiceBinder mOperationsBinder; - private ServiceHandler mSyncFolderHandler; + private SyncFolderHandler mSyncFolderHandler; /** * Service initialization @@ -151,7 +155,7 @@ public class OperationsService extends Service { /// Separated worker thread for download of folders (WIP) thread = new HandlerThread("Syncfolder thread", Process.THREAD_PRIORITY_BACKGROUND); thread.start(); - mSyncFolderHandler = new ServiceHandler(thread.getLooper(), this); + mSyncFolderHandler = new SyncFolderHandler(thread.getLooper(), this); } @@ -163,19 +167,37 @@ public class OperationsService extends Service { */ @Override public int onStartCommand(Intent intent, int flags, int startId) { + // WIP: for the moment, only SYNC_FOLDER and CANCEL_SYNC_FOLDER is expected here; + // the rest of the operations are requested through the Binder if (ACTION_SYNC_FOLDER.equals(intent.getAction())) { - // WIP: for the moment, only SYNC_FOLDER is expected here; the rest of the operations are requested through - // the Binder + if (!intent.hasExtra(EXTRA_ACCOUNT) || !intent.hasExtra(EXTRA_REMOTE_PATH)) { + Log_OC.e(TAG, "Not enough information provided in intent"); + return START_NOT_STICKY; + } + Account account = intent.getParcelableExtra(EXTRA_ACCOUNT); + String remotePath = intent.getStringExtra(EXTRA_REMOTE_PATH); + + Pair itemSyncKey = new Pair(account, remotePath); + Pair itemToQueue = newOperation(intent); if (itemToQueue != null) { - mSyncFolderHandler.mPendingOperations.add(itemToQueue); + mSyncFolderHandler.add(account, remotePath, (SynchronizeFolderOperation)itemToQueue.second); + sendBroadcastNewSyncFolder(account, remotePath); Message msg = mSyncFolderHandler.obtainMessage(); msg.arg1 = startId; + msg.obj = itemSyncKey; mSyncFolderHandler.sendMessage(msg); } - } else if (ACTION_CANCEL_SYNC_FOLDER.equals(intent.getAction())) { + if (!intent.hasExtra(EXTRA_ACCOUNT) || !intent.hasExtra(EXTRA_FILE)) { + Log_OC.e(TAG, "Not enough information provided in intent"); + return START_NOT_STICKY; + } + Account account = intent.getParcelableExtra(EXTRA_ACCOUNT); + OCFile file = intent.getParcelableExtra(EXTRA_FILE); + // Cancel operation + mSyncFolderHandler.cancel(account,file); } else { Message msg = mOperationsHandler.obtainMessage(); msg.arg1 = startId; @@ -185,6 +207,19 @@ public class OperationsService extends Service { return START_NOT_STICKY; } + /** + * TODO remove this method when "folder synchronization" replaces "folder download"; this is a fast and ugly + * patch. + */ + private void sendBroadcastNewSyncFolder(Account account, String remotePath) { + Intent added = new Intent(FileDownloader.getDownloadAddedMessage()); + added.putExtra(FileDownloader.ACCOUNT_NAME, account.name); + added.putExtra(FileDownloader.EXTRA_REMOTE_PATH, remotePath); + added.putExtra(FileDownloader.EXTRA_FILE_PATH, FileStorageUtils.getSavePath(account.name) + remotePath); + sendStickyBroadcast(added); + } + + @Override public void onDestroy() { //Log_OC.wtf(TAG, "onDestroy init" ); @@ -211,7 +246,6 @@ public class OperationsService extends Service { super.onDestroy(); } - /** * Provides a binder object that clients can use to perform actions on the queue of operations, * except the addition of new operations. @@ -232,7 +266,7 @@ public class OperationsService extends Service { return false; // not accepting rebinding (default behaviour) } - + /** * Binder to let client components to perform actions on the queue of operations. * @@ -342,10 +376,146 @@ public class OperationsService extends Service { //Log_OC.wtf(TAG, "Not finished yet"); } } + + + /** + * Returns True when the file described by 'file' in the ownCloud account 'account' is downloading or waiting to download. + * + * If 'file' is a directory, returns 'true' if some of its descendant files is downloading or waiting to download. + * + * @param account ownCloud account where the remote file is stored. + * @param file A file that could be affected + */ + public boolean isSynchronizing(Account account, String remotePath) { + return mSyncFolderHandler.isSynchronizing(account, remotePath); + } } - - + + + /** + * SyncFolder worker. Performs the pending operations in the order they were requested. + * + * Created with the Looper of a new thread, started in {@link OperationsService#onCreate()}. + */ + private static class SyncFolderHandler extends Handler { + + // don't make it a final class, and don't remove the static ; lint will warn about a possible memory leak + + OperationsService mService; + + private ConcurrentMap mPendingOperations = + new ConcurrentHashMap(); + private OwnCloudClient mOwnCloudClient = null; + private FileDataStorageManager mStorageManager; + private SynchronizeFolderOperation mCurrentSyncOperation; + + + public SyncFolderHandler(Looper looper, OperationsService service) { + super(looper); + if (service == null) { + throw new IllegalArgumentException("Received invalid NULL in parameter 'service'"); + } + mService = service; + } + + + public boolean isSynchronizing(Account account, String remotePath) { + if (account == null || remotePath == null) return false; + String targetKey = buildRemoteName(account, remotePath); + synchronized (mPendingOperations) { + return (mPendingOperations.containsKey(targetKey)); + } + } + + + @Override + public void handleMessage(Message msg) { + Pair itemSyncKey = (Pair) msg.obj; + doOperation(itemSyncKey.first, itemSyncKey.second); + mService.stopSelf(msg.arg1); + } + + + /** + * Performs the next operation in the queue + */ + private void doOperation(Account account, String remotePath) { + + String syncKey = buildRemoteName(account,remotePath); + + synchronized(mPendingOperations) { + mCurrentSyncOperation = mPendingOperations.get(syncKey); + } + + if (mCurrentSyncOperation != null) { + + try { + + OwnCloudAccount ocAccount = new OwnCloudAccount(account, mService); + mOwnCloudClient = OwnCloudClientManagerFactory.getDefaultSingleton(). + getClientFor(ocAccount, mService); + mStorageManager = new FileDataStorageManager( + account, + mService.getContentResolver() + ); + + mCurrentSyncOperation.execute(mOwnCloudClient, mStorageManager); + + } catch (AccountsException e) { + Log_OC.e(TAG, "Error while trying to get autorization", e); + } catch (IOException e) { + Log_OC.e(TAG, "Error while trying to get autorization", e); + } finally { + synchronized(mPendingOperations) { + mPendingOperations.remove(syncKey); + } + } + } + } + + public void add(Account account, String remotePath, SynchronizeFolderOperation syncFolderOperation){ + String syncKey = buildRemoteName(account,remotePath); + mPendingOperations.putIfAbsent(syncKey,syncFolderOperation); + } + + + /** + * Cancels a pending or current sync operation. + * + * @param account Owncloud account where the remote file is stored. + * @param file File + */ + public void cancel(Account account, OCFile file) { + SynchronizeFolderOperation syncOperation = null; + synchronized (mPendingOperations) { + syncOperation = mPendingOperations.remove(buildRemoteName(account, file.getRemotePath())); + } + if (syncOperation != null) { + syncOperation.cancel(); + } + + /// cancellation of download needs to be done separately in any case; a SynchronizeFolderOperation + // may finish much sooner than the real download of the files in the folder + Intent intent = new Intent(mService, FileDownloader.class); + intent.setAction(FileDownloader.ACTION_CANCEL_FILE_DOWNLOAD); + intent.putExtra(FileDownloader.EXTRA_ACCOUNT, account); + intent.putExtra(FileDownloader.EXTRA_FILE, file); + mService.startService(intent); + } + + /** + * Builds a key from the account and file to download + * + * @param account Account where the file to download is stored + * @param path File path + */ + private String buildRemoteName(Account account, String path) { + return account.name + path; + } + } + + /** * Operations worker. Performs the pending operations in the order they were requested. * @@ -358,7 +528,7 @@ public class OperationsService extends Service { OperationsService mService; - private ConcurrentLinkedQueue> mPendingOperations = + private ConcurrentLinkedQueue> mPendingOperations = new ConcurrentLinkedQueue>(); private RemoteOperation mCurrentOperation = null; private Target mLastTarget = null; @@ -690,6 +860,4 @@ public class OperationsService extends Service { } Log_OC.d(TAG, "Called " + count + " listeners"); } - - }