expo-camera 12.0.2 → 12.1.2

package/android/src/main/java/expo/modules/camera/Constants.kt

@@ -0,0 +1,184 @@
+package expo.modules.camera
+
+import androidx.exifinterface.media.ExifInterface
+import com.google.android.cameraview.Constants
+
+const val REACT_CLASS = "ExponentCamera"
+const val TAG = "ExponentCameraModule"
+const val ERROR_TAG = "E_CAMERA"
+
+const val VIDEO_2160P = 0
+const val VIDEO_1080P = 1
+const val VIDEO_720P = 2
+const val VIDEO_480P = 3
+const val VIDEO_4x3 = 4
+
+val typeConstants = mapOf(
+  "front" to Constants.FACING_FRONT,
+  "back" to Constants.FACING_BACK
+)
+
+val flashModeConstants = mapOf(
+  "off" to Constants.FLASH_OFF,
+  "on" to Constants.FLASH_ON,
+  "auto" to Constants.FLASH_AUTO,
+  "torch" to Constants.FLASH_TORCH
+)
+
+val autoFocusConstants = mapOf(
+  "on" to true,
+  "off" to false
+)
+
+val whiteBalanceConstants = mapOf(
+  "auto" to Constants.WB_AUTO,
+  "cloudy" to Constants.WB_CLOUDY,
+  "sunny" to Constants.WB_SUNNY,
+  "shadow" to Constants.WB_SHADOW,
+  "fluorescent" to Constants.WB_FLUORESCENT,
+  "incandescent" to Constants.WB_INCANDESCENT
+)
+
+val videoQualityConstants = mapOf(
+  "2160p" to VIDEO_2160P,
+  "1080p" to VIDEO_1080P,
+  "720p" to VIDEO_720P,
+  "480p" to VIDEO_480P,
+  "4:3" to VIDEO_4x3
+)
+
+val exifTags = 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("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),
+  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("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),
+  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/camera/ExpoCameraView.kt

@@ -0,0 +1,329 @@
+package expo.modules.camera
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Color
+import android.Manifest
+import android.media.CamcorderProfile
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.view.View
+
+import com.google.android.cameraview.CameraView
+
+import expo.modules.camera.CameraViewHelper.emitCameraReadyEvent
+import expo.modules.camera.CameraViewHelper.emitMountErrorEvent
+import expo.modules.camera.CameraViewHelper.getCorrectCameraRotation
+import expo.modules.camera.CameraViewHelper.emitPictureSavedEvent
+import expo.modules.camera.CameraViewHelper.getCamcorderProfile
+import expo.modules.camera.CameraViewHelper.emitBarCodeReadEvent
+import expo.modules.camera.CameraViewHelper.emitFacesDetectedEvent
+import expo.modules.camera.CameraViewHelper.emitFaceDetectionErrorEvent
+import expo.modules.camera.tasks.BarCodeScannerAsyncTaskDelegate
+import expo.modules.camera.tasks.FaceDetectorAsyncTaskDelegate
+import expo.modules.camera.tasks.PictureSavedDelegate
+import expo.modules.camera.tasks.ResolveTakenPictureAsyncTask
+import expo.modules.camera.tasks.BarCodeScannerAsyncTask
+import expo.modules.camera.tasks.FaceDetectorTask
+import expo.modules.camera.utils.FileSystemUtils
+import expo.modules.camera.utils.ImageDimensions
+import expo.modules.core.ModuleRegistryDelegate
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.LifecycleEventListener
+import expo.modules.core.interfaces.services.UIManager
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.interfaces.camera.CameraViewInterface
+import expo.modules.interfaces.barcodescanner.BarCodeScannerInterface
+import expo.modules.interfaces.facedetector.FaceDetectorInterface
+import expo.modules.interfaces.barcodescanner.BarCodeScannerProviderInterface
+import expo.modules.interfaces.barcodescanner.BarCodeScannerSettings
+import expo.modules.interfaces.barcodescanner.BarCodeScannerResult
+import expo.modules.interfaces.facedetector.FaceDetectorProviderInterface
+import expo.modules.interfaces.permissions.Permissions
+
+import java.io.File
+import java.io.IOException
+import java.lang.Exception
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentLinkedQueue
+
+private const val MUTE_KEY = "mute"
+private const val QUALITY_KEY = "quality"
+private const val FAST_MODE_KEY = "fastMode"
+private const val MAX_DURATION_KEY = "maxDuration"
+private const val MAX_FILE_SIZE_KEY = "maxFileSize"
+private const val VIDEO_BITRATE_KEY = "videoBitrate"
+
+class ExpoCameraView(
+  themedReactContext: Context,
+  private val moduleRegistryDelegate: ModuleRegistryDelegate = ModuleRegistryDelegate()
+) : CameraView(themedReactContext, true),
+  LifecycleEventListener,
+  BarCodeScannerAsyncTaskDelegate,
+  FaceDetectorAsyncTaskDelegate,
+  PictureSavedDelegate,
+  CameraViewInterface {
+
+  private inline fun <reified T> moduleRegistry() = moduleRegistryDelegate.getFromModuleRegistry<T>()
+  private val pictureTakenPromises: Queue<Promise> = ConcurrentLinkedQueue()
+  private val pictureTakenOptions: MutableMap<Promise, Map<String, Any>> = ConcurrentHashMap()
+  private val pictureTakenDirectories: MutableMap<Promise, File> = ConcurrentHashMap()
+  private var videoRecordedPromise: Promise? = null
+  private var isPaused = false
+  private var isNew = true
+  private val eventEmitter: EventEmitter by moduleRegistry()
+
+  // Concurrency lock for scanners to avoid flooding the runtime
+  @Volatile
+  var barCodeScannerTaskLock = false
+
+  @Volatile
+  var faceDetectorTaskLock = false
+
+  // Scanning-related properties
+  private var barCodeScanner: BarCodeScannerInterface? = null
+  private var faceDetector: FaceDetectorInterface? = null
+  private var pendingFaceDetectorSettings: Map<String, Any>? = null
+  private var shouldDetectFaces = false
+  private var mShouldScanBarCodes = false
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    val preview = view ?: return
+    setBackgroundColor(Color.BLACK)
+    val width = right - left
+    val height = bottom - top
+    preview.layout(0, 0, width, height)
+  }
+
+  @SuppressLint("MissingSuperCall")
+  override fun requestLayout() {
+    // React handles this for us, so we don't need to call super.requestLayout();
+  }
+
+  override fun onViewAdded(child: View) {
+    // react adds children to containers at the beginning of children list and that moves pre-react added preview to the end of that list
+    // above would cause preview (TextureView that covers all available space) to be rendered at the top of children stack
+    // while we need this preview to be rendered last beneath all other children
+
+    // child is not preview
+    if (this.view === child || this.view == null) {
+      return
+    }
+
+    // bring to front all non-preview children
+    val childrenToBeReordered = mutableListOf<View>()
+    for (i in 0 until this.childCount) {
+      val childView = getChildAt(i)
+      if (i == 0 && childView === this.view) {
+        // preview is already first in children list - do not reorder anything
+        return
+      }
+      if (childView !== this.view) {
+        childrenToBeReordered.add(childView)
+      }
+    }
+    for (childView in childrenToBeReordered) {
+      bringChildToFront(childView)
+    }
+    requestLayout()
+    invalidate()
+  }
+
+  fun takePicture(options: Map<String, Any>, promise: Promise, cacheDirectory: File) {
+    pictureTakenPromises.add(promise)
+    pictureTakenOptions[promise] = options
+    pictureTakenDirectories[promise] = cacheDirectory
+    try {
+      super.takePicture()
+    } catch (e: Exception) {
+      pictureTakenPromises.remove(promise)
+      pictureTakenOptions.remove(promise)
+      pictureTakenDirectories.remove(promise)
+      throw e
+    }
+  }
+
+  override fun onPictureSaved(response: Bundle) {
+    emitPictureSavedEvent(eventEmitter, this, response)
+  }
+
+  fun record(options: Map<String?, Any?>, promise: Promise, cacheDirectory: File) {
+    try {
+      val path = FileSystemUtils.generateOutputPath(cacheDirectory, "Camera", ".mp4")
+      val maxDuration = options[MAX_DURATION_KEY]?.let { it as Double } ?: -1.0
+      val maxFileSize = options[MAX_FILE_SIZE_KEY]?.let { it as Double } ?: -1.0
+      val profile = if (options[QUALITY_KEY] != null) {
+        getCamcorderProfile(cameraId, (options[QUALITY_KEY] as Double).toInt())
+      } else {
+        CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_HIGH)
+      }
+      options[VIDEO_BITRATE_KEY]?.let { profile.videoBitRate = (it as Double).toInt() }
+      val muteValue = options[MUTE_KEY] as Boolean?
+      val recordAudio = muteValue != true
+      if (super.record(path, maxDuration.toInt() * 1000, maxFileSize.toInt(), recordAudio, profile)) {
+        videoRecordedPromise = promise
+      } else {
+        promise.reject("E_RECORDING_FAILED", "Starting video recording failed. Another recording might be in progress.")
+      }
+    } catch (e: IOException) {
+      promise.reject("E_RECORDING_FAILED", "Starting video recording failed - could not create video file.")
+    }
+  }
+
+  /**
+   * Initialize the barcode scanner.
+   * Supports all iOS codes except [code138, code39mod43, itf14]
+   * Additionally supports [codabar, code128, maxicode, rss14, rssexpanded, upc_a, upc_ean]
+   */
+  private fun initBarCodeScanner() {
+    val barCodeScannerProvider: BarCodeScannerProviderInterface? by moduleRegistry()
+    barCodeScanner = barCodeScannerProvider?.createBarCodeDetectorWithContext(context)
+  }
+
+  fun setShouldScanBarCodes(shouldScanBarCodes: Boolean) {
+    mShouldScanBarCodes = shouldScanBarCodes
+    scanning = mShouldScanBarCodes || shouldDetectFaces
+  }
+
+  fun setBarCodeScannerSettings(settings: BarCodeScannerSettings) {
+    barCodeScanner?.setSettings(settings)
+  }
+
+  override fun onBarCodeScanned(barCode: BarCodeScannerResult) {
+    if (mShouldScanBarCodes) {
+      emitBarCodeReadEvent(eventEmitter, this, barCode)
+    }
+  }
+
+  override fun onBarCodeScanningTaskCompleted() {
+    barCodeScannerTaskLock = false
+  }
+
+  override fun getPreviewSizeAsArray() = intArrayOf(previewSize.width, previewSize.height)
+
+  override fun onHostResume() {
+    if (hasCameraPermissions()) {
+      if (isPaused && !isCameraOpened || isNew) {
+        isPaused = false
+        isNew = false
+        if (!Build.FINGERPRINT.contains("generic")) {
+          start()
+          val faceDetectorProvider: FaceDetectorProviderInterface? by moduleRegistry()
+          faceDetector = faceDetectorProvider?.createFaceDetectorWithContext(context)
+          pendingFaceDetectorSettings.let {
+            faceDetector?.setSettings(it)
+            pendingFaceDetectorSettings = null
+          }
+        }
+      }
+    } else {
+      emitMountErrorEvent(eventEmitter, this, "Camera permissions not granted - component could not be rendered.")
+    }
+  }
+
+  override fun onHostPause() {
+    if (!isPaused && isCameraOpened) {
+      faceDetector?.release()
+      isPaused = true
+      stop()
+    }
+  }
+
+  override fun onHostDestroy() {
+    faceDetector?.release()
+    stop()
+  }
+
+  private fun hasCameraPermissions(): Boolean {
+    val permissionsManager: Permissions by moduleRegistry()
+    return permissionsManager.hasGrantedPermissions(Manifest.permission.CAMERA)
+  }
+
+  fun setShouldDetectFaces(shouldDetectFaces: Boolean) {
+    this.shouldDetectFaces = shouldDetectFaces
+    scanning = mShouldScanBarCodes || shouldDetectFaces
+  }
+
+  fun setFaceDetectorSettings(settings: Map<String, Any>?) {
+    faceDetector?.setSettings(settings) ?: run {
+      pendingFaceDetectorSettings = settings
+    }
+  }
+
+  override fun onFacesDetected(faces: List<Bundle>) {
+    if (shouldDetectFaces) {
+      emitFacesDetectedEvent(eventEmitter, this, faces)
+    }
+  }
+
+  override fun onFaceDetectionError(faceDetector: FaceDetectorInterface) {
+    faceDetectorTaskLock = false
+    if (shouldDetectFaces) {
+      emitFaceDetectionErrorEvent(eventEmitter, this, faceDetector)
+    }
+  }
+
+  override fun onFaceDetectingTaskCompleted() {
+    faceDetectorTaskLock = false
+  }
+
+  init {
+    initBarCodeScanner()
+    isChildrenDrawingOrderEnabled = true
+    val uIManager: UIManager by moduleRegistry()
+    uIManager.registerLifecycleEventListener(this)
+    addCallback(object : Callback() {
+      override fun onCameraOpened(cameraView: CameraView) {
+        emitCameraReadyEvent(eventEmitter, cameraView)
+      }
+
+      override fun onMountError(cameraView: CameraView) {
+        emitMountErrorEvent(eventEmitter, cameraView, "Camera component could not be rendered - is there any other instance running?")
+      }
+
+      override fun onPictureTaken(cameraView: CameraView, data: ByteArray) {
+        val promise = pictureTakenPromises.poll()
+        val cacheDirectory = pictureTakenDirectories.remove(promise)
+        val options = pictureTakenOptions.remove(promise) as MutableMap
+        if (options.containsKey(FAST_MODE_KEY) && options[FAST_MODE_KEY] as Boolean) {
+          promise.resolve(null)
+        }
+        cacheDirectory?.let {
+          ResolveTakenPictureAsyncTask(data, promise, options, it, this@ExpoCameraView).execute()
+        }
+      }
+
+      override fun onVideoRecorded(cameraView: CameraView, path: String) {
+        videoRecordedPromise?.let {
+          it.resolve(
+            Bundle().apply {
+              putString("uri", Uri.fromFile(File(path)).toString())
+            }
+          )
+          videoRecordedPromise = null
+        }
+      }
+
+      override fun onFramePreview(cameraView: CameraView, data: ByteArray, width: Int, height: Int, rotation: Int) {
+        val correctRotation = getCorrectCameraRotation(rotation, facing)
+        if (mShouldScanBarCodes && !barCodeScannerTaskLock && cameraView is BarCodeScannerAsyncTaskDelegate) {
+          barCodeScannerTaskLock = true
+          val delegate = cameraView as BarCodeScannerAsyncTaskDelegate
+          barCodeScanner?.let { BarCodeScannerAsyncTask(delegate, it, data, width, height, rotation).execute() }
+        }
+        if (shouldDetectFaces && !faceDetectorTaskLock && cameraView is FaceDetectorAsyncTaskDelegate) {
+          faceDetectorTaskLock = true
+          val density = cameraView.resources.displayMetrics.density
+          val dimensions = ImageDimensions(width, height, correctRotation, facing)
+          val scaleX = cameraView.width.toDouble() / (dimensions.width * density)
+          val scaleY = cameraView.height.toDouble() / (dimensions.height * density)
+          val delegate = cameraView as FaceDetectorAsyncTaskDelegate
+          val task = faceDetector?.let { FaceDetectorTask(delegate, it, data, width, height, correctRotation, facing == FACING_FRONT, scaleX, scaleY) }
+          task?.execute()
+        }
+      }
+    })
+  }
+}

package/android/src/main/java/expo/modules/camera/events/BarCodeScannedEvent.kt

@@ -0,0 +1,50 @@
+package expo.modules.camera.events
+
+import android.os.Bundle
+import androidx.core.util.Pools
+
+import expo.modules.camera.CameraViewManager
+import expo.modules.core.interfaces.services.EventEmitter.BaseEvent
+import expo.modules.interfaces.barcodescanner.BarCodeScannerResult
+
+class BarCodeScannedEvent private constructor() : BaseEvent() {
+  private lateinit var barCode: BarCodeScannerResult
+  private var viewTag = 0
+
+  private fun init(viewTag: Int, barCode: BarCodeScannerResult) {
+    this.viewTag = viewTag
+    this.barCode = barCode
+  }
+
+  /**
+   * We want every distinct barcode to be reported to the JS listener.
+   * If we return some static value as a coalescing key there may be two barcode events
+   * containing two different barcodes waiting to be transmitted to JS
+   * that would get coalesced (because both of them would have the same coalescing key).
+   * So let's differentiate them with a hash of the contents (mod short's max value).
+   */
+  override fun getCoalescingKey(): Short {
+    val hashCode = barCode.value.hashCode() % Short.MAX_VALUE
+    return hashCode.toShort()
+  }
+
+  override fun getEventName() = CameraViewManager.Events.EVENT_ON_BAR_CODE_SCANNED.toString()
+
+  override fun getEventBody() = Bundle().apply {
+    putInt("target", viewTag)
+    putString("data", barCode.value)
+    putInt("type", barCode.type)
+  }
+
+  companion object {
+    private val EVENTS_POOL = Pools.SynchronizedPool<BarCodeScannedEvent>(3)
+    fun obtain(viewTag: Int, barCode: BarCodeScannerResult): BarCodeScannedEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = BarCodeScannedEvent()
+      }
+      event.init(viewTag, barCode)
+      return event
+    }
+  }
+}

package/android/src/main/java/expo/modules/camera/events/CameraMountErrorEvent.kt

@@ -0,0 +1,33 @@
+package expo.modules.camera.events
+
+import androidx.core.util.Pools
+import android.os.Bundle
+
+import expo.modules.camera.CameraViewManager
+import expo.modules.core.interfaces.services.EventEmitter.BaseEvent
+
+class CameraMountErrorEvent private constructor() : BaseEvent() {
+  private lateinit var message: String
+
+  private fun init(message: String) {
+    this.message = message
+  }
+
+  override fun getEventName() = CameraViewManager.Events.EVENT_ON_MOUNT_ERROR.toString()
+
+  override fun getEventBody() = Bundle().apply {
+    putString("message", message)
+  }
+
+  companion object {
+    private val EVENTS_POOL = Pools.SynchronizedPool<CameraMountErrorEvent>(3)
+    fun obtain(message: String): CameraMountErrorEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = CameraMountErrorEvent()
+      }
+      event.init(message)
+      return event
+    }
+  }
+}

package/android/src/main/java/expo/modules/camera/events/CameraReadyEvent.kt

@@ -0,0 +1,23 @@
+package expo.modules.camera.events
+
+import android.os.Bundle
+import androidx.core.util.Pools
+import expo.modules.camera.CameraViewManager
+import expo.modules.core.interfaces.services.EventEmitter.BaseEvent
+
+class CameraReadyEvent private constructor() : BaseEvent() {
+  override fun getEventName() = CameraViewManager.Events.EVENT_CAMERA_READY.toString()
+
+  override fun getEventBody(): Bundle = Bundle.EMPTY
+
+  companion object {
+    private val EVENTS_POOL = Pools.SynchronizedPool<CameraReadyEvent>(3)
+    fun obtain(): CameraReadyEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = CameraReadyEvent()
+      }
+      return event
+    }
+  }
+}

package/android/src/main/java/expo/modules/camera/events/FaceDetectionErrorEvent.kt

@@ -0,0 +1,39 @@
+package expo.modules.camera.events
+
+import android.os.Bundle
+import androidx.core.util.Pools
+
+import expo.modules.core.interfaces.services.EventEmitter.BaseEvent
+import expo.modules.interfaces.facedetector.FaceDetectorInterface
+import expo.modules.camera.CameraViewManager
+
+class FaceDetectionErrorEvent private constructor() : BaseEvent() {
+  private var faceDetector: FaceDetectorInterface? = null
+
+  private fun init(faceDetector: FaceDetectorInterface) {
+    this.faceDetector = faceDetector
+  }
+
+  override fun getCoalescingKey(): Short = 0
+
+  override fun getEventName() = CameraViewManager.Events.EVENT_ON_MOUNT_ERROR.toString()
+
+  override fun getEventBody() = Bundle().apply {
+    putBoolean("isOperational", isFaceDetectorOperational)
+  }
+
+  private val isFaceDetectorOperational: Boolean
+    get() = faceDetector != null
+
+  companion object {
+    private val EVENTS_POOL = Pools.SynchronizedPool<FaceDetectionErrorEvent>(3)
+    fun obtain(faceDetector: FaceDetectorInterface): FaceDetectionErrorEvent {
+      var event = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = FaceDetectionErrorEvent()
+      }
+      event.init(faceDetector)
+      return event
+    }
+  }
+}