expo-camera 12.0.0 → 12.1.0

package/CHANGELOG.md

@@ -10,6 +10,21 @@
 
 ### 💡 Others
 
+## 12.1.0 — 2021-12-03
+
+### 🐛 Bug fixes
+
+- Fix Gradle error when running Gradle from outside of the project directory. ([#15109](https://github.com/expo/expo/pull/15109) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Rewrite module to Kotlin. ([#14717](https://github.com/expo/expo/pull/14717) by [@mstach60161](https://github.com/mstach60161))
+- [plugin] Use more specific gradle variable name. ([#14966](https://github.com/expo/expo/pull/14966) by [@EvanBacon](https://github.com/EvanBacon))
+
+## 12.0.1 — 2021-10-01
+
+_This version does not introduce any user-facing changes._
+
 ## 12.0.0 — 2021-09-28
 
 ### 🛠 Breaking changes
@@ -20,6 +35,7 @@
 ### 🎉 New features
 
 - Add `useCameraPermissions` and `useMicrophonePermissions` hooks from modules factory. ([#13855](https://github.com/expo/expo/pull/13855) by [@bycedric](https://github.com/bycedric))
+- [plugin] Add monorepo support to Android config plugin for Gradle import. ([#14521](https://github.com/expo/expo/pull/14521) by [@EvanBacon](https://github.com/EvanBacon))
 
 ### 🐛 Bug fixes
 

package/README.md

@@ -13,7 +13,7 @@ For managed [managed](https://docs.expo.io/versions/latest/introduction/managed-
 
 # Installation in bare React Native projects
 
-For bare React Native projects, you must ensure that you have [installed and configured the `react-native-unimodules` package](https://github.com/expo/expo/tree/master/packages/react-native-unimodules) before continuing.
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
 
 ### Add the package to your npm dependencies
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '12.0.0'
+version = '12.1.0'
 
 buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
@@ -57,8 +57,13 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     versionCode 32
-    versionName "12.0.0"
+    versionName "12.1.0"
   }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_1_8
+  }
+
   lintOptions {
     abortOnError false
   }

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

@@ -0,0 +1,217 @@
+package expo.modules.camera
+
+import android.Manifest
+import android.content.Context
+import android.os.Build
+
+import com.google.android.cameraview.AspectRatio
+
+import expo.modules.camera.tasks.ResolveTakenPictureAsyncTask
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.core.ModuleRegistryDelegate
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.services.UIManager
+import expo.modules.interfaces.permissions.Permissions
+
+import java.lang.Exception
+
+class CameraModule(
+  context: Context,
+  private val moduleRegistryDelegate: ModuleRegistryDelegate = ModuleRegistryDelegate()
+) : ExportedModule(context) {
+
+  private inline fun <reified T> moduleRegistry() = moduleRegistryDelegate.getFromModuleRegistry<T>()
+  private val permissionsManager: Permissions by moduleRegistry()
+  private val uIManager: UIManager by moduleRegistry()
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    moduleRegistryDelegate.onCreate(moduleRegistry)
+  }
+
+  override fun getName() = TAG
+
+  override fun getConstants() = mapOf(
+    "Type" to typeConstants,
+    "FlashMode" to flashModeConstants,
+    "AutoFocus" to autoFocusConstants,
+    "WhiteBalance" to whiteBalanceConstants,
+    "VideoQuality" to videoQualityConstants,
+    "FaceDetection" to emptyMap<String, Any>(),
+  )
+
+  @ExpoMethod
+  fun pausePreview(viewTag: Int, promise: Promise) {
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          try {
+            if (view.isCameraOpened) {
+              view.pausePreview()
+            }
+          } catch (e: Exception) {
+            promise.reject(ERROR_TAG, "pausePreview -- exception occurred -- " + e.message, e)
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  @ExpoMethod
+  fun resumePreview(viewTag: Int, promise: Promise) {
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          try {
+            if (view.isCameraOpened) {
+              view.resumePreview()
+            }
+          } catch (e: Exception) {
+            promise.reject(ERROR_TAG, "resumePreview -- exception occurred -- " + e.message, e)
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  @ExpoMethod
+  fun takePicture(options: Map<String, Any>, viewTag: Int, promise: Promise) {
+    val cacheDirectory = context.cacheDir
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          if (!Build.FINGERPRINT.contains("generic")) {
+            if (view.isCameraOpened) {
+              view.takePicture(options, promise, cacheDirectory)
+            } else {
+              promise.reject("E_CAMERA_UNAVAILABLE", "Camera is not running")
+            }
+          } else {
+            val image = CameraViewHelper.generateSimulatorPhoto(view.width, view.height)
+            ResolveTakenPictureAsyncTask(image, promise, options, cacheDirectory, view).execute()
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  @ExpoMethod
+  fun record(options: Map<String?, Any?>, viewTag: Int, promise: Promise) {
+    if (permissionsManager.hasGrantedPermissions(Manifest.permission.RECORD_AUDIO)) {
+      val cacheDirectory = context.cacheDir
+      addUIBlock(
+        viewTag,
+        object : UIManager.UIBlock<ExpoCameraView> {
+          override fun resolve(view: ExpoCameraView) {
+            if (view.isCameraOpened) {
+              view.record(options, promise, cacheDirectory)
+            } else {
+              promise.reject("E_CAMERA_UNAVAILABLE", "Camera is not running")
+            }
+          }
+          override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+        }
+      )
+    } else {
+      promise.reject(SecurityException("User rejected audio permissions"))
+    }
+  }
+
+  @ExpoMethod
+  fun stopRecording(viewTag: Int, promise: Promise) {
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          if (view.isCameraOpened) {
+            view.stopRecording()
+            promise.resolve(true)
+          } else {
+            promise.reject(ERROR_TAG, "Camera is not open")
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  @ExpoMethod
+  fun getSupportedRatios(viewTag: Int, promise: Promise) {
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          if (view.isCameraOpened) {
+            promise.resolve(view.supportedAspectRatios.map { it.toString() })
+          } else {
+            promise.reject(ERROR_TAG, "Camera is not running")
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  @ExpoMethod
+  fun getAvailablePictureSizes(ratio: String?, viewTag: Int, promise: Promise) {
+    addUIBlock(
+      viewTag,
+      object : UIManager.UIBlock<ExpoCameraView> {
+        override fun resolve(view: ExpoCameraView) {
+          if (view.isCameraOpened) {
+            try {
+              val sizes = view.getAvailablePictureSizes(AspectRatio.parse(ratio))
+              promise.resolve(sizes.map { it.toString() })
+            } catch (e: Exception) {
+              promise.reject(ERROR_TAG, "getAvailablePictureSizes -- unexpected error -- " + e.message, e)
+            }
+          } else {
+            promise.reject(ERROR_TAG, "Camera is not running")
+          }
+        }
+        override fun reject(throwable: Throwable) = promise.reject(ERROR_TAG, throwable)
+      }
+    )
+  }
+
+  private fun addUIBlock(viewTag: Int, block: UIManager.UIBlock<ExpoCameraView>) {
+    uIManager.addUIBlock(viewTag, block, ExpoCameraView::class.java)
+  }
+
+  @ExpoMethod
+  fun requestPermissionsAsync(promise: Promise) {
+    permissionsManager.askForPermissionsWithPromise(promise, Manifest.permission.CAMERA)
+  }
+
+  @ExpoMethod
+  fun requestCameraPermissionsAsync(promise: Promise) {
+    permissionsManager.askForPermissionsWithPromise(promise, Manifest.permission.CAMERA)
+  }
+
+  @ExpoMethod
+  fun requestMicrophonePermissionsAsync(promise: Promise) {
+    permissionsManager.askForPermissionsWithPromise(promise, Manifest.permission.RECORD_AUDIO)
+  }
+
+  @ExpoMethod
+  fun getPermissionsAsync(promise: Promise) {
+    permissionsManager.getPermissionsWithPromise(promise, Manifest.permission.CAMERA)
+  }
+
+  @ExpoMethod
+  fun getCameraPermissionsAsync(promise: Promise) {
+    permissionsManager.getPermissionsWithPromise(promise, Manifest.permission.CAMERA)
+  }
+
+  @ExpoMethod
+  fun getMicrophonePermissionsAsync(promise: Promise) {
+    permissionsManager.getPermissionsWithPromise(promise, Manifest.permission.RECORD_AUDIO)
+  }
+}

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

@@ -0,0 +1,10 @@
+package expo.modules.camera
+
+import android.content.Context
+import expo.modules.core.BasePackage
+
+class CameraPackage : BasePackage() {
+  override fun createExportedModules(context: Context) = listOf(CameraModule(context))
+
+  override fun createViewManagers(context: Context) = listOf(CameraViewManager())
+}

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

@@ -0,0 +1,139 @@
+package expo.modules.camera
+
+import androidx.exifinterface.media.ExifInterface
+import android.graphics.Bitmap
+import android.graphics.Canvas
+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.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) =
+    if (facing == CameraView.FACING_FRONT) (rotation - 90 + 360) % 360
+    else (-rotation + 90 + 360) % 360
+
+  @JvmStatic
+  fun getCamcorderProfile(cameraId: Int, quality: Int): CamcorderProfile {
+    var profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_HIGH)
+    when (quality) {
+      VIDEO_2160P -> profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_2160P)
+      VIDEO_1080P -> profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_1080P)
+      VIDEO_720P -> profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_720P)
+      VIDEO_480P -> profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_480P)
+      VIDEO_4x3 -> {
+        profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_480P)
+        profile.videoFrameWidth = 640
+      }
+    }
+    return profile
+  }
+
+  @JvmStatic
+  fun getExifData(exifInterface: ExifInterface): Bundle {
+    val exifMap = Bundle()
+    for ((type, name) in exifTags) {
+      if (exifInterface.getAttribute(name) != null) {
+        when (type) {
+          "string" -> exifMap.putString(name, exifInterface.getAttribute(name))
+          "int" -> exifMap.putInt(name, exifInterface.getAttributeInt(name, 0))
+          "double" -> exifMap.putDouble(name, exifInterface.getAttributeDouble(name, 0.0))
+        }
+      }
+    }
+    exifInterface.latLong?.let {
+      exifMap.putDouble(ExifInterface.TAG_GPS_LATITUDE, it[0])
+      exifMap.putDouble(ExifInterface.TAG_GPS_LONGITUDE, it[1])
+      exifMap.putDouble(ExifInterface.TAG_GPS_ALTITUDE, exifInterface.getAltitude(0.0))
+    }
+    return exifMap
+  }
+
+  @JvmStatic
+  @Throws(IOException::class)
+  fun addExifData(baseExif: ExifInterface, additionalExif: ExifInterface) {
+    for (tagInfo in exifTags) {
+      val name = tagInfo[1]
+      additionalExif.getAttribute(name)?.let {
+        baseExif.setAttribute(name, it)
+      }
+    }
+    baseExif.saveAttributes()
+  }
+
+  fun generateSimulatorPhoto(width: Int, height: Int): Bitmap {
+    val fakePhoto = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(fakePhoto)
+    val background = Paint().apply {
+      color = Color.BLACK
+    }
+    canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), background)
+    val textPaint = Paint().apply {
+      color = Color.YELLOW
+      textSize = 35f
+    }
+    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
+  }
+}

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

@@ -0,0 +1,116 @@
+package expo.modules.camera
+
+import android.content.Context
+
+import com.google.android.cameraview.AspectRatio
+import com.google.android.cameraview.Size
+
+import expo.modules.core.interfaces.ExpoProp
+import expo.modules.core.interfaces.services.UIManager
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.ModuleRegistryDelegate
+import expo.modules.core.ViewManager
+import expo.modules.interfaces.barcodescanner.BarCodeScannerSettings
+
+class CameraViewManager(
+  private val moduleRegistryDelegate: ModuleRegistryDelegate = ModuleRegistryDelegate()
+) : ViewManager<ExpoCameraView>() {
+
+  private inline fun <reified T> moduleRegistry() = moduleRegistryDelegate.getFromModuleRegistry<T>()
+
+  enum class Events(private val eventsName: String) {
+    EVENT_CAMERA_READY("onCameraReady"),
+    EVENT_ON_MOUNT_ERROR("onMountError"),
+    EVENT_ON_BAR_CODE_SCANNED("onBarCodeScanned"),
+    EVENT_ON_FACES_DETECTED("onFacesDetected"),
+    EVENT_ON_FACE_DETECTION_ERROR("onFaceDetectionError"),
+    EVENT_ON_PICTURE_SAVED("onPictureSaved");
+    override fun toString() = eventsName
+  }
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    moduleRegistryDelegate.onCreate(moduleRegistry)
+  }
+
+  override fun onDropViewInstance(view: ExpoCameraView) {
+    val uIManager: UIManager by moduleRegistry()
+    uIManager.unregisterLifecycleEventListener(view)
+    view.stop()
+  }
+
+  override fun getName() = REACT_CLASS
+
+  override fun getViewManagerType() = ViewManagerType.GROUP
+
+  override fun createViewInstance(context: Context) =
+    ExpoCameraView(context, moduleRegistryDelegate)
+
+  override fun getExportedEventNames() = Events.values().map {
+    it.toString()
+  }
+
+  @ExpoProp(name = "type")
+  fun setType(view: ExpoCameraView, type: Int) {
+    view.facing = type
+  }
+
+  @ExpoProp(name = "ratio")
+  fun setRatio(view: ExpoCameraView, ratio: String?) {
+    view.setAspectRatio(AspectRatio.parse(ratio))
+  }
+
+  @ExpoProp(name = "flashMode")
+  fun setFlashMode(view: ExpoCameraView, torchMode: Int) {
+    view.flash = torchMode
+  }
+
+  @ExpoProp(name = "autoFocus")
+  fun setAutoFocus(view: ExpoCameraView, autoFocus: Boolean) {
+    view.autoFocus = autoFocus
+  }
+
+  @ExpoProp(name = "focusDepth")
+  fun setFocusDepth(view: ExpoCameraView, depth: Float) {
+    view.focusDepth = depth
+  }
+
+  @ExpoProp(name = "zoom")
+  fun setZoom(view: ExpoCameraView, zoom: Float) {
+    view.zoom = zoom
+  }
+
+  @ExpoProp(name = "whiteBalance")
+  fun setWhiteBalance(view: ExpoCameraView, whiteBalance: Int) {
+    view.whiteBalance = whiteBalance
+  }
+
+  @ExpoProp(name = "pictureSize")
+  fun setPictureSize(view: ExpoCameraView, size: String?) {
+    view.pictureSize = Size.parse(size)
+  }
+
+  @ExpoProp(name = "barCodeScannerSettings")
+  fun setBarCodeScannerSettings(view: ExpoCameraView, settings: Map<String?, Any?>?) {
+    view.setBarCodeScannerSettings(BarCodeScannerSettings(settings))
+  }
+
+  @ExpoProp(name = "useCamera2Api")
+  fun setUseCamera2Api(view: ExpoCameraView, useCamera2Api: Boolean) {
+    view.setUsingCamera2Api(useCamera2Api)
+  }
+
+  @ExpoProp(name = "barCodeScannerEnabled")
+  fun setBarCodeScanning(view: ExpoCameraView, barCodeScannerEnabled: Boolean) {
+    view.setShouldScanBarCodes(barCodeScannerEnabled)
+  }
+
+  @ExpoProp(name = "faceDetectorEnabled")
+  fun setFaceDetectorEnabled(view: ExpoCameraView, faceDetectorEnabled: Boolean) {
+    view.setShouldDetectFaces(faceDetectorEnabled)
+  }
+
+  @ExpoProp(name = "faceDetectorSettings")
+  fun setFaceDetectorSettings(view: ExpoCameraView, settings: Map<String, Any>?) {
+    view.setFaceDetectorSettings(settings)
+  }
+}