Implement directory picking and related functions

android/build.gradle

@@ -28,6 +28,10 @@ android {
     namespace "codeux.design.filepicker.file_picker_writable"
     compileSdk 33
 
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'
     }

android/src/main/kotlin/codeux/design/filepicker/file_picker_writable/FilePickerWritableImpl.kt

@@ -5,11 +5,11 @@ import android.app.Activity.RESULT_OK
 import android.content.ActivityNotFoundException
 import android.content.ContentResolver
 import android.content.Intent
-import android.database.Cursor
 import android.net.Uri
 import android.os.Build
-import android.provider.OpenableColumns
+import android.provider.DocumentsContract
 import androidx.annotation.MainThread
+import androidx.annotation.RequiresApi
 import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
 import io.flutter.plugin.common.MethodChannel
 import io.flutter.plugin.common.PluginRegistry
@@ -35,6 +35,7 @@ class FilePickerWritableImpl(
   companion object {
     const val REQUEST_CODE_OPEN_FILE = 40832
     const val REQUEST_CODE_CREATE_FILE = 40833
+    const val REQUEST_CODE_OPEN_DIRECTORY = 40834
   }
 
   private var filePickerCreateFile: File? = null
@@ -59,7 +60,7 @@ class FilePickerWritableImpl(
       activity.startActivityForResult(intent, REQUEST_CODE_OPEN_FILE)
     } catch (e: ActivityNotFoundException) {
       filePickerResult = null
-      plugin.logDebug("exception while launcing file picker", e)
+      plugin.logDebug("exception while launching file picker", e)
       result.error(
         "FilePickerNotAvailable",
         "Unable to start file picker, $e",
@@ -68,6 +69,49 @@ class FilePickerWritableImpl(
     }
   }
 
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @MainThread
+  fun openDirectoryPicker(result: MethodChannel.Result, initialDirUri: String?) {
+    if (filePickerResult != null) {
+      throw FilePickerException("Invalid lifecycle, only one call at a time.")
+    }
+    filePickerResult = result
+    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        if (initialDirUri != null) {
+          try {
+            val parsedUri = Uri.parse(initialDirUri).let {
+              val context = requireActivity().applicationContext
+              if (DocumentsContract.isDocumentUri(context, it)) {
+                it
+              } else {
+                DocumentsContract.buildDocumentUriUsingTree(
+                  it,
+                  DocumentsContract.getTreeDocumentId(it)
+                )
+              }
+            }
+            putExtra(DocumentsContract.EXTRA_INITIAL_URI, parsedUri)
+          } catch (e: Exception) {
+            plugin.logDebug("exception while preparing document picker initial dir", e)
+          }
+        }
+      }
+    }
+    val activity = requireActivity()
+    try {
+      activity.startActivityForResult(intent, REQUEST_CODE_OPEN_DIRECTORY)
+    } catch (e: ActivityNotFoundException) {
+      filePickerResult = null
+      plugin.logDebug("exception while launching directory picker", e)
+      result.error(
+        "DirectoryPickerNotAvailable",
+        "Unable to start directory picker, $e",
+        null
+      )
+    }
+  }
+
   @MainThread
   fun openFilePickerForCreate(result: MethodChannel.Result, path: String) {
     if (filePickerResult != null) {
@@ -101,7 +145,7 @@ class FilePickerWritableImpl(
     resultCode: Int,
     data: Intent?
   ): Boolean {
-    if (!arrayOf(REQUEST_CODE_OPEN_FILE, REQUEST_CODE_CREATE_FILE).contains(
+    if (!arrayOf(REQUEST_CODE_OPEN_FILE, REQUEST_CODE_CREATE_FILE, REQUEST_CODE_OPEN_DIRECTORY).contains(
         requestCode
       )) {
       plugin.logDebug("Unknown requestCode $requestCode - ignore")
@@ -152,6 +196,19 @@ class FilePickerWritableImpl(
               initialFileContent
             )
           }
+          REQUEST_CODE_OPEN_DIRECTORY -> {
+            val directoryUri = data?.data
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+              throw FilePickerException("illegal state - get a directory response on an unsupported OS version")
+            }
+            if (directoryUri != null) {
+              plugin.logDebug("Got result $directoryUri")
+              handleDirectoryUriResponse(result, directoryUri)
+            } else {
+              plugin.logDebug("Got RESULT_OK with null directoryUri?")
+              result.success(null)
+            }
+          }
           else -> {
             // can never happen, we already checked the result code.
             throw IllegalStateException("Unexpected requestCode $requestCode")
@@ -192,6 +249,17 @@ class FilePickerWritableImpl(
     copyContentUriAndReturn(result, fileUri)
   }
 
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @MainThread
+  private suspend fun handleDirectoryUriResponse(
+    result: MethodChannel.Result,
+    directoryUri: Uri
+  ) {
+    result.success(
+      getDirectoryInfo(directoryUri)
+    )
+  }
+
   @MainThread
   suspend fun readFileWithIdentifier(
     result: MethodChannel.Result,
@@ -200,6 +268,70 @@ class FilePickerWritableImpl(
     copyContentUriAndReturn(result, Uri.parse(identifier))
   }
 
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @MainThread
+  suspend fun getDirectory(
+    result: MethodChannel.Result,
+    rootUri: String,
+    fileUri: String
+  ) {
+    val activity = requireActivity()
+
+    val root = Uri.parse(rootUri)
+    val leaf = Uri.parse(fileUri)
+    val leafUnderRoot = DocumentsContract.buildDocumentUriUsingTree(
+      root,
+      DocumentsContract.getDocumentId(leaf)
+    )
+
+    if (!fileExists(leafUnderRoot, activity.applicationContext.contentResolver)) {
+      result.error(
+        "InvalidArguments",
+        "The supplied fileUri $fileUri is not a child of $rootUri",
+        null
+      )
+      return
+    }
+
+    val ret = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      getParent(leafUnderRoot, activity.applicationContext)
+    } else {
+      null
+    } ?: findParent(root, leaf, activity.applicationContext)
+
+
+    result.success(mapOf(
+      "identifier" to ret.toString(),
+      "persistable" to "true",
+      "uri" to ret.toString()
+    ))
+  }
+
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @MainThread
+  suspend fun resolveRelativePath(
+    result: MethodChannel.Result,
+    parentIdentifier: String,
+    relativePath: String
+  ) {
+    val activity = requireActivity()
+
+    val resolvedUri = resolveRelativePath(Uri.parse(parentIdentifier), relativePath, activity.applicationContext)
+    if (resolvedUri != null) {
+      val displayName = getDisplayName(resolvedUri, activity.applicationContext.contentResolver)
+      val isDirectory = isDirectory(resolvedUri, activity.applicationContext.contentResolver)
+      result.success(mapOf(
+        "identifier" to resolvedUri.toString(),
+        "persistable" to "true",
+        "fileName" to displayName,
+        "uri" to resolvedUri.toString(),
+        "isDirectory" to isDirectory.toString()
+      ))
+    } else {
+      result.error("FileNotFound", "$relativePath could not be located relative to $parentIdentifier", null)
+    }
+  }
+
   @MainThread
   private suspend fun copyContentUriAndReturn(
     result: MethodChannel.Result,
@@ -228,7 +360,7 @@ class FilePickerWritableImpl(
         plugin.logDebug("Couldn't take persistable URI permission on $fileUri", e)
       }
 
-      val fileName = readFileInfo(fileUri, contentResolver)
+      val fileName = getDisplayName(fileUri, contentResolver)
 
       val tempFile =
         File.createTempFile(
@@ -254,31 +386,35 @@ class FilePickerWritableImpl(
     }
   }
 
-  private suspend fun readFileInfo(
-    uri: Uri,
-    contentResolver: ContentResolver
-  ): String = withContext(Dispatchers.IO) {
-    // The query, because it only applies to a single document, returns only
-    // one row. There's no need to filter, sort, or select fields,
-    // because we want all fields for one document.
-    val cursor: Cursor? = contentResolver.query(
-      uri, null, null, null, null, null
-    )
-
-    cursor?.use {
-      if (!it.moveToFirst()) {
-        throw FilePickerException("Cursor returned empty while trying to read file info for $uri")
-      }
-
-      // Note it's called "Display Name". This is
-      // provider-specific, and might not necessarily be the file name.
-      val displayName: String =
-        it.getString(it.getColumnIndex(OpenableColumns.DISPLAY_NAME))
-      plugin.logDebug("Display Name: $displayName")
-      displayName
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @MainThread
+  private suspend fun getDirectoryInfo(directoryUri: Uri): Map<String, String> {
+    val activity = requireActivity()
 
-    } ?: throw FilePickerException("Unable to load file info from $uri")
+    val contentResolver = activity.applicationContext.contentResolver
 
+    return withContext(Dispatchers.IO) {
+      var persistable = false
+      try {
+        val takeFlags: Int = Intent.FLAG_GRANT_READ_URI_PERMISSION or
+          Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+        contentResolver.takePersistableUriPermission(directoryUri, takeFlags)
+        persistable = true
+      } catch (e: SecurityException) {
+        plugin.logDebug("Couldn't take persistable URI permission on $directoryUri", e)
+      }
+      // URI as returned from picker is just a tree URI, but we need a document URI for getting the display name
+      val treeDocUri = DocumentsContract.buildDocumentUriUsingTree(
+        directoryUri,
+        DocumentsContract.getTreeDocumentId(directoryUri)
+      )
+      mapOf(
+        "identifier" to directoryUri.toString(),
+        "persistable" to persistable.toString(),
+        "uri" to directoryUri.toString(),
+        "fileName" to getDisplayName(treeDocUri, contentResolver)
+      )
+    }
   }
 
   fun onDetachedFromActivity(binding: ActivityPluginBinding) {

android/src/main/kotlin/codeux/design/filepicker/file_picker_writable/FilePickerWritablePlugin.kt

@@ -2,6 +2,7 @@ package codeux.design.filepicker.file_picker_writable
 
 import android.app.Activity
 import android.net.Uri
+import android.os.Build
 import android.util.Log
 import androidx.annotation.MainThread
 import androidx.annotation.NonNull
@@ -89,11 +90,44 @@ class FilePickerWritablePlugin : FlutterPlugin, MethodCallHandler,
               ?: throw FilePickerException("Expected argument 'path'")
             impl.openFilePickerForCreate(result, path)
           }
+          "isDirectoryAccessSupported" -> {
+            result.success(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+          }
+          "openDirectoryPicker" -> {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+              val initialDirUri = call.argument<String>("initialDirUri")
+              impl.openDirectoryPicker(result, initialDirUri)
+            } else {
+              throw FilePickerException("${call.method} is not supported on Android ${Build.VERSION.RELEASE}")
+            }
+          }
           "readFileWithIdentifier" -> {
             val identifier = call.argument<String>("identifier")
               ?: throw FilePickerException("Expected argument 'identifier'")
             impl.readFileWithIdentifier(result, identifier)
           }
+          "getDirectory" -> {
+            val rootIdentifier = call.argument<String>("rootIdentifier")
+              ?: throw FilePickerException("Expected argument 'rootIdentifier'")
+            val fileIdentifier = call.argument<String>("fileIdentifier")
+              ?: throw FilePickerException("Expected argument 'fileIdentifier'")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+              impl.getDirectory(result, rootIdentifier, fileIdentifier)
+            } else {
+              throw FilePickerException("${call.method} is not supported on Android ${Build.VERSION.RELEASE}")
+            }
+          }
+          "resolveRelativePath" -> {
+            val directoryIdentifier = call.argument<String>("directoryIdentifier")
+              ?: throw FilePickerException("Expected argument 'directoryIdentifier'")
+            val relativePath = call.argument<String>("relativePath")
+              ?: throw FilePickerException("Expected argument 'relativePath'")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+              impl.resolveRelativePath(result, directoryIdentifier, relativePath)
+            } else {
+              throw FilePickerException("${call.method} is not supported on Android ${Build.VERSION.RELEASE}")
+            }
+          }
           "writeFileWithIdentifier" -> {
             val identifier = call.argument<String>("identifier")
               ?: throw FilePickerException("Expected argument 'identifier'")