@capgo/camera-preview 7.4.0-alpha.1 → 7.4.0-alpha.11

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,8 @@ 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)
     ]
     // Camera state tracking
     private var isInitializing: Bool = false
@@ -126,6 +128,59 @@ 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)
+            values.append(2.0)
+        }
+        if hasTele { values.append(3.0) }
+
+        // Deduplicate and sort
+        let uniqueSorted = Array(Set(values)).sorted()
+        call.resolve(["values": uniqueSorted])
+    }
+
     @objc func rotated() {
         guard let previewView = self.previewView,
               let posX = self.posX,
@@ -141,23 +196,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 +225,66 @@ 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
+        let ratioParts = self.aspectRatio?.split(separator: ":").map { Double($0) ?? 1.0 } ?? [1.0, 1.0]
+
+        // For camera (portrait), we want portrait orientation: 4:3 becomes 3:4, 16:9 becomes 9:16
+        let ratio = !isPortrait ? ratioParts[0] / ratioParts[1] : ratioParts[1] / ratioParts[0]
+
+        // Calculate maximum size that fits the aspect ratio in available space
+        let maxWidthByHeight = availableHeight * CGFloat(ratio)
+        let maxHeightByWidth = availableWidth / CGFloat(ratio)
+
+        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
         }
+
+        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) {
@@ -435,12 +479,12 @@ 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.")
@@ -457,13 +501,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 +537,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 +572,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 +644,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()
         }
     }
@@ -703,9 +761,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 +790,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")
@@ -737,27 +809,54 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                         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] 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] Resolving capture call")
+                            call.resolve(result)
+                        } catch {
+                            call.reject("Error writing image to file")
+                        }
+                    }
 
-                    print("[CameraPreview] Resolving capture call")
-                    call.resolve(result)
                 }
             }
         }
@@ -792,24 +891,29 @@ 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 {
+    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 +933,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 +946,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             return mutableData as Data
         }
 
-        return originalImageData
+        return jpegDataAtQuality
     }
 
     @objc func captureSample(_ call: CAPPluginCall) {
@@ -1036,16 +1141,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,8 +1182,10 @@ 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
@@ -1326,6 +1434,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 +1469,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 +1484,20 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
                 currentHeight == UIScreen.main.bounds.size.height {
                 finalWidth = webViewWidth
 
+                // width: 428.0 height: 926.0 - portrait
+
+                print("[CameraPreview] width: \(UIScreen.main.bounds.size.width) height: \(UIScreen.main.bounds.size.height)")
+
                 // 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)
+                    if isPortrait {
+                        finalHeight = finalWidth / CGFloat(ratioValue)
+                    } else {
+                        finalWidth = finalHeight / CGFloat(ratioValue)
+                    }
                 }
             }
 
@@ -1371,9 +1509,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 +1522,12 @@ 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 {
+                        finalX = (screenWidth - finalWidth) / 2
+                    }
                 }
             } else {
                 finalY = currentY
@@ -1545,4 +1689,38 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelega
             }
         }
     }
+
+    @objc private func handleOrientationChange() {
+        DispatchQueue.main.async {
+            let result = self.rawSetAspectRatio()
+            self.notifyListeners("screenResize", data: result)
+        }
+    }
+
+    @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)")
+        }
+    }
 }

package/package.json

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