capacitor-camera-view 2.4.0 → 3.0.0

package/android/src/main/java/com/michaelwolz/capacitorcameraview/CameraViewPlugin.kt

@@ -52,7 +52,7 @@ class CameraViewPlugin : Plugin() {
         if (getPermissionState("camera") == PermissionState.GRANTED) {
             startCamera(call)
         } else {
-            call.reject("Permission is required to take a picture")
+            call.reject("Permission is required to take a picture", CameraError.PERMISSION_DENIED)
         }
     }
 
@@ -60,21 +60,35 @@ class CameraViewPlugin : Plugin() {
         val config = sessionConfigFromPluginCall(call)
 
         pluginScope.launch {
+            // Cancel any previous collector and, if this session wants barcode
+            // detection, subscribe a fresh one *before* starting the session.
+            // `barcodeEvents` has replay = 0, so a detection emitted between
+            // analyzer attachment (inside startSessionAsync -> bindToLifecycle)
+            // and collector subscription would otherwise be silently dropped -
+            // subscribing here, before startSessionAsync even runs, closes
+            // that window entirely. pluginScope uses Dispatchers.Main.immediate,
+            // so this nested launch's `collect` call registers its slot on the
+            // SharedFlow synchronously before control returns here.
+            barcodeJob?.cancel()
+            barcodeJob = if (config.enableBarcodeDetection) {
+                pluginScope.launch {
+                    implementation.barcodeEvents.collect { result ->
+                        notifyBarcodeDetected(result)
+                    }
+                }
+            } else {
+                null
+            }
+
             implementation.startSessionAsync(config).fold(
                 onSuccess = {
-                    // Subscribe to barcode events if detection is enabled
-                    if (config.enableBarcodeDetection) {
-                        barcodeJob?.cancel()
-                        barcodeJob = pluginScope.launch {
-                            implementation.barcodeEvents.collect { result ->
-                                notifyBarcodeDetected(result)
-                            }
-                        }
-                    }
                     call.resolve()
                 },
                 onError = { error ->
-                    call.reject("Failed to start camera preview: ${error.localizedMessage}", error)
+                    // The session never started - don't leak a live collector.
+                    barcodeJob?.cancel()
+                    barcodeJob = null
+                    call.reject("Failed to start camera preview: ${error.localizedMessage}", error.cameraErrorCode, error)
                 }
             )
         }
@@ -90,7 +104,7 @@ class CameraViewPlugin : Plugin() {
             implementation.stopSessionAsync().fold(
                 onSuccess = { call.resolve() },
                 onError = { error ->
-                    call.reject("Failed to stop camera preview: ${error.localizedMessage}", error)
+                    call.reject("Failed to stop camera preview: ${error.localizedMessage}", error.cameraErrorCode, error)
                 }
             )
         }
@@ -111,7 +125,7 @@ class CameraViewPlugin : Plugin() {
         val saveToFile = call.getBoolean("saveToFile") ?: false
 
         if (quality !in 0..100) {
-            call.reject("Quality must be between 0 and 100")
+            call.reject("Quality must be between 0 and 100", CameraError.INVALID_ARGUMENT)
             return
         }
 
@@ -122,7 +136,7 @@ class CameraViewPlugin : Plugin() {
                     Log.d(TAG, "capture took ${System.currentTimeMillis() - timeStart}ms")
                 },
                 onError = { error ->
-                    call.reject("Failed to capture image: ${error.message}", error)
+                    call.reject("Failed to capture image: ${error.message}", error.cameraErrorCode, error)
                     Log.d(TAG, "capture failed after ${System.currentTimeMillis() - timeStart}ms")
                 }
             )
@@ -136,7 +150,7 @@ class CameraViewPlugin : Plugin() {
         val saveToFile = call.getBoolean("saveToFile") ?: false
 
         if (quality !in 0..100) {
-            call.reject("Quality must be between 0 and 100")
+            call.reject("Quality must be between 0 and 100", CameraError.INVALID_ARGUMENT)
             return
         }
 
@@ -147,7 +161,7 @@ class CameraViewPlugin : Plugin() {
                     Log.d(TAG, "captureSample took ${System.currentTimeMillis() - timeStart}ms")
                 },
                 onError = { error ->
-                    call.reject("Failed to capture frame: ${error.message}", error)
+                    call.reject("Failed to capture frame: ${error.message}", error.cameraErrorCode, error)
                     Log.d(
                         TAG,
                         "captureSample failed after ${System.currentTimeMillis() - timeStart}ms"
@@ -201,7 +215,10 @@ class CameraViewPlugin : Plugin() {
         val videoQuality =
             parseVideoRecordingQuality(call.getString("videoQuality"))
                 ?: run {
-                    call.reject("Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest")
+                    call.reject(
+                        "Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest",
+                        CameraError.INVALID_ARGUMENT
+                    )
                     return
                 }
 
@@ -220,12 +237,15 @@ class CameraViewPlugin : Plugin() {
             val videoQuality =
                 parseVideoRecordingQuality(call.getString("videoQuality"))
                     ?: run {
-                        call.reject("Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest")
+                        call.reject(
+                            "Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest",
+                            CameraError.INVALID_ARGUMENT
+                        )
                         return
                     }
             doStartRecording(call, enableAudio, videoQuality)
         } else {
-            call.reject("Microphone permission is required for audio recording")
+            call.reject("Microphone permission is required for audio recording", CameraError.PERMISSION_DENIED)
         }
     }
 
@@ -242,7 +262,7 @@ class CameraViewPlugin : Plugin() {
             implementation.startRecordingAsync(enableAudio, videoQuality).fold(
                 onSuccess = { call.resolve() },
                 onError = { error ->
-                    call.reject("Failed to start recording: ${error.message}", error)
+                    call.reject("Failed to start recording: ${error.message}", error.cameraErrorCode, error)
                 }
             )
         }
@@ -254,7 +274,7 @@ class CameraViewPlugin : Plugin() {
             implementation.stopRecordingAsync().fold(
                 onSuccess = { result -> call.resolve(result) },
                 onError = { error ->
-                    call.reject("Failed to stop recording: ${error.message}", error)
+                    call.reject("Failed to stop recording: ${error.message}", error.cameraErrorCode, error)
                 }
             )
         }
@@ -269,6 +289,7 @@ class CameraViewPlugin : Plugin() {
                     put("id", device.id)
                     put("name", device.name)
                     put("position", device.position)
+                    device.deviceType?.let { put("deviceType", it) }
                 })
             }
         }
@@ -280,7 +301,7 @@ class CameraViewPlugin : Plugin() {
     fun flipCamera(call: PluginCall) {
         implementation.flipCamera { error ->
             if (error != null) {
-                call.reject("Failed to flip camera: ${error.localizedMessage}", error)
+                call.reject("Failed to flip camera: ${error.localizedMessage}", error.cameraErrorCode, error)
             } else {
                 call.resolve()
             }
@@ -302,13 +323,32 @@ class CameraViewPlugin : Plugin() {
     fun setZoom(call: PluginCall) {
         val level = call.getFloat("level")
         if (level == null) {
-            call.reject("Zoom level must be provided")
+            call.reject("Zoom level must be provided", CameraError.INVALID_ARGUMENT)
             return
         }
 
         implementation.setZoomFactor(level) { error ->
             if (error != null) {
-                call.reject(error.localizedMessage)
+                call.reject(error.localizedMessage ?: "Failed to set zoom level", error.cameraErrorCode, error)
+            } else {
+                call.resolve()
+            }
+        }
+    }
+
+    @PluginMethod
+    fun setFocusPoint(call: PluginCall) {
+        val x = call.getFloat("x")
+        val y = call.getFloat("y")
+
+        if (x == null || y == null) {
+            call.reject("Focus point x and y must be provided", CameraError.INVALID_ARGUMENT)
+            return
+        }
+
+        implementation.setFocusPoint(x, y) { error ->
+            if (error != null) {
+                call.reject("Failed to set focus point: ${error.localizedMessage}", error.cameraErrorCode, error)
             } else {
                 call.resolve()
             }
@@ -337,21 +377,22 @@ class CameraViewPlugin : Plugin() {
     fun setFlashMode(call: PluginCall) {
         val mode = call.getString("mode")
         if (mode == null) {
-            call.reject("Flash mode must be provided")
+            call.reject("Flash mode must be provided", CameraError.INVALID_ARGUMENT)
             return
         }
 
         val validModes = listOf("off", "on", "auto")
         if (!validModes.contains(mode)) {
-            call.reject("Invalid flash mode. Must be one of: ${validModes.joinToString(", ")}")
+            call.reject("Invalid flash mode. Must be one of: ${validModes.joinToString(", ")}", CameraError.INVALID_ARGUMENT)
             return
         }
 
-        try {
-            implementation.setFlashMode(mode)
-            call.resolve()
-        } catch (e: Exception) {
-            call.reject("Failed to set flash mode: ${e.localizedMessage}", e)
+        implementation.setFlashMode(mode) { error ->
+            if (error != null) {
+                call.reject("Failed to set flash mode: ${error.localizedMessage}", error.cameraErrorCode, error)
+            } else {
+                call.resolve()
+            }
         }
     }
 
@@ -366,14 +407,10 @@ class CameraViewPlugin : Plugin() {
 
     @PluginMethod
     fun getTorchMode(call: PluginCall) {
-        implementation.getTorchMode { enabled ->
+        implementation.getTorchMode { state ->
             call.resolve(JSObject().apply {
-                put("enabled", enabled)
-                put(
-                    "level",
-                    // Android always uses full intensity when enabled
-                    if (enabled) 1.0f else 0.0f
-                )
+                put("enabled", state.enabled)
+                put("level", state.level)
             })
         }
     }
@@ -382,13 +419,19 @@ class CameraViewPlugin : Plugin() {
     fun setTorchMode(call: PluginCall) {
         val enabled = call.getBoolean("enabled")
         if (enabled == null) {
-            call.reject("Enabled parameter is required")
+            call.reject("Enabled parameter is required", CameraError.INVALID_ARGUMENT)
+            return
+        }
+
+        val level = call.getFloat("level")
+        if (level != null && (level < 0.0f || level > 1.0f)) {
+            call.reject("Level must be between 0.0 and 1.0", CameraError.INVALID_ARGUMENT)
             return
         }
 
-        implementation.setTorchMode(enabled) { error ->
+        implementation.setTorchMode(enabled, level) { error ->
             if (error != null) {
-                call.reject("Failed to set torch mode: ${error.localizedMessage}", error)
+                call.reject("Failed to set torch mode: ${error.localizedMessage}", error.cameraErrorCode, error)
             } else {
                 call.resolve()
             }
@@ -396,9 +439,10 @@ class CameraViewPlugin : Plugin() {
     }
 
     /**
-     * Called by the CameraView when a barcode is detected.
+     * Notifies JS listeners of a barcode detection collected from
+     * [CameraView.barcodeEvents].
      */
-    fun notifyBarcodeDetected(result: BarcodeDetectionResult) {
+    private fun notifyBarcodeDetected(result: BarcodeDetectionResult) {
         val rawBytesArray = JSArray().apply {
             result.rawBytes.forEach { put(it.toInt() and 0xFF) }
         }

package/android/src/main/java/com/michaelwolz/capacitorcameraview/model/BarcodeDetectionResult.kt

@@ -1,7 +1,13 @@
 package com.michaelwolz.capacitorcameraview.model
 
 /**
- * Barcode detection result containing the value, format type, and normalized bounding rectangle.
+ * Barcode detection result containing the value, format type, and the bounding
+ * rectangle in display/CSS pixels within the webview coordinate space.
+ *
+ * Overrides `equals`/`hashCode` explicitly because [rawBytes] is an array: the
+ * data-class-generated versions would otherwise compare/hash it by reference identity
+ * rather than content, silently breaking equality (and any hash-based collection use)
+ * for two results with the same content but different array instances.
  */
 data class BarcodeDetectionResult(
     val value: String,
@@ -9,4 +15,24 @@ data class BarcodeDetectionResult(
     val displayValue: String,
     val type: String,
     val boundingRect: WebBoundingRect
-)
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is BarcodeDetectionResult) return false
+
+        return value == other.value &&
+            rawBytes.contentEquals(other.rawBytes) &&
+            displayValue == other.displayValue &&
+            type == other.type &&
+            boundingRect == other.boundingRect
+    }
+
+    override fun hashCode(): Int {
+        var result = value.hashCode()
+        result = 31 * result + rawBytes.contentHashCode()
+        result = 31 * result + displayValue.hashCode()
+        result = 31 * result + type.hashCode()
+        result = 31 * result + boundingRect.hashCode()
+        return result
+    }
+}

package/android/src/main/java/com/michaelwolz/capacitorcameraview/model/CameraDevice.kt

@@ -6,9 +6,14 @@ package com.michaelwolz.capacitorcameraview.model
  * @property id Unique identifier for the camera
  * @property name Human-readable name of the camera
  * @property position Position of the camera ("front" or "back")
+ * @property deviceType Lens type ("wideAngle", "ultraWide", or "telephoto") derived from
+ *                       camera characteristics where derivable, matching the
+ *                       iOS-populated field of the same name. `null` when it can't be
+ *                       determined (e.g. focal length/sensor size not reported).
  */
 data class CameraDevice(
     val id: String,
     val name: String,
-    val position: String
+    val position: String,
+    val deviceType: String? = null
 )

package/android/src/main/java/com/michaelwolz/capacitorcameraview/model/CameraSessionConfiguration.kt

@@ -9,12 +9,26 @@ package com.michaelwolz.capacitorcameraview.model
  *                        If null, all supported formats are detected.
  * @property position Camera position to use ("front" or "back").
  * @property zoomFactor Initial zoom factor.
+ * @property aspectRatio Desired sensor aspect ratio ("4:3" or "16:9") applied to both
+ *                       the preview and photo capture. If null, the long-standing
+ *                       defaults are kept (16:9-with-fallback for capture, automatic
+ *                       preview resolution).
+ * @property captureMaxDimension Optional upper bound, in pixels, for the longer edge
+ *                               of captured photos. If null, the default capture
+ *                               resolution is kept.
+ * @property previewScaleMode How the preview is scaled into its container. "fit"
+ *                            letterboxes the whole frame (FIT_CENTER); any other
+ *                            value (including null) keeps the default cover
+ *                            behavior (FILL_CENTER).
  */
 data class CameraSessionConfiguration(
     val deviceId: String? = null,
     val enableBarcodeDetection: Boolean = false,
     val barcodeTypes: List<Int>? = null,
     val position: String = "back",
-    val zoomFactor: Float = 1.0f
+    val zoomFactor: Float = 1.0f,
+    val aspectRatio: String? = null,
+    val captureMaxDimension: Int? = null,
+    val previewScaleMode: String? = null
 )
 

package/android/src/main/java/com/michaelwolz/capacitorcameraview/model/TorchModeState.kt

@@ -0,0 +1,15 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/**
+ * Represents the current torch (flashlight) mode and intensity.
+ *
+ * @property enabled Whether the torch is currently enabled.
+ * @property level The current torch intensity level, normalized to 0.0-1.0. Only meaningful
+ * as a continuous value on API 33+ devices with multi-level torch hardware - below API 33, or
+ * on single-level hardware, the torch is binary and this is always 1.0 when enabled and 0.0
+ * when off.
+ */
+data class TorchModeState(
+    val enabled: Boolean,
+    val level: Float
+)

package/android/src/main/java/com/michaelwolz/capacitorcameraview/model/WebBoundingRect.kt

@@ -1,6 +1,6 @@
 package com.michaelwolz.capacitorcameraview.model
 
-/** Normalized rectangle for barcode bounds. */
+/** Rectangle for barcode bounds in display/CSS pixels within the webview coordinate space. */
 data class WebBoundingRect(
     /** Top left x coordinate of the rectangle. */
     val x: Float,

package/android/src/main/java/com/michaelwolz/capacitorcameraview/utils.kt

@@ -5,9 +5,11 @@ import android.graphics.BitmapFactory
 import android.graphics.Matrix
 import android.graphics.Rect
 import android.util.Base64
+import android.util.Base64OutputStream
 import android.view.Surface
 import android.view.View
 import android.view.ViewGroup.MarginLayoutParams
+import androidx.camera.core.CameraSelector
 import androidx.camera.core.ImageProxy
 import androidx.camera.view.PreviewView
 import com.getcapacitor.PluginCall
@@ -15,7 +17,9 @@ import com.google.mlkit.vision.barcode.common.Barcode
 import com.michaelwolz.capacitorcameraview.model.CameraSessionConfiguration
 import com.michaelwolz.capacitorcameraview.model.VideoRecordingQuality
 import com.michaelwolz.capacitorcameraview.model.WebBoundingRect
+import kotlinx.coroutines.CancellableContinuation
 import java.io.ByteArrayOutputStream
+import kotlin.coroutines.resume
 
 /**
  * Memory-efficient Base64 encoding utilities.
@@ -31,7 +35,12 @@ object StreamingBase64Encoder {
 
     /**
      * Encodes a bitmap to Base64 with memory optimization.
-     * Reuses ByteArrayOutputStream to reduce allocations.
+     * Reuses a pooled [ByteArrayOutputStream] and streams the compressed bytes straight
+     * through a [Base64OutputStream] into it, instead of collecting the raw (un-encoded)
+     * bytes first and then Base64-encoding them as a separate pass. This avoids ever
+     * holding a full-size raw buffer and a full-size Base64 buffer at the same time,
+     * roughly halving peak memory versus a two-step compress-then-`Base64.encodeToString`
+     * approach.
      *
      * @param bitmap The bitmap to encode
      * @param quality JPEG compression quality (0-100)
@@ -46,10 +55,16 @@ object StreamingBase64Encoder {
         val outputStream = outputStreamPool.get()!!
         outputStream.reset() // Clear previous data
 
-        bitmap.compress(format, quality, outputStream)
-        val byteArray = outputStream.toByteArray()
+        // Base64OutputStream.close() finalizes any trailing padding and then closes the
+        // wrapped stream; closing a ByteArrayOutputStream is a documented no-op, so the
+        // pooled buffer and its contents remain valid (and reusable) afterwards.
+        Base64OutputStream(outputStream, Base64.NO_WRAP).use { base64Stream ->
+            bitmap.compress(format, quality, base64Stream)
+        }
 
-        return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+        // The Base64 alphabet is pure ASCII, so this is a lossless decode of the bytes
+        // already sitting in the pooled buffer.
+        return String(outputStream.toByteArray(), Charsets.US_ASCII)
     }
 
     /**
@@ -72,10 +87,10 @@ fun getBarcodeFormatString(format: Int): String {
         Barcode.FORMAT_DATA_MATRIX -> "dataMatrix"
         Barcode.FORMAT_EAN_8 -> "ean8"
         Barcode.FORMAT_EAN_13 -> "ean13"
-        Barcode.FORMAT_ITF -> "itf"
+        Barcode.FORMAT_ITF -> "itf14"
         Barcode.FORMAT_PDF417 -> "pdf417"
         Barcode.FORMAT_UPC_A -> "upcA"
-        Barcode.FORMAT_UPC_E -> "upcE"
+        Barcode.FORMAT_UPC_E -> "upce"
         else -> "unknown"
     }
 }
@@ -180,25 +195,43 @@ fun sessionConfigFromPluginCall(call: PluginCall): CameraSessionConfiguration {
         enableBarcodeDetection = call.getBoolean("enableBarcodeDetection") ?: false,
         barcodeTypes = barcodeTypes,
         position = call.getString("position") ?: "back",
-        zoomFactor = call.getFloat("zoomFactor") ?: 1.0f
+        zoomFactor = call.getFloat("zoomFactor") ?: 1.0f,
+        aspectRatio = call.getString("aspectRatio"),
+        captureMaxDimension = call.getInt("captureMaxDimension"),
+        previewScaleMode = call.getString("previewScaleMode")
     )
 }
 
 /**
- * Calculates the image orientation based on the display rotation and sensor rotation degrees.
+ * Whether the given CameraX lens-facing value denotes a front-facing camera.
+ *
+ * Deriving facing from the bound camera's lens facing is the only reliable signal:
+ * comparing the current [CameraSelector] against [CameraSelector.DEFAULT_FRONT_CAMERA] is
+ * wrong for any custom selector built from a `deviceId`.
+ *
+ * @param lensFacing A `CameraSelector.LENS_FACING_*` value, or `null` if not yet known.
+ * @return `true` only when [lensFacing] is [CameraSelector.LENS_FACING_FRONT].
+ */
+fun isLensFacingFront(lensFacing: Int?): Boolean {
+    return lensFacing == CameraSelector.LENS_FACING_FRONT
+}
+
+/**
+ * Calculates the clockwise rotation (in degrees) to apply to a still capture so it is
+ * upright for the given display orientation.
  *
- * This is because CameraController will set the image orientation based on the device's
- * motion sensor, which may not match the display rotation and in this case not what we actually
- * want.
+ * The base value is the frame's own [imageRotationDegrees] rather than a fixed
+ * sensor-derived value, so devices whose HAL returns pre-rotated buffers report `0` here
+ * and are not rotated a second time.
  *
- * @param displayRotation The current display rotation (0, 1, 2, or 3).
- * @param sensorRotationDegrees The rotation of the camera sensor in degrees (0, 90, 180, or 270).
- * @param isFrontFacing Whether the camera is front-facing or back-facing.
- * @return The calculated image orientation in degrees.
+ * @param imageRotationDegrees The captured frame's `ImageInfo.rotationDegrees` (0/90/180/270).
+ * @param displayRotation The current display rotation (`Surface.ROTATION_*`: 0, 1, 2, or 3).
+ * @param isFrontFacing Whether the active camera is front-facing.
+ * @return The calculated image orientation in degrees (0, 90, 180, or 270).
  */
-fun calculateImageRotationBasedOnDisplayRotation(
+fun calculateImageRotation(
+    imageRotationDegrees: Int,
     displayRotation: Int,
-    sensorRotationDegrees: Int,
     isFrontFacing: Boolean
 ): Int {
     val surfaceRotationDegrees = when (displayRotation) {
@@ -210,9 +243,9 @@ fun calculateImageRotationBasedOnDisplayRotation(
     }
 
     return if (isFrontFacing) {
-        (sensorRotationDegrees + surfaceRotationDegrees) % 360
+        (imageRotationDegrees + surfaceRotationDegrees) % 360
     } else {
-        (sensorRotationDegrees - surfaceRotationDegrees + 360) % 360
+        (imageRotationDegrees - surfaceRotationDegrees + 360) % 360
     }
 }
 
@@ -253,6 +286,27 @@ fun imageProxyToBase64(image: ImageProxy, quality: Int, rotationDegrees: Int): S
     }
 }
 
+/**
+ * Resumes this continuation with [value], but only if it hasn't already been resumed or
+ * cancelled. The camera/capture callbacks that resume continuations in this plugin run on
+ * the CameraX/ML Kit executor or a main-thread [android.os.Handler.post] callback - never on
+ * the coroutine's own dispatcher - so a resume can race with the caller cancelling the
+ * coroutine (e.g. because the plugin is being torn down mid-capture).
+ *
+ * The atomic `tryResume`/`completeResume` pair is `@InternalCoroutinesApi`, so this checks
+ * [CancellableContinuation.isActive] first and swallows the `IllegalStateException` a plain
+ * `resume()` throws if cancellation still wins the race.
+ */
+fun <T> CancellableContinuation<T>.resumeIfActive(value: T) {
+    if (!isActive) return
+    try {
+        resume(value)
+    } catch (e: IllegalStateException) {
+        // Lost the race with cancellation between the isActive check and resume() -
+        // nobody is awaiting the result anymore, so there's nothing to recover.
+    }
+}
+
 /**
  * Parses a string representation of video recording quality into a [VideoRecordingQuality] enum.
  */