@capgo/camera-preview 8.8.1 → 8.9.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -623,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()
@@ -1004,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
@@ -2721,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:

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.1"
+    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.1",
+  "version": "8.9.0",
   "description": "Camera preview",
   "license": "MPL-2.0",
   "repository": {