@capgo/camera-preview 7.4.0-beta.9 → 7.4.1

package/ios/Sources/CapgoCameraPreview/Plugin.swift

@@ -1,1369 +0,0 @@
-import Foundation
-import Capacitor
-import AVFoundation
-import Photos
-import CoreImage
-import CoreLocation
-import MobileCoreServices
-
-
-extension UIWindow {
-    static var isLandscape: Bool {
-        if #available(iOS 13.0, *) {
-            return UIApplication.shared.windows
-                .first?
-                .windowScene?
-                .interfaceOrientation
-                .isLandscape ?? false
-        } else {
-            return UIApplication.shared.statusBarOrientation.isLandscape
-        }
-    }
-    static var isPortrait: Bool {
-        if #available(iOS 13.0, *) {
-            return UIApplication.shared.windows
-                .first?
-                .windowScene?
-                .interfaceOrientation
-                .isPortrait ?? false
-        } else {
-            return UIApplication.shared.statusBarOrientation.isPortrait
-        }
-    }
-}
-
-/**
- * Please read the Capacitor iOS Plugin Development Guide
- * here: https://capacitor.ionicframework.com/docs/plugins/ios
- */
-@objc(CameraPreview)
-public class CameraPreview: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
-    public let identifier = "CameraPreviewPlugin"
-    public let jsName = "CameraPreview"
-    public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "flip", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "capture", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "captureSample", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getSupportedFlashModes", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getHorizontalFov", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "setFlashMode", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "startRecordVideo", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "stopRecordVideo", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getTempFilePath", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getSupportedPictureSizes", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getAvailableDevices", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getZoom", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "setZoom", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "getFlashMode", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "setDeviceId", 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()
-    let cameraController = CameraController()
-    var posX: CGFloat?
-    var posY: CGFloat?
-    var width: CGFloat?
-    var height: CGFloat?
-    var paddingBottom: CGFloat?
-    var rotateWhenOrientationChanged: Bool?
-    var toBack: Bool?
-    var storeToFile: Bool?
-    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()
-            webView.layoutIfNeeded()
-        }
-    }
-
-    @objc func rotated() {
-        guard let previewView = self.previewView,
-              let posX = self.posX,
-              let posY = self.posY,
-              let width = self.width,
-              let heightValue = self.height else {
-            return
-        }
-        let paddingBottom = self.paddingBottom ?? 0
-        let height = heightValue - paddingBottom
-
-        // 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.bounds
-            }
-            
-            CATransaction.commit()
-        }
-
-        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()
-
-        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 {
-                self.makeWebViewTransparent()
-            }
-        }
-    }
-
-
-    @objc func appWillEnterForeground() {
-        if self.isInitialized {
-            DispatchQueue.main.async {
-                self.makeWebViewTransparent()
-            }
-        }
-    }
-
-    struct CameraInfo {
-        let deviceID: String
-        let position: String
-        let pictureSizes: [CGSize]
-    }
-
-    func getSupportedPictureSizes() -> [CameraInfo] {
-        var cameraInfos = [CameraInfo]()
-
-        // Discover all available cameras
-        let deviceTypes: [AVCaptureDevice.DeviceType] = [
-            .builtInWideAngleCamera,
-            .builtInUltraWideCamera,
-            .builtInTelephotoCamera,
-            .builtInDualCamera,
-            .builtInDualWideCamera,
-            .builtInTripleCamera,
-            .builtInTrueDepthCamera
-        ]
-
-        let session = AVCaptureDevice.DiscoverySession(
-            deviceTypes: deviceTypes,
-            mediaType: .video,
-            position: .unspecified
-        )
-
-        let devices = session.devices
-
-        for device in devices {
-            // Determine the position of the camera
-            var position = "Unknown"
-            switch device.position {
-            case .front:
-                position = "Front"
-            case .back:
-                position = "Back"
-            case .unspecified:
-                position = "Unspecified"
-            @unknown default:
-                position = "Unknown"
-            }
-
-            var pictureSizes = [CGSize]()
-
-            // Get supported formats
-            for format in device.formats {
-                let description = format.formatDescription
-                let dimensions = CMVideoFormatDescriptionGetDimensions(description)
-                let size = CGSize(width: CGFloat(dimensions.width), height: CGFloat(dimensions.height))
-                if !pictureSizes.contains(size) {
-                    pictureSizes.append(size)
-                }
-            }
-
-            // Sort sizes in descending order (largest to smallest)
-            pictureSizes.sort { $0.width * $0.height > $1.width * $1.height }
-
-            let cameraInfo = CameraInfo(deviceID: device.uniqueID, position: position, pictureSizes: pictureSizes)
-            cameraInfos.append(cameraInfo)
-        }
-
-        return cameraInfos
-    }
-
-    @objc func getSupportedPictureSizes(_ call: CAPPluginCall) {
-        let cameraInfos = getSupportedPictureSizes()
-        call.resolve([
-            "supportedPictureSizes": cameraInfos.map {
-                return [
-                    "facing": $0.position,
-                    "supportedPictureSizes": $0.pictureSizes.map { size in
-                        return [
-                            "width": String(describing: size.width),
-                            "height": String(describing: size.height)
-                        ]
-                    }
-                ]
-            }
-        ])
-    }
-
-    @objc func start(_ call: CAPPluginCall) {
-        if self.isInitializing {
-            call.reject("camera initialization in progress")
-            return
-        }
-        if self.isInitialized {
-            call.reject("camera already started")
-            return
-        }
-        self.isInitializing = true
-
-        self.cameraPosition = call.getString("position") ?? "rear"
-        let deviceId = call.getString("deviceId")
-        let cameraMode = call.getBool("cameraMode") ?? false
-        self.highResolutionOutput = call.getBool("enableHighResolution") ?? false
-        self.cameraController.highResolutionOutput = self.highResolutionOutput
-
-        // 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
-        }
-
-        // 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
-        }
-
-        // 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")!)
-        }
-
-        self.rotateWhenOrientationChanged = call.getBool("rotateWhenOrientationChanged") ?? true
-        self.toBack = call.getBool("toBack") ?? true
-        self.storeToFile = call.getBool("storeToFile") ?? false
-        self.enableZoom = call.getBool("enableZoom") ?? 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 {
-                call.reject("permission failed")
-                return
-            }
-
-            DispatchQueue.main.async {
-                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) {error in
-                        if let error = error {
-                            print(error)
-                            call.reject(error.localizedDescription)
-                            return
-                        }
-                        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) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else {
-                call.reject("Camera controller deallocated")
-                return
-            }
-
-            // Disable user interaction during flip
-            self.previewView.isUserInteractionEnabled = false
-
-            // Perform camera switch on background thread
-            DispatchQueue.global(qos: .userInitiated).async {
-                var retryCount = 0
-                let maxRetries = 3
-
-                func attemptFlip() {
-                    do {
-                        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
-                            CATransaction.commit()
-                            
-                            self.previewView.isUserInteractionEnabled = true
-
-
-                            // Ensure webview remains transparent after flip
-                            self.makeWebViewTransparent()
-
-
-                            call.resolve()
-                        }
-                    } catch {
-                        retryCount += 1
-
-                        if retryCount < maxRetries {
-                            DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 0.5) {
-                                attemptFlip()
-                            }
-                        } else {
-                            DispatchQueue.main.async {
-                                self.previewView.isUserInteractionEnabled = true
-                                print("Failed to flip camera after \(maxRetries) attempts: \(error.localizedDescription)")
-                                call.reject("Failed to flip camera: \(error.localizedDescription)")
-                            }
-                        }
-                    }
-                }
-
-                attemptFlip()
-            }
-        }
-    }
-
-    @objc func stop(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            if self.isInitializing {
-                call.reject("cannot stop camera while initialization is in progress")
-                return
-            }
-            if !self.isInitialized {
-                call.reject("camera not initialized")
-                return
-            }
-
-            // Always attempt to stop and clean up, regardless of captureSession state
-            self.cameraController.removeGridOverlay()
-            if let previewView = self.previewView {
-                previewView.removeFromSuperview()
-                self.previewView = nil
-            }
-
-            self.webView?.isOpaque = true
-            self.isInitialized = false
-            self.isInitializing = false
-            self.cameraController.cleanup()
-
-
-            // Remove notification observers
-            NotificationCenter.default.removeObserver(self)
-
-            call.resolve()
-        }
-    }
-    // Get user's cache directory path
-    @objc func getTempFilePath() -> URL {
-        let path = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
-        let identifier = UUID()
-        let randomIdentifier = identifier.uuidString.replacingOccurrences(of: "-", with: "")
-        let finalIdentifier = String(randomIdentifier.prefix(8))
-        let fileName="cpcp_capture_"+finalIdentifier+".jpg"
-        let fileUrl=path.appendingPathComponent(fileName)
-        return fileUrl
-    }
-
-    @objc func capture(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-
-            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()
-            }
-
-            self.cameraController.captureImage(width: width, height: height, quality: quality, gpsLocation: self.currentLocation) { (image, error) in
-                if let error = error {
-                    call.reject(error.localizedDescription)
-                    return
-                }
-
-                        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 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) {
-        DispatchQueue.main.async {
-            let quality: Int? = call.getInt("quality", 85)
-
-            self.cameraController.captureSample { image, error in
-                guard let image = image else {
-                    print("Image capture error: \(String(describing: error))")
-                    call.reject("Image capture error: \(String(describing: error))")
-                    return
-                }
-
-                let imageData: Data?
-                if self.cameraPosition == "front" {
-                    let flippedImage = image.withHorizontallyFlippedOrientation()
-                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
-                } else {
-                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
-                }
-
-                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")
-                    }
-                }
-            }
-        }
-    }
-
-    @objc func getSupportedFlashModes(_ call: CAPPluginCall) {
-        do {
-            let supportedFlashModes = try self.cameraController.getSupportedFlashModes()
-            call.resolve(["result": supportedFlashModes])
-        } catch {
-            call.reject("failed to get supported flash modes")
-        }
-    }
-
-    @objc func getHorizontalFov(_ call: CAPPluginCall) {
-        do {
-            let horizontalFov = try self.cameraController.getHorizontalFov()
-            call.resolve(["result": horizontalFov])
-        } catch {
-            call.reject("failed to get FOV")
-        }
-    }
-
-    @objc func setFlashMode(_ call: CAPPluginCall) {
-        guard let flashMode = call.getString("flashMode") else {
-            call.reject("failed to set flash mode. required parameter flashMode is missing")
-            return
-        }
-        do {
-            var flashModeAsEnum: AVCaptureDevice.FlashMode?
-            switch flashMode {
-            case "off":
-                flashModeAsEnum = AVCaptureDevice.FlashMode.off
-            case "on":
-                flashModeAsEnum = AVCaptureDevice.FlashMode.on
-            case "auto":
-                flashModeAsEnum = AVCaptureDevice.FlashMode.auto
-            default: break
-            }
-            if flashModeAsEnum != nil {
-                try self.cameraController.setFlashMode(flashMode: flashModeAsEnum!)
-            } else if flashMode == "torch" {
-                try self.cameraController.setTorchMode()
-            } else {
-                call.reject("Flash Mode not supported")
-                return
-            }
-            call.resolve()
-        } catch {
-            call.reject("failed to set flash mode")
-        }
-    }
-
-    @objc func startRecordVideo(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            do {
-                try self.cameraController.captureVideo()
-                call.resolve()
-            } catch {
-                call.reject(error.localizedDescription)
-            }
-        }
-    }
-
-    @objc func stopRecordVideo(_ call: CAPPluginCall) {
-        DispatchQueue.main.async {
-            self.cameraController.stopRecording { (fileURL, error) in
-                guard let fileURL = fileURL else {
-                    print(error ?? "Video capture error")
-                    guard let error = error else {
-                        call.reject("Video capture error")
-                        return
-                    }
-                    call.reject(error.localizedDescription)
-                    return
-                }
-
-                call.resolve(["videoFilePath": fileURL.absoluteString])
-            }
-        }
-    }
-
-    @objc func isRunning(_ call: CAPPluginCall) {
-        let isRunning = self.isInitialized && (self.cameraController.captureSession?.isRunning ?? false)
-        call.resolve(["isRunning": isRunning])
-    }
-
-    @objc func getAvailableDevices(_ call: CAPPluginCall) {
-        let deviceTypes: [AVCaptureDevice.DeviceType] = [
-            .builtInWideAngleCamera,
-            .builtInUltraWideCamera,
-            .builtInTelephotoCamera,
-            .builtInDualCamera,
-            .builtInDualWideCamera,
-            .builtInTripleCamera,
-            .builtInTrueDepthCamera
-        ]
-
-        let session = AVCaptureDevice.DiscoverySession(
-            deviceTypes: deviceTypes,
-            mediaType: .video,
-            position: .unspecified
-        )
-
-        var devices: [[String: Any]] = []
-
-        // 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 {
-                    case .builtInWideAngleCamera: deviceType = "wideAngle"
-                    case .builtInUltraWideCamera: deviceType = "ultraWide"
-                    case .builtInTelephotoCamera: deviceType = "telephoto"
-                    case .builtInDualCamera: deviceType = "dual"
-                    case .builtInDualWideCamera: deviceType = "dualWide"
-                    case .builtInTripleCamera: deviceType = "triple"
-                    case .builtInTrueDepthCamera: deviceType = "trueDepth"
-                    default: deviceType = "unknown"
-                }
-
-                var baseZoomRatio: Float = 1.0
-                if lensDevice.deviceType == .builtInUltraWideCamera {
-                    baseZoomRatio = 0.5
-                } else if lensDevice.deviceType == .builtInTelephotoCamera {
-                    baseZoomRatio = 2.0 // A common value for telephoto lenses
-                }
-
-
-                let lensInfo: [String: Any] = [
-                    "label": lensDevice.localizedName,
-                    "deviceType": deviceType,
-                    "focalLength": 4.25, // Placeholder
-                    "baseZoomRatio": baseZoomRatio,
-                    "minZoom": Float(lensDevice.minAvailableVideoZoomFactor),
-                    "maxZoom": Float(lensDevice.maxAvailableVideoZoomFactor)
-                ]
-                lenses.append(lensInfo)
-            }
-
-
-            let deviceData: [String: Any] = [
-                "deviceId": device.uniqueID,
-                "label": device.localizedName,
-                "position": device.position == .front ? "front" : "rear",
-                "lenses": lenses,
-                "minZoom": Float(device.minAvailableVideoZoomFactor),
-                "maxZoom": Float(device.maxAvailableVideoZoomFactor),
-                "isLogical": device.isVirtualDevice
-            ]
-
-
-            devices.append(deviceData)
-        }
-
-        call.resolve(["devices": devices])
-    }
-
-    @objc func getZoom(_ call: CAPPluginCall) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        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
-
-            // 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
-            }
-
-            call.resolve([
-                "min": minZoom,
-                "max": maxZoom,
-                "current": currentZoom,
-                "lens": [
-                    "focalLength": lensInfo.focalLength,
-                    "deviceType": lensInfo.deviceType,
-                    "baseZoomRatio": lensInfo.baseZoomRatio,
-                    "digitalZoom": Float(currentZoom) / lensInfo.baseZoomRatio
-                ]
-            ])
-        } catch {
-            call.reject("Failed to get zoom: \(error.localizedDescription)")
-        }
-    }
-
-    @objc func setZoom(_ call: CAPPluginCall) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        guard var level = call.getFloat("level") else {
-            call.reject("level parameter is required")
-            return
-        }
-
-        // If using the multi-lens camera, translate the JS zoom value for the native layer
-        if self.cameraController.isUsingMultiLensVirtualCamera {
-            level += 0.5
-        }
-
-        let ramp = call.getBool("ramp") ?? true
-
-        do {
-            try self.cameraController.setZoom(level: CGFloat(level), ramp: ramp)
-            call.resolve()
-        } catch {
-            call.reject("Failed to set zoom: \(error.localizedDescription)")
-        }
-    }
-
-    @objc func getFlashMode(_ call: CAPPluginCall) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        do {
-            let flashMode = try self.cameraController.getFlashMode()
-            call.resolve(["flashMode": flashMode])
-        } catch {
-            call.reject("Failed to get flash mode: \(error.localizedDescription)")
-        }
-    }
-
-    @objc func setDeviceId(_ call: CAPPluginCall) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        guard let deviceId = call.getString("deviceId") else {
-            call.reject("deviceId parameter is required")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else {
-                call.reject("Camera controller deallocated")
-                return
-            }
-
-            // Disable user interaction during device swap
-            self.previewView.isUserInteractionEnabled = false
-
-            DispatchQueue.global(qos: .userInitiated).async {
-                do {
-                    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
-                        CATransaction.commit()
-                        
-                        self.previewView.isUserInteractionEnabled = true
-
-
-                        // Ensure webview remains transparent after device switch
-                        self.makeWebViewTransparent()
-
-
-                        call.resolve()
-                    }
-                } catch {
-                    DispatchQueue.main.async {
-                        self.previewView.isUserInteractionEnabled = true
-                        call.reject("Failed to swap to device \(deviceId): \(error.localizedDescription)")
-                    }
-                }
-            }
-        }
-    }
-
-        @objc func getDeviceId(_ call: CAPPluginCall) {
-        guard isInitialized else {
-            call.reject("Camera not initialized")
-            return
-        }
-
-        do {
-            let deviceId = try self.cameraController.getCurrentDeviceId()
-            call.resolve(["deviceId": deviceId])
-        } catch {
-            call.reject("Failed to get device ID: \(error.localizedDescription)")
-        }
-    }
-
-    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)
-    }
-}