expo-media-library 18.3.0-canary-20250919-7a31b96 → 18.3.0-canary-20251003-7b9d7ff

package/CHANGELOG.md

@@ -6,15 +6,19 @@
 
 ### 🎉 New features
 
+- [next] Add exif support ([#39992](https://github.com/expo/expo/pull/39992) by [@Wenszel](https://github.com/Wenszel))
 - [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

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-20251003-7b9d7ff'
 
 android {
   namespace "expo.modules.medialibrary"
   defaultConfig {
     versionCode 37
-    versionName "18.3.0-canary-20250919-7a31b96"
+    versionName "18.3.0-canary-20251003-7b9d7ff"
   }
 }
 
 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 ->
@@ -82,6 +92,16 @@ class MediaLibraryNextModule : Module() {
         self.getDuration()
       }
 
+      AsyncFunction("getExif") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getExif()
+      }
+
+      AsyncFunction("getLocation") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getLocation()
+      }
+
       AsyncFunction("getFilename") Coroutine { self: Asset ->
         systemPermissionsDelegate.requireSystemPermissions(false)
         self.getFilename()
@@ -114,14 +134,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 +159,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 +250,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,17 @@
 package expo.modules.medialibrary.next.objects.asset
 
-import android.content.Context
 import android.net.Uri
-import android.os.Build
+import android.os.Bundle
 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 expo.modules.medialibrary.next.records.Location
 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? =
@@ -55,6 +41,12 @@ class Asset(contentUri: Uri, context: Context) : SharedObject() {
   suspend fun getMimeType(): MimeType =
     assetDelegate.getMimeType()
 
+  suspend fun getLocation(): Location? =
+    assetDelegate.getLocation()
+
+  suspend fun getExif(): Bundle =
+    assetDelegate.getExif()
+
   suspend fun move(relativePath: RelativePath) = withContext(Dispatchers.IO) {
     assetDelegate.move(relativePath)
   }

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

@@ -0,0 +1,135 @@
+package expo.modules.medialibrary.next.objects.asset
+
+import androidx.exifinterface.media.ExifInterface
+
+val EXIF_TAGS = arrayOf(
+  arrayOf("string", ExifInterface.TAG_ARTIST),
+  arrayOf("int", ExifInterface.TAG_BITS_PER_SAMPLE),
+  arrayOf("int", ExifInterface.TAG_COMPRESSION),
+  arrayOf("string", ExifInterface.TAG_COPYRIGHT),
+  arrayOf("string", ExifInterface.TAG_DATETIME),
+  arrayOf("string", ExifInterface.TAG_IMAGE_DESCRIPTION),
+  arrayOf("int", ExifInterface.TAG_IMAGE_LENGTH),
+  arrayOf("int", ExifInterface.TAG_IMAGE_WIDTH),
+  arrayOf("int", ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT),
+  arrayOf("int", ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH),
+  arrayOf("string", ExifInterface.TAG_MAKE),
+  arrayOf("string", ExifInterface.TAG_MODEL),
+  arrayOf("int", ExifInterface.TAG_ORIENTATION),
+  arrayOf("int", ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION),
+  arrayOf("int", ExifInterface.TAG_PLANAR_CONFIGURATION),
+  arrayOf("double", ExifInterface.TAG_PRIMARY_CHROMATICITIES),
+  arrayOf("double", ExifInterface.TAG_REFERENCE_BLACK_WHITE),
+  arrayOf("int", ExifInterface.TAG_RESOLUTION_UNIT),
+  arrayOf("int", ExifInterface.TAG_ROWS_PER_STRIP),
+  arrayOf("int", ExifInterface.TAG_SAMPLES_PER_PIXEL),
+  arrayOf("string", ExifInterface.TAG_SOFTWARE),
+  arrayOf("int", ExifInterface.TAG_STRIP_BYTE_COUNTS),
+  arrayOf("int", ExifInterface.TAG_STRIP_OFFSETS),
+  arrayOf("int", ExifInterface.TAG_TRANSFER_FUNCTION),
+  arrayOf("double", ExifInterface.TAG_WHITE_POINT),
+  arrayOf("double", ExifInterface.TAG_X_RESOLUTION),
+  arrayOf("double", ExifInterface.TAG_Y_CB_CR_COEFFICIENTS),
+  arrayOf("int", ExifInterface.TAG_Y_CB_CR_POSITIONING),
+  arrayOf("int", ExifInterface.TAG_Y_CB_CR_SUB_SAMPLING),
+  arrayOf("double", ExifInterface.TAG_Y_RESOLUTION),
+  arrayOf("double", ExifInterface.TAG_APERTURE_VALUE),
+  arrayOf("double", ExifInterface.TAG_BRIGHTNESS_VALUE),
+  arrayOf("string", ExifInterface.TAG_CFA_PATTERN),
+  arrayOf("int", ExifInterface.TAG_COLOR_SPACE),
+  arrayOf("string", ExifInterface.TAG_COMPONENTS_CONFIGURATION),
+  arrayOf("double", ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL),
+  arrayOf("int", ExifInterface.TAG_CONTRAST),
+  arrayOf("int", ExifInterface.TAG_CUSTOM_RENDERED),
+  arrayOf("string", ExifInterface.TAG_DATETIME_DIGITIZED),
+  arrayOf("string", ExifInterface.TAG_DATETIME_ORIGINAL),
+  arrayOf("string", ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION),
+  arrayOf("double", ExifInterface.TAG_DIGITAL_ZOOM_RATIO),
+  arrayOf("string", ExifInterface.TAG_EXIF_VERSION),
+  arrayOf("double", ExifInterface.TAG_EXPOSURE_BIAS_VALUE),
+  arrayOf("double", ExifInterface.TAG_EXPOSURE_INDEX),
+  arrayOf("int", ExifInterface.TAG_EXPOSURE_MODE),
+  arrayOf("int", ExifInterface.TAG_EXPOSURE_PROGRAM),
+  arrayOf("double", ExifInterface.TAG_EXPOSURE_TIME),
+  arrayOf("double", ExifInterface.TAG_F_NUMBER),
+  arrayOf("string", ExifInterface.TAG_FILE_SOURCE),
+  arrayOf("int", ExifInterface.TAG_FLASH),
+  arrayOf("double", ExifInterface.TAG_FLASH_ENERGY),
+  arrayOf("string", ExifInterface.TAG_FLASHPIX_VERSION),
+  arrayOf("double", ExifInterface.TAG_FOCAL_LENGTH),
+  arrayOf("int", ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM),
+  arrayOf("int", ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT),
+  arrayOf("double", ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION),
+  arrayOf("double", ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION),
+  arrayOf("int", ExifInterface.TAG_GAIN_CONTROL),
+  arrayOf("int", ExifInterface.TAG_ISO_SPEED_RATINGS),
+  arrayOf("string", ExifInterface.TAG_IMAGE_UNIQUE_ID),
+  arrayOf("int", ExifInterface.TAG_LIGHT_SOURCE),
+  arrayOf("string", ExifInterface.TAG_MAKER_NOTE),
+  arrayOf("double", ExifInterface.TAG_MAX_APERTURE_VALUE),
+  arrayOf("int", ExifInterface.TAG_METERING_MODE),
+  arrayOf("int", ExifInterface.TAG_NEW_SUBFILE_TYPE),
+  arrayOf("string", ExifInterface.TAG_OECF),
+  arrayOf("int", ExifInterface.TAG_PIXEL_X_DIMENSION),
+  arrayOf("int", ExifInterface.TAG_PIXEL_Y_DIMENSION),
+  arrayOf("string", ExifInterface.TAG_RELATED_SOUND_FILE),
+  arrayOf("int", ExifInterface.TAG_SATURATION),
+  arrayOf("int", ExifInterface.TAG_SCENE_CAPTURE_TYPE),
+  arrayOf("string", ExifInterface.TAG_SCENE_TYPE),
+  arrayOf("int", ExifInterface.TAG_SENSING_METHOD),
+  arrayOf("int", ExifInterface.TAG_SHARPNESS),
+  arrayOf("double", ExifInterface.TAG_SHUTTER_SPEED_VALUE),
+  arrayOf("string", ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE),
+  arrayOf("string", ExifInterface.TAG_SPECTRAL_SENSITIVITY),
+  arrayOf("int", ExifInterface.TAG_SUBFILE_TYPE),
+  arrayOf("string", ExifInterface.TAG_SUBSEC_TIME),
+  arrayOf("string", ExifInterface.TAG_SUBSEC_TIME_DIGITIZED),
+  arrayOf("string", ExifInterface.TAG_SUBSEC_TIME_ORIGINAL),
+  arrayOf("int", ExifInterface.TAG_SUBJECT_AREA),
+  arrayOf("double", ExifInterface.TAG_SUBJECT_DISTANCE),
+  arrayOf("int", ExifInterface.TAG_SUBJECT_DISTANCE_RANGE),
+  arrayOf("int", ExifInterface.TAG_SUBJECT_LOCATION),
+  arrayOf("string", ExifInterface.TAG_USER_COMMENT),
+  arrayOf("int", ExifInterface.TAG_WHITE_BALANCE),
+  arrayOf("int", ExifInterface.TAG_GPS_ALTITUDE_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_AREA_INFORMATION),
+  arrayOf("double", ExifInterface.TAG_GPS_DOP),
+  arrayOf("string", ExifInterface.TAG_GPS_DATESTAMP),
+  arrayOf("double", ExifInterface.TAG_GPS_DEST_BEARING),
+  arrayOf("string", ExifInterface.TAG_GPS_DEST_BEARING_REF),
+  arrayOf("double", ExifInterface.TAG_GPS_DEST_DISTANCE),
+  arrayOf("string", ExifInterface.TAG_GPS_DEST_DISTANCE_REF),
+  arrayOf("double", ExifInterface.TAG_GPS_DEST_LATITUDE),
+  arrayOf("string", ExifInterface.TAG_GPS_DEST_LATITUDE_REF),
+  arrayOf("double", ExifInterface.TAG_GPS_DEST_LONGITUDE),
+  arrayOf("string", ExifInterface.TAG_GPS_DEST_LONGITUDE_REF),
+  arrayOf("int", ExifInterface.TAG_GPS_DIFFERENTIAL),
+  arrayOf("double", ExifInterface.TAG_GPS_IMG_DIRECTION),
+  arrayOf("string", ExifInterface.TAG_GPS_IMG_DIRECTION_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_LATITUDE_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_LONGITUDE_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_MAP_DATUM),
+  arrayOf("string", ExifInterface.TAG_GPS_MEASURE_MODE),
+  arrayOf("string", ExifInterface.TAG_GPS_PROCESSING_METHOD),
+  arrayOf("string", ExifInterface.TAG_GPS_SATELLITES),
+  arrayOf("double", ExifInterface.TAG_GPS_SPEED),
+  arrayOf("string", ExifInterface.TAG_GPS_SPEED_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_STATUS),
+  arrayOf("string", ExifInterface.TAG_GPS_TIMESTAMP),
+  arrayOf("double", ExifInterface.TAG_GPS_TRACK),
+  arrayOf("string", ExifInterface.TAG_GPS_TRACK_REF),
+  arrayOf("string", ExifInterface.TAG_GPS_VERSION_ID),
+  arrayOf("string", ExifInterface.TAG_INTEROPERABILITY_INDEX),
+  arrayOf("int", ExifInterface.TAG_THUMBNAIL_IMAGE_LENGTH),
+  arrayOf("int", ExifInterface.TAG_THUMBNAIL_IMAGE_WIDTH),
+  arrayOf("int", ExifInterface.TAG_DNG_VERSION),
+  arrayOf("int", ExifInterface.TAG_DEFAULT_CROP_SIZE),
+  arrayOf("int", ExifInterface.TAG_ORF_PREVIEW_IMAGE_START),
+  arrayOf("int", ExifInterface.TAG_ORF_PREVIEW_IMAGE_LENGTH),
+  arrayOf("int", ExifInterface.TAG_ORF_ASPECT_FRAME),
+  arrayOf("int", ExifInterface.TAG_RW2_SENSOR_BOTTOM_BORDER),
+  arrayOf("int", ExifInterface.TAG_RW2_SENSOR_LEFT_BORDER),
+  arrayOf("int", ExifInterface.TAG_RW2_SENSOR_RIGHT_BORDER),
+  arrayOf("int", ExifInterface.TAG_RW2_SENSOR_TOP_BORDER),
+  arrayOf("int", ExifInterface.TAG_RW2_ISO)
+)

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

@@ -1,10 +1,12 @@
 package expo.modules.medialibrary.next.objects.asset.delegates
 
 import android.net.Uri
+import android.os.Bundle
 import expo.modules.medialibrary.next.objects.wrappers.RelativePath
 import expo.modules.medialibrary.next.objects.asset.Asset
 import expo.modules.medialibrary.next.objects.wrappers.MediaType
 import expo.modules.medialibrary.next.objects.wrappers.MimeType
+import expo.modules.medialibrary.next.records.Location
 
 interface AssetDelegate {
   val contentUri: Uri
@@ -17,6 +19,8 @@ interface AssetDelegate {
   suspend fun getModificationTime(): Long?
   suspend fun getUri(): Uri
   suspend fun getMimeType(): MimeType
+  suspend fun getLocation(): Location?
+  suspend fun getExif(): Bundle
   suspend fun delete()
   suspend fun move(relativePath: RelativePath)
   suspend fun copy(relativePath: RelativePath): Asset