Fix #6 and support for delete.

android/src/main/kotlin/com/deepanshuchaudhary/pick_or_save/PickOrSave.kt

@@ -27,6 +27,8 @@ var directoryDocumentsPickingResult: MethodChannel.Result? = null
 
 var fileSavingResult: MethodChannel.Result? = null
 
+var fileDeleteResult: MethodChannel.Result? = null
+
 var fileMetadataResult: MethodChannel.Result? = null
 
 var cacheFilePathFromUriResult: MethodChannel.Result? = null
@@ -286,6 +288,59 @@ class PickOrSave(
         }
     }
 
+    // For deleting single file or multiple files.
+    fun deleteFile(
+        resultCallback: MethodChannel.Result,
+        deleteFiles: List<DeleteFileInfo>?,
+    ) {
+        try {
+
+            Log.d(
+                LOG_TAG,
+                "deleteFile - IN, deleteFiles=$deleteFiles"
+            )
+
+            if (fileDeleteResult != null) {
+                utils.finishWithAlreadyActiveError(resultCallback)
+                return
+            } else {
+                fileDeleteResult = resultCallback
+//        utils.cancelDelete()
+            }
+
+            if (deleteFiles == null) {
+                utils.finishWithError(
+                    "deleteFiles_not_found",
+                    "Delete files list is null",
+                    "Delete files list is null",
+                    fileDeleteResult
+                )
+            } else if (deleteFiles.isEmpty()) {
+                utils.finishWithError(
+                    "deleteFiles_not_found",
+                    "Delete files list is empty",
+                    "Delete files list is empty",
+                    fileDeleteResult
+                )
+            } else {
+                deleteMultipleFiles(
+                    deleteFilesInfo = deleteFiles,
+                    context = activity,
+                )
+            }
+
+
+        } catch (e: Exception) {
+            utils.finishWithError(
+                "deleteFile_exception", e.stackTraceToString(), null, fileDeleteResult
+            )
+        } catch (e: Error) {
+            utils.finishWithError(
+                "deleteFile_error", e.stackTraceToString(), null, fileDeleteResult
+            )
+        }
+    }
+
     // For picking single file or multiple files.
     fun fileMetaData(
         resultCallback: MethodChannel.Result,

android/src/main/kotlin/com/deepanshuchaudhary/pick_or_save/PickOrSavePlugin.kt

@@ -159,6 +159,11 @@ class PickOrSavePlugin : FlutterPlugin, ActivityAware, MethodCallHandler {
                 directoryUri = call.argument("directoryUri"),
             )
 
+            "deleteFiles" -> pickOrSave!!.deleteFile(
+                result,
+                deleteFiles = parseMethodCallListOfDeleteFileInfoArgument(call, "deleteFiles"),
+            )
+
             "fileMetaData" -> pickOrSave!!.fileMetaData(
                 result, sourceFilePathOrUri = call.argument("filePath")
             )
@@ -268,4 +273,21 @@ class PickOrSavePlugin : FlutterPlugin, ActivityAware, MethodCallHandler {
         return null
     }
 
+    private fun parseMethodCallListOfDeleteFileInfoArgument(
+        call: MethodCall, arg: String
+    ): List<DeleteFileInfo>? {
+        if (call.hasArgument(arg)) {
+            val deleteFilesMapsList = call.argument<ArrayList<Map<String, Any>>>(arg)?.toList()
+            val deleteFilesList: MutableList<DeleteFileInfo> = mutableListOf()
+            deleteFilesMapsList?.forEach { it ->
+                val deleteFile = DeleteFileInfo(
+                    filePath = it["filePath"] as String,
+                )
+                deleteFilesList.add(deleteFile)
+            }
+            return deleteFilesList
+        }
+        return null
+    }
+
 }

android/src/main/kotlin/com/deepanshuchaudhary/pick_or_save/Save.kt

@@ -15,8 +15,11 @@ import java.io.File
 //private var isSourceFileTemp : Boolean = false
 private var destinationSaveFileInfo: DestinationSaveFileInfo? = null
 private var destinationSaveFilesInfo: MutableList<DestinationSaveFileInfo> = mutableListOf()
+private var destinationDeleteFileInfo: DestinationDeleteFileInfo? = null
+private var destinationDeleteFilesInfo: MutableList<DestinationDeleteFileInfo> = mutableListOf()
 
 var fileSaveJob: Job? = null
+var fileDeleteJob: Job? = null
 
 data class DestinationSaveFileInfo(
     val file: File,
@@ -46,6 +49,8 @@ data class SaveFileInfo(val filePath: String?, val fileData: ByteArray?, val fil
         result = 31 * result + fileName.hashCode()
         return result
     }
+
+    override fun toString() = "SaveFileInfo(filePath=$filePath fileName=$fileName)"
 }
 
 // For saving single file.
@@ -139,6 +144,7 @@ fun saveMultipleFiles(
 
     val begin = System.nanoTime()
 
+    destinationSaveFilesInfo.clear()
     saveFilesInfo.indices.map { index ->
 
         val saveFileInfo = saveFilesInfo.elementAt(index)
@@ -397,4 +403,100 @@ fun processMultipleSaveFile(
     }
 
     return true
-}
+}
+
+data class DestinationDeleteFileInfo(
+    val fileUri: String,
+)
+
+data class DeleteFileInfo(val filePath: String) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as DeleteFileInfo
+
+        if (filePath != other.filePath) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = filePath.hashCode()
+        return result
+    }
+
+    override fun toString() = "DeleteFileInfo(filePath=$filePath)"
+}
+
+// For deleting multiple files.
+fun deleteMultipleFiles(
+    deleteFilesInfo: List<DeleteFileInfo>,
+    context: Activity,
+) {
+    val utils = Utils()
+
+    val begin = System.nanoTime()
+
+    destinationDeleteFilesInfo.clear()
+    deleteFilesInfo.indices.map { index ->
+
+        val deleteFileInfo = deleteFilesInfo.elementAt(index)
+        destinationDeleteFilesInfo.add(
+            DestinationDeleteFileInfo(
+                fileUri = deleteFileInfo.filePath,
+            )
+        )
+    }
+
+    deleteMultipleFilesInDirectory(context)
+}
+
+// Delete multiple files in directory.
+fun deleteMultipleFilesInDirectory(
+    context: Activity
+): Boolean {
+
+    val coroutineScope = CoroutineScope(Dispatchers.IO)
+    fileDeleteJob = coroutineScope.launch {
+
+        val utils = Utils()
+
+        val begin = System.nanoTime()
+
+        if (destinationDeleteFilesInfo.isNotEmpty()) {
+
+            val deletedFilesPaths: List<String> = utils.deleteMultipleFilesOnBackground(
+                destinationDeleteFilesInfo, fileDeleteResult, context
+            )
+
+            if (deletedFilesPaths.isNotEmpty()) {
+                utils.finishSuccessfully(
+                    deletedFilesPaths, fileDeleteResult
+                )
+            } else {
+                utils.finishWithError(
+                    "files_delete_failed",
+                    "deleted files paths list was empty",
+                    "deleted files paths list was empty",
+                    fileDeleteResult
+                )
+            }
+
+        } else {
+            utils.finishWithError(
+                "destinationDeleteFilesInfo_not_found",
+                "destinationDeleteFilesInfo is empty",
+                "destinationDeleteFilesInfo is empty",
+                fileDeleteResult
+            )
+        }
+
+
+        val end = System.nanoTime()
+        println("Elapsed time in nanoseconds: ${end - begin}")
+
+    }
+
+    return true
+}

android/src/main/kotlin/com/deepanshuchaudhary/pick_or_save/Utils.kt

@@ -9,6 +9,7 @@ import android.database.Cursor
 import android.net.Uri
 import android.os.Build
 import android.os.ext.SdkExtensions.getExtensionVersion
+import android.provider.DocumentsContract
 import android.provider.OpenableColumns
 import android.util.Log
 import android.webkit.MimeTypeMap
@@ -258,7 +259,7 @@ class Utils {
                     val saveFileNamePrefix: String =
                         destinationSaveFilesInfo.elementAt(index).saveFileNamePrefix
                     val documentFileNewFile = outputFolder!!.createFile(
-                        sourceFileMimeType ?: "application/random", saveFileNamePrefix
+                        sourceFileMimeType ?: "application/octet-stream", saveFileNamePrefix
                     )
                     val destinationFileUri: Uri = documentFileNewFile!!.uri
                     savedFilesPaths.add(withContext(Dispatchers.IO) {
@@ -315,6 +316,50 @@ class Utils {
         Log.d(LOG_TAG, "Canceled File Saving")
     }
 
+    suspend fun deleteMultipleFilesOnBackground(
+        destinationDeleteFilesInfo: List<DestinationDeleteFileInfo>,
+        resultCallback: MethodChannel.Result?,
+        context: Context,
+    ): List<String> {
+        val deletedFilesPaths: MutableList<String> = mutableListOf()
+        val uiScope = CoroutineScope(Dispatchers.Main)
+        withContext(uiScope.coroutineContext) {
+            try {
+                Log.d(LOG_TAG, "Deleting file on background...")
+                destinationDeleteFilesInfo.indices.map { index ->
+                    yield()
+                    val deleteFileUri = destinationDeleteFilesInfo.elementAt(index).fileUri
+                    if (DocumentsContract.deleteDocument(context.contentResolver, Uri.parse(deleteFileUri))) {
+                      deletedFilesPaths.add(deleteFileUri)
+                    }
+                }
+                Log.d(LOG_TAG, "...deleted file on background, result: $deletedFilesPaths")
+            } catch (e: SecurityException) {
+                Log.e(LOG_TAG, "deleteMultipleFilesOnBackground", e)
+                finishWithError(
+                    "security_exception", e.localizedMessage, e.toString(), resultCallback
+                )
+            } catch (e: Exception) {
+                Log.e(LOG_TAG, "deleteMultipleFilesOnBackground failed", e)
+                finishWithError(
+                    "delete_file_failed", e.localizedMessage, e.toString(), resultCallback
+                )
+            } catch (e: Error) {
+                Log.e(LOG_TAG, "deleteMultipleFilesOnBackground failed", e)
+                finishWithError(
+                    "delete_file_failed", e.localizedMessage, e.toString(), resultCallback
+                )
+            }
+        }
+        return deletedFilesPaths
+    }
+
+    fun cancelDelete(
+    ) {
+        fileDeleteJob?.cancel()
+        Log.d(LOG_TAG, "Canceled File Delete")
+    }
+
     fun cancelDirectoryDocumentsPicker(
     ) {
         directoryDocumentsPickerJob?.cancel()
@@ -344,6 +389,10 @@ class Utils {
             fileSavingResult = null
             println("fileSaving result cleared")
         }
+        if (resultCallback == fileDeleteResult && fileDeleteResult != null) {
+            fileDeleteResult = null
+            println("fileDelete result cleared")
+        }
         if (resultCallback == fileMetadataResult && fileMetadataResult != null) {
             fileMetadataResult = null
             println("fileMetadata result cleared")

lib/pick_or_save.dart

@@ -7,6 +7,8 @@ export 'src/pick_or_save_method_channel.dart'
         FileSavingType,
         SaveFileInfo,
         FileSaverParams,
+        DeleteFileInfo,
+        FileDeleteParams,
         FileMetadataParams,
         FileMetadata,
         CacheFilePathFromPathParams,

lib/src/pick_or_save.dart

@@ -37,6 +37,14 @@ class PickOrSave {
     return PickOrSavePlatform.instance.fileSaver(params: params);
   }
 
+  /// Deletes file or files.
+  ///
+  /// Returns path of the deleted file or folder if multiple files or null if operation was cancelled.
+  /// Throws exception on error.
+  Future<List<String>?> fileDelete({FileDeleteParams? params}) {
+    return PickOrSavePlatform.instance.fileDelete(params: params);
+  }
+
   /// Get the display name and size of a file from uri.
   ///
   /// Returns [FileMetadata].