expo-image-picker 10.2.3 → 11.0.0

package/CHANGELOG.md

@@ -10,17 +10,26 @@
 
 ### 💡 Others
 
-## 10.2.3 — 2021-08-20
+## 11.0.0 — 2021-09-28
 
-_This version does not introduce any user-facing changes._
+### 🛠 Breaking changes
 
-## 10.2.2 — 2021-06-24
+- Dropped support for iOS 11.0 ([#14383](https://github.com/expo/expo/pull/14383) by [@cruzach](https://github.com/cruzach))
 
-_This version does not introduce any user-facing changes._
+### 🎉 New features
 
-## 10.2.1 — 2021-06-22
+- Add useCameraPermissions and useMediaLibraryPermissions hooks from modules factory. ([#13859](https://github.com/expo/expo/pull/13859) by [@bycedric](https://github.com/bycedric))
+- Add possibility to change presentation style on iOS. ([#14068](https://github.com/expo/expo/pull/14068) by [@mstach60161](https://github.com/mstach60161))
 
-_This version does not introduce any user-facing changes._
+### 🐛 Bug fixes
+
+- Add missing `GPSHPositioningError` exif parameter on Android. ([#13998](https://github.com/expo/expo/pull/13998) by [@mstach60161](https://github.com/mstach60161))
+- Fix promise not resolving when the app is moved to the background on Android. ([#13975](https://github.com/expo/expo/pull/13975) by [@mstach60161](https://github.com/mstach60161))
+- Fix building errors from use_frameworks! in Podfile. ([#14523](https://github.com/expo/expo/pull/14523) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Updated `@expo/config-plugins` ([#14443](https://github.com/expo/expo/pull/14443) by [@EvanBacon](https://github.com/EvanBacon))
 
 ## 10.2.0 — 2021-06-16
 
@@ -29,10 +38,12 @@ _This version does not introduce any user-facing changes._
 - Fixed `base64` return on web. ([#12529](https://github.com/expo/expo/pull/12529) by [@simonezuccala](https://github.com/simonezuccala) and [@misterdev](https://github.com/misterdev))
 - Enable kotlin in all modules. ([#12716](https://github.com/expo/expo/pull/12716) by [@wschurman](https://github.com/wschurman))
 - Fixed cases where Picker & Camera would be transparent on iOS 14.5. ([#12897](https://github.com/expo/expo/pull/12897) by [@cruzach](https://github.com/cruzach))
+- Add missing exif data to cropped image on Android. ([#14038](https://github.com/expo/expo/pull/14038) by [@mstach60161](https://github.com/mstach60161))
 
 ### 💡 Others
 
 - Migrated from `unimodules-file-system-interface` and `unimodules-permissions-interface` to `expo-modules-core`. ([#12961](https://github.com/expo/expo/pull/12961) by [@tsapeta](https://github.com/tsapeta))
+- Migrated from `AsyncTask` to Kotlin concurrency utilities. ([#13800](https://github.com/expo/expo/pull/13800) by [@m1st4ke](https://github.com/m1st4ke))
 
 ## 10.1.3 — 2021-04-13
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '10.2.3'
+version = '11.0.0'
 
 buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
@@ -58,29 +58,22 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     versionCode 22
-    versionName "10.2.3"
+    versionName "11.0.0"
   }
   lintOptions {
     abortOnError false
   }
   kotlinOptions {
-    jvmTarget = '1.8'
+    jvmTarget = JavaVersion.VERSION_1_8
   }
 }
 
-if (new File(rootProject.projectDir.parentFile, 'package.json').exists()) {
-  apply from: project(":unimodules-core").file("../unimodules-core.gradle")
-} else {
-  throw new GradleException(
-      "'unimodules-core.gradle' was not found in the usual React Native dependency location. " +
-          "This package can only be used in such projects. Are you sure you've installed the dependencies properly?")
-}
-
 dependencies {
-  unimodule "unimodules-core"
-  unimodule 'expo-modules-core'
+  implementation project(':expo-modules-core')
 
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.4.21')}"
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3")
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1")
   api 'com.theartofdev.edmodo:android-image-cropper:2.8.0'
   api "androidx.legacy:legacy-support-v4:1.0.0"
   api 'commons-codec:commons-codec:1.10'

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

@@ -23,6 +23,9 @@ object ImagePickerConstants {
   const val MISSING_URL_MESSAGE = "Intent doesn't contain `url`."
   const val ERR_CAN_NOT_OPEN_CROP = "ERR_CAN_NOT_OPEN_CROP"
   const val CAN_NOT_OPEN_CROP_MESSAGE = "Can not open the crop tool."
+  const val COROUTINE_CANCELED = "Coroutine canceled by module destruction."
+  const val PROMISES_CANCELED = "Module destroyed, all promises canceled."
+  const val UNKNOWN_EXCEPTION = "Unknown exception."
 
   const val OPTION_QUALITY = "quality"
   const val OPTION_ALLOWS_EDITING = "allowsEditing"
@@ -32,8 +35,6 @@ object ImagePickerConstants {
   const val OPTION_EXIF = "exif"
   const val OPTION_VIDEO_MAX_DURATION = "videoMaxDuration"
 
-  // We need to explicitly get latitude, longitude, altitude with their specific accessor functions
-  // separately so we skip them in this list.
   val exifTags = arrayOf(
     arrayOf("string", ExifInterface.TAG_ARTIST),
     arrayOf("int", ExifInterface.TAG_BITS_PER_SAMPLE),
@@ -123,6 +124,7 @@ object ImagePickerConstants {
     arrayOf("int", ExifInterface.TAG_SUBJECT_LOCATION),
     arrayOf("string", ExifInterface.TAG_USER_COMMENT),
     arrayOf("int", ExifInterface.TAG_WHITE_BALANCE),
+    arrayOf("double", ExifInterface.TAG_GPS_ALTITUDE),
     arrayOf("int", ExifInterface.TAG_GPS_ALTITUDE_REF),
     arrayOf("string", ExifInterface.TAG_GPS_AREA_INFORMATION),
     arrayOf("double", ExifInterface.TAG_GPS_DOP),
@@ -136,9 +138,12 @@ object ImagePickerConstants {
     arrayOf("double", ExifInterface.TAG_GPS_DEST_LONGITUDE),
     arrayOf("string", ExifInterface.TAG_GPS_DEST_LONGITUDE_REF),
     arrayOf("int", ExifInterface.TAG_GPS_DIFFERENTIAL),
+    arrayOf("string", ExifInterface.TAG_GPS_H_POSITIONING_ERROR),
     arrayOf("double", ExifInterface.TAG_GPS_IMG_DIRECTION),
     arrayOf("string", ExifInterface.TAG_GPS_IMG_DIRECTION_REF),
+    arrayOf("double", ExifInterface.TAG_GPS_LATITUDE),
     arrayOf("string", ExifInterface.TAG_GPS_LATITUDE_REF),
+    arrayOf("double", ExifInterface.TAG_GPS_LONGITUDE),
     arrayOf("string", ExifInterface.TAG_GPS_LONGITUDE_REF),
     arrayOf("string", ExifInterface.TAG_GPS_MAP_DATUM),
     arrayOf("string", ExifInterface.TAG_GPS_MEASURE_MODE),

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

@@ -11,6 +11,17 @@ import android.os.Bundle
 import android.provider.MediaStore
 import android.util.Log
 import com.theartofdev.edmodo.cropper.CropImage
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.ModuleRegistryDelegate
+import expo.modules.core.Promise
+import expo.modules.core.errors.ModuleDestroyedException
+import expo.modules.core.interfaces.ActivityEventListener
+import expo.modules.core.interfaces.ActivityProvider
+import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.core.interfaces.LifecycleEventListener
+import expo.modules.core.interfaces.services.UIManager
+import expo.modules.core.utilities.FileUtilities.generateOutputPath
 import expo.modules.imagepicker.ImagePickerOptions.Companion.optionsFromMap
 import expo.modules.imagepicker.exporters.CompressionImageExporter
 import expo.modules.imagepicker.exporters.CropImageExporter
@@ -25,16 +36,9 @@ import expo.modules.interfaces.permissions.Permissions
 import expo.modules.interfaces.permissions.PermissionsResponse
 import expo.modules.interfaces.permissions.PermissionsResponseListener
 import expo.modules.interfaces.permissions.PermissionsStatus
-import org.unimodules.core.ExportedModule
-import org.unimodules.core.ModuleRegistry
-import org.unimodules.core.ModuleRegistryDelegate
-import org.unimodules.core.Promise
-import org.unimodules.core.interfaces.ActivityEventListener
-import org.unimodules.core.interfaces.ActivityProvider
-import org.unimodules.core.interfaces.ExpoMethod
-import org.unimodules.core.interfaces.LifecycleEventListener
-import org.unimodules.core.interfaces.services.UIManager
-import org.unimodules.core.utilities.FileUtilities.generateOutputPath
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
 import java.io.IOException
 import java.lang.ref.WeakReference
 
@@ -47,13 +51,24 @@ class ImagePickerModule(
   private var mCameraCaptureURI: Uri? = null
   private var mPromise: Promise? = null
   private var mPickerOptions: ImagePickerOptions? = null
+  private val moduleCoroutineScope = CoroutineScope(Dispatchers.IO)
+  private var exifDataHandler: ExifDataHandler? = null
+
+  override fun onDestroy() {
+    try {
+      mUIManager.unregisterLifecycleEventListener(this)
+      moduleCoroutineScope.cancel(ModuleDestroyedException(ImagePickerConstants.PROMISES_CANCELED))
+    } catch (e: IllegalStateException) {
+      Log.e(ImagePickerConstants.TAG, "The scope does not have a job in it")
+    }
+  }
 
   /**
    * Android system sometimes kills the `MainActivity` after the `ImagePicker` finishes.
    * Moreover, the react context will be reloaded again in such a case. We need to handle this situation.
    * To do it we track if the current activity was destroyed.
    */
-  private var mWasDestroyed = false
+  private var mWasHostDestroyed = false
 
   private val mImageLoader: ImageLoaderInterface by moduleRegistry()
   private val mUIManager: UIManager by moduleRegistry()
@@ -126,7 +141,8 @@ class ImagePickerModule(
 
     val permissionsResponseHandler = PermissionsResponseListener { permissionsResponse: Map<String, PermissionsResponse> ->
       if (permissionsResponse[Manifest.permission.WRITE_EXTERNAL_STORAGE]?.status == PermissionsStatus.GRANTED &&
-        permissionsResponse[Manifest.permission.CAMERA]?.status == PermissionsStatus.GRANTED) {
+        permissionsResponse[Manifest.permission.CAMERA]?.status == PermissionsStatus.GRANTED
+      ) {
         launchCameraWithPermissionsGranted(promise, cameraIntent, pickerOptions)
       } else {
         promise.reject(SecurityException("User rejected permissions"))
@@ -255,7 +271,7 @@ class ImagePickerModule(
       setOutputCompressFormat(compressFormat)
       setOutputCompressQuality(pickerOptions.quality)
     }
-
+    exifDataHandler = ExifDataHandler(uri)
     startActivityOnResult(cropImageBuilder.getIntent(context), CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE, promise, pickerOptions)
   }
 
@@ -270,7 +286,7 @@ class ImagePickerModule(
       mUIManager.unregisterActivityEventListener(this)
 
       var pickerOptions = mPickerOptions!!
-      val promise = if (mWasDestroyed && mPromise !is PendingPromise) {
+      val promise = if (mWasHostDestroyed && mPromise !is PendingPromise) {
         if (pickerOptions.isBase64) {
           // we know that the activity was killed and we don't want to store
           // base64 into `SharedPreferences`...
@@ -323,14 +339,16 @@ class ImagePickerModule(
       mPickerOptions != null &&
       // When we launched the crop tool and the android kills current activity, the references can be different.
       // So, we fallback to the requestCode in this case.
-      (activity === experienceActivity || mWasDestroyed && requestCode == CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE)
+      (activity === experienceActivity || mWasHostDestroyed && requestCode == CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE)
   }
 
   private fun handleOnActivityResult(promise: Promise, activity: Activity, requestCode: Int, resultCode: Int, intent: Intent?, pickerOptions: ImagePickerOptions) {
     if (resultCode != Activity.RESULT_OK) {
-      promise.resolve(Bundle().apply {
-        putBoolean("cancelled", true)
-      })
+      promise.resolve(
+        Bundle().apply {
+          putBoolean("cancelled", true)
+        }
+      )
       return
     }
 
@@ -339,7 +357,17 @@ class ImagePickerModule(
     if (requestCode == CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE) {
       val result = CropImage.getActivityResult(intent)
       val exporter = CropImageExporter(result.rotation, result.cropRect, pickerOptions.isBase64)
-      ImageResultTask(promise, result.uri, contentResolver, CropFileProvider(result.uri), pickerOptions.isExif, exporter).execute()
+      ImageResultTask(
+        promise,
+        result.uri,
+        contentResolver,
+        CropFileProvider(result.uri),
+        pickerOptions.isAllowsEditing,
+        pickerOptions.isExif,
+        exporter,
+        exifDataHandler,
+        moduleCoroutineScope
+      ).execute()
       return
     }
 
@@ -368,7 +396,17 @@ class ImagePickerModule(
         CompressionImageExporter(mImageLoader, pickerOptions.quality, pickerOptions.isBase64)
       }
 
-      ImageResultTask(promise, uri, contentResolver, CacheFileProvider(mContext.cacheDir, deduceExtension(type)), pickerOptions.isExif, exporter).execute()
+      ImageResultTask(
+        promise,
+        uri,
+        contentResolver,
+        CacheFileProvider(mContext.cacheDir, deduceExtension(type)),
+        pickerOptions.isAllowsEditing,
+        pickerOptions.isExif,
+        exporter,
+        exifDataHandler,
+        moduleCoroutineScope
+      ).execute()
       return
     }
 
@@ -376,7 +414,7 @@ class ImagePickerModule(
       val metadataRetriever = MediaMetadataRetriever().apply {
         setDataSource(mContext, uri)
       }
-      VideoResultTask(promise, uri, contentResolver, CacheFileProvider(mContext.cacheDir, ".mp4"), metadataRetriever).execute()
+      VideoResultTask(promise, uri, contentResolver, CacheFileProvider(mContext.cacheDir, ".mp4"), metadataRetriever, moduleCoroutineScope).execute()
     } catch (e: RuntimeException) {
       e.printStackTrace()
       promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
@@ -389,11 +427,15 @@ class ImagePickerModule(
   //region LifecycleEventListener
 
   override fun onHostDestroy() {
-    mWasDestroyed = true
-    mUIManager.unregisterLifecycleEventListener(this)
+    mWasHostDestroyed = true
   }
 
-  override fun onHostResume() = Unit
+  override fun onHostResume() {
+    if (mWasHostDestroyed) {
+      _experienceActivity = WeakReference(mActivityProvider.currentActivity)
+      mWasHostDestroyed = false
+    }
+  }
   override fun onHostPause() = Unit
 
   //endregion

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

@@ -1,6 +1,6 @@
 package expo.modules.imagepicker
 
-import org.unimodules.core.Promise
+import expo.modules.core.Promise
 
 data class ImagePickerOptions(
   val quality: Int,

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

@@ -1,7 +1,7 @@
 package expo.modules.imagepicker
 
 import android.content.Context
-import org.unimodules.core.BasePackage
+import expo.modules.core.BasePackage
 
 class ImagePickerPackage : BasePackage() {
   override fun createExportedModules(context: Context) = listOf(ImagePickerModule(context))

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

@@ -6,7 +6,8 @@ import android.net.Uri
 import android.util.Log
 import android.webkit.MimeTypeMap
 import androidx.core.content.FileProvider
-import org.unimodules.core.utilities.FileUtilities.generateOutputPath
+import androidx.exifinterface.media.ExifInterface
+import expo.modules.core.utilities.FileUtilities.generateOutputPath
 import java.io.File
 import java.io.IOException
 
@@ -63,3 +64,30 @@ fun deduceExtension(type: String): String = when {
   }
   else -> ".jpg"
 }
+
+class ExifDataHandler(private val uri: Uri) {
+  fun copyExifData(newUri: Uri, contentResolver: ContentResolver) {
+    if (uri == newUri) {
+      return
+    }
+    contentResolver.openInputStream(uri)?.use { input ->
+      val oldExif = ExifInterface(input)
+      newUri.path?.let {
+        val newExif = ExifInterface(it)
+        for ((_, exifTag) in ImagePickerConstants.exifTags) {
+          val value = oldExif.getAttribute(exifTag)
+          if (value != null &&
+            exifTag != ExifInterface.TAG_IMAGE_LENGTH &&
+            exifTag != ExifInterface.TAG_IMAGE_WIDTH &&
+            exifTag != ExifInterface.TAG_PIXEL_X_DIMENSION &&
+            exifTag != ExifInterface.TAG_PIXEL_Y_DIMENSION &&
+            exifTag != ExifInterface.TAG_ORIENTATION
+          ) {
+            newExif.setAttribute(exifTag, value)
+          }
+        }
+        newExif.saveAttributes()
+      }
+    }
+  }
+}

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

@@ -1,7 +1,7 @@
 package expo.modules.imagepicker
 
 import android.os.Bundle
-import org.unimodules.core.Promise
+import expo.modules.core.Promise
 
 /**
  * Class that represents a promise, which will not resolve immediately but saves results to the [PickerResultsStore].
@@ -25,12 +25,14 @@ class PendingPromise(
   }
 
   override fun reject(code: String, message: String, e: Throwable?) {
-    pickerResultsStore.addPendingResult(Bundle().apply {
-      putString("code", code)
-      putString("message", message)
-      e?.let {
-        putString("exception", it.toString())
+    pickerResultsStore.addPendingResult(
+      Bundle().apply {
+        putString("code", code)
+        putString("message", message)
+        e?.let {
+          putString("exception", it.toString())
+        }
       }
-    })
+    )
   }
 }

package/android/src/main/java/expo/modules/imagepicker/fileproviders/CacheFileProvider.kt

@@ -1,7 +1,7 @@
 package expo.modules.imagepicker.fileproviders
 
 import expo.modules.imagepicker.ImagePickerConstants
-import org.unimodules.core.utilities.FileUtilities
+import expo.modules.core.utilities.FileUtilities
 import java.io.File
 
 class CacheFileProvider(

package/android/src/main/java/expo/modules/imagepicker/tasks/ImageResultTask.kt

@@ -2,64 +2,106 @@ package expo.modules.imagepicker.tasks
 
 import android.content.ContentResolver
 import android.net.Uri
-import android.os.AsyncTask
 import android.os.Bundle
 import android.util.Base64
+import android.util.Log
 import androidx.exifinterface.media.ExifInterface
+import expo.modules.core.Promise
+import expo.modules.core.errors.ModuleDestroyedException
+import expo.modules.imagepicker.ExifDataHandler
 import expo.modules.imagepicker.ImagePickerConstants
 import expo.modules.imagepicker.ImagePickerConstants.exifTags
 import expo.modules.imagepicker.exporters.ImageExporter
 import expo.modules.imagepicker.exporters.ImageExporter.Listener
 import expo.modules.imagepicker.fileproviders.FileProvider
-import org.unimodules.core.Promise
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 import java.io.ByteArrayOutputStream
+import java.io.File
 import java.io.IOException
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
 open class ImageResultTask(
   private val promise: Promise,
   private val uri: Uri,
   private val contentResolver: ContentResolver,
   private val fileProvider: FileProvider,
+  private val isEdited: Boolean,
   private val withExifData: Boolean,
-  private val imageExporter: ImageExporter
-) :
-  AsyncTask<Void?, Void?, Void?>() {
-
-  override fun doInBackground(vararg params: Void?): Void? {
+  private val imageExporter: ImageExporter,
+  private var exifDataHandler: ExifDataHandler?,
+  private val coroutineScope: CoroutineScope
+) {
+  /**
+   * We need to make coroutine wait till the file is generated, while the underlying
+   * thread is free to continue executing other coroutines.
+   */
+  private suspend fun getFile(): File = suspendCancellableCoroutine { cancellableContinuation ->
     try {
       val outputFile = fileProvider.generateFile()
-      val exif: Bundle? = if (withExifData) readExif() else null
+      cancellableContinuation.resume(outputFile)
+    } catch (e: Exception) {
+      cancellableContinuation.resumeWithException(e)
+    }
+  }
 
-      val imageExporterHandler = object : Listener {
-        override fun onResult(out: ByteArrayOutputStream?, width: Int, height: Int) {
-          val response = Bundle().apply {
-            putString("uri", Uri.fromFile(outputFile).toString())
-            putInt("width", width)
-            putInt("height", height)
-            putBoolean("cancelled", false)
-            putString("type", "image")
+  /**
+   * We need to make coroutine wait till the exif data is being read, while the underlying
+   * thread is free to continue executing other coroutines.
+   */
+  private suspend fun getExifData(): Bundle? = suspendCancellableCoroutine { cancellableContinuation ->
+    try {
+      val exif = if (withExifData) readExif() else null
+      cancellableContinuation.resume(exif)
+    } catch (e: Exception) {
+      cancellableContinuation.resumeWithException(e)
+    }
+  }
 
-            out?.let {
-              putString("base64", Base64.encodeToString(it.toByteArray(), Base64.NO_WRAP))
-            }
-            exif?.let {
-              putBundle("exif", it)
+  fun execute() {
+    coroutineScope.launch {
+      try {
+        val outputFile = getFile()
+        if (isEdited) {
+          exifDataHandler?.copyExifData(uri, contentResolver)
+        }
+        val exif = getExifData()
+        val imageExporterHandler = object : Listener {
+          override fun onResult(out: ByteArrayOutputStream?, width: Int, height: Int) {
+            val response = Bundle().apply {
+              putString("uri", Uri.fromFile(outputFile).toString())
+              putInt("width", width)
+              putInt("height", height)
+              putBoolean("cancelled", false)
+              putString("type", "image")
+
+              out?.let {
+                putString("base64", Base64.encodeToString(it.toByteArray(), Base64.NO_WRAP))
+              }
+              exif?.let {
+                putBundle("exif", it)
+              }
             }
+            promise.resolve(response)
           }
-          promise.resolve(response)
-        }
 
-        override fun onFailure(cause: Throwable?) {
-          promise.reject(ImagePickerConstants.ERR_CAN_NOT_SAVE_RESULT, ImagePickerConstants.CAN_NOT_SAVE_RESULT_MESSAGE, cause)
+          override fun onFailure(cause: Throwable?) {
+            promise.reject(ImagePickerConstants.ERR_CAN_NOT_SAVE_RESULT, ImagePickerConstants.CAN_NOT_SAVE_RESULT_MESSAGE, cause)
+          }
         }
+        imageExporter.export(uri, outputFile, imageExporterHandler)
+      } catch (e: ModuleDestroyedException) {
+        Log.i(ImagePickerConstants.TAG, ImagePickerConstants.COROUTINE_CANCELED, e)
+        promise.reject(ImagePickerConstants.COROUTINE_CANCELED, e)
+      } catch (e: IOException) {
+        promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
+      } catch (e: Exception) {
+        Log.e(ImagePickerConstants.TAG, ImagePickerConstants.UNKNOWN_EXCEPTION, e)
+        promise.reject(ImagePickerConstants.UNKNOWN_EXCEPTION, e)
       }
-
-      imageExporter.export(uri, outputFile, imageExporterHandler)
-    } catch (e: IOException) {
-      promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
     }
-
-    return null
   }
 
   @Throws(IOException::class)

package/android/src/main/java/expo/modules/imagepicker/tasks/VideoResultTask.kt

@@ -3,49 +3,76 @@ package expo.modules.imagepicker.tasks
 import android.content.ContentResolver
 import android.media.MediaMetadataRetriever
 import android.net.Uri
-import android.os.AsyncTask
 import android.os.Bundle
+import android.util.Log
+import expo.modules.core.Promise
+import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.imagepicker.ImagePickerConstants
 import expo.modules.imagepicker.fileproviders.FileProvider
-import org.unimodules.core.Promise
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
-import java.lang.NullPointerException
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
 class VideoResultTask(
   private val promise: Promise,
   private val uri: Uri,
   private val contentResolver: ContentResolver,
   private val fileProvider: FileProvider,
-  private val mediaMetadataRetriever: MediaMetadataRetriever
-) :
-  AsyncTask<Void?, Void?, Void?>() {
+  private val mediaMetadataRetriever: MediaMetadataRetriever,
+  private val coroutineScope: CoroutineScope
+) {
+  private fun extractMediaMetadata(key: Int): Int =
+    mediaMetadataRetriever.extractMetadata(key)!!.toInt()
 
-  override fun doInBackground(vararg params: Void?): Void? {
+  /**
+   * We need to make coroutine wait till the video is saved, while the underlying
+   * thread is free to continue executing other coroutines.
+   */
+  private suspend fun getFile(): File = suspendCancellableCoroutine { cancellableContinuation ->
     try {
       val outputFile = fileProvider.generateFile()
       saveVideo(outputFile)
-      val response = Bundle().apply {
-        putString("uri", Uri.fromFile(outputFile).toString())
-        putBoolean("cancelled", false)
-        putString("type", "video")
-        putInt("width", mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt())
-        putInt("height", mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt())
-        putInt("rotation", mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)!!.toInt())
-        putInt("duration", mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)!!.toInt())
+      cancellableContinuation.resume(outputFile)
+    } catch (e: Exception) {
+      cancellableContinuation.resumeWithException(e)
+    }
+  }
+
+  fun execute() {
+    coroutineScope.launch {
+      try {
+        val outputFile = getFile()
+        val response = Bundle().apply {
+          putString("uri", Uri.fromFile(outputFile).toString())
+          putBoolean("cancelled", false)
+          putString("type", "video")
+          putInt("width", extractMediaMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH))
+          putInt("height", extractMediaMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT))
+          putInt("rotation", extractMediaMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION))
+          putInt("duration", extractMediaMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION))
+        }
+        promise.resolve(response)
+      } catch (e: ModuleDestroyedException) {
+        Log.d(ImagePickerConstants.TAG, ImagePickerConstants.COROUTINE_CANCELED, e)
+        promise.reject(e)
+      } catch (e: NullPointerException) {
+        promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
+      } catch (e: IllegalArgumentException) {
+        promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
+      } catch (e: SecurityException) {
+        promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
+      } catch (e: IOException) {
+        promise.reject(ImagePickerConstants.ERR_CAN_NOT_SAVE_RESULT, ImagePickerConstants.CAN_NOT_SAVE_RESULT_MESSAGE, e)
+      } catch (e: Exception) {
+        Log.e(ImagePickerConstants.TAG, ImagePickerConstants.UNKNOWN_EXCEPTION, e)
+        promise.reject(ImagePickerConstants.UNKNOWN_EXCEPTION, e)
       }
-      promise.resolve(response)
-    } catch (e: NullPointerException) {
-      promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
-    } catch (e: IllegalArgumentException) {
-      promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
-    } catch (e: SecurityException) {
-      promise.reject(ImagePickerConstants.ERR_CAN_NOT_EXTRACT_METADATA, ImagePickerConstants.CAN_NOT_EXTRACT_METADATA_MESSAGE, e)
-    } catch (e: IOException) {
-      promise.reject(ImagePickerConstants.ERR_CAN_NOT_SAVE_RESULT, ImagePickerConstants.CAN_NOT_SAVE_RESULT_MESSAGE, e)
     }
-    return null
   }
 
   @Throws(IOException::class)

package/build/ExponentImagePicker.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@unimodules/core").ProxyNativeModule;
+declare const _default: import("expo-modules-core").ProxyNativeModule;
 export default _default;

package/build/ExponentImagePicker.js

@@ -1,3 +1,3 @@
-import { NativeModulesProxy } from '@unimodules/core';
+import { NativeModulesProxy } from 'expo-modules-core';
 export default NativeModulesProxy.ExponentImagePicker;
 //# sourceMappingURL=ExponentImagePicker.js.map