expo-file-system 18.2.0-canary-20250713-8f814f8 → 18.2.0-canary-20250729-d8899ae

package/CHANGELOG.md

@@ -6,9 +6,13 @@
 
 ### 🎉 New features
 
+- Make file implement blob interface directly. ([#38160](https://github.com/expo/expo/pull/38160) by [@aleqsio](https://github.com/aleqsio))
+- 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))
+- [next] Add full 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-20250713-8f814f8'
+version = '18.2.0-canary-20250729-d8899ae'
 
 android {
   namespace "expo.modules.filesystem"
   defaultConfig {
     versionCode 30
-    versionName "18.2.0-canary-20250713-8f814f8"
+    versionName "18.2.0-canary-20250729-d8899ae"
   }
 }
 
@@ -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,41 +26,80 @@ 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 file.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(file.uri.toString())
+      )
+      return directoryInfo
+    }
+
+    val directoryInfo = DirectoryInfo(
+      exists = true,
+      uri = slashifyFilePath(file.uri.toString()),
+      files = file.listFilesAsUnified().mapNotNull { i -> i.fileName },
+      modificationTime = modificationTime,
+      creationTime = creationTime,
+      size = size
+    )
+    return directoryInfo
   }
 
   fun create(options: CreateOptions = CreateOptions()) {
     validateType()
     validatePermission(Permission.WRITE)
     validateCanCreate(options)
+    if (uri.isContentUri) {
+      throw UnableToCreateException("create function does not work with SAF Uris, use `createDirectory` and `createFile` instead")
+    }
     if (options.overwrite && file.exists()) {
       file.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 {
+    validateType()
+    validatePermission(Permission.WRITE)
+    val newFile = file.createFile(mimeType ?: "text/plain", fileName) ?: throw UnableToCreateException("file could not be created")
+    return FileSystemFile(newFile.uri)
+  }
+
+  fun createDirectory(fileName: String): FileSystemDirectory {
+    validateType()
+    validatePermission(Permission.WRITE)
+    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,24 +1,17 @@
 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
 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 +20,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,13 +37,16 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     validateType()
     validatePermission(Permission.WRITE)
     validateCanCreate(options)
-    if (options.overwrite && file.exists()) {
-      file.delete()
+    if (uri.isContentUri) {
+      throw UnableToCreateException("create function does not work with SAF Uris, use `createDirectory` and `createFile` instead")
+    }
+    if (options.overwrite && exists) {
+      javaFile.delete()
     }
     if (options.intermediates) {
-      file.parentFile?.mkdirs()
+      javaFile.parentFile?.mkdirs()
     }
-    val created = file.createNewFile()
+    val created = javaFile.createNewFile()
     if (!created) {
       throw UnableToCreateException("file already exists or could not be created")
     }
@@ -62,8 +58,8 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     if (!exists) {
       create()
     }
-    FileOutputStream(file).use {
-      it.write(content.toByteArray())
+    file.outputStream().use { outputStream ->
+      outputStream.write(content.toByteArray())
     }
   }
 
@@ -73,40 +69,56 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     if (!exists) {
       create()
     }
-    FileOutputStream(file).use {
-      it.channel.write(content.toDirectBuffer())
+    if (uri.isContentUri) {
+      file.outputStream().use { outputStream ->
+        val array = ByteArray(content.length)
+        content.toDirectBuffer().get(array)
+        outputStream.write(array)
+      }
+    } else {
+      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 file.inputStream().use { inputStream ->
+      inputStream.bufferedReader().use { it.readText() }
+    }
   }
 
   fun base64(): String {
     validateType()
     validatePermission(Permission.READ)
-    return Base64.encodeToString(file.readBytes(), Base64.NO_WRAP)
+    file.inputStream().use {
+      return Base64.encodeToString(it.readBytes(), Base64.NO_WRAP)
+    }
   }
 
   fun bytes(): ByteArray {
     validateType()
     validatePermission(Permission.READ)
-    return file.readBytes()
+    file.inputStream().use {
+      return it.readBytes()
+    }
   }
 
   @OptIn(ExperimentalStdlibApi::class)
   val md5: String get() {
     validatePermission(Permission.READ)
     val md = MessageDigest.getInstance("MD5")
-    val digest = md.digest(file.readBytes())
-    return digest.toHexString()
+    file.inputStream().use {
+      val digest = md.digest(it.readBytes())
+      return digest.toHexString()
+    }
   }
 
   val size: Long? get() {
@@ -118,23 +130,7 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
   }
 
   val type: String? get() {
-    return MimeTypeMap.getFileExtensionFromUrl(file.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
-    }
+    return file.type
   }
 
   fun info(options: InfoOptions?): FileInfo {
@@ -143,25 +139,20 @@ class FileSystemFile(file: File) : FileSystemPath(file) {
     if (!file.exists()) {
       val fileInfo = FileInfo(
         exists = false,
-        uri = slashifyFilePath(file.toURI().toString())
+        uri = slashifyFilePath(file.uri.toString())
       )
       return fileInfo
     }
-    when {
-      file.toURI().scheme == "file" -> {
-        val fileInfo = FileInfo(
-          exists = true,
-          uri = slashifyFilePath(file.toURI().toString()),
-          size = size,
-          modificationTime = modificationTime,
-          creationTime = creationTime
-        )
-        if (options != null && options.md5 == true) {
-          fileInfo.md5 = md5
-        }
-        return fileInfo
-      }
-      else -> throw UnableToGetInfoException("file schema ${file.toURI().scheme} is not supported")
+    val fileInfo = FileInfo(
+      exists = true,
+      uri = slashifyFilePath(file.uri.toString()),
+      size = size,
+      modificationTime = modificationTime,
+      creationTime = creationTime
+    )
+    if (options != null && options.md5 == true) {
+      fileInfo.md5 = md5
     }
+    return fileInfo
   }
 }

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 ->
@@ -121,15 +121,27 @@ class FileSystemNextModule : Module() {
         }
       }
 
-      Function("text") { file: FileSystemFile ->
+      AsyncFunction("text") { file: FileSystemFile ->
         file.text()
       }
 
-      Function("base64") { file: FileSystemFile ->
+      Function("textSync") { file: FileSystemFile ->
+        file.text()
+      }
+
+      AsyncFunction("base64") { file: FileSystemFile ->
+        file.base64()
+      }
+
+      Function("base64Sync") { file: FileSystemFile ->
         file.base64()
       }
 
-      Function("bytes") { file: FileSystemFile ->
+      AsyncFunction("bytes") { file: FileSystemFile ->
+        file.bytes()
+      }
+
+      Function("bytesSync") { file: FileSystemFile ->
         file.bytes()
       }
 
@@ -210,8 +222,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 +238,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,65 @@
 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.util.EnumSet
 import kotlin.io.path.moveTo
 
-// 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)
+    }
+
+  fun delete() {
+    if (!file.exists()) {
+      throw UnableToDeleteException("uri '${file.uri}' does not exist")
     }
-    if (fileOrDirectory.isDirectory) {
-      fileOrDirectory.listFiles()?.forEach { child ->
-        if (child.isDirectory) {
+    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 +71,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 +100,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 +120,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 +131,21 @@ 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 {
-      file.copyTo(getMoveOrCopyPath(to))
-      file.delete()
-      file = getMoveOrCopyPath(to)
+      javaFile.copyTo(getMoveOrCopyPath(to))
+      javaFile.delete()
+      uri = getMoveOrCopyPath(to).toUri()
     }
   }
+
+  val modificationTime: Long? get() {
+    validateType()
+    return file.lastModified()
+  }
+
+  val creationTime: Long? get() {
+    return file.creationTime
+  }
 }