expo-file-system 18.2.0-canary-20250709-136b77f → 18.2.0-canary-20250722-599a28f

package/CHANGELOG.md

@@ -6,9 +6,11 @@
 
 ### 🎉 New features
 
+- Add directory info function ([#37910](https://github.com/expo/expo/pull/37910) by [@Wenszel](https://github.com/Wenszel))
 - Add total and available sizes, directory sizes. ([#37594](https://github.com/expo/expo/pull/37594) by [@aleqsio](https://github.com/aleqsio))
 - Add info method, modificationTime and creationTime properties to file-system/next. ([#37505](https://github.com/expo/expo/pull/37505) by [@Wenszel](https://github.com/Wenszel))
 - Add support for custom headers in downloadFileAsync ([#36108](https://github.com/expo/expo/pull/36108) by [@leonhh](https://github.com/leonhh))
+- [next] Add limited support for SAF Uris. ([#38075](https://github.com/expo/expo/pull/38075) by [@aleqsio](https://github.com/aleqsio))
 
 ### 🐛 Bug fixes
 

package/android/build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '18.2.0-canary-20250709-136b77f'
+version = '18.2.0-canary-20250722-599a28f'
 
 android {
   namespace "expo.modules.filesystem"
   defaultConfig {
     versionCode 30
-    versionName "18.2.0-canary-20250709-136b77f"
+    versionName "18.2.0-canary-20250722-599a28f"
   }
 }
 
@@ -21,4 +21,5 @@ dependencies {
   api 'com.squareup.okhttp3:okhttp-urlconnection:4.9.2'
   api 'com.squareup.okio:okio:2.9.0'
   api "androidx.legacy:legacy-support-v4:1.0.0"
+  api "androidx.documentfile:documentfile:1.1.0"
 }

package/android/src/main/java/expo/modules/filesystem/next/FileSystemDirectory.kt

@@ -1,23 +1,23 @@
 package expo.modules.filesystem.next
 
 import android.net.Uri
+import expo.modules.filesystem.slashifyFilePath
 import expo.modules.interfaces.filesystem.Permission
-import java.io.File
 
-class FileSystemDirectory(file: File) : FileSystemPath(file) {
+class FileSystemDirectory(uri: Uri) : FileSystemPath(uri) {
   fun validatePath() {
 // Kept empty for now, but can be used to validate if the path is a valid directory path.
   }
 
   override fun validateType() {
-    if (file.exists() && !file.isDirectory) {
+    if (file.exists() && !file.isDirectory()) {
       throw InvalidTypeFolderException()
     }
   }
 
   val exists: Boolean get() {
     return if (checkPermission(Permission.READ)) {
-      file.isDirectory
+      file.isDirectory()
     } else {
       false
     }
@@ -26,7 +26,34 @@ class FileSystemDirectory(file: File) : FileSystemPath(file) {
   val size: Long get() {
     validatePermission(Permission.READ)
     validateType()
-    return file.walkTopDown().filter { it.isFile }.map { it.length() }.sum()
+    return javaFile.walkTopDown().filter { it.isFile }.map { it.length() }.sum()
+  }
+
+  fun info(): DirectoryInfo {
+    validateType()
+    validatePermission(Permission.READ)
+    if (!file.exists()) {
+      val directoryInfo = DirectoryInfo(
+        exists = false,
+        uri = slashifyFilePath(javaFile.toURI().toString())
+      )
+      return directoryInfo
+    }
+
+    when {
+      javaFile.toURI().scheme == "file" -> {
+        val directoryInfo = DirectoryInfo(
+          exists = true,
+          uri = slashifyFilePath(javaFile.toURI().toString()),
+          files = javaFile.listFiles()?.map { i -> i.name },
+          modificationTime = modificationTime,
+          creationTime = creationTime,
+          size = size
+        )
+        return directoryInfo
+      }
+      else -> throw UnableToGetInfoException("file schema ${javaFile.toURI().scheme} is not supported")
+    }
   }
 
   fun create(options: CreateOptions = CreateOptions()) {
@@ -34,33 +61,43 @@ class FileSystemDirectory(file: File) : FileSystemPath(file) {
     validatePermission(Permission.WRITE)
     validateCanCreate(options)
     if (options.overwrite && file.exists()) {
-      file.delete()
+      javaFile.delete()
     }
     val created = if (options.intermediates) {
-      file.mkdirs()
+      javaFile.mkdirs()
     } else {
-      file.mkdir()
+      javaFile.mkdir()
     }
     if (!created) {
       throw UnableToCreateException("directory already exists or could not be created")
     }
   }
 
+  fun createFile(mimeType: String?, fileName: String): FileSystemFile {
+    val newFile = file.createFile(mimeType ?: "text/plain", fileName) ?: throw UnableToCreateException("file could not be created")
+    return FileSystemFile(newFile.uri)
+  }
+
+  fun createDirectory(fileName: String): FileSystemDirectory {
+    val newDirectory = file.createDirectory(fileName) ?: throw UnableToCreateException("directory could not be created")
+    return FileSystemDirectory(newDirectory.uri)
+  }
+
   // this function is internal and will be removed in the future (when returning arrays of shared objects is supported)
   fun listAsRecords(): List<Map<String, Any>> {
     validateType()
     validatePermission(Permission.READ)
-    return file.listFiles()?.map {
-      val uriString = Uri.fromFile(it).toString()
+    return file.listFilesAsUnified().map {
+      val uriString = it.uri.toString()
       mapOf(
-        "isDirectory" to it.isDirectory,
+        "isDirectory" to it.isDirectory(),
         "uri" to if (uriString.endsWith("/")) uriString else "$uriString/"
       )
-    } ?: emptyList()
+    }
   }
 
   fun asString(): String {
-    val uriString = Uri.fromFile(file).toString()
+    val uriString = file.uri.toString()
     return if (uriString.endsWith("/")) uriString else "$uriString/"
   }
 }

package/android/src/main/java/expo/modules/filesystem/next/FileSystemFile.kt

@@ -1,7 +1,6 @@
 package expo.modules.filesystem.next
 
 import android.net.Uri
-import android.os.Build
 import android.util.Base64
 import android.webkit.MimeTypeMap
 import expo.modules.filesystem.InfoOptions
@@ -9,16 +8,11 @@ import expo.modules.filesystem.slashifyFilePath
 import expo.modules.interfaces.filesystem.Permission
 import expo.modules.kotlin.apifeatures.EitherType
 import expo.modules.kotlin.typedarray.TypedArray
-import java.io.File
 import java.io.FileOutputStream
-import java.nio.file.attribute.BasicFileAttributes
 import java.security.MessageDigest
-import kotlin.io.path.Path
-import kotlin.io.path.readAttributes
-import kotlin.time.Duration.Companion.milliseconds
 
 @OptIn(EitherType::class)
-class FileSystemFile(file: File) : FileSystemPath(file) {
+class FileSystemFile(uri: Uri) : FileSystemPath(uri) {
   // Kept empty for now, but can be used to validate if the uri is a valid file uri. // TODO: Move to the constructor once also moved on iOS
   fun validatePath() {
   }
@@ -27,14 +21,14 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
   // After calling this function, we can use the `isDirectory` and `isFile` functions safely as they will match the shared class used.
   override fun validateType() {
     validatePermission(Permission.READ)
-    if (file.exists() && file.isDirectory) {
+    if (file.exists() && file.isDirectory()) {
       throw InvalidTypeFileException()
     }
   }
 
   val exists: Boolean get() {
     return if (checkPermission(Permission.READ)) {
-      file.isFile
+      file.isFile()
     } else {
       false
     }
@@ -44,15 +38,19 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     validateType()
     validatePermission(Permission.WRITE)
     validateCanCreate(options)
-    if (options.overwrite && file.exists()) {
-      file.delete()
-    }
-    if (options.intermediates) {
-      file.parentFile?.mkdirs()
-    }
-    val created = file.createNewFile()
-    if (!created) {
-      throw UnableToCreateException("file already exists or could not be created")
+    if (uri.isContentUri) {
+      throw UnableToCreateException("create function does not work with SAF Uris, use `createDirectory` and `createFile` instead")
+    } else {
+      if (options.overwrite && exists) {
+        javaFile.delete()
+      }
+      if (options.intermediates) {
+        javaFile.parentFile?.mkdirs()
+      }
+      val created = javaFile.createNewFile()
+      if (!created) {
+        throw UnableToCreateException("file already exists or could not be created")
+      }
     }
   }
 
@@ -62,7 +60,7 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     if (!exists) {
       create()
     }
-    FileOutputStream(file).use {
+    FileOutputStream(javaFile).use {
       it.write(content.toByteArray())
     }
   }
@@ -73,85 +71,70 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     if (!exists) {
       create()
     }
-    FileOutputStream(file).use {
+    FileOutputStream(javaFile).use {
       it.channel.write(content.toDirectBuffer())
     }
   }
 
   fun asString(): String {
-    val uriString = Uri.fromFile(file).toString()
+    val uriString = file.uri.toString()
     return if (uriString.endsWith("/")) uriString.dropLast(1) else uriString
   }
 
   fun text(): String {
     validateType()
     validatePermission(Permission.READ)
-    return file.readText()
+    return javaFile.readText()
   }
 
   fun base64(): String {
     validateType()
     validatePermission(Permission.READ)
-    return Base64.encodeToString(file.readBytes(), Base64.NO_WRAP)
+    return Base64.encodeToString(javaFile.readBytes(), Base64.NO_WRAP)
   }
 
   fun bytes(): ByteArray {
     validateType()
     validatePermission(Permission.READ)
-    return file.readBytes()
+    return javaFile.readBytes()
   }
 
   @OptIn(ExperimentalStdlibApi::class)
   val md5: String get() {
     validatePermission(Permission.READ)
     val md = MessageDigest.getInstance("MD5")
-    val digest = md.digest(file.readBytes())
+    val digest = md.digest(javaFile.readBytes())
     return digest.toHexString()
   }
 
   val size: Long? get() {
-    return if (file.exists()) {
-      file.length()
+    return if (javaFile.exists()) {
+      javaFile.length()
     } else {
       null
     }
   }
 
   val type: String? get() {
-    return MimeTypeMap.getFileExtensionFromUrl(file.path)
+    return MimeTypeMap.getFileExtensionFromUrl(javaFile.path)
       ?.run { MimeTypeMap.getSingleton().getMimeTypeFromExtension(lowercase()) }
   }
 
-  val modificationTime: Long get() {
-    validateType()
-    return file.lastModified()
-  }
-
-  val creationTime: Long? get() {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      validateType()
-      val attributes = Path(file.path).readAttributes<BasicFileAttributes>()
-      return attributes.creationTime().toMillis().milliseconds.inWholeMilliseconds
-    } else {
-      return null
-    }
-  }
-
   fun info(options: InfoOptions?): FileInfo {
     validateType()
     validatePermission(Permission.READ)
     if (!file.exists()) {
       val fileInfo = FileInfo(
         exists = false,
-        uri = slashifyFilePath(file.toURI().toString())
+        uri = slashifyFilePath(javaFile.toURI().toString())
       )
       return fileInfo
     }
     when {
-      file.toURI().scheme == "file" -> {
+      javaFile.toURI().scheme == "file" -> {
         val fileInfo = FileInfo(
           exists = true,
-          uri = slashifyFilePath(file.toURI().toString()),
+          uri = slashifyFilePath(javaFile.toURI().toString()),
           size = size,
           modificationTime = modificationTime,
           creationTime = creationTime
@@ -161,7 +144,7 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
         }
         return fileInfo
       }
-      else -> throw UnableToGetInfoException("file schema ${file.toURI().scheme} is not supported")
+      else -> throw UnableToGetInfoException("file schema ${javaFile.toURI().scheme} is not supported")
     }
   }
 }

package/android/src/main/java/expo/modules/filesystem/next/FileSystemFileHandle.kt

@@ -4,7 +4,7 @@ import expo.modules.kotlin.sharedobjects.SharedRef
 import java.io.RandomAccessFile
 import java.nio.ByteBuffer
 import java.nio.channels.FileChannel
-class FileSystemFileHandle(file: FileSystemFile) : SharedRef<FileChannel>(RandomAccessFile(file.file, "rw").channel), AutoCloseable {
+class FileSystemFileHandle(file: FileSystemFile) : SharedRef<FileChannel>(RandomAccessFile(file.javaFile, "rw").channel), AutoCloseable {
   private val fileChannel: FileChannel = ref
 
   private fun ensureIsOpen() {

package/android/src/main/java/expo/modules/filesystem/next/FileSystemNextModule.kt

@@ -63,9 +63,9 @@ class FileSystemNextModule : Module() {
       val fileName = URLUtil.guessFileName(url.toString(), contentDisposition, contentType)
 
       val destination = if (to is FileSystemDirectory) {
-        File(to.file, fileName)
+        File(to.javaFile, fileName)
       } else {
-        to.file
+        to.javaFile
       }
 
       if (destination.exists()) {
@@ -78,7 +78,7 @@ class FileSystemNextModule : Module() {
           input.copyTo(output)
         }
       }
-      return@Coroutine destination.path
+      return@Coroutine destination.toURI()
     }
 
     Function("info") { url: URI ->
@@ -93,8 +93,8 @@ class FileSystemNextModule : Module() {
     }
 
     Class(FileSystemFile::class) {
-      Constructor { uri: URI ->
-        FileSystemFile(File(uri.path))
+      Constructor { uri: Uri ->
+        FileSystemFile(uri)
       }
 
       Function("delete") { file: FileSystemFile ->
@@ -210,8 +210,12 @@ class FileSystemNextModule : Module() {
     }
 
     Class(FileSystemDirectory::class) {
-      Constructor { uri: URI ->
-        FileSystemDirectory(File(uri.path))
+      Constructor { uri: Uri ->
+        FileSystemDirectory(uri)
+      }
+
+      Function("info") { directory: FileSystemDirectory ->
+        directory.info()
       }
 
       Function("delete") { directory: FileSystemDirectory ->
@@ -222,6 +226,14 @@ class FileSystemNextModule : Module() {
         directory.create(options ?: CreateOptions())
       }
 
+      Function("createDirectory") { file: FileSystemDirectory, name: String ->
+        return@Function file.createDirectory(name)
+      }
+
+      Function("createFile") { file: FileSystemDirectory, name: String, mimeType: String? ->
+        return@Function file.createFile(mimeType, name)
+      }
+
       Property("exists") { directory: FileSystemDirectory ->
         directory.exists
       }

package/android/src/main/java/expo/modules/filesystem/next/FileSystemNextRecords.kt

@@ -28,3 +28,13 @@ data class PathInfo(
   @Field var exists: Boolean,
   @Field var isDirectory: Boolean?
 ) : Record
+
+data class DirectoryInfo(
+  @Field var exists: Boolean,
+  @Field var uri: String?,
+  @Field var files: List<String>? = null,
+  @Field var md5: String? = null,
+  @Field var size: Long? = null,
+  @Field var modificationTime: Long? = null,
+  @Field var creationTime: Long? = null
+) : Record

package/android/src/main/java/expo/modules/filesystem/next/FileSystemPath.kt

@@ -1,35 +1,69 @@
 package expo.modules.filesystem.next
 
+import android.net.Uri
 import android.os.Build
+import androidx.core.net.toUri
+import expo.modules.filesystem.next.unifiedfile.JavaFile
+import expo.modules.filesystem.next.unifiedfile.SAFDocumentFile
+import expo.modules.filesystem.next.unifiedfile.UnifiedFileInterface
 import expo.modules.interfaces.filesystem.Permission
 import expo.modules.kotlin.sharedobjects.SharedObject
 import java.io.File
+import java.nio.file.attribute.BasicFileAttributes
 import java.util.EnumSet
+import kotlin.io.path.Path
 import kotlin.io.path.moveTo
+import kotlin.io.path.readAttributes
+import kotlin.time.Duration.Companion.milliseconds
 
-// We use the `File` class to represent a file or a directory in the file system.
-// The Path class might be better, but `java.nio.file.Path` class is not available in API 23.
-// The URL, URI classes seem like a less suitable choice.
-// https://stackoverflow.com/questions/27845223/whats-the-difference-between-a-resource-uri-url-path-and-file-in-java
-abstract class FileSystemPath(public var file: File) : SharedObject() {
-  fun delete(fileOrDirectory: File = file) {
-    if (!fileOrDirectory.exists()) {
-      throw UnableToDeleteException("path '${fileOrDirectory.path}' does not exist")
+val Uri.isContentUri get(): Boolean {
+  return scheme == "content"
+}
+
+abstract class FileSystemPath(var uri: Uri) : SharedObject() {
+  private var fileAdapter: UnifiedFileInterface? = null
+  val file: UnifiedFileInterface get() {
+    val currentAdapter = fileAdapter
+    if (currentAdapter?.uri == uri) {
+      return currentAdapter
+    }
+    val newAdapter = if (uri.isContentUri) {
+      SAFDocumentFile(appContext?.reactContext ?: throw Exception("No context"), uri)
+    } else {
+      JavaFile(uri)
+    }
+    fileAdapter = newAdapter
+    return newAdapter
+  }
+  val javaFile: File get() =
+    if (uri.isContentUri) {
+      throw Exception("This method cannot be used with content URIs: $uri")
+    } else {
+      (file as File)
     }
-    if (fileOrDirectory.isDirectory) {
-      fileOrDirectory.listFiles()?.forEach { child ->
-        if (child.isDirectory) {
+
+  fun delete() {
+    if (!file.exists()) {
+      throw UnableToDeleteException("uri '${file.uri}' does not exist")
+    }
+    if (file.isDirectory()) {
+      file.listFilesAsUnified().forEach { child ->
+        if (child.isDirectory()) {
           // Recursively delete subdirectories
-          delete(child)
+          if (uri.isContentUri) {
+            SAFDocumentFile(appContext?.reactContext ?: throw Exception("No context"), child.uri).delete()
+          } else {
+            JavaFile(child.uri).delete()
+          }
         } else {
           if (!child.delete()) {
-            throw UnableToDeleteException("failed to delete '${child.path}'")
+            throw UnableToDeleteException("failed to delete '${child.uri}'")
           }
         }
       }
     }
-    if (!fileOrDirectory.delete()) {
-      throw UnableToDeleteException("failed to delete '${fileOrDirectory.path}'")
+    if (!file.delete()) {
+      throw UnableToDeleteException("failed to delete '${file.uri}'")
     }
   }
 
@@ -41,26 +75,26 @@ abstract class FileSystemPath(public var file: File) : SharedObject() {
         if (!destination.exists) {
           throw DestinationDoesNotExistException()
         }
-        return File(destination.file, file.name)
+        return File(destination.javaFile, javaFile.name)
       }
       // this if FileSystemDirectory
       // we match unix behavior https://askubuntu.com/a/763915
       if (destination.exists) {
-        return File(destination.file, file.name)
+        return File(destination.javaFile, javaFile.name)
       }
-      if (destination.file.parentFile?.exists() != true) {
+      if (destination.javaFile.parentFile?.exists() != true) {
         throw DestinationDoesNotExistException()
       }
-      return destination.file
+      return destination.javaFile
     }
     // destination is FileSystemFile
     if (this !is FileSystemFile) {
       throw CopyOrMoveDirectoryToFileException()
     }
-    if (destination.file.parentFile?.exists() != true) {
+    if (destination.javaFile.parentFile?.exists() != true) {
       throw DestinationDoesNotExistException()
     }
-    return destination.file
+    return destination.javaFile
   }
 
   fun validatePermission(permission: Permission) {
@@ -70,7 +104,11 @@ abstract class FileSystemPath(public var file: File) : SharedObject() {
   }
 
   fun checkPermission(permission: Permission): Boolean {
-    val permissions = appContext?.filePermission?.getPathPermissions(appContext?.reactContext, file.path) ?: EnumSet.noneOf(Permission::class.java)
+    if (uri.isContentUri) {
+      // TODO: Consider adding a check for content URIs (not in legacy FS)
+      return true
+    }
+    val permissions = appContext?.filePermission?.getPathPermissions(appContext?.reactContext, javaFile.path) ?: EnumSet.noneOf(Permission::class.java)
     return permissions.contains(permission)
   }
 
@@ -86,7 +124,7 @@ abstract class FileSystemPath(public var file: File) : SharedObject() {
     validatePermission(Permission.READ)
     to.validatePermission(Permission.WRITE)
 
-    file.copyRecursively(getMoveOrCopyPath(to))
+    javaFile.copyRecursively(getMoveOrCopyPath(to))
   }
 
   fun move(to: FileSystemPath) {
@@ -97,12 +135,27 @@ abstract class FileSystemPath(public var file: File) : SharedObject() {
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       val destination = getMoveOrCopyPath(to)
-      file.toPath().moveTo(destination.toPath())
-      file = destination
+      javaFile.toPath().moveTo(destination.toPath())
+      uri = destination.toUri()
+    } else {
+      javaFile.copyTo(getMoveOrCopyPath(to))
+      javaFile.delete()
+      uri = getMoveOrCopyPath(to).toUri()
+    }
+  }
+
+  val modificationTime: Long get() {
+    validateType()
+    return javaFile.lastModified()
+  }
+
+  val creationTime: Long? get() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      validateType()
+      val attributes = Path(javaFile.path).readAttributes<BasicFileAttributes>()
+      return attributes.creationTime().toMillis().milliseconds.inWholeMilliseconds
     } else {
-      file.copyTo(getMoveOrCopyPath(to))
-      file.delete()
-      file = getMoveOrCopyPath(to)
+      return null
     }
   }
 }

package/android/src/main/java/expo/modules/filesystem/next/unifiedfile/JavaFile.kt

@@ -0,0 +1,34 @@
+package expo.modules.filesystem.next.unifiedfile
+
+import android.net.Uri
+import androidx.core.net.toUri
+import java.io.File
+import java.net.URI
+
+class JavaFile(override val uri: Uri) : UnifiedFileInterface, File(URI.create(uri.toString())) {
+  override fun isDirectory(): Boolean {
+    return super<File>.isDirectory()
+  }
+
+  override fun isFile(): Boolean {
+    return super<File>.isFile()
+  }
+
+  override val parentFile: UnifiedFileInterface?
+    get() = super<File>.parentFile?.toUri()?.let { JavaFile(it) }
+
+  override fun createFile(mimeType: String, displayName: String): UnifiedFileInterface? {
+    val childFile = File(super<File>.parentFile, displayName)
+    childFile.createNewFile()
+    return JavaFile(childFile.toUri())
+  }
+
+  override fun createDirectory(displayName: String): UnifiedFileInterface? {
+    val childFile = File(super<File>.parentFile, displayName)
+    childFile.mkdir()
+    return JavaFile(childFile.toUri())
+  }
+
+  override fun listFilesAsUnified(): List<UnifiedFileInterface> =
+    super<File>.listFiles()?.map { JavaFile(it.toUri()) } ?: emptyList()
+}

package/android/src/main/java/expo/modules/filesystem/next/unifiedfile/SAFDocumentFile.kt

@@ -0,0 +1,38 @@
+package expo.modules.filesystem.next.unifiedfile
+
+import android.content.Context
+import android.net.Uri
+import androidx.documentfile.provider.DocumentFile
+
+class SAFDocumentFile(private val context: Context, override val uri: Uri) : UnifiedFileInterface {
+  private val treeDocumentFile: DocumentFile? = DocumentFile.fromTreeUri(context, uri)
+  private val singleDocumentFile: DocumentFile? = DocumentFile.fromSingleUri(context, uri)
+
+  override fun exists(): Boolean = singleDocumentFile?.exists() == true
+
+  override fun isDirectory(): Boolean {
+    return singleDocumentFile?.isDirectory == true
+  }
+
+  override fun isFile(): Boolean {
+    return singleDocumentFile?.isFile == true
+  }
+
+  override val parentFile: UnifiedFileInterface?
+    get() = treeDocumentFile?.parentFile?.uri?.let { SAFDocumentFile(context, it) }
+
+  override fun createFile(mimeType: String, displayName: String): UnifiedFileInterface? {
+    val documentFile = treeDocumentFile?.createFile(mimeType, displayName)
+    return documentFile?.uri?.let { SAFDocumentFile(context, it) }
+  }
+
+  override fun createDirectory(displayName: String): UnifiedFileInterface? {
+    val documentFile = treeDocumentFile?.createDirectory(displayName)
+    return documentFile?.uri?.let { SAFDocumentFile(context, it) }
+  }
+
+  override fun delete(): Boolean = singleDocumentFile?.delete() ?: false
+
+  override fun listFilesAsUnified(): List<UnifiedFileInterface> =
+    treeDocumentFile?.listFiles()?.map { SAFDocumentFile(context, it.uri) } ?: emptyList()
+}