@capgo/camera-preview 7.4.0-beta.13 → 7.4.0-beta.16

package/ios/Sources/CapgoCameraPreview/CameraController.swift

@@ -30,14 +30,13 @@ class CameraController: NSObject {
 
     var previewLayer: AVCaptureVideoPreviewLayer?
     var gridOverlayView: GridOverlayView?
+    var focusIndicatorView: UIView?
 
     var flashMode = AVCaptureDevice.FlashMode.off
     var photoCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
 
     var sampleBufferCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
 
-    var highResolutionOutput: Bool = false
-
     var audioDevice: AVCaptureDevice?
     var audioInput: AVCaptureDeviceInput?
 
@@ -48,6 +47,10 @@ class CameraController: NSObject {
     var videoFileURL: URL?
     private let saneMaxZoomFactor: CGFloat = 25.5
 
+    // Track output preparation status
+    private var outputsPrepared: Bool = false
+    private let outputPreparationQueue = DispatchQueue(label: "camera.output.preparation", qos: .utility)
+
     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
@@ -65,18 +68,28 @@ extension CameraController {
         // 1. Create and configure session
         self.captureSession = AVCaptureSession()
 
-        // 2. Pre-configure session preset (can be changed later)
-        if captureSession!.canSetSessionPreset(.high) {
+        // 2. Pre-configure session preset (can be changed later) - use medium for faster startup
+        if captureSession!.canSetSessionPreset(.medium) {
+            captureSession!.sessionPreset = .medium // Start with medium, upgrade later if needed
+        } else if captureSession!.canSetSessionPreset(.high) {
             captureSession!.sessionPreset = .high
         }
 
-        // 3. Discover and configure all cameras
-        discoverAndConfigureCameras()
+        // 3. Discover cameras on-demand (only when needed for better startup performance)
+        // discoverAndConfigureCameras() - moved to lazy loading
 
-        // 4. Pre-create outputs (don't add to session yet)
-        prepareOutputs()
+        // // 4. Pre-create outputs asynchronously to avoid blocking camera opening
+        // outputPreparationQueue.async { [weak self] in
+        //     self?.prepareOutputs()
+        // }
+
+        print("[CameraPreview] Full session preparation complete - cameras will be discovered on-demand, outputs being prepared asynchronously")
+    }
 
-        print("[CameraPreview] Full session preparation complete")
+    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() {
@@ -137,67 +150,211 @@ extension CameraController {
     }
 
     private func prepareOutputs() {
-        // Pre-create photo output
+        // Pre-create photo output with optimized settings
         self.photoOutput = AVCapturePhotoOutput()
-        self.photoOutput?.isHighResolutionCaptureEnabled = false // Default, can be changed
+        self.photoOutput?.isHighResolutionCaptureEnabled = false // Start with lower resolution for speed
+
+        // Configure photo output for better performance
+        if #available(iOS 13.0, *) {
+            self.photoOutput?.maxPhotoQualityPrioritization = .speed // Prioritize speed over quality initially
+        }
 
         // Pre-create video output
         self.fileVideoOutput = AVCaptureMovieFileOutput()
 
-        // Pre-create data output
+        // Pre-create data output with optimized settings
         self.dataOutput = AVCaptureVideoDataOutput()
         self.dataOutput?.videoSettings = [
             (kCVPixelBufferPixelFormatTypeKey as String): NSNumber(value: kCVPixelFormatType_32BGRA as UInt32)
         ]
         self.dataOutput?.alwaysDiscardsLateVideoFrames = true
 
-        print("[CameraPreview] Outputs pre-created")
+        // Use a background queue for sample buffer processing to avoid blocking main thread
+        let dataOutputQueue = DispatchQueue(label: "camera.data.output", qos: .userInitiated)
+        self.dataOutput?.setSampleBufferDelegate(nil, queue: dataOutputQueue) // Will be set later
+
+        // Mark outputs as prepared
+        self.outputsPrepared = true
+
+        print("[CameraPreview] Outputs pre-created with performance optimizations")
     }
 
-    func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, completionHandler: @escaping (Error?) -> Void) {
-        do {
-            // Session and outputs already created in load(), just configure user-specific settings
-            if self.captureSession == nil {
-                // Fallback if prepareFullSession() wasn't called
-                self.prepareFullSession()
+    private func waitForOutputsToBeReady() {
+        // If outputs are already prepared, return immediately
+        if outputsPrepared {
+            return
+        }
+
+        // Wait for outputs to be prepared with a timeout
+        let semaphore = DispatchSemaphore(value: 0)
+        var outputsReady = false
+
+        // Check for outputs readiness periodically
+        let timer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true) { timer in
+            if self.outputsPrepared {
+                outputsReady = true
+                timer.invalidate()
+                semaphore.signal()
+            }
+        }
+
+        // Wait for outputs to be ready or timeout after 2 seconds
+        let timeout = DispatchTime.now() + .seconds(2)
+        let result = semaphore.wait(timeout: timeout)
+
+        timer.invalidate()
+
+        if result == .timedOut && !outputsReady {
+            print("[CameraPreview] Warning: Timed out waiting for outputs to be prepared, proceeding anyway")
+            // Fallback: prepare outputs synchronously if async preparation failed
+            if !outputsPrepared {
+                prepareOutputs()
+            }
+        } else {
+            print("[CameraPreview] Outputs ready, proceeding with camera preparation")
+        }
+    }
+
+    func upgradeQualitySettings() {
+        guard let captureSession = self.captureSession else { return }
+
+        // Upgrade session preset to high quality after initial startup
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+
+            captureSession.beginConfiguration()
+
+            // Upgrade to high quality preset
+            if captureSession.canSetSessionPreset(.high) && captureSession.sessionPreset != .high {
+                captureSession.sessionPreset = .high
+                print("[CameraPreview] Upgraded session preset to high quality")
             }
 
-            guard let captureSession = self.captureSession else {
-                throw CameraControllerError.captureSessionIsMissing
+            // Upgrade photo output quality
+            if let photoOutput = self.photoOutput {
+                photoOutput.isHighResolutionCaptureEnabled = true
+                if #available(iOS 13.0, *) {
+                    photoOutput.maxPhotoQualityPrioritization = .quality
+                }
+                print("[CameraPreview] Upgraded photo output to high resolution")
             }
 
-            print("[CameraPreview] Fast prepare - using pre-initialized session")
+            captureSession.commitConfiguration()
+        }
+    }
+
+    func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, initialZoomLevel: Float = 1.0, completionHandler: @escaping (Error?) -> Void) {
+        // Use background queue for preparation to avoid blocking main thread
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else {
+                DispatchQueue.main.async {
+                    completionHandler(CameraControllerError.unknown)
+                }
+                return
+            }
 
-            // Configure device inputs for the requested camera
-            try self.configureDeviceInputs(cameraPosition: cameraPosition, deviceId: deviceId, disableAudio: disableAudio)
+            do {
+                // Session and outputs already created in load(), just configure user-specific settings
+                if self.captureSession == nil {
+                    // Fallback if prepareFullSession() wasn't called
+                    self.prepareFullSession()
+                }
 
-            // Add outputs to session and apply user settings
-            try self.addOutputsToSession(cameraMode: cameraMode, aspectRatio: aspectRatio)
+                guard let captureSession = self.captureSession else {
+                    throw CameraControllerError.captureSessionIsMissing
+                }
 
-            // Start the session
-            captureSession.startRunning()
-            print("[CameraPreview] Session started")
+                print("[CameraPreview] Fast prepare - using pre-initialized session")
 
-            completionHandler(nil)
+                // Pre-create outputs asynchronously to avoid blocking camera opening
+                outputPreparationQueue.async { [weak self] in
+                    self?.prepareOutputs()
+                }
+
+                // // Configure device inputs for the requested camera
+                try self.configureDeviceInputs(cameraPosition: cameraPosition, deviceId: deviceId, disableAudio: disableAudio)
+
+                // Start the session on background thread (AVCaptureSession.startRunning() is thread-safe)
+                captureSession.startRunning()
+                print("[CameraPreview] Session started")
+
+                // Validate and set initial zoom level asynchronously
+                if initialZoomLevel != 1.0 {
+                    DispatchQueue.main.async { [weak self] in
+                        self?.setInitialZoom(level: initialZoomLevel)
+                    }
+                }
+
+                // Call completion on main thread
+                DispatchQueue.main.async {
+                    completionHandler(nil)
+
+                    // Upgrade quality settings after a short delay for better user experience
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+                        guard let self = self else { return }
+
+                        // Wait for outputs to be prepared before proceeding
+                        self.waitForOutputsToBeReady()
+
+                        // Add outputs to session and apply user settings
+                        do {
+                            try self.addOutputsToSession(cameraMode: cameraMode, aspectRatio: aspectRatio)
+                            print("[CameraPreview] Outputs successfully added to session")
+                        } catch {
+                            print("[CameraPreview] Error adding outputs to session: \(error)")
+                        }
+
+                        self.upgradeQualitySettings()
+                    }
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    completionHandler(error)
+                }
+            }
+        }
+    }
+
+    private func setInitialZoom(level: Float) {
+        let device = (currentCameraPosition == .rear) ? rearCamera : frontCamera
+        guard let device = device else { return }
+
+        let minZoom = device.minAvailableVideoZoomFactor
+        let maxZoom = min(device.maxAvailableVideoZoomFactor, saneMaxZoomFactor)
+
+        guard CGFloat(level) >= minZoom && CGFloat(level) <= maxZoom else {
+            print("[CameraPreview] Initial zoom level \(level) out of range (\(minZoom)-\(maxZoom))")
+            return
+        }
+
+        do {
+            try device.lockForConfiguration()
+            device.videoZoomFactor = CGFloat(level)
+            device.unlockForConfiguration()
+            self.zoomFactor = CGFloat(level)
+            print("[CameraPreview] Set initial zoom to \(level)")
         } catch {
-            completionHandler(error)
+            print("[CameraPreview] Failed to set initial zoom: \(error)")
         }
     }
 
     private func configureDeviceInputs(cameraPosition: String, deviceId: String?, disableAudio: Bool) throws {
         guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
+        // Ensure cameras are discovered before configuring inputs
+        ensureCamerasDiscovered()
+
         var selectedDevice: AVCaptureDevice?
 
-        // If deviceId is specified, find that specific device from pre-discovered devices
+        // 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 {
-                print("[CameraPreview] ERROR: Device with ID \(deviceId) not found in pre-discovered devices")
+                print("[CameraPreview] ERROR: Device with ID \(deviceId) not found in discovered devices")
                 throw CameraControllerError.noCamerasAvailable
             }
         } else {
-            // Use position-based selection from pre-discovered cameras
+            // Use position-based selection from discovered cameras
             if cameraPosition == "rear" {
                 selectedDevice = self.rearCamera
             } else if cameraPosition == "front" {
@@ -223,16 +380,16 @@ extension CameraController {
                 self.rearCameraInput = deviceInput
                 self.currentCameraPosition = .rear
 
-                // Configure zoom for multi-camera systems
-                try finalDevice.lockForConfiguration()
-                let defaultWideAngleZoom: CGFloat = 2.0
-                if finalDevice.isVirtualDevice && finalDevice.constituentDevices.count > 1 && finalDevice.videoZoomFactor != defaultWideAngleZoom {
+                // Configure zoom for multi-camera systems - simplified and faster
+                if finalDevice.isVirtualDevice && finalDevice.constituentDevices.count > 1 {
+                    try finalDevice.lockForConfiguration()
+                    let defaultWideAngleZoom: CGFloat = 1.0 // Changed from 2.0 to 1.0 for faster startup
                     if defaultWideAngleZoom >= finalDevice.minAvailableVideoZoomFactor && defaultWideAngleZoom <= finalDevice.maxAvailableVideoZoomFactor {
                         print("[CameraPreview] Setting initial zoom to \(defaultWideAngleZoom)")
                         finalDevice.videoZoomFactor = defaultWideAngleZoom
                     }
+                    finalDevice.unlockForConfiguration()
                 }
-                finalDevice.unlockForConfiguration()
             }
         } else {
             throw CameraControllerError.inputsAreInvalid
@@ -257,6 +414,10 @@ extension CameraController {
     private func addOutputsToSession(cameraMode: Bool, aspectRatio: String?) throws {
         guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
+        // Begin configuration to batch all changes
+        captureSession.beginConfiguration()
+        defer { captureSession.commitConfiguration() }
+
         // Update session preset based on aspect ratio if needed
         var targetPreset: AVCaptureSession.Preset = .high // Default to high quality
 
@@ -283,7 +444,7 @@ extension CameraController {
 
         // Add photo output (already created in prepareOutputs)
         if let photoOutput = self.photoOutput, captureSession.canAddOutput(photoOutput) {
-            photoOutput.isHighResolutionCaptureEnabled = self.highResolutionOutput
+            photoOutput.isHighResolutionCaptureEnabled = true
             captureSession.addOutput(photoOutput)
         }
 
@@ -295,9 +456,10 @@ extension CameraController {
         // Add data output
         if let dataOutput = self.dataOutput, captureSession.canAddOutput(dataOutput) {
             captureSession.addOutput(dataOutput)
-            captureSession.commitConfiguration()
-
-            dataOutput.setSampleBufferDelegate(self, queue: DispatchQueue.main)
+            // Set delegate after outputs are added for better performance
+            DispatchQueue.main.async {
+                dataOutput.setSampleBufferDelegate(self, queue: DispatchQueue.main)
+            }
         }
     }
 
@@ -306,33 +468,32 @@ extension CameraController {
 
         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
+        // Create and configure preview layer in one go
+        let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
 
-        // Set contentsScale for retina display quality
-        self.previewLayer?.contentsScale = UIScreen.main.scale
+        // Batch all layer configuration to avoid multiple redraws
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
 
-        // Enable high-quality rendering
-        if #available(iOS 13.0, *) {
-            self.previewLayer?.videoGravity = .resizeAspectFill
-        }
+        previewLayer.videoGravity = AVLayerVideoGravity.resizeAspectFill
+        previewLayer.connection?.videoOrientation = .portrait
+        previewLayer.isOpaque = true
+        previewLayer.contentsScale = UIScreen.main.scale
+        previewLayer.frame = view.bounds
 
-        view.layer.insertSublayer(self.previewLayer!, at: 0)
+        // Insert layer and store reference
+        view.layer.insertSublayer(previewLayer, at: 0)
+        self.previewLayer = previewLayer
 
-        // 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()
+        // Update video orientation asynchronously to avoid blocking
+        DispatchQueue.main.async { [weak self] in
+            self?.updateVideoOrientation()
+        }
     }
 
     func addGridOverlay(to view: UIView, gridMode: String) {
@@ -504,7 +665,7 @@ extension CameraController {
         self.updateVideoOrientation()
     }
 
-    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?, Error?) -> Void) {
         guard let photoOutput = self.photoOutput else {
             completion(nil, NSError(domain: "Camera", code: 0, userInfo: [NSLocalizedDescriptionKey: "Photo output is not available"]))
             return
@@ -512,6 +673,26 @@ extension CameraController {
 
         let settings = AVCapturePhotoSettings()
 
+        // 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, error) in
             if let error = error {
                 completion(nil, error)
@@ -527,12 +708,38 @@ extension CameraController {
                 self.addGPSMetadata(to: image, location: location)
             }
 
-            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)
+            var finalImage = image
+            
+            // Handle aspect ratio if no width/height specified
+            if width == nil && height == nil, let aspectRatio = aspectRatio {
+                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
+                    
+                    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
+                    }
+                }
+            } else if let width = width, let height = height {
+                finalImage = self.resizeImage(image: image, to: CGSize(width: width, height: height))!
             }
+            
+            completion(finalImage, nil)
         }
 
         photoOutput.capturePhoto(with: settings, delegate: self)
@@ -574,6 +781,23 @@ extension CameraController {
         }
         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 captureSample(completion: @escaping (UIImage?, Error?) -> Void) {
         guard let captureSession = captureSession,
@@ -749,7 +973,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:
@@ -780,12 +1004,73 @@ 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
         }
     }
 
-    func setFocus(at point: CGPoint) throws {
+    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:
@@ -804,6 +1089,13 @@ extension CameraController {
             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()
 
@@ -999,6 +1291,9 @@ extension CameraController {
         self.previewLayer?.removeFromSuperlayer()
         self.previewLayer = nil
 
+        self.focusIndicatorView?.removeFromSuperview()
+        self.focusIndicatorView = nil
+
         self.frontCameraInput = nil
         self.rearCameraInput = nil
         self.audioInput = nil
@@ -1006,6 +1301,7 @@ extension CameraController {
         self.frontCamera = nil
         self.rearCamera = nil
         self.audioDevice = nil
+        self.allDiscoveredDevices = []
 
         self.dataOutput = nil
         self.photoOutput = nil
@@ -1013,6 +1309,9 @@ extension CameraController {
 
         self.captureSession = nil
         self.currentCameraPosition = nil
+
+        // Reset output preparation status
+        self.outputsPrepared = false
     }
 
     func captureVideo() throws {
@@ -1089,6 +1388,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() }
@@ -1109,6 +1413,54 @@ extension CameraController: UIGestureRecognizerDelegate {
         }
     }
 
+    private func showFocusIndicator(at point: CGPoint, in view: UIView) {
+        // Remove any existing focus indicator
+        focusIndicatorView?.removeFromSuperview()
+
+        // Create a new focus indicator
+        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 = 40
+        indicator.backgroundColor = UIColor.clear
+        indicator.alpha = 0
+        indicator.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
+
+        // Add inner circle for better visibility
+        let innerCircle = UIView(frame: CGRect(x: 20, y: 20, width: 40, height: 40))
+        innerCircle.layer.borderColor = UIColor.yellow.cgColor
+        innerCircle.layer.borderWidth = 1.0
+        innerCircle.layer.cornerRadius = 20
+        innerCircle.backgroundColor = UIColor.clear
+        indicator.addSubview(innerCircle)
+
+        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 for a moment
+            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 }
@@ -1223,6 +1575,7 @@ enum CameraControllerError: Swift.Error {
     case cannotFindDocumentsDirectory
     case fileVideoOutputNotFound
     case unknown
+    case invalidZoomLevel(min: CGFloat, max: CGFloat, requested: CGFloat)
 }
 
 public enum CameraPosition {
@@ -1249,6 +1602,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,9 +1667,13 @@ extension UIImage {
 
         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)