Move every sendBroadcast from SynchronizeFolderOperation to SyncFolderHandler scope

src/com/owncloud/android/files/FileMenuFilter.java

@@ -143,7 +143,9 @@ public class FileMenuFilter {
             FileDownloaderBinder downloaderBinder = mComponentsGetter.getFileDownloaderBinder();
             downloading = downloaderBinder != null && downloaderBinder.isDownloading(mAccount, mFile);
             OperationsServiceBinder opsBinder = mComponentsGetter.getOperationsServiceBinder();
-            downloading |= (opsBinder != null && opsBinder.isSynchronizing(mAccount, mFile.getRemotePath()));
+            downloading |= (
+                    mFile.isFolder() && opsBinder != null && opsBinder.isSynchronizing(mAccount, mFile.getRemotePath())
+            );
             FileUploaderBinder uploaderBinder = mComponentsGetter.getFileUploaderBinder();
             uploading = uploaderBinder != null && uploaderBinder.isUploading(mAccount, mFile);
         }

src/com/owncloud/android/operations/SynchronizeFolderOperation.java

@@ -159,9 +159,6 @@ public class SynchronizeFolderOperation extends SyncOperation {
                     syncContents(client);
                 }
 
-                if (mFilesForDirectDownload.isEmpty()) {
-                    sendBroadcastForNotifyingUIUpdate(result.isSuccess());
-                }
             }
             
             if (mCancellationRequested.get()) {
@@ -170,16 +167,6 @@ public class SynchronizeFolderOperation extends SyncOperation {
             
         } catch (OperationCancelledException e) {
             result = new RemoteOperationResult(e);
-
-            // Needed in case that cancellation occurs before starting any download.
-            // If not, yellow arrow continues being shown.
-            sendBroadcastForNotifyingUIUpdate(false);
-
-            Intent intent = new Intent(mContext, FileDownloader.class);
-            intent.setAction(FileDownloader.ACTION_CANCEL_FILE_DOWNLOAD);
-            intent.putExtra(FileDownloader.EXTRA_ACCOUNT, mAccount);
-            intent.putExtra(FileDownloader.EXTRA_FILE, mLocalFolder);
-            mContext.startService(intent);            
         }
 
         return result;
@@ -224,7 +211,6 @@ public class SynchronizeFolderOperation extends SyncOperation {
                         result.getLogMessage());
             }
 
-            sendBroadcastForNotifyingUIUpdate(result.isSuccess());
         }
 
         return result;
@@ -511,16 +497,6 @@ public class SynchronizeFolderOperation extends SyncOperation {
         }
     }
 
-    private void sendBroadcastForNotifyingUIUpdate(boolean result) {
-        // Send a broadcast message for notifying UI update
-        Intent uiUpdate = new Intent(FileDownloader.getDownloadFinishMessage());
-        uiUpdate.putExtra(FileDownloader.EXTRA_DOWNLOAD_RESULT, result);
-        uiUpdate.putExtra(FileDownloader.ACCOUNT_NAME, mAccount.name);
-        uiUpdate.putExtra(FileDownloader.EXTRA_REMOTE_PATH, mRemotePath);
-        uiUpdate.putExtra(FileDownloader.EXTRA_FILE_PATH, mLocalFolder.getRemotePath());
-        mContext.sendStickyBroadcast(uiUpdate);
-    }
-
     
     /**
      * Cancel operation

src/com/owncloud/android/services/OperationsService.java

@@ -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;
@@ -182,7 +183,7 @@ 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;
@@ -193,11 +194,16 @@ public class OperationsService extends Service {
                 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);
-
+            final Account account = intent.getParcelableExtra(EXTRA_ACCOUNT);
+            final OCFile file = intent.getParcelableExtra(EXTRA_FILE);
             // Cancel operation
-            mSyncFolderHandler.cancel(account,file);
+            new Thread(new Runnable() {
+                public void run() {
+                    // Cancel the download
+                    mSyncFolderHandler.cancel(account,file);
+                }
+            }).start();
+
         } else {
             Message msg = mOperationsHandler.obtainMessage();
             msg.arg1 = startId;
@@ -207,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" );
@@ -424,7 +417,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;
             }
         }
         
@@ -473,6 +472,8 @@ public class OperationsService extends Service {
                     }
 
                     mService.dispatchResultToOperationListeners(null, mCurrentSyncOperation, result);
+                    
+                    sendBroadcastFinishedSyncFolder(account, remotePath, result.isSuccess());
                 }
             }
         }
@@ -490,6 +491,7 @@ public class OperationsService extends Service {
         public void cancel(Account account, OCFile file){
             SynchronizeFolderOperation syncOperation = null;
             String targetKey = buildRemoteName(account, file.getRemotePath());
+            ArrayList<String> keyItems = new ArrayList<String>();
             synchronized (mPendingOperations) {
                 if (file.isFolder()) {
                     Log_OC.d(TAG, "Canceling pending sync operations");
@@ -499,25 +501,25 @@ public class OperationsService extends Service {
                         String keySyncOperation = it.next();
                         found = keySyncOperation.startsWith(targetKey);
                         if (found) {
-                            syncOperation = mPendingOperations.get(keySyncOperation);
-                            if (syncOperation != null) {
-                                syncOperation.cancel();
-                                // Leave the ops in the hash; the cancellation is "passive"
-                                // TODO review full life-cicle of operations when folder download is replaced with
-                                //  folder synchronization
-                            }
+                            keyItems.add(keySyncOperation);
                         }
                     }
+                    
                 } else {
                     // this is not really expected...
                     Log_OC.d(TAG, "Canceling sync operation");
-                    syncOperation = mPendingOperations.get(buildRemoteName(account, file.getRemotePath()));
+                    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);
@@ -536,6 +538,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);
+        }
+
+
     }
 
 

src/com/owncloud/android/ui/adapter/FileListListAdapter.java

@@ -166,7 +166,7 @@ public class FileListListAdapter extends BaseAdapter implements ListAdapter {
             FileUploaderBinder uploaderBinder = mTransferServiceGetter.getFileUploaderBinder();
             OperationsServiceBinder opsBinder = mTransferServiceGetter.getOperationsServiceBinder();
             if ((downloaderBinder != null && downloaderBinder.isDownloading(mAccount, file)) ||
-                 (opsBinder != null && opsBinder.isSynchronizing(mAccount, file.getRemotePath()))) {
+                 (file.isFolder() && opsBinder != null && opsBinder.isSynchronizing(mAccount, file.getRemotePath()))) {
                 localStateView.setImageResource(R.drawable.downloading_file_indicator);
                 localStateView.setVisibility(View.VISIBLE);
             } else if (uploaderBinder != null && uploaderBinder.isUploading(mAccount, file)) {