Merge pull request #15453 from nextcloud/perf/remove-file

perf: increase file deletion performance 🚀

Author: alperozturk96

app/src/main/java/com/owncloud/android/operations/RemoveFileOperation.java

@@ -0,0 +1,99 @@
+/*
+ * Nextcloud - Android Client
+ *
+ * SPDX-FileCopyrightText: 2025 Alper Ozturk <[email protected]>
+ * SPDX-FileCopyrightText: 2020 Tobias Kaminsky <[email protected]>
+ * SPDX-FileCopyrightText: 2015 ownCloud Inc.
+ * SPDX-FileCopyrightText: 2015 María Asensio Valverde <[email protected]>
+ * SPDX-FileCopyrightText: 2012 David A. Velasco <[email protected]>
+ * SPDX-License-Identifier: GPL-2.0-only AND (AGPL-3.0-or-later OR GPL-2.0-only)
+ */
+package com.owncloud.android.operations
+import android.content.Context
+import com.nextcloud.client.account.User
+import com.owncloud.android.datamodel.FileDataStorageManager
+import com.owncloud.android.datamodel.OCFile
+import com.owncloud.android.datamodel.ThumbnailsCacheManager
+import com.owncloud.android.lib.common.OwnCloudClient
+import com.owncloud.android.lib.common.operations.RemoteOperation
+import com.owncloud.android.lib.common.operations.RemoteOperationResult
+import com.owncloud.android.lib.resources.files.RemoveFileRemoteOperation
+import com.owncloud.android.operations.common.SyncOperation
+import com.owncloud.android.utils.MimeTypeUtil
+
+/**
+ * Remote operation to remove a remote file or folder from an ownCloud server.
+ *
+ * @param file  OCFile instance representing the remote file or folder to remove.
+ * @param onlyLocalCopy  If true, only the local copy will be removed (if it exists).
+ * @param user  User account associated with the operation.
+ * @param isInBackground  Flag indicating if the operation runs in the background.
+ * @param context  Android context.
+ * @param storageManager  Storage manager handling local file operations.
+ */
+@Suppress("LongParameterList")
+class RemoveFileOperation(
+    val file: OCFile,
+    private val onlyLocalCopy: Boolean,
+    private val user: User,
+    val isInBackground: Boolean,
+    private val context: Context,
+    storageManager: FileDataStorageManager
+) : SyncOperation(storageManager) {
+
+    /**
+     * Executes the remove operation.
+     *
+     * If the file is an image, it will also be removed from the thumbnail cache.
+     * Handles both encrypted and non-encrypted files. Removes the file locally if needed.
+     *
+     * @param client  OwnCloudClient used to communicate with the remote server.
+     * @return RemoteOperationResult indicating success or failure of the operation.
+     */
+    override fun run(client: OwnCloudClient?): RemoteOperationResult<*> {
+        var result: RemoteOperationResult<*>? = null
+        val operation: RemoteOperation<*>?
+
+        var localRemovalFailed = false
+
+        if (onlyLocalCopy) {
+            // generate resize image if image is deleted only locally, to save server request
+            if (MimeTypeUtil.isImage(file.mimeType)) {
+                ThumbnailsCacheManager.generateResizedImage(file)
+            }
+
+            localRemovalFailed = !storageManager.removeFile(file, false, true)
+            if (!localRemovalFailed) {
+                result = RemoteOperationResult<Any?>(RemoteOperationResult.ResultCode.OK)
+            }
+        } else {
+            operation = if (file.isEncrypted) {
+                val parent = storageManager.getFileById(file.parentId)
+                if (parent == null) {
+                    return RemoteOperationResult<Any?>(RemoteOperationResult.ResultCode.LOCAL_FILE_NOT_FOUND)
+                }
+                RemoveRemoteEncryptedFileOperation(
+                    file.remotePath,
+                    user,
+                    context,
+                    file.getEncryptedFileName(),
+                    parent,
+                    file.isFolder
+                )
+            } else {
+                RemoveFileRemoteOperation(file.remotePath)
+            }
+
+            result = operation.execute(client)
+            if (result.isSuccess || result.code == RemoteOperationResult.ResultCode.FILE_NOT_FOUND) {
+                localRemovalFailed = !storageManager.removeFile(file, true, true)
+            }
+        }
+
+        if (localRemovalFailed) {
+            result = RemoteOperationResult<Any?>(RemoteOperationResult.ResultCode.LOCAL_STORAGE_NOT_REMOVED)
+        }
+
+        return result ?: RemoteOperationResult<Any?>(RemoteOperationResult.ResultCode.CANCELLED)
+    }
+}

app/src/main/java/com/owncloud/android/operations/RemoveFileOperation.kt

@@ -690,6 +690,11 @@ private Pair<Target, RemoteOperation> newOperation(Intent operationIntent) {
                     case ACTION_REMOVE:
                         // Remove file or folder
                         OCFile file = IntentExtensionsKt.getParcelableArgument(operationIntent, EXTRA_FILE, OCFile.class);
+                        if (file == null) {
+                            Log_OC.w(TAG, "file is null cannot remove file");
+                            break;
+                        }
+
                         boolean onlyLocalCopy = operationIntent.getBooleanExtra(EXTRA_REMOVE_ONLY_LOCAL, false);
                         boolean inBackground = operationIntent.getBooleanExtra(EXTRA_IN_BACKGROUND, false);
                         operation = new RemoveFileOperation(file,
@@ -748,6 +753,11 @@ private Pair<Target, RemoteOperation> newOperation(Intent operationIntent) {
 
                     case ACTION_RESTORE_VERSION:
                         FileVersion fileVersion = IntentExtensionsKt.getParcelableArgument(operationIntent, EXTRA_FILE_VERSION, FileVersion.class);
+                        if (fileVersion == null) {
+                            Log_OC.w(TAG, "file version is null cannot restore file");
+                            break;
+                        }
+
                         operation = new RestoreFileVersionRemoteOperation(fileVersion.getLocalId(),
                                                                           fileVersion.getFileName());
                         break;

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

@@ -97,19 +97,24 @@ class RemoveFilesDialogFragment :
 
         val fileActivity = getTypedActivity(FileActivity::class.java)
         val fda = getTypedActivity(FileDisplayActivity::class.java)
-
         fileActivity?.connectivityService?.isNetworkAndServerAvailable { result ->
             if (result) {
+                fileActivity.showLoadingDialog(fileActivity.getString(R.string.wait_a_moment))
+
                 if (files.isNotEmpty()) {
-                    fileActivity.fileOperationsHelper?.removeFiles(files, onlyLocalCopy, false)
+                    // Display the snackbar message only when a single file is deleted.
+                    val inBackground = (files.size != 1)
+                    fileActivity.fileOperationsHelper?.removeFiles(files, onlyLocalCopy, inBackground)
                 }
 
                 if (offlineFiles.isNotEmpty()) {
                     fda?.refreshCurrentDirectory()
                 }
+
+                fileActivity.dismissLoadingDialog()
             } else {
                 if (onlyLocalCopy) {
-                    fileActivity.fileOperationsHelper?.removeFiles(files, true, false)
+                    fileActivity.fileOperationsHelper?.removeFiles(files, true, true)
                 } else {
                     files.forEach { file ->
                         fileDataStorageManager.addRemoveFileOfflineOperation(file)

app/src/main/java/com/owncloud/android/ui/dialog/RemoveFilesDialogFragment.kt

@@ -950,10 +950,6 @@ public void removeFiles(Collection<OCFile> files, boolean onlyLocalCopy, boolean
         for (OCFile file : files) {
             removeFile(file, onlyLocalCopy, inBackground);
         }
-
-        if (!inBackground) {
-            fileActivity.showLoadingDialog(fileActivity.getString(R.string.wait_a_moment));
-        }
     }
 
     public void removeFile(OCFile file, boolean onlyLocalCopy, boolean inBackground) {