capacitor-camera-view 1.0.0

package/android/build.gradle

@@ -0,0 +1,79 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+}
+
+buildscript {
+    ext {
+        kotlin_version = '1.9.24'
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.3'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+android {
+    namespace "com.michaelwolz.capacitorcameraview"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+    kotlinOptions {
+        jvmTarget = '21'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'androidx.core:core-ktx:1.16.0'
+    implementation 'androidx.compose.material3:material3-android:1.3.2'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+
+    // CameraX dependencies
+    def camerax_version = "1.4.2"
+    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-view:${camerax_version}"
+    implementation "androidx.camera:camera-mlkit-vision:${camerax_version}"
+
+    // ML Kit for barcode scanning
+    implementation "com.google.mlkit:barcode-scanning:17.3.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,555 @@
+package com.michaelwolz.capacitorcameraview
+
+import android.content.Context
+import android.content.Context.CAMERA_SERVICE
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
+import android.util.Base64
+import android.util.Log
+import android.view.ViewGroup
+import android.webkit.WebView
+import androidx.annotation.OptIn
+import androidx.camera.camera2.interop.Camera2CameraInfo
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageCapture
+import androidx.camera.core.ImageCaptureException
+import androidx.camera.core.ImageProxy
+import androidx.camera.core.resolutionselector.AspectRatioStrategy
+import androidx.camera.core.resolutionselector.ResolutionSelector
+import androidx.camera.mlkit.vision.MlKitAnalyzer
+import androidx.camera.view.LifecycleCameraController
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import com.getcapacitor.Plugin
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.michaelwolz.capacitorcameraview.model.BarcodeDetectionResult
+import com.michaelwolz.capacitorcameraview.model.CameraDevice
+import com.michaelwolz.capacitorcameraview.model.CameraSessionConfiguration
+import com.michaelwolz.capacitorcameraview.model.ZoomFactors
+import java.io.ByteArrayOutputStream
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+/** Throttle time for barcode detection in milliseconds. */
+const val BARCODE_DETECTION_THROTTLE_MS = 100
+
+class CameraView(plugin: Plugin) {
+    // Camera components
+    private var cameraController: LifecycleCameraController? = null
+    private val cameraExecutor: ExecutorService by lazy { Executors.newSingleThreadExecutor() }
+    private var previewView: PreviewView? = null
+
+    // Camera state
+    private var currentCameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
+    private var currentFlashMode: Int = ImageCapture.FLASH_MODE_OFF
+
+    // Camera use cases
+    private var imageCapture: ImageCapture? = null
+
+    // Plugin context
+    private var lifecycleOwner: LifecycleOwner? = null
+    private var pluginDelegate: Plugin = plugin
+    private var webView: WebView = plugin.bridge.webView
+    private var context: Context = webView.context
+
+    private val mainHandler by lazy { android.os.Handler(android.os.Looper.getMainLooper()) }
+
+    private var lastBarcodeDetectionTime = 0L
+
+    /** Starts a camera session with the provided configuration. */
+    fun startSession(config: CameraSessionConfiguration, callback: (Exception?) -> Unit) {
+        val lifecycleOwner =
+            context as? LifecycleOwner
+                ?: run {
+                    callback(Exception("WebView context must be a LifecycleOwner"))
+                    return
+                }
+
+        // Store references for later use
+        this.lifecycleOwner = lifecycleOwner
+
+        mainHandler.post {
+            try {
+                initializeCamera(context, lifecycleOwner, config)
+                callback(null)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error in camera setup", e)
+                callback(e)
+            }
+        }
+    }
+
+    /** Stop the camera session and release resources */
+    fun stopSession(callback: ((Exception?) -> Unit)? = null) {
+        mainHandler.post {
+            cameraController?.unbind()
+
+            try {
+                imageCapture = null
+
+                previewView?.let { view ->
+                    try {
+                        (webView.parent as? ViewGroup)?.removeView(view)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error removing preview view", e)
+                    } finally {
+                        previewView = null
+                    }
+                }
+
+                webView.setLayerType(WebView.LAYER_TYPE_NONE, null)
+                webView.setBackgroundColor(android.graphics.Color.WHITE)
+
+                Log.d(TAG, "Camera session stopped successfully")
+                callback?.invoke(null)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error stopping camera session", e)
+                callback?.invoke(e)
+            }
+        }
+    }
+
+    /** Checks if the camera session is running */
+    fun isRunning(): Boolean {
+        return cameraController != null
+    }
+
+    /** Capture a photo with the current camera configuration */
+    fun capturePhoto(quality: Int?, callback: (String?, Exception?) -> Unit) {
+        val controller =
+            this.cameraController
+                ?: run {
+                    callback(null, Exception("Camera controller not initialized"))
+                    return
+                }
+
+        mainHandler.post {
+            try {
+                controller.takePicture(
+                    cameraExecutor,
+                    object : ImageCapture.OnImageCapturedCallback() {
+                        override fun onCaptureSuccess(image: ImageProxy) {
+                            try {
+                                val base64String = imageProxyToBase64(image, quality)
+                                callback(base64String, null)
+                            } catch (e: Exception) {
+                                Log.e(TAG, "Error processing captured image", e)
+                                callback(null, e)
+                            } finally {
+                                image.close()
+                            }
+                        }
+
+                        override fun onError(exception: ImageCaptureException) {
+                            Log.e(TAG, "Error capturing image", exception)
+                            callback(null, exception)
+                        }
+                    }
+                )
+            } catch (e: Exception) {
+                Log.e(TAG, "Error setting up image capture", e)
+                callback(null, e)
+            }
+        }
+    }
+
+    /**
+     * Capture a frame directly from the preview without using the full photo pipeline which is
+     * faster but has lower quality.
+     */
+    fun captureSampleFromPreview(quality: Int?, callback: (String?, Exception?) -> Unit) {
+        val previewView =
+            this.previewView
+                ?: run {
+                    callback(null, Exception("Camera preview not initialized"))
+                    return
+                }
+
+        mainHandler.post {
+            val outputStream = ByteArrayOutputStream()
+            try {
+                val bitmap =
+                    previewView.bitmap
+                        ?: run {
+                            callback(null, Exception("Preview bitmap not available"))
+                            return@post
+                        }
+
+                // Convert bitmap to Base64
+                bitmap.compress(Bitmap.CompressFormat.JPEG, quality ?: 90, outputStream)
+                val byteArray = outputStream.toByteArray()
+                val base64String = Base64.encodeToString(byteArray, Base64.NO_WRAP)
+
+                callback(base64String, null)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error capturing preview frame", e)
+                callback(null, e)
+            } finally {
+                outputStream.close()
+            }
+        }
+    }
+
+    /** Flip between front and back cameras */
+    fun flipCamera(callback: (Exception?) -> Unit) {
+        currentCameraSelector = when (currentCameraSelector) {
+            CameraSelector.DEFAULT_FRONT_CAMERA -> CameraSelector.DEFAULT_BACK_CAMERA
+            else -> CameraSelector.DEFAULT_FRONT_CAMERA
+        }
+
+        val controller =
+            this.cameraController
+                ?: run {
+                    callback(Exception("Camera controller not initialized"))
+                    return
+                }
+
+        mainHandler.post { controller.cameraSelector = currentCameraSelector }
+    }
+
+    /** Get the min, max, and current zoom values */
+    fun getSupportedZoomFactors(callback: (ZoomFactors) -> Unit) {
+        mainHandler.post { callback(getZoomFactorsInternal()) }
+    }
+
+    /** Set the zoom factor for the camera */
+    fun setZoomFactor(zoomFactor: Float, callback: (((Exception?) -> Unit)?) = null) {
+        mainHandler.post {
+            val cameraControl =
+                cameraController?.cameraControl
+                    ?: run {
+                        callback?.invoke(Exception("Camera controller not initialized"))
+                        return@post
+                    }
+
+            val availableZoomFactors = getZoomFactorsInternal()
+
+            if (zoomFactor !in availableZoomFactors.min..availableZoomFactors.max) {
+                callback?.invoke(Exception("The requested zoom factor is out of range."))
+                return@post
+            }
+
+            Log.d(TAG, "Setting zoom factor to $zoomFactor")
+            val zoomFuture = cameraControl.setZoomRatio(zoomFactor)
+
+            zoomFuture.addListener(
+                {
+                    try {
+                        zoomFuture.get()
+                        Log.d(TAG, "Zoom factor set successfully to $zoomFactor")
+                        callback?.invoke(null)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Failed to set zoom factor", e)
+                        callback?.invoke(Exception(e.message))
+                    }
+                },
+                ContextCompat.getMainExecutor(context)
+            )
+        }
+    }
+
+    /** Get the current flash mode */
+    fun getFlashMode(): String {
+        return when (currentFlashMode) {
+            ImageCapture.FLASH_MODE_ON -> "on"
+            ImageCapture.FLASH_MODE_AUTO -> "auto"
+            else -> "off"
+        }
+    }
+
+    /** Get supported flash modes */
+    fun getSupportedFlashModes(callback: (supportedFlashModes: List<String>) -> Unit) {
+        mainHandler.post {
+            val cameraInfo =
+                cameraController?.cameraInfo
+                    ?: run {
+                        callback(listOf("off"))
+                        return@post
+                    }
+
+            callback(
+                if (cameraInfo.hasFlashUnit()) {
+                    listOf("off", "on", "auto")
+                } else {
+                    listOf("off")
+                }
+            )
+        }
+    }
+
+    /** Set the flash mode */
+    fun setFlashMode(mode: String) {
+        val controller =
+            this.cameraController
+                ?: run { throw Exception("Camera controller not initialized") }
+
+        currentFlashMode =
+            when (mode) {
+                "on" -> ImageCapture.FLASH_MODE_ON
+                "auto" -> ImageCapture.FLASH_MODE_AUTO
+                else -> ImageCapture.FLASH_MODE_OFF
+            }
+
+        mainHandler.post { controller.imageCaptureFlashMode = currentFlashMode }
+    }
+
+    /** Get a list of available camera devices */
+    fun getAvailableDevices(): List<CameraDevice> {
+        try {
+            val cameraManager =
+                context.getSystemService(CAMERA_SERVICE) as? CameraManager ?: return emptyList()
+
+            return cameraManager.cameraIdList.mapNotNull { cameraId ->
+                val characteristics = cameraManager.getCameraCharacteristics(cameraId)
+                val facing =
+                    characteristics.get(CameraCharacteristics.LENS_FACING)
+                        ?: return@mapNotNull null
+
+                val position =
+                    when (facing) {
+                        CameraCharacteristics.LENS_FACING_FRONT -> "front"
+                        CameraCharacteristics.LENS_FACING_BACK -> "back"
+                        else -> "external"
+                    }
+
+                CameraDevice(id = cameraId, name = cameraId, position = position)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting camera devices", e)
+            return emptyList()
+        }
+    }
+
+    /** Clean up resources when the plugin is being destroyed */
+    fun cleanup() {
+        mainHandler.post {
+            try {
+                // Stop camera session
+                cameraController?.unbind()
+                cameraController = null
+
+                // Remove preview view
+                previewView?.let { view ->
+                    (webView.parent as? ViewGroup)?.removeView(view)
+                    previewView = null
+                }
+
+                // Reset WebView properties
+                webView.setLayerType(WebView.LAYER_TYPE_NONE, null)
+                webView.setBackgroundColor(android.graphics.Color.WHITE)
+
+                // Clear references
+                lifecycleOwner = null
+                imageCapture = null
+
+                // Shutdown executor
+                if (!cameraExecutor.isShutdown) {
+                    cameraExecutor.shutdown()
+                }
+
+                Log.d(TAG, "Camera resources cleaned up successfully")
+            } catch (e: Exception) {
+                Log.e(TAG, "Error during cleanup", e)
+            }
+        }
+    }
+
+    private fun setupPreviewView(context: Context) {
+        // Make WebView transparent
+        webView.setBackgroundColor(android.graphics.Color.TRANSPARENT)
+        webView.setLayerType(WebView.LAYER_TYPE_HARDWARE, null)
+
+        previewView =
+            PreviewView(context).apply {
+                layoutParams =
+                    ViewGroup.LayoutParams(
+                        ViewGroup.LayoutParams.MATCH_PARENT,
+                        ViewGroup.LayoutParams.MATCH_PARENT
+                    )
+                scaleType = PreviewView.ScaleType.FILL_CENTER
+            }
+
+        (webView.parent as? ViewGroup)?.addView(previewView, 0)
+    }
+
+    @OptIn(ExperimentalCamera2Interop::class)
+    private fun initializeCamera(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        config: CameraSessionConfiguration,
+    ) {
+        // Setup preview view
+        setupPreviewView(context)
+
+        currentCameraSelector = if (config.position == "front") {
+            CameraSelector.DEFAULT_FRONT_CAMERA
+        } else {
+            CameraSelector.DEFAULT_BACK_CAMERA
+        }
+
+        if (config.deviceId != null) {
+            // Prefer specific device id over position
+            currentCameraSelector = CameraSelector.Builder()
+                .addCameraFilter { cameraInfos ->
+                    cameraInfos.filter { info ->
+                        val cameraId = Camera2CameraInfo.from(info).cameraId
+                        cameraId == config.deviceId
+                    }
+                }
+                .build()
+        }
+
+        // Initialize camera controller
+        val controller = LifecycleCameraController(context).apply {
+            cameraSelector = currentCameraSelector
+            imageCaptureResolutionSelector = ResolutionSelector.Builder()
+                .setAspectRatioStrategy(
+                    AspectRatioStrategy.RATIO_16_9_FALLBACK_AUTO_STRATEGY
+                )
+                .build()
+        }
+
+        cameraController = controller
+        previewView?.controller = controller
+
+        // Setup barcode scanning if needed
+        if (config.enableBarcodeDetection) {
+            setupBarcodeScanner(controller)
+        }
+
+        // Bind to lifecycle
+        controller.bindToLifecycle(lifecycleOwner)
+
+        // Set initial zoom factor
+        this.setZoomFactor(config.zoomFactor, null)
+    }
+
+    private fun setupBarcodeScanner(controller: LifecycleCameraController) {
+        val previewView = this.previewView ?: return
+
+        val options =
+            BarcodeScannerOptions.Builder()
+                .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
+                .build()
+
+        val barcodeScanner = BarcodeScanning.getClient(options)
+        val mainExecutor = ContextCompat.getMainExecutor(previewView.context)
+
+        // Calculate a possible top offset of the webView which is not applied to the previewView
+        // and might break the positioning of the bounding box of the barcode in relation to the
+        // webView. This is due to capacitors required hack around the edge-to-edge behavior of web
+        // views on android
+        val topOffset = calculateTopOffset(webView)
+
+        controller.setImageAnalysisAnalyzer(
+            mainExecutor,
+            MlKitAnalyzer(
+                listOf(barcodeScanner),
+                ImageAnalysis.COORDINATE_SYSTEM_VIEW_REFERENCED,
+                mainExecutor
+            ) { result: MlKitAnalyzer.Result? ->
+                processBarcodeResults(result, barcodeScanner, previewView, topOffset)
+            }
+        )
+    }
+
+    private fun processBarcodeResults(
+        result: MlKitAnalyzer.Result?,
+        barcodeScanner: BarcodeScanner,
+        previewView: PreviewView,
+        topOffset: Int
+    ) {
+        val now = System.currentTimeMillis()
+        if (now - lastBarcodeDetectionTime < BARCODE_DETECTION_THROTTLE_MS) {
+            return // Skip this frame
+        }
+
+        val barcodes = result?.getValue(barcodeScanner) ?: return
+        if (barcodes.isEmpty()) return
+
+        val barcode = barcodes.firstOrNull() ?: return
+
+        // Adjust bounding box to webView coordinates
+        val webBoundingRect =
+            boundingBoxToWebBoundingRect(previewView, barcode.boundingBox, topOffset)
+
+        val barcodeResult =
+            BarcodeDetectionResult(
+                value = barcode.rawValue ?: "",
+                displayValue = barcode.displayValue ?: "",
+                type = getBarcodeFormatString(barcode.format),
+                boundingRect = webBoundingRect
+            )
+
+        notifyBarcodeDetected(barcodeResult)
+        lastBarcodeDetectionTime = now
+    }
+
+    /** Converts an ImageProxy to a Base64 encoded string */
+    private fun imageProxyToBase64(image: ImageProxy, quality: Int?): String {
+        val buffer = image.planes[0].buffer
+        val bytes = ByteArray(buffer.remaining())
+        buffer.get(bytes)
+
+        var bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+
+        try {
+            // Apply rotation if needed
+            if (image.imageInfo.rotationDegrees != 0) {
+                val matrix = Matrix()
+                matrix.postRotate(image.imageInfo.rotationDegrees.toFloat())
+                val rotatedBitmap =
+                    Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+                // Recycle the original bitmap to prevent memory leaks
+                bitmap.recycle()
+                bitmap = rotatedBitmap
+            }
+
+            val outputStream = ByteArrayOutputStream()
+            bitmap.compress(Bitmap.CompressFormat.JPEG, quality ?: 90, outputStream)
+            val byteArray = outputStream.toByteArray()
+            return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+        } finally {
+            // Ensure bitmap is always recycled
+            bitmap.recycle()
+        }
+    }
+
+    private fun notifyBarcodeDetected(result: BarcodeDetectionResult) {
+        pluginDelegate.let { plugin ->
+            if (plugin is CameraViewPlugin) {
+                plugin.notifyBarcodeDetected(result)
+            }
+        }
+    }
+
+    /** Get the current zoom factors */
+    private fun getZoomFactorsInternal(): ZoomFactors {
+        cameraController?.let { controller ->
+            val zoomState = controller.zoomState
+            val zoomFactors =
+                ZoomFactors(
+                    min = zoomState.value?.minZoomRatio ?: 1.0f,
+                    max = zoomState.value?.maxZoomRatio ?: 1.0f,
+                    current = zoomState.value?.zoomRatio ?: 1.0f
+                )
+
+            return zoomFactors
+        }
+
+        return ZoomFactors(1.0f, 1.0f, 1.0f)
+    }
+
+    companion object {
+        private const val TAG = "CameraView"
+    }
+}