expo-media-library 18.3.0-canary-20250919-7a31b96 → 18.3.0-canary-20250930-9dc59d3

package/CHANGELOG.md

@@ -10,11 +10,14 @@
 
 ### 🐛 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

package/android/build.gradle

@@ -4,23 +4,23 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '18.3.0-canary-20250919-7a31b96'
+version = '18.3.0-canary-20250930-9dc59d3'
 
 android {
   namespace "expo.modules.medialibrary"
   defaultConfig {
     versionCode 37
-    versionName "18.3.0-canary-20250919-7a31b96"
+    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

@@ -15,6 +15,8 @@ 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
@@ -40,22 +42,30 @@ class MediaLibraryNextModule : Module() {
   }
 
   private val albumQuery by lazy {
-    AlbumQuery(context)
+    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(context)
+      AssetLegacyFactory(assetDeleter, context)
+    }
+  }
+
+  private val assetDeleter by lazy {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      AssetModernDeleter(mediaStorePermissionsDelegate)
+    } else {
+      AssetLegacyDeleter(context)
     }
   }
 
@@ -64,7 +74,7 @@ class MediaLibraryNextModule : Module() {
 
     Class(Asset::class) {
       Constructor { contentUri: Uri ->
-        Asset(contentUri, context)
+        assetFactory.create(contentUri)
       }
 
       Property("id") { self: Asset ->
@@ -114,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 ->
@@ -140,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 ->
@@ -233,14 +240,16 @@ class MediaLibraryNextModule : Module() {
 
     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/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

@@ -4,9 +4,10 @@ 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(context: Context) {
+class AlbumQuery(val albumFactory: AlbumFactory, context: Context) {
   private val contextRef = WeakReference(context)
 
   private val contentResolver
@@ -17,6 +18,6 @@ class AlbumQuery(context: Context) {
   suspend fun getAlbum(title: String): Album? {
     val id = contentResolver.queryAlbumId(title)
       ?: return null
-    return Album(id, contextRef.getOrThrow())
+    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
@@ -24,6 +23,7 @@ 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
@@ -34,7 +34,11 @@ 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
@@ -111,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 {
@@ -146,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

@@ -22,6 +22,7 @@ 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
@@ -32,7 +33,11 @@ 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
@@ -109,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) {
@@ -121,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)
   }
 }

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

@@ -0,0 +1,8 @@
+package expo.modules.medialibrary.next.objects.asset.deleters
+
+import android.net.Uri
+
+interface AssetDeleter {
+  suspend fun delete(contentUri: Uri)
+  suspend fun delete(contentUris: List<Uri>)
+}

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

@@ -0,0 +1,46 @@
+package expo.modules.medialibrary.next.objects.asset.deleters
+
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import androidx.annotation.DeprecatedSinceApi
+import expo.modules.medialibrary.AssetFileException
+import expo.modules.medialibrary.next.exceptions.AssetPropertyNotFoundException
+import expo.modules.medialibrary.next.exceptions.ContentResolverNotObtainedException
+import expo.modules.medialibrary.next.extensions.getOrThrow
+import expo.modules.medialibrary.next.extensions.resolver.queryAssetPath
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.lang.ref.WeakReference
+
+@DeprecatedSinceApi(Build.VERSION_CODES.Q)
+class AssetLegacyDeleter(context: Context) : AssetDeleter {
+  private val contextRef = WeakReference(context)
+
+  private val contentResolver
+    get() = contextRef
+      .getOrThrow()
+      .contentResolver ?: throw ContentResolverNotObtainedException()
+
+  override suspend fun delete(contentUri: Uri): Unit = withContext(Dispatchers.IO) {
+    val path = contentResolver.queryAssetPath(contentUri)
+      ?: throw AssetPropertyNotFoundException("Uri")
+    if (!File(path).delete()) {
+      throw AssetFileException("Could not delete a file.")
+    }
+    contentResolver.delete(contentUri, null, null)
+  }
+
+  override suspend fun delete(contentUris: List<Uri>): Unit = withContext(Dispatchers.IO) {
+    contentUris.map { uri ->
+      async {
+        runCatching {
+          delete(uri)
+        }
+      }
+    }.awaitAll()
+  }
+}

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

@@ -0,0 +1,21 @@
+package expo.modules.medialibrary.next.objects.asset.deleters
+
+import android.net.Uri
+import android.os.Build
+import androidx.annotation.RequiresApi
+import expo.modules.medialibrary.next.permissions.MediaStorePermissionsDelegate
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+@RequiresApi(Build.VERSION_CODES.R)
+class AssetModernDeleter(
+  val mediaStorePermissionsDelegate: MediaStorePermissionsDelegate
+) : AssetDeleter {
+  override suspend fun delete(contentUri: Uri) = withContext(Dispatchers.IO) {
+    mediaStorePermissionsDelegate.launchMediaStoreDeleteRequest(listOf(contentUri))
+  }
+
+  override suspend fun delete(contentUris: List<Uri>) = withContext(Dispatchers.IO) {
+    mediaStorePermissionsDelegate.launchMediaStoreDeleteRequest(contentUris)
+  }
+}

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

@@ -4,6 +4,7 @@ import android.net.Uri
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
 
-fun interface AssetFactory {
+interface AssetFactory {
+  fun create(contentUri: Uri): Asset
   suspend fun create(filePath: Uri, relativePath: RelativePath?): Asset
 }