capacitor-camera-view 1.0.0

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

@@ -0,0 +1,227 @@
+package com.michaelwolz.capacitorcameraview
+
+import android.Manifest
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.PermissionState
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import com.michaelwolz.capacitorcameraview.model.BarcodeDetectionResult
+
+@CapacitorPlugin(
+    name = "CameraView",
+    permissions = [Permission(strings = [Manifest.permission.CAMERA], alias = "camera")]
+)
+class CameraViewPlugin : Plugin() {
+    private val implementation by lazy {
+        CameraView(this)
+    }
+
+    @PluginMethod
+    fun start(call: PluginCall) {
+        if (getPermissionState("camera") == PermissionState.GRANTED) {
+            startCamera(call)
+        } else {
+            requestPermissionForAlias("camera", call, "cameraPermsCallback")
+        }
+    }
+
+    @PermissionCallback
+    private fun cameraPermsCallback(call: PluginCall) {
+        if (getPermissionState("camera") == PermissionState.GRANTED) {
+            startCamera(call)
+        } else {
+            call.reject("Permission is required to take a picture")
+        }
+    }
+
+    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 {
+                    call.resolve()
+                }
+            }
+        )
+    }
+
+    @PluginMethod
+    fun stop(call: PluginCall) {
+        implementation.stopSession { error ->
+            if (error != null) {
+                call.reject("Failed to stop camera preview: ${error.localizedMessage}", error)
+            } else {
+                call.resolve()
+            }
+        }
+    }
+
+    @PluginMethod
+    fun isRunning(call: PluginCall) {
+        val result = JSObject().apply {
+            put("isRunning", implementation.isRunning())
+        }
+        call.resolve(result)
+    }
+
+    @PluginMethod
+    fun capture(call: PluginCall) {
+        val quality = call.getInt("quality", 90)
+
+        if (quality !in 0..100) {
+            call.reject("Quality must be between 0 and 100")
+            return
+        }
+
+        implementation.capturePhoto(quality) { photo, error ->
+            when {
+                error != null -> call.reject("Failed to capture image: ${error.message}", error)
+                photo == null -> call.reject("No image data")
+                else -> call.resolve(JSObject().apply { put("photo", photo) })
+            }
+        }
+    }
+
+    @PluginMethod
+    fun captureSample(call: PluginCall) {
+        val quality = call.getInt("quality", 90)
+
+        if (quality !in 0..100) {
+            call.reject("Quality must be between 0 and 100")
+            return
+        }
+
+        implementation.captureSampleFromPreview(quality) { photo, error ->
+            when {
+                error != null -> call.reject("Failed to capture frame: ${error.message}", error)
+                photo == null -> call.reject("No frame data")
+                else -> call.resolve(JSObject().apply { put("photo", photo) })
+            }
+        }
+    }
+
+    @PluginMethod
+    fun getAvailableDevices(call: PluginCall) {
+        val devices = implementation.getAvailableDevices()
+        val devicesArray = JSArray().apply {
+            devices.forEach { device ->
+                put(JSObject().apply {
+                    put("id", device.id)
+                    put("name", device.name)
+                    put("position", device.position)
+                })
+            }
+        }
+
+        call.resolve(JSObject().apply { put("devices", devicesArray) })
+    }
+
+    @PluginMethod
+    fun flipCamera(call: PluginCall) {
+        implementation.flipCamera { error ->
+            if (error != null) {
+                call.reject("Failed to flip camera: ${error.localizedMessage}", error)
+            } else {
+                call.resolve()
+            }
+        }
+    }
+
+    @PluginMethod
+    fun getZoom(call: PluginCall) {
+        implementation.getSupportedZoomFactors { zoomFactors ->
+            call.resolve(JSObject().apply {
+                put("min", zoomFactors.min)
+                put("max", zoomFactors.max)
+                put("current", zoomFactors.current)
+            })
+        }
+    }
+
+    @PluginMethod
+    fun setZoom(call: PluginCall) {
+        val level = call.getFloat("level")
+        if (level == null) {
+            call.reject("Zoom level must be provided")
+            return
+        }
+
+        implementation.setZoomFactor(level) { error ->
+            if (error != null) {
+                call.reject(error.localizedMessage)
+            } else {
+                call.resolve()
+            }
+        }
+    }
+
+    @PluginMethod
+    fun getFlashMode(call: PluginCall) {
+        call.resolve(JSObject().apply {
+            put("flashMode", implementation.getFlashMode())
+        })
+    }
+
+    @PluginMethod
+    fun getSupportedFlashModes(call: PluginCall) {
+        implementation.getSupportedFlashModes { supportedFlashModes ->
+            val modesArray = JSArray().apply {
+                supportedFlashModes.forEach { put(it) }
+            }
+
+            call.resolve(JSObject().apply { put("flashModes", modesArray) })
+        }
+    }
+
+    @PluginMethod
+    fun setFlashMode(call: PluginCall) {
+        val mode = call.getString("mode")
+        if (mode == null) {
+            call.reject("Flash mode must be provided")
+            return
+        }
+
+        val validModes = listOf("off", "on", "auto")
+        if (!validModes.contains(mode)) {
+            call.reject("Invalid flash mode. Must be one of: ${validModes.joinToString(", ")}")
+            return
+        }
+
+        try {
+            implementation.setFlashMode(mode)
+            call.resolve()
+        } catch (e: Exception) {
+            call.reject("Failed to set flash mode: ${e.localizedMessage}", e)
+        }
+    }
+
+    /**
+     * Called by the CameraView when a barcode is detected.
+     */
+    fun notifyBarcodeDetected(result: BarcodeDetectionResult) {
+        val jsObject = JSObject().apply {
+            put("value", result.value)
+            put("type", result.type)
+            put("boundingRect", JSObject().apply {
+                put("x", result.boundingRect.x)
+                put("y", result.boundingRect.y)
+                put("width", result.boundingRect.width)
+                put("height", result.boundingRect.height)
+            })
+        }
+
+        notifyListeners("barcodeDetected", jsObject)
+    }
+
+    override fun handleOnDestroy() {
+        implementation.cleanup()
+        super.handleOnDestroy()
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/**
+ * Barcode detection result containing the value, format type, and normalized bounding rectangle.
+ */
+data class BarcodeDetectionResult(
+    val value: String,
+    val displayValue: String,
+    val type: String,
+    val boundingRect: WebBoundingRect
+)

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

@@ -0,0 +1,14 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/**
+ * Represents a camera device available on the Android device.
+ *
+ * @property id Unique identifier for the camera
+ * @property name Human-readable name of the camera
+ * @property position Position of the camera ("front" or "back")
+ */
+data class CameraDevice(
+    val id: String,
+    val name: String,
+    val position: String
+)

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

@@ -0,0 +1,10 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/** Configuration for a camera session. */
+data class CameraSessionConfiguration(
+    val deviceId: String? = null,
+    val enableBarcodeDetection: Boolean = false,
+    val position: String = "back",
+    val zoomFactor: Float = 1.0f
+)
+

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

@@ -0,0 +1,16 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/** Normalized rectangle for barcode bounds. */
+data class WebBoundingRect(
+    /** Top left x coordinate of the rectangle. */
+    val x: Float,
+
+    /** Top left y coordinate of the rectangle. */
+    val y: Float,
+
+    /** Width of the rectangle. */
+    val width: Float,
+
+    /** Height of the rectangle. */
+    val height: Float
+)

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

@@ -0,0 +1,14 @@
+package com.michaelwolz.capacitorcameraview.model
+
+/**
+ * Represents supported zoom factors for the camera.
+ *
+ * @property min Minimum zoom level (typically 1.0)
+ * @property max Maximum zoom level supported by the device
+ * @property current Current zoom level in use
+ */
+data class ZoomFactors(
+    val min: Float,
+    val max: Float,
+    val current: Float
+)

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

@@ -0,0 +1,86 @@
+package com.michaelwolz.capacitorcameraview
+
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewGroup.MarginLayoutParams
+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.WebBoundingRect
+
+/** Converts a barcode format code to a readable string. */
+fun getBarcodeFormatString(format: Int): String {
+    return when (format) {
+        Barcode.FORMAT_QR_CODE -> "qr"
+        Barcode.FORMAT_AZTEC -> "aztec"
+        Barcode.FORMAT_CODABAR -> "codabar"
+        Barcode.FORMAT_CODE_39 -> "code39"
+        Barcode.FORMAT_CODE_93 -> "code93"
+        Barcode.FORMAT_CODE_128 -> "code128"
+        Barcode.FORMAT_DATA_MATRIX -> "dataMatrix"
+        Barcode.FORMAT_EAN_8 -> "ean8"
+        Barcode.FORMAT_EAN_13 -> "ean13"
+        Barcode.FORMAT_ITF -> "itf"
+        Barcode.FORMAT_PDF417 -> "pdf417"
+        Barcode.FORMAT_UPC_A -> "upcA"
+        Barcode.FORMAT_UPC_E -> "upcE"
+        else -> "unknown"
+    }
+}
+
+/**
+ * Converts the bounding box of a barcode detection result to a [WebBoundingRect]
+ * suitable for use in the web view via regular CSS pixels.
+ *
+ * @param previewView The [PreviewView] used for the camera preview.
+ * @param boundingBox The bounding box of the barcode detection result.
+ * @param topOffset The top offset to be subtracted from the bounding box's top coordinate.
+ */
+fun boundingBoxToWebBoundingRect(
+    previewView: PreviewView,
+    boundingBox: Rect?,
+    topOffset: Int = 0
+): WebBoundingRect {
+    if (boundingBox == null) {
+        return WebBoundingRect(0f, 0f, 0f, 0f)
+    }
+
+    val devicePixelRatio = previewView.context.resources.displayMetrics.density
+
+    return WebBoundingRect(
+        x = boundingBox.left.toFloat() / devicePixelRatio,
+        y = (boundingBox.top.toFloat() - topOffset) / devicePixelRatio,
+        width = boundingBox.width().toFloat() / devicePixelRatio,
+        height = boundingBox.height().toFloat() / devicePixelRatio
+    )
+}
+
+/**
+ * Helper method for calculating the top margin of the capacitor web view for correctly
+ * positioning the barcode detection rectangle due to weird android edge-to-edge behavior
+ * with web views and capacitors hack around this:
+ * https://github.com/ionic-team/capacitor/pull/7871
+ *
+ * Not subtracting the margins will lead to the barcode detection rectangle being
+ * positioned incorrectly too low on the screen.
+ */
+fun calculateTopOffset(webView: View): Int {
+    val layoutParams = webView.layoutParams
+
+    if (layoutParams is MarginLayoutParams) {
+        return layoutParams.topMargin
+    }
+
+    return 0
+}
+
+/** Maps a Capacitor plugin call to a [CameraSessionConfiguration]. */
+fun sessionConfigFromPluginCall(call: PluginCall): CameraSessionConfiguration {
+    return CameraSessionConfiguration(
+        deviceId = call.getString("deviceId"),
+        enableBarcodeDetection = call.getBoolean("enableBarcodeDetection") ?: false,
+        position = call.getString("position") ?: "back",
+        zoomFactor = call.getFloat("zoomFactor") ?: 1.0f
+    )
+}