@capgo/camera-preview 7.4.0-beta.1 → 7.4.0-beta.10

package/ios/Sources/CapgoCameraPreview/Plugin.swift

@@ -1,6 +1,11 @@
 import Foundation
 import Capacitor
 import AVFoundation
+import Photos
+import CoreImage
+import CoreLocation
+import MobileCoreServices
+
 
 extension UIWindow {
     static var isLandscape: Bool {
@@ -32,7 +37,7 @@ extension UIWindow {
  * here: https://capacitor.ionicframework.com/docs/plugins/ios
  */
 @objc(CameraPreview)
-public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
+public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
     public let identifier = "CameraPreviewPlugin"
     public let jsName = "CameraPreview"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -54,11 +59,18 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "setZoom", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getFlashMode", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setDeviceId", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getDeviceId", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "getDeviceId", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setAspectRatio", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getAspectRatio", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setGridMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getGridMode", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPreviewSize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setPreviewSize", returnType: CAPPluginReturnPromise)
     ]
     // Camera state tracking
     private var isInitializing: Bool = false
     private var isInitialized: Bool = false
+    private var backgroundSession: AVCaptureSession?
 
     var previewView: UIView!
     var cameraPosition = String()
@@ -74,33 +86,44 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
     var enableZoom: Bool?
     var highResolutionOutput: Bool = false
     var disableAudio: Bool = false
+    var locationManager: CLLocationManager?
+    var currentLocation: CLLocation?
+    private var aspectRatio: String?
+    private var gridMode: String = "none"
 
     // MARK: - Transparency Methods
-    
+
+
     private func makeWebViewTransparent() {
         guard let webView = self.webView else { return }
-        
+
+
         // Define a recursive function to traverse the view hierarchy
         func makeSubviewsTransparent(_ view: UIView) {
             // Set the background color to clear
             view.backgroundColor = .clear
-            
+
+
             // Recurse for all subviews
             for subview in view.subviews {
                 makeSubviewsTransparent(subview)
             }
         }
-        
+
+
         // Set the main webView to be transparent
         webView.isOpaque = false
         webView.backgroundColor = .clear
-        
+
+
         // Recursively make all subviews transparent
         makeSubviewsTransparent(webView)
-        
+
+
         // Also ensure the webview's container is transparent
         webView.superview?.backgroundColor = .clear
-        
+
+
         // Force a layout pass to apply changes
         DispatchQueue.main.async {
             webView.setNeedsLayout()
@@ -119,14 +142,26 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         let paddingBottom = self.paddingBottom ?? 0
         let height = heightValue - paddingBottom
 
-        if UIWindow.isLandscape {
-            previewView.frame = CGRect(x: posY, y: posX, width: max(height, width), height: min(height, width))
-            self.cameraController.previewLayer?.frame = previewView.frame
-        }
+        // Handle auto-centering during rotation
+        if posX == -1 || posY == -1 {
+            // Trigger full recalculation for auto-centered views
+            self.updateCameraFrame()
+        } else {
+            // Manual positioning - use original rotation logic with no animation
+            CATransaction.begin()
+            CATransaction.setDisableActions(true)
+            
+            if UIWindow.isLandscape {
+                previewView.frame = CGRect(x: posY, y: posX, width: max(height, width), height: min(height, width))
+                self.cameraController.previewLayer?.frame = previewView.bounds
+            }
 
-        if UIWindow.isPortrait {
-            previewView.frame = CGRect(x: posX, y: posY, width: min(height, width), height: max(height, width))
-            self.cameraController.previewLayer?.frame = previewView.frame
+            if UIWindow.isPortrait {
+                previewView.frame = CGRect(x: posX, y: posY, width: min(height, width), height: max(height, width))
+                self.cameraController.previewLayer?.frame = previewView.bounds
+            }
+            
+            CATransaction.commit()
         }
 
         if let connection = self.cameraController.fileVideoOutput?.connection(with: .video) {
@@ -145,13 +180,130 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         }
 
         cameraController.updateVideoOrientation()
-        
+
+        cameraController.updateVideoOrientation()
+
+        // Update grid overlay frame if it exists - no animation
+        if let gridOverlay = self.cameraController.gridOverlayView {
+            CATransaction.begin()
+            CATransaction.setDisableActions(true)
+            gridOverlay.frame = previewView.bounds
+            CATransaction.commit()
+        }
+
         // Ensure webview remains transparent after rotation
         if self.isInitialized {
             self.makeWebViewTransparent()
         }
     }
-    
+
+    @objc func setAspectRatio(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+        
+        guard let newAspectRatio = call.getString("aspectRatio") else {
+            call.reject("aspectRatio parameter is required")
+            return
+        }
+        
+        self.aspectRatio = newAspectRatio
+        
+        // When aspect ratio changes, calculate maximum size possible from current position
+        if let posX = self.posX, let posY = self.posY {
+            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 from current position
+            let availableWidth: CGFloat
+            let availableHeight: CGFloat
+            
+            if posX == -1 || posY == -1 {
+                // Auto-centering mode - use full dimensions
+                availableWidth = webViewWidth
+                availableHeight = webViewHeight - paddingBottom
+            } else {
+                // Manual positioning - calculate remaining space
+                availableWidth = webViewWidth - posX
+                availableHeight = webViewHeight - posY - paddingBottom
+            }
+            
+            // 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]
+            
+            // 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
+            }
+            
+            print("[CameraPreview] Aspect ratio changed to \(newAspectRatio), new size: \(self.width!)x\(self.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)
+        call.resolve(result)
+    }
+
+    @objc func getAspectRatio(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+        call.resolve(["aspectRatio": self.aspectRatio ?? "4:3"])
+    }
+
+    @objc func setGridMode(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+
+        guard let gridMode = call.getString("gridMode") else {
+            call.reject("gridMode parameter is required")
+            return
+        }
+
+        self.gridMode = gridMode
+
+        // Update grid overlay
+        DispatchQueue.main.async {
+            if gridMode == "none" {
+                self.cameraController.removeGridOverlay()
+            } else {
+                self.cameraController.addGridOverlay(to: self.previewView, gridMode: gridMode)
+            }
+        }
+
+        call.resolve()
+    }
+
+    @objc func getGridMode(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+        call.resolve(["gridMode": self.gridMode])
+    }
+
     @objc func appDidBecomeActive() {
         if self.isInitialized {
             DispatchQueue.main.async {
@@ -159,7 +311,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
             }
         }
     }
-    
+
+
     @objc func appWillEnterForeground() {
         if self.isInitialized {
             DispatchQueue.main.async {
@@ -266,18 +419,33 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         self.highResolutionOutput = call.getBool("enableHighResolution") ?? false
         self.cameraController.highResolutionOutput = self.highResolutionOutput
 
-        if call.getInt("width") != nil {
-            self.width = CGFloat(call.getInt("width")!)
+        // Set width - use screen width if not provided or if 0
+        if let width = call.getInt("width"), width > 0 {
+            self.width = CGFloat(width)
         } else {
             self.width = UIScreen.main.bounds.size.width
         }
-        if call.getInt("height") != nil {
-            self.height = CGFloat(call.getInt("height")!)
+
+        // Set height - use screen height if not provided or if 0
+        if let height = call.getInt("height"), height > 0 {
+            self.height = CGFloat(height)
         } else {
             self.height = UIScreen.main.bounds.size.height
         }
-        self.posX = call.getInt("x") != nil ? CGFloat(call.getInt("x")!)/UIScreen.main.scale: 0
-        self.posY = call.getInt("y") != nil ? CGFloat(call.getInt("y")!) / (call.getBool("includeSafeAreaInsets") ?? false ? 1.0 : UIScreen.main.scale) + (call.getBool("includeSafeAreaInsets") ?? false ? UIApplication.shared.windows.first?.safeAreaInsets.top ?? 0 : 0) : 0
+
+        // Set x position - use exact CSS pixel value from web view, or mark for centering
+        if let x = call.getInt("x") {
+            self.posX = CGFloat(x)
+        } else {
+            self.posX = -1 // Use -1 to indicate auto-centering
+        }
+
+        // Set y position - use exact CSS pixel value from web view, or mark for centering
+        if let y = call.getInt("y") {
+            self.posY = CGFloat(y)
+        } else {
+            self.posY = -1 // Use -1 to indicate auto-centering
+        }
         if call.getInt("paddingBottom") != nil {
             self.paddingBottom = CGFloat(call.getInt("paddingBottom")!)
         }
@@ -286,7 +454,17 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         self.toBack = call.getBool("toBack") ?? true
         self.storeToFile = call.getBool("storeToFile") ?? false
         self.enableZoom = call.getBool("enableZoom") ?? false
-        self.disableAudio = call.getBool("disableAudio") ?? false
+        self.disableAudio = call.getBool("disableAudio") ?? true
+        self.aspectRatio = call.getString("aspectRatio")
+        self.gridMode = call.getString("gridMode") ?? "none"
+        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.")
+            return
+        }
+
+        print("[CameraPreview] Camera start parameters - aspectRatio: \(String(describing: self.aspectRatio)), gridMode: \(self.gridMode)")
+        print("[CameraPreview] Screen dimensions: \(UIScreen.main.bounds.size)")
+        print("[CameraPreview] Final frame dimensions - width: \(self.width), height: \(self.height), x: \(self.posX), y: \(self.posY)")
 
         AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
             guard granted else {
@@ -298,44 +476,79 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 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) {error in
+                    self.cameraController.prepare(cameraPosition: self.cameraPosition, deviceId: deviceId, disableAudio: self.disableAudio, cameraMode: cameraMode, aspectRatio: self.aspectRatio) {error in
                         if let error = error {
                             print(error)
                             call.reject(error.localizedDescription)
                             return
                         }
-                        let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!
-                        self.previewView = UIView(frame: CGRect(x: self.posX ?? 0, y: self.posY ?? 0, width: self.width!, height: height))
-                        
-                        // Make webview transparent - comprehensive approach
-                        self.makeWebViewTransparent()
-                        
-                        self.webView?.superview?.addSubview(self.previewView)
-                        if self.toBack! {
-                            self.webView?.superview?.bringSubviewToFront(self.webView!)
-                        }
-                        try? self.cameraController.displayPreview(on: self.previewView)
-
-                        let frontView = self.toBack! ? self.webView : self.previewView
-                        self.cameraController.setupGestures(target: frontView ?? self.previewView, enableZoom: self.enableZoom!)
-
-                        if self.rotateWhenOrientationChanged == true {
-                            NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
-                        }
-                        
-                        // Add observers for app state changes to maintain transparency
-                        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
-                        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
-
-                        self.isInitializing = false
-                        self.isInitialized = true
-                        call.resolve()
-
+                        self.completeStartCamera(call: call)
                     }
                 }
             }
         })
+    }
+
+    override public func load() {
+        super.load()
+        // Initialize camera session in background for faster startup
+        prepareBackgroundCamera()
+    }
+
+    private func prepareBackgroundCamera() {
+        DispatchQueue.global(qos: .background).async {
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                guard granted else { return }
+                
+                // Pre-initialize camera controller for faster startup
+                DispatchQueue.main.async {
+                    self.cameraController.prepareBasicSession()
+                }
+            }
+        }
+    }
+
+    private func completeStartCamera(call: CAPPluginCall) {
+        // Create and configure the preview view first
+        self.updateCameraFrame()
+
+        // Make webview transparent - comprehensive approach
+        self.makeWebViewTransparent()
+
+        // Add the preview view to the webview itself to use same coordinate system
+        self.webView?.addSubview(self.previewView)
+        if self.toBack! {
+            self.webView?.sendSubviewToBack(self.previewView)
+        }
 
+        // Display the camera preview on the configured view
+        try? self.cameraController.displayPreview(on: self.previewView)
+
+        let frontView = self.toBack! ? self.webView : self.previewView
+        self.cameraController.setupGestures(target: frontView ?? self.previewView, enableZoom: self.enableZoom!)
+
+        // Add grid overlay if enabled
+        if self.gridMode != "none" {
+            self.cameraController.addGridOverlay(to: self.previewView, gridMode: self.gridMode)
+        }
+
+        if self.rotateWhenOrientationChanged == true {
+            NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
+        }
+
+        // Add observers for app state changes to maintain transparency
+        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appDidBecomeActive), name: UIApplication.didBecomeActiveNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
+
+        self.isInitializing = false
+        self.isInitialized = true
+
+        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)
     }
 
     @objc func flip(_ call: CAPPluginCall) {
@@ -363,13 +576,20 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                         try self.cameraController.switchCameras()
 
                         DispatchQueue.main.async {
+                            // Update preview layer frame without animation
+                            CATransaction.begin()
+                            CATransaction.setDisableActions(true)
                             self.cameraController.previewLayer?.frame = self.previewView.bounds
                             self.cameraController.previewLayer?.videoGravity = .resizeAspectFill
-                            self.previewView.isUserInteractionEnabled = true
+                            CATransaction.commit()
                             
+                            self.previewView.isUserInteractionEnabled = true
+
+
                             // Ensure webview remains transparent after flip
                             self.makeWebViewTransparent()
-                            
+
+
                             call.resolve()
                         }
                     } catch {
@@ -406,6 +626,7 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
             }
 
             // Always attempt to stop and clean up, regardless of captureSession state
+            self.cameraController.removeGridOverlay()
             if let previewView = self.previewView {
                 previewView.removeFromSuperview()
                 self.previewView = nil
@@ -415,7 +636,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
             self.isInitialized = false
             self.isInitializing = false
             self.cameraController.cleanup()
-            
+
+
             // Remove notification observers
             NotificationCenter.default.removeObserver(self)
 
@@ -436,41 +658,181 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
     @objc func capture(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
 
-            let quality: Int? = call.getInt("quality", 85)
-
-            self.cameraController.captureImage { (image, error) in
+            let quality = call.getFloat("quality", 85)
+            let saveToGallery = call.getBool("saveToGallery", false)
+            let withExifLocation = call.getBool("withExifLocation", false)
+            let width = call.getInt("width")
+            let height = call.getInt("height")
+
+            if withExifLocation {
+                self.locationManager = CLLocationManager()
+                self.locationManager?.delegate = self
+                self.locationManager?.requestWhenInUseAuthorization()
+                self.locationManager?.startUpdatingLocation()
+            }
 
-                guard let image = image else {
-                    print(error ?? "Image capture error")
-                    guard let error = error else {
-                        call.reject("Image capture error")
-                        return
-                    }
+            self.cameraController.captureImage(width: width, height: height, quality: quality, gpsLocation: self.currentLocation) { (image, error) in
+                if let error = error {
                     call.reject(error.localizedDescription)
                     return
                 }
-                let imageData: Data?
-                if self.cameraController.currentCameraPosition == .front {
-                    let flippedImage = image.withHorizontallyFlippedOrientation()
-                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
-                } else {
-                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
+
+                        var gallerySuccess = true
+            var galleryError: String?
+            
+            let group = DispatchGroup()
+            
+            group.notify(queue: .main) {
+                guard let imageDataWithExif = self.createImageDataWithExif(from: image!, quality: Int(quality), location: withExifLocation ? self.currentLocation : nil) else {
+                    call.reject("Failed to create image data with EXIF")
+                    return
                 }
 
-                if self.storeToFile == false {
-                    let imageBase64 = imageData?.base64EncodedString()
-                    call.resolve(["value": imageBase64!])
-                } else {
-                    do {
-                        let fileUrl=self.getTempFilePath()
-                        try imageData?.write(to: fileUrl)
-                        call.resolve(["value": fileUrl.absoluteString])
-                    } catch {
-                        call.reject("error writing image to file")
+                if saveToGallery {
+                    group.enter()
+                    self.saveImageDataToGallery(imageData: imageDataWithExif) { success, error in
+                        gallerySuccess = success
+                        if !success {
+                            galleryError = error?.localizedDescription ?? "Unknown error"
+                            print("CameraPreview: Error saving image to gallery: \(galleryError!)")
+                        }
+                        group.leave()
                     }
+                    
+                    group.notify(queue: .main) {
+                        let exifData = self.getExifData(from: imageDataWithExif)
+                        let base64Image = imageDataWithExif.base64EncodedString()
+
+                        var result = JSObject()
+                        result["value"] = base64Image
+                        result["exif"] = exifData
+                        result["gallerySaved"] = gallerySuccess
+                        if !gallerySuccess, let error = galleryError {
+                            result["galleryError"] = error
+                        }
+                        
+                        call.resolve(result)
+                    }
+                } else {
+                    let exifData = self.getExifData(from: imageDataWithExif)
+                    let base64Image = imageDataWithExif.base64EncodedString()
+
+                    var result = JSObject()
+                    result["value"] = base64Image
+                    result["exif"] = exifData
+                    
+                    call.resolve(result)
                 }
             }
+            }
+        }
+    }
+
+    private func getExifData(from imageData: Data) -> JSObject {
+        guard let imageSource = CGImageSourceCreateWithData(imageData as CFData, nil),
+              let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [String: Any],
+              let exifDict = imageProperties[kCGImagePropertyExifDictionary as String] as? [String: Any] else {
+            return [:]
+        }
+
+
+        var exifData = JSObject()
+        for (key, value) in exifDict {
+            // Convert value to JSValue-compatible type
+            if let stringValue = value as? String {
+                exifData[key] = stringValue
+            } else if let numberValue = value as? NSNumber {
+                exifData[key] = numberValue
+            } else if let boolValue = value as? Bool {
+                exifData[key] = boolValue
+            } else if let arrayValue = value as? [Any] {
+                exifData[key] = arrayValue
+            } else if let dictValue = value as? [String: Any] {
+                exifData[key] = JSObject(_immutableCocoaDictionary: NSMutableDictionary(dictionary: dictValue))
+            } else {
+                // Convert other types to string as fallback
+                exifData[key] = String(describing: value)
+            }
+        }
+
+
+        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 {
+            return nil
+        }
+        
+        guard let imageSource = CGImageSourceCreateWithData(originalImageData as CFData, nil),
+              let imageProperties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) as? [String: Any],
+              let cgImage = image.cgImage else {
+            return originalImageData
+        }
+        
+        let mutableData = NSMutableData()
+        guard let destination = CGImageDestinationCreateWithData(mutableData, kUTTypeJPEG, 1, nil) else {
+            return originalImageData
+        }
+        
+        var finalProperties = imageProperties
+        
+        // Add GPS location if available
+        if let location = location {
+            let formatter = DateFormatter()
+            formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
+            formatter.timeZone = TimeZone(abbreviation: "UTC")
+            
+            let gpsDict: [String: Any] = [
+                kCGImagePropertyGPSLatitude as String: abs(location.coordinate.latitude),
+                kCGImagePropertyGPSLatitudeRef as String: location.coordinate.latitude >= 0 ? "N" : "S",
+                kCGImagePropertyGPSLongitude as String: abs(location.coordinate.longitude),
+                kCGImagePropertyGPSLongitudeRef as String: location.coordinate.longitude >= 0 ? "E" : "W",
+                kCGImagePropertyGPSTimeStamp as String: formatter.string(from: location.timestamp),
+                kCGImagePropertyGPSAltitude as String: location.altitude,
+                kCGImagePropertyGPSAltitudeRef as String: location.altitude >= 0 ? 0 : 1
+            ]
+            
+            finalProperties[kCGImagePropertyGPSDictionary as String] = gpsDict
         }
+        
+        // Add lens information
+        do {
+            let currentZoom = try self.cameraController.getZoom()
+            let lensInfo = try self.cameraController.getCurrentLensInfo()
+            
+            // Create or update EXIF dictionary
+            var exifDict = finalProperties[kCGImagePropertyExifDictionary as String] as? [String: Any] ?? [:]
+            
+            // Add focal length (in mm)
+            exifDict[kCGImagePropertyExifFocalLength as String] = lensInfo.focalLength
+            
+            // Add digital zoom ratio
+            let digitalZoom = Float(currentZoom.current) / lensInfo.baseZoomRatio
+            exifDict[kCGImagePropertyExifDigitalZoomRatio as String] = digitalZoom
+            
+            // Add lens model info
+            exifDict[kCGImagePropertyExifLensModel as String] = lensInfo.deviceType
+            
+            finalProperties[kCGImagePropertyExifDictionary as String] = exifDict
+            
+            // Create or update TIFF dictionary for device info
+            var tiffDict = finalProperties[kCGImagePropertyTIFFDictionary as String] as? [String: Any] ?? [:]
+            tiffDict[kCGImagePropertyTIFFMake as String] = "Apple"
+            tiffDict[kCGImagePropertyTIFFModel as String] = UIDevice.current.model
+            finalProperties[kCGImagePropertyTIFFDictionary as String] = tiffDict
+            
+        } catch {
+            print("CameraPreview: Failed to get lens information: \(error)")
+        }
+        
+        CGImageDestinationAddImage(destination, cgImage, finalProperties as CFDictionary)
+        
+        if CGImageDestinationFinalize(destination) {
+            return mutableData as Data
+        }
+        
+        return originalImageData
     }
 
     @objc func captureSample(_ call: CAPPluginCall) {
@@ -612,9 +974,11 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         // Collect all devices by position
         for device in session.devices {
             var lenses: [[String: Any]] = []
-            
+
+
             let constituentDevices = device.isVirtualDevice ? device.constituentDevices : [device]
-            
+
+
             for lensDevice in constituentDevices {
                 var deviceType: String
                 switch lensDevice.deviceType {
@@ -634,7 +998,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 } else if lensDevice.deviceType == .builtInTelephotoCamera {
                     baseZoomRatio = 2.0 // A common value for telephoto lenses
                 }
-                
+
+
                 let lensInfo: [String: Any] = [
                     "label": lensDevice.localizedName,
                     "deviceType": deviceType,
@@ -645,7 +1010,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 ]
                 lenses.append(lensInfo)
             }
-            
+
+
             let deviceData: [String: Any] = [
                 "deviceId": device.uniqueID,
                 "label": device.localizedName,
@@ -655,7 +1021,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                 "maxZoom": Float(device.maxAvailableVideoZoomFactor),
                 "isLogical": device.isVirtualDevice
             ]
-            
+
+
             devices.append(deviceData)
         }
 
@@ -671,7 +1038,8 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         do {
             let zoomInfo = try self.cameraController.getZoom()
             let lensInfo = try self.cameraController.getCurrentLensInfo()
-            
+
+
             var minZoom = zoomInfo.min
             var maxZoom = zoomInfo.max
             var currentZoom = zoomInfo.current
@@ -764,13 +1132,20 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
                     try self.cameraController.swapToDevice(deviceId: deviceId)
 
                     DispatchQueue.main.async {
+                        // Update preview layer frame without animation
+                        CATransaction.begin()
+                        CATransaction.setDisableActions(true)
                         self.cameraController.previewLayer?.frame = self.previewView.bounds
                         self.cameraController.previewLayer?.videoGravity = .resizeAspectFill
-                        self.previewView.isUserInteractionEnabled = true
+                        CATransaction.commit()
                         
+                        self.previewView.isUserInteractionEnabled = true
+
+
                         // Ensure webview remains transparent after device switch
                         self.makeWebViewTransparent()
-                        
+
+
                         call.resolve()
                     }
                 } catch {
@@ -797,6 +1172,198 @@ public class CameraPreview: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        self.currentLocation = locations.last
+        self.locationManager?.stopUpdatingLocation()
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        print("CameraPreview: Failed to get location: \(error.localizedDescription)")
+    }
+
+    private func saveImageDataToGallery(imageData: Data, completion: @escaping (Bool, Error?) -> Void) {
+        // Check if NSPhotoLibraryUsageDescription is present in Info.plist
+        guard Bundle.main.object(forInfoDictionaryKey: "NSPhotoLibraryUsageDescription") != nil else {
+            let error = NSError(domain: "CameraPreview", code: 2, userInfo: [
+                NSLocalizedDescriptionKey: "NSPhotoLibraryUsageDescription key missing from Info.plist. Add this key with a description of how your app uses photo library access."
+            ])
+            completion(false, error)
+            return
+        }
+        
+        let status = PHPhotoLibrary.authorizationStatus()
+        
+        switch status {
+        case .authorized:
+            performSaveDataToGallery(imageData: imageData, completion: completion)
+        case .notDetermined:
+            PHPhotoLibrary.requestAuthorization { newStatus in
+                DispatchQueue.main.async {
+                    if newStatus == .authorized {
+                        self.performSaveDataToGallery(imageData: imageData, completion: completion)
+                    } else {
+                        completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Photo library access denied"]))
+                    }
+                }
+            }
+        case .denied, .restricted:
+            completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Photo library access denied"]))
+        case .limited:
+            performSaveDataToGallery(imageData: imageData, completion: completion)
+        @unknown default:
+            completion(false, NSError(domain: "CameraPreview", code: 1, userInfo: [NSLocalizedDescriptionKey: "Unknown photo library authorization status"]))
+        }
+    }
+    
+    private func performSaveDataToGallery(imageData: Data, completion: @escaping (Bool, Error?) -> Void) {
+        // Create a temporary file to write the JPEG data with EXIF
+        let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".jpg")
+        
+        do {
+            try imageData.write(to: tempURL)
+            
+            PHPhotoLibrary.shared().performChanges({
+                PHAssetChangeRequest.creationRequestForAssetFromImage(atFileURL: tempURL)
+            }, completionHandler: { success, error in
+                // Clean up temporary file
+                try? FileManager.default.removeItem(at: tempURL)
+                
+                DispatchQueue.main.async {
+                    completion(success, error)
+                }
+            })
+        } catch {
+            DispatchQueue.main.async {
+                completion(false, error)
+            }
+        }
+    }
+
+    private func updateCameraFrame() {
+        guard let width = self.width, var height = self.height, let posX = self.posX, let posY = self.posY else {
+            return
+        }
+
+        let paddingBottom = self.paddingBottom ?? 0
+        height -= paddingBottom
+
+        // Cache webView dimensions for performance
+        let webViewWidth = self.webView?.frame.width ?? UIScreen.main.bounds.width
+        let webViewHeight = self.webView?.frame.height ?? UIScreen.main.bounds.height
 
+        var finalX = posX
+        var finalY = posY
+        var finalWidth = width
+        var finalHeight = height
 
+        // Handle auto-centering when position is -1
+        if posX == -1 || posY == -1 {
+            finalWidth = webViewWidth
+            
+            // Calculate height based on aspect ratio or use provided height
+            if 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]
+                    finalHeight = finalWidth / CGFloat(ratio)
+                }
+            }
+            
+            finalX = posX == -1 ? 0 : posX
+            
+            if posY == -1 {
+                let availableHeight = webViewHeight - paddingBottom
+                finalY = finalHeight < availableHeight ? (availableHeight - finalHeight) / 2 : 0
+            }
+        }
+
+        var frame = CGRect(x: finalX, y: finalY, width: finalWidth, height: finalHeight)
+
+        // 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(finalWidth) / Double(finalHeight)
+                
+                if currentRatio > ratio {
+                    let newWidth = Double(finalHeight) * ratio
+                    frame.origin.x = finalX + (Double(finalWidth) - newWidth) / 2
+                    frame.size.width = CGFloat(newWidth)
+                } else {
+                    let newHeight = Double(finalWidth) / ratio
+                    frame.origin.y = finalY + (Double(finalHeight) - newHeight) / 2
+                    frame.size.height = CGFloat(newHeight)
+                }
+            }
+        }
+
+        // Disable ALL animations for frame updates - we want instant positioning
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        
+        // Batch UI updates for better performance
+        if self.previewView == nil {
+            self.previewView = UIView(frame: frame)
+            self.previewView.backgroundColor = UIColor.clear
+        } else {
+            self.previewView.frame = frame
+        }
+
+        // Update preview layer frame efficiently
+        if let previewLayer = self.cameraController.previewLayer {
+            previewLayer.frame = self.previewView.bounds
+        }
+        
+        // Update grid overlay frame if it exists
+        if let gridOverlay = self.cameraController.gridOverlayView {
+            gridOverlay.frame = self.previewView.bounds
+        }
+        
+        CATransaction.commit()
+    }
+
+    @objc func getPreviewSize(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+        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)
+    }
+
+    @objc func setPreviewSize(_ call: CAPPluginCall) {
+        guard self.isInitialized else {
+            call.reject("camera not started")
+            return
+        }
+        
+        // Only update position if explicitly provided, otherwise keep auto-centering
+        if let x = call.getInt("x") { 
+            self.posX = CGFloat(x) 
+        }
+        if let y = call.getInt("y") { 
+            self.posY = CGFloat(y) 
+        }
+        if let width = call.getInt("width") { self.width = CGFloat(width) }
+        if let height = call.getInt("height") { self.height = CGFloat(height) }
+        
+        // Direct update without animation for better performance
+        self.updateCameraFrame()
+        self.makeWebViewTransparent()
+        
+        // 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)
+    }
 }