fix(auto-upload): simplify error notification logic

Signed-off-by: alperozturk96 <alper_ozturk@proton.me>

Author: alperozturk96

app/src/main/java/com/nextcloud/client/jobs/upload/FileUploadWorker.kt

@@ -380,7 +380,7 @@ class FileUploadWorker(
                     notificationManager,
                     operation,
                     result,
-                    showSameFileAlreadyExistsNotification = {
+                    onSameFileConflict = {
                         withContext(Dispatchers.Main) {
                             val showSameFileAlreadyExistsNotification =
                                 inputData.getBoolean(SHOW_SAME_FILE_ALREADY_EXISTS_NOTIFICATION, false)

app/src/main/java/com/nextcloud/client/jobs/utils/UploadErrorNotificationManager.kt

@@ -31,35 +31,67 @@ import java.io.File
 object UploadErrorNotificationManager {
     private const val TAG = "UploadErrorNotificationManager"
 
+    /**
+     * Processes the result of an upload operation and manages error notifications.
+     * * It filters out successful or silent results and handles [ResultCode.SYNC_CONFLICT]
+     * by checking if the remote file is identical. If it's a "real" conflict or error,
+     * it displays a notification with relevant actions (e.g., Resolve Conflict, Pause, Cancel).
+     *
+     * @param onSameFileConflict Triggered only if a 409 Conflict occurs but files are identical.
+     */
+    @Suppress("ReturnCount")
     suspend fun handleResult(
         context: Context,
         notificationManager: WorkerNotificationManager,
         operation: UploadFileOperation,
         result: RemoteOperationResult<Any?>,
-        showSameFileAlreadyExistsNotification: suspend () -> Unit = {}
+        onSameFileConflict: suspend () -> Unit = {}
     ) {
         Log_OC.d(TAG, "handle upload result with result code: " + result.code)
 
-        val notification = withContext(Dispatchers.IO) {
-            val isSameFileOnRemote = FileUploadHelper.instance().isSameFileOnRemote(
-                operation.user,
-                File(operation.storagePath),
-                operation.remotePath,
-                context
-            )
+        if (result.isSuccess || result.isCancelled || operation.isMissingPermissionThrown) {
+            Log_OC.d(TAG, "operation is successful, cancelled or lack of storage permission, notification skipped")
+            return
+        }
 
-            getNotification(
-                isSameFileOnRemote,
-                context,
-                notificationManager.notificationBuilder,
-                operation,
-                result,
-                notifyOnSameFileExists = {
-                    showSameFileAlreadyExistsNotification()
-                    operation.handleLocalBehaviour()
-                }
-            )
-        } ?: return
+        val silentCodes = setOf(
+            ResultCode.DELAYED_FOR_WIFI,
+            ResultCode.DELAYED_FOR_CHARGING,
+            ResultCode.DELAYED_IN_POWER_SAVE_MODE,
+            ResultCode.LOCAL_FILE_NOT_FOUND,
+            ResultCode.LOCK_FAILED
+        )
+
+        if (result.code in silentCodes) {
+            Log_OC.d(TAG, "silent error code, notification skipped")
+            return
+        }
+
+        // Do not show an error notification when uploading the same file again (manual uploads only).
+        if (result.code == ResultCode.SYNC_CONFLICT) {
+            val isSameFile = withContext(Dispatchers.IO) {
+                FileUploadHelper.instance().isSameFileOnRemote(
+                    operation.user,
+                    File(operation.storagePath),
+                    operation.remotePath,
+                    context
+                )
+            }
+
+            if (isSameFile) {
+                Log_OC.w(TAG, "exact same file already exists on remote, error notification skipped")
+                onSameFileConflict()
+                return
+            }
+        }
+
+        // now we can show error notification
+        val notification = getNotification(
+            context,
+            notificationManager.notificationBuilder,
+            operation,
+            result
+        )
 
         Log_OC.d(TAG, "🔔" + "notification created")
 
@@ -72,19 +104,12 @@ object UploadErrorNotificationManager {
         }
     }
 
-    private suspend fun getNotification(
-        isSameFileOnRemote: Boolean,
+    private fun getNotification(
         context: Context,
         builder: NotificationCompat.Builder,
         operation: UploadFileOperation,
-        result: RemoteOperationResult<Any?>,
-        notifyOnSameFileExists: suspend () -> Unit
-    ): Notification? {
-        if (!shouldShowConflictDialog(isSameFileOnRemote, operation, result, notifyOnSameFileExists)) {
-            Log_OC.d(TAG, "no need to show conflict resolve notification")
-            return null
-        }
-
+        result: RemoteOperationResult<Any?>
+    ): Notification {
         val textId = result.code.toFailedResultTitleId()
         val errorMessage = ErrorMessageAdapter.getErrorCauseMessage(result, operation, context.resources)
 
@@ -97,19 +122,19 @@ object UploadErrorNotificationManager {
             setProgress(0, 0, false)
             clearActions()
 
-            result.code.takeIf { it == ResultCode.SYNC_CONFLICT }?.let {
+            // actions for all error types
+            addAction(UploadBroadcastAction.PauseAndCancel(operation).pauseAction(context))
+            addAction(UploadBroadcastAction.PauseAndCancel(operation).cancelAction(context))
+
+            if (result.code == ResultCode.SYNC_CONFLICT) {
                 addAction(
                     R.drawable.ic_cloud_upload,
                     context.getString(R.string.upload_list_resolve_conflict),
                     conflictResolvePendingIntent(context, operation)
                 )
             }
 
-            addAction(UploadBroadcastAction.PauseAndCancel(operation).pauseAction(context))
-
-            addAction(UploadBroadcastAction.PauseAndCancel(operation).cancelAction(context))
-
-            result.code.takeIf { it == ResultCode.UNAUTHORIZED }?.let {
+            if (result.code == ResultCode.UNAUTHORIZED) {
                 setContentIntent(credentialPendingIntent(context, operation))
             }
         }.build()
@@ -162,36 +187,4 @@ object UploadErrorNotificationManager {
             PendingIntent.FLAG_IMMUTABLE
         )
     }
-
-    @Suppress("ReturnCount", "ComplexCondition")
-    private suspend fun shouldShowConflictDialog(
-        isSameFileOnRemote: Boolean,
-        operation: UploadFileOperation,
-        result: RemoteOperationResult<Any?>,
-        notifyOnSameFileExists: suspend () -> Unit
-    ): Boolean {
-        if (result.isSuccess ||
-            result.isCancelled ||
-            result.code == ResultCode.USER_CANCELLED ||
-            operation.isMissingPermissionThrown
-        ) {
-            Log_OC.w(TAG, "operation is successful, cancelled or lack of storage permission")
-            return false
-        }
-
-        if (result.code == ResultCode.SYNC_CONFLICT) {
-            if (isSameFileOnRemote) {
-                Log_OC.w(TAG, "same file exists on remote")
-                notifyOnSameFileExists()
-            }
-
-            return false
-        }
-
-        val delayedCodes =
-            setOf(ResultCode.DELAYED_FOR_WIFI, ResultCode.DELAYED_FOR_CHARGING, ResultCode.DELAYED_IN_POWER_SAVE_MODE)
-        val invalidCodes = setOf(ResultCode.LOCAL_FILE_NOT_FOUND, ResultCode.LOCK_FAILED)
-
-        return result.code !in delayedCodes && result.code !in invalidCodes
-    }
 }