Merge pull request #15491 from nextcloud/backport/15487/stable-3.33

alperozturk96 · web-flow · commit c96f5b67bda5 · 2025-09-01T14:54:17.000+02:00
[stable-3.33] fix: offline operations worker
diff --git a/app/src/main/java/com/nextcloud/client/database/entity/OfflineOperationEntity.kt b/app/src/main/java/com/nextcloud/client/database/entity/OfflineOperationEntity.kt
@@ -42,13 +42,27 @@ data class OfflineOperationEntity(
     fun isRenameOrRemove(): Boolean =
         (type is OfflineOperationType.RenameFile || type is OfflineOperationType.RemoveFile)
 
-    fun getConflictText(context: Context): String = if (type is OfflineOperationType.RemoveFile) {
-        context.getString(R.string.offline_operations_worker_notification_remove_conflict_text, filename)
-    } else if (type is OfflineOperationType.RenameFile) {
-        context.getString(R.string.offline_operations_worker_notification_rename_conflict_text, filename)
-    } else if (type is OfflineOperationType.CreateFile) {
-        context.getString(R.string.offline_operations_worker_notification_create_file_conflict_text, filename)
-    } else {
-        context.getString(R.string.offline_operations_worker_notification_create_folder_conflict_text, filename)
+    fun isCreate(): Boolean = (type is OfflineOperationType.CreateFile || type is OfflineOperationType.CreateFolder)
+
+    fun getConflictText(context: Context): String {
+        val resId = when (type) {
+            is OfflineOperationType.RemoveFile -> {
+                R.string.offline_operations_worker_notification_remove_conflict_text
+            }
+
+            is OfflineOperationType.RenameFile -> {
+                R.string.offline_operations_worker_notification_rename_conflict_text
+            }
+
+            is OfflineOperationType.CreateFile -> {
+                R.string.offline_operations_worker_notification_create_file_conflict_text
+            }
+
+            else -> {
+                R.string.offline_operations_worker_notification_create_folder_conflict_text
+            }
+        }
+
+        return context.getString(resId, filename)
     }
 }
diff --git a/app/src/main/java/com/nextcloud/client/jobs/BackgroundJobManagerImpl.kt b/app/src/main/java/com/nextcloud/client/jobs/BackgroundJobManagerImpl.kt
@@ -466,7 +466,7 @@ internal class BackgroundJobManagerImpl(
 
         workManager.enqueueUniqueWork(
             JOB_OFFLINE_OPERATIONS,
-            ExistingWorkPolicy.REPLACE,
+            ExistingWorkPolicy.KEEP,
             request
         )
     }
diff --git a/app/src/main/java/com/nextcloud/client/jobs/offlineOperations/OfflineOperationsNotificationManager.kt b/app/src/main/java/com/nextcloud/client/jobs/offlineOperations/OfflineOperationsNotificationManager.kt
@@ -39,6 +39,15 @@ class OfflineOperationsNotificationManager(private val context: Context, viewThe
         private const val ONE_HUNDRED_PERCENT = 100
     }
 
+    init {
+        notificationBuilder.apply {
+            setSound(null)
+            setVibrate(null)
+            setOnlyAlertOnce(true)
+            setSilent(true)
+        }
+    }
+
     fun start() {
         notificationBuilder.run {
             setContentTitle(context.getString(R.string.offline_operations_worker_notification_start_text))
diff --git a/app/src/main/java/com/nextcloud/client/jobs/offlineOperations/OfflineOperationsWorker.kt b/app/src/main/java/com/nextcloud/client/jobs/offlineOperations/OfflineOperationsWorker.kt
@@ -34,8 +34,6 @@ import com.owncloud.android.operations.RenameFileOperation
 import com.owncloud.android.utils.MimeTypeUtil
 import com.owncloud.android.utils.theme.ViewThemeUtils
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
@@ -62,55 +60,106 @@ class OfflineOperationsWorker(
     private val notificationManager = OfflineOperationsNotificationManager(context, viewThemeUtils)
     private var repository = OfflineOperationsRepository(fileDataStorageManager)
 
+    @Suppress("TooGenericExceptionCaught")
     override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
-        val jobName = inputData.getString(JOB_NAME)
-        Log_OC.d(TAG, "[$jobName] OfflineOperationsWorker started for user: ${user.accountName}")
-
-        if (!isNetworkAndServerAvailable()) {
-            Log_OC.w(TAG, "⚠️ No internet/server connection. Retrying later...")
-            return@withContext Result.retry()
-        }
-
-        val client = clientFactory.create(user)
+        try {
+            val jobName = inputData.getString(JOB_NAME)
+            Log_OC.d(TAG, "[$jobName] OfflineOperationsWorker started for user: ${user.accountName}")
+
+            // check network connection
+            if (!isNetworkAndServerAvailable()) {
+                Log_OC.w(TAG, "⚠️ No internet/server connection. Retrying later...")
+                return@withContext Result.retry()
+            }
 
-        notificationManager.start()
-        val operations = fileDataStorageManager.offlineOperationDao.getAll()
-        Log_OC.d(TAG, "📋 Found ${operations.size} offline operations to process")
+            // check offline operations
+            val operations = fileDataStorageManager.offlineOperationDao.getAll()
+            if (operations.isEmpty()) {
+                Log_OC.d(TAG, "Skipping, no offline operation found")
+                return@withContext Result.success()
+            }
 
-        val result = processOperations(operations, client)
-        notificationManager.dismissNotification()
+            // process offline operations
+            notificationManager.start()
+            val client = clientFactory.create(user)
+            processOperations(operations, client)
 
-        Log_OC.d(TAG, "🏁 Worker finished with result: $result")
-        return@withContext result
+            // finish
+            WorkerStateLiveData.instance().setWorkState(WorkerState.OfflineOperationsCompleted)
+            Log_OC.d(TAG, "🏁 Worker finished with result")
+            return@withContext Result.success()
+        } catch (e: Exception) {
+            Log_OC.e(TAG, "💥 ProcessOperations failed: ${e.message}")
+            return@withContext Result.failure()
+        } finally {
+            notificationManager.dismissNotification()
+        }
     }
 
+    // region Handle offline operations
     @Suppress("TooGenericExceptionCaught")
-    private suspend fun processOperations(operations: List<OfflineOperationEntity>, client: OwnCloudClient): Result {
+    private suspend fun processOperations(operations: List<OfflineOperationEntity>, client: OwnCloudClient) {
         val totalOperationSize = operations.size
+        operations.forEachIndexed { index, operation ->
+            try {
+                Log_OC.d(TAG, "Processing operation, path: ${operation.path}")
+                val result = executeOperation(operation, client)
+                handleResult(operation, totalOperationSize, index, result)
+            } catch (e: Exception) {
+                Log_OC.e(TAG, "💥 Exception while processing operation id=${operation.id}: ${e.message}")
+            }
+        }
+    }
 
-        return try {
-            operations.forEachIndexed { index, operation ->
-                try {
-                    Log_OC.d(TAG, "Processing operation, path: ${operation.path}")
-                    val result = executeOperation(operation, client)
-                    val success = handleResult(operation, totalOperationSize, index, result)
-
-                    if (!success) {
-                        Log_OC.e(TAG, "❌ Operation failed: id=${operation.id}, type=${operation.type}")
-                    }
-                } catch (e: Exception) {
-                    Log_OC.e(TAG, "💥 Exception while processing operation id=${operation.id}: ${e.message}")
-                }
+    private fun handleResult(
+        operation: OfflineOperationEntity,
+        totalOperations: Int,
+        currentSuccessfulOperationIndex: Int,
+        result: OfflineOperationResult
+    ) {
+        val operationResult = result?.first ?: return
+        val logMessage = if (operationResult.isSuccess) "Operation completed" else "Operation failed"
+        Log_OC.d(TAG, "$logMessage filename: ${operation.filename}, type: ${operation.type}")
+
+        return if (result.first?.isSuccess == true) {
+            handleSuccessResult(operation, totalOperations, currentSuccessfulOperationIndex)
+        } else {
+            handleErrorResult(operation.id, result)
+        }
+    }
+
+    private fun handleSuccessResult(
+        operation: OfflineOperationEntity,
+        totalOperations: Int,
+        currentSuccessfulOperationIndex: Int
+    ) {
+        if (operation.type is OfflineOperationType.RemoveFile) {
+            val operationType = operation.type as OfflineOperationType.RemoveFile
+            fileDataStorageManager.getFileByDecryptedRemotePath(operationType.path)?.let { ocFile ->
+                repository.deleteOperation(ocFile)
             }
+        } else {
+            repository.updateNextOperations(operation)
+        }
 
-            Log_OC.i(TAG, "✅ All offline operations completed successfully.")
-            WorkerStateLiveData.instance().setWorkState(WorkerState.OfflineOperationsCompleted)
-            Result.success()
-        } catch (e: Exception) {
-            Log_OC.e(TAG, "💥 ProcessOperations failed: ${e.message}")
-            Result.failure()
+        fileDataStorageManager.offlineOperationDao.delete(operation)
+        notificationManager.update(totalOperations, currentSuccessfulOperationIndex + 1, operation.filename ?: "")
+    }
+
+    private fun handleErrorResult(id: Int?, result: OfflineOperationResult) {
+        val operationResult = result?.first ?: return
+        val operation = result.second ?: return
+        Log_OC.e(TAG, "❌ Operation failed [id=$id]: code=${operationResult.code}, message=${operationResult.message}")
+        val excludedErrorCodes =
+            listOf(RemoteOperationResult.ResultCode.FOLDER_ALREADY_EXISTS, RemoteOperationResult.ResultCode.LOCKED)
+
+        if (!excludedErrorCodes.contains(operationResult.code)) {
+            notificationManager.showNewNotification(id, operationResult, operation)
+        } else {
+            Log_OC.d(TAG, "ℹ️ Ignored error: ${operationResult.code}")
         }
     }
+    // endregion
 
     private suspend fun isNetworkAndServerAvailable(): Boolean = suspendCoroutine { continuation ->
         connectivityService.isNetworkAndServerAvailable { result ->
@@ -119,19 +168,28 @@ class OfflineOperationsWorker(
     }
 
     // region Operation Execution
-    @Suppress("ComplexCondition")
+    @Suppress("ComplexCondition", "LongMethod")
     private suspend fun executeOperation(
         operation: OfflineOperationEntity,
         client: OwnCloudClient
     ): OfflineOperationResult? = withContext(Dispatchers.IO) {
-        val path = (operation.path)
+        var path = (operation.path)
         if (path == null) {
             Log_OC.w(TAG, "⚠️ Skipped: path is null for operation id=${operation.id}")
             return@withContext null
         }
 
+        if (operation.type is OfflineOperationType.CreateFile && path.endsWith(OCFile.PATH_SEPARATOR)) {
+            Log_OC.w(
+                TAG,
+                "Create file operation should not ends with path separator removing suffix, " +
+                    "operation id=${operation.id}"
+            )
+            path = path.removeSuffix(OCFile.PATH_SEPARATOR)
+        }
+
         val remoteFile = getRemoteFile(path)
-        val ocFile = fileDataStorageManager.getFileByDecryptedRemotePath(operation.path)
+        val ocFile = fileDataStorageManager.getFileByDecryptedRemotePath(path)
 
         if (remoteFile != null && ocFile != null && isFileChanged(remoteFile, ocFile)) {
             Log_OC.w(TAG, "⚠️ Conflict detected: File already exists on server. Skipping operation id=${operation.id}")
@@ -148,6 +206,18 @@ class OfflineOperationsWorker(
             return@withContext null
         }
 
+        if (operation.isRenameOrRemove() && ocFile == null) {
+            Log_OC.d(TAG, "Skipping, attempting to delete or rename non-existing file")
+            fileDataStorageManager.offlineOperationDao.delete(operation)
+            return@withContext null
+        }
+
+        if (operation.isCreate() && remoteFile != null && ocFile != null && !isFileChanged(remoteFile, ocFile)) {
+            Log_OC.d(TAG, "Skipping, attempting to create same file creation")
+            fileDataStorageManager.offlineOperationDao.delete(operation)
+            return@withContext null
+        }
+
         return@withContext when (val type = operation.type) {
             is OfflineOperationType.CreateFolder -> {
                 Log_OC.d(TAG, "📂 Creating folder at ${type.path}")
@@ -173,113 +243,42 @@ class OfflineOperationsWorker(
     }
 
     @Suppress("DEPRECATION")
-    private suspend fun createFolder(
-        operation: OfflineOperationEntity,
-        client: OwnCloudClient
-    ): OfflineOperationResult {
+    private fun createFolder(operation: OfflineOperationEntity, client: OwnCloudClient): OfflineOperationResult {
         val operationType = (operation.type as OfflineOperationType.CreateFolder)
-        val createFolderOperation = withContext(NonCancellable) {
-            CreateFolderOperation(operationType.path, user, context, fileDataStorageManager)
-        }
-
+        val createFolderOperation = CreateFolderOperation(operationType.path, user, context, fileDataStorageManager)
         return createFolderOperation.execute(client) to createFolderOperation
     }
 
     @Suppress("DEPRECATION")
-    private suspend fun createFile(operation: OfflineOperationEntity, client: OwnCloudClient): OfflineOperationResult {
+    private fun createFile(operation: OfflineOperationEntity, client: OwnCloudClient): OfflineOperationResult {
         val operationType = (operation.type as OfflineOperationType.CreateFile)
-
-        val createFileOperation = withContext(NonCancellable) {
-            val lastModificationDate = System.currentTimeMillis() / ONE_SECOND
-
-            UploadFileRemoteOperation(
-                operationType.localPath,
-                operationType.remotePath,
-                operationType.mimeType,
-                "",
-                operation.modifiedAt ?: lastModificationDate,
-                operation.createdAt ?: System.currentTimeMillis(),
-                true
-            )
-        }
-
+        val lastModificationDate = System.currentTimeMillis() / ONE_SECOND
+        val createFileOperation = UploadFileRemoteOperation(
+            operationType.localPath,
+            operationType.remotePath,
+            operationType.mimeType,
+            "",
+            operation.modifiedAt ?: lastModificationDate,
+            operation.createdAt ?: System.currentTimeMillis(),
+            true
+        )
         return createFileOperation.execute(client) to createFileOperation
     }
 
     @Suppress("DEPRECATION")
-    private suspend fun renameFile(operation: OfflineOperationEntity, client: OwnCloudClient): OfflineOperationResult {
-        val renameFileOperation = withContext(NonCancellable) {
-            val operationType = (operation.type as OfflineOperationType.RenameFile)
-            RenameFileOperation(operation.path, operationType.newName, fileDataStorageManager)
-        }
-
+    private fun renameFile(operation: OfflineOperationEntity, client: OwnCloudClient): OfflineOperationResult {
+        val operationType = (operation.type as OfflineOperationType.RenameFile)
+        val renameFileOperation = RenameFileOperation(operation.path, operationType.newName, fileDataStorageManager)
         return renameFileOperation.execute(client) to renameFileOperation
     }
 
     @Suppress("DEPRECATION")
-    private suspend fun removeFile(ocFile: OCFile, client: OwnCloudClient): OfflineOperationResult {
-        val removeFileOperation = withContext(NonCancellable) {
-            RemoveFileOperation(ocFile, false, user, true, context, fileDataStorageManager)
-        }
-
+    private fun removeFile(ocFile: OCFile, client: OwnCloudClient): OfflineOperationResult {
+        val removeFileOperation = RemoveFileOperation(ocFile, false, user, true, context, fileDataStorageManager)
         return removeFileOperation.execute(client) to removeFileOperation
     }
     // endregion
 
-    private suspend fun handleResult(
-        operation: OfflineOperationEntity,
-        totalOperations: Int,
-        currentSuccessfulOperationIndex: Int,
-        result: OfflineOperationResult
-    ): Boolean {
-        val operationResult = result?.first ?: return false
-
-        val logMessage = if (operationResult.isSuccess) "Operation completed" else "Operation failed"
-        Log_OC.d(TAG, "$logMessage filename: ${operation.filename}, type: ${operation.type}")
-
-        return if (result.first?.isSuccess == true) {
-            handleSuccessResult(operation, totalOperations, currentSuccessfulOperationIndex)
-            true
-        } else {
-            handleErrorResult(operation.id, result)
-            false
-        }
-    }
-
-    private suspend fun handleSuccessResult(
-        operation: OfflineOperationEntity,
-        totalOperations: Int,
-        currentSuccessfulOperationIndex: Int
-    ) {
-        if (operation.type is OfflineOperationType.RemoveFile) {
-            val operationType = operation.type as OfflineOperationType.RemoveFile
-            fileDataStorageManager.getFileByDecryptedRemotePath(operationType.path)?.let { ocFile ->
-                repository.deleteOperation(ocFile)
-            }
-        } else {
-            repository.updateNextOperations(operation)
-        }
-
-        fileDataStorageManager.offlineOperationDao.delete(operation)
-
-        notificationManager.update(totalOperations, currentSuccessfulOperationIndex, operation.filename ?: "")
-        delay(ONE_SECOND)
-        notificationManager.dismissNotification(operation.id)
-    }
-
-    private fun handleErrorResult(id: Int?, result: OfflineOperationResult) {
-        val operationResult = result?.first ?: return
-        val operation = result.second ?: return
-        Log_OC.e(TAG, "❌ Operation failed [id=$id]: code=${operationResult.code}, message=${operationResult.message}")
-        val excludedErrorCodes = listOf(RemoteOperationResult.ResultCode.FOLDER_ALREADY_EXISTS)
-
-        if (!excludedErrorCodes.contains(operationResult.code)) {
-            notificationManager.showNewNotification(id, operationResult, operation)
-        } else {
-            Log_OC.d(TAG, "ℹ️ Ignored error: ${operationResult.code}")
-        }
-    }
-
     @Suppress("DEPRECATION")
     private fun getRemoteFile(remotePath: String): RemoteFile? {
         val mimeType = MimeTypeUtil.getMimeTypeFromPath(remotePath)

Original file line number	Diff line number	Diff line change
`@@ -466,7 +466,7 @@ internal class BackgroundJobManagerImpl(`
`466`	`466`
`467`	`467`	`workManager.enqueueUniqueWork(`
`468`	`468`	`JOB_OFFLINE_OPERATIONS,`
`469`		`- ExistingWorkPolicy.REPLACE,`
	`469`	`+ ExistingWorkPolicy.KEEP,`
`470`	`470`	`request`
`471`	`471`	`)`
`472`	`472`	`}`