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

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
+    }
 }

package/dist/docs.json

@@ -147,6 +147,58 @@
         ],
         "slug": "capturesample"
       },
+      {
+        "name": "startRecording",
+        "signature": "(options?: VideoRecordingOptions | undefined) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Optional recording configuration",
+            "type": "VideoRecordingOptions | undefined"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - Optional recording configuration"
+          },
+          {
+            "name": "returns",
+            "text": "A promise that resolves when recording has started"
+          },
+          {
+            "name": "since",
+            "text": "2.2.0"
+          }
+        ],
+        "docs": "Start recording video from the current camera.\nCamera must be running. Throws if already recording.",
+        "complexTypes": [
+          "VideoRecordingOptions"
+        ],
+        "slug": "startrecording"
+      },
+      {
+        "name": "stopRecording",
+        "signature": "() => Promise<VideoRecordingResponse>",
+        "parameters": [],
+        "returns": "Promise<VideoRecordingResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "A promise that resolves with the recorded video file path"
+          },
+          {
+            "name": "since",
+            "text": "2.2.0"
+          }
+        ],
+        "docs": "Stop the current video recording and return the result.\nThrows if no recording is in progress.",
+        "complexTypes": [
+          "VideoRecordingResponse"
+        ],
+        "slug": "stoprecording"
+      },
       {
         "name": "flipCamera",
         "signature": "() => Promise<void>",
@@ -429,14 +481,14 @@
         "tags": [
           {
             "name": "returns",
-            "text": "A promise that resolves with an object containing the camera permission status"
+            "text": "A promise that resolves with an object containing the camera and microphone permission status"
           },
           {
             "name": "since",
             "text": "1.0.0"
           }
         ],
-        "docs": "Check camera permission status without requesting permissions.",
+        "docs": "Check camera and microphone permission status without requesting permissions.",
         "complexTypes": [
           "PermissionStatus"
         ],
@@ -444,22 +496,33 @@
       },
       {
         "name": "requestPermissions",
-        "signature": "() => Promise<PermissionStatus>",
-        "parameters": [],
+        "signature": "(options?: { permissions?: CameraPermissionType[] | undefined; } | undefined) => Promise<PermissionStatus>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Optional object specifying which permissions to request",
+            "type": "{ permissions?: CameraPermissionType[] | undefined; } | undefined"
+          }
+        ],
         "returns": "Promise<PermissionStatus>",
         "tags": [
+          {
+            "name": "param",
+            "text": "options - Optional object specifying which permissions to request"
+          },
           {
             "name": "returns",
-            "text": "A promise that resolves with an object containing the camera permission status"
+            "text": "A promise that resolves with an object containing the camera and microphone permission status"
           },
           {
             "name": "since",
             "text": "1.0.0"
           }
         ],
-        "docs": "Request camera permission from the user.",
+        "docs": "Request camera and/or microphone permissions from the user.\n\nBy default, only camera permission is requested. To also request microphone\npermission (needed for video recording with audio), pass `{ permissions: ['camera', 'microphone'] }`.",
         "complexTypes": [
-          "PermissionStatus"
+          "PermissionStatus",
+          "CameraPermissionType"
         ],
         "slug": "requestpermissions"
       },
@@ -723,6 +786,80 @@
         }
       ]
     },
+    {
+      "name": "VideoRecordingOptions",
+      "slug": "videorecordingoptions",
+      "docs": "Configuration options for video recording.",
+      "tags": [
+        {
+          "text": "2.2.0",
+          "name": "since"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "enableAudio",
+          "tags": [
+            {
+              "text": "false",
+              "name": "default"
+            },
+            {
+              "text": "2.2.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Whether to record audio with the video.\nRequires microphone permission.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "videoQuality",
+          "tags": [
+            {
+              "text": "'highest'",
+              "name": "default"
+            },
+            {
+              "text": "2.2.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Video recording quality preset.\nNative platforms only (iOS/Android). Ignored on web.",
+          "complexTypes": [
+            "VideoRecordingQuality"
+          ],
+          "type": "VideoRecordingQuality"
+        }
+      ]
+    },
+    {
+      "name": "VideoRecordingResponse",
+      "slug": "videorecordingresponse",
+      "docs": "Response from stopping a video recording.",
+      "tags": [
+        {
+          "text": "2.2.0",
+          "name": "since"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "webPath",
+          "tags": [
+            {
+              "text": "2.2.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Web-accessible path to the recorded video file.\nOn web, this is a blob URL.\nOn iOS/Android, this is a path accessible via Capacitor's filesystem.",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    },
     {
       "name": "GetAvailableDevicesResponse",
       "slug": "getavailabledevicesresponse",
@@ -925,7 +1062,7 @@
     {
       "name": "PermissionStatus",
       "slug": "permissionstatus",
-      "docs": "Response for the camera permission status.",
+      "docs": "Response for the camera and microphone permission status.",
       "tags": [
         {
           "text": "1.0.0",
@@ -942,6 +1079,15 @@
             "PermissionState"
           ],
           "type": "PermissionState"
+        },
+        {
+          "name": "microphone",
+          "tags": [],
+          "docs": "The state of the microphone permission",
+          "complexTypes": [
+            "PermissionState"
+          ],
+          "type": "PermissionState"
         }
       ]
     },
@@ -1172,6 +1318,37 @@
         }
       ]
     },
+    {
+      "name": "VideoRecordingQuality",
+      "slug": "videorecordingquality",
+      "docs": "Video recording quality presets.",
+      "types": [
+        {
+          "text": "'lowest'",
+          "complexTypes": []
+        },
+        {
+          "text": "'sd'",
+          "complexTypes": []
+        },
+        {
+          "text": "'hd'",
+          "complexTypes": []
+        },
+        {
+          "text": "'fhd'",
+          "complexTypes": []
+        },
+        {
+          "text": "'uhd'",
+          "complexTypes": []
+        },
+        {
+          "text": "'highest'",
+          "complexTypes": []
+        }
+      ]
+    },
     {
       "name": "FlashMode",
       "slug": "flashmode",
@@ -1213,6 +1390,21 @@
           "complexTypes": []
         }
       ]
+    },
+    {
+      "name": "CameraPermissionType",
+      "slug": "camerapermissiontype",
+      "docs": "Permission types that can be requested.\n- 'camera': Camera access permission\n- 'microphone': Microphone access permission (needed for video recording with audio)",
+      "types": [
+        {
+          "text": "'camera'",
+          "complexTypes": []
+        },
+        {
+          "text": "'microphone'",
+          "complexTypes": []
+        }
+      ]
     }
   ],
   "pluginConfigs": []

package/dist/esm/definitions.d.ts

@@ -56,6 +56,25 @@ export interface CameraViewPlugin {
      * @since 1.0.0
      */
     captureSample<T extends CaptureOptions>(options: T): Promise<CaptureResponse<T>>;
+    /**
+     * Start recording video from the current camera.
+     * Camera must be running. Throws if already recording.
+     *
+     * @param options - Optional recording configuration
+     * @returns A promise that resolves when recording has started
+     *
+     * @since 2.2.0
+     */
+    startRecording(options?: VideoRecordingOptions): Promise<void>;
+    /**
+     * Stop the current video recording and return the result.
+     * Throws if no recording is in progress.
+     *
+     * @returns A promise that resolves with the recorded video file path
+     *
+     * @since 2.2.0
+     */
+    stopRecording(): Promise<VideoRecordingResponse>;
     /**
      * Switch between front and back camera.
      *
@@ -177,21 +196,27 @@ export interface CameraViewPlugin {
         level?: number;
     }): Promise<void>;
     /**
-     * Check camera permission status without requesting permissions.
+     * Check camera and microphone permission status without requesting permissions.
      *
-     * @returns A promise that resolves with an object containing the camera permission status
+     * @returns A promise that resolves with an object containing the camera and microphone permission status
      *
      * @since 1.0.0
      */
     checkPermissions(): Promise<PermissionStatus>;
     /**
-     * Request camera permission from the user.
+     * Request camera and/or microphone permissions from the user.
      *
-     * @returns A promise that resolves with an object containing the camera permission status
+     * By default, only camera permission is requested. To also request microphone
+     * permission (needed for video recording with audio), pass `{ permissions: ['camera', 'microphone'] }`.
+     *
+     * @param options - Optional object specifying which permissions to request
+     * @returns A promise that resolves with an object containing the camera and microphone permission status
      *
      * @since 1.0.0
      */
-    requestPermissions(): Promise<PermissionStatus>;
+    requestPermissions(options?: {
+        permissions?: CameraPermissionType[];
+    }): Promise<PermissionStatus>;
     /**
      * Listen for barcode detection events.
      * This event is emitted when a barcode is detected in the camera preview.
@@ -230,6 +255,16 @@ export type CameraPosition = 'front' | 'back';
  * @since 1.0.0
  */
 export type FlashMode = 'off' | 'on' | 'auto';
+/**
+ * Video recording quality presets.
+ *
+ * @remarks
+ * On iOS this maps to `AVCaptureSession.Preset` values.
+ * On Android this maps to CameraX `QualitySelector` values.
+ *
+ * @since 2.2.0
+ */
+export type VideoRecordingQuality = 'lowest' | 'sd' | 'hd' | 'fhd' | 'uhd' | 'highest';
 /**
  * Represents a physical camera device on the device.
  *
@@ -383,6 +418,39 @@ export interface CaptureOptions {
      */
     saveToFile?: boolean;
 }
+/**
+ * Configuration options for video recording.
+ * @since 2.2.0
+ */
+export interface VideoRecordingOptions {
+    /**
+     * Whether to record audio with the video.
+     * Requires microphone permission.
+     * @default false
+     * @since 2.2.0
+     */
+    enableAudio?: boolean;
+    /**
+     * Video recording quality preset.
+     * Native platforms only (iOS/Android). Ignored on web.
+     * @default 'highest'
+     * @since 2.2.0
+     */
+    videoQuality?: VideoRecordingQuality;
+}
+/**
+ * Response from stopping a video recording.
+ * @since 2.2.0
+ */
+export interface VideoRecordingResponse {
+    /**
+     * 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.
+     * @since 2.2.0
+     */
+    webPath: string;
+}
 /**
  * Response for checking if the camera view is running.
  *
@@ -497,11 +565,21 @@ export interface BoundingRect {
     height: number;
 }
 /**
- * Response for the camera permission status.
+ * Permission types that can be requested.
+ * - 'camera': Camera access permission
+ * - 'microphone': Microphone access permission (needed for video recording with audio)
+ *
+ * @since 2.2.0
+ */
+export type CameraPermissionType = 'camera' | 'microphone';
+/**
+ * Response for the camera and microphone permission status.
  *
  * @since 1.0.0
  */
 export interface PermissionStatus {
     /** The state of the camera permission */
     camera: PermissionState;
+    /** The state of the microphone permission */
+    microphone: PermissionState;
 }