@capgo/camera-preview 7.6.1-alpha.3 → 7.7.0

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -100,48 +100,7 @@ class CameraController: NSObject {
     private func parseAspectRatio(_ aspectRatio: String) -> (width: CGFloat, height: CGFloat)? {
         let components = aspectRatio.split(separator: ":").compactMap { Float(String($0)) }
         guard components.count == 2 else { return nil }
-
-        // Check if device is in portrait orientation by looking at the current interface orientation
-        var isPortrait = false
-        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
-            print("[CameraPreview] parseAspectRatio - windowScene.interfaceOrientation: \(windowScene.interfaceOrientation)")
-            switch windowScene.interfaceOrientation {
-            case .portrait, .portraitUpsideDown:
-                isPortrait = true
-            case .landscapeLeft, .landscapeRight:
-                isPortrait = false
-            case .unknown:
-                // Fallback to device orientation
-                isPortrait = UIDevice.current.orientation.isPortrait
-            @unknown default:
-                isPortrait = UIDevice.current.orientation.isPortrait
-            }
-        } else {
-            // Fallback to device orientation
-            isPortrait = UIDevice.current.orientation.isPortrait
-        }
-
-        let originalWidth = CGFloat(components[0])
-        let originalHeight = CGFloat(components[1])
-        print("[CameraPreview] parseAspectRatio - isPortrait: \(isPortrait) originalWidth: \(originalWidth) originalHeight: \(originalHeight)")
-
-        let finalWidth: CGFloat
-        let finalHeight: CGFloat
-
-        if isPortrait {
-            // For portrait mode, swap width and height to maintain portrait orientation
-            // 4:3 becomes 3:4, 16:9 becomes 9:16
-            finalWidth = originalHeight
-            finalHeight = originalWidth
-            print("[CameraPreview] parseAspectRatio - Portrait mode: \(aspectRatio) -> \(finalWidth):\(finalHeight) (ratio: \(finalWidth/finalHeight))")
-        } else {
-            // For landscape mode, keep original orientation
-            finalWidth = originalWidth
-            finalHeight = originalHeight
-            print("[CameraPreview] parseAspectRatio - Landscape mode: \(aspectRatio) -> \(finalWidth):\(finalHeight) (ratio: \(finalWidth/finalHeight))")
-        }
-
-        return (width: finalWidth, height: finalHeight)
+        return (width: CGFloat(components[0]), height: CGFloat(components[1]))
     }
 }
 
@@ -381,38 +340,6 @@ extension CameraController {
         }
     }
 
-    /// Update the requested aspect ratio at runtime and reconfigure session/preview accordingly
-    func updateAspectRatio(_ aspectRatio: String?) {
-        // Update internal state
-        self.requestedAspectRatio = aspectRatio
-
-        // Reconfigure session preset to match the new ratio for optimal capture resolution
-        if let captureSession = self.captureSession {
-            captureSession.beginConfiguration()
-            self.configureSessionPreset(for: aspectRatio)
-            captureSession.commitConfiguration()
-        }
-
-        // Update preview layer geometry on the main thread
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self, let previewLayer = self.previewLayer else { return }
-            if let superlayer = previewLayer.superlayer {
-                let bounds = superlayer.bounds
-                if let aspect = aspectRatio {
-                    let frame = self.calculateAspectRatioFrame(for: aspect, in: bounds)
-                    previewLayer.frame = frame
-                    previewLayer.videoGravity = .resizeAspectFill
-                } else {
-                    previewLayer.frame = bounds
-                    previewLayer.videoGravity = .resizeAspect
-                }
-
-                // Keep grid overlay in sync with preview
-                self.gridOverlayView?.frame = previewLayer.frame
-            }
-        }
-    }
-
     private func setInitialZoom(level: Float?) {
         let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
         guard let device = device else {
@@ -502,6 +429,20 @@ extension CameraController {
                 }
             }
         }
+
+        // Set default exposure mode to CONTINUOUS when starting the camera
+        do {
+            try finalDevice.lockForConfiguration()
+            if finalDevice.isExposureModeSupported(.continuousAutoExposure) {
+                finalDevice.exposureMode = .continuousAutoExposure
+                if finalDevice.isExposurePointOfInterestSupported {
+                    finalDevice.exposurePointOfInterest = CGPoint(x: 0.5, y: 0.5)
+                }
+            }
+            finalDevice.unlockForConfiguration()
+        } catch {
+            // Non-fatal; continue without setting default exposure
+        }
     }
 
     func displayPreview(on view: UIView) throws {
@@ -603,7 +544,7 @@ extension CameraController {
     }
 
     private func updateVideoOrientationOnMainThread() {
-        var videoOrientation: AVCaptureVideoOrientation
+        let videoOrientation: AVCaptureVideoOrientation
 
         // Use window scene interface orientation
         if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
@@ -754,7 +695,7 @@ extension CameraController {
     }
 
     func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
-        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1), requestedAspectRatio: \(self.requestedAspectRatio ?? "nil")")
+        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1)")
 
         guard let photoOutput = self.photoOutput else {
             completion(nil, nil, nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
@@ -823,9 +764,18 @@ extension CameraController {
                 print("[CameraPreview] Resized to max dimensions: \(finalImage.size.width)x\(finalImage.size.height)")
             } else if let aspectRatio = self.requestedAspectRatio {
                 // No max dimensions specified, but aspect ratio is specified
-                // Always apply aspect ratio cropping to ensure correct orientation
-                finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
-                print("[CameraPreview] Applied aspect ratio cropping for \(aspectRatio): \(finalImage.size.width)x\(finalImage.size.height)")
+                // If we used session preset (low-res), image should already be correct aspect ratio
+                // If we used high-res (shouldn't happen without max dimensions), crop it
+                let imageAspectRatio = image.size.width / image.size.height
+                if let targetRatio = self.parseAspectRatio(aspectRatio) {
+                    let targetAspectRatio = targetRatio.width / targetRatio.height
+
+                    // Allow small tolerance for aspect ratio comparison
+                    if abs(imageAspectRatio - targetAspectRatio) > 0.01 {
+                        finalImage = self.cropImageToAspectRatio(image: image, aspectRatio: aspectRatio) ?? image
+                        print("[CameraPreview] Cropped to match aspect ratio \(aspectRatio): \(finalImage.size.width)x\(finalImage.size.height)")
+                    }
+                }
             }
 
             completion(finalImage, photoData, metadata, nil)
@@ -907,27 +857,13 @@ extension CameraController {
 
     func cropImageToAspectRatio(image: UIImage, aspectRatio: String) -> UIImage? {
         guard let ratio = parseAspectRatio(aspectRatio) else {
-            print("[CameraPreview] cropImageToAspectRatio - Failed to parse aspect ratio: \(aspectRatio)")
             return image
         }
 
-        // Only normalize the image orientation if it's not already correct
-        let normalizedImage: UIImage
-        if image.imageOrientation == .up {
-            normalizedImage = image
-            print("[CameraPreview] cropImageToAspectRatio - Image already has correct orientation")
-        } else {
-            normalizedImage = image.fixedOrientation() ?? image
-            print("[CameraPreview] cropImageToAspectRatio - Normalized image orientation from \(image.imageOrientation.rawValue) to .up")
-        }
-
-        let imageSize = normalizedImage.size
+        let imageSize = image.size
         let imageAspectRatio = imageSize.width / imageSize.height
         let targetAspectRatio = ratio.width / ratio.height
 
-        print("[CameraPreview] cropImageToAspectRatio - Original image: \(imageSize.width)x\(imageSize.height) (ratio: \(imageAspectRatio))")
-        print("[CameraPreview] cropImageToAspectRatio - Target ratio: \(ratio.width):\(ratio.height) (ratio: \(targetAspectRatio))")
-
         var cropRect: CGRect
 
         if imageAspectRatio > targetAspectRatio {
@@ -935,36 +871,19 @@ extension CameraController {
             let targetWidth = imageSize.height * targetAspectRatio
             let xOffset = (imageSize.width - targetWidth) / 2
             cropRect = CGRect(x: xOffset, y: 0, width: targetWidth, height: imageSize.height)
-            print("[CameraPreview] cropImageToAspectRatio - Horizontal crop: \(cropRect)")
         } else {
             // Image is taller than target - crop vertically (center crop)
             let targetHeight = imageSize.width / targetAspectRatio
             let yOffset = (imageSize.height - targetHeight) / 2
             cropRect = CGRect(x: 0, y: yOffset, width: imageSize.width, height: targetHeight)
-            print("[CameraPreview] cropImageToAspectRatio - Vertical crop: \(cropRect) - Target height: \(targetHeight)")
         }
 
-        // Validate crop rect is within image bounds
-        if cropRect.minX < 0 || cropRect.minY < 0 ||
-           cropRect.maxX > imageSize.width || cropRect.maxY > imageSize.height {
-            print("[CameraPreview] cropImageToAspectRatio - Warning: Crop rect \(cropRect) exceeds image bounds \(imageSize)")
-            // Adjust crop rect to fit within image bounds
-            cropRect = cropRect.intersection(CGRect(origin: .zero, size: imageSize))
-            print("[CameraPreview] cropImageToAspectRatio - Adjusted crop rect: \(cropRect)")
-        }
-
-        guard let cgImage = normalizedImage.cgImage,
+        guard let cgImage = image.cgImage,
               let croppedCGImage = cgImage.cropping(to: cropRect) else {
-            print("[CameraPreview] cropImageToAspectRatio - Failed to crop image")
             return nil
         }
 
-        let croppedImage = UIImage(cgImage: croppedCGImage, scale: normalizedImage.scale, orientation: .up)
-        let finalAspectRatio = croppedImage.size.width / croppedImage.size.height
-        print("[CameraPreview] cropImageToAspectRatio - Final cropped image: \(croppedImage.size.width)x\(croppedImage.size.height) (ratio: \(finalAspectRatio))")
-
-        // Create the cropped image with normalized orientation
-        return croppedImage
+        return UIImage(cgImage: croppedCGImage, scale: image.scale, orientation: image.imageOrientation)
     }
 
     func cropImageToMatchPreview(image: UIImage, previewLayer: AVCaptureVideoPreviewLayer) -> UIImage? {
@@ -1262,17 +1181,12 @@ extension CameraController {
                 }
             }
 
-            // Also set exposure point if supported
-            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
-                device.exposureMode = .autoExpose
-                device.exposurePointOfInterest = centerPoint
-            } else if device.isExposureModeSupported(.continuousAutoExposure) {
-                device.exposureMode = .continuousAutoExposure
-                if device.isExposurePointOfInterestSupported {
+            if device.isExposurePointOfInterestSupported {
+                let exposureMode = try getExposureMode()
+                if exposureMode == "AUTO" || exposureMode == "CONTINUOUS" {
                     device.exposurePointOfInterest = centerPoint
                 }
             }
-
             device.unlockForConfiguration()
         } catch {
             // Silently ignore errors during autofocus
@@ -1327,6 +1241,7 @@ extension CameraController {
             // Also set exposure point if supported
             if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
                 device.exposureMode = .autoExpose
+                device.setExposureTargetBias(0.0) { _ in }
                 device.exposurePointOfInterest = point
             }
 
@@ -1533,6 +1448,172 @@ extension CameraController {
         self.firstFrameReadyCallback = nil
     }
 
+    // MARK: - Exposure Controls
+
+    func getExposureModes() 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.isExposureModeSupported(.locked) { modes.append("LOCK") }
+        if device.isExposureModeSupported(.autoExpose) { modes.append("AUTO") }
+        if device.isExposureModeSupported(.continuousAutoExposure) { modes.append("CONTINUOUS") }
+        if device.isExposureModeSupported(.custom) { modes.append("CUSTOM") }
+        return modes
+    }
+
+    func getExposureMode() 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.exposureMode {
+        case .locked:
+            return "LOCK"
+        case .autoExpose:
+            return "AUTO"
+        case .continuousAutoExposure:
+            return "CONTINUOUS"
+        case .custom:
+            return "CUSTOM"
+        @unknown default:
+            return "CONTINUOUS"
+        }
+    }
+
+    func setExposureMode(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.ExposureMode?
+        switch normalized {
+        case "LOCK":
+            desiredMode = .locked
+        case "AUTO":
+            desiredMode = .autoExpose
+        case "CONTINUOUS":
+            desiredMode = .continuousAutoExposure
+        case "CUSTOM":
+            desiredMode = .custom
+        default:
+            desiredMode = .continuousAutoExposure
+        }
+
+        guard let finalMode = desiredMode, device.isExposureModeSupported(finalMode) else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        do {
+            try device.lockForConfiguration()
+            device.exposureMode = finalMode
+            // Reset EV to 0 when switching to AUTO or CONTINUOUS
+            if finalMode == .autoExpose || finalMode == .continuousAutoExposure {
+                device.setExposureTargetBias(0.0) { _ in }
+            }
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
+    func getExposureCompensationRange() throws -> (min: Float, max: Float, step: Float) {
+        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
+        }
+
+        // iOS reports EV bias directly; typical step is 0.1 or 0.125 depending on device
+        // There's no direct API for step; approximate as 0.1 for compatibility
+        let step: Float = 0.1
+        return (min: device.minExposureTargetBias, max: device.maxExposureTargetBias, step: step)
+    }
+
+    func getExposureCompensation() throws -> Float {
+        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
+        }
+
+        return device.exposureTargetBias
+    }
+
+    func setExposureCompensation(_ value: Float) 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 clamped = max(device.minExposureTargetBias, min(value, device.maxExposureTargetBias))
+
+        do {
+            try device.lockForConfiguration()
+            device.setExposureTargetBias(clamped) { _ in }
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
     func captureVideo() throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
             throw CameraControllerError.captureSessionIsMissing
@@ -1545,9 +1626,23 @@ extension CameraController {
             throw CameraControllerError.fileVideoOutputNotFound
         }
 
+        // 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)
+            } else {
+                captureSession.commitConfiguration()
+                throw CameraControllerError.invalidOperation
+            }
+            captureSession.commitConfiguration()
+        }
+
         // cpcp_video_A6C01203 - portrait
         //
         if let connection = fileVideoOutput.connection(with: .video) {
+            if connection.isEnabled == false { connection.isEnabled = true }
             switch UIDevice.current.orientation {
             case .landscapeRight:
                 connection.videoOrientation = .landscapeLeft
@@ -1626,6 +1721,7 @@ extension CameraController: UIGestureRecognizerDelegate {
             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 }
             }
         } catch {
             debugPrint(error)
@@ -1765,8 +1861,7 @@ extension CameraController: AVCapturePhotoCaptureDelegate {
         }
 
         // Pass through original file data and metadata so callers can preserve EXIF
-        // Don't call fixedOrientation() here - let the completion block handle it after cropping
-        self.photoCaptureCompletionBlock?(image, imageData, photo.metadata, nil)
+        self.photoCaptureCompletionBlock?(image.fixedOrientation(), imageData, photo.metadata, nil)
     }
 }
 

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -69,7 +69,14 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "setFocus", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "deleteFile", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getOrientation", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getSafeAreaInsets", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "getSafeAreaInsets", returnType: CAPPluginReturnPromise),
+        // Exposure control methods
+        CAPPluginMethod(name: "getExposureModes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getExposureMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setExposureMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getExposureCompensationRange", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getExposureCompensation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setExposureCompensation", returnType: CAPPluginReturnPromise)
 
     ]
     // Camera state tracking
@@ -101,8 +108,6 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
     // MARK: - Helper Methods for Aspect Ratio
 
-
-
     /// Parses aspect ratio string and returns the appropriate ratio for the current orientation
     private func parseAspectRatio(_ ratio: String, isPortrait: Bool) -> CGFloat {
         let parts = ratio.split(separator: ":").compactMap { Double($0) }
@@ -305,10 +310,6 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         self.aspectRatio = newAspectRatio
-
-        // Propagate to camera controller so capture output and preview align
-        self.cameraController.updateAspectRatio(newAspectRatio)
-
         DispatchQueue.main.async {
             call.resolve(self.rawSetAspectRatio())
         }
@@ -590,8 +591,6 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             return
         }
 
-
-
         AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
 
             guard granted else {
@@ -1804,6 +1803,113 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    // MARK: - Exposure Bridge
+
+    @objc func getExposureModes(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let modes = try self.cameraController.getExposureModes()
+            call.resolve(["modes": modes])
+        } catch {
+            call.reject("Failed to get exposure modes: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getExposureMode(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let mode = try self.cameraController.getExposureMode()
+            call.resolve(["mode": mode])
+        } catch {
+            call.reject("Failed to get exposure mode: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setExposureMode(_ 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
+        }
+        // Validate against allowed exposure modes before delegating
+        let normalized = mode.uppercased()
+        let allowedModes: Set<String> = ["AUTO", "LOCK", "CONTINUOUS", "CUSTOM"]
+        guard allowedModes.contains(normalized) else {
+            let allowedList = Array(allowedModes).sorted().joined(separator: ", ")
+            call.reject("Invalid exposure mode: \(mode). Allowed values: \(allowedList)")
+            return
+        }
+        do {
+            try self.cameraController.setExposureMode(mode: normalized)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set exposure mode: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getExposureCompensationRange(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let range = try self.cameraController.getExposureCompensationRange()
+            call.resolve(["min": range.min, "max": range.max, "step": range.step])
+        } catch {
+            call.reject("Failed to get exposure compensation range: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func getExposureCompensation(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        do {
+            let value = try self.cameraController.getExposureCompensation()
+            call.resolve(["value": value])
+        } catch {
+            call.reject("Failed to get exposure compensation: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setExposureCompensation(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+        guard var value = call.getFloat("value") else {
+            call.reject("value parameter is required")
+            return
+        }
+        do {
+            // Snap to valid range and step
+            var range = try self.cameraController.getExposureCompensationRange()
+            if range.step <= 0 { range.step = 0.1 }
+            let lo = min(range.min, range.max)
+            let hi = max(range.min, range.max)
+            // Clamp to [lo, hi]
+            value = max(lo, min(hi, value))
+            // Snap to nearest step
+            let steps = round((value - lo) / range.step)
+            let snapped = lo + steps * range.step
+
+            try self.cameraController.setExposureCompensation(snapped)
+            call.resolve()
+        } catch {
+            call.reject("Failed to set exposure compensation: \(error.localizedDescription)")
+        }
+    }
+
     @objc private func handleOrientationChange() {
         DispatchQueue.main.async {
             let result = self.rawSetAspectRatio()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.6.1-alpha.3",
+  "version": "7.7.0",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {