@capgo/camera-preview 7.4.0-alpha.3 → 7.4.0-alpha.32

package/ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift

@@ -55,6 +55,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getAvailableDevices", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getZoom", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getZoomButtonValues", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setZoom", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getFlashMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setDeviceId", returnType: CAPPluginReturnPromise),
@@ -65,7 +66,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         CAPPluginMethod(name: "getGridMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getPreviewSize", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setPreviewSize", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "setFocus", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "setFocus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "deleteFile", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getOrientation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSafeAreaInsets", returnType: CAPPluginReturnPromise)
+
     ]
     // Camera state tracking
     private var isInitializing: Bool = false
@@ -93,6 +98,44 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
     private var permissionCallID: String?
     private var waitingForLocation: Bool = false
 
+    // MARK: - Helper Methods for Aspect Ratio
+
+    /// Validates that aspectRatio and size (width/height) are not both set
+    private func validateAspectRatioParameters(aspectRatio: String?, width: Int?, height: Int?) -> String? {
+        if aspectRatio != nil && (width != nil || height != nil) {
+            return "Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start."
+        }
+        return nil
+    }
+
+    /// 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) }
+        guard parts.count == 2 else { return 1.0 }
+
+        // For camera (portrait), we want portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
+        return isPortrait ?
+            CGFloat(parts[1] / parts[0]) :
+            CGFloat(parts[0] / parts[1])
+    }
+
+    /// Calculates dimensions based on aspect ratio and available space
+    private func calculateDimensionsForAspectRatio(_ aspectRatio: String, availableWidth: CGFloat, availableHeight: CGFloat, isPortrait: Bool) -> (width: CGFloat, height: CGFloat) {
+        let ratio = parseAspectRatio(aspectRatio, isPortrait: isPortrait)
+
+        // Calculate maximum size that fits the aspect ratio in available space
+        let maxWidthByHeight = availableHeight * ratio
+        let maxHeightByWidth = availableWidth / ratio
+
+        if maxWidthByHeight <= availableWidth {
+            // Height is the limiting factor
+            return (width: maxWidthByHeight, height: availableHeight)
+        } else {
+            // Width is the limiting factor
+            return (width: availableWidth, height: maxHeightByWidth)
+        }
+    }
+
     // MARK: - Transparency Methods
 
     private func makeWebViewTransparent() {
@@ -126,6 +169,103 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    @objc func getZoomButtonValues(_ call: CAPPluginCall) {
+        guard isInitialized else {
+            call.reject("Camera not initialized")
+            return
+        }
+
+        // Determine current device based on active position
+        var currentDevice: AVCaptureDevice?
+        switch self.cameraController.currentCameraPosition {
+        case .front:
+            currentDevice = self.cameraController.frontCamera
+        case .rear:
+            currentDevice = self.cameraController.rearCamera
+        default:
+            currentDevice = nil
+        }
+
+        guard let device = currentDevice else {
+            call.reject("No active camera device")
+            return
+        }
+
+        var hasUltraWide = false
+        var hasWide = false
+        var hasTele = false
+
+        let lenses = device.isVirtualDevice ? device.constituentDevices : [device]
+        for lens in lenses {
+            switch lens.deviceType {
+            case .builtInUltraWideCamera:
+                hasUltraWide = true
+            case .builtInWideAngleCamera:
+                hasWide = true
+            case .builtInTelephotoCamera:
+                hasTele = true
+            default:
+                break
+            }
+        }
+
+        var values: [Float] = []
+        if hasUltraWide {
+            values.append(0.5)
+        }
+        if hasWide {
+            values.append(1.0)
+            if self.isProModelSupportingOptical2x() {
+                values.append(2.0)
+            }
+        }
+        if hasTele {
+            // Use the virtual device's switch-over zoom factors when available
+            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
+                }
+            } else {
+                teleStep = Float(device.maxAvailableVideoZoomFactor) * displayMultiplier
+            }
+            values.append(teleStep)
+        }
+
+        // Deduplicate and sort
+        let uniqueSorted = Array(Set(values)).sorted()
+        call.resolve(["values": uniqueSorted])
+    }
+
+    private func isProModelSupportingOptical2x() -> Bool {
+        // Detects iPhone 14 Pro/Pro Max, 15 Pro/Pro Max, and 16 Pro/Pro Max
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let mirror = Mirror(reflecting: systemInfo.machine)
+        let identifier = mirror.children.reduce("") { partialResult, element in
+            guard let value = element.value as? Int8, value != 0 else { return partialResult }
+            return partialResult + String(UnicodeScalar(UInt8(value)))
+        }
+
+        // Known identifiers: 14 Pro (iPhone15,2), 14 Pro Max (iPhone15,3),
+        // 15 Pro (iPhone16,1), 15 Pro Max (iPhone16,2),
+        // 16 Pro (iPhone17,1), 16 Pro Max (iPhone17,2),
+        // 17 Pro (iPhone18,1), 17 Pro Max (iPhone18,2)
+        let supportedIdentifiers: Set<String> = [
+            "iPhone15,2", "iPhone15,3", // 14 Pro / 14 Pro Max
+            "iPhone16,1", "iPhone16,2", // 15 Pro / 15 Pro Max
+            "iPhone17,1", "iPhone17,2" // 16 Pro / 16 Pro Max
+        ]
+        return supportedIdentifiers.contains(identifier)
+    }
+
     @objc func rotated() {
         guard let previewView = self.previewView,
               let posX = self.posX,
@@ -141,23 +281,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         // Always use the factorized method for consistent positioning
         self.updateCameraFrame()
 
-        if let connection = self.cameraController.fileVideoOutput?.connection(with: .video) {
-            switch UIDevice.current.orientation {
-            case .landscapeRight:
-                connection.videoOrientation = .landscapeLeft
-            case .landscapeLeft:
-                connection.videoOrientation = .landscapeRight
-            case .portrait:
-                connection.videoOrientation = .portrait
-            case .portraitUpsideDown:
-                connection.videoOrientation = .portraitUpsideDown
-            default:
-                connection.videoOrientation = .portrait
-            }
-        }
-
-        cameraController.updateVideoOrientation()
-
+        // Centralize orientation update to use interface orientation consistently
         cameraController.updateVideoOrientation()
 
         // Update grid overlay frame if it exists - no animation
@@ -186,61 +310,54 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         self.aspectRatio = newAspectRatio
-
         DispatchQueue.main.async {
-            // When aspect ratio changes, always auto-center the view
-            // This ensures consistent behavior where changing aspect ratio recenters the view
-            self.posX = -1
-            self.posY = -1
-
-            // Calculate maximum size based on aspect ratio
-            let webViewWidth = self.webView?.frame.width ?? UIScreen.main.bounds.width
-            let webViewHeight = self.webView?.frame.height ?? UIScreen.main.bounds.height
-            let paddingBottom = self.paddingBottom ?? 0
-
-            // Calculate available space
-            let availableWidth: CGFloat
-            let availableHeight: CGFloat
-
-            if self.posX == -1 || self.posY == -1 {
-                // Auto-centering mode - use full dimensions
-                availableWidth = webViewWidth
-                availableHeight = webViewHeight - paddingBottom
-            } else {
-                // Manual positioning - calculate remaining space
-                availableWidth = webViewWidth - self.posX!
-                availableHeight = webViewHeight - self.posY! - paddingBottom
-            }
+            call.resolve(self.rawSetAspectRatio())
+        }
+    }
 
-            // Parse aspect ratio - convert to portrait orientation for camera use
-            let ratioParts = newAspectRatio.split(separator: ":").map { Double($0) ?? 1.0 }
-            // For camera, we want portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
-            let ratio = ratioParts[1] / ratioParts[0]
+    func rawSetAspectRatio() -> JSObject {
+        // When aspect ratio changes, always auto-center the view
+        // This ensures consistent behavior where changing aspect ratio recenters the view
+        self.posX = -1
+        self.posY = -1
 
-            // Calculate maximum size that fits the aspect ratio in available space
-            let maxWidthByHeight = availableHeight * CGFloat(ratio)
-            let maxHeightByWidth = availableWidth / CGFloat(ratio)
+        // Calculate maximum size based on aspect ratio
+        let webViewWidth = self.webView?.frame.width ?? UIScreen.main.bounds.width
+        let webViewHeight = self.webView?.frame.height ?? UIScreen.main.bounds.height
+        let paddingBottom = self.paddingBottom ?? 0
+        let isPortrait = self.isPortrait()
 
-            if maxWidthByHeight <= availableWidth {
-                // Height is the limiting factor
-                self.width = maxWidthByHeight
-                self.height = availableHeight
-            } else {
-                // Width is the limiting factor
-                self.width = availableWidth
-                self.height = maxHeightByWidth
-            }
+        // Calculate available space
+        let availableWidth: CGFloat
+        let availableHeight: CGFloat
 
-            self.updateCameraFrame()
+        if self.posX == -1 || self.posY == -1 {
+            // Auto-centering mode - use full dimensions
+            availableWidth = webViewWidth
+            availableHeight = webViewHeight - paddingBottom
+        } else {
+            // Manual positioning - calculate remaining space
+            availableWidth = webViewWidth - self.posX!
+            availableHeight = webViewHeight - self.posY! - paddingBottom
+        }
 
-            // Return the actual preview bounds
-            var result = JSObject()
-            result["x"] = Double(self.previewView.frame.origin.x)
-            result["y"] = Double(self.previewView.frame.origin.y)
-            result["width"] = Double(self.previewView.frame.width)
-            result["height"] = Double(self.previewView.frame.height)
-            call.resolve(result)
+        // Parse aspect ratio - convert to portrait orientation for camera use
+        // Use the centralized calculation method
+        if let aspectRatio = self.aspectRatio {
+            let dimensions = calculateDimensionsForAspectRatio(aspectRatio, availableWidth: availableWidth, availableHeight: availableHeight, isPortrait: isPortrait)
+            self.width = dimensions.width
+            self.height = dimensions.height
         }
+
+        self.updateCameraFrame()
+
+        // Return the actual preview bounds
+        var result = JSObject()
+        result["x"] = Double(self.previewView.frame.origin.x)
+        result["y"] = Double(self.previewView.frame.origin.y)
+        result["width"] = Double(self.previewView.frame.width)
+        result["height"] = Double(self.previewView.frame.height)
+        return result
     }
 
     @objc func getAspectRatio(_ call: CAPPluginCall) {
@@ -385,6 +502,26 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         let startTime = CFAbsoluteTimeGetCurrent()
         print("[CameraPreview] 🚀 START CALLED at \(Date())")
 
+        // Log all received settings
+        print("[CameraPreview] 📋 Settings received:")
+        print("  - position: \(call.getString("position") ?? "rear")")
+        print("  - deviceId: \(call.getString("deviceId") ?? "nil")")
+        print("  - cameraMode: \(call.getBool("cameraMode") ?? false)")
+        print("  - width: \(call.getInt("width") ?? 0)")
+        print("  - height: \(call.getInt("height") ?? 0)")
+        print("  - x: \(call.getInt("x") ?? -1)")
+        print("  - y: \(call.getInt("y") ?? -1)")
+        print("  - paddingBottom: \(call.getInt("paddingBottom") ?? 0)")
+        print("  - rotateWhenOrientationChanged: \(call.getBool("rotateWhenOrientationChanged") ?? true)")
+        print("  - toBack: \(call.getBool("toBack") ?? true)")
+        print("  - storeToFile: \(call.getBool("storeToFile") ?? false)")
+        print("  - enableZoom: \(call.getBool("enableZoom") ?? false)")
+        print("  - disableAudio: \(call.getBool("disableAudio") ?? true)")
+        print("  - aspectRatio: \(call.getString("aspectRatio") ?? "4:3")")
+        print("  - gridMode: \(call.getString("gridMode") ?? "none")")
+        print("  - positioning: \(call.getString("positioning") ?? "top")")
+        print("  - initialZoomLevel: \(call.getFloat("initialZoomLevel") ?? 1.0)")
+
         if self.isInitializing {
             call.reject("camera initialization in progress")
             return
@@ -435,15 +572,16 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         self.storeToFile = call.getBool("storeToFile") ?? false
         self.enableZoom = call.getBool("enableZoom") ?? false
         self.disableAudio = call.getBool("disableAudio") ?? true
-        self.aspectRatio = call.getString("aspectRatio")
+        // Default to 4:3 aspect ratio if not provided
+        self.aspectRatio = call.getString("aspectRatio") ?? "4:3"
         self.gridMode = call.getString("gridMode") ?? "none"
         self.positioning = call.getString("positioning") ?? "top"
 
-        let userProvidedZoom = call.getFloat("initialZoomLevel")
-        let initialZoomLevel = userProvidedZoom ?? 1.5
+        let initialZoomLevel = call.getFloat("initialZoomLevel")
 
-        if self.aspectRatio != nil && (call.getInt("width") != nil || call.getInt("height") != nil) {
-            call.reject("Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start.")
+        // Validate aspect ratio parameters using centralized method
+        if let validationError = validateAspectRatioParameters(aspectRatio: self.aspectRatio, width: call.getInt("width"), height: call.getInt("height")) {
+            call.reject(validationError)
             return
         }
 
@@ -457,13 +595,19 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             if self.cameraController.captureSession?.isRunning ?? false {
                 call.reject("camera already started")
             } else {
-                self.cameraController.prepare(cameraPosition: self.cameraPosition, deviceId: deviceId, disableAudio: self.disableAudio, cameraMode: cameraMode, aspectRatio: self.aspectRatio, initialZoomLevel: Float(initialZoomLevel)) {error in
+                self.cameraController.prepare(cameraPosition: self.cameraPosition, deviceId: deviceId, disableAudio: self.disableAudio, cameraMode: cameraMode, aspectRatio: self.aspectRatio, initialZoomLevel: initialZoomLevel) {error in
                     if let error = error {
                         print(error)
                         call.reject(error.localizedDescription)
                         return
                     }
+
                     DispatchQueue.main.async {
+                        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+                        NotificationCenter.default.addObserver(self,
+                                                               selector: #selector(self.handleOrientationChange),
+                                                               name: UIDevice.orientationDidChangeNotification,
+                                                               object: nil)
                         self.completeStartCamera(call: call)
                     }
                 }
@@ -487,6 +631,9 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         // Display the camera preview on the configured view
         try? self.cameraController.displayPreview(on: self.previewView)
 
+        // Ensure the preview orientation matches the current interface orientation at startup
+        self.cameraController.updateVideoOrientation()
+
         self.cameraController.setupGestures(target: self.previewView, enableZoom: self.enableZoom!)
 
         // Add grid overlay if enabled
@@ -519,14 +666,16 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             }
         }
 
-        // If already received first frame (unlikely but possible), resolve immediately
+        // If already received first frame (unlikely but possible), resolve immediately on main thread
         if self.cameraController.hasReceivedFirstFrame {
-            var returnedObject = JSObject()
-            returnedObject["width"] = self.previewView.frame.width as any JSValue
-            returnedObject["height"] = self.previewView.frame.height as any JSValue
-            returnedObject["x"] = self.previewView.frame.origin.x as any JSValue
-            returnedObject["y"] = self.previewView.frame.origin.y as any JSValue
-            call.resolve(returnedObject)
+            DispatchQueue.main.async {
+                var returnedObject = JSObject()
+                returnedObject["width"] = self.previewView.frame.width as any JSValue
+                returnedObject["height"] = self.previewView.frame.height as any JSValue
+                returnedObject["x"] = self.previewView.frame.origin.x as any JSValue
+                returnedObject["y"] = self.previewView.frame.origin.y as any JSValue
+                call.resolve(returnedObject)
+            }
         }
     }
 
@@ -589,6 +738,9 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             // Remove notification observers
             NotificationCenter.default.removeObserver(self)
 
+            NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
+            UIDevice.current.endGeneratingDeviceOrientationNotifications()
+
             call.resolve()
         }
     }
@@ -685,10 +837,10 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         print("[CameraPreview] Raw parameter values - width: \(String(describing: width)), height: \(String(describing: height)), aspectRatio: \(String(describing: aspectRatio))")
 
-        // Check for conflicting parameters
-        if aspectRatio != nil && (width != nil || height != nil) {
-            print("[CameraPreview] Error: Cannot set both aspectRatio and size (width/height)")
-            call.reject("Cannot set both aspectRatio and size (width/height). Use setPreviewSize after start.")
+        // Check for conflicting parameters using centralized validation
+        if let validationError = validateAspectRatioParameters(aspectRatio: aspectRatio, width: width, height: height) {
+            print("[CameraPreview] Error: \(validationError)")
+            call.reject(validationError)
             return
         }
 
@@ -703,9 +855,22 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         print("[CameraPreview] Capture params - quality: \(quality), saveToGallery: \(saveToGallery), withExifLocation: \(withExifLocation), width: \(width ?? -1), height: \(height ?? -1), aspectRatio: \(aspectRatio ?? "nil"), using aspectRatio: \(captureAspectRatio ?? "nil")")
         print("[CameraPreview] Current location: \(self.currentLocation?.description ?? "nil")")
-        print("[CameraPreview] Preview dimensions: \(self.previewView.frame.width)x\(self.previewView.frame.height)")
+        // Safely read frame from main thread for logging
+        let (previewWidth, previewHeight): (CGFloat, CGFloat) = {
+            if Thread.isMainThread {
+                return (self.previewView.frame.width, self.previewView.frame.height)
+            }
+            var w: CGFloat = 0
+            var h: CGFloat = 0
+            DispatchQueue.main.sync {
+                w = self.previewView.frame.width
+                h = self.previewView.frame.height
+            }
+            return (w, h)
+        }()
+        print("[CameraPreview] Preview dimensions: \(previewWidth)x\(previewHeight)")
 
-        self.cameraController.captureImage(width: width, height: height, aspectRatio: captureAspectRatio, quality: quality, gpsLocation: self.currentLocation) { (image, error) in
+        self.cameraController.captureImage(width: width, height: height, aspectRatio: captureAspectRatio, quality: quality, gpsLocation: self.currentLocation) { (image, originalPhotoData, _, error) in
             print("[CameraPreview] captureImage callback received")
             DispatchQueue.main.async {
                 print("[CameraPreview] Processing capture on main thread")
@@ -719,7 +884,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                       let imageDataWithExif = self.createImageDataWithExif(
                         from: image,
                         quality: Int(quality),
-                        location: withExifLocation ? self.currentLocation : nil
+                        location: withExifLocation ? self.currentLocation : nil,
+                        originalPhotoData: originalPhotoData
                       )
                 else {
                     print("[CameraPreview] Failed to create image data with EXIF")
@@ -734,30 +900,56 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                     self.saveImageDataToGallery(imageData: imageDataWithExif) { success, error in
                         print("[CameraPreview] Save to gallery completed, success: \(success), error: \(error?.localizedDescription ?? "none")")
                         let exifData = self.getExifData(from: imageDataWithExif)
-                        let base64Image = imageDataWithExif.base64EncodedString()
 
                         var result = JSObject()
-                        result["value"] = base64Image
                         result["exif"] = exifData
                         result["gallerySaved"] = success
                         if !success, let error = error {
                             result["galleryError"] = error.localizedDescription
                         }
 
+                        if self.storeToFile == false {
+                            let base64Image = imageDataWithExif.base64EncodedString()
+                            result["value"] = base64Image
+                        } else {
+                            do {
+                                let fileUrl = self.getTempFilePath()
+                                try imageDataWithExif.write(to: fileUrl)
+                                result["value"] = fileUrl.absoluteString
+                            } catch {
+                                call.reject("Error writing image to file")
+                            }
+                        }
+
                         print("[CameraPreview] Resolving capture call with gallery save")
                         call.resolve(result)
                     }
                 } else {
                     print("[CameraPreview] Not saving to gallery, returning image data")
                     let exifData = self.getExifData(from: imageDataWithExif)
-                    let base64Image = imageDataWithExif.base64EncodedString()
 
-                    var result = JSObject()
-                    result["value"] = base64Image
-                    result["exif"] = exifData
+                    if self.storeToFile == false {
+                        let base64Image = imageDataWithExif.base64EncodedString()
+                        var result = JSObject()
+                        result["value"] = base64Image
+                        result["exif"] = exifData
+
+                        print("[CameraPreview] base64 - Resolving capture call")
+                        call.resolve(result)
+                    } else {
+                        do {
+                            let fileUrl = self.getTempFilePath()
+                            try imageDataWithExif.write(to: fileUrl)
+                            var result = JSObject()
+                            result["value"] = fileUrl.absoluteString
+                            result["exif"] = exifData
+                            print("[CameraPreview] filePath - Resolving capture call")
+                            call.resolve(result)
+                        } catch {
+                            call.reject("Error writing image to file")
+                        }
+                    }
 
-                    print("[CameraPreview] Resolving capture call")
-                    call.resolve(result)
                 }
             }
         }
@@ -792,24 +984,85 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         return exifData
     }
 
-    private func createImageDataWithExif(from image: UIImage, quality: Int, location: CLLocation?) -> Data? {
-        guard let originalImageData = image.jpegData(compressionQuality: CGFloat(Double(quality) / 100.0)) else {
+    @objc func getSafeAreaInsets(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            var notchInset: CGFloat = 0
+            var orientation: Int = 0
+
+            // Get the current interface orientation
+            let interfaceOrientation: UIInterfaceOrientation? = {
+                return (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.interfaceOrientation
+            }()
+
+            // Convert to orientation number (matching Android values for consistency)
+            switch interfaceOrientation {
+            case .portrait, .portraitUpsideDown:
+                orientation = 1 // Portrait
+            case .landscapeLeft, .landscapeRight:
+                orientation = 2 // Landscape
+            default:
+                orientation = 0 // Unknown
+            }
+
+            // Get safe area insets
+            if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+               let window = windowScene.windows.first {
+                let safeAreaInsets = window.safeAreaInsets
+
+                switch interfaceOrientation {
+                case .portrait:
+                    // Portrait: notch is at the top
+                    notchInset = safeAreaInsets.top
+                case .portraitUpsideDown:
+                    // Portrait upside down: notch is at the bottom (but we still call it "top" for consistency)
+                    notchInset = safeAreaInsets.bottom
+                case .landscapeLeft:
+                    // Landscape left: notch is typically on the left
+                    notchInset = safeAreaInsets.left
+                case .landscapeRight:
+                    // Landscape right: notch is typically on the right (but we use left for consistency with Android)
+                    notchInset = safeAreaInsets.right
+                default:
+                    // Unknown orientation, default to top
+                    notchInset = safeAreaInsets.top
+                }
+            } else {
+                // Fallback: use status bar height as approximation
+                notchInset = UIApplication.shared.statusBarFrame.height
+            }
+
+            let result: [String: Any] = [
+                "orientation": orientation,
+                "top": Double(notchInset)
+            ]
+
+            call.resolve(result)
+        }
+    }
+
+    private func createImageDataWithExif(from image: UIImage, quality: Int, location: CLLocation?, originalPhotoData: Data?) -> Data? {
+        guard let jpegDataAtQuality = image.jpegData(compressionQuality: CGFloat(Double(quality) / 100.0)) else {
             return nil
         }
 
-        guard let imageSource = CGImageSourceCreateWithData(originalImageData as CFData, nil),
+        // Prefer metadata from the original AVCapturePhoto file data to preserve lens/EXIF
+        let sourceDataForMetadata = (originalPhotoData ?? jpegDataAtQuality) as CFData
+        guard let imageSource = CGImageSourceCreateWithData(sourceDataForMetadata, nil),
               let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [String: Any],
               let cgImage = image.cgImage else {
-            return originalImageData
+            return jpegDataAtQuality
         }
 
         let mutableData = NSMutableData()
         guard let destination = CGImageDestinationCreateWithData(mutableData, kUTTypeJPEG, 1, nil) else {
-            return originalImageData
+            return jpegDataAtQuality
         }
 
         var finalProperties = imageProperties
 
+        // Ensure orientation reflects the pixel data (we pass an orientation-fixed UIImage)
+        finalProperties[kCGImagePropertyOrientation as String] = 1
+
         // Add GPS location if available
         if let location = location {
             let formatter = DateFormatter()
@@ -829,10 +1082,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             finalProperties[kCGImagePropertyGPSDictionary as String] = gpsDict
         }
 
-        // Create or update TIFF dictionary for device info
+        // Create or update TIFF dictionary for device info and set orientation to Up
         var tiffDict = finalProperties[kCGImagePropertyTIFFDictionary as String] as? [String: Any] ?? [:]
         tiffDict[kCGImagePropertyTIFFMake as String] = "Apple"
         tiffDict[kCGImagePropertyTIFFModel as String] = UIDevice.current.model
+        tiffDict[kCGImagePropertyTIFFOrientation as String] = 1
         finalProperties[kCGImagePropertyTIFFDictionary as String] = tiffDict
 
         CGImageDestinationAddImage(destination, cgImage, finalProperties as CFDictionary)
@@ -841,7 +1095,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             return mutableData as Data
         }
 
-        return originalImageData
+        return jpegDataAtQuality
     }
 
     @objc func captureSample(_ call: CAPPluginCall) {
@@ -1036,16 +1290,17 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         do {
             let zoomInfo = try self.cameraController.getZoom()
             let lensInfo = try self.cameraController.getCurrentLensInfo()
+            let displayMultiplier = self.cameraController.getDisplayZoomMultiplier()
 
             var minZoom = zoomInfo.min
             var maxZoom = zoomInfo.max
             var currentZoom = zoomInfo.current
 
-            // If using the multi-lens camera, translate the native zoom values for JS
-            if self.cameraController.isUsingMultiLensVirtualCamera {
-                minZoom -= 0.5
-                maxZoom -= 0.5
-                currentZoom -= 0.5
+            // Apply iOS 18+ display multiplier so UI sees the expected values
+            if displayMultiplier != 1.0 {
+                minZoom *= displayMultiplier
+                maxZoom *= displayMultiplier
+                currentZoom *= displayMultiplier
             }
 
             call.resolve([
@@ -1076,12 +1331,14 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
 
         // If using the multi-lens camera, translate the JS zoom value for the native layer
-        if self.cameraController.isUsingMultiLensVirtualCamera {
-            level += 0.5
+        // First, convert from UI/display zoom to native zoom using the iOS 18 multiplier
+        let displayMultiplier = self.cameraController.getDisplayZoomMultiplier()
+        if displayMultiplier != 1.0 {
+            level = level / displayMultiplier
         }
 
         let ramp = call.getBool("ramp") ?? true
-        let autoFocus = call.getBool("autoFocus") ?? true
+        let autoFocus = call.getBool("autoFocus") ?? false
 
         do {
             try self.cameraController.setZoom(level: CGFloat(level), ramp: ramp, autoFocus: autoFocus)
@@ -1326,6 +1583,26 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         }
     }
 
+    private func isPortrait() -> Bool {
+        let orientation = UIDevice.current.orientation
+        if orientation.isValidInterfaceOrientation {
+            return orientation.isPortrait
+        } else {
+            let interfaceOrientation: UIInterfaceOrientation? = {
+                if Thread.isMainThread {
+                    return (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.interfaceOrientation
+                } else {
+                    var value: UIInterfaceOrientation?
+                    DispatchQueue.main.sync {
+                        value = (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.interfaceOrientation
+                    }
+                    return value
+                }
+            }()
+            return interfaceOrientation?.isPortrait ?? false
+        }
+    }
+
     private func calculateCameraFrame(x: CGFloat? = nil, y: CGFloat? = nil, width: CGFloat? = nil, height: CGFloat? = nil, aspectRatio: String? = nil) -> CGRect {
         // Use provided values or existing ones
         let currentWidth = width ?? self.width ?? UIScreen.main.bounds.size.width
@@ -1341,6 +1618,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
         let webViewWidth = self.webView?.frame.width ?? UIScreen.main.bounds.width
         let webViewHeight = self.webView?.frame.height ?? UIScreen.main.bounds.height
 
+        let isPortrait = self.isPortrait()
+
         var finalX = currentX
         var finalY = currentY
         var finalWidth = currentWidth
@@ -1354,12 +1633,20 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 currentHeight == UIScreen.main.bounds.size.height {
                 finalWidth = webViewWidth
 
-                // Calculate height based on aspect ratio
-                let ratioParts = ratio.split(separator: ":").compactMap { Double($0) }
-                if ratioParts.count == 2 {
-                    // For camera, use portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
-                    let ratioValue = ratioParts[1] / ratioParts[0]
-                    finalHeight = finalWidth / CGFloat(ratioValue)
+                // width: 428.0 height: 926.0 - portrait
+
+                print("[CameraPreview] width: \(UIScreen.main.bounds.size.width) height: \(UIScreen.main.bounds.size.height)")
+
+                // Calculate dimensions using centralized method
+                let dimensions = calculateDimensionsForAspectRatio(ratio, availableWidth: finalWidth, availableHeight: webViewHeight - paddingBottom, isPortrait: isPortrait)
+                if isPortrait {
+                    finalHeight = dimensions.height
+                    finalWidth = dimensions.width
+                } else {
+                    // In landscape, recalculate based on available space
+                    let landscapeDimensions = calculateDimensionsForAspectRatio(ratio, availableWidth: webViewWidth, availableHeight: webViewHeight - paddingBottom, isPortrait: isPortrait)
+                    finalWidth = landscapeDimensions.width
+                    finalHeight = landscapeDimensions.height
                 }
             }
 
@@ -1371,9 +1658,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             }
 
             // Position vertically if y is -1
+            // TODO: fix top, bottom for landscape
             if currentY == -1 {
                 // Use full screen height for positioning
                 let screenHeight = UIScreen.main.bounds.size.height
+                let screenWidth = UIScreen.main.bounds.size.width
                 switch self.positioning {
                 case "top":
                     finalY = 0
@@ -1382,8 +1671,14 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                     finalY = screenHeight - finalHeight
                     print("[CameraPreview] Positioning at bottom: screenHeight=\(screenHeight), finalHeight=\(finalHeight), finalY=\(finalY)")
                 default: // "center"
-                    finalY = (screenHeight - finalHeight) / 2
-                    print("[CameraPreview] Centering vertically: screenHeight=\(screenHeight), finalHeight=\(finalHeight), finalY=\(finalY)")
+                    if isPortrait {
+                        finalY = (screenHeight - finalHeight) / 2
+                        print("[CameraPreview] Centering vertically: screenHeight=\(screenHeight), finalHeight=\(finalHeight), finalY=\(finalY)")
+                    } else {
+                        // In landscape, center both horizontally and vertically
+                        finalY = (screenHeight - finalHeight) / 2
+                        finalX = (screenWidth - finalWidth) / 2
+                    }
                 }
             } else {
                 finalY = currentY
@@ -1411,21 +1706,18 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
 
         // Apply aspect ratio adjustments only if not auto-centering
         if posX != -1 && posY != -1, let aspectRatio = self.aspectRatio {
-            let ratioParts = aspectRatio.split(separator: ":").compactMap { Double($0) }
-            if ratioParts.count == 2 {
-                // For camera, use portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
-                let ratio = ratioParts[1] / ratioParts[0]
-                let currentRatio = Double(frame.width) / Double(frame.height)
-
-                if currentRatio > ratio {
-                    let newWidth = Double(frame.height) * ratio
-                    frame.origin.x = frame.origin.x + (frame.width - CGFloat(newWidth)) / 2
-                    frame.size.width = CGFloat(newWidth)
-                } else {
-                    let newHeight = Double(frame.width) / ratio
-                    frame.origin.y = frame.origin.y + (frame.height - CGFloat(newHeight)) / 2
-                    frame.size.height = CGFloat(newHeight)
-                }
+            let isPortrait = self.isPortrait()
+            let ratio = parseAspectRatio(aspectRatio, isPortrait: isPortrait)
+            let currentRatio = frame.width / frame.height
+
+            if currentRatio > ratio {
+                let newWidth = frame.height * ratio
+                frame.origin.x = frame.origin.x + (frame.width - newWidth) / 2
+                frame.size.width = newWidth
+            } else {
+                let newHeight = frame.width / ratio
+                frame.origin.y = frame.origin.y + (frame.height - newHeight) / 2
+                frame.size.height = newHeight
             }
         }
 
@@ -1545,4 +1837,66 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             }
         }
     }
+
+    @objc private func handleOrientationChange() {
+        DispatchQueue.main.async {
+            let result = self.rawSetAspectRatio()
+            self.notifyListeners("screenResize", data: result)
+            self.notifyListeners("orientationChange", data: ["orientation": self.currentOrientationString()])
+        }
+    }
+
+    @objc func deleteFile(_ call: CAPPluginCall) {
+        guard let path = call.getString("path"), !path.isEmpty else {
+            call.reject("path parameter is required")
+            return
+        }
+        let url: URL?
+        if path.hasPrefix("file://") {
+            url = URL(string: path)
+        } else {
+            url = URL(fileURLWithPath: path)
+        }
+        guard let fileURL = url else {
+            call.reject("Invalid path")
+            return
+        }
+        do {
+            if FileManager.default.fileExists(atPath: fileURL.path) {
+                try FileManager.default.removeItem(at: fileURL)
+                call.resolve(["success": true])
+            } else {
+                call.resolve(["success": false])
+            }
+        } catch {
+            call.reject("Failed to delete file: \(error.localizedDescription)")
+        }
+    }
+
+    // MARK: - Orientation
+    private func currentOrientationString() -> String {
+        // Prefer interface orientation for UI-consistent results
+        let orientation: UIInterfaceOrientation? = {
+            if Thread.isMainThread {
+                return (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.interfaceOrientation
+            } else {
+                var value: UIInterfaceOrientation?
+                DispatchQueue.main.sync {
+                    value = (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.interfaceOrientation
+                }
+                return value
+            }
+        }()
+        switch orientation {
+        case .portrait: return "portrait"
+        case .portraitUpsideDown: return "portrait-upside-down"
+        case .landscapeLeft: return "landscape-left"
+        case .landscapeRight: return "landscape-right"
+        default: return "unknown"
+        }
+    }
+
+    @objc func getOrientation(_ call: CAPPluginCall) {
+        call.resolve(["orientation": self.currentOrientationString()])
+    }
 }