Merge branch 'download_folder__refactoring_observance_of_downloads_in_progress' into...
[pub/Android/ownCloud.git] / src / com / owncloud / android / services / OperationsService.java
index 6e70a8c..779e5b6 100644 (file)
@@ -18,6 +18,7 @@
 package com.owncloud.android.services;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
@@ -26,6 +27,7 @@ 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;
@@ -84,7 +86,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";
@@ -180,22 +183,27 @@ public class OperationsService extends Service {
             Pair<Target, RemoteOperation> itemToQueue = newOperation(intent);
             if (itemToQueue != null) {
                 mSyncFolderHandler.add(account, remotePath, (SynchronizeFolderOperation)itemToQueue.second);
-                sendBroadcastNewSyncFolder(account, remotePath);
+                mSyncFolderHandler.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_REMOTE_PATH)) {
+            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);
-            String remotePath = intent.getStringExtra(EXTRA_REMOTE_PATH);
-
+            final Account account = intent.getParcelableExtra(EXTRA_ACCOUNT);
+            final OCFile file = intent.getParcelableExtra(EXTRA_FILE);
             // Cancel operation
-            mSyncFolderHandler.cancel(account,remotePath);
+            new Thread(new Runnable() {
+                public void run() {
+                    // Cancel the download
+                    mSyncFolderHandler.cancel(account,file);
+                }
+            }).start();
+
         } else {
             Message msg = mOperationsHandler.obtainMessage();
             msg.arg1 = startId;
@@ -205,19 +213,6 @@ 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" );
@@ -384,9 +379,11 @@ public class OperationsService extends Service {
          * @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);
         }
+        */
 
     }
 
@@ -422,7 +419,13 @@ public class OperationsService extends Service {
             if (account == null || remotePath == null) return false;
             String targetKey = buildRemoteName(account, remotePath);
             synchronized (mPendingOperations) {
-                return (mPendingOperations.containsKey(targetKey));
+                // TODO - this can be slow when synchronizing a big tree - need a better data structure
+                Iterator<String> it = mPendingOperations.keySet().iterator();
+                boolean found = false;
+                while (it.hasNext() && !found) {
+                    found = it.next().startsWith(targetKey);
+                }
+                return found;
             }
         }
         
@@ -447,6 +450,7 @@ public class OperationsService extends Service {
             }
 
             if (mCurrentSyncOperation != null) {
+                RemoteOperationResult result = null;
 
                 try {
 
@@ -458,7 +462,7 @@ public class OperationsService extends Service {
                             mService.getContentResolver()
                     );
 
-                    mCurrentSyncOperation.execute(mOwnCloudClient, mStorageManager);
+                    result = mCurrentSyncOperation.execute(mOwnCloudClient, mStorageManager);
 
                 } catch (AccountsException e) {
                     Log_OC.e(TAG, "Error while trying to get autorization", e);
@@ -468,6 +472,10 @@ public class OperationsService extends Service {
                     synchronized(mPendingOperations) {
                         mPendingOperations.remove(syncKey);
                     }
+
+                    mService.dispatchResultToOperationListeners(null, mCurrentSyncOperation, result);
+                    
+                    sendBroadcastFinishedSyncFolder(account, remotePath, result.isSuccess());
                 }
             }
         }
@@ -477,21 +485,50 @@ public class OperationsService extends Service {
             mPendingOperations.putIfAbsent(syncKey,syncFolderOperation);
         }
 
-
         /**
-         * Cancels a pending or current sync operation.
-         *
+         * Cancels sync operations.
          * @param account       Owncloud account where the remote file is stored.
-         * @param remotePath    A remote file path
+         * @param file          File OCFile
          */
-        public void cancel(Account account, String remotePath) {
+        public void cancel(Account account, OCFile file){
             SynchronizeFolderOperation syncOperation = null;
+            String targetKey = buildRemoteName(account, file.getRemotePath());
+            ArrayList<String> keyItems = new ArrayList<String>();
             synchronized (mPendingOperations) {
-                syncOperation = mPendingOperations.remove(buildRemoteName(account, remotePath));
-            }
-            if (syncOperation != null) {
-                syncOperation.cancel();
+                if (file.isFolder()) {
+                    Log_OC.d(TAG, "Canceling pending sync operations");
+                    Iterator<String> it = mPendingOperations.keySet().iterator();
+                    boolean found = false;
+                    while (it.hasNext()) {
+                        String keySyncOperation = it.next();
+                        found = keySyncOperation.startsWith(targetKey);
+                        if (found) {
+                            keyItems.add(keySyncOperation);
+                        }
+                    }
+                    
+                } else {
+                    // this is not really expected...
+                    Log_OC.d(TAG, "Canceling sync operation");
+                    keyItems.add(buildRemoteName(account, file.getRemotePath()));
+                }
+                for (String item: keyItems) {
+                    syncOperation = mPendingOperations.remove(item);
+                    if (syncOperation != null) {
+                        syncOperation.cancel();
+                    }
+                }
             }
+
+            //sendBroadcastFinishedSyncFolder(account, file.getRemotePath());
+            
+            /// 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);
         }
 
         /**
@@ -503,6 +540,34 @@ public class OperationsService extends Service {
         private String buildRemoteName(Account account, String path) {
             return account.name + path;
         }
+        
+        
+        /**
+         * TODO review 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);
+            mService.sendStickyBroadcast(added);
+        }
+
+        /**
+         * TODO review this method when "folder synchronization" replaces "folder download"; this is a fast and ugly 
+         * patch. 
+         */
+        private void sendBroadcastFinishedSyncFolder(Account account, String remotePath, boolean success) {
+            Intent finished = new Intent(FileDownloader.getDownloadFinishMessage());
+            finished.putExtra(FileDownloader.ACCOUNT_NAME, account.name);
+            finished.putExtra(FileDownloader.EXTRA_REMOTE_PATH, remotePath);
+            finished.putExtra(FileDownloader.EXTRA_FILE_PATH, FileStorageUtils.getSavePath(account.name) + remotePath);
+            finished.putExtra(FileDownloader.EXTRA_DOWNLOAD_RESULT, success);
+            mService.sendStickyBroadcast(finished);
+        }
+
+
     }
 
 
@@ -678,7 +743,7 @@ public class OperationsService extends Service {
                     String remotePath = operationIntent.getStringExtra(EXTRA_REMOTE_PATH);
                     Intent sendIntent = operationIntent.getParcelableExtra(EXTRA_SEND_INTENT);
                     if (remotePath.length() > 0) {
-                        operation = new CreateShareOperation(remotePath, ShareType.PUBLIC_LINK, 
+                        operation = new CreateShareOperation(OperationsService.this, remotePath, ShareType.PUBLIC_LINK,
                                 "", false, "", 1, sendIntent);
                     }
                     
@@ -820,7 +885,7 @@ public class OperationsService extends Service {
     
     /**
      * Notifies the currently subscribed listeners about the end of an operation.
-     * 
+     *
      * @param target            Account or URL pointing to an OC server.
      * @param operation         Finished operation.
      * @param result            Result of the operation.