@capgo/camera-preview 7.13.11 → 7.14.3

package/android/.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1756902493462</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

package/android/src/main/java/com/ahm/capacitor/camera/preview/CameraXView.java

@@ -51,6 +51,7 @@ import androidx.camera.core.MeteringPoint;
 import androidx.camera.core.MeteringPointFactory;
 import androidx.camera.core.Preview;
 import androidx.camera.core.ResolutionInfo;
+import androidx.camera.core.TorchState;
 import androidx.camera.core.UseCase;
 import androidx.camera.core.ZoomState;
 import androidx.camera.core.resolutionselector.AspectRatioStrategy;
@@ -2321,7 +2322,8 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     try {
       boolean hasFlash = camera.getCameraInfo().hasFlashUnit();
       if (hasFlash) {
-        return Arrays.asList("off", "on", "auto");
+        // Include torch for devices with a flash unit
+        return Arrays.asList("off", "on", "auto", "torch");
       } else {
         return Collections.singletonList("off");
       }
@@ -2332,6 +2334,16 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   }
 
   public String getFlashMode() {
+    // If torch is enabled, report torch regardless of ImageCapture flash mode
+    try {
+      if (camera != null) {
+        Integer torch = camera.getCameraInfo().getTorchState().getValue();
+        if (torch != null && torch == TorchState.ON) {
+          return "torch";
+        }
+      }
+    } catch (Exception ignore) {}
+
     switch (currentFlashMode) {
       case ImageCapture.FLASH_MODE_ON:
         return "on";
@@ -2343,6 +2355,35 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
   }
 
   public void setFlashMode(String mode) {
+    // Handle torch separately via CameraControl
+    if ("torch".equals(mode)) {
+      try {
+        if (camera != null) {
+          camera.getCameraControl().enableTorch(true);
+        }
+      } catch (Exception e) {
+        Log.e(TAG, "setFlashMode: Failed to enable torch", e);
+      }
+      // Keep ImageCapture flash mode OFF to avoid conflicts with torch
+      currentFlashMode = ImageCapture.FLASH_MODE_OFF;
+      if (imageCapture != null) {
+        imageCapture.setFlashMode(ImageCapture.FLASH_MODE_OFF);
+      }
+      if (sampleImageCapture != null) {
+        sampleImageCapture.setFlashMode(ImageCapture.FLASH_MODE_OFF);
+      }
+      return;
+    }
+
+    // For non-torch modes, ensure torch is disabled
+    try {
+      if (camera != null) {
+        camera.getCameraControl().enableTorch(false);
+      }
+    } catch (Exception e) {
+      Log.w(TAG, "setFlashMode: Failed to disable torch", e);
+    }
+
     int flashMode;
     switch (mode) {
       case "on":

package/ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift

@@ -3,6 +3,39 @@ import UIKit
 import CoreLocation
 
 class CameraController: NSObject {
+    private func getVideoOrientation() -> AVCaptureVideoOrientation {
+        var orientation: AVCaptureVideoOrientation = .portrait
+        if Thread.isMainThread {
+            if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
+                switch windowScene.interfaceOrientation {
+                case .portrait: orientation = .portrait
+                case .landscapeLeft: orientation = .landscapeLeft
+                case .landscapeRight: orientation = .landscapeRight
+                case .portraitUpsideDown: orientation = .portraitUpsideDown
+                case .unknown: fallthrough
+                @unknown default: orientation = .portrait
+                }
+            }
+        } else {
+            let semaphore = DispatchSemaphore(value: 0)
+            DispatchQueue.main.async {
+                if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
+                    switch windowScene.interfaceOrientation {
+                    case .portrait: orientation = .portrait
+                    case .landscapeLeft: orientation = .landscapeLeft
+                    case .landscapeRight: orientation = .landscapeRight
+                    case .portraitUpsideDown: orientation = .portraitUpsideDown
+                    case .unknown: fallthrough
+                    @unknown default: orientation = .portrait
+                    }
+                }
+                semaphore.signal()
+            }
+            _ = semaphore.wait(timeout: .now() + 0.1) // Timeout after 100ms to prevent deadlocks
+        }
+        return orientation
+    }
+
     var captureSession: AVCaptureSession?
     var disableFocusIndicator: Bool = false
 
@@ -101,25 +134,9 @@ class CameraController: NSObject {
         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
-        }
+        // Get orientation in a thread-safe way
+        let orientation = self.getVideoOrientation()
+        let isPortrait = (orientation == .portrait || orientation == .portraitUpsideDown)
 
         let originalWidth = CGFloat(components[0])
         let originalHeight = CGFloat(components[1])
@@ -180,7 +197,7 @@ extension CameraController {
         // Log all found devices for debugging
 
         for camera in cameras {
-            let constituentCount = camera.isVirtualDevice ? camera.constituentDevices.count : 1
+            _ = camera.isVirtualDevice ? camera.constituentDevices.count : 1
 
         }
 
@@ -257,20 +274,43 @@ extension CameraController {
             let layer = AVCaptureVideoPreviewLayer()
             // Configure orientation immediately
             if let connection = layer.connection {
-                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
+                // 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
+                            }
+                        }
                     }
                 }
             }
@@ -283,7 +323,7 @@ extension CameraController {
     }
 
     func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, initialZoomLevel: Float?, disableFocusIndicator: Bool = false, completionHandler: @escaping (Error?) -> Void) {
-        print("[CameraPreview] 🎬 Starting prepare - position: \(cameraPosition), deviceId: \(deviceId ?? "nil"), disableAudio: \(disableAudio), cameraMode: \(cameraMode), aspectRatio: \(aspectRatio ?? "nil"), zoom: \(initialZoomLevel)")
+        print("[CameraPreview] 🎬 Starting prepare - position: \(cameraPosition), deviceId: \(deviceId ?? "nil"), disableAudio: \(disableAudio), cameraMode: \(cameraMode), aspectRatio: \(aspectRatio ?? "nil"), zoom: \(initialZoomLevel ?? 1)")
 
         DispatchQueue.global(qos: .userInitiated).async { [weak self] in
             guard let self = self else {
@@ -321,18 +361,8 @@ extension CameraController {
 
                 // Add ALL outputs BEFORE starting session to avoid flashes from reconfiguration
 
-                // Determine initial orientation once
-                var videoOrientation: AVCaptureVideoOrientation = .portrait
-                if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
-                    switch windowScene.interfaceOrientation {
-                    case .portrait: videoOrientation = .portrait
-                    case .landscapeLeft: videoOrientation = .landscapeLeft
-                    case .landscapeRight: videoOrientation = .landscapeRight
-                    case .portraitUpsideDown: videoOrientation = .portraitUpsideDown
-                    case .unknown: fallthrough
-                    @unknown default: videoOrientation = .portrait
-                    }
-                }
+                // Get orientation in a thread-safe way
+                let videoOrientation = self.getVideoOrientation()
 
                 // Add data output for preview
                 if let dataOutput = self.dataOutput, captureSession.canAddOutput(dataOutput) {
@@ -706,25 +736,8 @@ extension CameraController {
     }
 
     func updateVideoOrientation() {
-        // Get orientation on the current thread to avoid blocking
-        var videoOrientation: AVCaptureVideoOrientation = .portrait
-
-        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
-            switch windowScene.interfaceOrientation {
-            case .portrait:
-                videoOrientation = .portrait
-            case .landscapeLeft:
-                videoOrientation = .landscapeLeft
-            case .landscapeRight:
-                videoOrientation = .landscapeRight
-            case .portraitUpsideDown:
-                videoOrientation = .portraitUpsideDown
-            case .unknown:
-                fallthrough
-            @unknown default:
-                videoOrientation = .portrait
-            }
-        }
+        // Get orientation in a thread-safe way
+        let videoOrientation = self.getVideoOrientation()
 
         // Apply orientation asynchronously on main thread
         let updateBlock = { [weak self] in
@@ -768,102 +781,131 @@ extension CameraController {
         }
     }
 
+    // Helper: pick the best preset the TARGET device supports for a given aspect ratio
+    private func bestPreset(for aspectRatio: String?, on device: AVCaptureDevice) -> AVCaptureSession.Preset {
+        // 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
+            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 }
+            if device.supportsSessionPreset(.hd1280x720) { return .hd1280x720 }
+            return .vga640x480
+        }
+    }
+
     func switchCameras() throws {
         guard let currentCameraPosition = currentCameraPosition,
               let captureSession = self.captureSession else {
             throw CameraControllerError.captureSessionIsMissing
         }
 
-        // Ensure we have the necessary cameras
-        guard (currentCameraPosition == .front && rearCamera != nil) ||
-                (currentCameraPosition == .rear && frontCamera != nil) else {
-            throw CameraControllerError.noCamerasAvailable
+        // Determine the device we’re switching TO
+        let targetDevice: AVCaptureDevice
+        switch currentCameraPosition {
+        case .front:
+            guard let rear = rearCamera else { throw CameraControllerError.invalidOperation }
+            targetDevice = rear
+        case .rear:
+            guard let front = frontCamera else { throw CameraControllerError.invalidOperation }
+            targetDevice = front
         }
 
-        // Store the current running state
-        let wasRunning = captureSession.isRunning
-        if wasRunning {
-            captureSession.stopRunning()
-        }
+        // Compute the desired preset for the TARGET device up front
+        let desiredPreset = bestPreset(for: self.requestedAspectRatio, on: targetDevice)
 
-        // Begin configuration
+        // Keep the preview layer visually stable during the swap
+        let savedPreviewFrame = self.previewLayer?.frame
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        self.previewLayer?.connection?.isEnabled = false  // reduce visible glitching
+
+        // No need to stopRunning; Apple recommends reconfiguring within begin/commit
         captureSession.beginConfiguration()
         defer {
             captureSession.commitConfiguration()
-            // Restart the session if it was running before
-            if wasRunning {
-                DispatchQueue.global(qos: .userInitiated).async {
-                    captureSession.startRunning()
-                }
+            self.previewLayer?.connection?.isEnabled = true
+            // Restore frame (it shouldn't change, but this ensures zero animation)
+            if let f = savedPreviewFrame { self.previewLayer?.frame = f }
+            CATransaction.commit()
+            DispatchQueue.main.async { [weak self] in
+                self?.setDefaultZoomAfterFlip()   // normalize zoom (UI 1.0x)
             }
         }
 
-        // Store audio input if it exists
-        let audioInput = captureSession.inputs.first { ($0 as? AVCaptureDeviceInput)?.device.hasMediaType(.audio) ?? false }
+        // Preserve audio input (if any)
+        let existingAudioInput = captureSession.inputs.first {
+            ($0 as? AVCaptureDeviceInput)?.device.hasMediaType(.audio) ?? false
+        }
 
-        // Remove only video inputs
-        captureSession.inputs.forEach { input in
+        // Remove ONLY video inputs
+        for input in captureSession.inputs {
             if (input as? AVCaptureDeviceInput)?.device.hasMediaType(.video) ?? false {
                 captureSession.removeInput(input)
             }
         }
 
-        // Configure new camera
-        switch currentCameraPosition {
-        case .front:
-            guard let rearCamera = rearCamera else {
-                throw CameraControllerError.invalidOperation
-            }
-
-            // Configure rear camera
-            try rearCamera.lockForConfiguration()
-            if rearCamera.isFocusModeSupported(.continuousAutoFocus) {
-                rearCamera.focusMode = .continuousAutoFocus
-            }
-            rearCamera.unlockForConfiguration()
-
-            if let newInput = try? AVCaptureDeviceInput(device: rearCamera),
-               captureSession.canAddInput(newInput) {
-                captureSession.addInput(newInput)
-                rearCameraInput = newInput
-                self.currentCameraPosition = .rear
-            } else {
-                throw CameraControllerError.invalidOperation
-            }
-        case .rear:
-            guard let frontCamera = frontCamera else {
-                throw CameraControllerError.invalidOperation
+        // Only downgrade to a safe preset if the TARGET cannot support the CURRENT one
+        let currentPreset = captureSession.sessionPreset
+        let targetSupportsCurrent = targetDevice.supportsSessionPreset(currentPreset)
+        if !targetSupportsCurrent {
+            // Choose the first preset supported by BOTH the target device and the session
+            let fallbacks: [AVCaptureSession.Preset] =
+                (self.requestedAspectRatio == "16:9")
+                ? [.hd4K3840x2160, .hd1920x1080, .hd1280x720, .high, .photo, .vga640x480]
+                : [.photo, .high, .hd1920x1080, .hd1280x720, .vga640x480]
+            for p in fallbacks {
+                if targetDevice.supportsSessionPreset(p), captureSession.canSetSessionPreset(p) {
+                    captureSession.sessionPreset = p
+                    break
+                }
             }
+        }
 
-            // Configure front camera
-            try frontCamera.lockForConfiguration()
-            if frontCamera.isFocusModeSupported(.continuousAutoFocus) {
-                frontCamera.focusMode = .continuousAutoFocus
-            }
-            frontCamera.unlockForConfiguration()
+        // Add the new video input
+        let newInput = try AVCaptureDeviceInput(device: targetDevice)
+        guard captureSession.canAddInput(newInput) else {
+            throw CameraControllerError.invalidOperation
+        }
+        captureSession.addInput(newInput)
 
-            if let newInput = try? AVCaptureDeviceInput(device: frontCamera),
-               captureSession.canAddInput(newInput) {
-                captureSession.addInput(newInput)
-                frontCameraInput = newInput
-                self.currentCameraPosition = .front
-            } else {
-                throw CameraControllerError.invalidOperation
-            }
+        // Update pointers / focus defaults
+        if targetDevice.position == .front {
+            self.frontCameraInput = newInput
+            self.currentCameraPosition = .front
+        } else {
+            self.rearCameraInput = newInput
+            self.currentCameraPosition = .rear
+        }
+        // (Lightweight focus config; non-fatal on failure)
+        try? targetDevice.lockForConfiguration()
+        if targetDevice.isFocusModeSupported(.continuousAutoFocus) {
+            targetDevice.focusMode = .continuousAutoFocus
         }
+        targetDevice.unlockForConfiguration()
 
-        // Re-add audio input if it existed
-        if let audioInput = audioInput, captureSession.canAddInput(audioInput) {
+        // Restore audio input if it existed
+        if let audioInput = existingAudioInput, captureSession.canAddInput(audioInput) {
             captureSession.addInput(audioInput)
         }
 
-        // Update video orientation
-        self.updateVideoOrientation()
-
-        // Set default 1.0 zoom level after camera switch to prevent iOS 18+ zoom jumps
-        DispatchQueue.main.async { [weak self] in
-            self?.setDefaultZoomAfterFlip()
+        // Now apply the BEST preset for the target device & requested AR
+        if captureSession.sessionPreset != desiredPreset,
+           targetDevice.supportsSessionPreset(desiredPreset),
+           captureSession.canSetSessionPreset(desiredPreset) {
+            captureSession.sessionPreset = desiredPreset
         }
+
+        // Keep orientation correct
+        self.updateVideoOrientation()
     }
 
     func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
@@ -874,11 +916,9 @@ extension CameraController {
 
         let settings = AVCapturePhotoSettings()
         // Configure photo capture settings optimized for speed
-        if #available(iOS 13.0, *) {
-            // Only use high res if explicitly requesting large dimensions
-            let shouldUseHighRes = width.map { $0 > 1920 } ?? false || height.map { $0 > 1920 } ?? false
-            settings.isHighResolutionPhotoEnabled = shouldUseHighRes
-        }
+        // Only use high res if explicitly requesting large dimensions
+        let shouldUseHighRes = width.map { $0 > 1920 } ?? false || height.map { $0 > 1920 } ?? false
+        settings.isHighResolutionPhotoEnabled = shouldUseHighRes
         if #available(iOS 15.0, *) {
             // Prioritize speed over quality
             settings.photoQualityPrioritization = .speed
@@ -2207,11 +2247,11 @@ extension UIImage {
         // Flip image one more time if needed to, this is to prevent flipped image
         switch imageOrientation {
         case .upMirrored, .downMirrored:
-            transform.translatedBy(x: size.width, y: 0)
-            transform.scaledBy(x: -1, y: 1)
+            _ = transform.translatedBy(x: size.width, y: 0)
+            _ = transform.scaledBy(x: -1, y: 1)
         case .leftMirrored, .rightMirrored:
-            transform.translatedBy(x: size.height, y: 0)
-            transform.scaledBy(x: -1, y: 1)
+            _ = transform.translatedBy(x: size.height, y: 0)
+            _ = transform.scaledBy(x: -1, y: 1)
         case .up, .down, .left, .right:
             break
         @unknown default:

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -8,26 +8,22 @@ import MobileCoreServices
 
 extension UIWindow {
     static var isLandscape: Bool {
-        if #available(iOS 13.0, *) {
-            return UIApplication.shared.windows
-                .first?
-                .windowScene?
-                .interfaceOrientation
-                .isLandscape ?? false
-        } else {
-            return UIApplication.shared.statusBarOrientation.isLandscape
-        }
+        // iOS 14+ only: derive from the active window scene's interface orientation
+        let scene = UIApplication.shared
+            .connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .first { $0.activationState == .foregroundActive }
+
+        return scene?.interfaceOrientation.isLandscape ?? false
     }
     static var isPortrait: Bool {
-        if #available(iOS 13.0, *) {
-            return UIApplication.shared.windows
-                .first?
-                .windowScene?
-                .interfaceOrientation
-                .isPortrait ?? false
-        } else {
-            return UIApplication.shared.statusBarOrientation.isPortrait
-        }
+        // iOS 14+ only: derive from the active window scene's interface orientation
+        let scene = UIApplication.shared
+            .connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .first { $0.activationState == .foregroundActive }
+
+        return scene?.interfaceOrientation.isPortrait ?? false
     }
 }
 
@@ -142,7 +138,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         guard let webView = self.webView else { return }
 
         DispatchQueue.main.async {
-            let startTransparency = CFAbsoluteTimeGetCurrent()
+            _ = CFAbsoluteTimeGetCurrent()
 
             // Define a recursive function to traverse the view hierarchy
             func makeSubviewsTransparent(_ view: UIView) {
@@ -225,15 +221,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             let displayMultiplier = self.cameraController.getDisplayZoomMultiplier()
             var teleStep: Float
 
-            if #available(iOS 13.0, *) {
-                let switchFactors = device.virtualDeviceSwitchOverVideoZoomFactors
-                if !switchFactors.isEmpty {
-                    // Choose the highest switch-over factor (typically the wide->tele threshold)
-                    let maxSwitch = switchFactors.map { $0.floatValue }.max() ?? Float(device.maxAvailableVideoZoomFactor)
-                    teleStep = maxSwitch * displayMultiplier
-                } else {
-                    teleStep = Float(device.maxAvailableVideoZoomFactor) * displayMultiplier
-                }
+            let switchFactors = device.virtualDeviceSwitchOverVideoZoomFactors
+            if !switchFactors.isEmpty {
+                // Choose the highest switch-over factor (typically the wide->tele threshold)
+                let maxSwitch = switchFactors.map { $0.floatValue }.max() ?? Float(device.maxAvailableVideoZoomFactor)
+                teleStep = maxSwitch * displayMultiplier
             } else {
                 teleStep = Float(device.maxAvailableVideoZoomFactor) * displayMultiplier
             }
@@ -268,15 +260,9 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     }
 
     @objc func rotated() {
-        guard let previewView = self.previewView,
-              let posX = self.posX,
-              let posY = self.posY,
-              let width = self.width,
-              let heightValue = self.height else {
+        guard let previewView = self.previewView else {
             return
         }
-        let paddingBottom = self.paddingBottom ?? 0
-        let height = heightValue - paddingBottom
 
         // Handle auto-centering during rotation
         // Always use the factorized method for consistent positioning
@@ -786,7 +772,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     }
 
     @objc func capture(_ call: CAPPluginCall) {
-        print("[CameraPreview] capture called with options: \(call.options)")
+        print("[CameraPreview] capture called with options: \(call.options ?? [:])")
         let withExifLocation = call.getBool("withExifLocation", false)
         print("[CameraPreview] capture called, withExifLocation: \(withExifLocation)")
 
@@ -857,7 +843,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
     private func performCapture(call: CAPPluginCall) {
         print("[CameraPreview] performCapture called")
-        print("[CameraPreview] Call parameters: \(call.options)")
+        print("[CameraPreview] Call parameters: \(call.options ?? [:])")
         let quality = call.getFloat("quality", 85)
         let saveToGallery = call.getBool("saveToGallery", false)
         let withExifLocation = call.getBool("withExifLocation", false)
@@ -1016,8 +1002,13 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                     notchInset = safeAreaInsets.top
                 }
             } else {
-                // Fallback: use status bar height as approximation
-                notchInset = UIApplication.shared.statusBarFrame.height
+                // Fallback for iOS 14+: try to derive from any available window's safe area
+                let anyWindow = UIApplication.shared
+                    .connectedScenes
+                    .compactMap { $0 as? UIWindowScene }
+                    .flatMap { $0.windows }
+                    .first
+                notchInset = anyWindow?.safeAreaInsets.top ?? 0
             }
 
             let result: [String: Any] = [
@@ -1681,7 +1672,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     }
 
     private func updateCameraFrame() {
-        guard let width = self.width, let height = self.height, let posX = self.posX, let posY = self.posY else {
+        guard let posX = self.posX, let posY = self.posY else {
             return
         }
 
@@ -1940,7 +1931,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     private var lastOrientation: String?
 
     @objc private func handleOrientationChange() {
-        var currentOrientation = self.currentOrientationString()
+        let currentOrientation = self.currentOrientationString()
         if currentOrientation == "portrait-upside-down" || currentOrientation == lastOrientation {
             return
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/camera-preview",
-  "version": "7.13.11",
+  "version": "7.14.3",
   "description": "Camera preview",
   "license": "MIT",
   "repository": {