expo-camera 13.7.0 → 13.9.0

package/CHANGELOG.md

@@ -10,6 +10,36 @@
 
 ### 💡 Others
 
+## 13.9.0 — 2023-11-14
+
+### 🛠 Breaking changes
+
+- Bumped iOS deployment target to 13.4. ([#25063](https://github.com/expo/expo/pull/25063) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+- On `Android` bump `compileSdkVersion` and `targetSdkVersion` to `34`. ([#24708](https://github.com/expo/expo/pull/24708) by [@alanjhughes](https://github.com/alanjhughes))
+
+### 🎉 New features
+
+- [iOS] Rewrote Objective-C classes to Swift. ([#22604](https://github.com/expo/expo/pull/22604) by [@alanjhughes](https://github.com/alanjhughes))
+
+### 🐛 Bug fixes
+
+- [iOS] Fix a regression from ([#22604](https://github.com/expo/expo/pull/22604) that prevented the barcode scanner from starting.([#25053](https://github.com/expo/expo/pull/25053) by [@alanjhughes](https://github.com/alanjhughes))
+
+### 💡 Others
+
+- Use `pointerEvent` style instead of prop. ([#24931](https://github.com/expo/expo/pull/24931) by [@EvanBacon](https://github.com/EvanBacon))
+
+## 13.8.0 — 2023-10-17
+
+### 🛠 Breaking changes
+
+- Dropped support for Android SDK 21 and 22. ([#24201](https://github.com/expo/expo/pull/24201) by [@behenate](https://github.com/behenate))
+- Mark the `ratio` param of `getAvailablePictureSizes` as required because omitting it causes a crash on Android. On iOS, the param has no effect. ([#24234](https://github.com/expo/expo/pull/24234) by [@vonovak](https://github.com/vonovak))
+
+### 💡 Others
+
+- Ship untranspiled JSX to support custom handling of `jsx` and `createElement`. ([#24889](https://github.com/expo/expo/pull/24889) by [@EvanBacon](https://github.com/EvanBacon))
+
 ## 13.7.0 — 2023-09-15
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -3,15 +3,20 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '13.7.0'
-
-buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
+version = '13.9.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+if (expoModulesCorePlugin.exists()) {
+  apply from: expoModulesCorePlugin
+  applyKotlinExpoModulesCorePlugin()
+  // Remove this check, but keep the contents after SDK49 support is dropped
+  if (safeExtGet("expoProvidesDefaultConfig", false)) {
+    useExpoPublishing()
+    useCoreDependencies()
   }
+}
 
+buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -35,23 +40,44 @@ buildscript {
   }
 }
 
-afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
+// Remove this if and it's contents, when support for SDK49 is dropped
+if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+  afterEvaluate {
+    publishing {
+      publications {
+        release(MavenPublication) {
+          from components.release
+        }
       }
-    }
-    repositories {
-      maven {
-        url = mavenLocal().url
+      repositories {
+        maven {
+          url = mavenLocal().url
+        }
       }
     }
   }
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 23)
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+
+    publishing {
+      singleVariant("release") {
+        withSourcesJar()
+      }
+    }
+
+    lintOptions {
+      abortOnError false
+    }
+  }
 
   def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
   if (agpVersion.tokenize('.')[0].toInteger() < 8) {
@@ -67,19 +93,8 @@ android {
 
   namespace "expo.modules.camera"
   defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 32
-    versionName "13.7.0"
-  }
-
-  lintOptions {
-    abortOnError false
-  }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
-    }
+    versionName "13.9.0"
   }
 }
 
@@ -91,10 +106,25 @@ repositories {
 }
 
 dependencies {
-  implementation project(':expo-modules-core')
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  }
+  def camerax_version = "1.3.0"
 
-  api "androidx.exifinterface:exifinterface:1.0.0"
+  api "androidx.exifinterface:exifinterface:1.3.6"
   api 'com.google.android:cameraview:1.0.0'
 
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation "androidx.camera:camera-core:${camerax_version}"
+  implementation "androidx.camera:camera-camera2:${camerax_version}"
+  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
+  implementation "androidx.camera:camera-video:${camerax_version}"
+
+  implementation "androidx.camera:camera-view:${camerax_version}"
+  implementation "androidx.camera:camera-extensions:${camerax_version}"
+  implementation "com.google.mlkit:barcode-scanning:17.2.0"
+  implementation 'androidx.camera:camera-mlkit-vision:1.4.0-alpha02'
+
+  api 'com.google.android:cameraview:1.0.0'
 }

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
   <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
 </manifest>

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

@@ -17,7 +17,7 @@ import java.io.File
 
 class CameraViewModule : Module() {
   override fun definition() = ModuleDefinition {
-    Name("ExponentCamera")
+    Name("ExpoCamera")
 
     Constants(
       "Type" to mapOf(
@@ -114,7 +114,7 @@ class CameraViewModule : Module() {
       return@AsyncFunction view.cameraView.supportedAspectRatios.map { it.toString() }
     }.runOnQueue(Queues.MAIN)
 
-    AsyncFunction("getAvailablePictureSizes") { ratio: String?, viewTag: Int ->
+    AsyncFunction("getAvailablePictureSizes") { ratio: String, viewTag: Int ->
       val view = findView(viewTag)
 
       if (!view.cameraView.isCameraOpened) {

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

@@ -16,8 +16,8 @@ class PictureOptions : Record {
 }
 
 class RecordingOptions : Record {
-  @Field val maxDuration: Int = -1
-  @Field val maxFileSize: Int = -1
+  @Field val maxDuration: Int = 0
+  @Field val maxFileSize: Int = 0
   @Field val quality: Int = CamcorderProfile.QUALITY_HIGH
   @Field val mute: Boolean = false
   @Field val videoBitrate: Int? = null

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

@@ -0,0 +1,9 @@
+package expo.modules.camera.next
+
+import expo.modules.kotlin.exception.CodedException
+
+class CameraExceptions {
+  class ImageCaptureFailed : CodedException(message = "Failed to capture image")
+
+  class VideoRecordingFailed(cause: String?) : CodedException("Video recording failed: $cause")
+}

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

@@ -0,0 +1,40 @@
+package expo.modules.camera.next
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import expo.modules.camera.next.records.CameraType
+import java.io.ByteArrayOutputStream
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Locale
+
+object CameraViewHelper {
+  // Utilities
+  @JvmStatic
+  fun getCorrectCameraRotation(rotation: Int, facing: CameraType) =
+    if (facing == CameraType.FRONT) (rotation - 90 + 360) % 360
+    else (-rotation + 90 + 360) % 360
+
+  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
+    }
+    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)
+
+    val stream = ByteArrayOutputStream()
+    fakePhotoBitmap.compress(Bitmap.CompressFormat.PNG, 90, stream)
+    val fakePhotoByteArray = stream.toByteArray()
+    return fakePhotoByteArray
+  }
+}

package/android/src/main/java/expo/modules/camera/next/CameraViewNextModule.kt

@@ -0,0 +1,158 @@
+package expo.modules.camera.next
+
+import android.Manifest
+import android.util.Log
+import expo.modules.camera.next.records.BarCodeSettings
+import expo.modules.camera.next.records.CameraMode
+import expo.modules.camera.next.records.CameraType
+import expo.modules.camera.next.records.FlashMode
+import expo.modules.camera.next.tasks.ResolveTakenPicture
+import expo.modules.core.errors.ModuleDestroyedException
+import expo.modules.core.utilities.EmulatorUtilities
+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
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.io.File
+
+val cameraEvents = arrayOf(
+  "onCameraReady",
+  "onMountError",
+  "onBarCodeScanned",
+  "onFacesDetected",
+  "onFaceDetectionError",
+  "onPictureSaved"
+)
+
+class CameraViewNextModule : Module() {
+  private val moduleScope = CoroutineScope(Dispatchers.Main)
+  override fun definition() = ModuleDefinition {
+    Name("ExpoCameraNext")
+
+    Events("onModernBarcodeScanned")
+
+    AsyncFunction("requestCameraPermissionsAsync") { promise: Promise ->
+      Permissions.askForPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("requestMicrophonePermissionsAsync") { promise: Promise ->
+      Permissions.askForPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.RECORD_AUDIO
+      )
+    }
+
+    AsyncFunction("getCameraPermissionsAsync") { promise: Promise ->
+      Permissions.getPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.CAMERA
+      )
+    }
+
+    AsyncFunction("getMicrophonePermissionsAsync") { promise: Promise ->
+      Permissions.getPermissionsWithPermissionsManager(
+        permissionsManager,
+        promise,
+        Manifest.permission.RECORD_AUDIO
+      )
+    }
+
+    OnDestroy {
+      try {
+        moduleScope.cancel(ModuleDestroyedException())
+      } catch (e: IllegalStateException) {
+        Log.e(TAG, "The scope does not have a job in it")
+      }
+    }
+
+    View(ExpoCameraView::class) {
+      Events(cameraEvents)
+
+      Prop("type") { view, type: CameraType ->
+        view.lenFacing = type
+      }
+
+      Prop("flashMode") { view, flashMode: FlashMode ->
+        view.setCameraFlashMode(flashMode)
+      }
+
+      Prop("enableTorch") { view, enabled: Boolean ->
+        view.setTorchEnabled(enabled)
+      }
+
+      Prop("zoom") { view, zoom: Float ->
+        view.camera?.cameraControl?.setLinearZoom(zoom)
+      }
+
+      Prop("mode") { view, mode: CameraMode ->
+        view.cameraMode = mode
+      }
+
+      Prop("mute") { view, muted: Boolean? ->
+        view.mute = muted ?: false
+      }
+
+      Prop("barCodeScannerSettings") { view, settings: BarCodeSettings? ->
+        if (settings == null) {
+          return@Prop
+        }
+        view.setBarCodeScannerSettings(settings)
+      }
+
+      Prop("barCodeScannerEnabled") { view, barCodeScannerEnabled: Boolean? ->
+        view.setShouldScanBarCodes(barCodeScannerEnabled ?: false)
+      }
+
+      AsyncFunction("takePicture") { view: ExpoCameraView, options: PictureOptions, promise: Promise ->
+        if (!EmulatorUtilities.isRunningOnEmulator()) {
+          view.takePicture(options, promise, cacheDirectory)
+        } else {
+          val image = CameraViewHelper.generateSimulatorPhoto(view.width, view.height)
+          moduleScope.launch {
+            ResolveTakenPicture(image, promise, options, cacheDirectory) { response ->
+              view.onPictureSaved(response)
+            }.resolve()
+          }
+        }
+      }.runOnQueue(Queues.MAIN)
+
+      AsyncFunction("record") { view: ExpoCameraView, options: RecordingOptions, promise: Promise ->
+        if (!view.mute && !permissionsManager.hasGrantedPermissions(Manifest.permission.RECORD_AUDIO)) {
+          throw Exceptions.MissingPermissions(Manifest.permission.RECORD_AUDIO)
+        }
+
+        view.record(options, promise, cacheDirectory)
+      }.runOnQueue(Queues.MAIN)
+
+      AsyncFunction("stopRecording") { view: ExpoCameraView ->
+        view.activeRecording?.close()
+      }.runOnQueue(Queues.MAIN)
+
+      OnViewDestroys { view ->
+        view.cancelCoroutineScope()
+      }
+    }
+  }
+
+  private val cacheDirectory: File
+    get() = appContext.cacheDirectory
+
+  private val permissionsManager: Permissions
+    get() = appContext.permissions ?: throw Exceptions.PermissionsModuleNotFound()
+
+  companion object {
+    internal val TAG = CameraViewNextModule::class.java.simpleName
+  }
+}