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

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

@@ -1,7 +1,9 @@
 package com.michaelwolz.capacitorcameraview
 
+import android.Manifest
 import android.content.Context
 import android.content.Context.CAMERA_SERVICE
+import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.hardware.camera2.CameraCharacteristics
 import android.hardware.camera2.CameraManager
@@ -23,8 +25,16 @@ import androidx.camera.core.TorchState
 import androidx.camera.core.resolutionselector.AspectRatioStrategy
 import androidx.camera.core.resolutionselector.ResolutionSelector
 import androidx.camera.mlkit.vision.MlKitAnalyzer
+import androidx.camera.video.FallbackStrategy
+import androidx.camera.video.FileOutputOptions
+import androidx.camera.video.Quality
+import androidx.camera.video.QualitySelector
+import androidx.camera.video.Recording
+import androidx.camera.video.VideoRecordEvent
+import androidx.camera.view.CameraController
 import androidx.camera.view.LifecycleCameraController
 import androidx.camera.view.PreviewView
+import androidx.camera.view.video.AudioConfig
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.LifecycleOwner
 import com.getcapacitor.FileUtils
@@ -36,20 +46,49 @@ 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.CameraResult
 import com.michaelwolz.capacitorcameraview.model.CameraSessionConfiguration
+import com.michaelwolz.capacitorcameraview.model.VideoRecordingQuality
 import com.michaelwolz.capacitorcameraview.model.ZoomFactors
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileOutputStream
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.coroutines.resume
 
 /** Throttle time for barcode detection in milliseconds. */
-const val BARCODE_DETECTION_THROTTLE_MS = 100
+const val BARCODE_DETECTION_THROTTLE_MS = 100L
 
 class CameraView(plugin: Plugin) {
-    // Camera components
-    private var cameraController: LifecycleCameraController? = null
+    // Coroutine scope for async operations
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    // Thread-safe camera controller reference
+    private val cameraControllerRef = AtomicReference<LifecycleCameraController?>(null)
+
+    // Camera components (using atomic reference for thread safety)
+    private var cameraController: LifecycleCameraController?
+        get() = cameraControllerRef.get()
+        set(value) {
+            cameraControllerRef.set(value)
+        }
+
     private val cameraExecutor: ExecutorService by lazy { Executors.newSingleThreadExecutor() }
     private var previewView: PreviewView? = null
 
@@ -57,6 +96,18 @@ class CameraView(plugin: Plugin) {
     private var currentCameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
     private var currentFlashMode: Int = ImageCapture.FLASH_MODE_OFF
 
+    // Active video recording
+    private var activeRecording: Recording? = null
+
+    /**
+     * Holds the pending stop-recording continuation result handler.
+     * Needed because CameraX delivers the final recording outcome asynchronously via Finalize.
+     */
+    private var pendingStopCallback: ((CameraResult<JSObject>) -> Unit)? = null
+
+    // Track the output file for the current recording
+    private var currentRecordingFile: File? = null
+
     // Plugin context
     private var lifecycleOwner: LifecycleOwner? = null
     private var pluginDelegate: Plugin = plugin
@@ -65,56 +116,86 @@ class CameraView(plugin: Plugin) {
 
     private val mainHandler by lazy { android.os.Handler(android.os.Looper.getMainLooper()) }
 
-    private var lastBarcodeDetectionTime = 0L
+    // Thread-safe barcode throttle timestamp
+    private val lastBarcodeDetectionTime = AtomicLong(0L)
+
+    // Flow for reactive barcode events
+    private val _barcodeEvents = MutableSharedFlow<BarcodeDetectionResult>(
+        replay = 0,
+        extraBufferCapacity = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST
+    )
+    val barcodeEvents: SharedFlow<BarcodeDetectionResult> = _barcodeEvents.asSharedFlow()
 
     /** Starts a camera session with the provided configuration. */
-    fun startSession(config: CameraSessionConfiguration, callback: (Exception?) -> Unit) {
-        val lifecycleOwner =
-            context as? LifecycleOwner
-                ?: run {
-                    callback(CameraError.LifecycleOwnerMissing())
-                    return
-                }
+    suspend fun startSessionAsync(config: CameraSessionConfiguration): CameraResult<Unit> =
+        withContext(Dispatchers.Main) {
+            val lifecycleOwner = context as? LifecycleOwner
+                ?: return@withContext CameraResult.Error(CameraError.LifecycleOwnerMissing())
 
-        // Store references for later use
-        this.lifecycleOwner = lifecycleOwner
+            this@CameraView.lifecycleOwner = lifecycleOwner
 
-        mainHandler.post {
             try {
                 initializeCamera(context, lifecycleOwner, config)
-                callback(null)
+                CameraResult.Success(Unit)
             } catch (e: Exception) {
                 Log.e(TAG, "Error in camera setup", e)
-                callback(e)
+                CameraResult.Error(e)
             }
         }
+
+    /** Starts a camera session with the provided configuration (callback version for backward compatibility). */
+    fun startSession(config: CameraSessionConfiguration, callback: (Exception?) -> Unit) {
+        scope.launch {
+            startSessionAsync(config).fold(
+                onSuccess = { callback(null) },
+                onError = { callback(it) }
+            )
+        }
     }
 
-    /** Stop the camera session and release resources */
-    fun stopSession(callback: ((Exception?) -> Unit)? = null) {
-        mainHandler.post {
+    /** Stop the camera session and release resources. */
+    suspend fun stopSessionAsync(): CameraResult<Unit> = withContext(Dispatchers.Main) {
+        try {
+            // Stop any active recording before unbinding
+            activeRecording?.stop()
+            activeRecording = null
+            pendingStopCallback?.invoke(
+                CameraResult.Error(Exception("Recording was interrupted because the camera session stopped"))
+            )
+            pendingStopCallback = null
+            currentRecordingFile = null
+
             cameraController?.unbind()
 
-            try {
-                previewView?.let { view ->
-                    try {
-                        (webView.parent as? ViewGroup)?.removeView(view)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Error removing preview view", e)
-                    } finally {
-                        previewView = 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)
+            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)
-            }
+            Log.d(TAG, "Camera session stopped successfully")
+            CameraResult.Success(Unit)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error stopping camera session", e)
+            CameraResult.Error(e)
+        }
+    }
+
+    /** Stop the camera session and release resources (callback version for backward compatibility). */
+    fun stopSession(callback: ((Exception?) -> Unit)? = null) {
+        scope.launch {
+            stopSessionAsync().fold(
+                onSuccess = { callback?.invoke(null) },
+                onError = { callback?.invoke(it) }
+            )
         }
     }
 
@@ -123,24 +204,24 @@ class CameraView(plugin: Plugin) {
         return cameraController != null
     }
 
-    /** Capture a photo with the current camera configuration */
-    fun capturePhoto(
+    /** Capture a photo with the current camera configuration. */
+    suspend fun capturePhotoAsync(
         quality: Int,
-        saveToFile: Boolean = false,
-        callback: (JSObject?, Exception?) -> Unit
-    ) {
+        saveToFile: Boolean = false
+    ): CameraResult<JSObject> = suspendCancellableCoroutine { continuation ->
         val startTime = System.currentTimeMillis()
+
         val controller = cameraController
-            ?: run {
-                callback(null, CameraError.CameraNotInitialized())
-                return
-            }
+        if (controller == null) {
+            continuation.resume(CameraResult.Error(CameraError.CameraNotInitialized()))
+            return@suspendCancellableCoroutine
+        }
 
         val preview = previewView
-            ?: run {
-                callback(null, CameraError.PreviewNotInitialized())
-                return
-            }
+        if (preview == null) {
+            continuation.resume(CameraResult.Error(CameraError.PreviewNotInitialized()))
+            return@suspendCancellableCoroutine
+        }
 
         mainHandler.post {
             val cameraInfo = controller.cameraInfo
@@ -177,12 +258,12 @@ class CameraView(plugin: Plugin) {
 
                                     put("webPath", capacitorFilePath)
                                 }
-                                callback(result, null)
+                                continuation.resume(CameraResult.Success(result))
                             }
 
                             override fun onError(exception: ImageCaptureException) {
                                 Log.e(TAG, "Error saving image to file", exception)
-                                callback(null, exception)
+                                continuation.resume(CameraResult.Error(exception))
                             }
                         }
                     )
@@ -196,109 +277,353 @@ class CameraView(plugin: Plugin) {
                                     TAG,
                                     "Image captured successfully in ${System.currentTimeMillis() - startTime}ms"
                                 )
-                                handleCaptureSuccess(image, quality, imageRotationDegrees, callback)
+                                try {
+                                    val base64String =
+                                        imageProxyToBase64(image, quality, imageRotationDegrees)
+                                    val result = JSObject().apply {
+                                        put("photo", base64String)
+                                    }
+                                    Log.d(
+                                        TAG,
+                                        "Image processed to Base64 in ${System.currentTimeMillis() - startTime}ms"
+                                    )
+                                    continuation.resume(CameraResult.Success(result))
+                                } catch (e: Exception) {
+                                    Log.e(TAG, "Error processing captured image", e)
+                                    continuation.resume(CameraResult.Error(e))
+                                } finally {
+                                    image.close()
+                                }
                             }
 
                             override fun onError(exception: ImageCaptureException) {
                                 Log.e(TAG, "Error capturing image", exception)
-                                callback(null, exception)
+                                continuation.resume(CameraResult.Error(exception))
                             }
                         }
                     )
                 }
             } catch (e: Exception) {
                 Log.e(TAG, "Error setting up image capture", e)
-                callback(null, e)
+                continuation.resume(CameraResult.Error(e))
             }
         }
     }
 
-    /**
-     * Handles the successful capture of an image for base64 conversion
-     */
-    fun handleCaptureSuccess(
-        image: ImageProxy,
+    /** Capture a photo with the current camera configuration (callback version for backward compatibility). */
+    fun capturePhoto(
         quality: Int,
-        rotationDegrees: Int,
+        saveToFile: Boolean = false,
         callback: (JSObject?, Exception?) -> Unit
     ) {
-        val startTime = System.currentTimeMillis()
+        scope.launch {
+            capturePhotoAsync(quality, saveToFile).fold(
+                onSuccess = { callback(it, null) },
+                onError = { callback(null, it) }
+            )
+        }
+    }
+
+    /**
+     * Capture a frame directly from the preview without using the full photo pipeline.
+     * Faster but has lower quality than full photo capture.
+     */
+    suspend fun captureSampleFromPreviewAsync(
+        quality: Int,
+        saveToFile: Boolean = false
+    ): CameraResult<JSObject> = withContext(Dispatchers.Main) {
+        val preview = previewView
+            ?: return@withContext CameraResult.Error(CameraError.PreviewNotInitialized())
+
         try {
-            val base64String = imageProxyToBase64(image, quality, rotationDegrees)
-            val result = JSObject().apply {
-                put("photo", base64String)
+            val bitmap = preview.bitmap
+                ?: return@withContext CameraResult.Error(Exception("Preview bitmap not available"))
+
+            val result = JSObject()
+
+            if (saveToFile) {
+                val tempFile =
+                    File.createTempFile("camera_capture_sample", ".jpg", context.cacheDir)
+
+                FileOutputStream(tempFile).use { outputStream ->
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
+                }
+
+                val capacitorFilePath = FileUtils.getPortablePath(
+                    context,
+                    pluginDelegate.bridge.localUrl,
+                    Uri.fromFile(tempFile)
+                )
+
+                result.put("webPath", capacitorFilePath)
+            } else {
+                // Convert bitmap to Base64 using pooled stream
+                val base64String = bitmapToBase64(bitmap, quality)
+                result.put("photo", base64String)
             }
-            Log.d(TAG, "Image processed to Base64 in ${System.currentTimeMillis() - startTime}ms")
-            callback(result, null)
+
+            CameraResult.Success(result)
         } catch (e: Exception) {
-            Log.e(TAG, "Error processing captured image", e)
-            callback(null, e)
-        } finally {
-            image.close()
+            Log.e(TAG, "Error capturing preview frame", e)
+            CameraResult.Error(e)
         }
     }
 
     /**
-     * Capture a frame directly from the preview without using the full photo pipeline which is
-     * faster but has lower quality.
+     * Capture a frame directly from the preview without using the full photo pipeline (callback version).
+     * Faster but has lower quality than full photo capture.
      */
     fun captureSampleFromPreview(
         quality: Int,
         saveToFile: Boolean = false,
         callback: (JSObject?, Exception?) -> Unit
     ) {
-        val previewView =
-            this.previewView
-                ?: run {
-                    callback(null, CameraError.PreviewNotInitialized())
-                    return
-                }
+        scope.launch {
+            captureSampleFromPreviewAsync(quality, saveToFile).fold(
+                onSuccess = { callback(it, null) },
+                onError = { callback(null, it) }
+            )
+        }
+    }
 
+    /**
+     * Starts video recording to a temporary file.
+     */
+    suspend fun startRecordingAsync(
+        enableAudio: Boolean,
+        videoQuality: VideoRecordingQuality,
+    ): CameraResult<Unit> = suspendCancellableCoroutine { continuation ->
         mainHandler.post {
-            try {
-                val bitmap =
-                    previewView.bitmap
-                        ?: run {
-                            callback(null, Exception("Preview bitmap not available"))
-                            return@post
-                        }
+            startRecordingOnMainThread(enableAudio, videoQuality, continuation)
+        }
+    }
 
-                val result = JSObject()
+    private fun startRecordingOnMainThread(
+        enableAudio: Boolean,
+        videoQuality: VideoRecordingQuality,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ) {
+        val controller = validateRecordingPreconditions(continuation) ?: return
 
-                if (saveToFile) {
-                    val tempFile =
-                        File.createTempFile("camera_capture_sample", ".jpg", context.cacheDir)
+        try {
+            controller.videoCaptureQualitySelector = videoQuality.toQualitySelector()
 
-                    FileOutputStream(tempFile).use { outputStream ->
-                        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
-                    }
+            // Enable VIDEO_CAPTURE use case alongside IMAGE_CAPTURE
+            controller.setEnabledUseCases(
+                CameraController.IMAGE_CAPTURE or CameraController.VIDEO_CAPTURE
+            )
 
-                    val capacitorFilePath = FileUtils.getPortablePath(
-                        context,
-                        pluginDelegate.bridge.localUrl,
-                        Uri.fromFile(tempFile)
-                    )
+            val outputOptions = createRecordingOutputOptions()
+            val audioConfig = resolveAudioConfig(enableAudio, continuation) ?: return
 
-                    result.put("webPath", capacitorFilePath)
-                } else {
-                    // Convert bitmap to Base64
-                    val outputStream = ByteArrayOutputStream()
-                    outputStream.use { stream ->
-                        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream)
-                        val byteArray = stream.toByteArray()
-                        val base64String = Base64.encodeToString(byteArray, Base64.NO_WRAP)
-                        result.put("photo", base64String)
-                    }
+            startCameraRecording(controller, outputOptions, audioConfig, continuation)
+        } catch (e: SecurityException) {
+            Log.e(TAG, "Security exception when starting recording. Missing permission?", e)
+            // Restore normal use cases on permission error
+            cameraController?.setEnabledUseCases(CameraController.IMAGE_CAPTURE)
+            continuation.resume(CameraResult.Error(e))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error starting recording", e)
+            // Restore normal use cases on error
+            cameraController?.setEnabledUseCases(CameraController.IMAGE_CAPTURE)
+            continuation.resume(CameraResult.Error(e))
+        }
+    }
+
+    private fun validateRecordingPreconditions(
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ): LifecycleCameraController? {
+        val controller = cameraController
+        if (controller == null) {
+            continuation.resume(CameraResult.Error(CameraError.CameraNotInitialized()))
+            return null
+        }
+
+        if (activeRecording != null) {
+            continuation.resume(CameraResult.Error(Exception("Recording is already in progress")))
+            return null
+        }
+
+        return controller
+    }
+
+    private fun createRecordingOutputOptions(): FileOutputOptions {
+        val tempFile = File.createTempFile(
+            "camera_recording_",
+            ".mp4",
+            context.cacheDir
+        )
+        currentRecordingFile = tempFile
+        return FileOutputOptions.Builder(tempFile).build()
+    }
+
+    private fun resolveAudioConfig(
+        enableAudio: Boolean,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ): AudioConfig? {
+        if (!enableAudio) {
+            return AudioConfig.AUDIO_DISABLED
+        }
+
+        if (hasMicrophonePermission()) {
+            return try {
+                AudioConfig.create(true)
+            } catch (e: SecurityException) {
+                continuation.resume(CameraResult.Error(e))
+                null
+            }
+        }
+
+        continuation.resume(
+            CameraResult.Error(
+                SecurityException("Microphone permission is required for audio recording")
+            )
+        )
+        return null
+    }
+
+    private fun hasMicrophonePermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun startCameraRecording(
+        controller: LifecycleCameraController,
+        outputOptions: FileOutputOptions,
+        audioConfig: AudioConfig,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ) {
+        val startResumed = AtomicBoolean(false)
+        activeRecording = controller.startRecording(
+            outputOptions,
+            audioConfig,
+            cameraExecutor
+        ) { event ->
+            when (event) {
+                is VideoRecordEvent.Start -> handleRecordingStartEvent(startResumed, continuation)
+                is VideoRecordEvent.Finalize -> {
+                    handleRecordingFinalizeEvent(event, startResumed, continuation)
                 }
 
-                callback(result, null)
-            } catch (e: Exception) {
-                Log.e(TAG, "Error capturing preview frame", e)
-                callback(null, e)
+                else -> Unit
+            }
+        }
+    }
+
+    private fun handleRecordingStartEvent(
+        startResumed: AtomicBoolean,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ) {
+        Log.d(TAG, "Video recording started")
+        if (continuation.isActive && startResumed.compareAndSet(false, true)) {
+            continuation.resume(CameraResult.Success(Unit))
+        }
+    }
+
+    private fun handleRecordingFinalizeEvent(
+        event: VideoRecordEvent.Finalize,
+        startResumed: AtomicBoolean,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ) {
+        // If recording finalized before Start was emitted, resume the
+        // startRecording continuation with an error
+        if (continuation.isActive && startResumed.compareAndSet(false, true)) {
+            continuation.resume(
+                CameraResult.Error(
+                    Exception("Recording failed to start: error code ${event.error}")
+                )
+            )
+        }
+
+        finalizeRecordingAndNotifyStopCallback(event)
+    }
+
+    private fun finalizeRecordingAndNotifyStopCallback(event: VideoRecordEvent.Finalize) {
+        mainHandler.post {
+            // CameraX requires use case changes on the main thread.
+            cameraController?.setEnabledUseCases(CameraController.IMAGE_CAPTURE)
+
+            val callback = pendingStopCallback
+            pendingStopCallback = null
+            // Always clean up recording state
+            activeRecording = null
+
+            if (event.hasError()) {
+                Log.e(TAG, "Recording error: ${event.error}")
+                currentRecordingFile = null
+                callback?.invoke(CameraResult.Error(Exception("Recording failed with error code: ${event.error}")))
+                return@post
+            }
+
+            val file = currentRecordingFile
+            currentRecordingFile = null
+            if (file == null) {
+                callback?.invoke(CameraResult.Error(Exception("Recording file not found")))
+                return@post
             }
+
+            val capacitorFilePath = FileUtils.getPortablePath(
+                context,
+                pluginDelegate.bridge.localUrl,
+                Uri.fromFile(file)
+            )
+            val result = JSObject().apply {
+                put("webPath", capacitorFilePath)
+            }
+            callback?.invoke(CameraResult.Success(result))
+        }
+    }
+
+    private fun VideoRecordingQuality.toQualitySelector(): QualitySelector {
+        return when (this) {
+            VideoRecordingQuality.LOWEST -> QualitySelector.from(Quality.LOWEST)
+            VideoRecordingQuality.SD -> QualitySelector.from(
+                Quality.SD,
+                FallbackStrategy.lowerQualityOrHigherThan(Quality.SD)
+            )
+
+            VideoRecordingQuality.HD -> QualitySelector.from(
+                Quality.HD,
+                FallbackStrategy.lowerQualityOrHigherThan(Quality.HD)
+            )
+
+            VideoRecordingQuality.FHD -> QualitySelector.from(
+                Quality.FHD,
+                FallbackStrategy.lowerQualityOrHigherThan(Quality.FHD)
+            )
+
+            VideoRecordingQuality.UHD -> QualitySelector.from(
+                Quality.UHD,
+                FallbackStrategy.lowerQualityOrHigherThan(Quality.UHD)
+            )
+
+            VideoRecordingQuality.HIGHEST -> QualitySelector.from(Quality.HIGHEST)
         }
     }
 
+    /**
+     * Stops the current video recording and returns the file path.
+     */
+    suspend fun stopRecordingAsync(): CameraResult<JSObject> =
+        suspendCancellableCoroutine { continuation ->
+            mainHandler.post {
+                val recording = activeRecording
+                if (recording == null) {
+                    continuation.resume(CameraResult.Error(Exception("No recording is in progress")))
+                    return@post
+                }
+
+                pendingStopCallback = { result ->
+                    continuation.resume(result)
+                }
+
+                activeRecording = null
+                recording.stop()
+            }
+        }
+
     /** Flip between front and back cameras */
     fun flipCamera(callback: (Exception?) -> Unit) {
         currentCameraSelector = when (currentCameraSelector) {
@@ -481,8 +806,17 @@ class CameraView(plugin: Plugin) {
 
     /** Clean up resources when the plugin is being destroyed */
     fun cleanup() {
+        // Cancel all coroutines first
+        scope.cancel()
+
         mainHandler.post {
             try {
+                // Stop any active recording before cleanup
+                activeRecording?.stop()
+                activeRecording = null
+                pendingStopCallback = null
+                currentRecordingFile = null
+
                 // Stop camera session
                 cameraController?.unbind()
                 cameraController = null
@@ -512,6 +846,14 @@ class CameraView(plugin: Plugin) {
         }
     }
 
+    /** Converts a bitmap to Base64 with memory-efficient pooled ByteArrayOutputStream. */
+    private fun bitmapToBase64(bitmap: Bitmap, quality: Int): String {
+        val outputStream = ByteArrayOutputStream(256 * 1024) // 256KB initial capacity
+        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
+        val byteArray = outputStream.toByteArray()
+        return Base64.encodeToString(byteArray, Base64.NO_WRAP)
+    }
+
     private fun setupPreviewView(context: Context) {
         // Make WebView transparent
         webView.setBackgroundColor(android.graphics.Color.TRANSPARENT)
@@ -575,7 +917,7 @@ class CameraView(plugin: Plugin) {
 
         // Setup barcode scanning if needed
         if (config.enableBarcodeDetection) {
-            setupBarcodeScanner(controller)
+            setupBarcodeScanner(controller, config.barcodeTypes)
         }
 
         // Bind to lifecycle
@@ -585,13 +927,33 @@ class CameraView(plugin: Plugin) {
         this.setZoomFactor(config.zoomFactor, null)
     }
 
-    private fun setupBarcodeScanner(controller: LifecycleCameraController) {
+    /**
+     * Sets up the barcode scanner with the specified formats.
+     *
+     * @param controller The camera controller to attach the scanner to.
+     * @param barcodeTypes Optional list of specific barcode format codes to detect.
+     *                     If null, all supported formats are detected (backwards compatible).
+     */
+    private fun setupBarcodeScanner(
+        controller: LifecycleCameraController,
+        barcodeTypes: List<Int>? = null
+    ) {
         val previewView = this.previewView ?: return
 
-        val options =
+        // Build scanner options with specified formats or all formats
+        val options = if (barcodeTypes != null && barcodeTypes.isNotEmpty()) {
+            // Use specific formats - setBarcodeFormats takes first format + vararg rest
+            val firstFormat = barcodeTypes.first()
+            val restFormats = barcodeTypes.drop(1).toIntArray()
+            BarcodeScannerOptions.Builder()
+                .setBarcodeFormats(firstFormat, *restFormats)
+                .build()
+        } else {
+            // Default to all formats for backwards compatibility
             BarcodeScannerOptions.Builder()
                 .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
                 .build()
+        }
 
         val barcodeScanner = BarcodeScanning.getClient(options)
         val mainExecutor = ContextCompat.getMainExecutor(previewView.context)
@@ -621,10 +983,18 @@ class CameraView(plugin: Plugin) {
         topOffset: Int
     ) {
         val now = System.currentTimeMillis()
-        if (now - lastBarcodeDetectionTime < BARCODE_DETECTION_THROTTLE_MS) {
+        val lastTime = lastBarcodeDetectionTime.get()
+
+        // Thread-safe throttle check using atomic compare-and-set
+        if (now - lastTime < BARCODE_DETECTION_THROTTLE_MS) {
             return // Skip this frame
         }
 
+        // Atomically update the timestamp - if another thread beat us, skip
+        if (!lastBarcodeDetectionTime.compareAndSet(lastTime, now)) {
+            return
+        }
+
         val barcodes = result?.getValue(barcodeScanner) ?: return
         if (barcodes.isEmpty()) return
 
@@ -642,8 +1012,13 @@ class CameraView(plugin: Plugin) {
                 boundingRect = webBoundingRect
             )
 
+        // Emit to Flow for reactive subscribers
+        scope.launch {
+            _barcodeEvents.emit(barcodeResult)
+        }
+
+        // Also notify via callback for backward compatibility
         notifyBarcodeDetected(barcodeResult)
-        lastBarcodeDetectionTime = now
     }
 
     private fun notifyBarcodeDetected(result: BarcodeDetectionResult) {