@capacitor/filesystem 7.0.2-nightly-20250526T150552.0 → 7.1.0-dev.1

package/android/src/main/kotlin/com/capacitorjs/plugins/filesystem/FilesystemMethodOptions.kt

@@ -0,0 +1,129 @@
+package com.capacitorjs.plugins.filesystem
+
+import com.getcapacitor.PluginCall
+import io.ionic.libs.ionfilesystemlib.model.IONFILEEncoding
+import io.ionic.libs.ionfilesystemlib.model.IONFILEFolderType
+import io.ionic.libs.ionfilesystemlib.model.IONFILEReadInChunksOptions
+import io.ionic.libs.ionfilesystemlib.model.IONFILEReadOptions
+import io.ionic.libs.ionfilesystemlib.model.IONFILESaveMode
+import io.ionic.libs.ionfilesystemlib.model.IONFILESaveOptions
+import io.ionic.libs.ionfilesystemlib.model.IONFILEUri
+
+internal const val INPUT_APPEND = "append"
+private const val INPUT_PATH = "path"
+private const val INPUT_DIRECTORY = "directory"
+private const val INPUT_ENCODING = "encoding"
+private const val INPUT_CHUNK_SIZE = "chunkSize"
+private const val INPUT_DATA = "data"
+private const val INPUT_RECURSIVE = "recursive"
+private const val INPUT_FROM = "from"
+private const val INPUT_FROM_DIRECTORY = "directory"
+private const val INPUT_TO = "to"
+private const val INPUT_TO_DIRECTORY = "toDirectory"
+
+internal data class ReadFileOptions(
+    val uri: IONFILEUri.Unresolved,
+    val options: IONFILEReadOptions
+)
+
+internal data class ReadFileInChunksOptions(
+    val uri: IONFILEUri.Unresolved,
+    val options: IONFILEReadInChunksOptions
+)
+
+internal data class WriteFileOptions(
+    val uri: IONFILEUri.Unresolved,
+    val options: IONFILESaveOptions
+)
+
+internal data class SingleUriWithRecursiveOptions(
+    val uri: IONFILEUri.Unresolved,
+    val recursive: Boolean
+)
+
+internal data class DoubleUri(
+    val fromUri: IONFILEUri.Unresolved,
+    val toUri: IONFILEUri.Unresolved,
+)
+
+/**
+ * @return [ReadFileOptions] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getReadFileOptions(): ReadFileOptions? {
+    val uri = getSingleIONFILEUri() ?: return null
+    val encoding = IONFILEEncoding.fromEncodingName(getString(INPUT_ENCODING))
+    return ReadFileOptions(uri = uri, options = IONFILEReadOptions(encoding))
+}
+
+/**
+ * @return [ReadFileInChunksOptions] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getReadFileInChunksOptions(): ReadFileInChunksOptions? {
+    val uri = getSingleIONFILEUri() ?: return null
+    val encoding = IONFILEEncoding.fromEncodingName(getString(INPUT_ENCODING))
+    val chunkSize = getInt(INPUT_CHUNK_SIZE)?.takeIf { it > 0 } ?: return null
+    return ReadFileInChunksOptions(
+        uri = uri,
+        options = IONFILEReadInChunksOptions(encoding, chunkSize)
+    )
+}
+
+/**
+ * @return [ReadFileOptions] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getWriteFileOptions(): WriteFileOptions? {
+    val uri = getSingleIONFILEUri() ?: return null
+    val data = getString(INPUT_DATA) ?: return null
+    val recursive = getBoolean(INPUT_RECURSIVE) ?: false
+    val append = getBoolean(INPUT_APPEND) ?: false
+    val saveMode = if (append) IONFILESaveMode.APPEND else IONFILESaveMode.WRITE
+    val encoding = IONFILEEncoding.fromEncodingName(getString(INPUT_ENCODING))
+    return WriteFileOptions(
+        uri = uri,
+        options = IONFILESaveOptions(
+            data = data,
+            encoding = encoding,
+            mode = saveMode,
+            createFileRecursive = recursive
+        )
+    )
+}
+
+/**
+ * @return [SingleUriWithRecursiveOptions] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getSingleUriWithRecursiveOptions(): SingleUriWithRecursiveOptions? {
+    val uri = getSingleIONFILEUri() ?: return null
+    val recursive = getBoolean(INPUT_RECURSIVE) ?: false
+    return SingleUriWithRecursiveOptions(uri = uri, recursive = recursive)
+}
+
+/**
+ * @return two uris in form of [DoubleUri] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getDoubleIONFILEUri(): DoubleUri? {
+    val fromPath = getString(INPUT_FROM) ?: return null
+    val fromFolder = IONFILEFolderType.fromStringAlias(getString(INPUT_FROM_DIRECTORY))
+    val toPath = getString(INPUT_TO) ?: return null
+    val toFolder = getString(INPUT_TO_DIRECTORY)?.let { toDirectory ->
+        IONFILEFolderType.fromStringAlias(toDirectory)
+    } ?: fromFolder
+    return DoubleUri(
+        fromUri = IONFILEUri.Unresolved(fromFolder, fromPath),
+        toUri = IONFILEUri.Unresolved(toFolder, toPath),
+    )
+}
+
+/**
+ * return a single [IONFILEUri.Unresolved] from JSON inside [PluginCall], or null if input is invalid
+ */
+internal fun PluginCall.getSingleIONFILEUri(): IONFILEUri.Unresolved? {
+    val path = getString(INPUT_PATH) ?: return null
+    val directoryAlias = getString(INPUT_DIRECTORY)
+    return unresolvedUri(path, directoryAlias)
+}
+
+private fun unresolvedUri(path: String, directoryAlias: String?) = IONFILEUri.Unresolved(
+    parentFolder = IONFILEFolderType.fromStringAlias(directoryAlias),
+    uriPath = path
+)

package/android/src/main/kotlin/com/capacitorjs/plugins/filesystem/FilesystemMethodResults.kt

@@ -0,0 +1,65 @@
+package com.capacitorjs.plugins.filesystem
+
+import android.net.Uri
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import io.ionic.libs.ionfilesystemlib.model.IONFILEFileType
+import io.ionic.libs.ionfilesystemlib.model.IONFILEMetadataResult
+import io.ionic.libs.ionfilesystemlib.model.IONFILESaveMode
+import io.ionic.libs.ionfilesystemlib.model.IONFILEUri
+
+private val OUTPUT_DATA = "data"
+private val OUTPUT_NAME = "name"
+private val OUTPUT_TYPE = "type"
+private val OUTPUT_SIZE = "size"
+private val OUTPUT_MODIFIED_TIME = "mtime"
+private val OUTPUT_CREATED_TIME = "ctime"
+private val OUTPUT_URI = "uri"
+private val OUTPUT_FILES = "files"
+
+/**
+ * @return a result [JSObject] for reading a file
+ */
+fun createReadResultObject(readData: String): JSObject =
+    JSObject().also { it.putOpt(OUTPUT_DATA, readData) }
+
+
+/**
+ * @return a result [JSObject] for writing/append a file
+ */
+fun createWriteResultObject(uri: Uri, mode: IONFILESaveMode): JSObject? =
+    if (mode == IONFILESaveMode.APPEND) {
+        null
+    } else {
+        createUriResultObject(uri)
+    }
+
+/**
+ * @return a result [JSObject] for the list of a directories contents
+ */
+fun createReadDirResultObject(list: List<IONFILEMetadataResult>): JSObject = JSObject().also {
+    it.put(OUTPUT_FILES, JSArray(list.map { child -> child.toResultObject() }))
+}
+
+/**
+ * @return a result [JSObject] for stat, from the [IONFILEMetadataResult] object
+ */
+fun IONFILEMetadataResult.toResultObject(): JSObject = JSObject().apply {
+    put(OUTPUT_NAME, name)
+    put(OUTPUT_TYPE, if (type is IONFILEFileType.Directory) "directory" else "file")
+    put(OUTPUT_SIZE, size)
+    put(OUTPUT_MODIFIED_TIME, lastModifiedTimestamp)
+    put(OUTPUT_CREATED_TIME, createdTimestamp)
+    put(OUTPUT_URI, uri)
+}
+
+/**
+ * @return a result [JSObject] based on a resolved uri [IONFILEUri.Resolved]
+ */
+fun IONFILEUri.Resolved.toResultObject(): JSObject = createUriResultObject(this.uri)
+
+/**
+ * @return a result [JSObject] for an Android [Uri]
+ */
+fun createUriResultObject(uri: Uri): JSObject =
+    JSObject().also { it.put(OUTPUT_URI, uri.toString()) }

package/android/src/main/kotlin/com/capacitorjs/plugins/filesystem/FilesystemPlugin.kt

@@ -0,0 +1,412 @@
+package com.capacitorjs.plugins.filesystem
+
+import android.Manifest
+import android.media.MediaScannerConnection
+import android.os.Build
+import android.os.Environment
+import android.util.Log
+import com.getcapacitor.JSObject
+import com.getcapacitor.Logger
+import com.getcapacitor.PermissionState
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import com.getcapacitor.plugin.util.HttpRequestHandler.ProgressEmitter
+import io.ionic.libs.ionfilesystemlib.IONFILEController
+import io.ionic.libs.ionfilesystemlib.model.IONFILECreateOptions
+import io.ionic.libs.ionfilesystemlib.model.IONFILEDeleteOptions
+import io.ionic.libs.ionfilesystemlib.model.IONFILEUri
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import org.json.JSONException
+
+private const val PUBLIC_STORAGE = "publicStorage"
+private const val PUBLIC_STORAGE_ABOVE_ANDROID_10 = "publicStorageAboveAPI29"
+private const val PERMISSION_GRANTED = "granted"
+
+@CapacitorPlugin(
+    name = "Filesystem",
+    permissions = [
+        Permission(
+            strings = [Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE],
+            alias = PUBLIC_STORAGE
+        ),
+        /*
+        For SDK versions 30-32 (Android 11 and Android 12)
+        Could be that certain files may require read permission, such as local file path to photos/videos in gallery
+        */
+        Permission(
+            strings = [Manifest.permission.READ_EXTERNAL_STORAGE],
+            alias = PUBLIC_STORAGE_ABOVE_ANDROID_10
+        )
+    ]
+)
+class FilesystemPlugin : Plugin() {
+
+    private var legacyImplementation: LegacyFilesystemImplementation? = null
+
+    private val coroutineScope: CoroutineScope by lazy { CoroutineScope(Dispatchers.Main) }
+    private val controller: IONFILEController by lazy { IONFILEController(context.applicationContext) }
+
+    override fun load() {
+        super.load()
+        legacyImplementation = LegacyFilesystemImplementation(context)
+    }
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+        coroutineScope.cancel()
+    }
+
+    @PluginMethod
+    fun readFile(call: PluginCall) {
+        val input: ReadFileOptions = call.getReadFileOptions() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.uri, call) { uri ->
+            controller.readFile(uri, input.options)
+                .onSuccess { call.sendSuccess(result = createReadResultObject(it)) }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    fun readFileInChunks(call: PluginCall) {
+        val input: ReadFileInChunksOptions = call.getReadFileInChunksOptions() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.uri, call) { uri ->
+            controller.readFileInChunks(uri, input.options)
+                .onEach { chunk ->
+                    call.sendSuccess(result = createReadResultObject(chunk), keepCallback = true)
+                }
+                .onCompletion { error ->
+                    if (error == null) {
+                        call.sendSuccess(result = createReadResultObject(""))
+                    }
+                }
+                .catch {
+                    call.sendError(it.toFilesystemError(call.methodName))
+                }
+                .launchIn(coroutineScope)
+        }
+    }
+
+    @PluginMethod
+    fun writeFile(call: PluginCall) {
+        val input: WriteFileOptions = call.getWriteFileOptions() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.uri, call) { uri ->
+            controller.saveFile(uri, input.options)
+                .onSuccess { uriSaved ->
+                    // update mediaStore index only if file was written to external storage
+                    if (uri.inExternalStorage) {
+                        uriSaved.path?.let {
+                            MediaScannerConnection.scanFile(context, arrayOf(it), null, null)
+                        }
+                    }
+                    call.sendSuccess(result = createWriteResultObject(uriSaved, input.options.mode))
+                }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun appendFile(call: PluginCall) {
+        try {
+            call.data.putOpt(INPUT_APPEND, true)
+        } catch (ex: JSONException) {
+            Log.e(logTag, "Tried to set `append` in `PluginCall`, but got exception", ex)
+            call.sendError(
+                FilesystemErrors.operationFailed(call.methodName, ex.localizedMessage ?: "")
+            )
+            return
+        }
+        writeFile(call)
+    }
+
+    @PluginMethod
+    fun deleteFile(call: PluginCall) {
+        val input = call.getSingleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input, call) { uri ->
+            controller.delete(uri, IONFILEDeleteOptions(recursive = false))
+                .onSuccess { call.sendSuccess() }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun mkdir(call: PluginCall) {
+        val input = call.getSingleUriWithRecursiveOptions() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.uri, call) { uri ->
+            controller.createDirectory(uri, IONFILECreateOptions(input.recursive))
+                .onSuccess { call.sendSuccess() }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun rmdir(call: PluginCall) {
+        val input = call.getSingleUriWithRecursiveOptions() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.uri, call) { uri ->
+            controller.delete(uri, IONFILEDeleteOptions(input.recursive))
+                .onSuccess { call.sendSuccess() }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun readdir(call: PluginCall) {
+        val input = call.getSingleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input, call) { uri ->
+            controller.listDirectory(uri)
+                .onSuccess { call.sendSuccess(result = createReadDirResultObject(it)) }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun getUri(call: PluginCall) {
+        val input = call.getSingleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        coroutineScope.launch {
+            controller.getFileUri(input)
+                .onSuccess { resolvedUri -> call.sendSuccess(result = resolvedUri.toResultObject()) }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun stat(call: PluginCall) {
+        val input = call.getSingleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input, call) { uri ->
+            controller.getMetadata(uri)
+                .onSuccess { metadata -> call.sendSuccess(result = metadata.toResultObject()) }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun rename(call: PluginCall) {
+        val input = call.getDoubleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.fromUri, input.toUri, call) { source, destination ->
+            controller.move(source, destination)
+                .onSuccess { call.sendSuccess() }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    fun copy(call: PluginCall) {
+        val input = call.getDoubleIONFILEUri() ?: run {
+            call.sendError(FilesystemErrors.invalidInputMethod(call.methodName))
+            return
+        }
+        runWithPermission(input.fromUri, input.toUri, call) { source, destination ->
+            controller.copy(source, destination)
+                .onSuccess { call.sendSuccess(createUriResultObject(it)) }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    @PluginMethod
+    @Deprecated("Use @capacitor/file-transfer plugin instead")
+    fun downloadFile(call: PluginCall) {
+        try {
+            val directory = call.getString("directory", Environment.DIRECTORY_DOWNLOADS)
+
+            if (legacyImplementation?.isPublicDirectory(directory) == true &&
+                !isStoragePermissionGranted(false)
+            ) {
+                requestAllPermissions(call, "permissionCallback")
+                return
+            }
+
+            val emitter = ProgressEmitter { bytes: Int?, contentLength: Int? ->
+                val ret = JSObject()
+                ret.put("url", call.getString("url"))
+                ret.put("bytes", bytes)
+                ret.put("contentLength", contentLength)
+                notifyListeners("progress", ret)
+            }
+
+            legacyImplementation?.downloadFile(
+                call,
+                bridge,
+                emitter,
+                object : LegacyFilesystemImplementation.FilesystemDownloadCallback {
+                    override fun onSuccess(result: JSObject) {
+                        // update mediaStore index only if file was written to external storage
+                        if (legacyImplementation?.isPublicDirectory(directory) == true) {
+                            MediaScannerConnection.scanFile(
+                                context,
+                                arrayOf(result.getString("path")),
+                                null,
+                                null
+                            )
+                        }
+                        call.resolve(result)
+                    }
+
+                    override fun onError(error: Exception) {
+                        call.reject("Error downloading file: " + error.localizedMessage, error)
+                    }
+                }
+            )
+        } catch (ex: Exception) {
+            call.reject("Error downloading file: " + ex.localizedMessage, ex)
+        }
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        if (isStoragePermissionGranted(false)) {
+            call.sendSuccess(JSObject().also { it.put(PUBLIC_STORAGE, PERMISSION_GRANTED) })
+        } else {
+            super.checkPermissions(call)
+        }
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        if (isStoragePermissionGranted(false)) {
+            call.sendSuccess(JSObject().also { it.put(PUBLIC_STORAGE, PERMISSION_GRANTED) })
+        } else {
+            super.requestPermissions(call)
+        }
+    }
+
+    @PermissionCallback
+    private fun permissionCallback(call: PluginCall) {
+        if (!isStoragePermissionGranted(true)) {
+            Logger.debug(logTag, "User denied storage permission")
+            call.sendError(FilesystemErrors.filePermissionsDenied)
+            return
+        }
+
+        when (call.methodName) {
+            // appendFile and writeFile have the same implementation, hence the same method is called;
+            //  the only difference being that we add a boolean for append in the PluginCall,
+            //  which is done before this method is called.
+            "appendFile", "writeFile" -> writeFile(call)
+            "deleteFile" -> deleteFile(call)
+            "mkdir" -> mkdir(call)
+            "rmdir" -> rmdir(call)
+            "rename" -> rename(call)
+            "copy" -> copy(call)
+            "readFile" -> readFile(call)
+            "readFileInChunks" -> readFileInChunks(call)
+            "readdir" -> readdir(call)
+            "getUri" -> getUri(call)
+            "stat" -> stat(call)
+            "downloadFile" -> downloadFile(call)
+        }
+    }
+
+    /**
+     * Runs a suspend code if the app has permission to access the uri
+     *
+     * Will ask for permission if it has not been granted.
+     *
+     * May return an error if the uri is not resolvable.
+     *
+     * @param uri the uri pointing to the file / directory
+     * @param call the capacitor plugin call
+     * @param onPermissionGranted the callback to run the suspending code
+     */
+    private fun runWithPermission(
+        uri: IONFILEUri.Unresolved,
+        call: PluginCall,
+        onPermissionGranted: suspend (resolvedUri: IONFILEUri.Resolved) -> Unit
+    ) {
+        coroutineScope.launch {
+            controller.getFileUri(uri)
+                .onSuccess { resolvedUri ->
+                    // certain files like a photo/video in gallery may require read permission on Android 11 and 12.
+                    if (
+                        resolvedUri.inExternalStorage
+                        && !isStoragePermissionGranted(shouldRequestAboveAndroid10 = uri.parentFolder == null)
+                    ) {
+                        requestAllPermissions(call, this@FilesystemPlugin::permissionCallback.name)
+                    } else {
+                        onPermissionGranted(resolvedUri)
+                    }
+                }
+                .onFailure { call.sendError(it.toFilesystemError(call.methodName)) }
+        }
+    }
+
+    /**
+     * Runs a suspend code if the app has permission to access both to and from uris
+     *
+     * Will ask for permission if it has not been granted.
+     *
+     * May return an error if the uri is not resolvable.
+     *
+     * @param fromUri the source uri pointing to the file / directory
+     * @param toUri the destination uri pointing to the file / directory
+     * @param call the capacitor plugin call
+     * @param onPermissionGranted the callback to run the suspending code
+     */
+    private fun runWithPermission(
+        fromUri: IONFILEUri.Unresolved,
+        toUri: IONFILEUri.Unresolved,
+        call: PluginCall,
+        onPermissionGranted: suspend (resolvedSourceUri: IONFILEUri.Resolved, resolvedDestinationUri: IONFILEUri.Resolved) -> Unit
+    ) {
+        runWithPermission(fromUri, call) { resolvedSourceUri ->
+            runWithPermission(toUri, call) { resolvedDestinationUri ->
+                onPermissionGranted(resolvedSourceUri, resolvedDestinationUri)
+            }
+        }
+    }
+
+    /**
+     * Checks the the given permission is granted or not
+     * @param shouldRequestAboveAndroid10 whether or not should check for read permission above android 10
+     *  May vary with the kind of file path that is provided.
+     * @return Returns true if the app is running on Android 13 (API 33) or newer, or if the permission is already granted
+     * or false if it is denied.
+     */
+    private fun isStoragePermissionGranted(shouldRequestAboveAndroid10: Boolean): Boolean = when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> true
+
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.R ->
+            !shouldRequestAboveAndroid10 || getPermissionState(PUBLIC_STORAGE_ABOVE_ANDROID_10) == PermissionState.GRANTED
+
+        else -> getPermissionState(PUBLIC_STORAGE) == PermissionState.GRANTED
+    }
+}