@capgo/camera-preview 8.6.0 → 8.8.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -1,4 +1,4 @@
-// swiftlint:disable file_length cyclomatic_complexity identifier_name
+// swiftlint:disable file_length type_body_length cyclomatic_complexity identifier_name function_body_length
 import AVFoundation
 import UIKit
 import CoreLocation
@@ -150,11 +150,15 @@ class CameraController: NSObject {
 
     var videoFileURL: URL?
     var recordingFinishedCallback: ((URL, String) -> Void)?
+    private var stopRecordingCompletion: ((URL?, String?, Error?) -> Void)?
     private let saneMaxZoomFactor: CGFloat = 25.5
 
     var videoQuality: String = "high"
+    private var configuredVideoFrameRate: Int?
     var videoCodec: String = "avc1"
     var videoStabilizationMode: String = "off"
+    private var cachedSupportedVideoStabilizationModes: [String] = []
+    private var isSupportedVideoStabilizationModesCacheValid = false
 
     private static let allVideoQualities = ["low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3"]
 
@@ -221,23 +225,10 @@ class CameraController: NSObject {
     }
 
     func getSupportedVideoStabilizationModes() -> [String] {
-        guard let connection = self.fileVideoOutput?.connection(with: .video),
-              connection.isVideoStabilizationSupported else {
-            return ["off"]
-        }
-
-        let savedPreferred = connection.preferredVideoStabilizationMode
-        var supported: [String] = []
-
-        for candidate in Self.allVideoStabilizationModeCandidates() {
-            connection.preferredVideoStabilizationMode = candidate.mode
-            if connection.preferredVideoStabilizationMode == candidate.mode {
-                supported.append(candidate.name)
-            }
+        if self.isSupportedVideoStabilizationModesCacheValid {
+            return self.cachedSupportedVideoStabilizationModes
         }
-
-        connection.preferredVideoStabilizationMode = savedPreferred
-        return supported.isEmpty ? ["off"] : supported
+        return self.refreshSupportedVideoStabilizationModesCache()
     }
 
     func getVideoStabilizationMode() -> String {
@@ -255,12 +246,96 @@ class CameraController: NSObject {
         guard let avMode = self.avVideoStabilizationMode(from: mode) else {
             throw CameraControllerError.invalidOperation
         }
+
+        if self.isVideoStabilizationOutputAttached() {
+            try self.validateVideoStabilizationMode(mode)
+        }
+
+        self.videoStabilizationMode = mode
+
+        guard self.isVideoStabilizationOutputAttached() else {
+            return
+        }
+
+        self.configureCaptureSession {
+            self.applyVideoStabilizationMode(avMode)
+        }
+    }
+
+    @discardableResult
+    private func refreshSupportedVideoStabilizationModesCache() -> [String] {
+        let modes = self.probeSupportedVideoStabilizationModes()
+        self.cachedSupportedVideoStabilizationModes = modes
+        self.isSupportedVideoStabilizationModesCacheValid = true
+        return modes
+    }
+
+    private func invalidateSupportedVideoStabilizationModesCache() {
+        self.isSupportedVideoStabilizationModesCacheValid = false
+        self.cachedSupportedVideoStabilizationModes = []
+    }
+
+    private func validateVideoStabilizationMode(_ mode: String) throws {
         let supportedModes = self.getSupportedVideoStabilizationModes()
         guard supportedModes.contains(mode) else {
             throw CameraControllerError.invalidOperation
         }
-        self.videoStabilizationMode = mode
-        self.applyVideoStabilizationMode(avMode)
+    }
+
+    private func isVideoStabilizationOutputAttached() -> Bool {
+        guard let captureSession = self.captureSession,
+              let fileVideoOutput = self.fileVideoOutput else {
+            return false
+        }
+        return captureSession.outputs.contains(where: { $0 === fileVideoOutput })
+    }
+
+    private func configureCaptureSession(_ block: () -> Void) {
+        guard let captureSession = self.captureSession else {
+            block()
+            return
+        }
+
+        captureSession.beginConfiguration()
+        defer { captureSession.commitConfiguration() }
+        block()
+    }
+
+    private func activeVideoCaptureDevice() -> AVCaptureDevice? {
+        switch self.currentCameraPosition {
+        case .front:
+            return self.frontCamera
+        case .rear:
+            return self.rearCamera
+        default:
+            return nil
+        }
+    }
+
+    private func probeSupportedVideoStabilizationModes() -> [String] {
+        guard let connection = self.fileVideoOutput?.connection(with: .video),
+              connection.isVideoStabilizationSupported,
+              let device = self.activeVideoCaptureDevice() else {
+            return ["off"]
+        }
+
+        let format = device.activeFormat
+        var supported: [String] = ["off"]
+
+        for candidate in Self.allVideoStabilizationModeCandidates() where candidate.mode != .off {
+            if format.isVideoStabilizationModeSupported(candidate.mode) {
+                supported.append(candidate.name)
+            }
+        }
+
+        return supported
+    }
+
+    private func refreshVideoStabilizationAfterMovieOutputAttached() throws {
+        self.invalidateSupportedVideoStabilizationModesCache()
+        _ = self.refreshSupportedVideoStabilizationModesCache()
+        try self.validateVideoStabilizationMode(self.videoStabilizationMode)
+        self.applyVideoStabilizationMode()
     }
 
     private static func allVideoStabilizationModeCandidates() -> [(name: String, mode: AVCaptureVideoStabilizationMode)] {
@@ -269,7 +344,7 @@ class CameraController: NSObject {
             ("standard", .standard),
             ("cinematic", .cinematic),
             ("cinematicExtended", .cinematicExtended),
-            ("auto", .auto),
+            ("auto", .auto)
         ]
         if #available(iOS 17.0, *) {
             candidates.append(("previewOptimized", .previewOptimized))
@@ -647,7 +722,7 @@ extension CameraController {
                     captureSession.addOutput(fileVideoOutput)
                     // Set orientation immediately
                     self.setVideoOrientation(videoOrientation, on: fileVideoOutput.connections)
-                    self.applyVideoStabilizationMode()
+                    try self.refreshVideoStabilizationAfterMovieOutputAttached()
                 }
 
                 // Set up preview layer session in the same configuration block
@@ -1120,6 +1195,7 @@ extension CameraController {
     }
 
     func switchCameras() throws {
+        configuredVideoFrameRate = nil
         guard let currentCameraPosition = currentCameraPosition,
               let captureSession = self.captureSession else {
             throw CameraControllerError.captureSessionIsMissing
@@ -1227,7 +1303,7 @@ extension CameraController {
             captureSession.removeOutput(fileVideoOutput)
             if captureSession.canAddOutput(fileVideoOutput) {
                 captureSession.addOutput(fileVideoOutput)
-                self.applyVideoStabilizationMode()
+                try self.refreshVideoStabilizationAfterMovieOutputAttached()
             }
         }
 
@@ -2369,11 +2445,22 @@ extension CameraController {
             captureSession.addInput(audioInput)
         }
 
+        // Re-attach movie file output so its connection is bound to the new input.
+        if let fileVideoOutput = self.fileVideoOutput,
+           captureSession.outputs.contains(where: { $0 === fileVideoOutput }) {
+            captureSession.removeOutput(fileVideoOutput)
+            if captureSession.canAddOutput(fileVideoOutput) {
+                captureSession.addOutput(fileVideoOutput)
+                try self.refreshVideoStabilizationAfterMovieOutputAttached()
+            }
+        }
+
         // Update video orientation
         self.updateVideoOrientation()
     }
 
     func cleanup() {
+        configuredVideoFrameRate = nil
         stopBarcodeScanner()
         if let captureSession = self.captureSession {
             captureSession.stopRunning()
@@ -2409,6 +2496,7 @@ extension CameraController {
 
         // Reset output preparation status
         self.outputsPrepared = false
+        self.invalidateSupportedVideoStabilizationModesCache()
 
         // Reset first frame detection
         self.hasReceivedFirstFrame = false
@@ -2581,7 +2669,130 @@ extension CameraController {
         }
     }
 
-    func captureVideo(maxDuration: Float? = nil, maxFileSize: Int? = nil) throws {
+    private func activeVideoDevice() -> AVCaptureDevice? {
+        switch currentCameraPosition {
+        case .front:
+            return self.frontCamera
+        case .rear:
+            return self.rearCamera
+        default:
+            return nil
+        }
+    }
+
+    private func frameRates(from format: AVCaptureDevice.Format) -> [Int] {
+        var rates = Set<Int>()
+        let standardRates = [24, 25, 30, 50, 60, 120]
+
+        for range in format.videoSupportedFrameRateRanges {
+            let minFps = Int(ceil(range.minFrameRate))
+            let maxFps = Int(floor(range.maxFrameRate))
+
+            if minFps == maxFps {
+                rates.insert(minFps)
+                continue
+            }
+
+            rates.insert(minFps)
+            rates.insert(maxFps)
+
+            for rate in standardRates where rate >= minFps && rate <= maxFps {
+                rates.insert(rate)
+            }
+        }
+
+        return rates.sorted()
+    }
+
+    private func formatSupportsFrameRate(_ format: AVCaptureDevice.Format, frameRate: Int) -> Bool {
+        let fps = Double(frameRate)
+        return format.videoSupportedFrameRateRanges.contains { range in
+            fps >= range.minFrameRate && fps <= range.maxFrameRate
+        }
+    }
+
+    private func frameRate(from duration: CMTime) -> Int {
+        guard duration.value > 0 else { return 30 }
+        return Int(round(Double(duration.timescale) / Double(duration.value)))
+    }
+
+    private func allSupportedFrameRates(for device: AVCaptureDevice) -> [Int] {
+        var rates = Set<Int>()
+        for format in device.formats {
+            for rate in frameRates(from: format) {
+                rates.insert(rate)
+            }
+        }
+        return rates.sorted()
+    }
+
+    func getSupportedVideoFrameRates() throws -> [Int] {
+        guard let device = activeVideoDevice() else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        return allSupportedFrameRates(for: device)
+    }
+
+    func getVideoFrameRate() throws -> Int {
+        if let configuredVideoFrameRate = self.configuredVideoFrameRate {
+            return configuredVideoFrameRate
+        }
+
+        guard let device = activeVideoDevice() else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        return frameRate(from: device.activeVideoMinFrameDuration)
+    }
+
+    func setVideoFrameRate(_ frameRate: Int) throws {
+        guard frameRate > 0 else {
+            throw NSError(domain: "CameraPreview", code: 0, userInfo: [NSLocalizedDescriptionKey: "frameRate must be greater than 0"])
+        }
+
+        if let fileVideoOutput = self.fileVideoOutput, fileVideoOutput.isRecording {
+            throw NSError(domain: "CameraPreview", code: 0, userInfo: [NSLocalizedDescriptionKey: "Cannot change video frame rate while recording"])
+        }
+
+        guard let device = activeVideoDevice() else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        let supportedRates = allSupportedFrameRates(for: device)
+        guard supportedRates.contains(frameRate) else {
+            throw NSError(
+                domain: "CameraPreview",
+                code: 0,
+                userInfo: [NSLocalizedDescriptionKey: "Unsupported frame rate \(frameRate). Supported values: \(supportedRates.map(String.init).joined(separator: ", "))"]
+            )
+        }
+
+        guard let targetFormat = device.formats.first(where: { formatSupportsFrameRate($0, frameRate: frameRate) }) else {
+            throw NSError(
+                domain: "CameraPreview",
+                code: 0,
+                userInfo: [NSLocalizedDescriptionKey: "Unsupported frame rate \(frameRate) for the active camera"]
+            )
+        }
+
+        let frameDuration = CMTime(value: 1, timescale: CMTimeScale(frameRate))
+
+        do {
+            try device.lockForConfiguration()
+            if device.activeFormat != targetFormat {
+                device.activeFormat = targetFormat
+            }
+            device.activeVideoMinFrameDuration = frameDuration
+            device.activeVideoMaxFrameDuration = frameDuration
+            device.unlockForConfiguration()
+            self.configuredVideoFrameRate = frameRate
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
+    func captureVideo(maxDuration: Float? = nil, maxFileSize: Int? = nil, allowHapticsAndSystemSoundsDuringRecording: Bool = false) throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
             throw CameraControllerError.captureSessionIsMissing
         }
@@ -2602,6 +2813,7 @@ extension CameraController {
                 let audioSession = AVAudioSession.sharedInstance()
                 try audioSession.setCategory(.playAndRecord, mode: .videoRecording, options: [.defaultToSpeaker])
                 try audioSession.setActive(true)
+                try audioSession.setAllowHapticsAndSystemSoundsDuringRecording(allowHapticsAndSystemSoundsDuringRecording)
             } catch {
                 print("[CameraPreview] Failed to configure AVAudioSession for video recording: \(error)")
             }
@@ -2610,15 +2822,21 @@ extension CameraController {
         // Ensure the movie file output is attached to the active session.
         // If the camera was started without cameraMode=true, the output may not have been added yet.
         if !captureSession.outputs.contains(where: { $0 === fileVideoOutput }) {
-            captureSession.beginConfiguration()
-            if captureSession.canAddOutput(fileVideoOutput) {
-                captureSession.addOutput(fileVideoOutput)
-                self.applyVideoStabilizationMode()
-            } else {
-                captureSession.commitConfiguration()
+            var didAddOutput = false
+            self.configureCaptureSession {
+                if captureSession.canAddOutput(fileVideoOutput) {
+                    captureSession.addOutput(fileVideoOutput)
+                    do {
+                        try self.refreshVideoStabilizationAfterMovieOutputAttached()
+                        didAddOutput = true
+                    } catch {
+                        didAddOutput = false
+                    }
+                }
+            }
+            guard didAddOutput else {
                 throw CameraControllerError.invalidOperation
             }
-            captureSession.commitConfiguration()
         }
 
         if let connection = fileVideoOutput.connection(with: .video) {
@@ -2655,7 +2873,9 @@ extension CameraController {
             fileVideoOutput.setOutputSettings([AVVideoCodecKey: codecType], for: connection)
         }
 
-        self.applyVideoStabilizationMode()
+        self.configureCaptureSession {
+            self.applyVideoStabilizationMode()
+        }
 
         // Start recording video
         fileVideoOutput.startRecording(to: fileUrl, recordingDelegate: self)
@@ -2664,21 +2884,26 @@ extension CameraController {
         self.videoFileURL = fileUrl
     }
 
-    func stopRecording(completion: @escaping (URL?, Error?) -> Void) {
+    func stopRecording(completion: @escaping (URL?, String?, Error?) -> Void) {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
-            completion(nil, CameraControllerError.captureSessionIsMissing)
+            completion(nil, nil, CameraControllerError.captureSessionIsMissing)
             return
         }
         guard let fileVideoOutput = self.fileVideoOutput else {
-            completion(nil, CameraControllerError.fileVideoOutputNotFound)
+            completion(nil, nil, CameraControllerError.fileVideoOutputNotFound)
+            return
+        }
+        guard fileVideoOutput.isRecording else {
+            completion(nil, nil, CameraControllerError.invalidOperation)
+            return
+        }
+        guard self.stopRecordingCompletion == nil else {
+            completion(nil, nil, CameraControllerError.invalidOperation)
             return
         }
 
-        // Stop recording video
+        self.stopRecordingCompletion = completion
         fileVideoOutput.stopRecording()
-
-        // Return the video file URL in the completion handler
-        completion(self.videoFileURL, nil)
     }
 }
 
@@ -3074,6 +3299,19 @@ extension UIImage {
 extension CameraController: AVCaptureFileOutputRecordingDelegate {
     func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {
         let reason = recordingFinishReason(from: error)
+        let stopCompletion = self.stopRecordingCompletion
+        self.stopRecordingCompletion = nil
+
+        if let stopCompletion = stopCompletion {
+            DispatchQueue.main.async {
+                if reason == "error" {
+                    stopCompletion(nil, nil, error ?? CameraControllerError.unknown)
+                } else {
+                    stopCompletion(outputFileURL, reason, nil)
+                }
+            }
+        }
+
         if reason == "error" {
             print("Error recording movie: \(error?.localizedDescription ?? "unknown")")
             return

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -35,7 +35,7 @@ extension UIWindow {
  */
 @objc(CameraPreview)
 public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
-    private let pluginVersion: String = "8.6.0"
+    private let pluginVersion: String = "8.8.0"
     public let identifier = "CameraPreviewPlugin"
     public let jsName = "CameraPreview"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -90,6 +90,9 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "getExposureCompensationRange", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getExposureCompensation", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setExposureCompensation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSupportedVideoFrameRates", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getVideoFrameRate", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setVideoFrameRate", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
     ]
     // Camera state tracking
@@ -673,6 +676,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         print("  - disableFocusIndicator: \(call.getBool("disableFocusIndicator") ?? false)")
         print("  - force: \(call.getBool("force") ?? false)")
         print("  - videoQuality: \(call.getString("videoQuality") ?? "high")")
+        print("  - videoStabilizationMode: \(call.getString("videoStabilizationMode") ?? "off")")
 
         let force = call.getBool("force") ?? false
 
@@ -775,6 +779,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         // Default to high if not provided
         let videoQuality = call.getString("videoQuality") ?? "high"
+        let videoStabilizationMode = call.getString("videoStabilizationMode")
         self.pendingStartBarcodeScannerOptions = self.barcodeScannerStartOptions(from: call)
 
         let initialZoomLevel = call.getFloat("initialZoomLevel")
@@ -798,6 +803,19 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 return
             }
 
+            if let videoStabilizationMode = videoStabilizationMode {
+                do {
+                    try self.cameraController.setVideoStabilizationMode(videoStabilizationMode)
+                } catch {
+                    DispatchQueue.main.async {
+                        self.isInitializing = false
+                        self.pendingStartBarcodeScannerOptions = nil
+                        call.reject("Failed to set video stabilization mode: \(error.localizedDescription)")
+                    }
+                    return
+                }
+            }
+
             self.cameraController.prepare(cameraPosition: self.cameraPosition, deviceId: deviceId, disableAudio: self.disableAudio, cameraMode: cameraMode, aspectRatio: self.aspectRatio, aspectMode: self.aspectMode, initialZoomLevel: initialZoomLevel, disableFocusIndicator: self.disableFocusIndicator, videoQuality: videoQuality) { error in
                 if let error = error {
                     print(error)
@@ -1693,7 +1711,15 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         do {
-            try self.cameraController.captureVideo(maxDuration: maxDuration, maxFileSize: maxFileSize)
+            if let frameRate = call.getInt("frameRate") {
+                try self.cameraController.setVideoFrameRate(frameRate)
+            }
+            let allowHapticsAndSystemSoundsDuringRecording = call.getBool("allowHapticsAndSystemSoundsDuringRecording") ?? false
+            try self.cameraController.captureVideo(
+                maxDuration: maxDuration,
+                maxFileSize: maxFileSize,
+                allowHapticsAndSystemSoundsDuringRecording: allowHapticsAndSystemSoundsDuringRecording
+            )
             call.resolve()
         } catch {
             call.reject(error.localizedDescription)
@@ -1701,8 +1727,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     }
 
     @objc func stopRecordVideo(_ call: CAPPluginCall) {
-        self.cameraController.stopRecording { (fileURL, error) in
-            guard let fileURL = fileURL else {
+        self.cameraController.stopRecording { (fileURL, reason, error) in
+            guard let fileURL = fileURL, let reason = reason else {
                 print(error ?? "Video capture error")
                 guard let error = error else {
                     call.reject("Video capture error")
@@ -1712,7 +1738,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 return
             }
 
-            call.resolve(["videoFilePath": fileURL.absoluteString, "reason": "manual"])
+            call.resolve(["videoFilePath": fileURL.absoluteString, "reason": reason])
         }
     }
 
@@ -2473,6 +2499,49 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    @objc func getSupportedVideoFrameRates(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let frameRates = try self.cameraController.getSupportedVideoFrameRates()
+            call.resolve(["frameRates": frameRates])
+        } catch {
+            call.reject("Failed to get supported video frame rates: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getVideoFrameRate(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let frameRate = try self.cameraController.getVideoFrameRate()
+            call.resolve(["frameRate": frameRate])
+        } catch {
+            call.reject("Failed to get video frame rate: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setVideoFrameRate(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        guard let frameRate = call.getInt("frameRate") else {
+            call.reject("frameRate parameter is required")
+            return
+        }
+        do {
+            try self.cameraController.setVideoFrameRate(frameRate)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
     private var lastOrientation: String?
 
     @objc private func handleOrientationChange() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "8.6.0",
+  "version": "8.8.0",
   "description": "Camera preview",
   "license": "MPL-2.0",
   "repository": {