@capgo/camera-preview 8.4.8 → 8.5.1

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -57,6 +57,16 @@ 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 }
@@ -140,9 +150,79 @@ class CameraController: NSObject {
     private var lastCaptureOrientation: AVCaptureVideoOrientation?
 
     var videoFileURL: URL?
+    var recordingFinishedCallback: ((URL, String) -> Void)?
     private let saneMaxZoomFactor: CGFloat = 25.5
 
     var videoQuality: String = "high"
+    var videoCodec: String = "avc1"
+
+    private static let allVideoQualities = ["low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3"]
+
+    func getSupportedVideoQualities() -> [String] {
+        guard let captureSession = self.captureSession else {
+            return Self.allVideoQualities
+        }
+        let device = self.currentCameraPosition == .front ? self.frontCamera : self.rearCamera
+        guard let device = device else {
+            return Self.allVideoQualities
+        }
+        return Self.allVideoQualities.filter { quality in
+            let preset = self.bestPreset(for: self.requestedAspectRatio, quality: quality, on: device)
+            return captureSession.canSetSessionPreset(preset)
+        }
+    }
+
+    func setVideoQuality(_ quality: String) throws {
+        guard Self.allVideoQualities.contains(quality.lowercased()) else {
+            throw CameraControllerError.invalidOperation
+        }
+        self.videoQuality = quality.lowercased()
+        self.configureSessionPreset(for: self.requestedAspectRatio)
+    }
+
+    func getVideoQuality() -> String {
+        return self.videoQuality
+    }
+
+    func getSupportedVideoCodecs() -> [String] {
+        guard let fileVideoOutput = self.fileVideoOutput else {
+            return ["avc1"]
+        }
+        var codecs: [String] = []
+        if fileVideoOutput.availableVideoCodecTypes.contains(.h264) {
+            codecs.append("avc1")
+        }
+        if fileVideoOutput.availableVideoCodecTypes.contains(.hevc) {
+            codecs.append("hvc1")
+        }
+        return codecs.isEmpty ? ["avc1"] : codecs
+    }
+
+    func setVideoCodec(_ codec: String) throws {
+        let normalized = codec.lowercased()
+        guard ["avc1", "hvc1"].contains(normalized) else {
+            throw CameraControllerError.invalidOperation
+        }
+        if !getSupportedVideoCodecs().contains(normalized) {
+            throw CameraControllerError.invalidOperation
+        }
+        self.videoCodec = normalized
+    }
+
+    func getVideoCodec() -> String {
+        return self.videoCodec
+    }
+
+    private func avVideoCodecType(for codec: String) -> AVVideoCodecType? {
+        switch codec.lowercased() {
+        case "avc1":
+            return .h264
+        case "hvc1":
+            return .hevc
+        default:
+            return nil
+        }
+    }
 
     // Track output preparation status
     private var outputsPrepared: Bool = false
@@ -346,45 +426,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
@@ -457,7 +499,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
@@ -465,21 +507,21 @@ 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)
                 }
 
                 // 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
                 }
@@ -528,28 +570,40 @@ extension CameraController {
 
         // Prioritize video quality setting
         switch self.videoQuality.lowercased() {
-        case "low":
-            // Match Android "Low" (SD/480p)
-            if captureSession.canSetSessionPreset(.vga640x480) {
-                targetPreset = .vga640x480
-            } else {
-                targetPreset = .low
+        case "2160p":
+            if captureSession.canSetSessionPreset(.hd4K3840x2160) {
+                targetPreset = .hd4K3840x2160
+            } else if captureSession.canSetSessionPreset(.hd1920x1080) {
+                targetPreset = .hd1920x1080
+            }
+        case "1080p":
+            if captureSession.canSetSessionPreset(.hd1920x1080) {
+                targetPreset = .hd1920x1080
+            } else if captureSession.canSetSessionPreset(.hd1280x720) {
+                targetPreset = .hd1280x720
             }
-        case "medium":
-            // Match Android "Medium" (HD/720p)
+        case "720p", "medium":
             if captureSession.canSetSessionPreset(.hd1280x720) {
                 targetPreset = .hd1280x720
             } else {
                 targetPreset = .medium
             }
+        case "480p", "low":
+            if captureSession.canSetSessionPreset(.vga640x480) {
+                targetPreset = .vga640x480
+            } else {
+                targetPreset = .low
+            }
+        case "4:3":
+            if captureSession.canSetSessionPreset(.photo) {
+                targetPreset = .photo
+            } else if captureSession.canSetSessionPreset(.high) {
+                targetPreset = .high
+            }
         case "high":
-            // Exisiting logic for High Quality (4K/1080p based on Asepct Ratio)
-
             if let aspectRatio = aspectRatio {
                 switch aspectRatio {
                 case "16:9":
-                    // Start with 1080p for faster initialization, 4K only when explicitly needed
-                    // This maintains capture quality while optimizing preview performance
                     if captureSession.canSetSessionPreset(.hd1920x1080) {
                         targetPreset = .hd1920x1080
                     } else if captureSession.canSetSessionPreset(.hd4K3840x2160) {
@@ -573,7 +627,6 @@ extension CameraController {
                     }
                 }
             }
-        // Handle unexpected values
         default:
             if captureSession.canSetSessionPreset(.photo) {
                 targetPreset = .photo
@@ -849,9 +902,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 {
@@ -893,28 +947,37 @@ extension CameraController {
 
         // Handle specific quality overrides first
         switch quality.lowercased() {
-        case "low":
-            if device.supportsSessionPreset(.vga640x480) { return .vga640x480 }
-            return .low
-        case "medium":
+        case "2160p":
+            if device.supportsSessionPreset(.hd4K3840x2160) { return .hd4K3840x2160 }
+            if device.supportsSessionPreset(.hd1920x1080) { return .hd1920x1080 }
+            if device.supportsSessionPreset(.hd1280x720) { return .hd1280x720 }
+            return .vga640x480
+        case "1080p":
+            if device.supportsSessionPreset(.hd1920x1080) { return .hd1920x1080 }
+            if device.supportsSessionPreset(.hd1280x720) { return .hd1280x720 }
+            return .vga640x480
+        case "720p", "medium":
             if device.supportsSessionPreset(.hd1280x720) { return .hd1280x720 }
             return .medium
-        case "high":
-            break // Exit and go off code below
+        case "480p", "low":
+            if device.supportsSessionPreset(.vga640x480) { return .vga640x480 }
+            return .low
+        case "4:3":
+            if device.supportsSessionPreset(.photo) { return .photo }
+            if device.supportsSessionPreset(.high) { return .high }
+            return .vga640x480
         default:
-            break // Exit and go off code below
+            break
         }
         // Preference order depends on aspect ratio
         if aspectRatio == "16:9" {
-            // Prefer 4K → 1080p → 720p → high → photo → vga
             if device.supportsSessionPreset(.hd4K3840x2160) { return .hd4K3840x2160 }
             if device.supportsSessionPreset(.hd1920x1080) { return .hd1920x1080 }
             if device.supportsSessionPreset(.hd1280x720) { return .hd1280x720 }
             if device.supportsSessionPreset(.high) { return .high }
-            if device.supportsSessionPreset(.photo) { return .photo } // safe, though 4:3
+            if device.supportsSessionPreset(.photo) { return .photo }
             return .vga640x480
         } else {
-            // 4:3 or unknown: prefer photo → high → 1080p → 720p → vga
             if device.supportsSessionPreset(.photo) { return .photo }
             if device.supportsSessionPreset(.high) { return .high }
             if device.supportsSessionPreset(.hd1920x1080) { return .hd1920x1080 }
@@ -1048,7 +1111,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
@@ -2384,7 +2447,7 @@ extension CameraController {
         }
     }
 
-    func captureVideo() throws {
+    func captureVideo(maxDuration: Float? = nil, maxFileSize: Int? = nil) throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
             throw CameraControllerError.captureSessionIsMissing
         }
@@ -2426,7 +2489,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 {
@@ -2444,6 +2507,19 @@ extension CameraController {
         let fileUrl = documentsDirectory.appendingPathComponent(fileName)
         try? FileManager.default.removeItem(at: fileUrl)
 
+        if let maxDuration = maxDuration, maxDuration > 0 {
+            fileVideoOutput.maxRecordedDuration = CMTime(seconds: Double(maxDuration), preferredTimescale: 600)
+        } else {
+            fileVideoOutput.maxRecordedDuration = .invalid
+        }
+        fileVideoOutput.maxRecordedFileSize = Int64(maxFileSize ?? 0)
+
+        if let connection = fileVideoOutput.connection(with: .video),
+           let codecType = avVideoCodecType(for: self.videoCodec),
+           fileVideoOutput.availableVideoCodecTypes.contains(codecType) {
+            fileVideoOutput.setOutputSettings([AVVideoCodecKey: codecType], for: connection)
+        }
+
         // Start recording video
         fileVideoOutput.startRecording(to: fileUrl, recordingDelegate: self)
 
@@ -2857,11 +2933,33 @@ extension UIImage {
 
 extension CameraController: AVCaptureFileOutputRecordingDelegate {
     func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {
-        if let error = error {
-            print("Error recording movie: \(error.localizedDescription)")
-        } else {
-            print("Movie recorded successfully: \(outputFileURL)")
-            // You can save the file to the library, upload it, etc.
+        let reason = recordingFinishReason(from: error)
+        if reason == "error" {
+            print("Error recording movie: \(error?.localizedDescription ?? "unknown")")
+            return
+        }
+
+        print("Movie recorded successfully: \(outputFileURL)")
+        self.recordingFinishedCallback?(outputFileURL, reason)
+    }
+
+    private func recordingFinishReason(from error: Error?) -> String {
+        guard let error = error else {
+            return "manual"
+        }
+
+        let nsError = error as NSError
+        guard nsError.domain == AVFoundationErrorDomain else {
+            return "error"
+        }
+
+        switch AVError.Code(rawValue: nsError.code) {
+        case .maximumDurationReached:
+            return "maxDuration"
+        case .maximumFileSizeReached:
+            return "maxFileSize"
+        default:
+            return "error"
         }
     }
 }

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.4.8"
+    private let pluginVersion: String = "8.5.1"
     public let identifier = "CameraPreviewPlugin"
     public let jsName = "CameraPreview"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -51,6 +51,12 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "setFlashMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "startRecordVideo", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stopRecordVideo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSupportedVideoCodecs", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getVideoCodec", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setVideoCodec", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSupportedVideoQualities", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getVideoQuality", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setVideoQuality", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getTempFilePath", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getSupportedPictureSizes", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
@@ -646,7 +652,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)")
@@ -718,7 +724,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 {
@@ -1595,9 +1601,62 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    @objc func setVideoQuality(_ call: CAPPluginCall) {
+        guard let quality = call.getString("quality") else {
+            call.reject("quality is required")
+            return
+        }
+        do {
+            try self.cameraController.setVideoQuality(quality)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set video quality: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getVideoQuality(_ call: CAPPluginCall) {
+        call.resolve(["quality": self.cameraController.getVideoQuality()])
+    }
+
+    @objc func getSupportedVideoQualities(_ call: CAPPluginCall) {
+        call.resolve(["qualities": self.cameraController.getSupportedVideoQualities()])
+    }
+
+    @objc func setVideoCodec(_ call: CAPPluginCall) {
+        guard let codec = call.getString("codec") else {
+            call.reject("codec is required")
+            return
+        }
+        do {
+            try self.cameraController.setVideoCodec(codec)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set video codec: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getVideoCodec(_ call: CAPPluginCall) {
+        call.resolve(["codec": self.cameraController.getVideoCodec()])
+    }
+
+    @objc func getSupportedVideoCodecs(_ call: CAPPluginCall) {
+        call.resolve(["codecs": self.cameraController.getSupportedVideoCodecs()])
+    }
+
     @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)
+        }
+        self.cameraController.recordingFinishedCallback = { [weak self] fileURL, reason in
+            DispatchQueue.main.async {
+                self?.notifyListeners("recordingFinished", data: ["videoFilePath": fileURL.absoluteString, "reason": reason])
+            }
+        }
+
         do {
-            try self.cameraController.captureVideo()
+            try self.cameraController.captureVideo(maxDuration: maxDuration, maxFileSize: maxFileSize)
             call.resolve()
         } catch {
             call.reject(error.localizedDescription)
@@ -1616,7 +1675,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 return
             }
 
-            call.resolve(["videoFilePath": fileURL.absoluteString])
+            call.resolve(["videoFilePath": fileURL.absoluteString, "reason": "manual"])
         }
     }
 

package/package.json

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