capacitor-camera-view 2.0.2 → 2.2.0-rc.1

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

@@ -12,12 +12,28 @@ import com.getcapacitor.annotation.CapacitorPlugin
 import com.getcapacitor.annotation.Permission
 import com.getcapacitor.annotation.PermissionCallback
 import com.michaelwolz.capacitorcameraview.model.BarcodeDetectionResult
+import com.michaelwolz.capacitorcameraview.model.VideoRecordingQuality
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
 
 @CapacitorPlugin(
     name = "CameraView",
-    permissions = [Permission(strings = [Manifest.permission.CAMERA], alias = "camera")]
+    permissions = [
+        Permission(strings = [Manifest.permission.CAMERA], alias = "camera"),
+        Permission(strings = [Manifest.permission.RECORD_AUDIO], alias = "microphone")
+    ]
 )
 class CameraViewPlugin : Plugin() {
+    // Coroutine scope for async operations
+    private val pluginScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    // Job for barcode event subscription
+    private var barcodeJob: Job? = null
+
     private val implementation by lazy {
         CameraView(this)
     }
@@ -41,26 +57,42 @@ class CameraViewPlugin : Plugin() {
     }
 
     private fun startCamera(call: PluginCall) {
-        implementation.startSession(
-            config = sessionConfigFromPluginCall(call),
-            callback = { error ->
-                if (error != null) {
-                    call.reject("Failed to start camera preview: ${error.localizedMessage}", error)
-                } else {
+        val config = sessionConfigFromPluginCall(call)
+
+        pluginScope.launch {
+            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)
                 }
-            }
-        )
+            )
+        }
     }
 
     @PluginMethod
     fun stop(call: PluginCall) {
-        implementation.stopSession { error ->
-            if (error != null) {
-                call.reject("Failed to stop camera preview: ${error.localizedMessage}", error)
-            } else {
-                call.resolve()
-            }
+        // Cancel barcode subscription
+        barcodeJob?.cancel()
+        barcodeJob = null
+
+        pluginScope.launch {
+            implementation.stopSessionAsync().fold(
+                onSuccess = { call.resolve() },
+                onError = { error ->
+                    call.reject("Failed to stop camera preview: ${error.localizedMessage}", error)
+                }
+            )
         }
     }
 
@@ -74,7 +106,7 @@ class CameraViewPlugin : Plugin() {
 
     @PluginMethod
     fun capture(call: PluginCall) {
-        val timeStart = System.currentTimeMillis();
+        val timeStart = System.currentTimeMillis()
         val quality = call.getInt("quality") ?: 90
         val saveToFile = call.getBoolean("saveToFile") ?: false
 
@@ -83,19 +115,23 @@ class CameraViewPlugin : Plugin() {
             return
         }
 
-        implementation.capturePhoto(quality, saveToFile) { result, error ->
-            when {
-                error != null -> call.reject("Failed to capture image: ${error.message}", error)
-                result == null -> call.reject("No image data")
-                else -> call.resolve(result)
-            }
-            Log.d(TAG, "capture took ${System.currentTimeMillis() - timeStart}ms")
+        pluginScope.launch {
+            implementation.capturePhotoAsync(quality, saveToFile).fold(
+                onSuccess = { result ->
+                    call.resolve(result)
+                    Log.d(TAG, "capture took ${System.currentTimeMillis() - timeStart}ms")
+                },
+                onError = { error ->
+                    call.reject("Failed to capture image: ${error.message}", error)
+                    Log.d(TAG, "capture failed after ${System.currentTimeMillis() - timeStart}ms")
+                }
+            )
         }
     }
 
     @PluginMethod
     fun captureSample(call: PluginCall) {
-        val timeStart = System.currentTimeMillis();
+        val timeStart = System.currentTimeMillis()
         val quality = call.getInt("quality") ?: 90
         val saveToFile = call.getBoolean("saveToFile") ?: false
 
@@ -104,13 +140,123 @@ class CameraViewPlugin : Plugin() {
             return
         }
 
-        implementation.captureSampleFromPreview(quality, saveToFile) { result, error ->
-            when {
-                error != null -> call.reject("Failed to capture frame: ${error.message}", error)
-                result == null -> call.reject("No frame data")
-                else -> call.resolve(result)
-            }
-            Log.d(TAG, "captureSample took ${System.currentTimeMillis() - timeStart}ms")
+        pluginScope.launch {
+            implementation.captureSampleFromPreviewAsync(quality, saveToFile).fold(
+                onSuccess = { result ->
+                    call.resolve(result)
+                    Log.d(TAG, "captureSample took ${System.currentTimeMillis() - timeStart}ms")
+                },
+                onError = { error ->
+                    call.reject("Failed to capture frame: ${error.message}", error)
+                    Log.d(
+                        TAG,
+                        "captureSample failed after ${System.currentTimeMillis() - timeStart}ms"
+                    )
+                }
+            )
+        }
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        val permissionsList = call.getArray("permissions")
+            ?.toList<String>()
+            ?: listOf("camera")
+
+        // Determine which aliases still need to be requested
+        val aliasesToRequest = permissionsList.filter { alias ->
+            getPermissionState(alias) != PermissionState.GRANTED
+        }
+
+        if (aliasesToRequest.isEmpty()) {
+            checkPermissions(call)
+            return
+        }
+
+        // Store which permissions to request so callback can continue the chain
+        call.data.put("_pendingAliases", com.getcapacitor.JSArray(aliasesToRequest))
+        requestPermissionForAlias(aliasesToRequest.first(), call, "requestedPermsCallback")
+    }
+
+    @PermissionCallback
+    private fun requestedPermsCallback(call: PluginCall) {
+        val pendingAliases = call.getArray("_pendingAliases")?.toList<String>() ?: emptyList()
+
+        // Find remaining aliases that still need requesting
+        val remaining = pendingAliases.drop(1).filter { alias ->
+            getPermissionState(alias) != PermissionState.GRANTED
+        }
+
+        if (remaining.isNotEmpty()) {
+            call.data.put("_pendingAliases", com.getcapacitor.JSArray(remaining))
+            requestPermissionForAlias(remaining.first(), call, "requestedPermsCallback")
+        } else {
+            checkPermissions(call)
+        }
+    }
+
+    @PluginMethod
+    fun startRecording(call: PluginCall) {
+        val enableAudio = call.getBoolean("enableAudio") ?: false
+        val videoQuality =
+            parseVideoRecordingQuality(call.getString("videoQuality"))
+                ?: run {
+                    call.reject("Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest")
+                    return
+                }
+
+        if (enableAudio && getPermissionState("microphone") != PermissionState.GRANTED) {
+            requestPermissionForAlias("microphone", call, "microphonePermsCallback")
+            return
+        }
+
+        doStartRecording(call, enableAudio, videoQuality)
+    }
+
+    @PermissionCallback
+    private fun microphonePermsCallback(call: PluginCall) {
+        if (getPermissionState("microphone") == PermissionState.GRANTED) {
+            val enableAudio = call.getBoolean("enableAudio") ?: false
+            val videoQuality =
+                parseVideoRecordingQuality(call.getString("videoQuality"))
+                    ?: run {
+                        call.reject("Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest")
+                        return
+                    }
+            doStartRecording(call, enableAudio, videoQuality)
+        } else {
+            call.reject("Microphone permission is required for audio recording")
+        }
+    }
+
+
+    /**
+     * Helper method to start recording after ensuring permissions are granted.
+     */
+    private fun doStartRecording(
+        call: PluginCall,
+        enableAudio: Boolean,
+        videoQuality: VideoRecordingQuality
+    ) {
+        pluginScope.launch {
+            implementation.startRecordingAsync(enableAudio, videoQuality).fold(
+                onSuccess = { call.resolve() },
+                onError = { error ->
+                    call.reject("Failed to start recording: ${error.message}", error)
+                }
+            )
+        }
+    }
+
+    @PluginMethod
+    fun stopRecording(call: PluginCall) {
+        pluginScope.launch {
+            implementation.stopRecordingAsync().fold(
+                onSuccess = { result -> call.resolve(result) },
+                onError = { error ->
+                    call.reject("Failed to stop recording: ${error.message}", error)
+                }
+            )
         }
     }
 
@@ -268,6 +414,10 @@ class CameraViewPlugin : Plugin() {
     }
 
     override fun handleOnDestroy() {
+        // Cancel barcode subscription and plugin scope
+        barcodeJob?.cancel()
+        pluginScope.cancel()
+
         implementation.cleanup()
         super.handleOnDestroy()
     }

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

@@ -0,0 +1,47 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/**
+ * A Result type for consistent error handling throughout camera operations.
+ * Provides a functional approach to handling success and error cases.
+ */
+sealed class CameraResult<out T> {
+    data class Success<T>(val value: T) : CameraResult<T>()
+    data class Error(val exception: Exception) : CameraResult<Nothing>()
+
+    /**
+     * Transforms this result using the provided functions.
+     */
+    inline fun <R> fold(
+        onSuccess: (T) -> R,
+        onError: (Exception) -> R
+    ): R = when (this) {
+        is Success -> onSuccess(value)
+        is Error -> onError(exception)
+    }
+
+    /**
+     * Returns the value if Success, null otherwise.
+     */
+    fun getOrNull(): T? = when (this) {
+        is Success -> value
+        is Error -> null
+    }
+
+    /**
+     * Returns the exception if Error, null otherwise.
+     */
+    fun exceptionOrNull(): Exception? = when (this) {
+        is Success -> null
+        is Error -> exception
+    }
+
+    /**
+     * Returns true if this is a Success.
+     */
+    val isSuccess: Boolean get() = this is Success
+
+    /**
+     * Returns true if this is an Error.
+     */
+    val isError: Boolean get() = this is Error
+}

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

@@ -1,9 +1,19 @@
 package com.michaelwolz.capacitorcameraview.model
 
-/** Configuration for a camera session. */
+/**
+ * Configuration for a camera session.
+ *
+ * @property deviceId Specific device ID to use. Takes precedence over position.
+ * @property enableBarcodeDetection Whether to enable barcode detection.
+ * @property barcodeTypes Optional list of specific barcode format codes to detect.
+ *                        If null, all supported formats are detected.
+ * @property position Camera position to use ("front" or "back").
+ * @property zoomFactor Initial zoom factor.
+ */
 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
 )

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

@@ -0,0 +1,10 @@
+package com.michaelwolz.capacitorcameraview.model
+
+enum class VideoRecordingQuality {
+    LOWEST,
+    SD,
+    HD,
+    FHD,
+    UHD,
+    HIGHEST,
+}

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

@@ -13,9 +13,53 @@ import androidx.camera.view.PreviewView
 import com.getcapacitor.PluginCall
 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 java.io.ByteArrayOutputStream
 
+/**
+ * Memory-efficient Base64 encoding utilities.
+ * Uses ThreadLocal ByteArrayOutputStream pool to reduce allocation churn.
+ */
+object StreamingBase64Encoder {
+    // Reusable ByteArrayOutputStream to reduce allocation churn (per-thread)
+    private val outputStreamPool = object : ThreadLocal<ByteArrayOutputStream>() {
+        override fun initialValue(): ByteArrayOutputStream {
+            return ByteArrayOutputStream(256 * 1024) // 256KB initial capacity
+        }
+    }
+
+    /**
+     * Encodes a bitmap to Base64 with memory optimization.
+     * Reuses ByteArrayOutputStream to reduce allocations.
+     *
+     * @param bitmap The bitmap to encode
+     * @param quality JPEG compression quality (0-100)
+     * @param format Compression format (default JPEG)
+     * @return Base64 encoded string
+     */
+    fun encodeToBase64(
+        bitmap: Bitmap,
+        quality: Int,
+        format: Bitmap.CompressFormat = Bitmap.CompressFormat.JPEG
+    ): String {
+        val outputStream = outputStreamPool.get()!!
+        outputStream.reset() // Clear previous data
+
+        bitmap.compress(format, quality, outputStream)
+        val byteArray = outputStream.toByteArray()
+
+        return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+    }
+
+    /**
+     * Encodes raw byte array to Base64.
+     */
+    fun encodeToBase64(bytes: ByteArray): String {
+        return Base64.encodeToString(bytes, Base64.NO_WRAP)
+    }
+}
+
 /** Converts a barcode format code to a readable string. */
 fun getBarcodeFormatString(format: Int): String {
     return when (format) {
@@ -36,6 +80,43 @@ fun getBarcodeFormatString(format: Int): String {
     }
 }
 
+/**
+ * Converts a string barcode type from JavaScript to ML Kit Barcode format constant.
+ *
+ * @param stringType The string barcode type from JavaScript.
+ * @return The corresponding ML Kit Barcode format constant, or null if not recognized.
+ */
+fun convertToNativeBarcodeFormat(stringType: String): Int? {
+    return when (stringType) {
+        "qr" -> Barcode.FORMAT_QR_CODE
+        "aztec" -> Barcode.FORMAT_AZTEC
+        "codabar" -> Barcode.FORMAT_CODABAR
+        "code39" -> Barcode.FORMAT_CODE_39
+        "code39Mod43" -> Barcode.FORMAT_CODE_39 // ML Kit doesn't distinguish Mod43
+        "code93" -> Barcode.FORMAT_CODE_93
+        "code128" -> Barcode.FORMAT_CODE_128
+        "dataMatrix" -> Barcode.FORMAT_DATA_MATRIX
+        "ean8" -> Barcode.FORMAT_EAN_8
+        "ean13" -> Barcode.FORMAT_EAN_13
+        "interleaved2of5" -> Barcode.FORMAT_ITF
+        "itf14" -> Barcode.FORMAT_ITF
+        "pdf417" -> Barcode.FORMAT_PDF417
+        "upcA" -> Barcode.FORMAT_UPC_A
+        "upce" -> Barcode.FORMAT_UPC_E
+        else -> null
+    }
+}
+
+/**
+ * Converts an array of string barcode types to ML Kit Barcode format constants.
+ *
+ * @param stringTypes List of string barcode types from JavaScript.
+ * @return List of ML Kit Barcode format constants (invalid types are filtered out).
+ */
+fun convertToNativeBarcodeFormats(stringTypes: List<String>): List<Int> {
+    return stringTypes.mapNotNull { convertToNativeBarcodeFormat(it) }.distinct()
+}
+
 /**
  * Converts the bounding box of a barcode detection result to a [WebBoundingRect]
  * suitable for use in the web view via regular CSS pixels.
@@ -84,9 +165,20 @@ fun calculateTopOffset(webView: View): Int {
 
 /** Maps a Capacitor plugin call to a [CameraSessionConfiguration]. */
 fun sessionConfigFromPluginCall(call: PluginCall): CameraSessionConfiguration {
+    // Parse barcode types if provided
+    val barcodeTypes: List<Int>? = call.getArray("barcodeTypes")?.let { jsonArray ->
+        val stringTypes = mutableListOf<String>()
+        for (i in 0 until jsonArray.length()) {
+            jsonArray.optString(i)?.let { stringTypes.add(it) }
+        }
+        val converted = convertToNativeBarcodeFormats(stringTypes)
+        converted.ifEmpty { null }
+    }
+
     return CameraSessionConfiguration(
         deviceId = call.getString("deviceId"),
         enableBarcodeDetection = call.getBoolean("enableBarcodeDetection") ?: false,
+        barcodeTypes = barcodeTypes,
         position = call.getString("position") ?: "back",
         zoomFactor = call.getFloat("zoomFactor") ?: 1.0f
     )
@@ -126,6 +218,7 @@ fun calculateImageRotationBasedOnDisplayRotation(
 
 /**
  * Converts an ImageProxy to a Base64 encoded string and applies rotation if necessary.
+ * Uses StreamingBase64Encoder for memory-efficient encoding.
  *
  * @param image The ImageProxy to convert.
  * @param quality The JPEG compression quality (0-100).
@@ -152,13 +245,29 @@ fun imageProxyToBase64(image: ImageProxy, quality: Int, rotationDegrees: Int): S
             bitmap = rotatedBitmap
         }
 
-        val outputStream = ByteArrayOutputStream()
-        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
-        val byteArray = outputStream.toByteArray()
-
-        return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+        // Use streaming encoder for memory efficiency
+        return StreamingBase64Encoder.encodeToBase64(bitmap, quality)
     } finally {
         // Ensure bitmap is always recycled
         bitmap.recycle()
     }
+}
+
+/**
+ * Parses a string representation of video recording quality into a [VideoRecordingQuality] enum.
+ */
+fun parseVideoRecordingQuality(rawValue: String?): VideoRecordingQuality? {
+    if (rawValue == null) {
+        return VideoRecordingQuality.HIGHEST
+    }
+
+    return when (rawValue) {
+        "lowest" -> VideoRecordingQuality.LOWEST
+        "sd" -> VideoRecordingQuality.SD
+        "hd" -> VideoRecordingQuality.HD
+        "fhd" -> VideoRecordingQuality.FHD
+        "uhd" -> VideoRecordingQuality.UHD
+        "highest" -> VideoRecordingQuality.HIGHEST
+        else -> null
+    }
 }