@capgo/camera-preview 7.4.0-beta.8 → 7.4.0

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

@@ -1,11 +1,3 @@
-//
-//  CameraController.swift
-//  Plugin
-//
-//  Created by Ariel Hernandez Musa on 7/14/19.
-//  Copyright © 2019 Max Lynch. All rights reserved.
-//
-
 import AVFoundation
 import UIKit
 import CoreLocation
@@ -24,46 +16,78 @@ class CameraController: NSObject {
     var rearCamera: AVCaptureDevice?
     var rearCameraInput: AVCaptureDeviceInput?
 
+    var allDiscoveredDevices: [AVCaptureDevice] = []
+
     var fileVideoOutput: AVCaptureMovieFileOutput?
 
     var previewLayer: AVCaptureVideoPreviewLayer?
     var gridOverlayView: GridOverlayView?
+    var focusIndicatorView: UIView?
 
     var flashMode = AVCaptureDevice.FlashMode.off
-    var photoCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
+    var photoCaptureCompletionBlock: ((UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void)?
 
     var sampleBufferCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
 
-    var highResolutionOutput: Bool = false
+    // Add callback for detecting when first frame is ready
+    var firstFrameReadyCallback: (() -> Void)?
+    var hasReceivedFirstFrame = false
 
     var audioDevice: AVCaptureDevice?
     var audioInput: AVCaptureDeviceInput?
 
-    var zoomFactor: CGFloat = 1.0
+    var zoomFactor: CGFloat = 2.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
 
+    // Track output preparation status
+    private var outputsPrepared: Bool = false
+
     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
     }
+
+    // Returns the display zoom multiplier introduced in iOS 18 to map between
+    // native zoom factor and the UI-displayed zoom factor. Falls back to 1.0 on
+    // older systems or if the property is unavailable.
+    func getDisplayZoomMultiplier() -> Float {
+        var multiplier: Float = 1.0
+        // Use KVC to avoid compile-time dependency on the iOS 18 SDK symbol
+        let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
+        if #available(iOS 18.0, *), let device = device {
+            if let value = device.value(forKey: "displayVideoZoomFactorMultiplier") as? NSNumber {
+                let m = value.floatValue
+                if m > 0 { multiplier = m }
+            }
+        }
+        return multiplier
+    }
+
+    // Track whether an aspect ratio was explicitly requested
+    var requestedAspectRatio: String?
 }
 
 extension CameraController {
-    func prepareBasicSession() {
-        // Only prepare if we don't already have a session
+    func prepareFullSession() {
+        // This function is now deprecated in favor of inline session creation in prepare()
+        // Kept for backward compatibility
         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
+    }
+
+    private func ensureCamerasDiscovered() {
+        // Rediscover cameras if the array is empty OR if the camera pointers are nil
+        guard allDiscoveredDevices.isEmpty || (rearCamera == nil && frontCamera == nil) else { return }
+        discoverAndConfigureCameras()
+    }
+
+    private func discoverAndConfigureCameras() {
         let deviceTypes: [AVCaptureDevice.DeviceType] = [
             .builtInWideAngleCamera,
             .builtInUltraWideCamera,
@@ -76,327 +100,331 @@ extension CameraController {
 
         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 }
-        
+
+        // Store all discovered devices for fast lookup later
+        self.allDiscoveredDevices = cameras
+
+        // Log all found devices for debugging
+
+        for camera in cameras {
+            let constituentCount = camera.isVirtualDevice ? camera.constituentDevices.count : 1
+
+        }
+
+        // Set front camera (usually just one option)
         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 }) {
+
+        // Find rear camera - prefer tripleCamera for multi-lens support
+        let rearCameras = cameras.filter { $0.position == .back }
+
+        // First try to find built-in triple camera (provides access to all lenses)
+        if let tripleCamera = rearCameras.first(where: {
+            $0.deviceType == .builtInTripleCamera
+        }) {
+            self.rearCamera = tripleCamera
+        } else if let dualWideCamera = rearCameras.first(where: {
+            $0.deviceType == .builtInDualWideCamera
+        }) {
+            // Fallback to dual wide camera
+            self.rearCamera = dualWideCamera
+        } else if let dualCamera = rearCameras.first(where: {
+            $0.deviceType == .builtInDualCamera
+        }) {
+            // Fallback to dual camera
+            self.rearCamera = dualCamera
+        } else if let wideAngleCamera = rearCameras.first(where: {
+            $0.deviceType == .builtInWideAngleCamera
+        }) {
+            // Fallback to wide angle camera
+            self.rearCamera = wideAngleCamera
+        } else if let firstRearCamera = rearCameras.first {
+            // Final fallback to any rear camera
             self.rearCamera = firstRearCamera
         }
-        
-        print("[CameraPreview] Basic session prepared with \(cameras.count) devices")
+
+        // Pre-configure focus modes
+        configureCameraFocus(camera: self.rearCamera)
+        configureCameraFocus(camera: self.frontCamera)
     }
 
-    func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, completionHandler: @escaping (Error?) -> Void) {
-        func createCaptureSession() {
-            // Use existing session if available from background preparation
-            if self.captureSession == nil {
-                self.captureSession = AVCaptureSession()
+    private func configureCameraFocus(camera: AVCaptureDevice?) {
+        guard let camera = camera else { return }
+
+        do {
+            try camera.lockForConfiguration()
+            if camera.isFocusModeSupported(.continuousAutoFocus) {
+                camera.focusMode = .continuousAutoFocus
             }
+            camera.unlockForConfiguration()
+        } catch {
+            print("[CameraPreview] Could not configure focus for \(camera.localizedName): \(error)")
         }
+    }
 
-        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: deviceTypes, mediaType: AVMediaType.video, position: .unspecified)
-
-            let cameras = session.devices.compactMap { $0 }
-
-            // Log all found devices for debugging
-            print("[CameraPreview] Found \(cameras.count) devices:")
-            for camera in cameras {
-                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))")
-            }
+    private func prepareOutputs() {
+        // Skip if already prepared
+        guard !self.outputsPrepared else { return }
 
-            guard !cameras.isEmpty else {
-                print("[CameraPreview] ERROR: No cameras found.")
-                throw CameraControllerError.noCamerasAvailable
-            }
+        // Create photo output
+        self.photoOutput = AVCapturePhotoOutput()
+        self.photoOutput?.isHighResolutionCaptureEnabled = true
 
-            // --- 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 }
+        // Create video output
+        self.fileVideoOutput = AVCaptureMovieFileOutput()
 
-            self.frontCamera = cameras.first(where: { $0.position == .front })
+        // Create data output for preview
+        self.dataOutput = AVCaptureVideoDataOutput()
+        self.dataOutput?.videoSettings = [
+            (kCVPixelBufferPixelFormatTypeKey as String): NSNumber(value: kCVPixelFormatType_32BGRA as UInt32)
+        ]
+        self.dataOutput?.alwaysDiscardsLateVideoFrames = true
 
-            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 ---
+        // Pre-create preview layer to avoid delay later
+        if self.previewLayer == nil {
+            self.previewLayer = AVCaptureVideoPreviewLayer()
+        }
 
-            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)")
+        // Mark as prepared
+        self.outputsPrepared = true
+    }
+
+    func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, initialZoomLevel: Float?, completionHandler: @escaping (Error?) -> Void) {
+        print("[CameraPreview] 🎬 Starting prepare - position: \(cameraPosition), deviceId: \(deviceId ?? "nil"), disableAudio: \(disableAudio), cameraMode: \(cameraMode), aspectRatio: \(aspectRatio ?? "nil"), zoom: \(initialZoomLevel)")
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else {
+                DispatchQueue.main.async {
+                    completionHandler(CameraControllerError.unknown)
                 }
+                return
             }
 
-            if disableAudio == false {
-                self.audioDevice = AVCaptureDevice.default(for: AVMediaType.audio)
-            }
-        }
+            do {
+                // Create session if needed
+                if self.captureSession == nil {
+                    self.captureSession = AVCaptureSession()
+                }
 
-        func configureDeviceInputs() throws {
-            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
+                guard let captureSession = self.captureSession else {
+                    throw CameraControllerError.captureSessionIsMissing
+                }
 
-            var selectedDevice: AVCaptureDevice?
+                // Prepare outputs
+                self.prepareOutputs()
 
-            // 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
+                // Configure the session
+                captureSession.beginConfiguration()
 
-                selectedDevice = allDevices.first(where: { $0.uniqueID == deviceId })
-                guard selectedDevice != nil else {
-                    throw CameraControllerError.noCamerasAvailable
-                }
-            } else {
-                // Use position-based selection
-                if cameraPosition == "rear" {
-                    selectedDevice = self.rearCamera
-                } else if cameraPosition == "front" {
-                    selectedDevice = self.frontCamera
+                // Set aspect ratio preset and remember requested ratio
+                self.requestedAspectRatio = aspectRatio
+                self.configureSessionPreset(for: aspectRatio)
+
+                // Configure device inputs
+                try self.configureDeviceInputs(cameraPosition: cameraPosition, deviceId: deviceId, disableAudio: disableAudio)
+
+                // Add data output BEFORE starting session for faster first frame
+                if let dataOutput = self.dataOutput, captureSession.canAddOutput(dataOutput) {
+                    captureSession.addOutput(dataOutput)
+                    dataOutput.setSampleBufferDelegate(self, queue: DispatchQueue.main)
                 }
-            }
 
-            guard let finalDevice = selectedDevice else {
-                print("[CameraPreview] ERROR: No camera device selected for position: \(cameraPosition)")
-                throw CameraControllerError.noCamerasAvailable
-            }
+                captureSession.commitConfiguration()
 
-            print("[CameraPreview] Configuring device: \(finalDevice.localizedName)")
-            let deviceInput = try AVCaptureDeviceInput(device: finalDevice)
+                // Set initial zoom
+                self.setInitialZoom(level: initialZoomLevel)
 
-            if captureSession.canAddInput(deviceInput) {
-                captureSession.addInput(deviceInput)
+                // Start the session
+                captureSession.startRunning()
 
-                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
+                // Defer adding photo/video outputs to avoid blocking
+                // These aren't needed immediately for preview
+                DispatchQueue.global(qos: .utility).async { [weak self] in
+                    guard let self = self else { return }
+
+                    captureSession.beginConfiguration()
+
+                    // Add photo output
+                    if let photoOutput = self.photoOutput, captureSession.canAddOutput(photoOutput) {
+                        photoOutput.isHighResolutionCaptureEnabled = true
+                        captureSession.addOutput(photoOutput)
                     }
 
-                    // 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
-                        }
+                    // Add video output if needed
+                    if cameraMode, let fileVideoOutput = self.fileVideoOutput, captureSession.canAddOutput(fileVideoOutput) {
+                        captureSession.addOutput(fileVideoOutput)
                     }
-                    finalDevice.unlockForConfiguration()
-                    // --- End of Correction ---
+
+                    captureSession.commitConfiguration()
                 }
-            } else {
-                print("[CameraPreview] ERROR: Cannot add device input to session.")
-                throw CameraControllerError.inputsAreInvalid
-            }
 
-            // Add audio input
-            if disableAudio == false {
-                if let audioDevice = self.audioDevice {
-                    self.audioInput = try AVCaptureDeviceInput(device: audioDevice)
-                    if captureSession.canAddInput(self.audioInput!) {
-                        captureSession.addInput(self.audioInput!)
-                    } else {
-                        throw CameraControllerError.inputsAreInvalid
-                    }
+                // Success callback
+                DispatchQueue.main.async {
+                    completionHandler(nil)
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    completionHandler(error)
                 }
             }
         }
+    }
 
-        func configurePhotoOutput(cameraMode: Bool) throws {
-            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
-
-            // 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
-                    }
+    private func configureSessionPreset(for aspectRatio: String?) {
+        guard let captureSession = self.captureSession else { return }
+
+        var targetPreset: AVCaptureSession.Preset = .photo
+        if let aspectRatio = aspectRatio {
+            switch aspectRatio {
+            case "16:9":
+                if captureSession.canSetSessionPreset(.hd4K3840x2160) {
+                    targetPreset = .hd4K3840x2160
+                } else if captureSession.canSetSessionPreset(.hd1920x1080) {
+                    targetPreset = .hd1920x1080
                 }
-            } else {
-                // Default to highest available quality when no aspect ratio specified
+            case "4:3":
                 if captureSession.canSetSessionPreset(.photo) {
                     targetPreset = .photo
                 } else if captureSession.canSetSessionPreset(.high) {
                     targetPreset = .high
                 } else {
-                    targetPreset = .medium
+                    targetPreset = captureSession.sessionPreset
                 }
-            }
-
-            // 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
+            default:
+                if captureSession.canSetSessionPreset(.photo) {
+                    targetPreset = .photo
+                } else if captureSession.canSetSessionPreset(.high) {
+                    targetPreset = .high
+                } else {
+                    targetPreset = captureSession.sessionPreset
                 }
             }
+        }
 
-            self.photoOutput = AVCapturePhotoOutput()
-            self.photoOutput!.setPreparedPhotoSettingsArray([AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg])], completionHandler: nil)
-            self.photoOutput?.isHighResolutionCaptureEnabled = self.highResolutionOutput
-            if captureSession.canAddOutput(self.photoOutput!) { captureSession.addOutput(self.photoOutput!) }
+        if captureSession.canSetSessionPreset(targetPreset) {
+            captureSession.sessionPreset = targetPreset
+        }
+    }
 
-            let fileVideoOutput = AVCaptureMovieFileOutput()
-            if captureSession.canAddOutput(fileVideoOutput) {
-                captureSession.addOutput(fileVideoOutput)
-                self.fileVideoOutput = fileVideoOutput
-            }
-            captureSession.startRunning()
+    private func setInitialZoom(level: Float?) {
+        let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
+        guard let device = device else {
+            print("[CameraPreview] No device available for initial zoom")
+            return
         }
 
-        func configureDataOutput() throws {
-            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
+        let minZoom = device.minAvailableVideoZoomFactor
+        let maxZoom = min(device.maxAvailableVideoZoomFactor, saneMaxZoomFactor)
 
-            self.dataOutput = AVCaptureVideoDataOutput()
-            self.dataOutput?.videoSettings = [
-                (kCVPixelBufferPixelFormatTypeKey as String): NSNumber(value: kCVPixelFormatType_32BGRA as UInt32)
-            ]
-            self.dataOutput?.alwaysDiscardsLateVideoFrames = true
-            if captureSession.canAddOutput(self.dataOutput!) {
-                captureSession.addOutput(self.dataOutput!)
-            }
+        // Compute UI-level default = 1 * multiplier when not provided
+        let multiplier = self.getDisplayZoomMultiplier()
+        // if level is nil, it's the initial zoom
+        let uiLevel: Float = level ?? (2.0 * multiplier)
+        // Map UI/display zoom to native zoom using iOS 18+ multiplier
+        let adjustedLevel = multiplier != 1.0 ? (uiLevel / multiplier) : uiLevel
 
-            captureSession.commitConfiguration()
+        guard CGFloat(adjustedLevel) >= minZoom && CGFloat(adjustedLevel) <= maxZoom else {
+            print("[CameraPreview] Initial zoom level \(adjustedLevel) out of range (\(minZoom)-\(maxZoom))")
+            return
+        }
 
-            let queue = DispatchQueue(label: "DataOutput", attributes: [])
-            self.dataOutput?.setSampleBufferDelegate(self, queue: queue)
+        do {
+            try device.lockForConfiguration()
+            device.videoZoomFactor = CGFloat(adjustedLevel)
+            device.unlockForConfiguration()
+            self.zoomFactor = CGFloat(adjustedLevel)
+        } catch {
+            print("[CameraPreview] Failed to set initial zoom: \(error)")
         }
+    }
 
-        DispatchQueue(label: "prepare").async {
-            do {
-                createCaptureSession()
-                try configureCaptureDevices()
-                try configureDeviceInputs()
-                try configurePhotoOutput(cameraMode: cameraMode)
-                try configureDataOutput()
-                // try configureVideoOutput()
-            } catch {
-                DispatchQueue.main.async {
-                    completionHandler(error)
-                }
+    private func configureDeviceInputs(cameraPosition: String, deviceId: String?, disableAudio: Bool) throws {
+        guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
-                return
-            }
+        // Ensure cameras are discovered before configuring inputs
+        ensureCamerasDiscovered()
 
-            DispatchQueue.main.async {
-                completionHandler(nil)
+        var selectedDevice: AVCaptureDevice?
+
+        // If deviceId is specified, find that specific device from discovered devices
+        if let deviceId = deviceId {
+            selectedDevice = self.allDiscoveredDevices.first(where: { $0.uniqueID == deviceId })
+            guard selectedDevice != nil else {
+                throw CameraControllerError.noCamerasAvailable
+            }
+        } else {
+            // Use position-based selection from discovered cameras
+            if cameraPosition == "rear" {
+                selectedDevice = self.rearCamera
+            } else if cameraPosition == "front" {
+                selectedDevice = self.frontCamera
             }
         }
-    }
 
-    func displayPreview(on view: UIView) throws {
-        guard let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
+        guard let finalDevice = selectedDevice else {
+            throw CameraControllerError.noCamerasAvailable
+        }
 
-        print("[CameraPreview] displayPreview called with view frame: \(view.frame)")
+        let deviceInput = try AVCaptureDeviceInput(device: finalDevice)
 
-        self.previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
-        self.previewLayer?.videoGravity = AVLayerVideoGravity.resizeAspectFill
+        if captureSession.canAddInput(deviceInput) {
+            captureSession.addInput(deviceInput)
 
-        // Optimize preview layer for better quality
-        self.previewLayer?.connection?.videoOrientation = .portrait
-        self.previewLayer?.isOpaque = true
+            if finalDevice.position == .front {
+                self.frontCameraInput = deviceInput
+                self.currentCameraPosition = .front
+            } else {
+                self.rearCameraInput = deviceInput
+                self.currentCameraPosition = .rear
+            }
+        } else {
+            throw CameraControllerError.inputsAreInvalid
+        }
 
-        // Enable high-quality rendering
-        if #available(iOS 13.0, *) {
-            self.previewLayer?.videoGravity = .resizeAspectFill
+        // Add audio input if needed
+        if !disableAudio {
+            if self.audioDevice == nil {
+                self.audioDevice = AVCaptureDevice.default(for: AVMediaType.audio)
+            }
+            if let audioDevice = self.audioDevice {
+                self.audioInput = try AVCaptureDeviceInput(device: audioDevice)
+                if captureSession.canAddInput(self.audioInput!) {
+                    captureSession.addInput(self.audioInput!)
+                } else {
+                    throw CameraControllerError.inputsAreInvalid
+                }
+            }
         }
+    }
 
-        view.layer.insertSublayer(self.previewLayer!, at: 0)
-        
-        // Disable animation for frame update
-        CATransaction.begin()
-        CATransaction.setDisableActions(true)
-        self.previewLayer?.frame = view.bounds
-        CATransaction.commit()
+    func displayPreview(on view: UIView) throws {
+        guard let captureSession = self.captureSession, captureSession.isRunning else {
+            throw CameraControllerError.captureSessionIsMissing
+        }
 
-        print("[CameraPreview] Set preview layer frame to view bounds: \(view.bounds)")
-        print("[CameraPreview] Session preset: \(captureSession.sessionPreset.rawValue)")
+        // Create or reuse preview layer
+        let previewLayer: AVCaptureVideoPreviewLayer
+        if let existingLayer = self.previewLayer {
+            // Always reuse if we have one - just update the session if needed
+            previewLayer = existingLayer
+            if existingLayer.session != captureSession {
+                existingLayer.session = captureSession
+            }
+        } else {
+            // Create layer with minimal properties to speed up creation
+            previewLayer = AVCaptureVideoPreviewLayer()
+            previewLayer.session = captureSession
+        }
 
-        updateVideoOrientation()
+        // Fast configuration without CATransaction overhead
+        // Use resizeAspect to avoid crop when no aspect ratio is requested; otherwise fill
+        previewLayer.videoGravity = (requestedAspectRatio == nil) ? .resizeAspect : .resizeAspectFill
+        previewLayer.frame = view.bounds
+
+        // Insert layer immediately (only if new)
+        if previewLayer.superlayer != view.layer {
+            view.layer.insertSublayer(previewLayer, at: 0)
+        }
+        self.previewLayer = previewLayer
     }
 
     func addGridOverlay(to view: UIView, gridMode: String) {
@@ -443,8 +471,8 @@ extension CameraController {
         if Thread.isMainThread {
             updateVideoOrientationOnMainThread()
         } else {
-            DispatchQueue.main.async { [weak self] in
-                self?.updateVideoOrientationOnMainThread()
+            DispatchQueue.main.sync {
+                self.updateVideoOrientationOnMainThread()
             }
         }
     }
@@ -477,6 +505,33 @@ extension CameraController {
         photoOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
     }
 
+    private func setDefaultZoomAfterFlip() {
+        let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
+        guard let device = device else {
+            print("[CameraPreview] No device available for default zoom after flip")
+            return
+        }
+
+        // Set zoom to 1.0x in UI terms, accounting for display multiplier
+        let multiplier = self.getDisplayZoomMultiplier()
+        let targetUIZoom: Float = 1.0  // We want 1.0x in the UI
+        let nativeZoom = multiplier != 1.0 ? (targetUIZoom / multiplier) : targetUIZoom
+
+        let minZoom = device.minAvailableVideoZoomFactor
+        let maxZoom = min(device.maxAvailableVideoZoomFactor, saneMaxZoomFactor)
+        let clampedZoom = max(minZoom, min(CGFloat(nativeZoom), maxZoom))
+
+        do {
+            try device.lockForConfiguration()
+            device.videoZoomFactor = clampedZoom
+            device.unlockForConfiguration()
+            self.zoomFactor = clampedZoom
+            print("[CameraPreview] Set default zoom after flip: UI=\(targetUIZoom)x, native=\(clampedZoom), multiplier=\(multiplier)")
+        } catch {
+            print("[CameraPreview] Failed to set default zoom after flip: \(error)")
+        }
+    }
+
     func switchCameras() throws {
         guard let currentCameraPosition = currentCameraPosition,
               let captureSession = self.captureSession else {
@@ -485,7 +540,7 @@ extension CameraController {
 
         // Ensure we have the necessary cameras
         guard (currentCameraPosition == .front && rearCamera != nil) ||
-              (currentCameraPosition == .rear && frontCamera != nil) else {
+                (currentCameraPosition == .rear && frontCamera != nil) else {
             throw CameraControllerError.noCamerasAvailable
         }
 
@@ -501,9 +556,7 @@ extension CameraController {
             captureSession.commitConfiguration()
             // Restart the session if it was running before
             if wasRunning {
-                DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-                    self?.captureSession?.startRunning()
-                }
+                captureSession.startRunning()
             }
         }
 
@@ -513,7 +566,7 @@ extension CameraController {
         // Remove only video inputs
         captureSession.inputs.forEach { input in
             if (input as? AVCaptureDeviceInput)?.device.hasMediaType(.video) ?? false {
-            captureSession.removeInput(input)
+                captureSession.removeInput(input)
             }
         }
 
@@ -532,7 +585,7 @@ extension CameraController {
             rearCamera.unlockForConfiguration()
 
             if let newInput = try? AVCaptureDeviceInput(device: rearCamera),
-                captureSession.canAddInput(newInput) {
+               captureSession.canAddInput(newInput) {
                 captureSession.addInput(newInput)
                 rearCameraInput = newInput
                 self.currentCameraPosition = .rear
@@ -552,7 +605,7 @@ extension CameraController {
             frontCamera.unlockForConfiguration()
 
             if let newInput = try? AVCaptureDeviceInput(device: frontCamera),
-                captureSession.canAddInput(newInput) {
+               captureSession.canAddInput(newInput) {
                 captureSession.addInput(newInput)
                 frontCameraInput = newInput
                 self.currentCameraPosition = .front
@@ -567,27 +620,59 @@ extension CameraController {
         }
 
         // Update video orientation
+        self.updateVideoOrientation()
+
+        // Set default 1.0 zoom level after camera switch to prevent iOS 18+ zoom jumps
         DispatchQueue.main.async { [weak self] in
-            self?.updateVideoOrientation()
+            self?.setDefaultZoomAfterFlip()
         }
     }
 
-    func captureImage(width: Int?, height: Int?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Error?) -> Void) {
+    func captureImage(width: Int?, height: Int?, aspectRatio: String?, quality: Float, gpsLocation: CLLocation?, completion: @escaping (UIImage?, Data?, [AnyHashable: Any]?, Error?) -> Void) {
+        print("[CameraPreview] captureImage called - width: \(width ?? -1), height: \(height ?? -1), aspectRatio: \(aspectRatio ?? "nil")")
+
         guard let photoOutput = self.photoOutput else {
-            completion(nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
+            completion(nil, nil, nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
             return
         }
 
         let settings = AVCapturePhotoSettings()
+        // Request highest quality photo capture
+        if #available(iOS 13.0, *) {
+            settings.isHighResolutionPhotoEnabled = true
+        }
+        if #available(iOS 15.0, *) {
+            settings.photoQualityPrioritization = .balanced
+        }
 
-        self.photoCaptureCompletionBlock = { (image, error) in
+        // Apply the current flash mode to the photo settings
+        // Check if the current device supports flash
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default:
+            break
+        }
+
+        // Only apply flash if the device has flash and the flash mode is supported
+        if let device = currentCamera, device.hasFlash {
+            let supportedFlashModes = photoOutput.supportedFlashModes
+            if supportedFlashModes.contains(self.flashMode) {
+                settings.flashMode = self.flashMode
+            }
+        }
+
+        self.photoCaptureCompletionBlock = { (image, photoData, metadata, error) in
             if let error = error {
-                completion(nil, error)
+                completion(nil, nil, nil, error)
                 return
             }
 
             guard let image = image else {
-                completion(nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to capture image"]))
+                completion(nil, nil, nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to capture image"]))
                 return
             }
 
@@ -595,12 +680,53 @@ extension CameraController {
                 self.addGPSMetadata(to: image, location: location)
             }
 
+            var finalImage = image
+
+            // Determine what to do based on parameters
             if let width = width, let height = height {
-                let resizedImage = self.resizeImage(image: image, to: CGSize(width: width, height: height))
-                completion(resizedImage, nil)
+                // Specific dimensions requested - resize to exact size
+                finalImage = self.resizeImage(image: image, to: CGSize(width: width, height: height))!
+                print("[CameraPreview] Resized to exact dimensions: \(finalImage.size.width)x\(finalImage.size.height)")
+            } else if let aspectRatio = aspectRatio {
+                // Aspect ratio specified - crop to that ratio
+                let components = aspectRatio.split(separator: ":").compactMap { Double($0) }
+                if components.count == 2 {
+                    // For capture in portrait orientation, swap the aspect ratio (16:9 becomes 9:16)
+                    let isPortrait = image.size.height > image.size.width
+                    let targetAspectRatio = isPortrait ? components[1] / components[0] : components[0] / components[1]
+                    let imageSize = image.size
+                    let originalAspectRatio = imageSize.width / imageSize.height
+
+                    // Only crop if the aspect ratios don't match
+                    if abs(originalAspectRatio - targetAspectRatio) > 0.01 {
+                        var targetSize = imageSize
+
+                        if originalAspectRatio > targetAspectRatio {
+                            // Original is wider than target - fit by height
+                            targetSize.width = imageSize.height * CGFloat(targetAspectRatio)
+                        } else {
+                            // Original is taller than target - fit by width
+                            targetSize.height = imageSize.width / CGFloat(targetAspectRatio)
+                        }
+
+                        // Center crop the image
+                        if let croppedImage = self.cropImageToAspectRatio(image: image, targetSize: targetSize) {
+                            finalImage = croppedImage
+                            print("[CameraPreview] Applied aspect ratio crop: \(finalImage.size.width)x\(finalImage.size.height)")
+                        }
+                    }
+                }
             } else {
-                completion(image, nil)
+                // No parameters specified - crop to match what's visible in the preview
+                // This ensures we capture exactly what the user sees
+                if let previewLayer = self.previewLayer,
+                   let previewCroppedImage = self.cropImageToMatchPreview(image: image, previewLayer: previewLayer) {
+                    finalImage = previewCroppedImage
+                    print("[CameraPreview] Cropped to match preview: \(finalImage.size.width)x\(finalImage.size.height)")
+                }
             }
+
+            completion(finalImage, photoData, metadata, nil)
         }
 
         photoOutput.capturePhoto(with: settings, delegate: self)
@@ -637,12 +763,73 @@ extension CameraController {
 
     func resizeImage(image: UIImage, to size: CGSize) -> UIImage? {
         let renderer = UIGraphicsImageRenderer(size: size)
-        let resizedImage = renderer.image { (context) in
+        let resizedImage = renderer.image { (_) in
             image.draw(in: CGRect(origin: .zero, size: size))
         }
         return resizedImage
     }
 
+    func cropImageToAspectRatio(image: UIImage, targetSize: CGSize) -> UIImage? {
+        let imageSize = image.size
+
+        // Calculate the crop rect - center crop
+        let xOffset = (imageSize.width - targetSize.width) / 2
+        let yOffset = (imageSize.height - targetSize.height) / 2
+        let cropRect = CGRect(x: xOffset, y: yOffset, width: targetSize.width, height: targetSize.height)
+
+        // Create the cropped image
+        guard let cgImage = image.cgImage,
+              let croppedCGImage = cgImage.cropping(to: cropRect) else {
+            return nil
+        }
+
+        return UIImage(cgImage: croppedCGImage, scale: image.scale, orientation: image.imageOrientation)
+    }
+
+    func cropImageToMatchPreview(image: UIImage, previewLayer: AVCaptureVideoPreviewLayer) -> UIImage? {
+        // When using resizeAspectFill, the preview layer shows a cropped portion of the video
+        // We need to calculate what portion of the captured image corresponds to what's visible
+
+        let previewBounds = previewLayer.bounds
+        let previewAspectRatio = previewBounds.width / previewBounds.height
+
+        // Get the dimensions of the captured image
+        let imageSize = image.size
+        let imageAspectRatio = imageSize.width / imageSize.height
+
+        print("[CameraPreview] cropImageToMatchPreview - Preview bounds: \(previewBounds.width)x\(previewBounds.height) (ratio: \(previewAspectRatio))")
+        print("[CameraPreview] cropImageToMatchPreview - Image size: \(imageSize.width)x\(imageSize.height) (ratio: \(imageAspectRatio))")
+
+        // Since we're using resizeAspectFill, we need to calculate what portion of the image
+        // is visible in the preview
+        var cropRect: CGRect
+
+        if imageAspectRatio > previewAspectRatio {
+            // Image is wider than preview - crop horizontally
+            let visibleWidth = imageSize.height * previewAspectRatio
+            let xOffset = (imageSize.width - visibleWidth) / 2
+            cropRect = CGRect(x: xOffset, y: 0, width: visibleWidth, height: imageSize.height)
+
+        } else {
+            // Image is taller than preview - crop vertically
+            let visibleHeight = imageSize.width / previewAspectRatio
+            let yOffset = (imageSize.height - visibleHeight) / 2
+            cropRect = CGRect(x: 0, y: yOffset, width: imageSize.width, height: visibleHeight)
+
+        }
+
+        // Create the cropped image
+        guard let cgImage = image.cgImage,
+              let croppedCGImage = cgImage.cropping(to: cropRect) else {
+
+            return nil
+        }
+
+        let result = UIImage(cgImage: croppedCGImage, scale: image.scale, orientation: image.imageOrientation)
+
+        return result
+    }
+
     func captureSample(completion: @escaping (UIImage?, Error?) -> Void) {
         guard let captureSession = captureSession,
               captureSession.isRunning else {
@@ -697,6 +884,7 @@ extension CameraController {
         return supportedFlashModesAsStrings
 
     }
+
     func getHorizontalFov() throws -> Float {
         var currentCamera: AVCaptureDevice?
         switch currentCameraPosition {
@@ -723,6 +911,7 @@ extension CameraController {
 
         return adjustedFov
     }
+
     func setFlashMode(flashMode: AVCaptureDevice.FlashMode) throws {
         var currentCamera: AVCaptureDevice?
         switch currentCameraPosition {
@@ -796,6 +985,7 @@ extension CameraController {
 
     func getZoom() throws -> (min: Float, max: Float, current: Float) {
         var currentCamera: AVCaptureDevice?
+
         switch currentCameraPosition {
         case .front:
             currentCamera = self.frontCamera
@@ -817,7 +1007,7 @@ extension CameraController {
         )
     }
 
-    func setZoom(level: CGFloat, ramp: Bool) throws {
+    func setZoom(level: CGFloat, ramp: Bool, autoFocus: Bool = true) throws {
         var currentCamera: AVCaptureDevice?
         switch currentCameraPosition {
         case .front:
@@ -848,9 +1038,121 @@ extension CameraController {
 
             // Update our internal zoom factor tracking
             self.zoomFactor = zoomLevel
+
+            // Trigger autofocus after zoom if requested
+            if autoFocus {
+                self.triggerAutoFocus()
+            }
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
+    private func triggerAutoFocus() {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera
+        case .rear:
+            currentCamera = self.rearCamera
+        default: break
+        }
+
+        guard let device = currentCamera else {
+            return
+        }
+
+        // Focus on the center of the preview (0.5, 0.5)
+        let centerPoint = CGPoint(x: 0.5, y: 0.5)
+
+        do {
+            try device.lockForConfiguration()
+
+            // Set focus mode to auto if supported
+            if device.isFocusModeSupported(.autoFocus) {
+                device.focusMode = .autoFocus
+                if device.isFocusPointOfInterestSupported {
+                    device.focusPointOfInterest = centerPoint
+                }
+            } else if device.isFocusModeSupported(.continuousAutoFocus) {
+                device.focusMode = .continuousAutoFocus
+                if device.isFocusPointOfInterestSupported {
+                    device.focusPointOfInterest = centerPoint
+                }
+            }
+
+            // Also set exposure point if supported
+            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
+                device.exposureMode = .autoExpose
+                device.exposurePointOfInterest = centerPoint
+            } else if device.isExposureModeSupported(.continuousAutoExposure) {
+                device.exposureMode = .continuousAutoExposure
+                if device.isExposurePointOfInterestSupported {
+                    device.exposurePointOfInterest = centerPoint
+                }
+            }
+
+            device.unlockForConfiguration()
         } catch {
+            // Silently ignore errors during autofocus
+        }
+    }
+
+    func setFocus(at point: CGPoint, showIndicator: Bool = false, in view: UIView? = nil) throws {
+        // Validate that coordinates are within bounds (0-1 range for device coordinates)
+        if point.x < 0 || point.x > 1 || point.y < 0 || point.y > 1 {
+            print("setFocus: Coordinates out of bounds - x: \(point.x), y: \(point.y)")
             throw CameraControllerError.invalidOperation
         }
+
+        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
+        }
+
+        guard device.isFocusPointOfInterestSupported else {
+            // Device doesn't support focus point of interest
+            return
+        }
+
+        // Show focus indicator if requested and view is provided - only after validation
+        if showIndicator, let view = view, let previewLayer = self.previewLayer {
+            // Convert the device point to layer point for indicator display
+            let layerPoint = previewLayer.layerPointConverted(fromCaptureDevicePoint: point)
+            showFocusIndicator(at: layerPoint, in: view)
+        }
+
+        do {
+            try device.lockForConfiguration()
+
+            // Set focus mode to auto if supported
+            if device.isFocusModeSupported(.autoFocus) {
+                device.focusMode = .autoFocus
+            } else if device.isFocusModeSupported(.continuousAutoFocus) {
+                device.focusMode = .continuousAutoFocus
+            }
+
+            // Set the focus point
+            device.focusPointOfInterest = point
+
+            // Also set exposure point if supported
+            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(.autoExpose) {
+                device.exposureMode = .autoExpose
+                device.exposurePointOfInterest = point
+            }
+
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.unknown
+        }
     }
 
     func getFlashMode() throws -> String {
@@ -963,9 +1265,7 @@ extension CameraController {
             captureSession.commitConfiguration()
             // Restart the session if it was running before
             if wasRunning {
-                DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-                    self?.captureSession?.startRunning()
-                }
+                captureSession.startRunning()
             }
         }
 
@@ -1012,13 +1312,9 @@ extension CameraController {
         }
 
         // Update video orientation
-        DispatchQueue.main.async { [weak self] in
-            self?.updateVideoOrientation()
-        }
+        self.updateVideoOrientation()
     }
 
-
-
     func cleanup() {
         if let captureSession = self.captureSession {
             captureSession.stopRunning()
@@ -1029,6 +1325,9 @@ extension CameraController {
         self.previewLayer?.removeFromSuperlayer()
         self.previewLayer = nil
 
+        self.focusIndicatorView?.removeFromSuperview()
+        self.focusIndicatorView = nil
+
         self.frontCameraInput = nil
         self.rearCameraInput = nil
         self.audioInput = nil
@@ -1036,6 +1335,7 @@ extension CameraController {
         self.frontCamera = nil
         self.rearCamera = nil
         self.audioDevice = nil
+        self.allDiscoveredDevices = []
 
         self.dataOutput = nil
         self.photoOutput = nil
@@ -1043,6 +1343,13 @@ extension CameraController {
 
         self.captureSession = nil
         self.currentCameraPosition = nil
+
+        // Reset output preparation status
+        self.outputsPrepared = false
+
+        // Reset first frame detection
+        self.hasReceivedFirstFrame = false
+        self.firstFrameReadyCallback = nil
     }
 
     func captureVideo() throws {
@@ -1119,6 +1426,11 @@ extension CameraController: UIGestureRecognizerDelegate {
         let point = tap.location(in: tap.view)
         let devicePoint = self.previewLayer?.captureDevicePointConverted(fromLayerPoint: point)
 
+        // Show focus indicator at the tap point
+        if let view = tap.view {
+            showFocusIndicator(at: point, in: view)
+        }
+
         do {
             try device.lockForConfiguration()
             defer { device.unlockForConfiguration() }
@@ -1139,7 +1451,80 @@ extension CameraController: UIGestureRecognizerDelegate {
         }
     }
 
-        @objc
+    private func showFocusIndicator(at point: CGPoint, in view: UIView) {
+        // Remove any existing focus indicator
+        focusIndicatorView?.removeFromSuperview()
+
+        // Create a new focus indicator (iOS Camera style): square with mid-edge ticks
+        let indicator = UIView(frame: CGRect(x: 0, y: 0, width: 80, height: 80))
+        indicator.center = point
+        indicator.layer.borderColor = UIColor.yellow.cgColor
+        indicator.layer.borderWidth = 2.0
+        indicator.layer.cornerRadius = 0
+        indicator.backgroundColor = UIColor.clear
+        indicator.alpha = 0
+        indicator.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
+
+        // Add 4 tiny mid-edge ticks inside the square
+        let stroke: CGFloat = 2.0
+        let tickLen: CGFloat = 12.0
+        let inset: CGFloat = stroke // ticks should touch the sides
+        // Top tick (perpendicular): vertical inward from top edge
+        let topTick = UIView(frame: CGRect(x: (indicator.bounds.width - stroke)/2,
+                                           y: inset,
+                                           width: stroke,
+                                           height: tickLen))
+        topTick.backgroundColor = .yellow
+        indicator.addSubview(topTick)
+        // Bottom tick (perpendicular): vertical inward from bottom edge
+        let bottomTick = UIView(frame: CGRect(x: (indicator.bounds.width - stroke)/2,
+                                              y: indicator.bounds.height - inset - tickLen,
+                                              width: stroke,
+                                              height: tickLen))
+        bottomTick.backgroundColor = .yellow
+        indicator.addSubview(bottomTick)
+        // Left tick (perpendicular): horizontal inward from left edge
+        let leftTick = UIView(frame: CGRect(x: inset,
+                                            y: (indicator.bounds.height - stroke)/2,
+                                            width: tickLen,
+                                            height: stroke))
+        leftTick.backgroundColor = .yellow
+        indicator.addSubview(leftTick)
+        // Right tick (perpendicular): horizontal inward from right edge
+        let rightTick = UIView(frame: CGRect(x: indicator.bounds.width - inset - tickLen,
+                                             y: (indicator.bounds.height - stroke)/2,
+                                             width: tickLen,
+                                             height: stroke))
+        rightTick.backgroundColor = .yellow
+        indicator.addSubview(rightTick)
+
+        view.addSubview(indicator)
+        focusIndicatorView = indicator
+
+        // Animate the focus indicator
+        UIView.animate(withDuration: 0.15, animations: {
+            indicator.alpha = 1.0
+            indicator.transform = CGAffineTransform.identity
+        }) { _ in
+            // Keep the indicator visible briefly
+            UIView.animate(withDuration: 0.2, delay: 0.5, options: [], animations: {
+                indicator.alpha = 0.3
+            }) { _ in
+                // Fade out and remove
+                UIView.animate(withDuration: 0.3, delay: 0.2, options: [], animations: {
+                    indicator.alpha = 0
+                    indicator.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
+                }) { _ in
+                    indicator.removeFromSuperview()
+                    if self.focusIndicatorView == indicator {
+                        self.focusIndicatorView = nil
+                    }
+                }
+            }
+        }
+    }
+
+    @objc
     private func handlePinch(_ pinch: UIPinchGestureRecognizer) {
         guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
 
@@ -1151,7 +1536,7 @@ extension CameraController: UIGestureRecognizerDelegate {
             // Store the initial zoom factor when pinch begins
             zoomFactor = device.videoZoomFactor
 
-                case .changed:
+        case .changed:
             // Throttle zoom updates to prevent excessive CPU usage
             let currentTime = CACurrentMediaTime()
             guard currentTime - lastZoomUpdateTime >= zoomUpdateThrottle else { return }
@@ -1181,21 +1566,41 @@ extension CameraController: UIGestureRecognizerDelegate {
 }
 
 extension CameraController: AVCapturePhotoCaptureDelegate {
-    public func photoOutput(_ captureOutput: AVCapturePhotoOutput, didFinishProcessingPhoto photoSampleBuffer: CMSampleBuffer?, previewPhoto previewPhotoSampleBuffer: CMSampleBuffer?,
-                            resolvedSettings: AVCaptureResolvedPhotoSettings, bracketSettings: AVCaptureBracketedStillImageSettings?, error: Swift.Error?) {
+    public func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
         if let error = error {
-            self.photoCaptureCompletionBlock?(nil, error)
-        } else if let buffer = photoSampleBuffer, let data = AVCapturePhotoOutput.jpegPhotoDataRepresentation(forJPEGSampleBuffer: buffer, previewPhotoSampleBuffer: nil),
-                  let image = UIImage(data: data) {
-            self.photoCaptureCompletionBlock?(image.fixedOrientation(), nil)
-        } else {
-            self.photoCaptureCompletionBlock?(nil, CameraControllerError.unknown)
+            self.photoCaptureCompletionBlock?(nil, nil, nil, error)
+            return
         }
+
+        // Get the photo data using the modern API
+        guard let imageData = photo.fileDataRepresentation() else {
+            self.photoCaptureCompletionBlock?(nil, nil, nil, CameraControllerError.unknown)
+            return
+        }
+
+        guard let image = UIImage(data: imageData) else {
+            self.photoCaptureCompletionBlock?(nil, nil, nil, CameraControllerError.unknown)
+            return
+        }
+
+        // Pass through original file data and metadata so callers can preserve EXIF
+        self.photoCaptureCompletionBlock?(image.fixedOrientation(), imageData, photo.metadata, nil)
     }
 }
 
 extension CameraController: AVCaptureVideoDataOutputSampleBufferDelegate {
     func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
+        // Check if we're waiting for the first frame
+        if !hasReceivedFirstFrame, let firstFrameCallback = firstFrameReadyCallback {
+            hasReceivedFirstFrame = true
+            firstFrameCallback()
+            firstFrameReadyCallback = nil
+            // If no capture is in progress, we can return early
+            if sampleBufferCaptureCompletionBlock == nil {
+                return
+            }
+        }
+
         guard let completion = sampleBufferCaptureCompletionBlock else { return }
 
         guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
@@ -1245,6 +1650,7 @@ enum CameraControllerError: Swift.Error {
     case cannotFindDocumentsDirectory
     case fileVideoOutputNotFound
     case unknown
+    case invalidZoomLevel(min: CGFloat, max: CGFloat, requested: CGFloat)
 }
 
 public enum CameraPosition {
@@ -1271,6 +1677,8 @@ extension CameraControllerError: LocalizedError {
             return NSLocalizedString("Cannot find documents directory", comment: "This should never happen")
         case .fileVideoOutputNotFound:
             return NSLocalizedString("Video recording is not available. Make sure the camera is properly initialized.", comment: "Video recording not available")
+        case .invalidZoomLevel(let min, let max, let requested):
+            return NSLocalizedString("Invalid zoom level. Must be between \(min) and \(max). Requested: \(requested)", comment: "Invalid Zoom Level")
         }
     }
 }
@@ -1312,6 +1720,8 @@ extension UIImage {
             print("right")
         case .up, .upMirrored:
             break
+        @unknown default:
+            break
         }
 
         // Flip image one more time if needed to, this is to prevent flipped image
@@ -1324,15 +1734,21 @@ extension UIImage {
             transform.scaledBy(x: -1, y: 1)
         case .up, .down, .left, .right:
             break
+        @unknown default:
+            break
         }
 
         ctx.concatenate(transform)
 
         switch imageOrientation {
         case .left, .leftMirrored, .right, .rightMirrored:
-            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.height, height: size.width))
+            if let cgImage = self.cgImage {
+                ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: size.height, height: size.width))
+            }
         default:
-            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
+            if let cgImage = self.cgImage {
+                ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
+            }
         }
         guard let newCGImage = ctx.makeImage() else { return nil }
         return UIImage.init(cgImage: newCGImage, scale: 1, orientation: .up)