Merge pull request #12194 from nextcloud/bugfix/make_cancel_work_with_new_upload_worker

Bugfix/Make cancelation work again for Android >= 11 via Worker

app/src/main/java/com/nextcloud/client/jobs/BackgroundJobManager.kt

@@ -137,6 +137,7 @@ interface BackgroundJobManager {
     fun startAccountRemovalJob(accountName: String, remoteWipe: Boolean)
     fun startFilesUploadJob(user: User)
     fun getFileUploads(user: User): LiveData<List<JobInfo>>
+    fun cancelFilesUploadJob(user: User)
 
     fun startPdfGenerateAndUploadWork(user: User, uploadFolder: String, imagePaths: List<String>, pdfPath: String)
 

app/src/main/java/com/nextcloud/client/jobs/BackgroundJobManagerImpl.kt

@@ -461,6 +461,10 @@ internal class BackgroundJobManagerImpl(
         return workInfo.map { it -> it.map { fromWorkInfo(it) ?: JobInfo() } }
     }
 
+    override fun cancelFilesUploadJob(user: User) {
+        workManager.cancelJob(JOB_FILES_UPLOAD, user)
+    }
+
     override fun startPdfGenerateAndUploadWork(
         user: User,
         uploadFolder: String,

app/src/main/java/com/nextcloud/client/jobs/FilesUploadWorker.kt

@@ -76,6 +76,7 @@ class FilesUploadWorker(
     private val notificationManager: NotificationManager =
         context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
     private val fileUploaderDelegate = FileUploaderDelegate()
+    private var currentUploadFileOperation: UploadFileOperation? = null
 
     override fun doWork(): Result {
         val accountName = inputData.getString(ACCOUNT)
@@ -89,7 +90,7 @@ class FilesUploadWorker(
          * they will be present in the pages that follow.
          */
         var currentPage = uploadsStorageManager.getCurrentAndPendingUploadsForAccountPageAscById(-1, accountName)
-        while (currentPage.isNotEmpty()) {
+        while (currentPage.isNotEmpty() && !isStopped) {
             Log_OC.d(TAG, "Handling ${currentPage.size} uploads for account $accountName")
             val lastId = currentPage.last().uploadId
             handlePendingUploads(currentPage, accountName)
@@ -105,11 +106,16 @@ class FilesUploadWorker(
         val user = userAccountManager.getUser(accountName)
 
         for (upload in uploads) {
+            if (isStopped) {
+                break
+            }
             // create upload file operation
             if (user.isPresent) {
                 val uploadFileOperation = createUploadFileOperation(upload, user.get())
 
+                currentUploadFileOperation = uploadFileOperation
                 val result = upload(uploadFileOperation, user.get())
+                currentUploadFileOperation = null
 
                 fileUploaderDelegate.sendBroadcastUploadFinished(
                     uploadFileOperation,
@@ -172,13 +178,16 @@ class FilesUploadWorker(
             Log_OC.e(TAG, "Error uploading", e)
             uploadResult = RemoteOperationResult<Any?>(e)
         } finally {
-            uploadsStorageManager.updateDatabaseUploadResult(uploadResult, uploadFileOperation)
+            // only update db if operation finished and worker didn't get canceled
+            if (!(isStopped && uploadResult.isCancelled)) {
+                uploadsStorageManager.updateDatabaseUploadResult(uploadResult, uploadFileOperation)
 
-            // / notify result
-            notifyUploadResult(uploadFileOperation, uploadResult)
+                // / notify result
+                notifyUploadResult(uploadFileOperation, uploadResult)
 
-            // cancel notification
-            notificationManager.cancel(FOREGROUND_SERVICE_ID)
+                // cancel notification
+                notificationManager.cancel(FOREGROUND_SERVICE_ID)
+            }
         }
 
         return uploadResult
@@ -357,6 +366,12 @@ class FilesUploadWorker(
         lastPercent = percent
     }
 
+    override fun onStopped() {
+        super.onStopped()
+        currentUploadFileOperation?.cancel(null)
+        notificationManager.cancel(FOREGROUND_SERVICE_ID)
+    }
+
     companion object {
         val TAG: String = FilesUploadWorker::class.java.simpleName
         private const val FOREGROUND_SERVICE_ID: Int = 412

app/src/main/java/com/owncloud/android/files/services/FileUploader.java

@@ -89,6 +89,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.NoSuchElementException;
 
 import javax.annotation.Nullable;
 import javax.inject.Inject;
@@ -1152,24 +1153,34 @@ public class FileUploader extends Service
          * @param remotePath  Remote target of the upload
          * @param resultCode  Setting result code will pause rather than cancel the job
          */
-        private void cancel(String accountName, String remotePath, @Nullable ResultCode resultCode) {
-            Pair<UploadFileOperation, String> removeResult = mPendingUploads.remove(accountName, remotePath);
-            UploadFileOperation upload = removeResult.first;
-            if (upload == null && mCurrentUpload != null && mCurrentAccount != null &&
-                mCurrentUpload.getRemotePath().startsWith(remotePath) && accountName.equals(mCurrentAccount.name)) {
+        public void cancel(String accountName, String remotePath, @Nullable ResultCode resultCode) {
+            // Cancel for Android version >= Android 11
+            if (useFilesUploadWorker(getApplicationContext())){
+                try{
+                    new FilesUploadHelper().cancelFileUpload(remotePath, accountManager.getUser(accountName).get());
+                }catch(NoSuchElementException e){
+                    Log_OC.e(TAG,"Error cancelling current upload because user does not exist!");
+                }
+            } else {
+                // Cancel for Android version <= Android 10
+                Pair<UploadFileOperation, String> removeResult = mPendingUploads.remove(accountName, remotePath);
+                UploadFileOperation upload = removeResult.first;
+                if (upload == null && mCurrentUpload != null && mCurrentAccount != null &&
+                    mCurrentUpload.getRemotePath().startsWith(remotePath) && accountName.equals(mCurrentAccount.name)) {
 
-                upload = mCurrentUpload;
-            }
+                    upload = mCurrentUpload;
+                }
 
-            if (upload != null) {
-                upload.cancel(resultCode);
-                // need to update now table in mUploadsStorageManager,
-                // since the operation will not get to be run by FileUploader#uploadFile
-                if (resultCode != null) {
-                    mUploadsStorageManager.updateDatabaseUploadResult(new RemoteOperationResult(resultCode), upload);
-                    notifyUploadResult(upload, new RemoteOperationResult(resultCode));
-                } else {
-                    mUploadsStorageManager.removeUpload(accountName, remotePath);
+                if (upload != null) {
+                    upload.cancel(resultCode);
+                    // need to update now table in mUploadsStorageManager,
+                    // since the operation will not get to be run by FileUploader#uploadFile
+                    if (resultCode != null) {
+                        mUploadsStorageManager.updateDatabaseUploadResult(new RemoteOperationResult(resultCode), upload);
+                        notifyUploadResult(upload, new RemoteOperationResult(resultCode));
+                    } else {
+                        mUploadsStorageManager.removeUpload(accountName, remotePath);
+                    }
                 }
             }
         }
@@ -1180,16 +1191,19 @@ public class FileUploader extends Service
          * @param user Nextcloud user
          */
         public void cancel(User user) {
-            if (mCurrentUpload != null && mCurrentUpload.getUser().nameEquals(user)) {
-                mCurrentUpload.cancel(ResultCode.CANCELLED);
-            }
-            cancelPendingUploads(user.getAccountName());
+            cancel(user.getAccountName());
         }
 
         public void cancel(String accountName) {
-            if (mCurrentUpload != null && mCurrentUpload.getUser().nameEquals(accountName)) {
-                mCurrentUpload.cancel(ResultCode.CANCELLED);
+            cancelPendingUploads(accountName);
+            if (useFilesUploadWorker(getApplicationContext())) {
+                new FilesUploadHelper().restartUploadJob(accountManager.getUser(accountName).get());
+            }else{
+                if (mCurrentUpload != null && mCurrentUpload.getUser().nameEquals(accountName)) {
+                    mCurrentUpload.cancel(ResultCode.CANCELLED);
+                }
             }
+
         }
 
         public void clearListeners() {

app/src/main/java/com/owncloud/android/utils/FilesUploadHelper.kt

@@ -70,6 +70,19 @@ class FilesUploadHelper {
         backgroundJobManager.startFilesUploadJob(user)
     }
 
+    fun cancelFileUpload(remotePath: String, user: User) {
+        // need to update now table in mUploadsStorageManager,
+        // since the operation will not get to be run by FileUploader#uploadFile
+        uploadsStorageManager.removeUpload(user.accountName, remotePath)
+
+        restartUploadJob(user)
+    }
+
+    fun restartUploadJob(user: User) {
+        backgroundJobManager.cancelFilesUploadJob(user)
+        backgroundJobManager.startFilesUploadJob(user)
+    }
+
     fun uploadUpdatedFile(
         user: User,
         existingFiles: Array<OCFile>,