@capgo/camera-preview 8.8.0 → 8.9.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -105,6 +105,10 @@ class CameraController: NSObject {
 
     var captureSession: AVCaptureSession?
     var disableFocusIndicator: Bool = false
+    private var focusExposureRestoreGeneration: UInt = 0
+    private var focusExposureRestoreTimeoutWorkItem: DispatchWorkItem?
+    private let focusExposureRestoreTimeout: TimeInterval = 3.0
+    private let focusExposureRestorePollInterval: TimeInterval = 0.05
 
     var currentCameraPosition: CameraPosition?
 
@@ -619,7 +623,10 @@ extension CameraController {
         self.photoOutput?.isHighResolutionCaptureEnabled = true
 
         // Create video output
-        self.fileVideoOutput = AVCaptureMovieFileOutput()
+        let movieFileOutput = AVCaptureMovieFileOutput()
+        // MP4 does not support movie fragments; the default 10s interval drops the final partial segment on stop.
+        movieFileOutput.movieFragmentInterval = .invalid
+        self.fileVideoOutput = movieFileOutput
 
         // Create data output for preview
         self.dataOutput = AVCaptureVideoDataOutput()
@@ -1000,6 +1007,10 @@ extension CameraController {
                     finalDevice.exposurePointOfInterest = CGPoint(x: 0.5, y: 0.5)
                 }
             }
+            // Default white balance to continuous auto (prevents a warm/yellow cast)
+            if finalDevice.isWhiteBalanceModeSupported(.continuousAutoWhiteBalance) {
+                finalDevice.whiteBalanceMode = .continuousAutoWhiteBalance
+            }
             // Reset exposure compensation so sessions start neutral
             let minBias = finalDevice.minExposureTargetBias
             let maxBias = finalDevice.maxExposureTargetBias
@@ -1195,6 +1206,7 @@ extension CameraController {
     }
 
     func switchCameras() throws {
+        self.cancelPendingFocusExposureRestore()
         configuredVideoFrameRate = nil
         guard let currentCameraPosition = currentCameraPosition,
               let captureSession = self.captureSession else {
@@ -2179,46 +2191,116 @@ extension CameraController {
         }
     }
 
-    private func triggerAutoFocus() {
-        var currentCamera: AVCaptureDevice?
-        switch currentCameraPosition {
-        case .front:
-            currentCamera = self.frontCamera
-        case .rear:
-            currentCamera = self.rearCamera
-        default: break
+
+    private func cancelPendingFocusExposureRestore() {
+        self.focusExposureRestoreGeneration &+= 1
+        self.focusExposureRestoreTimeoutWorkItem?.cancel()
+        self.focusExposureRestoreTimeoutWorkItem = nil
+    }
+
+    private func applyOneShotFocusAndExposure(at point: CGPoint, on device: AVCaptureDevice, adjustExposure: Bool) throws {
+        try device.lockForConfiguration()
+        defer { device.unlockForConfiguration() }
+
+        if device.isFocusModeSupported(.autoFocus) {
+            device.focusMode = .autoFocus
+        } else if device.isFocusModeSupported(.continuousAutoFocus) {
+            device.focusMode = .continuousAutoFocus
         }
 
-        guard let device = currentCamera else {
+        if device.isFocusPointOfInterestSupported {
+            device.focusPointOfInterest = point
+        }
+
+        if adjustExposure, device.exposureMode != .locked {
+            if device.isExposurePointOfInterestSupported, device.isExposureModeSupported(.autoExpose) {
+                device.exposureMode = .autoExpose
+                device.setExposureTargetBias(0.0) { _ in }
+                device.exposurePointOfInterest = point
+            }
+        }
+
+        device.isSubjectAreaChangeMonitoringEnabled = true
+    }
+
+    private func scheduleFocusExposureRestore(for device: AVCaptureDevice) {
+        self.focusExposureRestoreGeneration &+= 1
+        let generation = self.focusExposureRestoreGeneration
+
+        self.focusExposureRestoreTimeoutWorkItem?.cancel()
+
+        let timeoutWork = DispatchWorkItem { [weak self] in
+            self?.restoreContinuousFocusAndExposureIfCurrent(on: device, generation: generation)
+        }
+        self.focusExposureRestoreTimeoutWorkItem = timeoutWork
+
+        self.pollFocusExposureAdjustmentCompletion(on: device, generation: generation)
+        DispatchQueue.main.asyncAfter(deadline: .now() + self.focusExposureRestoreTimeout, execute: timeoutWork)
+    }
+
+    private func pollFocusExposureAdjustmentCompletion(on device: AVCaptureDevice, generation: UInt) {
+        guard generation == self.focusExposureRestoreGeneration else { return }
+
+        if device.isAdjustingFocus || device.isAdjustingExposure {
+            DispatchQueue.main.asyncAfter(deadline: .now() + self.focusExposureRestorePollInterval) { [weak self] in
+                self?.pollFocusExposureAdjustmentCompletion(on: device, generation: generation)
+            }
             return
         }
 
-        // Focus on the center of the preview (0.5, 0.5)
-        let centerPoint = CGPoint(x: 0.5, y: 0.5)
+        self.restoreContinuousFocusAndExposureIfCurrent(on: device, generation: generation)
+    }
+
+    private func restoreContinuousFocusAndExposureIfCurrent(on device: AVCaptureDevice, generation: UInt) {
+        guard generation == self.focusExposureRestoreGeneration else { return }
+
+        self.focusExposureRestoreTimeoutWorkItem?.cancel()
+        self.focusExposureRestoreTimeoutWorkItem = nil
 
         do {
             try device.lockForConfiguration()
+            defer { device.unlockForConfiguration() }
 
-            // Set focus mode to auto if supported
-            if device.isFocusModeSupported(.autoFocus) {
-                device.focusMode = .autoFocus
-                if device.isFocusPointOfInterestSupported {
-                    device.focusPointOfInterest = centerPoint
-                }
-            } else if device.isFocusModeSupported(.continuousAutoFocus) {
+            let centerPoint = CGPoint(x: 0.5, y: 0.5)
+
+            if device.isFocusModeSupported(.continuousAutoFocus) {
                 device.focusMode = .continuousAutoFocus
                 if device.isFocusPointOfInterestSupported {
                     device.focusPointOfInterest = centerPoint
                 }
             }
 
-            if device.isExposurePointOfInterestSupported {
-                let exposureMode = try getExposureMode()
-                if exposureMode == "AUTO" || exposureMode == "CONTINUOUS" {
-                    device.exposurePointOfInterest = centerPoint
+            if device.exposureMode != .locked {
+                if device.isExposureModeSupported(.continuousAutoExposure) {
+                    device.exposureMode = .continuousAutoExposure
+                    if device.isExposurePointOfInterestSupported {
+                        device.exposurePointOfInterest = centerPoint
+                    }
+                    device.setExposureTargetBias(0.0) { _ in }
                 }
             }
-            device.unlockForConfiguration()
+
+            device.isSubjectAreaChangeMonitoringEnabled = false
+        } catch {
+            print("[CameraPreview] Failed to restore continuous focus/exposure: \(error)")
+        }
+    }
+
+    private func triggerAutoFocus() {
+        guard let device = self.activeVideoDevice() else { return }
+
+        let centerPoint = CGPoint(x: 0.5, y: 0.5)
+        let adjustExposure: Bool
+        do {
+            let exposureMode = try self.getExposureMode()
+            adjustExposure = exposureMode == "AUTO" || exposureMode == "CONTINUOUS"
+        } catch {
+            adjustExposure = true
+        }
+
+        do {
+            try self.applyOneShotFocusAndExposure(at: centerPoint, on: device, adjustExposure: adjustExposure)
+            self.scheduleFocusExposureRestore(for: device)
         } catch {
             // Silently ignore errors during autofocus
         }
@@ -2257,33 +2339,8 @@ extension CameraController {
         }
 
         do {
-            try device.lockForConfiguration()
-
-            // Set focus mode to auto if supported
-            if device.isFocusModeSupported(.autoFocus) {
-                device.focusMode = .autoFocus
-            } else if device.isFocusModeSupported(.continuousAutoFocus) {
-                device.focusMode = .continuousAutoFocus
-            }
-
-            // Set the focus point
-            device.focusPointOfInterest = point
-
-            // Skip exposure point if exposure locked
-            if device.exposureMode != .locked {
-
-                // Also set exposure point if supported
-                if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
-                    device.exposureMode = .autoExpose
-                    device.setExposureTargetBias(0.0) { _ in }
-                    device.exposurePointOfInterest = point
-                }
-            }
-
-            // Turn on subject area monitor for switch to continuous focus if needed
-            device.isSubjectAreaChangeMonitoringEnabled = true
-
-            device.unlockForConfiguration()
+            try self.applyOneShotFocusAndExposure(at: point, on: device, adjustExposure: true)
+            self.scheduleFocusExposureRestore(for: device)
         } catch {
             throw CameraControllerError.unknown
         }
@@ -2372,6 +2429,7 @@ extension CameraController {
     }
 
     func swapToDevice(deviceId: String) throws {
+        self.cancelPendingFocusExposureRestore()
         guard let captureSession = self.captureSession else {
             throw CameraControllerError.captureSessionIsMissing
         }
@@ -2460,6 +2518,7 @@ extension CameraController {
     }
 
     func cleanup() {
+        self.cancelPendingFocusExposureRestore()
         configuredVideoFrameRate = nil
         stopBarcodeScanner()
         if let captureSession = self.captureSession {
@@ -2669,6 +2728,100 @@ extension CameraController {
         }
     }
 
+    // MARK: - White Balance Controls
+
+    func getWhiteBalanceModes() throws -> [String] {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        var modes: [String] = []
+        if device.isWhiteBalanceModeSupported(.locked) { modes.append("LOCK") }
+        if device.isWhiteBalanceModeSupported(.autoWhiteBalance) { modes.append("AUTO") }
+        if device.isWhiteBalanceModeSupported(.continuousAutoWhiteBalance) { modes.append("CONTINUOUS") }
+        return modes
+    }
+
+    func getWhiteBalanceMode() throws -> String {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        switch device.whiteBalanceMode {
+        case .locked:
+            return "LOCK"
+        case .autoWhiteBalance:
+            return "AUTO"
+        case .continuousAutoWhiteBalance:
+            return "CONTINUOUS"
+        @unknown default:
+            return "CONTINUOUS"
+        }
+    }
+
+    func setWhiteBalanceMode(mode: String) throws {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        let normalized = mode.uppercased()
+        let desiredMode: AVCaptureDevice.WhiteBalanceMode?
+        switch normalized {
+        case "LOCK":
+            desiredMode = .locked
+        case "AUTO":
+            desiredMode = .autoWhiteBalance
+        case "CONTINUOUS":
+            desiredMode = .continuousAutoWhiteBalance
+        case "CUSTOM":
+            throw CameraControllerError.invalidOperation
+        default:
+            throw CameraControllerError.invalidOperation
+        }
+
+        guard let finalMode = desiredMode, device.isWhiteBalanceModeSupported(finalMode) else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        do {
+            try device.lockForConfiguration()
+            device.whiteBalanceMode = finalMode
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
     private func activeVideoDevice() -> AVCaptureDevice? {
         switch currentCameraPosition {
         case .front:
@@ -2914,38 +3067,16 @@ extension CameraController: UIGestureRecognizerDelegate {
 
     @objc
     func handleTap(_ tap: UITapGestureRecognizer) {
-        guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
-
-        let point = tap.location(in: tap.view)
-        let devicePoint = self.previewLayer?.captureDevicePointConverted(fromLayerPoint: point)
-
-        // Show focus indicator at the tap point if not disabled
-        if !self.disableFocusIndicator, let view = tap.view {
-            showFocusIndicator(at: point, in: view)
+        guard let devicePoint = self.previewLayer?.captureDevicePointConverted(fromLayerPoint: tap.location(in: tap.view)) else {
+            return
         }
 
         do {
-            try device.lockForConfiguration()
-            defer { device.unlockForConfiguration() }
-
-            let focusMode = AVCaptureDevice.FocusMode.autoFocus
-            if device.isFocusPointOfInterestSupported && device.isFocusModeSupported(focusMode) {
-                device.focusPointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
-                device.focusMode = focusMode
-            }
-            // Skip exposure point if locked
-            if device.exposureMode != .locked {
-                let exposureMode = AVCaptureDevice.ExposureMode.autoExpose
-                if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(exposureMode) {
-                    device.exposurePointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
-                    device.exposureMode = exposureMode
-                    device.setExposureTargetBias(0.0) { _ in }
-                }
-            }
-
-            // Turn on subject area monitor for switch to continuous focus if needed
-            device.isSubjectAreaChangeMonitoringEnabled = true
-
+            try self.setFocus(
+                at: devicePoint,
+                showIndicator: !self.disableFocusIndicator,
+                in: tap.view
+            )
         } catch {
             debugPrint(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.8.0"
+    private let pluginVersion: String = "8.9.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: "getWhiteBalanceModes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getWhiteBalanceMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setWhiteBalanceMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getSupportedVideoFrameRates", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getVideoFrameRate", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setVideoFrameRate", returnType: CAPPluginReturnPromise),
@@ -2392,6 +2395,58 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    // MARK: - White Balance Bridge
+
+    @objc func getWhiteBalanceModes(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let modes = try self.cameraController.getWhiteBalanceModes()
+            call.resolve(["modes": modes])
+        } catch {
+            call.reject("Failed to get white balance modes: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getWhiteBalanceMode(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let mode = try self.cameraController.getWhiteBalanceMode()
+            call.resolve(["mode": mode])
+        } catch {
+            call.reject("Failed to get white balance mode: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setWhiteBalanceMode(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        guard let mode = call.getString("mode") else {
+            call.reject("mode parameter is required")
+            return
+        }
+        let normalized = mode.uppercased()
+        let allowedModes: Set<String> = ["AUTO", "LOCK", "CONTINUOUS"]
+        guard allowedModes.contains(normalized) else {
+            let allowedList = Array(allowedModes).sorted().joined(separator: ", ")
+            call.reject("Invalid white balance mode: \(mode). Allowed values: \(allowedList)")
+            return
+        }
+        do {
+            try self.cameraController.setWhiteBalanceMode(mode: normalized)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set white balance mode: \(error.localizedDescription)")
+        }
+    }
+
     // MARK: - Exposure Bridge
 
     @objc func getExposureModes(_ call: CAPPluginCall) {

package/package.json

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