@capgo/camera-preview 8.5.0 → 8.6.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -57,6 +57,15 @@ class CameraController: NSObject {
         }
     }
 
+    private func setVideoOrientation(_ orientation: AVCaptureVideoOrientation, on connection: AVCaptureConnection) {
+        guard connection.isVideoOrientationSupported else { return }
+        connection.videoOrientation = orientation
+    }
+
+    private func setVideoOrientation(_ orientation: AVCaptureVideoOrientation, on connections: [AVCaptureConnection]) {
+        connections.forEach { setVideoOrientation(orientation, on: $0) }
+    }
+
     // Continuous focus with significant movement if focus was locked from setFocus earlier
     @objc private func subjectAreaDidChange(notification: NSNotification) {
         guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
@@ -145,6 +154,7 @@ class CameraController: NSObject {
 
     var videoQuality: String = "high"
     var videoCodec: String = "avc1"
+    var videoStabilizationMode: String = "off"
 
     private static let allVideoQualities = ["low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3"]
 
@@ -203,6 +213,138 @@ class CameraController: NSObject {
         return self.videoCodec
     }
 
+    func isVideoStabilizationSupported() -> Bool {
+        guard let connection = self.fileVideoOutput?.connection(with: .video) else {
+            return false
+        }
+        return connection.isVideoStabilizationSupported
+    }
+
+    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)
+            }
+        }
+
+        connection.preferredVideoStabilizationMode = savedPreferred
+        return supported.isEmpty ? ["off"] : supported
+    }
+
+    func getVideoStabilizationMode() -> String {
+        if let connection = self.fileVideoOutput?.connection(with: .video),
+           connection.isVideoStabilizationSupported {
+            return self.videoStabilizationModeString(from: connection.activeVideoStabilizationMode)
+        }
+        return self.videoStabilizationMode
+    }
+
+    func setVideoStabilizationMode(_ mode: String) throws {
+        if self.fileVideoOutput?.isRecording == true {
+            throw CameraControllerError.recordingInProgress
+        }
+        guard let avMode = self.avVideoStabilizationMode(from: mode) else {
+            throw CameraControllerError.invalidOperation
+        }
+        let supportedModes = self.getSupportedVideoStabilizationModes()
+        guard supportedModes.contains(mode) else {
+            throw CameraControllerError.invalidOperation
+        }
+        self.videoStabilizationMode = mode
+        self.applyVideoStabilizationMode(avMode)
+    }
+
+    private static func allVideoStabilizationModeCandidates() -> [(name: String, mode: AVCaptureVideoStabilizationMode)] {
+        var candidates: [(String, AVCaptureVideoStabilizationMode)] = [
+            ("off", .off),
+            ("standard", .standard),
+            ("cinematic", .cinematic),
+            ("cinematicExtended", .cinematicExtended),
+            ("auto", .auto),
+        ]
+        if #available(iOS 17.0, *) {
+            candidates.append(("previewOptimized", .previewOptimized))
+        }
+        if #available(iOS 18.0, *) {
+            candidates.append(("cinematicExtendedEnhanced", .cinematicExtendedEnhanced))
+        }
+        return candidates
+    }
+
+    private func applyVideoStabilizationMode(_ mode: AVCaptureVideoStabilizationMode? = nil) {
+        guard let connection = self.fileVideoOutput?.connection(with: .video),
+              connection.isVideoStabilizationSupported else {
+            return
+        }
+        let targetMode = mode ?? self.avVideoStabilizationMode(from: self.videoStabilizationMode) ?? .off
+        connection.preferredVideoStabilizationMode = targetMode
+    }
+
+    private func avVideoStabilizationMode(from mode: String) -> AVCaptureVideoStabilizationMode? {
+        switch mode {
+        case "off":
+            return .off
+        case "standard":
+            return .standard
+        case "cinematic":
+            return .cinematic
+        case "cinematicExtended":
+            return .cinematicExtended
+        case "auto":
+            return .auto
+        case "previewOptimized":
+            if #available(iOS 17.0, *) {
+                return .previewOptimized
+            }
+            return nil
+        case "cinematicExtendedEnhanced":
+            if #available(iOS 18.0, *) {
+                return .cinematicExtendedEnhanced
+            }
+            return nil
+        case "lowLatency":
+            return nil
+        default:
+            return nil
+        }
+    }
+
+    private func videoStabilizationModeString(from mode: AVCaptureVideoStabilizationMode) -> String {
+        switch mode {
+        case .off:
+            return "off"
+        case .standard:
+            return "standard"
+        case .cinematic:
+            return "cinematic"
+        case .cinematicExtended:
+            return "cinematicExtended"
+        case .auto:
+            return "auto"
+        default:
+            if #available(iOS 17.0, *) {
+                if mode == .previewOptimized {
+                    return "previewOptimized"
+                }
+            }
+            if #available(iOS 18.0, *) {
+                if mode == .cinematicExtendedEnhanced {
+                    return "cinematicExtendedEnhanced"
+                }
+            }
+            return self.videoStabilizationMode
+        }
+    }
+
     private func avVideoCodecType(for codec: String) -> AVVideoCodecType? {
         switch codec.lowercased() {
         case "avc1":
@@ -416,45 +558,7 @@ extension CameraController {
             let layer = AVCaptureVideoPreviewLayer()
             // Configure orientation immediately
             if let connection = layer.connection {
-                // Ensure UI calls are made on the main thread
-                if Thread.isMainThread {
-                    if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
-                        switch windowScene.interfaceOrientation {
-                        case .portrait:
-                            connection.videoOrientation = .portrait
-                        case .landscapeLeft:
-                            connection.videoOrientation = .landscapeLeft
-                        case .landscapeRight:
-                            connection.videoOrientation = .landscapeRight
-                        case .portraitUpsideDown:
-                            connection.videoOrientation = .portraitUpsideDown
-                        case .unknown:
-                            fallthrough
-                        @unknown default:
-                            connection.videoOrientation = .portrait
-                        }
-                    }
-                } else {
-                    // If not on main thread, use a sync call to get the orientation
-                    DispatchQueue.main.sync {
-                        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
-                            switch windowScene.interfaceOrientation {
-                            case .portrait:
-                                connection.videoOrientation = .portrait
-                            case .landscapeLeft:
-                                connection.videoOrientation = .landscapeLeft
-                            case .landscapeRight:
-                                connection.videoOrientation = .landscapeRight
-                            case .portraitUpsideDown:
-                                connection.videoOrientation = .portraitUpsideDown
-                            case .unknown:
-                                fallthrough
-                            @unknown default:
-                                connection.videoOrientation = .portrait
-                            }
-                        }
-                    }
-                }
+                self.setVideoOrientation(self.getVideoOrientation(), on: connection)
             }
             // Don't set session here - we'll do it during configuration
             self.previewLayer = layer
@@ -527,7 +631,7 @@ extension CameraController {
                     let videoQueue = DispatchQueue(label: "com.camera.videoQueue", qos: .userInteractive)
                     dataOutput.setSampleBufferDelegate(self, queue: videoQueue)
                     // Set orientation immediately
-                    dataOutput.connections.forEach { $0.videoOrientation = videoOrientation }
+                    self.setVideoOrientation(videoOrientation, on: dataOutput.connections)
                 }
 
                 // Add photo output immediately to avoid later reconfiguration
@@ -535,21 +639,22 @@ extension CameraController {
                     photoOutput.isHighResolutionCaptureEnabled = true
                     captureSession.addOutput(photoOutput)
                     // Set orientation immediately
-                    photoOutput.connections.forEach { $0.videoOrientation = videoOrientation }
+                    self.setVideoOrientation(videoOrientation, on: photoOutput.connections)
                 }
 
                 // Add video output if in camera mode
                 if cameraMode, let fileVideoOutput = self.fileVideoOutput, captureSession.canAddOutput(fileVideoOutput) {
                     captureSession.addOutput(fileVideoOutput)
                     // Set orientation immediately
-                    fileVideoOutput.connections.forEach { $0.videoOrientation = videoOrientation }
+                    self.setVideoOrientation(videoOrientation, on: fileVideoOutput.connections)
+                    self.applyVideoStabilizationMode()
                 }
 
                 // Set up preview layer session in the same configuration block
                 if let layer = self.previewLayer {
                     layer.session = captureSession
                     // Set orientation for preview layer
-                    layer.connection?.videoOrientation = videoOrientation
+                    if let connection = layer.connection { self.setVideoOrientation(videoOrientation, on: connection) }
                     // Start with a very subtle fade to smooth any remaining visual artifacts
                     layer.opacity = 0.95
                 }
@@ -930,9 +1035,10 @@ extension CameraController {
         // Apply orientation asynchronously on main thread
         let updateBlock = { [weak self] in
             guard let self = self else { return }
-            self.previewLayer?.connection?.videoOrientation = videoOrientation
-            self.dataOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
-            self.photoOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
+            if let connection = self.previewLayer?.connection { self.setVideoOrientation(videoOrientation, on: connection) }
+            if let connections = self.dataOutput?.connections { self.setVideoOrientation(videoOrientation, on: connections) }
+            if let connections = self.photoOutput?.connections { self.setVideoOrientation(videoOrientation, on: connections) }
+            if let connections = self.fileVideoOutput?.connections { self.setVideoOrientation(videoOrientation, on: connections) }
         }
 
         if Thread.isMainThread {
@@ -1121,6 +1227,7 @@ extension CameraController {
             captureSession.removeOutput(fileVideoOutput)
             if captureSession.canAddOutput(fileVideoOutput) {
                 captureSession.addOutput(fileVideoOutput)
+                self.applyVideoStabilizationMode()
             }
         }
 
@@ -1138,7 +1245,7 @@ extension CameraController {
         if let connection = photoOutput.connection(with: .video) {
             let captureOrientation = self.getPhysicalOrientation()
             self.lastCaptureOrientation = captureOrientation
-            connection.videoOrientation = captureOrientation
+            self.setVideoOrientation(captureOrientation, on: connection)
         }
         let settings = AVCapturePhotoSettings()
         // Configure photo capture settings optimized for speed
@@ -2506,6 +2613,7 @@ extension CameraController {
             captureSession.beginConfiguration()
             if captureSession.canAddOutput(fileVideoOutput) {
                 captureSession.addOutput(fileVideoOutput)
+                self.applyVideoStabilizationMode()
             } else {
                 captureSession.commitConfiguration()
                 throw CameraControllerError.invalidOperation
@@ -2516,7 +2624,7 @@ extension CameraController {
         if let connection = fileVideoOutput.connection(with: .video) {
             if connection.isEnabled == false { connection.isEnabled = true }
             // Goes off accelerometer now
-            connection.videoOrientation = self.getPhysicalOrientation()
+            self.setVideoOrientation(self.getPhysicalOrientation(), on: connection)
 
             // Front camera: mirror the recorded video so it looks natural (selfie style).
             if self.currentCameraPosition == .front, connection.isVideoMirroringSupported {
@@ -2547,6 +2655,8 @@ extension CameraController {
             fileVideoOutput.setOutputSettings([AVVideoCodecKey: codecType], for: connection)
         }
 
+        self.applyVideoStabilizationMode()
+
         // Start recording video
         fileVideoOutput.startRecording(to: fileUrl, recordingDelegate: self)
 
@@ -2851,6 +2961,7 @@ enum CameraControllerError: Swift.Error {
     case invalidOperation
     case noCamerasAvailable
     case cannotFindDocumentsDirectory
+    case recordingInProgress
     case fileVideoOutputNotFound
     case unknown
     case invalidZoomLevel(min: CGFloat, max: CGFloat, requested: CGFloat)
@@ -2878,6 +2989,8 @@ extension CameraControllerError: LocalizedError {
             return NSLocalizedString("Unknown", comment: "Unknown")
         case .cannotFindDocumentsDirectory:
             return NSLocalizedString("Cannot find documents directory", comment: "This should never happen")
+        case .recordingInProgress:
+            return NSLocalizedString("Cannot change video stabilization while recording is in progress.", comment: "Recording in progress")
         case .fileVideoOutputNotFound:
             return NSLocalizedString("Video recording is not available. Make sure the camera is properly initialized.", comment: "Video recording not available")
         case .invalidZoomLevel(let min, let max, let requested):

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.5.0"
+    private let pluginVersion: String = "8.6.0"
     public let identifier = "CameraPreviewPlugin"
     public let jsName = "CameraPreview"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -54,6 +54,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "getSupportedVideoCodecs", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getVideoCodec", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setVideoCodec", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isVideoStabilizationSupported", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSupportedVideoStabilizationModes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getVideoStabilizationMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setVideoStabilizationMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getSupportedVideoQualities", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getVideoQuality", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setVideoQuality", returnType: CAPPluginReturnPromise),
@@ -652,7 +656,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         print("[CameraPreview] 📋 Settings received:")
         print("  - position: \(call.getString("position") ?? "rear")")
         print("  - deviceId: \(call.getString("deviceId") ?? "nil")")
-        print("  - cameraMode: \(call.getBool("cameraMode") ?? false)")
+        print("  - enableVideoMode: \(call.getBool("enableVideoMode") ?? call.getBool("cameraMode") ?? false)")
         print("  - width: \(call.getInt("width") ?? 0)")
         print("  - height: \(call.getInt("height") ?? 0)")
         print("  - x: \(call.getInt("x") ?? -1)")
@@ -724,7 +728,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         self.cameraPosition = call.getString("position") ?? "rear"
         let deviceId = call.getString("deviceId")
-        let cameraMode = call.getBool("cameraMode") ?? false
+        let cameraMode = call.getBool("enableVideoMode") ?? call.getBool("cameraMode") ?? false
 
         // Set width - use screen width if not provided or if 0
         if let width = call.getInt("width"), width > 0 {
@@ -1643,12 +1647,45 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         call.resolve(["codecs": self.cameraController.getSupportedVideoCodecs()])
     }
 
+    @objc func isVideoStabilizationSupported(_ call: CAPPluginCall) {
+        call.resolve(["supported": self.cameraController.isVideoStabilizationSupported()])
+    }
+
+    @objc func getSupportedVideoStabilizationModes(_ call: CAPPluginCall) {
+        call.resolve(["modes": self.cameraController.getSupportedVideoStabilizationModes()])
+    }
+
+    @objc func getVideoStabilizationMode(_ call: CAPPluginCall) {
+        call.resolve(["mode": self.cameraController.getVideoStabilizationMode()])
+    }
+
+    @objc func setVideoStabilizationMode(_ call: CAPPluginCall) {
+        guard let mode = call.getString("mode") else {
+            call.reject("mode is required")
+            return
+        }
+        do {
+            try self.cameraController.setVideoStabilizationMode(mode)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set video stabilization mode: \(error.localizedDescription)")
+        }
+    }
+
     @objc func startRecordVideo(_ call: CAPPluginCall) {
         let maxDuration = call.getFloat("maxDuration")
         let maxFileSize = call.getInt("maxFileSize")
         if let videoCodec = call.getString("videoCodec") {
             try? self.cameraController.setVideoCodec(videoCodec)
         }
+        if let videoStabilizationMode = call.getString("videoStabilizationMode") {
+            do {
+                try self.cameraController.setVideoStabilizationMode(videoStabilizationMode)
+            } catch {
+                call.reject("Failed to set video stabilization mode: \(error.localizedDescription)")
+                return
+            }
+        }
         self.cameraController.recordingFinishedCallback = { [weak self] fileURL, reason in
             DispatchQueue.main.async {
                 self?.notifyListeners("recordingFinished", data: ["videoFilePath": fileURL.absoluteString, "reason": reason])

package/package.json

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