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

package/README.md

@@ -29,6 +29,7 @@
 
 - 📹 Embed a **live camera feed** directly into your app.
 - 📸 Capture photos or frames from the camera preview.
+- 🎥 **Video recording** with optional audio support.
 - 🔍 **Barcode detection** support.
 - 📱 **Virtual device support** for automatic lens selection based on zoom level and focus (iOS only).
 - 🔦 Control **zoom**, **flash** and **torch** modes programmatically.
@@ -62,12 +63,70 @@ Add the following keys to your app's `Info.plist` file:
 <string>To capture photos and videos</string>
 ```
 
+If you plan to use `startRecording` with `enableAudio: true`, also add:
+
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>To record audio with video</string>
+```
+
+> [!IMPORTANT]
+> The `NSMicrophoneUsageDescription` key must be present in `Info.plist` **before** microphone permission is ever requested — even if the request happens automatically when starting a recording with audio. Omitting it will cause your app to crash at runtime.
+
 #### Android
 
-The `CAMERA` permission is automatically added by Capacitor. Ensure your `AndroidManifest.xml` includes it if needed for specific configurations:
+The `CAMERA` permission is added to your app's `AndroidManifest.xml` automatically by the plugin. If you plan to use `startRecording` with `enableAudio: true`, the `RECORD_AUDIO` permission is also declared automatically by the plugin. You can verify these in your merged manifest:
 
 ```xml
 <uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+```
+
+> [!IMPORTANT]
+> Declaring a permission in `AndroidManifest.xml` is required for the system to allow requesting it at runtime. The plugin handles this for you, but make sure you are not accidentally stripping the permission in your build configuration.
+
+## 🔒 Permissions
+
+The plugin handles permissions for you automatically when a feature that requires them is used. However, you can also request permissions explicitly in advance.
+
+### Requesting permissions explicitly
+
+By default, `requestPermissions()` only requests **camera** permission, preserving backward compatibility:
+
+```typescript
+// Request camera permission only (default behavior)
+const status = await CameraView.requestPermissions();
+console.log(status.camera); // 'granted' | 'denied' | 'prompt'
+```
+
+To also request **microphone** permission (needed for video recording with audio), pass the `permissions` option:
+
+```typescript
+// Request both camera and microphone permissions
+const status = await CameraView.requestPermissions({
+  permissions: ['camera', 'microphone'],
+});
+console.log(status.camera);     // 'granted' | 'denied' | 'prompt'
+console.log(status.microphone); // 'granted' | 'denied' | 'prompt'
+```
+
+### Automatic permission requests
+
+You do not need to call `requestPermissions()` manually. The plugin will automatically request the required permissions when a feature is first used:
+
+- **Camera** permission is requested automatically when `start()` is called.
+- **Microphone** permission is requested automatically when `startRecording({ enableAudio: true })` is called.
+
+Regardless of whether you request permissions manually or rely on the automatic flow, the corresponding entries **must** be declared in your app's platform configuration (`Info.plist` on iOS, `AndroidManifest.xml` on Android) as described above.
+
+### Checking permission status
+
+Use `checkPermissions()` to query the current permission state without triggering a system prompt:
+
+```typescript
+const status = await CameraView.checkPermissions();
+console.log(status.camera);     // 'granted' | 'denied' | 'prompt'
+console.log(status.microphone); // 'granted' | 'denied' | 'prompt'
 ```
 
 ## ▶️ Basic Usage
@@ -174,6 +233,54 @@ CameraView.addListener('barcodeDetected', (data) => {
 
 See the [`BarcodeDetectionData`](#barcodedetectiondata) interface for details on the event payload.
 
+## 🎥 Video Recording
+
+This plugin supports recording video directly from the live camera feed.
+
+**How it works:**
+*   **iOS:** Uses `AVCaptureMovieFileOutput` on top of the existing `AVCaptureSession`. Output is saved as `.mp4`.
+*   **Android:** Uses the CameraX `VideoCapture` use case via `LifecycleCameraController`. Output is saved as `.mp4`.
+*   **Web:** Uses the browser `MediaRecorder` API on the existing `MediaStream`. Output is a `.webm` blob URL (MP4 is not broadly supported by browsers).
+
+**Basic usage:**
+
+```typescript
+import { CameraView } from 'capacitor-camera-view';
+
+// Start recording (camera must already be running)
+await CameraView.startRecording({ enableAudio: false });
+
+// Stop recording and get the result
+const result = await CameraView.stopRecording();
+console.log('Video saved to:', result.webPath);
+```
+
+**Playing back the recorded video:**
+
+```html
+<video [src]="videoPath" controls></video>
+```
+
+**Recording with audio:**
+
+```typescript
+await CameraView.startRecording({ enableAudio: true });
+```
+
+**Recording with explicit quality preset (native):**
+
+```typescript
+await CameraView.startRecording({
+  enableAudio: true,
+  videoQuality: 'fhd', // lowest | sd | hd | fhd | uhd | highest
+});
+```
+
+> [!NOTE]
+> When `enableAudio: true` is used, the plugin automatically requests microphone permission from the user if it has not been granted yet. The permission declaration must still be present in your platform configuration — see the [Permissions](#-permissions) section for details.
+
+See the [`VideoRecordingOptions`](#videorecordingoptions) and [`VideoRecordingResponse`](#videorecordingresponse) interfaces in the API section for the full set of options.
+
 ## 🧪 Example App
 
 To see the plugin in action, check out the example app in the `example-app` folder. The app demonstrates how to integrate and use the Capacitor Camera View plugin in an Ionic Angular project.
@@ -206,6 +313,8 @@ chore: update dependencies
 * [`isRunning()`](#isrunning)
 * [`capture(...)`](#capture)
 * [`captureSample(...)`](#capturesample)
+* [`startRecording(...)`](#startrecording)
+* [`stopRecording()`](#stoprecording)
 * [`flipCamera()`](#flipcamera)
 * [`getAvailableDevices()`](#getavailabledevices)
 * [`getZoom()`](#getzoom)
@@ -217,7 +326,7 @@ chore: update dependencies
 * [`getTorchMode()`](#gettorchmode)
 * [`setTorchMode(...)`](#settorchmode)
 * [`checkPermissions()`](#checkpermissions)
-* [`requestPermissions()`](#requestpermissions)
+* [`requestPermissions(...)`](#requestpermissions)
 * [`addListener('barcodeDetected', ...)`](#addlistenerbarcodedetected-)
 * [`removeAllListeners(...)`](#removealllisteners)
 * [Interfaces](#interfaces)
@@ -321,6 +430,40 @@ not yet well supported on the web.
 --------------------
 
 
+### startRecording(...)
+
+```typescript
+startRecording(options?: VideoRecordingOptions | undefined) => Promise<void>
+```
+
+Start recording video from the current camera.
+Camera must be running. Throws if already recording.
+
+| Param         | Type                                                                    | Description                        |
+| ------------- | ----------------------------------------------------------------------- | ---------------------------------- |
+| **`options`** | <code><a href="#videorecordingoptions">VideoRecordingOptions</a></code> | - Optional recording configuration |
+
+**Since:** 2.2.0
+
+--------------------
+
+
+### stopRecording()
+
+```typescript
+stopRecording() => Promise<VideoRecordingResponse>
+```
+
+Stop the current video recording and return the result.
+Throws if no recording is in progress.
+
+**Returns:** <code>Promise&lt;<a href="#videorecordingresponse">VideoRecordingResponse</a>&gt;</code>
+
+**Since:** 2.2.0
+
+--------------------
+
+
 ### flipCamera()
 
 ```typescript
@@ -481,7 +624,7 @@ Set the torch (flashlight) mode and intensity.
 checkPermissions() => Promise<PermissionStatus>
 ```
 
-Check camera permission status without requesting permissions.
+Check camera and microphone permission status without requesting permissions.
 
 **Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
 
@@ -490,13 +633,20 @@ Check camera permission status without requesting permissions.
 --------------------
 
 
-### requestPermissions()
+### requestPermissions(...)
 
 ```typescript
-requestPermissions() => Promise<PermissionStatus>
+requestPermissions(options?: { permissions?: CameraPermissionType[] | undefined; } | undefined) => Promise<PermissionStatus>
 ```
 
-Request camera permission from the user.
+Request camera and/or microphone permissions from the user.
+
+By default, only camera permission is requested. To also request microphone
+permission (needed for video recording with audio), pass `{ permissions: ['camera', 'microphone'] }`.
+
+| Param         | Type                                                   | Description                                               |
+| ------------- | ------------------------------------------------------ | --------------------------------------------------------- |
+| **`options`** | <code>{ permissions?: CameraPermissionType[]; }</code> | - Optional object specifying which permissions to request |
 
 **Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
 
@@ -581,6 +731,25 @@ Configuration options for capturing photos and samples.
 | **`saveToFile`** | <code>boolean</code> | If true, saves to a temporary file and returns the web path instead of base64. The web path can be used to set the src attribute of an image for efficient loading and rendering. This reduces the data that needs to be transferred over the bridge, which can improve performance especially for high-resolution images. | <code>false</code> | 1.1.0 |
 
 
+#### VideoRecordingOptions
+
+Configuration options for video recording.
+
+| Prop               | Type                                                                    | Description                                                                          | Default                | Since |
+| ------------------ | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ---------------------- | ----- |
+| **`enableAudio`**  | <code>boolean</code>                                                    | Whether to record audio with the video. Requires microphone permission.              | <code>false</code>     | 2.2.0 |
+| **`videoQuality`** | <code><a href="#videorecordingquality">VideoRecordingQuality</a></code> | Video recording quality preset. Native platforms only (iOS/Android). Ignored on web. | <code>'highest'</code> | 2.2.0 |
+
+
+#### VideoRecordingResponse
+
+Response from stopping a video recording.
+
+| Prop          | Type                | Description                                                                                                                                       | Since |
+| ------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`webPath`** | <code>string</code> | Web-accessible path to the recorded video file. On web, this is a blob URL. On iOS/Android, this is a path accessible via Capacitor's filesystem. | 2.2.0 |
+
+
 #### GetAvailableDevicesResponse
 
 Response for getting available camera devices.
@@ -652,11 +821,12 @@ Response for getting the current torch mode.
 
 #### PermissionStatus
 
-Response for the camera permission status.
+Response for the camera and microphone permission status.
 
-| Prop         | Type                                                        | Description                        |
-| ------------ | ----------------------------------------------------------- | ---------------------------------- |
-| **`camera`** | <code><a href="#permissionstate">PermissionState</a></code> | The state of the camera permission |
+| Prop             | Type                                                        | Description                            |
+| ---------------- | ----------------------------------------------------------- | -------------------------------------- |
+| **`camera`**     | <code><a href="#permissionstate">PermissionState</a></code> | The state of the camera permission     |
+| **`microphone`** | <code><a href="#permissionstate">PermissionState</a></code> | The state of the microphone permission |
 
 
 #### PluginListenerHandle
@@ -729,6 +899,13 @@ depending on the `saveToFile` option in the <a href="#captureoptions">CaptureOpt
 <code>T['saveToFile'] extends true ? { /** The web path to the captured photo that can be used to set the src attribute of an image for efficient loading and rendering (when saveToFile is true) */ webPath: string; } : { /** The base64 encoded string of the captured photo (when saveToFile is false or undefined) */ photo: string; }</code>
 
 
+#### VideoRecordingQuality
+
+Video recording quality presets.
+
+<code>'lowest' | 'sd' | 'hd' | 'fhd' | 'uhd' | 'highest'</code>
+
+
 #### FlashMode
 
 Flash mode options for the camera.
@@ -743,4 +920,13 @@ Flash mode options for the camera.
 
 <code>'prompt' | 'prompt-with-rationale' | 'granted' | 'denied'</code>
 
+
+#### CameraPermissionType
+
+Permission types that can be requested.
+- 'camera': Camera access permission
+- 'microphone': Microphone access permission (needed for video recording with audio)
+
+<code>'camera' | 'microphone'</code>
+
 </docgen-api>

package/android/build.gradle

@@ -78,6 +78,7 @@ dependencies {
     implementation "androidx.camera:camera-lifecycle:${camerax_version}"
     implementation "androidx.camera:camera-view:${camerax_version}"
     implementation "androidx.camera:camera-mlkit-vision:${camerax_version}"
+    implementation "androidx.camera:camera-video:${camerax_version}"
 
     // ML Kit for barcode scanning
     implementation "com.google.mlkit:barcode-scanning:17.3.0"

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,3 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
 </manifest>

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,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
@@ -130,6 +157,15 @@ 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()
 
             previewView?.let { view ->
@@ -242,11 +278,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 +386,244 @@ 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
+            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)
+            // 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)
+                }
+
+                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) {
@@ -533,6 +811,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