capacitor-camera-view 2.2.0 → 2.3.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
@@ -38,7 +48,9 @@ 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
@@ -55,6 +67,7 @@ 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
@@ -72,7 +85,9 @@ class CameraView(plugin: Plugin) {
     // Camera components (using atomic reference for thread safety)
     private var cameraController: LifecycleCameraController?
         get() = cameraControllerRef.get()
-        set(value) { cameraControllerRef.set(value) }
+        set(value) {
+            cameraControllerRef.set(value)
+        }
 
     private val cameraExecutor: ExecutorService by lazy { Executors.newSingleThreadExecutor() }
     private var previewView: PreviewView? = null
@@ -81,6 +96,21 @@ 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
+
+    // Enabled CameraX use cases before video recording temporarily changes them.
+    private var enabledUseCasesBeforeRecording: Int? = null
+
     // Plugin context
     private var lifecycleOwner: LifecycleOwner? = null
     private var pluginDelegate: Plugin = plugin
@@ -130,7 +160,17 @@ class CameraView(plugin: Plugin) {
     /** 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()
+            cameraController = null
 
             previewView?.let { view ->
                 try {
@@ -242,11 +282,15 @@ class CameraView(plugin: Plugin) {
                                     "Image captured successfully in ${System.currentTimeMillis() - startTime}ms"
                                 )
                                 try {
-                                    val base64String = imageProxyToBase64(image, quality, imageRotationDegrees)
+                                    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")
+                                    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)
@@ -346,6 +390,263 @@ class CameraView(plugin: Plugin) {
         }
     }
 
+    /**
+     * Starts video recording to a temporary file.
+     */
+    suspend fun startRecordingAsync(
+        enableAudio: Boolean,
+        videoQuality: VideoRecordingQuality,
+    ): CameraResult<Unit> = suspendCancellableCoroutine { continuation ->
+        mainHandler.post {
+            startRecordingOnMainThread(enableAudio, videoQuality, continuation)
+        }
+    }
+
+    private fun startRecordingOnMainThread(
+        enableAudio: Boolean,
+        videoQuality: VideoRecordingQuality,
+        continuation: CancellableContinuation<CameraResult<Unit>>
+    ) {
+        val controller = validateRecordingPreconditions(continuation) ?: return
+
+        try {
+            controller.videoCaptureQualitySelector = videoQuality.toQualitySelector()
+
+            // Enable VIDEO_CAPTURE use case alongside IMAGE_CAPTURE
+            enabledUseCasesBeforeRecording = controller.currentEnabledUseCases()
+            controller.setEnabledUseCases(
+                CameraController.IMAGE_CAPTURE or CameraController.VIDEO_CAPTURE
+            )
+
+            val outputOptions = createRecordingOutputOptions()
+            val audioConfig = resolveAudioConfig(enableAudio, continuation) ?: return
+
+            startCameraRecording(controller, outputOptions, audioConfig, continuation)
+        } catch (e: SecurityException) {
+            Log.e(TAG, "Security exception when starting recording. Missing permission?", e)
+            restoreUseCasesAfterRecording()
+            continuation.resume(CameraResult.Error(e))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error starting recording", e)
+            restoreUseCasesAfterRecording()
+            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)
+                }
+
+                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.
+            restoreUseCasesAfterRecording()
+
+            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 LifecycleCameraController.currentEnabledUseCases(): Int {
+        var enabledUseCases = 0
+        if (isImageCaptureEnabled) {
+            enabledUseCases = enabledUseCases or CameraController.IMAGE_CAPTURE
+        }
+        if (isImageAnalysisEnabled) {
+            enabledUseCases = enabledUseCases or CameraController.IMAGE_ANALYSIS
+        }
+        if (isVideoCaptureEnabled) {
+            enabledUseCases = enabledUseCases or CameraController.VIDEO_CAPTURE
+        }
+        return enabledUseCases
+    }
+
+    private fun restoreUseCasesAfterRecording() {
+        val useCases = enabledUseCasesBeforeRecording ?: CameraController.IMAGE_CAPTURE
+        enabledUseCasesBeforeRecording = null
+        cameraController?.setEnabledUseCases(useCases)
+    }
+
+    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) {
@@ -533,6 +834,12 @@ class CameraView(plugin: Plugin) {
 
         mainHandler.post {
             try {
+                // Stop any active recording before cleanup
+                activeRecording?.stop()
+                activeRecording = null
+                pendingStopCallback = null
+                currentRecordingFile = null
+
                 // Stop camera session
                 cameraController?.unbind()
                 cameraController = null

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

@@ -12,6 +12,7 @@ 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
@@ -21,7 +22,10 @@ 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
@@ -144,7 +148,113 @@ class CameraViewPlugin : Plugin() {
                 },
                 onError = { error ->
                     call.reject("Failed to capture frame: ${error.message}", error)
-                    Log.d(TAG, "captureSample failed after ${System.currentTimeMillis() - timeStart}ms")
+                    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)
                 }
             )
         }

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,6 +13,7 @@ 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
 
@@ -171,7 +172,7 @@ fun sessionConfigFromPluginCall(call: PluginCall): CameraSessionConfiguration {
             jsonArray.optString(i)?.let { stringTypes.add(it) }
         }
         val converted = convertToNativeBarcodeFormats(stringTypes)
-        if (converted.isNotEmpty()) converted else null
+        converted.ifEmpty { null }
     }
 
     return CameraSessionConfiguration(
@@ -250,4 +251,23 @@ fun imageProxyToBase64(image: ImageProxy, quality: Int, rotationDegrees: Int): S
         // 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
+    }
 }