Merge pull request #16858 from nextcloud/backport/16819/stable-33.1.0

[stable-33.1.0] fix(upload-list): handle conflict actions

Author: alperozturk96

app/src/androidTest/java/com/nextcloud/utils/WebDavParentPathTests.kt

@@ -0,0 +1,92 @@
+/*
+ * Nextcloud - Android Client
+ *
+ * SPDX-FileCopyrightText: 2026 Alper Ozturk <alper.ozturk@nextcloud.com>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+package com.nextcloud.utils
+
+import com.nextcloud.utils.extensions.webDavParentPath
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+@Suppress("TooManyFunctions")
+class WebDavParentPathTests {
+
+    @Test
+    fun testWebDavParentPathWhenGivenCorrectParentShouldReturnOneLevelAbove() {
+        assertEquals("/Photos/Vacation/", "/Photos/Vacation/beach.jpg".webDavParentPath())
+        assertEquals("/work/docs/", "/work/docs/notes.txt".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenDeepNestingShouldReturnDirectParent() {
+        assertEquals("/a/b/c/d/", "/a/b/c/d/e.txt".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenRootFileShouldReturnRoot() {
+        assertEquals("/", "/image.png".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenSlashShouldReturnRoot() {
+        assertEquals("/", "/".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenEmptyStringShouldReturnRoot() {
+        assertEquals("/", "".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenOnlySlashesShouldReturnRoot() {
+        assertEquals("/", "///".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenRelativePathShouldReturnOneLevelAbove() {
+        assertEquals("Documents/", "Documents/file.pdf".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenSingleWordPathShouldReturnRoot() {
+        assertEquals("/", "readme.md".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenTrailingSlashShouldReturnOneLevelAbove() {
+        assertEquals("/Photos/", "/Photos/Vacation/".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenMultipleTrailingSlashesShouldReturnOneLevelAbove() {
+        assertEquals("/Photos/", "/Photos/Vacation///".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenEncodedSpacesShouldPreserveEncoding() {
+        assertEquals("/My%20Photos/", "/My%20Photos/beach%20photo.jpg".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenEncodedSpecialCharsShouldPreserveEncoding() {
+        assertEquals("/files/%23reports/", "/files/%23reports/q1%262.pdf".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenUnicodeCharsShouldReturnOneLevelAbove() {
+        assertEquals("/照片/假期/", "/照片/假期/海滩.jpg".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenSingleCharFileAtRootShouldReturnRoot() {
+        assertEquals("/", "/a".webDavParentPath())
+    }
+
+    @Test
+    fun testWebDavParentPathWhenGivenSingleCharDirShouldReturnOneLevelAbove() {
+        assertEquals("/a/", "/a/b".webDavParentPath())
+    }
+}

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

@@ -36,6 +36,7 @@ import com.nextcloud.client.preferences.AppPreferences
 import com.owncloud.android.datamodel.ArbitraryDataProvider
 import com.owncloud.android.datamodel.SyncedFolderProvider
 import com.owncloud.android.datamodel.UploadsStorageManager
+import com.owncloud.android.operations.factory.UploadFileOperationFactory
 import com.owncloud.android.utils.theme.ViewThemeUtils
 import org.greenrobot.eventbus.EventBus
 import javax.inject.Inject
@@ -66,7 +67,8 @@ class BackgroundJobFactory @Inject constructor(
     private val localBroadcastManager: Provider<LocalBroadcastManager>,
     private val generatePdfUseCase: GeneratePDFUseCase,
     private val syncedFolderProvider: SyncedFolderProvider,
-    private val database: NextcloudDatabase
+    private val database: NextcloudDatabase,
+    private val uploadFileOperationFactory: UploadFileOperationFactory
 ) : WorkerFactory() {
 
     @SuppressLint("NewApi")
@@ -247,6 +249,7 @@ class BackgroundJobFactory @Inject constructor(
             FileSystemRepository(dao = database.fileSystemDao(), uploadsStorageManager, context),
             syncedFolderProvider,
             context,
+            uploadFileOperationFactory,
             params
         )
 

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

@@ -25,7 +25,9 @@ import com.nextcloud.client.network.ConnectivityService
 import com.nextcloud.client.notifications.AppWideNotificationManager
 import com.nextcloud.utils.extensions.checkWCFRestrictions
 import com.nextcloud.utils.extensions.getUploadIds
+import com.nextcloud.utils.extensions.isAnonymous
 import com.nextcloud.utils.extensions.isLastResultConflictError
+import com.nextcloud.utils.extensions.isSame
 import com.owncloud.android.MainApp
 import com.owncloud.android.R
 import com.owncloud.android.datamodel.FileDataStorageManager
@@ -36,6 +38,7 @@ import com.owncloud.android.db.OCUpload
 import com.owncloud.android.db.UploadResult
 import com.owncloud.android.files.services.NameCollisionPolicy
 import com.owncloud.android.lib.common.OwnCloudClient
+import com.owncloud.android.lib.common.OwnCloudClientFactory
 import com.owncloud.android.lib.common.network.OnDatatransferProgressListener
 import com.owncloud.android.lib.common.operations.RemoteOperationResult
 import com.owncloud.android.lib.common.utils.Log_OC
@@ -45,8 +48,9 @@ import com.owncloud.android.lib.resources.files.model.ServerFileInterface
 import com.owncloud.android.lib.resources.status.OCCapability
 import com.owncloud.android.operations.RemoveFileOperation
 import com.owncloud.android.operations.UploadFileOperation
+import com.owncloud.android.ui.adapter.uploadList.helper.ConflictHandlingResult
+import com.owncloud.android.ui.adapter.uploadList.helper.UploadListAdapterActionHandler
 import com.owncloud.android.utils.DisplayUtils
-import com.owncloud.android.utils.FileUtil
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -167,25 +171,36 @@ class FileUploadHelper {
     }
 
     @Suppress("ComplexCondition")
-    private fun retryUploads(
+    private suspend fun retryUploads(
         uploadsStorageManager: UploadsStorageManager,
         connectivityService: ConnectivityService,
         accountManager: UserAccountManager,
         powerManagementService: PowerManagementService,
         uploads: List<OCUpload>
-    ): Boolean {
+    ): Boolean = withContext(Dispatchers.IO) {
         var showNotExistMessage = false
-        var showSyncConflictNotification = false
+        var conflictHandlingResult: ConflictHandlingResult? = null
         val isOnline = checkConnectivity(connectivityService)
         val connectivity = connectivityService.connectivity
         val batteryStatus = powerManagementService.battery
 
         val uploadsToRetry = mutableListOf<Long>()
 
+        val currentAccount = accountManager.currentAccount
+        val context = MainApp.getAppContext()
+        var ownCloudClient: OwnCloudClient? = null
+        if (!currentAccount.isAnonymous(context)) {
+            ownCloudClient =
+                OwnCloudClientFactory.createOwnCloudClient(accountManager.currentAccount, MainApp.getAppContext())
+        }
+        val uploadActionHandler = UploadListAdapterActionHandler()
+
         for (upload in uploads) {
             if (upload.isLastResultConflictError()) {
-                Log_OC.d(TAG, "retry upload skipped, sync conflict: ${upload.remotePath}")
-                showSyncConflictNotification = true
+                ownCloudClient?.let {
+                    conflictHandlingResult =
+                        uploadActionHandler.handleConflict(upload, ownCloudClient, uploadsStorageManager)
+                }
                 continue
             }
 
@@ -226,11 +241,12 @@ class FileUploadHelper {
             )
         }
 
-        if (showSyncConflictNotification) {
+        if (conflictHandlingResult is ConflictHandlingResult.ShowConflictResolveDialog) {
+            Log_OC.d(TAG, "retry upload skipped, sync conflict: ${conflictHandlingResult.file.remotePath}")
             AppWideNotificationManager.showSyncConflictNotification(MainApp.getAppContext())
         }
 
-        return showNotExistMessage
+        return@withContext showNotExistMessage
     }
 
     @JvmOverloads
@@ -563,25 +579,17 @@ class FileUploadHelper {
     }
 
     @Suppress("MagicNumber", "ReturnCount", "ComplexCondition")
-    fun isSameFileOnRemote(user: User?, localFile: File?, remotePath: String?, context: Context?): Boolean {
-        if (user == null || localFile == null || remotePath == null || context == null) {
+    fun isSameFileOnRemote(user: User?, localPath: String?, remotePath: String?, context: Context?): Boolean {
+        if (user == null || localPath == null || remotePath == null || context == null) {
             Log_OC.e(TAG, "cannot compare remote and local file")
             return false
         }
 
-        // Compare remote file to local file
-        val localLastModifiedTimestamp = localFile.lastModified() / 1000 // remote file timestamp in milli not micro sec
-        val localCreationTimestamp = FileUtil.getCreationTimestamp(localFile)
-        val localSize: Long = localFile.length()
-
         val operation = ReadFileRemoteOperation(remotePath)
         val result: RemoteOperationResult<*> = operation.execute(user, context)
         if (result.isSuccess) {
             val remoteFile = result.data[0] as RemoteFile
-            return remoteFile.size == localSize &&
-                localCreationTimestamp != null &&
-                localCreationTimestamp == remoteFile.creationTimestamp &&
-                remoteFile.modifiedTimestamp == localLastModifiedTimestamp * 1000
+            return remoteFile.isSame(localPath)
         }
         return false
     }

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

@@ -29,7 +29,6 @@ import com.nextcloud.utils.extensions.getPercent
 import com.nextcloud.utils.extensions.toFile
 import com.nextcloud.utils.extensions.updateStatus
 import com.owncloud.android.R
-import com.owncloud.android.datamodel.FileDataStorageManager
 import com.owncloud.android.datamodel.ForegroundServiceType
 import com.owncloud.android.datamodel.SyncedFolder
 import com.owncloud.android.datamodel.SyncedFolderProvider
@@ -44,6 +43,7 @@ import com.owncloud.android.lib.common.operations.RemoteOperationResult
 import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode
 import com.owncloud.android.lib.common.utils.Log_OC
 import com.owncloud.android.operations.UploadFileOperation
+import com.owncloud.android.operations.factory.UploadFileOperationFactory
 import com.owncloud.android.ui.notifications.NotificationUtils
 import com.owncloud.android.utils.theme.ViewThemeUtils
 import kotlinx.coroutines.Dispatchers
@@ -66,6 +66,7 @@ class FileUploadWorker(
     val filesystemRepository: FileSystemRepository,
     val syncedFolderProvider: SyncedFolderProvider,
     val context: Context,
+    val uploadFileOperationFactory: UploadFileOperationFactory,
     params: WorkerParameters
 ) : CoroutineWorker(context, params),
     OnDatatransferProgressListener {
@@ -270,7 +271,7 @@ class FileUploadWorker(
             }
 
             fileUploadEventBroadcaster.sendUploadEnqueued(context)
-            val operation = createUploadFileOperation(upload, user)
+            val operation = uploadFileOperationFactory.create(upload, this@FileUploadWorker)
             activeOperations[upload.uploadId] = operation
 
             val currentIndex = (index + 1)
@@ -348,24 +349,6 @@ class FileUploadWorker(
         return result
     }
 
-    private fun createUploadFileOperation(upload: OCUpload, user: User): UploadFileOperation = UploadFileOperation(
-        uploadsStorageManager,
-        connectivityService,
-        powerManagementService,
-        user,
-        null,
-        upload,
-        upload.nameCollisionPolicy,
-        upload.localAction,
-        context,
-        upload.isUseWifiOnly,
-        upload.isWhileChargingOnly,
-        true,
-        FileDataStorageManager(user, context.contentResolver)
-    ).apply {
-        addDataTransferProgressListener(this@FileUploadWorker)
-    }
-
     @Suppress("TooGenericExceptionCaught", "DEPRECATION")
     private suspend fun upload(
         upload: OCUpload,

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

@@ -28,7 +28,6 @@ import com.owncloud.android.ui.activity.ConflictsResolveActivity
 import com.owncloud.android.utils.ErrorMessageAdapter
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import java.io.File
 
 object UploadErrorNotificationManager {
     private const val TAG = "UploadErrorNotificationManager"
@@ -76,7 +75,7 @@ object UploadErrorNotificationManager {
             val isSameFile = withContext(Dispatchers.IO) {
                 FileUploadHelper.instance().isSameFileOnRemote(
                     operation.user,
-                    File(operation.storagePath),
+                    operation.storagePath,
                     operation.remotePath,
                     context
                 )

app/src/main/java/com/nextcloud/utils/OCFileUtils.kt

@@ -11,7 +11,8 @@ import android.graphics.drawable.BitmapDrawable
 import androidx.core.content.ContextCompat
 import androidx.core.graphics.drawable.toBitmap
 import androidx.core.graphics.drawable.toDrawable
-import androidx.exifinterface.media.ExifInterface
+import com.nextcloud.utils.extensions.getBitmapSize
+import com.nextcloud.utils.extensions.getExifSize
 import com.owncloud.android.MainApp
 import com.owncloud.android.R
 import com.owncloud.android.datamodel.OCFile
@@ -41,8 +42,8 @@ object OCFileUtils {
             // Local file
             val path = ocFile.storagePath
             if (!path.isNullOrEmpty() && ocFile.exists()) {
-                getExifSize(path)?.let { return it }
-                getBitmapSize(path)?.let { return it }
+                path.getExifSize()?.let { return it }
+                path.getBitmapSize()?.let { return it }
             }
 
             // 3 Fallback
@@ -55,41 +56,6 @@ object OCFileUtils {
         return fallbackPair
     }
 
-    private fun getExifSize(path: String): Pair<Int, Int>? = try {
-        val exif = ExifInterface(path)
-        var w = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, 0)
-        var h = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, 0)
-
-        val orientation = exif.getAttributeInt(
-            ExifInterface.TAG_ORIENTATION,
-            ExifInterface.ORIENTATION_NORMAL
-        )
-        if (orientation == ExifInterface.ORIENTATION_ROTATE_90 ||
-            orientation == ExifInterface.ORIENTATION_ROTATE_270
-        ) {
-            val tmp = w
-            w = h
-            h = tmp
-        }
-
-        Log_OC.d(TAG, "Using exif imageDimension: $w x $h")
-        if (w > 0 && h > 0) w to h else null
-    } catch (_: Exception) {
-        null
-    }
-
-    private fun getBitmapSize(path: String): Pair<Int, Int>? = try {
-        val options = android.graphics.BitmapFactory.Options().apply { inJustDecodeBounds = true }
-        android.graphics.BitmapFactory.decodeFile(path, options)
-        val w = options.outWidth
-        val h = options.outHeight
-
-        Log_OC.d(TAG, "Using bitmap factory imageDimension: $w x $h")
-        if (w > 0 && h > 0) w to h else null
-    } catch (_: Exception) {
-        null
-    }
-
     fun getMediaPlaceholder(file: OCFile, imageDimension: Pair<Int, Int>): BitmapDrawable {
         val context = MainApp.getAppContext()