expo-camera 12.3.0 → 13.0.0-beta.1

package/CHANGELOG.md

@@ -10,6 +10,27 @@
 
 ### 💡 Others
 
+## 13.0.0-beta.1 — 2022-10-06
+
+### 🛠 Breaking changes
+
+- [plugin] Upgrade minimum runtime requirement to Node 14 (LTS). ([#18204](https://github.com/expo/expo/pull/18204) by [@EvanBacon](https://github.com/EvanBacon))
+- Bumped iOS deployment target to 13.0 and deprecated support for iOS 12. ([#18873](https://github.com/expo/expo/pull/18873) by [@tsapeta](https://github.com/tsapeta))
+
+### 🎉 New features
+
+- On iOS and Android, added new `additionalExif` parameter to `takePictureAsync()` method so that users can add extra information to the photos, such as GPS coordinates. ([#18469](https://github.com/expo/expo/pull/18469) by [@alexyangjie](https://github.com/alexyangjie))
+- Native module for camera view is now written in Swift using the new API. ([#18703](https://github.com/expo/expo/pull/18703) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- Fix error when calling `takePictureAsync()` on Android emulator. ([#18704](https://github.com/expo/expo/pull/18704)) by [@keith-kurak](https://github.com/keith-kurak))
+
+### 💡 Others
+
+- Drop `@expo/config-plugins` dependency in favor of peer dependency on `expo`. ([#18595](https://github.com/expo/expo/pull/18595) by [@EvanBacon](https://github.com/EvanBacon))
+- Refactored inline Android emulator checks to use enhanced checking in `EmulatorUtilities.isRunningOnEmulator()`. ([#16177](https://github.com/expo/expo/pull/16177)) by [@kbrandwijk](https://github.com/kbrandwijk), [@keith-kurak](https://github.com/keith-kurak))
+
 ## 12.3.0 — 2022-07-07
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '12.3.0'
+version = '13.0.0-beta.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 32
-    versionName "12.3.0"
+    versionName "13.0.0-beta.1"
   }
 
   lintOptions {

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

@@ -0,0 +1,7 @@
+package expo.modules.camera
+
+import expo.modules.kotlin.exception.CodedException
+
+class CameraExceptions {
+  class CameraIsNotRunning : CodedException(message = "Camera is not running")
+}

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

@@ -7,65 +7,15 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.media.CamcorderProfile
 import android.os.Bundle
-import android.view.ViewGroup
 
 import com.google.android.cameraview.CameraView
 
-import expo.modules.camera.events.CameraMountErrorEvent
-import expo.modules.camera.events.CameraReadyEvent
-import expo.modules.interfaces.barcodescanner.BarCodeScannerResult
-import expo.modules.core.interfaces.services.EventEmitter
-import expo.modules.camera.events.FacesDetectedEvent
-import expo.modules.interfaces.facedetector.FaceDetectorInterface
-import expo.modules.camera.events.FaceDetectionErrorEvent
-import expo.modules.camera.events.PictureSavedEvent
-import expo.modules.camera.events.BarCodeScannedEvent
+import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.text.SimpleDateFormat
 import java.util.*
 
 object CameraViewHelper {
-  // Mount error event
-  @JvmStatic
-  fun emitMountErrorEvent(emitter: EventEmitter, view: ViewGroup, message: String) {
-    val event = CameraMountErrorEvent.obtain(message)
-    emitter.emit(view.id, event)
-  }
-
-  // Camera ready event
-  @JvmStatic
-  fun emitCameraReadyEvent(emitter: EventEmitter, view: ViewGroup) {
-    val event = CameraReadyEvent.obtain()
-    emitter.emit(view.id, event)
-  }
-
-  // Bar code read event
-  @JvmStatic
-  fun emitBarCodeReadEvent(emitter: EventEmitter, view: ViewGroup, barCode: BarCodeScannerResult) {
-    val event = BarCodeScannedEvent.obtain(view.id, barCode)
-    emitter.emit(view.id, event)
-  }
-
-  // Face detection events
-  @JvmStatic
-  fun emitFacesDetectedEvent(emitter: EventEmitter, view: ViewGroup, faces: List<Bundle>) {
-    val event = FacesDetectedEvent.obtain(view.id, faces)
-    emitter.emit(view.id, event)
-  }
-
-  @JvmStatic
-  fun emitFaceDetectionErrorEvent(emitter: EventEmitter, view: ViewGroup, faceDetector: FaceDetectorInterface) {
-    val event = FaceDetectionErrorEvent.obtain(faceDetector)
-    emitter.emit(view.id, event)
-  }
-
-  // Picture saved
-  @JvmStatic
-  fun emitPictureSavedEvent(emitter: EventEmitter, view: ViewGroup, info: Bundle) {
-    val event = PictureSavedEvent.obtain(info)
-    emitter.emit(view.id, event)
-  }
-
   // Utilities
   @JvmStatic
   fun getCorrectCameraRotation(rotation: Int, facing: Int) =
@@ -108,6 +58,38 @@ object CameraViewHelper {
     return exifMap
   }
 
+  @JvmStatic
+  @Throws(IllegalArgumentException::class)
+  fun setExifData(baseExif: ExifInterface, exifMap: Map<String, Any>) {
+    for ((_, name) in exifTags) {
+      exifMap[name]?.let {
+        // Convert possible type to string before putting into baseExif
+        when (it) {
+          is String -> baseExif.setAttribute(name, it)
+          is Number -> baseExif.setAttribute(name, it.toDouble().toBigDecimal().toPlainString())
+          is Boolean -> baseExif.setAttribute(name, it.toString())
+        }
+      }
+    }
+
+    if (exifMap.containsKey(ExifInterface.TAG_GPS_LATITUDE) &&
+      exifMap.containsKey(ExifInterface.TAG_GPS_LONGITUDE) &&
+      exifMap[ExifInterface.TAG_GPS_LATITUDE] is Number &&
+      exifMap[ExifInterface.TAG_GPS_LONGITUDE] is Number
+    ) {
+      baseExif.setLatLong(
+        exifMap[ExifInterface.TAG_GPS_LATITUDE] as Double,
+        exifMap[ExifInterface.TAG_GPS_LONGITUDE] as Double
+      )
+    }
+
+    if (exifMap.containsKey(ExifInterface.TAG_GPS_ALTITUDE) &&
+      exifMap[ExifInterface.TAG_GPS_ALTITUDE] is Number
+    ) {
+      baseExif.setAltitude(exifMap[ExifInterface.TAG_GPS_ALTITUDE] as Double)
+    }
+  }
+
   @JvmStatic
   @Throws(IOException::class)
   fun addExifData(baseExif: ExifInterface, additionalExif: ExifInterface) {
@@ -120,9 +102,9 @@ object CameraViewHelper {
     baseExif.saveAttributes()
   }
 
-  fun generateSimulatorPhoto(width: Int, height: Int): Bitmap {
-    val fakePhoto = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-    val canvas = Canvas(fakePhoto)
+  fun generateSimulatorPhoto(width: Int, height: Int): ByteArray {
+    val fakePhotoBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(fakePhotoBitmap)
     val background = Paint().apply {
       color = Color.BLACK
     }
@@ -134,6 +116,10 @@ object CameraViewHelper {
     val calendar = Calendar.getInstance()
     val simpleDateFormat = SimpleDateFormat("dd.MM.yy HH:mm:ss", Locale.US)
     canvas.drawText(simpleDateFormat.format(calendar.time), width * 0.1f, height * 0.9f, textPaint)
-    return fakePhoto
+
+    val stream = ByteArrayOutputStream()
+    fakePhotoBitmap.compress(Bitmap.CompressFormat.PNG, 90, stream)
+    val fakePhotoByteArray = stream.toByteArray()
+    return fakePhotoByteArray
   }
 }

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

@@ -0,0 +1,264 @@
+package expo.modules.camera
+
+import android.Manifest
+import android.content.Context
+import com.google.android.cameraview.AspectRatio
+import com.google.android.cameraview.Size
+import expo.modules.camera.tasks.ResolveTakenPictureAsyncTask
+import expo.modules.core.interfaces.services.UIManager
+import expo.modules.core.utilities.EmulatorUtilities
+import expo.modules.interfaces.barcodescanner.BarCodeScannerSettings
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.functions.Queues
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class CameraViewModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExponentCamera")
+
+    Constants(
+      "Type" to mapOf(
+        "front" to com.google.android.cameraview.Constants.FACING_FRONT,
+        "back" to com.google.android.cameraview.Constants.FACING_BACK
+      ),
+      "FlashMode" to mapOf(
+        "off" to com.google.android.cameraview.Constants.FLASH_OFF,
+        "on" to com.google.android.cameraview.Constants.FLASH_ON,
+        "auto" to com.google.android.cameraview.Constants.FLASH_AUTO,
+        "torch" to com.google.android.cameraview.Constants.FLASH_TORCH
+      ),
+      "AutoFocus" to mapOf(
+        "on" to true,
+        "off" to false
+      ),
+      "WhiteBalance" to mapOf(
+        "auto" to com.google.android.cameraview.Constants.WB_AUTO,
+        "cloudy" to com.google.android.cameraview.Constants.WB_CLOUDY,
+        "sunny" to com.google.android.cameraview.Constants.WB_SUNNY,
+        "shadow" to com.google.android.cameraview.Constants.WB_SHADOW,
+        "fluorescent" to com.google.android.cameraview.Constants.WB_FLUORESCENT,
+        "incandescent" to com.google.android.cameraview.Constants.WB_INCANDESCENT
+      ),
+      "VideoQuality" to mapOf(
+        "2160p" to VIDEO_2160P,
+        "1080p" to VIDEO_1080P,
+        "720p" to VIDEO_720P,
+        "480p" to VIDEO_480P,
+        "4:3" to VIDEO_4x3
+      ),
+    )
+
+    AsyncFunction("pausePreview") { viewTag: Int ->
+      val view = findView(viewTag)
+
+      if (view.cameraView.isCameraOpened) {
+        view.cameraView.pausePreview()
+      }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("resumePreview") { viewTag: Int ->
+      val view = findView(viewTag)
+
+      if (view.cameraView.isCameraOpened) {
+        view.cameraView.resumePreview()
+      }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("takePicture") { options: PictureOptions, viewTag: Int, promise: Promise ->
+      val cacheDirectory = reactContext.cacheDir
+      val view = findView(viewTag)
+
+      if (!EmulatorUtilities.isRunningOnEmulator()) {
+        if (!view.cameraView.isCameraOpened) {
+          throw CameraExceptions.CameraIsNotRunning()
+        }
+
+        view.takePicture(options, promise, cacheDirectory)
+      } else {
+        val image = CameraViewHelper.generateSimulatorPhoto(view.width, view.height)
+        ResolveTakenPictureAsyncTask(image, promise, options, cacheDirectory, view).execute()
+      }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("record") { options: RecordingOptions, viewTag: Int, promise: Promise ->
+      if (!permissionsManager.hasGrantedPermissions(Manifest.permission.RECORD_AUDIO)) {
+        throw Exceptions.MissingPermissions(Manifest.permission.RECORD_AUDIO)
+      }
+
+      val cacheDirectory = reactContext.cacheDir
+      val view = findView(viewTag)
+
+      if (!view.cameraView.isCameraOpened) {
+        throw CameraExceptions.CameraIsNotRunning()
+      }
+
+      view.record(options, promise, cacheDirectory)
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("stopRecording") { viewTag: Int ->
+      val view = findView(viewTag)
+
+      if (view.cameraView.isCameraOpened) {
+        view.cameraView.stopRecording()
+      }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("getSupportedRatios") { viewTag: Int ->
+      val view = findView(viewTag)
+
+      if (!view.cameraView.isCameraOpened) {
+        throw CameraExceptions.CameraIsNotRunning()
+      }
+
+      return@AsyncFunction view.cameraView.supportedAspectRatios.map { it.toString() }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("getAvailablePictureSizes") { ratio: String?, viewTag: Int ->
+      val view = findView(viewTag)
+
+      if (!view.cameraView.isCameraOpened) {
+        throw CameraExceptions.CameraIsNotRunning()
+      }
+
+      val sizes = view.cameraView.getAvailablePictureSizes(AspectRatio.parse(ratio))
+      return@AsyncFunction sizes.map { it.toString() }
+    }.runOnQueue(Queues.MAIN)
+
+    AsyncFunction("requestPermissionsAsync") { promise: Promise ->
+      Permissions.askForPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("requestCameraPermissionsAsync") { promise: Promise ->
+      Permissions.askForPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("requestMicrophonePermissionsAsync") { promise: Promise ->
+      Permissions.askForPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.RECORD_AUDIO
+      )
+    }
+
+    AsyncFunction("getPermissionsAsync") { promise: Promise ->
+      Permissions.getPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("getCameraPermissionsAsync") { promise: Promise ->
+      Permissions.getPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("getMicrophonePermissionsAsync") { promise: Promise ->
+      Permissions.getPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.RECORD_AUDIO
+      )
+    }
+
+    View(ExpoCameraView::class) {
+      Events(
+        "onCameraReady",
+        "onMountError",
+        "onBarCodeScanned",
+        "onFacesDetected",
+        "onFaceDetectionError",
+        "onPictureSaved"
+      )
+
+      OnViewDestroys<ExpoCameraView> { view ->
+        val uiManager = appContext.legacyModule<UIManager>()
+        uiManager?.unregisterLifecycleEventListener(view)
+        view.cameraView.stop()
+      }
+
+      Prop("type") { view: ExpoCameraView, type: Int ->
+        view.cameraView.facing = type
+      }
+
+      Prop("ratio") { view: ExpoCameraView, ratio: String? ->
+        if (ratio == null) {
+          return@Prop
+        }
+        view.cameraView.setAspectRatio(AspectRatio.parse(ratio))
+      }
+
+      Prop("flashMode") { view: ExpoCameraView, torchMode: Int ->
+        view.cameraView.flash = torchMode
+      }
+
+      Prop("autoFocus") { view: ExpoCameraView, autoFocus: Boolean ->
+        view.cameraView.autoFocus = autoFocus
+      }
+
+      Prop("focusDepth") { view: ExpoCameraView, depth: Float ->
+        view.cameraView.focusDepth = depth
+      }
+
+      Prop("zoom") { view: ExpoCameraView, zoom: Float ->
+        view.cameraView.zoom = zoom
+      }
+
+      Prop("whiteBalance") { view: ExpoCameraView, whiteBalance: Int ->
+        view.cameraView.whiteBalance = whiteBalance
+      }
+
+      Prop("pictureSize") { view: ExpoCameraView, size: String? ->
+        if (size == null) {
+          return@Prop
+        }
+        view.cameraView.pictureSize = Size.parse(size)
+      }
+
+      Prop("barCodeScannerSettings") { view: ExpoCameraView, settings: Map<String, Any?>? ->
+        view.setBarCodeScannerSettings(BarCodeScannerSettings(settings))
+      }
+
+      Prop("useCamera2Api") { view: ExpoCameraView, useCamera2Api: Boolean ->
+        view.cameraView.setUsingCamera2Api(useCamera2Api)
+      }
+
+      Prop("barCodeScannerEnabled") { view: ExpoCameraView, barCodeScannerEnabled: Boolean ->
+        view.setShouldScanBarCodes(barCodeScannerEnabled)
+      }
+
+      Prop("faceDetectorEnabled") { view: ExpoCameraView, faceDetectorEnabled: Boolean ->
+        view.setShouldDetectFaces(faceDetectorEnabled)
+      }
+
+      Prop("faceDetectorSettings") { view: ExpoCameraView, settings: Map<String, Any>? ->
+        view.setFaceDetectorSettings(settings)
+      }
+    }
+  }
+
+  private val reactContext: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  private val permissionsManager: Permissions
+    get() = appContext.permissions ?: throw Exceptions.PermissionsModuleNotFound()
+
+  private fun findView(viewTag: Int): ExpoCameraView {
+    return appContext.findView(viewTag)
+      ?: throw Exceptions.ViewNotFound(ExpoCameraView::class, viewTag)
+  }
+}

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

@@ -0,0 +1,30 @@
+package expo.modules.camera
+
+import android.os.Bundle
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class BarCodeScannedEvent(
+  @Field val target: Int,
+  @Field val data: String,
+  @Field val type: Int
+) : Record
+
+data class CameraMountErrorEvent(
+  @Field val message: String
+) : Record
+
+data class FaceDetectionErrorEvent(
+  @Field val isOperational: Boolean
+) : Record
+
+data class FacesDetectedEvent(
+  @Field val type: String,
+  @Field val faces: List<Bundle>,
+  @Field val target: Int
+) : Record
+
+data class PictureSavedEvent(
+  @Field val id: Int,
+  @Field val data: Bundle
+) : Record

package/android/src/main/java/expo/modules/camera/{Constants.kt → ExifTags.kt}

@@ -1,11 +1,6 @@
 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
@@ -13,40 +8,6 @@ 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),