@capgo/camera-preview 8.6.0 → 8.7.1

package/README.md

@@ -412,6 +412,9 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`getExposureCompensationRange()`](#getexposurecompensationrange)
 * [`getExposureCompensation()`](#getexposurecompensation)
 * [`setExposureCompensation(...)`](#setexposurecompensation)
+* [`getSupportedVideoFrameRates()`](#getsupportedvideoframerates)
+* [`getVideoFrameRate()`](#getvideoframerate)
+* [`setVideoFrameRate(...)`](#setvideoframerate)
 * [`getPluginVersion()`](#getpluginversion)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
@@ -759,9 +762,11 @@ startRecordVideo(options: CameraPreviewOptions) => Promise<void>
 
 Starts recording a video.
 
-| Param         | Type                                                                  | Description                                                                                                                           |
-| ------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
-| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`. |
+Supports `frameRate`, `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio` on each call.
+
+| Param         | Type                                                                  | Description                        |
+| ------------- | --------------------------------------------------------------------- | ---------------------------------- |
+| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. |
 
 **Since:** 0.0.1
 
@@ -1359,6 +1364,57 @@ Sets the exposure compensation (EV bias). Value will be clamped to range.
 --------------------
 
 
+### getSupportedVideoFrameRates()
+
+```typescript
+getSupportedVideoFrameRates() => Promise<{ frameRates: number[]; }>
+```
+
+Lists the video frame rates supported by the active camera for the current format.
+Supported values depend on the selected camera, lens, and video quality.
+
+**Returns:** <code>Promise&lt;{ frameRates: number[]; }&gt;</code>
+
+**Since:** 8.6.0
+
+--------------------
+
+
+### getVideoFrameRate()
+
+```typescript
+getVideoFrameRate() => Promise<{ frameRate: number; }>
+```
+
+Returns the configured video frame rate for the active camera.
+On Android the actual recording frame rate can still vary in low light or under thermal pressure.
+
+**Returns:** <code>Promise&lt;{ frameRate: number; }&gt;</code>
+
+**Since:** 8.6.0
+
+--------------------
+
+
+### setVideoFrameRate(...)
+
+```typescript
+setVideoFrameRate(options: { frameRate: number; }) => Promise<void>
+```
+
+Sets the target video frame rate for the active camera session.
+Prefer passing `frameRate` to `startRecordVideo()` when starting a recording.
+Rejects unsupported values with a clear error.
+
+| Param         | Type                                |
+| ------------- | ----------------------------------- |
+| **`options`** | <code>{ frameRate: number; }</code> |
+
+**Since:** 8.6.0
+
+--------------------
+
+
 ### getPluginVersion()
 
 ```typescript
@@ -1411,6 +1467,7 @@ Defines the configuration options for starting the camera preview.
 | **`maxDuration`**                   | <code>number</code>                                                                | Maximum recording duration in seconds. Recording stops automatically when reached.                                                                                                                                                  |                        |        |
 | **`maxFileSize`**                   | <code>number</code>                                                                | Maximum recording file size in bytes. Recording stops automatically when reached.                                                                                                                                                   |                        |        |
 | **`videoCodec`**                    | <code><a href="#videocodec">VideoCodec</a></code>                                  | Preferred video codec for recording.                                                                                                                                                                                                | <code>"avc1"</code>    |        |
+| **`frameRate`**                     | <code>number</code>                                                                | Target video frame rate in frames per second. Applied when recording starts. Use `getSupportedVideoFrameRates()` to list supported values.                                                                                          |                        | 8.6.0  |
 | **`videoStabilizationMode`**        | <code><a href="#videostabilizationmode">VideoStabilizationMode</a></code>          | Preferred video stabilization mode for recording.                                                                                                                                                                                   | <code>"off"</code>     |        |
 | **`barcodeScanner`**                | <code>boolean \| <a href="#barcodescanneroptions">BarcodeScannerOptions</a></code> | Starts barcode scanning together with the camera preview. Set to `true` or pass options to scan all supported formats. Omit this option to keep barcode scanning disabled at startup.                                               |                        | 8.8.0  |
 

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java

@@ -291,6 +291,56 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         }
     }
 
+    @PluginMethod
+    public void getSupportedVideoFrameRates(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        try {
+            List<Integer> frameRates = cameraXView.getSupportedVideoFrameRates();
+            JSObject ret = new JSObject();
+            JSONArray frameRatesArray = new JSONArray();
+            for (Integer frameRate : frameRates) {
+                frameRatesArray.put(frameRate);
+            }
+            ret.put("frameRates", frameRatesArray);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("Failed to get supported video frame rates: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getVideoFrameRate(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        try {
+            int frameRate = cameraXView.getVideoFrameRate();
+            JSObject ret = new JSObject();
+            ret.put("frameRate", frameRate);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("Failed to get video frame rate: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void setVideoFrameRate(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        Integer frameRate = call.getInt("frameRate");
+        if (frameRate == null) {
+            call.reject("frameRate parameter is required");
+            return;
+        }
+        cameraXView.setVideoFrameRate(frameRate, call::resolve, call::reject);
+    }
+
     @PluginMethod
     public void getOrientation(PluginCall call) {
         String o = getDeviceOrientationString();
@@ -2773,14 +2823,7 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         String permissionAlias = disableAudio ? CAMERA_ONLY_PERMISSION_ALIAS : CAMERA_WITH_AUDIO_PERMISSION_ALIAS;
 
         if (PermissionState.GRANTED.equals(getPermissionState(permissionAlias))) {
-            try {
-                applyVideoCodecFromCall(call);
-                applyVideoStabilizationFromCall(call);
-                cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
-                call.resolve();
-            } catch (Exception e) {
-                call.reject("Failed to start video recording: " + e.getMessage());
-            }
+            beginVideoRecording(call);
         } else {
             requestPermissionForAlias(permissionAlias, call, "handleVideoRecordingPermissionResult");
         }
@@ -2858,6 +2901,23 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         return bytes > 0L ? bytes : null;
     }
 
+    private void beginVideoRecording(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        try {
+            applyVideoCodecFromCall(call);
+            applyVideoStabilizationFromCall(call);
+            Integer frameRate = call.getInt("frameRate");
+            cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call), frameRate, call::resolve, (message) ->
+                call.reject("Failed to start video recording: " + message)
+            );
+        } catch (Exception e) {
+            call.reject("Failed to start video recording: " + e.getMessage());
+        }
+    }
+
     @PermissionCallback
     private void handleVideoRecordingPermissionResult(PluginCall call) {
         // Use the persisted session value to determine which permission we requested
@@ -2868,14 +2928,7 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
             PermissionState.GRANTED.equals(getPermissionState(CAMERA_ONLY_PERMISSION_ALIAS)) ||
             PermissionState.GRANTED.equals(getPermissionState(CAMERA_WITH_AUDIO_PERMISSION_ALIAS))
         ) {
-            try {
-                applyVideoCodecFromCall(call);
-                applyVideoStabilizationFromCall(call);
-                cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
-                call.resolve();
-            } catch (Exception e) {
-                call.reject("Failed to start video recording: " + e.getMessage());
-            }
+            beginVideoRecording(call);
         } else {
             call.reject("camera permission denied. enable camera access in Settings.", "cameraPermissionDenied");
         }

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java

@@ -45,6 +45,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.OptIn;
 import androidx.camera.camera2.interop.Camera2CameraControl;
 import androidx.camera.camera2.interop.Camera2CameraInfo;
+import androidx.camera.camera2.interop.Camera2Interop;
 import androidx.camera.camera2.interop.CaptureRequestOptions;
 import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
 import androidx.camera.core.AspectRatio;
@@ -110,6 +111,7 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
@@ -184,6 +186,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private boolean isRunning = false;
     private Size currentPreviewResolution = null;
     private ListenableFuture<FocusMeteringResult> currentFocusFuture = null; // Track current focus operation
+    private Integer configuredVideoFrameRate = null;
+    private Range<Integer> configuredVideoFrameRateRange = null;
+    private Runnable pendingFrameRateBindSuccess;
+    private java.util.function.Consumer<String> pendingFrameRateBindError;
     private String currentExposureMode = "CONTINUOUS"; // Default behavior
     // Capture/stop coordination
     private final Object captureLock = new Object();
@@ -1071,7 +1077,11 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     ? previewView.getDisplay().getRotation()
                     : android.view.Surface.ROTATION_0;
 
-                Preview preview = new Preview.Builder().setResolutionSelector(resolutionSelector).setTargetRotation(rotation).build();
+                Preview.Builder previewBuilder = new Preview.Builder()
+                    .setResolutionSelector(resolutionSelector)
+                    .setTargetRotation(rotation);
+                previewBuilder = applyTargetFpsToPreviewBuilder(previewBuilder);
+                Preview preview = previewBuilder.build();
                 // Keep reference to preview use case for later re-binding (e.g., when enabling video)
                 imageCapture = new ImageCapture.Builder()
                     .setResolutionSelector(resolutionSelector)
@@ -1140,6 +1150,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     }
                     Recorder recorder = recorderBuilder.build();
                     VideoCapture.Builder<Recorder> videoCaptureBuilder = new VideoCapture.Builder<>(recorder);
+                    videoCaptureBuilder = applyTargetFpsToVideoCaptureBuilder(videoCaptureBuilder);
                     videoCaptureBuilder.setVideoStabilizationEnabled(isVideoStabilizationEnabledForSession());
                     videoCapture = videoCaptureBuilder.build();
                 }
@@ -1289,6 +1300,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 }
 
                 isRunning = true;
+                completePendingFrameRateBindSuccess();
                 Log.d(TAG, "bindCameraUseCases: Camera bound successfully");
                 if (listener != null) {
                     if (sessionConfig != null && sessionConfig.isToBack()) {
@@ -1326,6 +1338,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
             } catch (Exception e) {
                 // Restore webView background on error
                 restoreWebViewBackground();
+                completePendingFrameRateBindError("Error binding camera: " + e.getMessage());
                 if (listener != null) listener.onCameraStartError(this, "Error binding camera: " + e.getMessage());
             }
         });
@@ -3357,6 +3370,185 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
     }
 
+    private void clearConfiguredVideoFrameRate() {
+        configuredVideoFrameRate = null;
+        configuredVideoFrameRateRange = null;
+    }
+
+    private Range<Integer>[] getAdvertisedFpsRanges() throws Exception {
+        CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+        String cameraId = resolveActiveCameraIdForCharacteristics();
+        CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
+        return characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+    }
+
+    private Range<Integer> findAdvertisedFpsRangeForRate(int frameRate, Range<Integer>[] ranges) {
+        if (ranges == null) {
+            return null;
+        }
+
+        Range<Integer> containingRange = null;
+        for (Range<Integer> range : ranges) {
+            if (range.getLower() > frameRate || range.getUpper() < frameRate) {
+                continue;
+            }
+            if (range.getLower().equals(range.getUpper()) && range.getLower() == frameRate) {
+                return range;
+            }
+            containingRange = range;
+        }
+        return containingRange;
+    }
+
+    private Range<Integer> resolveConfiguredVideoFrameRateRange() {
+        if (configuredVideoFrameRate == null) {
+            return null;
+        }
+        try {
+            Range<Integer>[] ranges = getAdvertisedFpsRanges();
+            return findAdvertisedFpsRangeForRate(configuredVideoFrameRate, ranges);
+        } catch (Exception e) {
+            Log.w(TAG, "resolveConfiguredVideoFrameRateRange: Failed to resolve FPS range", e);
+            return null;
+        }
+    }
+
+    private void completePendingFrameRateBindSuccess() {
+        if (pendingFrameRateBindSuccess == null) {
+            return;
+        }
+        Runnable callback = pendingFrameRateBindSuccess;
+        pendingFrameRateBindSuccess = null;
+        pendingFrameRateBindError = null;
+        callback.run();
+    }
+
+    private void completePendingFrameRateBindError(String message) {
+        if (pendingFrameRateBindError == null) {
+            return;
+        }
+        java.util.function.Consumer<String> callback = pendingFrameRateBindError;
+        pendingFrameRateBindSuccess = null;
+        pendingFrameRateBindError = null;
+        callback.accept(message);
+    }
+
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
+    private Preview.Builder applyTargetFpsToPreviewBuilder(Preview.Builder builder) {
+        Range<Integer> fpsRange = resolveConfiguredVideoFrameRateRange();
+        if (fpsRange == null) {
+            return builder;
+        }
+
+        Camera2Interop.Extender<Preview> extender = new Camera2Interop.Extender<>(builder);
+        extender.setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
+        return builder;
+    }
+
+    @OptIn(markerClass = ExperimentalCamera2Interop.class)
+    private VideoCapture.Builder<Recorder> applyTargetFpsToVideoCaptureBuilder(VideoCapture.Builder<Recorder> builder) {
+        Range<Integer> fpsRange = resolveConfiguredVideoFrameRateRange();
+        if (fpsRange == null) {
+            return builder;
+        }
+
+        Camera2Interop.Extender<VideoCapture<Recorder>> extender = new Camera2Interop.Extender<>(builder);
+        extender.setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
+        return builder;
+    }
+
+    private String resolveActiveCameraIdForCharacteristics() throws Exception {
+        if (currentLogicalDeviceId != null) {
+            return currentLogicalDeviceId;
+        }
+        if (camera != null) {
+            return Camera2CameraInfo.from(camera.getCameraInfo()).getCameraId();
+        }
+        throw new Exception("Camera not initialized");
+    }
+
+    private List<Integer> frameRatesFromFpsRanges(Range<Integer>[] ranges) {
+        TreeSet<Integer> rates = new TreeSet<>();
+        int[] standardRates = new int[] { 24, 25, 30, 50, 60, 120 };
+
+        if (ranges == null) {
+            return new ArrayList<>();
+        }
+
+        for (Range<Integer> range : ranges) {
+            int min = range.getLower();
+            int max = range.getUpper();
+            if (min == max) {
+                rates.add(min);
+                continue;
+            }
+
+            rates.add(min);
+            rates.add(max);
+            for (int standardRate : standardRates) {
+                if (standardRate >= min && standardRate <= max) {
+                    rates.add(standardRate);
+                }
+            }
+        }
+
+        return new ArrayList<>(rates);
+    }
+
+    public List<Integer> getSupportedVideoFrameRates() throws Exception {
+        return frameRatesFromFpsRanges(getAdvertisedFpsRanges());
+    }
+
+    public int getVideoFrameRate() throws Exception {
+        if (configuredVideoFrameRate != null) {
+            return configuredVideoFrameRate;
+        }
+        return 30;
+    }
+
+    public void setVideoFrameRate(int frameRate, Runnable onSuccess, java.util.function.Consumer<String> onError) {
+        mainExecutor.execute(() -> {
+            Integer previousFrameRate = configuredVideoFrameRate;
+            Range<Integer> previousRange = configuredVideoFrameRateRange;
+            try {
+                if (currentRecording != null) {
+                    throw new Exception("Cannot change video frame rate while recording");
+                }
+                if (frameRate <= 0) {
+                    throw new Exception("frameRate must be greater than 0");
+                }
+
+                List<Integer> supportedRates = getSupportedVideoFrameRates();
+                if (!supportedRates.contains(frameRate)) {
+                    throw new Exception("Unsupported frame rate " + frameRate + ". Supported values: " + supportedRates);
+                }
+
+                Range<Integer> advertisedRange = findAdvertisedFpsRangeForRate(frameRate, getAdvertisedFpsRanges());
+                if (advertisedRange == null) {
+                    throw new Exception("Unsupported frame rate " + frameRate + " for the active camera");
+                }
+
+                configuredVideoFrameRate = frameRate;
+                configuredVideoFrameRateRange = advertisedRange;
+                if (isRunning && cameraProvider != null) {
+                    pendingFrameRateBindSuccess = onSuccess;
+                    pendingFrameRateBindError = (message) -> {
+                        configuredVideoFrameRate = previousFrameRate;
+                        configuredVideoFrameRateRange = previousRange;
+                        onError.accept(message);
+                    };
+                    bindCameraUseCases();
+                    return;
+                }
+                onSuccess.run();
+            } catch (Exception e) {
+                configuredVideoFrameRate = previousFrameRate;
+                configuredVideoFrameRateRange = previousRange;
+                onError.accept(e.getMessage());
+            }
+        });
+    }
+
     private long showFocusIndicator(float x, float y) {
         // If preview is gone (e.g., stopping/closing), bail out safely
         if (previewContainer == null) {
@@ -3648,6 +3840,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
         mainExecutor.execute(() -> {
             try {
+                String previousDeviceId = currentDeviceId;
                 CameraSessionConfiguration previousConfig = sessionConfig;
                 CameraInfo targetCameraInfo = findAvailableCameraInfoById(deviceId);
                 String fallbackPosition = resolveFallbackPositionForDeviceId(deviceId);
@@ -3690,6 +3883,9 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                 );
                 copyMutableSessionConfigState(previousConfig, updatedConfig);
                 updatedConfig.setTargetZoom(1.0f);
+                if (!Objects.equals(deviceId, previousDeviceId)) {
+                    clearConfiguredVideoFrameRate();
+                }
                 sessionConfig = updatedConfig;
 
                 Log.d(TAG, "switchToDevice: Updated sessionConfig with deviceId: " + deviceId);
@@ -3703,6 +3899,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
 
     public void flipCamera() {
         Log.d(TAG, "flipCamera: Flipping camera");
+        clearConfiguredVideoFrameRate();
 
         // Determine current position based on session config and flip it
         String currentPosition = sessionConfig.getPosition();
@@ -4665,6 +4862,30 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
     }
 
+    public void startRecordVideo(
+        Long maxDurationMillis,
+        Long maxFileSize,
+        Integer frameRate,
+        Runnable onSuccess,
+        java.util.function.Consumer<String> onError
+    ) {
+        Runnable startRecording = () -> {
+            try {
+                startRecordVideo(maxDurationMillis, maxFileSize);
+                onSuccess.run();
+            } catch (Exception e) {
+                onError.accept(e.getMessage());
+            }
+        };
+
+        if (frameRate == null) {
+            mainExecutor.execute(startRecording);
+            return;
+        }
+
+        setVideoFrameRate(frameRate, startRecording, onError);
+    }
+
     /** @noinspection ResultOfMethodCallIgnored*/
     public void startRecordVideo(Long maxDurationMillis, Long maxFileSize) throws Exception {
         if (videoCapture == null) {

package/dist/docs.json

@@ -520,7 +520,7 @@
         "parameters": [
           {
             "name": "options",
-            "docs": "- The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`.",
+            "docs": "- The options for video recording.",
             "type": "CameraPreviewOptions"
           }
         ],
@@ -528,7 +528,7 @@
         "tags": [
           {
             "name": "param",
-            "text": "options - The options for video recording. Supports `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio`."
+            "text": "options - The options for video recording."
           },
           {
             "name": "returns",
@@ -539,7 +539,7 @@
             "text": "0.0.1"
           }
         ],
-        "docs": "Starts recording a video.",
+        "docs": "Starts recording a video.\n\nSupports `frameRate`, `videoCodec`, `videoStabilizationMode`, `maxDuration`, `maxFileSize`, and `disableAudio` on each call.",
         "complexTypes": [
           "CameraPreviewOptions"
         ],
@@ -1495,6 +1495,69 @@
         "complexTypes": [],
         "slug": "setexposurecompensation"
       },
+      {
+        "name": "getSupportedVideoFrameRates",
+        "signature": "() => Promise<{ frameRates: number[]; }>",
+        "parameters": [],
+        "returns": "Promise<{ frameRates: number[]; }>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          },
+          {
+            "name": "since",
+            "text": "8.6.0"
+          }
+        ],
+        "docs": "Lists the video frame rates supported by the active camera for the current format.\nSupported values depend on the selected camera, lens, and video quality.",
+        "complexTypes": [],
+        "slug": "getsupportedvideoframerates"
+      },
+      {
+        "name": "getVideoFrameRate",
+        "signature": "() => Promise<{ frameRate: number; }>",
+        "parameters": [],
+        "returns": "Promise<{ frameRate: number; }>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          },
+          {
+            "name": "since",
+            "text": "8.6.0"
+          }
+        ],
+        "docs": "Returns the configured video frame rate for the active camera.\nOn Android the actual recording frame rate can still vary in low light or under thermal pressure.",
+        "complexTypes": [],
+        "slug": "getvideoframerate"
+      },
+      {
+        "name": "setVideoFrameRate",
+        "signature": "(options: { frameRate: number; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ frameRate: number; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "platform",
+            "text": "android, ios"
+          },
+          {
+            "name": "since",
+            "text": "8.6.0"
+          }
+        ],
+        "docs": "Sets the target video frame rate for the active camera session.\nPrefer passing `frameRate` to `startRecordVideo()` when starting a recording.\nRejects unsupported values with a clear error.",
+        "complexTypes": [],
+        "slug": "setvideoframerate"
+      },
       {
         "name": "getPluginVersion",
         "signature": "() => Promise<{ version: string; }>",
@@ -1981,6 +2044,22 @@
           ],
           "type": "VideoCodec"
         },
+        {
+          "name": "frameRate",
+          "tags": [
+            {
+              "text": "ios, android",
+              "name": "platform"
+            },
+            {
+              "text": "8.6.0",
+              "name": "since"
+            }
+          ],
+          "docs": "Target video frame rate in frames per second.\nApplied when recording starts. Use `getSupportedVideoFrameRates()` to list supported values.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
         {
           "name": "videoStabilizationMode",
           "tags": [