expo-media-library 18.2.0 → 18.3.0-canary-20250930-9dc59d3

package/CHANGELOG.md

@@ -6,10 +6,20 @@
 
 ### 🎉 New features
 
+- [next] Add `Album.get(title)` ([#39717](https://github.com/expo/expo/pull/39717) by [@Wenszel](https://github.com/Wenszel))
+
 ### 🐛 Bug fixes
 
+- [next][iOS] Convert `id` to URI format ([#39920](https://github.com/expo/expo/pull/39920) by [@Wenszel](https://github.com/Wenszel))
+- [next][android] Fix `delete()` throwing security exception ([#39914](https://github.com/expo/expo/pull/39914) by [@Wenszel](https://github.com/Wenszel))
+- [next][android] Change default root directory to Pictures ([#39716](https://github.com/expo/expo/pull/39716) by [@Wenszel](https://github.com/Wenszel))
+- [next] Fix `asset.getModificationTime` to return milliseconds ([#39715](https://github.com/expo/expo/pull/39715) by [@Wenszel](https://github.com/Wenszel))
+
 ### 💡 Others
 
+- [next] Add test screens ([#39951](https://github.com/expo/expo/pull/39951) by [@Wenszel](https://github.com/Wenszel))
+- [next] Add documentation ([#39754](https://github.com/expo/expo/pull/39754) by [@Wenszel](https://github.com/Wenszel))
+
 ## 18.2.0 — 2025-09-16
 
 ### 🎉 New features

package/android/build.gradle

@@ -4,23 +4,23 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '18.2.0'
+version = '18.3.0-canary-20250930-9dc59d3'
 
 android {
   namespace "expo.modules.medialibrary"
   defaultConfig {
     versionCode 37
-    versionName "18.2.0"
+    versionName "18.3.0-canary-20250930-9dc59d3"
   }
 }
 
 dependencies {
-  implementation "androidx.annotation:annotation:1.2.0"
-  api "androidx.exifinterface:exifinterface:1.3.3"
-  implementation 'androidx.activity:activity-ktx:1.10.1'
+  implementation "androidx.annotation:annotation:1.9.1"
+  api "androidx.exifinterface:exifinterface:1.4.1"
+  implementation 'androidx.activity:activity-ktx:1.11.0'
 
   if (project.findProject(':expo-modules-test-core')) {
     testImplementation project(':expo-modules-test-core')
   }
-  testImplementation "org.robolectric:robolectric:4.10"
+  testImplementation "org.robolectric:robolectric:4.16"
 }

package/android/src/main/java/expo/modules/medialibrary/next/MediaLibraryNextModule.kt

@@ -11,9 +11,12 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.types.Either
 import expo.modules.kotlin.types.toKClass
 import expo.modules.medialibrary.next.objects.album.Album
+import expo.modules.medialibrary.next.objects.album.AlbumQuery
 import expo.modules.medialibrary.next.objects.asset.Asset
 import expo.modules.medialibrary.next.objects.album.factories.AlbumModernFactory
 import expo.modules.medialibrary.next.objects.album.factories.AlbumLegacyFactory
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetLegacyDeleter
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetModernDeleter
 import expo.modules.medialibrary.next.objects.asset.factories.AssetModernFactory
 import expo.modules.medialibrary.next.objects.asset.factories.AssetLegacyFactory
 import expo.modules.medialibrary.next.objects.query.MediaStoreQueryFormatter
@@ -38,19 +41,31 @@ class MediaLibraryNextModule : Module() {
     MediaStorePermissionsDelegate(appContext)
   }
 
+  private val albumQuery by lazy {
+    AlbumQuery(albumFactory, context)
+  }
+
   private val albumFactory by lazy {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      AlbumModernFactory(assetFactory, context)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      AlbumModernFactory(assetFactory, assetDeleter, context)
     } else {
-      AlbumLegacyFactory(assetFactory, context)
+      AlbumLegacyFactory(assetFactory, assetDeleter, context)
     }
   }
 
   private val assetFactory by lazy {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      AssetModernFactory(context)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      AssetModernFactory(assetDeleter, context)
+    } else {
+      AssetLegacyFactory(assetDeleter, context)
+    }
+  }
+
+  private val assetDeleter by lazy {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      AssetModernDeleter(mediaStorePermissionsDelegate)
     } else {
-      AssetLegacyFactory(context)
+      AssetLegacyDeleter(context)
     }
   }
 
@@ -59,7 +74,7 @@ class MediaLibraryNextModule : Module() {
 
     Class(Asset::class) {
       Constructor { contentUri: Uri ->
-        Asset(contentUri, context)
+        assetFactory.create(contentUri)
       }
 
       Property("id") { self: Asset ->
@@ -109,14 +124,13 @@ class MediaLibraryNextModule : Module() {
 
       AsyncFunction("delete") Coroutine { self: Asset ->
         systemPermissionsDelegate.requireSystemPermissions(true)
-        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(listOf(self.contentUri), needsDeletePermission = true)
         self.delete()
       }
     }
 
     Class(Album::class) {
       Constructor { id: String ->
-        Album(id, context)
+        Album(id, assetDeleter, assetFactory, context)
       }
 
       Property("id") { self: Album ->
@@ -135,21 +149,19 @@ class MediaLibraryNextModule : Module() {
 
       AsyncFunction("add") Coroutine { self: Album, asset: Asset ->
         systemPermissionsDelegate.requireSystemPermissions(true)
-        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(listOf(asset.contentUri))
+        mediaStorePermissionsDelegate.requestMediaLibraryWritePermission(listOf(asset.contentUri))
         self.add(asset)
       }
 
       AsyncFunction("delete") Coroutine { self: Album ->
         systemPermissionsDelegate.requireSystemPermissions(true)
-        val assetIdsToDelete = self.getAssets().map { it.contentUri }
-        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(assetIdsToDelete, needsDeletePermission = true)
         self.delete()
       }
     }
 
     Class(Query::class) {
       Constructor {
-        Query(context)
+        Query(assetFactory, context)
       }
 
       Function("limit") { self: Query, limit: Int ->
@@ -164,29 +176,29 @@ class MediaLibraryNextModule : Module() {
         self.album(album)
       }
 
-      Function("eq") { self: Query, field: AssetField, value: Either<MediaType, Int> ->
-        self.eq(field, MediaStoreQueryFormatter.parse(value))
+      Function("eq") { self: Query, field: AssetField, value: Either<MediaType, Long> ->
+        self.eq(field, MediaStoreQueryFormatter.parse(field, value))
       }
 
-      Function("within") { self: Query, field: AssetField, values: List<Either<MediaType, Int>> ->
-        val stringValues = values.map { value -> MediaStoreQueryFormatter.parse(value) }
+      Function("within") { self: Query, field: AssetField, values: List<Either<MediaType, Long>> ->
+        val stringValues = values.map { value -> MediaStoreQueryFormatter.parse(field, value) }
         self.within(field, stringValues)
       }
 
-      Function("gt") { self: Query, field: AssetField, value: Int ->
-        self.gt(field, MediaStoreQueryFormatter.parse(value))
+      Function("gt") { self: Query, field: AssetField, value: Long ->
+        self.gt(field, MediaStoreQueryFormatter.parse(field, value))
       }
 
-      Function("gte") { self: Query, field: AssetField, value: Int ->
-        self.gte(field, MediaStoreQueryFormatter.parse(value))
+      Function("gte") { self: Query, field: AssetField, value: Long ->
+        self.gte(field, MediaStoreQueryFormatter.parse(field, value))
       }
 
-      Function("lt") { self: Query, field: AssetField, value: Int ->
-        self.lt(field, MediaStoreQueryFormatter.parse(value))
+      Function("lt") { self: Query, field: AssetField, value: Long ->
+        self.lt(field, MediaStoreQueryFormatter.parse(field, value))
       }
 
-      Function("lte") { self: Query, field: AssetField, value: Int ->
-        self.lte(field, MediaStoreQueryFormatter.parse(value))
+      Function("lte") { self: Query, field: AssetField, value: Long ->
+        self.lte(field, MediaStoreQueryFormatter.parse(field, value))
       }
 
       Function("orderBy") { self: Query, sortDescriptorRef: Either<AssetField, SortDescriptor> ->
@@ -221,16 +233,23 @@ class MediaLibraryNextModule : Module() {
       return@Coroutine albumFactory.createFromFilePaths(name, assetPaths)
     }
 
+    AsyncFunction("getAlbum") Coroutine { title: String ->
+      systemPermissionsDelegate.requireSystemPermissions(false)
+      albumQuery.getAlbum(title)
+    }
+
     AsyncFunction("deleteAlbums") Coroutine { albums: List<Album> ->
       systemPermissionsDelegate.requireSystemPermissions(true)
-      albums.forEach { album -> album.delete() }
+      val contentUris = albums
+        .map { it.getAssets() }
+        .flatten()
+        .map { it.contentUri }
+      assetDeleter.delete(contentUris)
     }
 
     AsyncFunction("deleteAssets") Coroutine { assets: List<Asset> ->
       systemPermissionsDelegate.requireSystemPermissions(true)
-      val assetIdsToDelete = assets.map { it.contentUri }
-      mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(assetIdsToDelete, needsDeletePermission = true)
-      assets.forEach { asset -> asset.delete() }
+      assetDeleter.delete(assets.map { it.contentUri })
     }
 
     AsyncFunction("requestPermissionsAsync") { writeOnly: Boolean, permissions: List<GranularPermission>?, promise: Promise ->

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/AlbumExtensions.kt

@@ -48,6 +48,15 @@ suspend fun ContentResolver.queryAlbumId(relativePath: RelativePath): String? =
     arrayOf(relativePath.value)
   )
 
+suspend fun ContentResolver.queryAlbumId(name: String): String? =
+  queryOne(
+    EXTERNAL_CONTENT_URI,
+    MediaStore.Files.FileColumns.BUCKET_ID,
+    Cursor::getString,
+    "${MediaStore.MediaColumns.BUCKET_DISPLAY_NAME} = ?",
+    arrayOf(name)
+  )
+
 suspend fun ContentResolver.queryAlbumAssetsContentUris(bucketId: String): List<Uri> =
   withContext(Dispatchers.IO) {
     val projection = arrayOf(

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/AssetExtensions.kt

@@ -17,8 +17,8 @@ import kotlinx.coroutines.withContext
 suspend fun ContentResolver.queryAssetDisplayName(contentUri: Uri): String? =
   queryOne(contentUri, MediaStore.MediaColumns.DISPLAY_NAME, Cursor::getString)
 
-suspend fun ContentResolver.queryGetCreationTime(contentUri: Uri): Long? =
-  queryOne(contentUri, MediaStore.MediaColumns.DATE_TAKEN, Cursor::getLong)
+suspend fun ContentResolver.queryAssetCreationTime(contentUri: Uri): Long? =
+  queryOne(contentUri, MediaStore.Images.Media.DATE_TAKEN, Cursor::getLong)
 
 suspend fun ContentResolver.queryAssetModificationTime(contentUri: Uri): Long? =
   queryOne(contentUri, MediaStore.MediaColumns.DATE_MODIFIED, Cursor::getLong)
@@ -38,9 +38,6 @@ suspend fun ContentResolver.queryAssetPath(contentUri: Uri): String? =
 suspend fun ContentResolver.queryAssetBucketId(contentUri: Uri): Int? =
   queryOne(contentUri, MediaStore.MediaColumns.BUCKET_ID, Cursor::getInt)
 
-suspend fun ContentResolver.queryAssetMediaType(contentUri: Uri): Int? =
-  queryOne(contentUri, MediaStore.Files.FileColumns.MEDIA_TYPE, Cursor::getInt)
-
 suspend fun ContentResolver.insertPendingAsset(
   displayName: String,
   mimeType: MimeType,

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/CursorExtensions.kt

@@ -3,16 +3,26 @@ package expo.modules.medialibrary.next.extensions.resolver
 import android.content.ContentUris
 import android.database.Cursor
 import android.net.Uri
+import android.os.Build
 import android.provider.MediaStore
 
 fun Cursor.extractAssetContentUri(idColumn: Int, typeColumn: Int): Uri {
   val id = getLong(idColumn)
   val mediaType = getInt(typeColumn)
-  val baseUri = when (mediaType) {
-    MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
-    MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
-    MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
-    else -> EXTERNAL_CONTENT_URI
+  val baseUri = if (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
+    when (mediaType) {
+      MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+      MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+      MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO -> MediaStore.Audio.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+      else -> MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+    }
+  } else {
+    when (mediaType) {
+      MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+      MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+      MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+      else -> EXTERNAL_CONTENT_URI
+    }
   }
   return ContentUris.withAppendedId(baseUri, id)
 }

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/Album.kt

@@ -12,14 +12,18 @@ import expo.modules.medialibrary.next.extensions.resolver.queryAlbumFilepath
 import expo.modules.medialibrary.next.extensions.resolver.queryAlbumRelativePath
 import expo.modules.medialibrary.next.extensions.resolver.queryAlbumTitle
 import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetDeleter
+import expo.modules.medialibrary.next.objects.asset.factories.AssetFactory
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
 import java.io.File
 import java.lang.ref.WeakReference
 
-class Album(val id: String, context: Context) : SharedObject() {
+class Album(
+  val id: String,
+  val assetDeleter: AssetDeleter,
+  val assetFactory: AssetFactory,
+  context: Context
+) : SharedObject() {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -51,21 +55,16 @@ class Album(val id: String, context: Context) : SharedObject() {
     return RelativePath(relative)
   }
 
-  suspend fun getAssets(): List<Asset> {
-    return contentResolver
+  suspend fun getAssets(): List<Asset> =
+    contentResolver
       .queryAlbumAssetsContentUris(id)
-      .map { contentUri -> Asset(contentUri, contextRef.getOrThrow()) }
-  }
+      .map { assetFactory.create(it) }
 
-  suspend fun delete() = coroutineScope {
-    getAssets().map { asset ->
-      async {
-        asset.delete()
-      }
-    }.awaitAll()
-  }
+  suspend fun delete() =
+    assetDeleter.delete(
+      getAssets().map { it.contentUri }
+    )
 
-  suspend fun add(asset: Asset) {
+  suspend fun add(asset: Asset) =
     asset.move(getRelativePath())
-  }
 }

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/AlbumQuery.kt

@@ -0,0 +1,23 @@
+package expo.modules.medialibrary.next.objects.album
+
+import android.content.Context
+import expo.modules.medialibrary.next.exceptions.ContentResolverNotObtainedException
+import expo.modules.medialibrary.next.extensions.getOrThrow
+import expo.modules.medialibrary.next.extensions.resolver.queryAlbumId
+import expo.modules.medialibrary.next.objects.album.factories.AlbumFactory
+import java.lang.ref.WeakReference
+
+class AlbumQuery(val albumFactory: AlbumFactory, context: Context) {
+  private val contextRef = WeakReference(context)
+
+  private val contentResolver
+    get() = contextRef
+      .getOrThrow()
+      .contentResolver ?: throw ContentResolverNotObtainedException()
+
+  suspend fun getAlbum(title: String): Album? {
+    val id = contentResolver.queryAlbumId(title)
+      ?: return null
+    return albumFactory.create(id)
+  }
+}

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/factories/AlbumFactory.kt

@@ -5,6 +5,7 @@ import expo.modules.medialibrary.next.objects.album.Album
 import expo.modules.medialibrary.next.objects.asset.Asset
 
 interface AlbumFactory {
+  fun create(id: String): Album
   suspend fun createFromAssets(albumName: String, assets: List<Asset>, deleteOriginalAssets: Boolean): Album
   suspend fun createFromFilePaths(albumName: String, filePaths: List<Uri>): Album
 }

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/factories/AlbumLegacyFactory.kt

@@ -12,14 +12,19 @@ import expo.modules.medialibrary.next.extensions.resolver.queryAssetBucketId
 import expo.modules.medialibrary.next.objects.album.Album
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetDeleter
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
 import expo.modules.medialibrary.next.objects.asset.factories.AssetFactory
 import java.io.File
 import java.io.IOException
 import java.lang.ref.WeakReference
 
-@DeprecatedSinceApi(Build.VERSION_CODES.Q)
-class AlbumLegacyFactory(private val assetFactory: AssetFactory, context: Context) : AlbumFactory {
+@DeprecatedSinceApi(Build.VERSION_CODES.R)
+class AlbumLegacyFactory(
+  private val assetFactory: AssetFactory,
+  private val assetDeleter: AssetDeleter,
+  context: Context
+) : AlbumFactory {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -27,6 +32,10 @@ class AlbumLegacyFactory(private val assetFactory: AssetFactory, context: Contex
       .getOrThrow()
       .contentResolver ?: throw AlbumCouldNotBeCreated("Failed to create album: ContentResolver is unavailable.")
 
+  override fun create(id: String): Album {
+    return Album(id, assetDeleter, assetFactory, contextRef.getOrThrow())
+  }
+
   override suspend fun createFromAssets(albumName: String, assets: List<Asset>, deleteOriginalAssets: Boolean): Album {
     try {
       val firstAsset = assets.firstOrNull()
@@ -37,7 +46,7 @@ class AlbumLegacyFactory(private val assetFactory: AssetFactory, context: Contex
       processAssetsLocation(assets, relativePath, true)
       val albumId = contentResolver.queryAssetBucketId(assets[0].contentUri)
         ?: throw AlbumNotFoundException("Could not find album with filePath: ${relativePath.toFilePath()}")
-      return Album(albumId.toString(), contextRef.getOrThrow())
+      return Album(albumId.toString(), assetDeleter, assetFactory, contextRef.getOrThrow())
     } catch (e: SecurityException) {
       throw AlbumCouldNotBeCreated("Missing WRITE_EXTERNAL_STORAGE permission: ${e.message}", e)
     } catch (e: IOException) {
@@ -55,7 +64,7 @@ class AlbumLegacyFactory(private val assetFactory: AssetFactory, context: Contex
     }
     val albumId = contentResolver.queryAssetBucketId(assets[0].contentUri)
       ?: throw AlbumCouldNotBeCreated("Could not find album with relativePath: $relativePath")
-    return Album(albumId.toString(), contextRef.getOrThrow())
+    return Album(albumId.toString(), assetDeleter, assetFactory, contextRef.getOrThrow())
   }
 
   private suspend fun processAssetsLocation(assets: List<Asset>, relativePath: RelativePath, deleteOriginalAssets: Boolean) {

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/factories/AlbumModernFactory.kt

@@ -11,13 +11,18 @@ import expo.modules.medialibrary.next.extensions.resolver.queryAlbumId
 import expo.modules.medialibrary.next.objects.album.Album
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetDeleter
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
 import expo.modules.medialibrary.next.objects.asset.factories.AssetFactory
 import java.io.IOException
 import java.lang.ref.WeakReference
 
-@RequiresApi(Build.VERSION_CODES.Q)
-class AlbumModernFactory(private val assetFactory: AssetFactory, context: Context) : AlbumFactory {
+@RequiresApi(Build.VERSION_CODES.R)
+class AlbumModernFactory(
+  private val assetFactory: AssetFactory,
+  private val assetDeleter: AssetDeleter,
+  context: Context
+) : AlbumFactory {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -25,6 +30,10 @@ class AlbumModernFactory(private val assetFactory: AssetFactory, context: Contex
       .getOrThrow()
       .contentResolver ?: throw AlbumCouldNotBeCreated("Failed to create album: ContentResolver is unavailable.")
 
+  override fun create(id: String): Album {
+    return Album(id, assetDeleter, assetFactory, contextRef.getOrThrow())
+  }
+
   override suspend fun createFromAssets(albumName: String, assets: List<Asset>, deleteOriginalAssets: Boolean): Album =
     try {
       val mimeTypeOfFirstAsset = assets[0].getMimeType()
@@ -32,7 +41,7 @@ class AlbumModernFactory(private val assetFactory: AssetFactory, context: Contex
       processAssetsLocation(assets, albumRelativePath, deleteOriginalAssets)
       val albumId = contentResolver.queryAlbumId(albumRelativePath)
         ?: throw AlbumNotFoundException("Could not find album with relativePath: $albumRelativePath")
-      Album(albumId, contextRef.getOrThrow())
+      Album(albumId, assetDeleter, assetFactory, contextRef.getOrThrow())
     } catch (e: SecurityException) {
       throw AlbumCouldNotBeCreated("Security Exception: ${e.message}", e)
     } catch (e: IOException) {
@@ -47,7 +56,7 @@ class AlbumModernFactory(private val assetFactory: AssetFactory, context: Contex
     }
     val albumId = contentResolver.queryAlbumId(relativePath)
       ?: throw AlbumCouldNotBeCreated("Failed to create album: newly created album was not found in the MediaStore.")
-    return Album(albumId, contextRef.getOrThrow())
+    return Album(albumId, assetDeleter, assetFactory, contextRef.getOrThrow())
   }
 
   private suspend fun processAssetsLocation(assets: List<Asset>, relativePath: RelativePath, deleteOriginalAssets: Boolean) {

package/android/src/main/java/expo/modules/medialibrary/next/objects/asset/Asset.kt

@@ -1,31 +1,15 @@
 package expo.modules.medialibrary.next.objects.asset
 
-import android.content.Context
 import android.net.Uri
-import android.os.Build
 import expo.modules.kotlin.sharedobjects.SharedObject
-import expo.modules.medialibrary.next.extensions.getOrThrow
+import expo.modules.medialibrary.next.objects.asset.delegates.AssetDelegate
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
-import expo.modules.medialibrary.next.objects.asset.delegates.AssetLegacyDelegate
-import expo.modules.medialibrary.next.objects.asset.delegates.AssetModernDelegate
 import expo.modules.medialibrary.next.objects.wrappers.MediaType
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import java.lang.ref.WeakReference
-import kotlin.getValue
-
-class Asset(contentUri: Uri, context: Context) : SharedObject() {
-  private val contextRef = WeakReference(context)
-
-  val assetDelegate by lazy {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      AssetModernDelegate(contentUri, contextRef.getOrThrow())
-    } else {
-      AssetLegacyDelegate(contentUri, contextRef.getOrThrow())
-    }
-  }
 
+class Asset(val assetDelegate: AssetDelegate) : SharedObject() {
   val contentUri: Uri get() = assetDelegate.contentUri
 
   suspend fun getCreationTime(): Long? =

package/android/src/main/java/expo/modules/medialibrary/next/objects/asset/delegates/AssetLegacyDelegate.kt

@@ -6,7 +6,6 @@ import android.net.Uri
 import android.os.Build
 import androidx.annotation.DeprecatedSinceApi
 import androidx.core.net.toUri
-import expo.modules.medialibrary.AssetFileException
 import expo.modules.medialibrary.MediaLibraryUtils
 import expo.modules.medialibrary.next.exceptions.AssetCouldNotBeCreated
 import expo.modules.medialibrary.next.exceptions.AssetPropertyNotFoundException
@@ -19,20 +18,27 @@ import expo.modules.medialibrary.next.extensions.resolver.queryAssetHeight
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetModificationTime
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetPath
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetWidth
-import expo.modules.medialibrary.next.extensions.resolver.queryGetCreationTime
+import expo.modules.medialibrary.next.extensions.resolver.queryAssetCreationTime
 import expo.modules.medialibrary.next.extensions.safeCopy
 import expo.modules.medialibrary.next.extensions.safeMove
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetDeleter
 import expo.modules.medialibrary.next.objects.wrappers.MediaType
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.lang.ref.WeakReference
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
 
 @DeprecatedSinceApi(Build.VERSION_CODES.Q)
-class AssetLegacyDelegate(contentUri: Uri, context: Context) : AssetDelegate {
+class AssetLegacyDelegate(
+  contentUri: Uri,
+  val assetDeleter: AssetDeleter,
+  context: Context
+) : AssetDelegate {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -50,7 +56,7 @@ class AssetLegacyDelegate(contentUri: Uri, context: Context) : AssetDelegate {
 
   override suspend fun getCreationTime(): Long? {
     return contentResolver
-      .queryGetCreationTime(contentUri)
+      .queryAssetCreationTime(contentUri)
       .takeIf { it != 0L }
   }
 
@@ -98,7 +104,10 @@ class AssetLegacyDelegate(contentUri: Uri, context: Context) : AssetDelegate {
     MediaType.fromContentUri(contentUri)
 
   override suspend fun getModificationTime(): Long? =
-    contentResolver.queryAssetModificationTime(contentUri).takeIf { it != 0L }
+    contentResolver.queryAssetModificationTime(contentUri)
+      ?.takeIf { it != 0L }
+      ?.toDuration(DurationUnit.SECONDS)
+      ?.inWholeMilliseconds
 
   override suspend fun getMimeType(): MimeType {
     return contentResolver.getType(contentUri)?.let { MimeType(it) }
@@ -106,12 +115,7 @@ class AssetLegacyDelegate(contentUri: Uri, context: Context) : AssetDelegate {
   }
 
   override suspend fun delete(): Unit = withContext(Dispatchers.IO) {
-    val path = contentResolver.queryAssetPath(contentUri)
-      ?: throw AssetPropertyNotFoundException("Uri")
-    if (!File(path).delete()) {
-      throw AssetFileException("Could not delete file.")
-    }
-    contentResolver.delete(contentUri, null, null)
+    assetDeleter.delete(contentUri)
   }
 
   override suspend fun getUri(): Uri {
@@ -141,6 +145,7 @@ class AssetLegacyDelegate(contentUri: Uri, context: Context) : AssetDelegate {
     if (uri == null) {
       throw AssetCouldNotBeCreated("Could not create a new asset while copying the old one")
     }
-    return@withContext Asset(uri, contextRef.getOrThrow())
+    val newAssetDelegate = AssetLegacyDelegate(contentUri, assetDeleter, contextRef.getOrThrow())
+    return@withContext Asset(newAssetDelegate)
   }
 }

package/android/src/main/java/expo/modules/medialibrary/next/objects/asset/delegates/AssetModernDelegate.kt

@@ -18,19 +18,26 @@ import expo.modules.medialibrary.next.extensions.resolver.queryAssetHeight
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetModificationTime
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetPath
 import expo.modules.medialibrary.next.extensions.resolver.queryAssetWidth
-import expo.modules.medialibrary.next.extensions.resolver.queryGetCreationTime
+import expo.modules.medialibrary.next.extensions.resolver.queryAssetCreationTime
 import expo.modules.medialibrary.next.extensions.resolver.updateRelativePath
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.asset.deleters.AssetDeleter
 import expo.modules.medialibrary.next.objects.wrappers.MediaType
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.File
 import java.lang.ref.WeakReference
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
 
 @RequiresApi(Build.VERSION_CODES.Q)
-class AssetModernDelegate(override val contentUri: Uri, context: Context) : AssetDelegate {
+class AssetModernDelegate(
+  override val contentUri: Uri,
+  val assetDeleter: AssetDeleter,
+  context: Context
+) : AssetDelegate {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -40,7 +47,7 @@ class AssetModernDelegate(override val contentUri: Uri, context: Context) : Asse
 
   override suspend fun getCreationTime(): Long? {
     return contentResolver
-      .queryGetCreationTime(contentUri)
+      .queryAssetCreationTime(contentUri)
       .takeIf { it != 0L }
   }
 
@@ -88,7 +95,10 @@ class AssetModernDelegate(override val contentUri: Uri, context: Context) : Asse
     MediaType.fromContentUri(contentUri)
 
   override suspend fun getModificationTime(): Long? =
-    contentResolver.queryAssetModificationTime(contentUri).takeIf { it != 0L }
+    contentResolver.queryAssetModificationTime(contentUri)
+      ?.takeIf { it != 0L }
+      ?.toDuration(DurationUnit.SECONDS)
+      ?.inWholeMilliseconds
 
   override suspend fun getUri(): Uri {
     // e.g. storage/emulated/0/Android/data/expo/files/[ROOT_ALBUM]/[ALBUM_NAME]
@@ -104,8 +114,8 @@ class AssetModernDelegate(override val contentUri: Uri, context: Context) : Asse
       ?: MimeType.from(getUri())
   }
 
-  override suspend fun delete() {
-    contentResolver.delete(contentUri, null, null)
+  override suspend fun delete() = withContext(Dispatchers.IO) {
+    assetDeleter.delete(contentUri)
   }
 
   override suspend fun move(relativePath: RelativePath) {
@@ -116,6 +126,7 @@ class AssetModernDelegate(override val contentUri: Uri, context: Context) : Asse
     val newAssetUri = contentResolver.insertPendingAsset(getFilename(), getMimeType(), relativePath)
     contentResolver.copyUriContent(contentUri, newAssetUri)
     contentResolver.publishPendingAsset(newAssetUri)
-    return@withContext Asset(newAssetUri, contextRef.getOrThrow())
+    val newAssetDelegate = AssetModernDelegate(newAssetUri, assetDeleter, contextRef.getOrThrow())
+    return@withContext Asset(newAssetDelegate)
   }
 }