expo-image-picker 13.2.0 → 13.3.1

package/CHANGELOG.md

@@ -10,11 +10,32 @@
 
 ### 💡 Others
 
+## 13.3.1 — 2022-07-25
+
+_This version does not introduce any user-facing changes._
+
+## 13.3.0 — 2022-07-16
+
+### 🎉 New features
+
+- On iOS 14+ added support for selection limit and on iOS 15+ for ordered selection. ([#18142](https://github.com/expo/expo/pull/18142), [#18143](https://github.com/expo/expo/pull/18143) by [@barthap](https://github.com/barthap))
+- The picker now resolves media library asset ID. ([#18236](https://github.com/expo/expo/pull/18236), [#18185](https://github.com/expo/expo/pull/18185) by [@barthap](https://github.com/barthap))
+- On iOS, the picker now resolves file name and size and media library asset ID. ([#18179](https://github.com/expo/expo/pull/18179) by [@barthap](https://github.com/barthap))
+- On Android added support for selecting multiple images/videos. ([#18161](https://github.com/expo/expo/pull/18161) by [@bbarthec](https://github.com/bbarthec))
+
+### 🐛 Bug fixes
+
+- On Android restored support for `allowsEditing` option that was disabled when migrating to `registerForActivityResult` mechanism. ([#17963](https://github.com/expo/expo/pull/17963) by [@bbarthec](https://github.com/bbarthec))
+
+## 13.2.1 — 2022-07-11
+
+_This version does not introduce any user-facing changes._
+
 ## 13.2.0 — 2022-07-07
 
 ### 🎉 New features
 
-- On iOS 14+ added support for selecting multiple images/videos. ([#18102](https://github.com/expo/expo/pull/18102) by [@barthap](https://github.com/barthap))
+- On iOS 14+ added support for selecting multiple images/videos. ([#18102](https://github.com/expo/expo/pull/18102), [#18138](https://github.com/expo/expo/pull/18138), [#18145](https://github.com/expo/expo/pull/18145) by [@barthap](https://github.com/barthap))
 
 ### 🐛 Bug fixes
 
@@ -22,7 +43,7 @@
 
 ### 💡 Others
 
-- On Android migrated to the new `registerForActivityResult` mechanism. ([#17671](https://github.com/expo/expo/pull/17671), ([#17987](https://github.com/expo/expo/pull/17987) by [@bbarthec](https://github.com/bbarthec))
+- On Android migrated to the new `registerForActivityResult` mechanism. This migration disables `allowsEditing` option. ([#17671](https://github.com/expo/expo/pull/17671), ([#17987](https://github.com/expo/expo/pull/17987) by [@bbarthec](https://github.com/bbarthec))
 - Native module on Android is now written in Kotlin using [Sweet API](https://docs.expo.dev/modules/module-api). ([#17668](https://github.com/expo/expo/pull/17668) by [@bbarthec](https://github.com/bbarthec))
 - Migrated Expo modules definitions to the new naming convention. ([#17193](https://github.com/expo/expo/pull/17193) by [@tsapeta](https://github.com/tsapeta))
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '13.2.0'
+version = '13.3.1'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -74,7 +74,7 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 31)
     versionCode 22
-    versionName "13.2.0"
+    versionName "13.3.1"
   }
   lintOptions {
     abortOnError false
@@ -84,9 +84,11 @@ android {
 dependencies {
   implementation project(':expo-modules-core')
 
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
-  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3")
-  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.3")
-  implementation "com.github.CanHub:Android-Image-Cropper:1.1.1"
+  implementation "androidx.activity:activity-ktx:1.4.0"
+  implementation "androidx.appcompat:appcompat:1.4.2"
   implementation "androidx.exifinterface:exifinterface:1.3.3"
+  implementation "com.github.CanHub:Android-Image-Cropper:4.3.0"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.3"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3"
 }

package/android/src/main/java/expo/modules/imagepicker/ImagePickerModule.kt

@@ -1,5 +1,3 @@
-@file:OptIn(ExperimentalContracts::class)
-
 package expo.modules.imagepicker
 
 import android.Manifest
@@ -10,6 +8,8 @@ import expo.modules.core.errors.ModuleNotFoundException
 import android.os.OperationCanceledException
 import expo.modules.imagepicker.contracts.CameraContract
 import expo.modules.imagepicker.contracts.CameraContractOptions
+import expo.modules.imagepicker.contracts.CropImageContract
+import expo.modules.imagepicker.contracts.CropImageContractOptions
 import expo.modules.imagepicker.contracts.ImageLibraryContract
 import expo.modules.imagepicker.contracts.ImageLibraryContractOptions
 import expo.modules.imagepicker.contracts.ImagePickerContractResult
@@ -24,7 +24,6 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
-import kotlin.contracts.ExperimentalContracts
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
@@ -71,7 +70,7 @@ class ImagePickerModule : Module() {
       launchContract({ imageLibraryLauncher.launch(contractOptions) }, options)
     }
 
-    AsyncFunction("getPendingResultAsync") Coroutine { _: Promise ->
+    AsyncFunction("getPendingResultAsync") Coroutine { ->
       val (bareResult, options) = pendingMediaPickingResult ?: return@Coroutine null
 
       pendingMediaPickingResult = null
@@ -90,6 +89,9 @@ class ImagePickerModule : Module() {
           imageLibraryLauncher = appContext.registerForActivityResult(
             ImageLibraryContract(this@ImagePickerModule),
           ) { input, result -> handleResultUponActivityDestruction(result, input.options) }
+          cropImageLauncher = appContext.registerForActivityResult(
+            CropImageContract(this@ImagePickerModule),
+          ) { input, result -> handleResultUponActivityDestruction(result, input.options) }
         }
       }
     }
@@ -106,6 +108,7 @@ class ImagePickerModule : Module() {
 
   private lateinit var cameraLauncher: AppContextActivityResultLauncher<CameraContractOptions, ImagePickerContractResult>
   private lateinit var imageLibraryLauncher: AppContextActivityResultLauncher<ImageLibraryContractOptions, ImagePickerContractResult>
+  private lateinit var cropImageLauncher: AppContextActivityResultLauncher<CropImageContractOptions, ImagePickerContractResult>
 
   /**
    * Stores result for an operation that has been interrupted by the activity destruction.
@@ -123,8 +126,18 @@ class ImagePickerModule : Module() {
     options: ImagePickerOptions,
   ): Any {
     return try {
-      val bareResult = launchPicker(pickerLauncher)
-      mediaHandler.readExtras(bareResult, options)
+      var result = launchPicker(pickerLauncher)
+      if (
+        !options.allowsMultipleSelection &&
+        options.allowsEditing &&
+        result.data.size == 1 &&
+        result.data[0].first == MediaType.IMAGE
+      ) {
+        result = launchPicker {
+          cropImageLauncher.launch(CropImageContractOptions(result.data[0].second, options))
+        }
+      }
+      mediaHandler.readExtras(result.data, options)
     } catch (cause: OperationCanceledException) {
       ImagePickerCancelledResponse()
     }
@@ -145,9 +158,9 @@ class ImagePickerModule : Module() {
    */
   private suspend fun launchPicker(
     pickerLauncher: suspend () -> ImagePickerContractResult,
-  ): Pair<MediaType, Uri> = withContext(Dispatchers.Main) {
+  ): ImagePickerContractResult.Success = withContext(Dispatchers.Main) {
     when (val pickingResult = pickerLauncher()) {
-      is ImagePickerContractResult.Success -> pickingResult.data
+      is ImagePickerContractResult.Success -> pickingResult
       is ImagePickerContractResult.Cancelled -> throw OperationCanceledException()
     }
   }
@@ -191,15 +204,10 @@ class ImagePickerModule : Module() {
   // endregion
 }
 
-internal enum class PickingSource {
-  CAMERA,
-  IMAGE_LIBRARY
-}
-
 /**
  * Simple data structure to hold the data that has to be preserved after the Activity is destroyed.
  */
 internal data class PendingMediaPickingResult(
-  val data: Pair<MediaType, Uri>,
+  val data: List<Pair<MediaType, Uri>>,
   val options: ImagePickerOptions
 )

package/android/src/main/java/expo/modules/imagepicker/ImagePickerOptions.kt

@@ -14,6 +14,9 @@ internal class ImagePickerOptions : Record, Serializable {
   @Field
   var allowsEditing: Boolean = false
 
+  @Field
+  var allowsMultipleSelection: Boolean = false
+
   @Field
   @FloatRange(from = 0.0, to = 1.0)
   var quality: Double = 0.2

package/android/src/main/java/expo/modules/imagepicker/ImagePickerResponse.kt

@@ -9,32 +9,42 @@ internal class ImagePickerCancelledResponse : Record {
   val cancelled: Boolean = true
 }
 
-internal sealed class ImagePickerMediaResponse(
-  @Field val type: MediaType,
-  @Field val uri: String,
-  @Field val width: Int,
-  @Field val height: Int,
-) : Record {
+internal sealed class ImagePickerResponse : Record {
   @Field
   val cancelled: Boolean = false
 
-  class Image(
-    uri: String,
-    width: Int,
-    height: Int,
-
-    @Field val base64: String?,
-    @Field val exif: Bundle?
-  ) : ImagePickerMediaResponse(MediaType.IMAGE, uri, width, height)
-
-  class Video(
-    uri: String,
-    width: Int,
-    height: Int,
-
-    @Field val duration: Int,
-    @Field val rotation: Int
-  ) : ImagePickerMediaResponse(MediaType.VIDEO, uri, width, height)
+  sealed class Single(
+    @Field val type: MediaType,
+    @Field val uri: String,
+    @Field val width: Int,
+    @Field val height: Int,
+    @Field val assetId: String?,
+  ) : ImagePickerResponse() {
+    class Image(
+      uri: String,
+      width: Int,
+      height: Int,
+      assetId: String?,
+
+      @Field val base64: String?,
+      @Field val exif: Bundle?
+    ) : Single(MediaType.IMAGE, uri, width, height, assetId)
+
+    class Video(
+      uri: String,
+      width: Int,
+      height: Int,
+      assetId: String?,
+
+      @Field val duration: Int,
+      @Field val rotation: Int
+    ) : Single(MediaType.VIDEO, uri, width, height, assetId)
+  }
+
+  class Multiple(
+    @Field
+    val selected: List<Single>
+  ) : ImagePickerResponse()
 }
 
 enum class MediaType(val value: String) {

package/android/src/main/java/expo/modules/imagepicker/ImagePickerUtils.kt

@@ -1,10 +1,13 @@
 package expo.modules.imagepicker
 
+import android.content.ClipData
 import android.content.ContentResolver
 import android.content.Context
+import android.content.Intent
 import android.graphics.Bitmap
 import android.media.MediaMetadataRetriever
 import android.net.Uri
+import android.provider.DocumentsContract
 import android.util.Log
 import android.webkit.MimeTypeMap
 import androidx.core.content.FileProvider
@@ -100,6 +103,42 @@ internal fun MediaMetadataRetriever.extractInt(key: Int): Int {
   return this.extractMetadata(key)?.toInt() ?: throw FailedToExtractVideoMetadataException()
 }
 
+/**
+ * [Iterable] implementation for [ClipData] items
+ */
+val ClipData.items: Iterable<ClipData.Item>
+  get() = object : Iterable<ClipData.Item> {
+    override fun iterator() = object : Iterator<ClipData.Item> {
+      var index = 0
+      val count = itemCount
+
+      override fun hasNext(): Boolean = index < count
+
+      override fun next(): ClipData.Item = getItemAt(index++)
+    }
+  }
+
+/**
+ * Gets all data that is associated with this [Intent].
+ * Original data order is preserved.
+ *
+ * Adapted from [androidx.activity.result.contract.ActivityResultContracts.GetMultipleContents.getClipDataUris]
+ */
+internal fun Intent.getAllDataUris(): List<Uri> {
+  // Use a LinkedHashSet to maintain any ordering that may be present in the ClipData
+  val resultSet = LinkedHashSet<Uri>()
+
+  data
+    ?.let { resultSet.add(it) }
+
+  clipData
+    ?.items
+    ?.map { it.uri }
+    ?.let { resultSet.addAll(it) }
+
+  return resultSet.toList()
+}
+
 /**
  * Copy the media file from `sourceUri` to `destinationUri`.
  *
@@ -168,3 +207,72 @@ internal suspend fun copyExifData(
     throw FailedToWriteFileException(targetFile, cause)
   }
 }
+
+/*
+Getting asset ID (and metadata) on Android is not that obvious. When getting a `content://` URI
+using `ACTION_GET_CONTENT` or `ACTION_OPEN_DOCUMENT` intents, there are 3 possible ways:
+
+1. When the user selects a photo from **Images** section of the picker (on the left drawer)
+  In this case we get a URI from `com.android.providers.media.MediaDocumentsProvider`,
+  that inherits from `DocumentsProvider`. The URI looks like this:
+  ```
+  com.android.providers.media.documents/document/image:56
+  ```
+  In this case, the `56` is the ID we're looking for.
+
+2. When the user selects a photo from **Downloads** section, another content provider is used:
+  `DownloadStorageProvider` which is a bit different, and also differs depending on Android version:
+  - On API 29+ it also inherits from `com.android.providers.downloads.DocumentsProvider`
+    and the URI looks like this:
+    ```
+    com.android.providers.downloads.documents/document/msf:56
+    ```
+    Where "msf" is abbr. of "media store file" and 56 is our asset ID
+  - On API <29 it looks similar:
+    ```
+    com.android.providers.downloads.documents/document/128
+    ```
+    but the 128 is an internal ID of downloads provider, unrelated to media store asset ID.
+
+3. When the user selects a photo by browsing the filesystem, the URI looks like this:
+  ```
+  com.android.externalstorage.documents/document/primary:Download:filename.jpg
+  ```
+  No ID in this case
+ */
+
+/**
+ * Checks whether this [Uri] is a `com.android.providers.media.documents` provider uri
+ */
+internal val Uri.isMediaProviderUri
+  get() = this.authority == "com.android.providers.media.documents"
+
+/**
+ * Checks whether this [Uri] is a `com.android.providers.downloads.documents` provider uri
+ */
+internal val Uri.isDownloadsProviderUri
+  get() = this.authority == "com.android.providers.downloads.documents"
+
+/**
+ * Checks whether asset represented by this [Uri] can be queried in the media store
+ */
+internal val Uri.isMediaStoreAssetUri
+  get() = isMediaProviderUri || (
+    isDownloadsProviderUri &&
+      DocumentsContract
+        .getDocumentId(this)
+        .startsWith("msf:")
+    )
+
+/**
+ * If the URI represents a media store asset, this returns its ID. Otherwise, returns `null`.
+ *
+ * See the detailed explanation above in this file (ImagePickerUtils.kt).
+ */
+internal fun Uri.getMediaStoreAssetId(): String? {
+  if (isMediaStoreAssetUri) {
+    val rawId = DocumentsContract.getDocumentId(this)
+    return if (rawId.contains(':')) rawId.split(':')[1] else rawId
+  }
+  return null
+}

package/android/src/main/java/expo/modules/imagepicker/MediaHandler.kt

@@ -17,17 +17,27 @@ internal class MediaHandler(
     get() = requireNotNull(appContextProvider.appContext.reactContext) { "React Application Context is null" }
 
   internal suspend fun readExtras(
-    bareResult: Pair<MediaType, Uri>,
+    bareResult: List<Pair<MediaType, Uri>>,
     options: ImagePickerOptions,
-  ): ImagePickerMediaResponse = when (bareResult.first) {
-    MediaType.VIDEO -> handleVideo(bareResult.second)
-    MediaType.IMAGE -> handleImage(bareResult.second, options)
+  ): ImagePickerResponse {
+    val results = bareResult.map { (mediaType, uri) ->
+      when (mediaType) {
+        MediaType.VIDEO -> handleVideo(uri)
+        MediaType.IMAGE -> handleImage(uri, options)
+      }
+    }
+
+    return if (results.size == 1) {
+      results[0]
+    } else {
+      ImagePickerResponse.Multiple(results)
+    }
   }
 
   private suspend fun handleImage(
     sourceUri: Uri,
     options: ImagePickerOptions,
-  ): ImagePickerMediaResponse.Image {
+  ): ImagePickerResponse.Single.Image {
     val exporter: ImageExporter = if (options.quality == ImagePickerConstants.MAXIMUM_QUALITY) {
       RawImageExporter()
     } else {
@@ -43,18 +53,19 @@ internal class MediaHandler(
     val exif = options.exif.takeIf { it }
       ?.let { exportedImage.exif(context.contentResolver) }
 
-    return ImagePickerMediaResponse.Image(
+    return ImagePickerResponse.Single.Image(
       uri = Uri.fromFile(outputFile).toString(),
       width = exportedImage.width,
       height = exportedImage.height,
       base64 = base64,
       exif = exif,
+      assetId = sourceUri.getMediaStoreAssetId()
     )
   }
 
   private suspend fun handleVideo(
     sourceUri: Uri,
-  ): ImagePickerMediaResponse.Video {
+  ): ImagePickerResponse.Single.Video {
     val outputFile = createOutputFile(context.cacheDir, ".mp4")
     copyFile(sourceUri, outputFile, context.contentResolver)
     val outputUri = outputFile.toUri()
@@ -64,12 +75,13 @@ internal class MediaHandler(
         setDataSource(context, outputUri)
       }
 
-      ImagePickerMediaResponse.Video(
+      ImagePickerResponse.Single.Video(
         uri = outputUri.toString(),
         width = metadataRetriever.extractInt(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH),
         height = metadataRetriever.extractInt(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT),
         duration = metadataRetriever.extractInt(MediaMetadataRetriever.METADATA_KEY_DURATION),
         rotation = metadataRetriever.extractInt(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION),
+        assetId = sourceUri.getMediaStoreAssetId()
       )
     } catch (cause: FailedToExtractVideoMetadataException) {
       throw FailedToExtractVideoMetadataException(outputFile, cause)

package/android/src/main/java/expo/modules/imagepicker/contracts/CameraContract.kt

@@ -1,6 +1,7 @@
 package expo.modules.imagepicker.contracts
 
 import android.app.Activity
+import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
@@ -21,6 +22,11 @@ import java.io.Serializable
 internal class CameraContract(
   private val appContextProvider: AppContextProvider,
 ) : AppContextActivityResultContract<CameraContractOptions, ImagePickerContractResult> {
+  val contentResolver: ContentResolver
+    get() = requireNotNull(appContextProvider.appContext.reactContext) {
+      "React Application Context is null"
+    }.contentResolver
+
   override fun createIntent(context: Context, input: CameraContractOptions): Intent =
     Intent(input.options.mediaTypes.toCameraIntentAction())
       .putExtra(MediaStore.EXTRA_OUTPUT, input.uri)
@@ -34,14 +40,16 @@ internal class CameraContract(
     if (resultCode == Activity.RESULT_CANCELED) {
       ImagePickerContractResult.Cancelled()
     } else {
-      val contentResolver = requireNotNull(appContextProvider.appContext.reactContext) { "React Application Context is null. " }.contentResolver
       val uri = input.uri
       val type = uri.toMediaType(contentResolver)
-      ImagePickerContractResult.Success(type to uri)
+      ImagePickerContractResult.Success(listOf(type to uri))
     }
 }
 
 internal data class CameraContractOptions(
+  /**
+   * Destination file in a form of content-[Uri] to save results coming from camera to.
+   */
   val uri: Uri,
   val options: ImagePickerOptions,
 ) : Serializable

package/android/src/main/java/expo/modules/imagepicker/contracts/ContractsUtils.kt

@@ -1,18 +1,12 @@
 package expo.modules.imagepicker.contracts
 
 import android.net.Uri
-import androidx.activity.result.contract.ActivityResultContract
 import expo.modules.imagepicker.MediaType
 
-/**
- * Alias for [androidx.activity.result.contract.ActivityResultContract] with required generic types already specified
- */
-internal typealias ImagePickerContract = ActivityResultContract<Any?, ImagePickerContractResult>
-
 /**
  * Data required to be returned upon successful contract completion
  */
 internal sealed class ImagePickerContractResult private constructor() {
   class Cancelled : ImagePickerContractResult()
-  class Success(val data: Pair<MediaType, Uri>) : ImagePickerContractResult()
+  class Success(val data: List<Pair<MediaType, Uri>>) : ImagePickerContractResult()
 }

package/android/src/main/java/expo/modules/imagepicker/contracts/CropImageContract.kt

@@ -12,44 +12,34 @@ import com.canhub.cropper.CropImageActivity
 import com.canhub.cropper.CropImageOptions
 import expo.modules.imagepicker.ImagePickerOptions
 import expo.modules.imagepicker.MediaType
-import expo.modules.imagepicker.PickingSource
 import expo.modules.imagepicker.copyExifData
 import expo.modules.imagepicker.createOutputFile
 import expo.modules.imagepicker.toBitmapCompressFormat
 import expo.modules.imagepicker.toImageFileExtension
+import expo.modules.kotlin.activityresult.AppContextActivityResultContract
 import expo.modules.kotlin.providers.AppContextProvider
 import kotlinx.coroutines.runBlocking
+import java.io.Serializable
 
 internal class CropImageContract(
   private val appContextProvider: AppContextProvider,
-  private val sourceUri: Uri,
-  private val options: ImagePickerOptions,
-  private val pickingSource: PickingSource
-) : ImagePickerContract() {
-  override fun createIntent(context: Context, input: Any?) = Intent(context, CropImageActivity::class.java).apply {
-    // for [IMAGE_LIBRARY] we need to create a new file as up to this point we've been operating on the original media asset
-    // for [CAMERA] we do not have to do it as it's already been created at the beginning of the picking process
-    val needCreateNewFile = pickingSource == PickingSource.IMAGE_LIBRARY
-    val mediaType = expo.modules.imagepicker.getType(context.contentResolver, sourceUri)
-
+) : AppContextActivityResultContract<CropImageContractOptions, ImagePickerContractResult> {
+  override fun createIntent(context: Context, input: CropImageContractOptions) = Intent(context, CropImageActivity::class.java).apply {
+    val mediaType = expo.modules.imagepicker.getType(context.contentResolver, input.sourceUri)
     val compressFormat = mediaType.toBitmapCompressFormat()
-
-    val outputUri: Uri = if (needCreateNewFile) {
-      createOutputFile(context.cacheDir, compressFormat.toImageFileExtension()).toUri()
-    } else {
-      sourceUri
-    }
+    val outputUri = createOutputFile(context.cacheDir, compressFormat.toImageFileExtension()).toUri()
 
     putExtra(
       CropImage.CROP_IMAGE_EXTRA_BUNDLE,
       bundleOf(
-        CropImage.CROP_IMAGE_EXTRA_SOURCE to sourceUri,
+        CropImage.CROP_IMAGE_EXTRA_SOURCE to input.sourceUri,
         CropImage.CROP_IMAGE_EXTRA_OPTIONS to CropImageOptions().apply {
           outputCompressFormat = compressFormat
-          outputCompressQuality = (this@CropImageContract.options.quality * 100).toInt()
-          this.outputUri = outputUri
+          outputCompressQuality = (input.options.quality * 100).toInt()
 
-          this@CropImageContract.options.aspect?.let { (x, y) ->
+          this.customOutputUri = outputUri
+
+          input.options.aspect?.let { (x, y) ->
             aspectRatioX = x
             aspectRatioY = y
             fixAspectRatio = true
@@ -62,14 +52,19 @@ internal class CropImageContract(
     )
   }
 
-  override fun parseResult(resultCode: Int, intent: Intent?): ImagePickerContractResult {
+  override fun parseResult(input: CropImageContractOptions, resultCode: Int, intent: Intent?): ImagePickerContractResult {
     val result = intent?.getParcelableExtra<CropImage.ActivityResult?>(CropImage.CROP_IMAGE_EXTRA_RESULT)
     if (resultCode == Activity.RESULT_CANCELED || result == null) {
       return ImagePickerContractResult.Cancelled()
     }
-    val targetUri = requireNotNull(result.uri)
+    val targetUri = requireNotNull(result.uriContent)
     val contentResolver = requireNotNull(appContextProvider.appContext.reactContext) { "React Application Context is null" }.contentResolver
-    runBlocking { copyExifData(sourceUri, targetUri.toFile(), contentResolver) }
-    return ImagePickerContractResult.Success(MediaType.IMAGE to targetUri)
+    runBlocking { copyExifData(input.sourceUri, targetUri.toFile(), contentResolver) }
+    return ImagePickerContractResult.Success(listOf(MediaType.IMAGE to targetUri))
   }
 }
+
+internal data class CropImageContractOptions(
+  val sourceUri: Uri,
+  val options: ImagePickerOptions,
+) : Serializable

package/android/src/main/java/expo/modules/imagepicker/contracts/ImageLibraryContract.kt

@@ -1,10 +1,12 @@
 package expo.modules.imagepicker.contracts
 
 import android.app.Activity
+import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import expo.modules.imagepicker.ImagePickerOptions
+import expo.modules.imagepicker.getAllDataUris
 import expo.modules.imagepicker.toMediaType
 import expo.modules.kotlin.activityresult.AppContextActivityResultContract
 import expo.modules.kotlin.providers.AppContextProvider
@@ -14,25 +16,37 @@ import java.io.Serializable
  * An [androidx.activity.result.contract.ActivityResultContract] to prompt the user to pick single or multiple image(s) or/and video(s),
  * receiving a `content://` [Uri] for each piece of content.
  *
- * @see [androidx.activity.result.contract.ActivityResultContracts.GetContent]
+ * @see [androidx.activity.result.contract.ActivityResultContracts.GetContent],
+ * @see [androidx.activity.result.contract.ActivityResultContracts.GetMultipleContents]
  */
 internal class ImageLibraryContract(
   private val appContextProvider: AppContextProvider,
 ) : AppContextActivityResultContract<ImageLibraryContractOptions, ImagePickerContractResult> {
+  val contentResolver: ContentResolver
+    get() = requireNotNull(appContextProvider.appContext.reactContext) {
+      "React Application Context is null"
+    }.contentResolver
+
   override fun createIntent(context: Context, input: ImageLibraryContractOptions) =
     Intent(Intent.ACTION_GET_CONTENT)
       .addCategory(Intent.CATEGORY_OPENABLE)
       .setType(input.options.mediaTypes.toMimeType())
+      .apply {
+        if (input.options.allowsMultipleSelection) {
+          putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+        }
+      }
 
   override fun parseResult(input: ImageLibraryContractOptions, resultCode: Int, intent: Intent?) =
     if (resultCode == Activity.RESULT_CANCELED) {
       ImagePickerContractResult.Cancelled()
+    } else if (input.options.allowsMultipleSelection) {
+      val uris = requireNotNull(intent).getAllDataUris()
+      ImagePickerContractResult.Success(uris.map { uri -> uri.toMediaType(contentResolver) to uri })
     } else {
       val uri = requireNotNull(requireNotNull(intent).data)
-      val contentResolver = requireNotNull(appContextProvider.appContext.reactContext) { "React Application Context is null. " }.contentResolver
       val type = uri.toMediaType(contentResolver)
-
-      ImagePickerContractResult.Success(type to uri)
+      ImagePickerContractResult.Success(listOf(type to uri))
     }
 }
 

package/build/ImagePicker.d.ts

@@ -68,7 +68,7 @@ export declare function getPendingResultAsync(): Promise<(ImagePickerResult | Im
 /**
  * Display the system UI for taking a photo with the camera. Requires `Permissions.CAMERA`.
  * On Android and iOS 10 `Permissions.CAMERA_ROLL` is also required. On mobile web, this must be
- * called immediately in a user interaction like a button press, otherwise the browser will bloc
+ * called immediately in a user interaction like a button press, otherwise the browser will block
  * the request without a warning.
  * > **Note:** Make sure that you handle `MainActivity` destruction on **Android**. See [ImagePicker.getPendingResultAsync](#imagepickergetpendingresultasync).
  * > **Notes for Web:** The system UI can only be shown after user activation (e.g. a `Button` press).

package/build/ImagePicker.js

@@ -118,7 +118,7 @@ export async function getPendingResultAsync() {
 /**
  * Display the system UI for taking a photo with the camera. Requires `Permissions.CAMERA`.
  * On Android and iOS 10 `Permissions.CAMERA_ROLL` is also required. On mobile web, this must be
- * called immediately in a user interaction like a button press, otherwise the browser will bloc
+ * called immediately in a user interaction like a button press, otherwise the browser will block
  * the request without a warning.
  * > **Note:** Make sure that you handle `MainActivity` destruction on **Android**. See [ImagePicker.getPendingResultAsync](#imagepickergetpendingresultasync).
  * > **Notes for Web:** The system UI can only be shown after user activation (e.g. a `Button` press).