@onekeyfe/react-native-image-crop-picker 3.0.147

package/android/src/main/java/com/margelo/nitro/reactnativeimagecroppicker/ImageCropPickerImageProcessor.kt

@@ -0,0 +1,308 @@
+package com.margelo.nitro.reactnativeimagecroppicker
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.net.Uri
+import android.util.Base64
+import androidx.exifinterface.media.ExifInterface
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.util.UUID
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+internal data class ImageCropPickerConfig(
+  val width: Int?,
+  val height: Int?,
+  val cropping: Boolean,
+  val includeBase64: Boolean,
+  val compressImageQuality: Double?,
+  val compressImageMaxWidth: Double?,
+  val compressImageMaxHeight: Double?,
+  val freeStyleCropEnabled: Boolean,
+  val cropperCircleOverlay: Boolean,
+  val cropperToolbarTitle: String?,
+  val cropperActiveWidgetColor: String?,
+  val cropperToolbarColor: String?,
+  val cropperToolbarWidgetColor: String?,
+  val cropperStatusBarLight: Boolean,
+  val cropperNavigationBarLight: Boolean,
+  val showCropGuidelines: Boolean,
+  val showCropFrame: Boolean,
+  val enableRotationGesture: Boolean,
+  val hideBottomControls: Boolean,
+  val disableCropperColorSetters: Boolean,
+) {
+  companion object {
+    fun from(options: ImageCropPickerOptions, forceCropping: Boolean) = ImageCropPickerConfig(
+      width = options.width?.takeIf { it.isFinite() }?.roundToInt()?.takeIf { it > 0 },
+      height = options.height?.takeIf { it.isFinite() }?.roundToInt()?.takeIf { it > 0 },
+      cropping = forceCropping || options.cropping == true,
+      includeBase64 = options.includeBase64 == true,
+      compressImageQuality = options.compressImageQuality,
+      compressImageMaxWidth = options.compressImageMaxWidth,
+      compressImageMaxHeight = options.compressImageMaxHeight,
+      freeStyleCropEnabled = options.freeStyleCropEnabled == true,
+      cropperCircleOverlay = options.cropperCircleOverlay == true,
+      cropperToolbarTitle = options.cropperToolbarTitle,
+      cropperActiveWidgetColor = options.cropperActiveWidgetColor,
+      cropperToolbarColor = options.cropperToolbarColor,
+      cropperToolbarWidgetColor = options.cropperToolbarWidgetColor,
+      cropperStatusBarLight = options.cropperStatusBarLight ?: true,
+      cropperNavigationBarLight = options.cropperNavigationBarLight ?: false,
+      showCropGuidelines = options.showCropGuidelines ?: true,
+      showCropFrame = options.showCropFrame ?: true,
+      enableRotationGesture = options.enableRotationGesture == true,
+      hideBottomControls = options.hideBottomControls == true,
+      disableCropperColorSetters = options.disableCropperColorSetters == true,
+    )
+  }
+}
+
+internal object ImageCropPickerImageProcessor {
+  // Bounds memory for huge photos. Crop targets are far smaller than this.
+  private const val MAX_DECODED_PIXEL_SIZE = 4096
+
+  // Matches react-native-image-crop-picker on Android.
+  private const val DEFAULT_COMPRESS_QUALITY = 1.0
+  private const val TEMPORARY_DIRECTORY_NAME = "react-native-image-crop-picker"
+
+  fun temporaryDirectory(context: Context): File {
+    val directory = File(context.cacheDir, TEMPORARY_DIRECTORY_NAME)
+    if (!directory.isDirectory && !directory.mkdirs()) {
+      throw ImageCropPickerException.cannotSaveImage()
+    }
+    return directory
+  }
+
+  fun createTemporaryFile(context: Context, extension: String): File =
+    File(temporaryDirectory(context), "${UUID.randomUUID()}.$extension")
+
+  fun cleanTemporaryDirectory(context: Context) {
+    val directory = File(context.cacheDir, TEMPORARY_DIRECTORY_NAME)
+    if (directory.exists() && !directory.deleteRecursively()) {
+      throw ImageCropPickerException.cleanupFailed()
+    }
+  }
+
+  fun removeFile(path: String) {
+    val file = fileFromPath(path) ?: throw ImageCropPickerException.cleanupFailed()
+    if (!file.delete()) {
+      throw ImageCropPickerException.cleanupFailed()
+    }
+  }
+
+  private fun fileFromPath(path: String): File? = when {
+    path.startsWith("file://") -> Uri.parse(path).path?.let { File(it) }
+    path.startsWith("/") -> File(path)
+    else -> null
+  }
+
+  // Resolves an openCropper source into a Uri that uCrop can read. Returns the
+  // temporary file it had to create, if any, so the caller can delete it.
+  fun resolveCropSource(context: Context, path: String): Pair<Uri, File?> {
+    when {
+      path.startsWith("data:") -> {
+        val commaIndex = path.indexOf(',')
+        if (commaIndex < 0) {
+          throw ImageCropPickerException.cropperImageNotFound()
+        }
+        val bytes = try {
+          Base64.decode(path.substring(commaIndex + 1), Base64.DEFAULT)
+        } catch (error: IllegalArgumentException) {
+          throw ImageCropPickerException.cropperImageNotFound()
+        }
+        val file = createTemporaryFile(context, "img")
+        try {
+          file.writeBytes(bytes)
+        } catch (error: IOException) {
+          throw ImageCropPickerException.cannotSaveImage(error)
+        }
+        return Uri.fromFile(file) to file
+      }
+      // uCrop downloads remote sources and reads content URIs itself.
+      path.startsWith("http://") || path.startsWith("https://") || path.startsWith("content://") ->
+        return Uri.parse(path) to null
+      else -> {
+        val file = fileFromPath(path)
+        if (file == null || !file.isFile) {
+          throw ImageCropPickerException.cropperImageNotFound()
+        }
+        return Uri.fromFile(file) to null
+      }
+    }
+  }
+
+  // Decodes an image with its EXIF orientation applied, downsampled so its
+  // longest side is at most MAX_DECODED_PIXEL_SIZE.
+  fun decodeBitmap(context: Context, uri: Uri): Bitmap {
+    val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    openStream(context, uri).use { BitmapFactory.decodeStream(it, null, bounds) }
+    if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
+      throw ImageCropPickerException.noImageData("Invalid image selected")
+    }
+
+    var sampleSize = 1
+    while (max(bounds.outWidth, bounds.outHeight) / (sampleSize * 2) >= MAX_DECODED_PIXEL_SIZE) {
+      sampleSize *= 2
+    }
+    val options = BitmapFactory.Options().apply { inSampleSize = sampleSize }
+    val sampled = try {
+      openStream(context, uri).use { BitmapFactory.decodeStream(it, null, options) }
+    } catch (error: OutOfMemoryError) {
+      throw ImageCropPickerException.lowMemory(error)
+    } ?: throw ImageCropPickerException.noImageData("Invalid image selected")
+
+    val orientation = try {
+      openStream(context, uri).use {
+        ExifInterface(it).getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+      }
+    } catch (error: IOException) {
+      ExifInterface.ORIENTATION_NORMAL
+    }
+    val oriented = applyOrientation(sampled, orientation)
+    val scale = min(
+      MAX_DECODED_PIXEL_SIZE.toDouble() / oriented.width,
+      MAX_DECODED_PIXEL_SIZE.toDouble() / oriented.height,
+    )
+    return if (scale < 1.0) {
+      scaleBitmap(oriented, floorSize(oriented.width * scale), floorSize(oriented.height * scale))
+    } else {
+      oriented
+    }
+  }
+
+  // Scales a cropped image to the requested size; smaller crops are scaled up.
+  // With a locked aspect ratio the crop can still end up a few pixels off that
+  // ratio, so the result is scaled to exactly the requested size, as
+  // react-native-image-crop-picker did. Free-style crops keep their own aspect
+  // ratio and fit inside it.
+  fun resizeCroppedBitmap(bitmap: Bitmap, config: ImageCropPickerConfig): Bitmap {
+    val width = config.width ?: return bitmap
+    val height = config.height ?: return bitmap
+    if (!config.freeStyleCropEnabled) {
+      return scaleBitmap(bitmap, width, height)
+    }
+    val widthRatio = width.toDouble() / bitmap.width
+    val heightRatio = height.toDouble() / bitmap.height
+    return if (widthRatio < heightRatio) {
+      scaleBitmap(bitmap, width, roundSize(bitmap.height * widthRatio))
+    } else {
+      scaleBitmap(bitmap, roundSize(bitmap.width * heightRatio), height)
+    }
+  }
+
+  fun makeResult(
+    context: Context,
+    bitmap: Bitmap,
+    config: ImageCropPickerConfig,
+    cropRect: CropRect?,
+    filename: String?,
+  ): PickedImage {
+    var output = bitmap
+    val maxWidth = config.compressImageMaxWidth
+    val maxHeight = config.compressImageMaxHeight
+    val shouldResizeWidth = maxWidth != null && maxWidth < output.width
+    val shouldResizeHeight = maxHeight != null && maxHeight < output.height
+    if (shouldResizeWidth || shouldResizeHeight) {
+      val scale = min(
+        (maxWidth ?: output.width.toDouble()) / output.width,
+        (maxHeight ?: output.height.toDouble()) / output.height,
+      )
+      output = scaleBitmap(output, floorSize(output.width * scale), floorSize(output.height * scale))
+    }
+
+    val quality = ((config.compressImageQuality ?: DEFAULT_COMPRESS_QUALITY).coerceIn(0.0, 1.0) * 100).roundToInt()
+    val file = createTemporaryFile(context, "jpg")
+    try {
+      FileOutputStream(file).use { stream ->
+        if (!output.compress(Bitmap.CompressFormat.JPEG, quality, stream)) {
+          throw ImageCropPickerException.cannotSaveImage()
+        }
+      }
+    } catch (error: IOException) {
+      file.delete()
+      throw ImageCropPickerException.cannotSaveImage(error)
+    }
+
+    val data = if (config.includeBase64) {
+      Base64.encodeToString(file.readBytes(), Base64.NO_WRAP)
+    } else {
+      null
+    }
+    return PickedImage(
+      path = Uri.fromFile(file).toString(),
+      size = file.length().toDouble(),
+      width = output.width.toDouble(),
+      height = output.height.toDouble(),
+      mime = "image/jpeg",
+      data = data,
+      cropRect = cropRect,
+      filename = filename,
+    )
+  }
+
+  private fun openStream(context: Context, uri: Uri): InputStream =
+    try {
+      context.contentResolver.openInputStream(uri)
+    } catch (error: Exception) {
+      null
+    } ?: throw ImageCropPickerException.noImageData()
+
+  private fun floorSize(value: Double): Int = max(1, floor(value).toInt())
+
+  private fun roundSize(value: Double): Int = max(1, value.roundToInt())
+
+  private fun scaleBitmap(bitmap: Bitmap, width: Int, height: Int): Bitmap {
+    if (width == bitmap.width && height == bitmap.height) {
+      return bitmap
+    }
+    val scaled = try {
+      Bitmap.createScaledBitmap(bitmap, width, height, true)
+    } catch (error: OutOfMemoryError) {
+      throw ImageCropPickerException.lowMemory(error)
+    }
+    if (scaled !== bitmap) {
+      bitmap.recycle()
+    }
+    return scaled
+  }
+
+  private fun applyOrientation(bitmap: Bitmap, orientation: Int): Bitmap {
+    val matrix = Matrix()
+    when (orientation) {
+      ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.setScale(-1f, 1f)
+      ExifInterface.ORIENTATION_ROTATE_180 -> matrix.setRotate(180f)
+      ExifInterface.ORIENTATION_FLIP_VERTICAL -> {
+        matrix.setRotate(180f)
+        matrix.postScale(-1f, 1f)
+      }
+      ExifInterface.ORIENTATION_TRANSPOSE -> {
+        matrix.setRotate(90f)
+        matrix.postScale(-1f, 1f)
+      }
+      ExifInterface.ORIENTATION_ROTATE_90 -> matrix.setRotate(90f)
+      ExifInterface.ORIENTATION_TRANSVERSE -> {
+        matrix.setRotate(-90f)
+        matrix.postScale(-1f, 1f)
+      }
+      ExifInterface.ORIENTATION_ROTATE_270 -> matrix.setRotate(-90f)
+      else -> return bitmap
+    }
+    val oriented = try {
+      Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+    } catch (error: OutOfMemoryError) {
+      throw ImageCropPickerException.lowMemory(error)
+    }
+    if (oriented !== bitmap) {
+      bitmap.recycle()
+    }
+    return oriented
+  }
+}

package/android/src/main/java/com/margelo/nitro/reactnativeimagecroppicker/ImageCropPickerSession.kt

@@ -0,0 +1,297 @@
+package com.margelo.nitro.reactnativeimagecroppicker
+
+import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.provider.OpenableColumns
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResult
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.PickVisualMediaRequest
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.result.contract.ActivityResultContracts
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nativelogger.OneKeyLog
+import com.yalantis.ucrop.UCrop
+import com.yalantis.ucrop.UCropActivity
+import java.io.File
+import java.util.UUID
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+// One picker or cropper flow. It owns the JS promise until the launched
+// activities report back, and settles it exactly once.
+internal class ImageCropPickerSession(
+  private val activity: ComponentActivity,
+  private val mode: Mode,
+  private val config: ImageCropPickerConfig,
+  private val promise: Promise<PickedImage>,
+  private val onFinish: (ImageCropPickerSession) -> Unit,
+) {
+  sealed class Mode {
+    object Picker : Mode()
+
+    class Cropper(val path: String) : Mode()
+  }
+
+  // Main thread state.
+  private val keyPrefix = "onekey-image-crop-picker-${UUID.randomUUID()}"
+  private val launchers = mutableListOf<ActivityResultLauncher<*>>()
+  private val temporaryFiles = mutableListOf<File>()
+  private var pickedFilename: String? = null
+  private var isAwaitingResult = false
+  private var isProcessing = false
+  private var isFinished = false
+
+  // Whether a launched activity or background work is still pending.
+  val isActive: Boolean
+    get() = !isFinished && (isProcessing || (isAwaitingResult && !activity.isDestroyed))
+
+  fun start() {
+    when (mode) {
+      is Mode.Picker -> launchPicker()
+      is Mode.Cropper -> resolveCropperSource(mode.path)
+    }
+  }
+
+  // Settles a session whose activity went away without calling back.
+  fun abandon() {
+    finish(Result.failure(ImageCropPickerException.cancelled()))
+  }
+
+  // The system Photo Picker needs no storage or media permission. On devices
+  // without it, PickVisualMedia falls back to ACTION_OPEN_DOCUMENT.
+  private fun launchPicker() {
+    val launcher = register(ActivityResultContracts.PickVisualMedia()) { uri ->
+      when {
+        uri == null -> finish(Result.failure(ImageCropPickerException.cancelled()))
+        config.cropping -> {
+          pickedFilename = queryDisplayName(uri)
+          launchCropper(uri)
+        }
+        else -> processPickedImage(uri)
+      }
+    }
+    launch {
+      launcher.launch(
+        PickVisualMediaRequest.Builder()
+          .setMediaType(ActivityResultContracts.PickVisualMedia.ImageOnly)
+          .build(),
+      )
+    }
+  }
+
+  private fun processPickedImage(uri: Uri) {
+    val filename = queryDisplayName(uri)
+    runInBackground(
+      work = {
+        ImageCropPickerImageProcessor.makeResult(
+          activity,
+          ImageCropPickerImageProcessor.decodeBitmap(activity, uri),
+          config,
+          null,
+          filename,
+        )
+      },
+      onComplete = ::finish,
+    )
+  }
+
+  private fun resolveCropperSource(path: String) {
+    runInBackground(
+      work = { ImageCropPickerImageProcessor.resolveCropSource(activity, path) },
+      onComplete = { result ->
+        result.fold(
+          onSuccess = { (source, temporaryFile) ->
+            temporaryFile?.let { temporaryFiles.add(it) }
+            launchCropper(source)
+          },
+          onFailure = { finish(Result.failure(it)) },
+        )
+      },
+    )
+  }
+
+  private fun launchCropper(source: Uri) {
+    val destination = try {
+      ImageCropPickerImageProcessor.createTemporaryFile(activity, "jpg")
+    } catch (error: ImageCropPickerException) {
+      finish(Result.failure(error))
+      return
+    }
+    temporaryFiles.add(destination)
+
+    val cropper = UCrop.of(source, Uri.fromFile(destination)).withOptions(buildCropOptions())
+    if (config.width != null && config.height != null) {
+      cropper.withAspectRatio(config.width.toFloat(), config.height.toFloat())
+    }
+    val launcher = register(ActivityResultContracts.StartActivityForResult()) { result ->
+      handleCropResult(result)
+    }
+    launch { launcher.launch(cropper.getIntent(activity)) }
+  }
+
+  private fun handleCropResult(result: ActivityResult) {
+    val data = result.data
+    when (result.resultCode) {
+      Activity.RESULT_OK -> {
+        val output = data?.let { UCrop.getOutput(it) }
+        if (data == null || output == null) {
+          finish(Result.failure(ImageCropPickerException.noImageData()))
+          return
+        }
+        val cropRect = CropRect(
+          x = data.getIntExtra(UCrop.EXTRA_OUTPUT_OFFSET_X, -1).toDouble(),
+          y = data.getIntExtra(UCrop.EXTRA_OUTPUT_OFFSET_Y, -1).toDouble(),
+          width = data.getIntExtra(UCrop.EXTRA_OUTPUT_IMAGE_WIDTH, -1).toDouble(),
+          height = data.getIntExtra(UCrop.EXTRA_OUTPUT_IMAGE_HEIGHT, -1).toDouble(),
+        )
+        val filename = pickedFilename
+        runInBackground(
+          work = {
+            val cropped = ImageCropPickerImageProcessor.decodeBitmap(activity, output)
+            ImageCropPickerImageProcessor.makeResult(
+              activity,
+              ImageCropPickerImageProcessor.resizeCroppedBitmap(cropped, config),
+              config,
+              cropRect,
+              filename,
+            )
+          },
+          onComplete = ::finish,
+        )
+      }
+      UCrop.RESULT_ERROR -> {
+        val message = data?.let { UCrop.getError(it)?.message } ?: "Cannot crop image"
+        finish(Result.failure(ImageCropPickerException.noImageData(message)))
+      }
+      else -> finish(Result.failure(ImageCropPickerException.cancelled()))
+    }
+  }
+
+  private fun buildCropOptions(): UCrop.Options = UCrop.Options().apply {
+    setCompressionFormat(Bitmap.CompressFormat.JPEG)
+    setCompressionQuality(100)
+    setCircleDimmedLayer(config.cropperCircleOverlay)
+    setFreeStyleCropEnabled(config.freeStyleCropEnabled)
+    setShowCropGrid(config.showCropGuidelines)
+    setShowCropFrame(config.showCropFrame)
+    setHideBottomControls(config.hideBottomControls)
+    config.cropperToolbarTitle?.let { setToolbarTitle(it) }
+    if (config.enableRotationGesture) {
+      setAllowedGestures(UCropActivity.ALL, UCropActivity.ALL, UCropActivity.ALL)
+    }
+    if (!config.disableCropperColorSetters) {
+      parseColor(config.cropperActiveWidgetColor)?.let { setActiveControlsWidgetColor(it) }
+      parseColor(config.cropperToolbarColor)?.let { setToolbarColor(it) }
+      parseColor(config.cropperToolbarWidgetColor)?.let { setToolbarWidgetColor(it) }
+      setStatusBarLight(config.cropperStatusBarLight)
+      setNavigationBarLight(config.cropperNavigationBarLight)
+    }
+  }
+
+  private fun <I, O> register(
+    contract: ActivityResultContract<I, O>,
+    callback: (O) -> Unit,
+  ): ActivityResultLauncher<I> {
+    val key = "$keyPrefix-${launchers.size}"
+    val launcher = activity.activityResultRegistry.register(key, contract) { output ->
+      isAwaitingResult = false
+      if (!isFinished) {
+        callback(output)
+      }
+    }
+    launchers.add(launcher)
+    return launcher
+  }
+
+  private fun launch(block: () -> Unit) {
+    isAwaitingResult = true
+    try {
+      block()
+    } catch (error: Exception) {
+      isAwaitingResult = false
+      finish(Result.failure(ImageCropPickerException.failedToShowPicker(error)))
+    }
+  }
+
+  private fun <T> runInBackground(work: () -> T, onComplete: (Result<T>) -> Unit) {
+    isProcessing = true
+    executor.execute {
+      val result = try {
+        Result.success(work())
+      } catch (error: ImageCropPickerException) {
+        Result.failure(error)
+      } catch (error: OutOfMemoryError) {
+        Result.failure(ImageCropPickerException.lowMemory(error))
+      } catch (error: Exception) {
+        Result.failure(ImageCropPickerException.noImageData(error.message ?: "Cannot process image"))
+      }
+      mainHandler.post {
+        isProcessing = false
+        if (!isFinished) {
+          onComplete(result)
+        }
+      }
+    }
+  }
+
+  private fun finish(result: Result<PickedImage>) {
+    if (isFinished) {
+      return
+    }
+    isFinished = true
+    isAwaitingResult = false
+
+    // Unregister outside of the registry's dispatch callback.
+    val finishedLaunchers = launchers.toList()
+    launchers.clear()
+    mainHandler.post { finishedLaunchers.forEach { it.unregister() } }
+
+    val filesToDelete = temporaryFiles.toList()
+    temporaryFiles.clear()
+    if (filesToDelete.isNotEmpty()) {
+      executor.execute { filesToDelete.forEach { it.delete() } }
+    }
+
+    result.fold(
+      onSuccess = { promise.resolve(it) },
+      onFailure = { error ->
+        if ((error as? ImageCropPickerException)?.code != ImageCropPickerException.E_PICKER_CANCELLED) {
+          OneKeyLog.warn(TAG, error.message ?: error.toString())
+        }
+        promise.reject(error)
+      },
+    )
+    onFinish(this)
+  }
+
+  private fun queryDisplayName(uri: Uri): String? {
+    val displayName = try {
+      activity.contentResolver
+        .query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
+        ?.use { cursor -> if (cursor.moveToFirst()) cursor.getString(0) else null }
+    } catch (error: Exception) {
+      null
+    }
+    return displayName ?: uri.lastPathSegment
+  }
+
+  private fun parseColor(value: String?): Int? =
+    value?.let {
+      try {
+        Color.parseColor(it)
+      } catch (error: IllegalArgumentException) {
+        null
+      }
+    }
+
+  companion object {
+    private const val TAG = "ImageCropPicker"
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val executor: ExecutorService = Executors.newSingleThreadExecutor()
+  }
+}

package/android/src/main/java/com/margelo/nitro/reactnativeimagecroppicker/ReactNativeImageCropPicker.kt

@@ -0,0 +1,69 @@
+package com.margelo.nitro.reactnativeimagecroppicker
+
+import android.os.Handler
+import android.os.Looper
+import androidx.activity.ComponentActivity
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+
+@DoNotStrip
+class ReactNativeImageCropPicker : HybridReactNativeImageCropPickerSpec() {
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  // Main thread only.
+  private var activeSession: ImageCropPickerSession? = null
+
+  override fun openPicker(options: ImageCropPickerOptions): Promise<PickedImage> =
+    startSession(
+      ImageCropPickerSession.Mode.Picker,
+      ImageCropPickerConfig.from(options, forceCropping = false),
+    )
+
+  override fun openCropper(path: String, options: ImageCropPickerOptions): Promise<PickedImage> =
+    startSession(
+      ImageCropPickerSession.Mode.Cropper(path),
+      ImageCropPickerConfig.from(options, forceCropping = true),
+    )
+
+  override fun clean(): Promise<Unit> =
+    Promise.parallel {
+      val context = NitroModules.applicationContext ?: throw ImageCropPickerException.cleanupFailed()
+      ImageCropPickerImageProcessor.cleanTemporaryDirectory(context)
+    }
+
+  override fun cleanSingle(path: String): Promise<Unit> =
+    Promise.parallel { ImageCropPickerImageProcessor.removeFile(path) }
+
+  private fun startSession(
+    mode: ImageCropPickerSession.Mode,
+    config: ImageCropPickerConfig,
+  ): Promise<PickedImage> {
+    val promise = Promise<PickedImage>()
+    mainHandler.post {
+      activeSession?.let { session ->
+        if (session.isActive) {
+          promise.reject(ImageCropPickerException.inProgress())
+          return@post
+        }
+        // Its activity went away without calling back; don't block new requests on it.
+        session.abandon()
+      }
+
+      val activity = NitroModules.applicationContext?.currentActivity as? ComponentActivity
+      if (activity == null || activity.isFinishing || activity.isDestroyed) {
+        promise.reject(ImageCropPickerException.noActivity())
+        return@post
+      }
+
+      val session = ImageCropPickerSession(activity, mode, config, promise) { finishedSession ->
+        if (activeSession === finishedSession) {
+          activeSession = null
+        }
+      }
+      activeSession = session
+      session.start()
+    }
+    return promise
+  }
+}

package/android/src/main/java/com/margelo/nitro/reactnativeimagecroppicker/ReactNativeImageCropPickerPackage.kt

@@ -0,0 +1,24 @@
+package com.margelo.nitro.reactnativeimagecroppicker
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeImageCropPickerPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativeimagecroppicker")
+        }
+    }
+}
+
+