@capgo/camera-preview 8.5.1 → 8.7.1

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)
@@ -1139,7 +1149,10 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                         recorderBuilder.setVideoCapabilitiesSource(Recorder.VIDEO_CAPABILITIES_SOURCE_CODEC_CAPABILITIES);
                     }
                     Recorder recorder = recorderBuilder.build();
-                    videoCapture = VideoCapture.withOutput(recorder);
+                    VideoCapture.Builder<Recorder> videoCaptureBuilder = new VideoCapture.Builder<>(recorder);
+                    videoCaptureBuilder = applyTargetFpsToVideoCaptureBuilder(videoCaptureBuilder);
+                    videoCaptureBuilder.setVideoStabilizationEnabled(isVideoStabilizationEnabledForSession());
+                    videoCapture = videoCaptureBuilder.build();
                 }
 
                 // Unbind any existing use cases and bind new ones
@@ -1287,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()) {
@@ -1324,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());
             }
         });
@@ -3355,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) {
@@ -3646,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);
@@ -3688,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);
@@ -3701,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();
@@ -4663,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) {
@@ -4785,6 +5008,15 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     private static final List<String> ALL_VIDEO_QUALITIES = Arrays.asList("low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3");
 
     private static final List<String> ALL_VIDEO_CODECS = Arrays.asList("avc1", "hvc1");
+    private static final List<String> ALL_VIDEO_STABILIZATION_MODES = Arrays.asList("off", "standard");
+    private static final List<String> IOS_ONLY_VIDEO_STABILIZATION_MODES = Arrays.asList(
+        "cinematic",
+        "cinematicExtended",
+        "previewOptimized",
+        "cinematicExtendedEnhanced",
+        "auto",
+        "lowLatency"
+    );
 
     public String getVideoQualitySetting() {
         if (sessionConfig == null) {
@@ -4864,4 +5096,86 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
         return false;
     }
+
+    public boolean isVideoStabilizationSupported() {
+        return isStandardVideoStabilizationSupported();
+    }
+
+    public List<String> getSupportedVideoStabilizationModes() {
+        List<String> modes = new ArrayList<>();
+        modes.add("off");
+        if (isStandardVideoStabilizationSupported()) {
+            modes.add("standard");
+        }
+        return modes;
+    }
+
+    public String getVideoStabilizationModeSetting() {
+        if (sessionConfig == null) {
+            return "off";
+        }
+        return sessionConfig.getVideoStabilizationMode();
+    }
+
+    public void setVideoStabilizationModeSetting(String mode) {
+        if (sessionConfig == null) {
+            throw new IllegalStateException("Camera session is not running");
+        }
+        if (currentRecording != null) {
+            throw new IllegalStateException("Cannot change video stabilization while recording is in progress");
+        }
+        String normalized = mode != null ? mode : "off";
+        if (IOS_ONLY_VIDEO_STABILIZATION_MODES.contains(normalized)) {
+            throw new IllegalArgumentException(
+                "Video stabilization mode '" + normalized + "' is only supported on iOS. Use 'off' or 'standard' on Android."
+            );
+        }
+        if (!ALL_VIDEO_STABILIZATION_MODES.contains(normalized)) {
+            throw new IllegalArgumentException("Unsupported video stabilization mode: " + mode);
+        }
+        if ("standard".equals(normalized) && !isStandardVideoStabilizationSupported()) {
+            throw new IllegalArgumentException("Video stabilization mode 'standard' is not supported on this device");
+        }
+        if (normalized.equals(sessionConfig.getVideoStabilizationMode())) {
+            return;
+        }
+        sessionConfig.setVideoStabilizationMode(normalized);
+        if (sessionConfig.isVideoModeEnabled() && isRunning) {
+            mainExecutor.execute(this::bindCameraUseCases);
+        }
+    }
+
+    private boolean isVideoStabilizationEnabledForSession() {
+        if (sessionConfig == null) {
+            return false;
+        }
+        return "standard".equalsIgnoreCase(sessionConfig.getVideoStabilizationMode());
+    }
+
+    private boolean isStandardVideoStabilizationSupported() {
+        if (camera == null) {
+            return false;
+        }
+        try {
+            String cameraId = Camera2CameraInfo.from(camera.getCameraInfo()).getCameraId();
+            CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+            if (cameraManager == null) {
+                return false;
+            }
+            int[] modes = cameraManager
+                .getCameraCharacteristics(cameraId)
+                .get(CameraCharacteristics.CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
+            if (modes == null) {
+                return false;
+            }
+            for (int availableMode : modes) {
+                if (availableMode == CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE_ON) {
+                    return true;
+                }
+            }
+        } catch (CameraAccessException e) {
+            Log.w(TAG, "Failed to read video stabilization modes", e);
+        }
+        return false;
+    }
 }

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

@@ -27,6 +27,7 @@ public class CameraSessionConfiguration {
     private boolean isCentered = false;
     private String videoQuality;
     private String videoCodec = "avc1";
+    private String videoStabilizationMode = "off";
     private boolean enablePhysicalDeviceSelection = false;
     private boolean barcodeScannerEnabled = false;
 
@@ -160,6 +161,14 @@ public class CameraSessionConfiguration {
         this.videoCodec = codec != null ? codec : "avc1";
     }
 
+    public String getVideoStabilizationMode() {
+        return videoStabilizationMode;
+    }
+
+    public void setVideoStabilizationMode(String mode) {
+        this.videoStabilizationMode = mode != null ? mode : "off";
+    }
+
     public boolean isPhysicalDeviceSelectionEnabled() {
         return enablePhysicalDeviceSelection;
     }