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

package/ios/{Plugin → Sources/CapgoCameraPreview}/CameraController.swift

@@ -8,6 +8,7 @@
 
 import AVFoundation
 import UIKit
+import CoreLocation
 
 class CameraController: NSObject {
     var captureSession: AVCaptureSession?
@@ -26,6 +27,7 @@ class CameraController: NSObject {
     var fileVideoOutput: AVCaptureMovieFileOutput?
 
     var previewLayer: AVCaptureVideoPreviewLayer?
+    var gridOverlayView: GridOverlayView?
 
     var flashMode = AVCaptureDevice.FlashMode.off
     var photoCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
@@ -38,36 +40,129 @@ class CameraController: NSObject {
     var audioInput: AVCaptureDeviceInput?
 
     var zoomFactor: CGFloat = 1.0
+    private var lastZoomUpdateTime: TimeInterval = 0
+    private let zoomUpdateThrottle: TimeInterval = 1.0 / 60.0 // 60 FPS max
 
     var videoFileURL: URL?
+    private let saneMaxZoomFactor: CGFloat = 25.5
+
+    var isUsingMultiLensVirtualCamera: Bool {
+        guard let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera else { return false }
+        // A rear multi-lens virtual camera will have a min zoom of 1.0 but support wider angles
+        return device.position == .back && device.isVirtualDevice && device.constituentDevices.count > 1
+    }
 }
 
 extension CameraController {
-    func prepare(cameraPosition: String, disableAudio: Bool, cameraMode: Bool, completionHandler: @escaping (Error?) -> Void) {
+    func prepareBasicSession() {
+        // Only prepare if we don't already have a session
+        guard self.captureSession == nil else { return }
+        
+        print("[CameraPreview] Preparing basic camera session in background")
+        
+        // Create basic capture session
+        self.captureSession = AVCaptureSession()
+        
+        // Configure basic devices without full preparation
+        let deviceTypes: [AVCaptureDevice.DeviceType] = [
+            .builtInWideAngleCamera,
+            .builtInUltraWideCamera,
+            .builtInTelephotoCamera,
+            .builtInDualCamera,
+            .builtInDualWideCamera,
+            .builtInTripleCamera,
+            .builtInTrueDepthCamera
+        ]
+
+        let session = AVCaptureDevice.DiscoverySession(deviceTypes: deviceTypes, mediaType: AVMediaType.video, position: .unspecified)
+        let cameras = session.devices.compactMap { $0 }
+        
+        // Find best cameras
+        let rearVirtualDevices = cameras.filter { $0.position == .back && $0.isVirtualDevice }
+        let bestRearVirtualDevice = rearVirtualDevices.max { $0.constituentDevices.count < $1.constituentDevices.count }
+        
+        self.frontCamera = cameras.first(where: { $0.position == .front })
+        
+        if let bestCamera = bestRearVirtualDevice {
+            self.rearCamera = bestCamera
+        } else if let firstRearCamera = cameras.first(where: { $0.position == .back }) {
+            self.rearCamera = firstRearCamera
+        }
+        
+        print("[CameraPreview] Basic session prepared with \(cameras.count) devices")
+    }
+
+    func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, completionHandler: @escaping (Error?) -> Void) {
         func createCaptureSession() {
-            self.captureSession = AVCaptureSession()
+            // Use existing session if available from background preparation
+            if self.captureSession == nil {
+                self.captureSession = AVCaptureSession()
+            }
         }
 
         func configureCaptureDevices() throws {
+            // Skip device discovery if cameras are already found during background preparation
+            if self.frontCamera != nil || self.rearCamera != nil {
+                print("[CameraPreview] Using pre-discovered cameras")
+                return
+            }
+            
+            // Expanded device types to support more camera configurations
+            let deviceTypes: [AVCaptureDevice.DeviceType] = [
+                .builtInWideAngleCamera,
+                .builtInUltraWideCamera,
+                .builtInTelephotoCamera,
+                .builtInDualCamera,
+                .builtInDualWideCamera,
+                .builtInTripleCamera,
+                .builtInTrueDepthCamera
+            ]
 
-            let session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera], mediaType: AVMediaType.video, position: .unspecified)
+            let session = AVCaptureDevice.DiscoverySession(deviceTypes: deviceTypes, mediaType: AVMediaType.video, position: .unspecified)
 
             let cameras = session.devices.compactMap { $0 }
-            guard !cameras.isEmpty else { throw CameraControllerError.noCamerasAvailable }
 
+            // Log all found devices for debugging
+            print("[CameraPreview] Found \(cameras.count) devices:")
             for camera in cameras {
-                if camera.position == .front {
-                    self.frontCamera = camera
-                }
+                let constituentCount = camera.isVirtualDevice ? camera.constituentDevices.count : 1
+                print("[CameraPreview] - \(camera.localizedName) (Position: \(camera.position.rawValue), Virtual: \(camera.isVirtualDevice), Lenses: \(constituentCount), Zoom: \(camera.minAvailableVideoZoomFactor)-\(camera.maxAvailableVideoZoomFactor))")
+            }
+
+            guard !cameras.isEmpty else {
+                print("[CameraPreview] ERROR: No cameras found.")
+                throw CameraControllerError.noCamerasAvailable
+            }
+
+            // --- Corrected Device Selection Logic ---
+            // Find the virtual device with the most constituent cameras (this is the most capable one)
+            let rearVirtualDevices = cameras.filter { $0.position == .back && $0.isVirtualDevice }
+            let bestRearVirtualDevice = rearVirtualDevices.max { $0.constituentDevices.count < $1.constituentDevices.count }
+
+            self.frontCamera = cameras.first(where: { $0.position == .front })
 
-                if camera.position == .back {
-                    self.rearCamera = camera
+            if let bestCamera = bestRearVirtualDevice {
+                self.rearCamera = bestCamera
+                print("[CameraPreview] Selected best virtual rear camera: \(bestCamera.localizedName) with \(bestCamera.constituentDevices.count) physical cameras.")
+            } else if let firstRearCamera = cameras.first(where: { $0.position == .back }) {
+                // Fallback for devices without a virtual camera system
+                self.rearCamera = firstRearCamera
+                print("[CameraPreview] WARN: No virtual rear camera found. Selected first available: \(firstRearCamera.localizedName)")
+            }
+            // --- End of Correction ---
 
-                    try camera.lockForConfiguration()
-                    camera.focusMode = .continuousAutoFocus
-                    camera.unlockForConfiguration()
+            if let rearCamera = self.rearCamera {
+                do {
+                    try rearCamera.lockForConfiguration()
+                    if rearCamera.isFocusModeSupported(.continuousAutoFocus) {
+                        rearCamera.focusMode = .continuousAutoFocus
+                    }
+                    rearCamera.unlockForConfiguration()
+                } catch {
+                    print("[CameraPreview] WARN: Could not set focus mode on rear camera. \(error)")
                 }
             }
+
             if disableAudio == false {
                 self.audioDevice = AVCaptureDevice.default(for: AVMediaType.audio)
             }
@@ -76,23 +171,72 @@ extension CameraController {
         func configureDeviceInputs() throws {
             guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
-            if cameraPosition == "rear" {
-                if let rearCamera = self.rearCamera {
-                    self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera)
+            var selectedDevice: AVCaptureDevice?
 
-                    if captureSession.canAddInput(self.rearCameraInput!) { captureSession.addInput(self.rearCameraInput!) }
+            // If deviceId is specified, use that specific device
+            if let deviceId = deviceId {
+                let allDevices = AVCaptureDevice.DiscoverySession(
+                    deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera, .builtInTelephotoCamera, .builtInDualCamera, .builtInDualWideCamera, .builtInTripleCamera, .builtInTrueDepthCamera],
+                    mediaType: .video,
+                    position: .unspecified
+                ).devices
 
-                    self.currentCameraPosition = .rear
+                selectedDevice = allDevices.first(where: { $0.uniqueID == deviceId })
+                guard selectedDevice != nil else {
+                    throw CameraControllerError.noCamerasAvailable
                 }
-            } else if cameraPosition == "front" {
-                if let frontCamera = self.frontCamera {
-                    self.frontCameraInput = try AVCaptureDeviceInput(device: frontCamera)
+            } else {
+                // Use position-based selection
+                if cameraPosition == "rear" {
+                    selectedDevice = self.rearCamera
+                } else if cameraPosition == "front" {
+                    selectedDevice = self.frontCamera
+                }
+            }
 
-                    if captureSession.canAddInput(self.frontCameraInput!) { captureSession.addInput(self.frontCameraInput!) } else { throw CameraControllerError.inputsAreInvalid }
+            guard let finalDevice = selectedDevice else {
+                print("[CameraPreview] ERROR: No camera device selected for position: \(cameraPosition)")
+                throw CameraControllerError.noCamerasAvailable
+            }
+
+            print("[CameraPreview] Configuring device: \(finalDevice.localizedName)")
+            let deviceInput = try AVCaptureDeviceInput(device: finalDevice)
 
+            if captureSession.canAddInput(deviceInput) {
+                captureSession.addInput(deviceInput)
+
+                if finalDevice.position == .front {
+                    self.frontCameraInput = deviceInput
+                    self.frontCamera = finalDevice
                     self.currentCameraPosition = .front
+                } else {
+                    self.rearCameraInput = deviceInput
+                    self.rearCamera = finalDevice
+                    self.currentCameraPosition = .rear
+
+                    // --- Corrected Initial Zoom Logic ---
+                    try finalDevice.lockForConfiguration()
+                    if finalDevice.isFocusModeSupported(.continuousAutoFocus) {
+                        finalDevice.focusMode = .continuousAutoFocus
+                    }
+
+                    // On a multi-camera system, a zoom factor of 2.0 often corresponds to the standard "1x" wide-angle lens.
+                    // We set this as the default to provide a familiar starting point for users.
+                    let defaultWideAngleZoom: CGFloat = 2.0
+                    if finalDevice.isVirtualDevice && finalDevice.constituentDevices.count > 1 && finalDevice.videoZoomFactor != defaultWideAngleZoom {
+                        // Check if 2.0 is a valid zoom factor before setting it.
+                        if defaultWideAngleZoom >= finalDevice.minAvailableVideoZoomFactor && defaultWideAngleZoom <= finalDevice.maxAvailableVideoZoomFactor {
+                             print("[CameraPreview] Multi-camera system detected. Setting initial zoom to \(defaultWideAngleZoom) (standard wide-angle).")
+                             finalDevice.videoZoomFactor = defaultWideAngleZoom
+                        }
+                    }
+                    finalDevice.unlockForConfiguration()
+                    // --- End of Correction ---
                 }
-            } else { throw CameraControllerError.noCamerasAvailable }
+            } else {
+                print("[CameraPreview] ERROR: Cannot add device input to session.")
+                throw CameraControllerError.inputsAreInvalid
+            }
 
             // Add audio input
             if disableAudio == false {
@@ -110,11 +254,65 @@ extension CameraController {
         func configurePhotoOutput(cameraMode: Bool) throws {
             guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
-            //  TODO: check if that really useful
-            if !cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.photo) {
-                captureSession.sessionPreset = .photo
-            } else if cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.high) {
-                captureSession.sessionPreset = .high
+            // Configure session preset for high-quality preview
+            // Prioritize higher quality presets for better preview resolution
+            var targetPreset: AVCaptureSession.Preset = .high // Default to high quality
+
+            if let aspectRatio = aspectRatio {
+                switch aspectRatio {
+                case "16:9":
+                    // Use highest available HD preset for 16:9 aspect ratio
+                    if captureSession.canSetSessionPreset(.hd4K3840x2160) {
+                        targetPreset = .hd4K3840x2160
+                    } else if captureSession.canSetSessionPreset(.hd1920x1080) {
+                        targetPreset = .hd1920x1080
+                    } else if captureSession.canSetSessionPreset(.hd1280x720) {
+                        targetPreset = .hd1280x720
+                    } else {
+                        targetPreset = .high
+                    }
+                case "4:3":
+                    // Use photo preset for 4:3 aspect ratio (highest quality)
+                    if captureSession.canSetSessionPreset(.photo) {
+                        targetPreset = .photo
+                    } else if captureSession.canSetSessionPreset(.high) {
+                        targetPreset = .high
+                    } else {
+                        targetPreset = .medium
+                    }
+                default:
+                    // Default to highest available quality
+                    if captureSession.canSetSessionPreset(.photo) {
+                        targetPreset = .photo
+                    } else if captureSession.canSetSessionPreset(.high) {
+                        targetPreset = .high
+                    } else {
+                        targetPreset = .medium
+                    }
+                }
+            } else {
+                // Default to highest available quality when no aspect ratio specified
+                if captureSession.canSetSessionPreset(.photo) {
+                    targetPreset = .photo
+                } else if captureSession.canSetSessionPreset(.high) {
+                    targetPreset = .high
+                } else {
+                    targetPreset = .medium
+                }
+            }
+
+            // Apply the determined preset
+            if captureSession.canSetSessionPreset(targetPreset) {
+                captureSession.sessionPreset = targetPreset
+                print("[CameraPreview] Set session preset to \(targetPreset) for aspect ratio: \(aspectRatio ?? "default")")
+            } else {
+                // Fallback to high quality preset if the target preset is not supported
+                print("[CameraPreview] Target preset \(targetPreset) not supported, falling back to .high")
+                if captureSession.canSetSessionPreset(.high) {
+                    captureSession.sessionPreset = .high
+                } else if captureSession.canSetSessionPreset(.medium) {
+                    captureSession.sessionPreset = .medium
+                }
             }
 
             self.photoOutput = AVCapturePhotoOutput()
@@ -173,15 +371,51 @@ extension CameraController {
     func displayPreview(on view: UIView) throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
 
+        print("[CameraPreview] displayPreview called with view frame: \(view.frame)")
+
         self.previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
         self.previewLayer?.videoGravity = AVLayerVideoGravity.resizeAspectFill
 
+        // Optimize preview layer for better quality
+        self.previewLayer?.connection?.videoOrientation = .portrait
+        self.previewLayer?.isOpaque = true
+
+        // Enable high-quality rendering
+        if #available(iOS 13.0, *) {
+            self.previewLayer?.videoGravity = .resizeAspectFill
+        }
+
         view.layer.insertSublayer(self.previewLayer!, at: 0)
-        self.previewLayer?.frame = view.frame
+        
+        // Disable animation for frame update
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        self.previewLayer?.frame = view.bounds
+        CATransaction.commit()
+
+        print("[CameraPreview] Set preview layer frame to view bounds: \(view.bounds)")
+        print("[CameraPreview] Session preset: \(captureSession.sessionPreset.rawValue)")
 
         updateVideoOrientation()
     }
 
+    func addGridOverlay(to view: UIView, gridMode: String) {
+        removeGridOverlay()
+
+        // Disable animation for grid overlay creation and positioning
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        gridOverlayView = GridOverlayView(frame: view.bounds)
+        gridOverlayView?.gridMode = gridMode
+        view.addSubview(gridOverlayView!)
+        CATransaction.commit()
+    }
+
+    func removeGridOverlay() {
+        gridOverlayView?.removeFromSuperview()
+        gridOverlayView = nil
+    }
+
     func setupGestures(target: UIView, enableZoom: Bool) {
         setupTapGesture(target: target, selector: #selector(handleTap(_:)), delegate: self)
         if enableZoom {
@@ -198,6 +432,10 @@ extension CameraController {
     func setupPinchGesture(target: UIView, selector: Selector, delegate: UIGestureRecognizerDelegate?) {
         let pinchGesture = UIPinchGestureRecognizer(target: self, action: selector)
         pinchGesture.delegate = delegate
+        // Optimize gesture recognition for better performance
+        pinchGesture.delaysTouchesBegan = false
+        pinchGesture.delaysTouchesEnded = false
+        pinchGesture.cancelsTouchesInView = false
         target.addGestureRecognizer(pinchGesture)
     }
 
@@ -213,7 +451,7 @@ extension CameraController {
 
     private func updateVideoOrientationOnMainThread() {
         let videoOrientation: AVCaptureVideoOrientation
-        
+
         // Use window scene interface orientation
         if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
             switch windowScene.interfaceOrientation {
@@ -244,19 +482,19 @@ extension CameraController {
               let captureSession = self.captureSession else {
             throw CameraControllerError.captureSessionIsMissing
         }
-        
+
         // Ensure we have the necessary cameras
         guard (currentCameraPosition == .front && rearCamera != nil) ||
               (currentCameraPosition == .rear && frontCamera != nil) else {
             throw CameraControllerError.noCamerasAvailable
         }
-        
+
         // Store the current running state
         let wasRunning = captureSession.isRunning
         if wasRunning {
             captureSession.stopRunning()
         }
-        
+
         // Begin configuration
         captureSession.beginConfiguration()
         defer {
@@ -268,7 +506,7 @@ extension CameraController {
                 }
             }
         }
-        
+
         // Store audio input if it exists
         let audioInput = captureSession.inputs.first { ($0 as? AVCaptureDeviceInput)?.device.hasMediaType(.audio) ?? false }
 
@@ -278,21 +516,21 @@ extension CameraController {
             captureSession.removeInput(input)
             }
         }
-        
+
         // Configure new camera
         switch currentCameraPosition {
         case .front:
             guard let rearCamera = rearCamera else {
                 throw CameraControllerError.invalidOperation
             }
-            
+
             // Configure rear camera
             try rearCamera.lockForConfiguration()
             if rearCamera.isFocusModeSupported(.continuousAutoFocus) {
                 rearCamera.focusMode = .continuousAutoFocus
             }
             rearCamera.unlockForConfiguration()
-            
+
             if let newInput = try? AVCaptureDeviceInput(device: rearCamera),
                 captureSession.canAddInput(newInput) {
                 captureSession.addInput(newInput)
@@ -306,13 +544,13 @@ extension CameraController {
                 throw CameraControllerError.invalidOperation
             }
 
-            // Configure front camera 
+            // Configure front camera
             try frontCamera.lockForConfiguration()
             if frontCamera.isFocusModeSupported(.continuousAutoFocus) {
                 frontCamera.focusMode = .continuousAutoFocus
             }
             frontCamera.unlockForConfiguration()
-    
+
             if let newInput = try? AVCaptureDeviceInput(device: frontCamera),
                 captureSession.canAddInput(newInput) {
                 captureSession.addInput(newInput)
@@ -327,22 +565,82 @@ extension CameraController {
         if let audioInput = audioInput, captureSession.canAddInput(audioInput) {
             captureSession.addInput(audioInput)
         }
-        
+
         // Update video orientation
         DispatchQueue.main.async { [weak self] in
             self?.updateVideoOrientation()
         }
     }
 
-    func captureImage(completion: @escaping (UIImage?, Error?) -> Void) {
-        guard let captureSession = captureSession, captureSession.isRunning else { completion(nil, CameraControllerError.captureSessionIsMissing); return }
+    func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Error?) -> Void) {
+        guard let photoOutput = self.photoOutput else {
+            completion(nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
+            return
+        }
+
         let settings = AVCapturePhotoSettings()
 
-        settings.flashMode = self.flashMode
-        settings.isHighResolutionPhotoEnabled = self.highResolutionOutput
+        self.photoCaptureCompletionBlock = { (image, error) in
+            if let error = error {
+                completion(nil, error)
+                return
+            }
+
+            guard let image = image else {
+                completion(nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to capture image"]))
+                return
+            }
+
+            if let location = gpsLocation {
+                self.addGPSMetadata(to: image, location: location)
+            }
 
-        self.photoOutput?.capturePhoto(with: settings, delegate: self)
-        self.photoCaptureCompletionBlock = completion
+            if let width = width, let height = height {
+                let resizedImage = self.resizeImage(image: image, to: CGSize(width: width, height: height))
+                completion(resizedImage, nil)
+            } else {
+                completion(image, nil)
+            }
+        }
+
+        photoOutput.capturePhoto(with: settings, delegate: self)
+    }
+
+    func addGPSMetadata(to image: UIImage, location: CLLocation) {
+        guard let jpegData = image.jpegData(compressionQuality: 1.0),
+              let source = CGImageSourceCreateWithData(jpegData as CFData, nil),
+              let uti = CGImageSourceGetType(source) else { return }
+
+        var metadata = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] ?? [:]
+
+        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
+        ]
+
+        metadata[kCGImagePropertyGPSDictionary as String] = gpsDict
+
+        let destData = NSMutableData()
+        guard let destination = CGImageDestinationCreateWithData(destData, uti, 1, nil) else { return }
+        CGImageDestinationAddImageFromSource(destination, source, 0, metadata as CFDictionary)
+        CGImageDestinationFinalize(destination)
+    }
+
+    func resizeImage(image: UIImage, to size: CGSize) -> UIImage? {
+        let renderer = UIGraphicsImageRenderer(size: size)
+        let resizedImage = renderer.image { (context) in
+            image.draw(in: CGRect(origin: .zero, size: size))
+        }
+        return resizedImage
     }
 
     func captureSample(completion: @escaping (UIImage?, Error?) -> Void) {
@@ -415,8 +713,15 @@ extension CameraController {
             throw CameraControllerError.noCamerasAvailable
         }
 
-        return device.activeFormat.videoFieldOfView
+        // Get the active format and field of view
+        let activeFormat = device.activeFormat
+        let fov = activeFormat.videoFieldOfView
+
+        // Adjust for current zoom level
+        let zoomFactor = device.videoZoomFactor
+        let adjustedFov = fov / Float(zoomFactor)
 
+        return adjustedFov
     }
     func setFlashMode(flashMode: AVCaptureDevice.FlashMode) throws {
         var currentCamera: AVCaptureDevice?
@@ -489,6 +794,231 @@ extension CameraController {
         }
     }
 
+    func getZoom() throws -> (min: Float, max: Float, current: Float) {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default: break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        let effectiveMaxZoom = min(device.maxAvailableVideoZoomFactor, self.saneMaxZoomFactor)
+
+        return (
+            min: Float(device.minAvailableVideoZoomFactor),
+            max: Float(effectiveMaxZoom),
+            current: Float(device.videoZoomFactor)
+        )
+    }
+
+    func setZoom(level: CGFloat, ramp: Bool) throws {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default: break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        let effectiveMaxZoom = min(device.maxAvailableVideoZoomFactor, self.saneMaxZoomFactor)
+        let zoomLevel = max(device.minAvailableVideoZoomFactor, min(level, effectiveMaxZoom))
+
+        do {
+            try device.lockForConfiguration()
+
+            if ramp {
+                // Use a very fast ramp rate for immediate response
+                device.ramp(toVideoZoomFactor: zoomLevel, withRate: 8.0)
+            } else {
+                device.videoZoomFactor = zoomLevel
+            }
+
+            device.unlockForConfiguration()
+
+            // Update our internal zoom factor tracking
+            self.zoomFactor = zoomLevel
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
+    func getFlashMode() throws -> String {
+        switch self.flashMode {
+        case .off:
+            return "off"
+        case .on:
+            return "on"
+        case .auto:
+            return "auto"
+        @unknown default:
+            return "off"
+        }
+    }
+
+    func getCurrentDeviceId() throws -> String {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        return device.uniqueID
+    }
+
+    func getCurrentLensInfo() throws -> (focalLength: Float, deviceType: String, baseZoomRatio: Float) {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        var deviceType = "wideAngle"
+        var baseZoomRatio: Float = 1.0
+
+        switch device.deviceType {
+        case .builtInWideAngleCamera:
+            deviceType = "wideAngle"
+            baseZoomRatio = 1.0
+        case .builtInUltraWideCamera:
+            deviceType = "ultraWide"
+            baseZoomRatio = 0.5
+        case .builtInTelephotoCamera:
+            deviceType = "telephoto"
+            baseZoomRatio = 2.0
+        case .builtInDualCamera:
+            deviceType = "dual"
+            baseZoomRatio = 1.0
+        case .builtInDualWideCamera:
+            deviceType = "dualWide"
+            baseZoomRatio = 1.0
+        case .builtInTripleCamera:
+            deviceType = "triple"
+            baseZoomRatio = 1.0
+        case .builtInTrueDepthCamera:
+            deviceType = "trueDepth"
+            baseZoomRatio = 1.0
+        default:
+            deviceType = "wideAngle"
+            baseZoomRatio = 1.0
+        }
+
+        // Approximate focal length for mobile devices
+        let focalLength: Float = 4.25
+
+        return (focalLength: focalLength, deviceType: deviceType, baseZoomRatio: baseZoomRatio)
+    }
+
+    func swapToDevice(deviceId: String) throws {
+        guard let captureSession = self.captureSession else {
+            throw CameraControllerError.captureSessionIsMissing
+        }
+
+        // Find the device with the specified deviceId
+        let allDevices = AVCaptureDevice.DiscoverySession(
+            deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera, .builtInTelephotoCamera, .builtInDualCamera, .builtInDualWideCamera, .builtInTripleCamera, .builtInTrueDepthCamera],
+            mediaType: .video,
+            position: .unspecified
+        ).devices
+
+        guard let targetDevice = allDevices.first(where: { $0.uniqueID == deviceId }) else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        // Store the current running state
+        let wasRunning = captureSession.isRunning
+        if wasRunning {
+            captureSession.stopRunning()
+        }
+
+        // Begin configuration
+        captureSession.beginConfiguration()
+        defer {
+            captureSession.commitConfiguration()
+            // Restart the session if it was running before
+            if wasRunning {
+                DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                    self?.captureSession?.startRunning()
+                }
+            }
+        }
+
+        // Store audio input if it exists
+        let audioInput = captureSession.inputs.first { ($0 as? AVCaptureDeviceInput)?.device.hasMediaType(.audio) ?? false }
+
+        // Remove only video inputs
+        captureSession.inputs.forEach { input in
+            if (input as? AVCaptureDeviceInput)?.device.hasMediaType(.video) ?? false {
+                captureSession.removeInput(input)
+            }
+        }
+
+        // Configure the new device
+        let newInput = try AVCaptureDeviceInput(device: targetDevice)
+
+        if captureSession.canAddInput(newInput) {
+            captureSession.addInput(newInput)
+
+            // Update camera references based on device position
+            if targetDevice.position == .front {
+                self.frontCameraInput = newInput
+                self.frontCamera = targetDevice
+                self.currentCameraPosition = .front
+            } else {
+                self.rearCameraInput = newInput
+                self.rearCamera = targetDevice
+                self.currentCameraPosition = .rear
+
+                // Configure rear camera
+                try targetDevice.lockForConfiguration()
+                if targetDevice.isFocusModeSupported(.continuousAutoFocus) {
+                    targetDevice.focusMode = .continuousAutoFocus
+                }
+                targetDevice.unlockForConfiguration()
+            }
+        } else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        // Re-add audio input if it existed
+        if let audioInput = audioInput, captureSession.canAddInput(audioInput) {
+            captureSession.addInput(audioInput)
+        }
+
+        // Update video orientation
+        DispatchQueue.main.async { [weak self] in
+            self?.updateVideoOrientation()
+        }
+    }
+
+
+
     func cleanup() {
         if let captureSession = self.captureSession {
             captureSession.stopRunning()
@@ -609,30 +1139,42 @@ extension CameraController: UIGestureRecognizerDelegate {
         }
     }
 
-    @objc
+        @objc
     private func handlePinch(_ pinch: UIPinchGestureRecognizer) {
         guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
 
-        func minMaxZoom(_ factor: CGFloat) -> CGFloat { return max(1.0, min(factor, device.activeFormat.videoMaxZoomFactor)) }
+        let effectiveMaxZoom = min(device.maxAvailableVideoZoomFactor, self.saneMaxZoomFactor)
+        func minMaxZoom(_ factor: CGFloat) -> CGFloat { return max(device.minAvailableVideoZoomFactor, min(factor, effectiveMaxZoom)) }
+
+        switch pinch.state {
+        case .began:
+            // Store the initial zoom factor when pinch begins
+            zoomFactor = device.videoZoomFactor
 
-        func update(scale factor: CGFloat) {
+                case .changed:
+            // Throttle zoom updates to prevent excessive CPU usage
+            let currentTime = CACurrentMediaTime()
+            guard currentTime - lastZoomUpdateTime >= zoomUpdateThrottle else { return }
+            lastZoomUpdateTime = currentTime
+
+            // Calculate new zoom factor based on pinch scale
+            let newScaleFactor = minMaxZoom(pinch.scale * zoomFactor)
+
+            // Use ramping for smooth zoom transitions during pinch
+            // This provides much smoother performance than direct setting
             do {
                 try device.lockForConfiguration()
-                defer { device.unlockForConfiguration() }
-
-                device.videoZoomFactor = factor
+                // Use a very fast ramp rate for immediate response
+                device.ramp(toVideoZoomFactor: newScaleFactor, withRate: 5.0)
+                device.unlockForConfiguration()
             } catch {
-                debugPrint(error)
+                debugPrint("Failed to set zoom: \(error)")
             }
-        }
 
-        switch pinch.state {
-        case .began: fallthrough
-        case .changed:
-            let newScaleFactor = minMaxZoom(pinch.scale * zoomFactor)
-            update(scale: newScaleFactor)
         case .ended:
+            // Update our internal zoom factor tracking
             zoomFactor = device.videoZoomFactor
+
         default: break
         }
     }