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

package/ios/Sources/CapgoCameraPreview/CameraController.swift

@@ -40,6 +40,8 @@ class CameraController: NSObject {
     var audioInput: AVCaptureDeviceInput?
 
     var zoomFactor: CGFloat = 1.0
+    private var lastZoomUpdateTime: TimeInterval = 0
+    private let zoomUpdateThrottle: TimeInterval = 1.0 / 60.0 // 60 FPS max
 
     var videoFileURL: URL?
     private let saneMaxZoomFactor: CGFloat = 25.5
@@ -52,12 +54,59 @@ class CameraController: NSObject {
 }
 
 extension CameraController {
+    func prepareBasicSession() {
+        // Only prepare if we don't already have a session
+        guard self.captureSession == nil else { return }
+        
+        print("[CameraPreview] Preparing basic camera session in background")
+        
+        // Create basic capture session
+        self.captureSession = AVCaptureSession()
+        
+        // Configure basic devices without full preparation
+        let deviceTypes: [AVCaptureDevice.DeviceType] = [
+            .builtInWideAngleCamera,
+            .builtInUltraWideCamera,
+            .builtInTelephotoCamera,
+            .builtInDualCamera,
+            .builtInDualWideCamera,
+            .builtInTripleCamera,
+            .builtInTrueDepthCamera
+        ]
+
+        let session = AVCaptureDevice.DiscoverySession(deviceTypes: deviceTypes, mediaType: AVMediaType.video, position: .unspecified)
+        let cameras = session.devices.compactMap { $0 }
+        
+        // Find best cameras
+        let rearVirtualDevices = cameras.filter { $0.position == .back && $0.isVirtualDevice }
+        let bestRearVirtualDevice = rearVirtualDevices.max { $0.constituentDevices.count < $1.constituentDevices.count }
+        
+        self.frontCamera = cameras.first(where: { $0.position == .front })
+        
+        if let bestCamera = bestRearVirtualDevice {
+            self.rearCamera = bestCamera
+        } else if let firstRearCamera = cameras.first(where: { $0.position == .back }) {
+            self.rearCamera = firstRearCamera
+        }
+        
+        print("[CameraPreview] Basic session prepared with \(cameras.count) devices")
+    }
+
     func prepare(cameraPosition: String, deviceId: String? = nil, disableAudio: Bool, cameraMode: Bool, aspectRatio: String? = nil, completionHandler: @escaping (Error?) -> Void) {
         func createCaptureSession() {
-            self.captureSession = AVCaptureSession()
+            // Use existing session if available from background preparation
+            if self.captureSession == nil {
+                self.captureSession = AVCaptureSession()
+            }
         }
 
         func configureCaptureDevices() throws {
+            // Skip device discovery if cameras are already found during background preparation
+            if self.frontCamera != nil || self.rearCamera != nil {
+                print("[CameraPreview] Using pre-discovered cameras")
+                return
+            }
+            
             // Expanded device types to support more camera configurations
             let deviceTypes: [AVCaptureDevice.DeviceType] = [
                 .builtInWideAngleCamera,
@@ -205,14 +254,17 @@ extension CameraController {
         func configurePhotoOutput(cameraMode: Bool) throws {
             guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
-            // Configure session preset based on aspect ratio and other settings
-            var targetPreset: AVCaptureSession.Preset = .photo // Default preset
+            // 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 HD presets for 16:9 aspect ratio
-                    if self.highResolutionOutput && captureSession.canSetSessionPreset(.hd1920x1080) {
+                    // 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
@@ -220,26 +272,32 @@ extension CameraController {
                         targetPreset = .high
                     }
                 case "4:3":
-                    // Use photo preset for 4:3 aspect ratio (traditional photo format)
-                    if self.highResolutionOutput && captureSession.canSetSessionPreset(.photo) {
+                    // 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 behavior for unrecognized aspect ratios
-                    if !cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.photo) {
+                    // Default to highest available quality
+                    if captureSession.canSetSessionPreset(.photo) {
                         targetPreset = .photo
-                    } else if cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.high) {
+                    } else if captureSession.canSetSessionPreset(.high) {
                         targetPreset = .high
+                    } else {
+                        targetPreset = .medium
                     }
                 }
             } else {
-                // Original logic when no aspect ratio is specified
-                if !cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.photo) {
+                // Default to highest available quality when no aspect ratio specified
+                if captureSession.canSetSessionPreset(.photo) {
                     targetPreset = .photo
-                } else if cameraMode && self.highResolutionOutput && captureSession.canSetSessionPreset(.high) {
+                } else if captureSession.canSetSessionPreset(.high) {
                     targetPreset = .high
+                } else {
+                    targetPreset = .medium
                 }
             }
 
@@ -248,9 +306,11 @@ extension CameraController {
                 captureSession.sessionPreset = targetPreset
                 print("[CameraPreview] Set session preset to \(targetPreset) for aspect ratio: \(aspectRatio ?? "default")")
             } else {
-                // Fallback to a basic preset if the target preset is not supported
-                print("[CameraPreview] Target preset \(targetPreset) not supported, falling back to .medium")
-                if captureSession.canSetSessionPreset(.medium) {
+                // 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
                 }
             }
@@ -311,11 +371,30 @@ extension CameraController {
     func displayPreview(on view: UIView) throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
 
+        print("[CameraPreview] displayPreview called with view frame: \(view.frame)")
+
         self.previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
         self.previewLayer?.videoGravity = AVLayerVideoGravity.resizeAspectFill
 
+        // Optimize preview layer for better quality
+        self.previewLayer?.connection?.videoOrientation = .portrait
+        self.previewLayer?.isOpaque = true
+
+        // Enable high-quality rendering
+        if #available(iOS 13.0, *) {
+            self.previewLayer?.videoGravity = .resizeAspectFill
+        }
+
         view.layer.insertSublayer(self.previewLayer!, at: 0)
-        self.previewLayer?.frame = view.frame
+        
+        // Disable animation for frame update
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        self.previewLayer?.frame = view.bounds
+        CATransaction.commit()
+
+        print("[CameraPreview] Set preview layer frame to view bounds: \(view.bounds)")
+        print("[CameraPreview] Session preset: \(captureSession.sessionPreset.rawValue)")
 
         updateVideoOrientation()
     }
@@ -323,9 +402,13 @@ extension CameraController {
     func addGridOverlay(to view: UIView, gridMode: String) {
         removeGridOverlay()
 
+        // Disable animation for grid overlay creation and positioning
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
         gridOverlayView = GridOverlayView(frame: view.bounds)
         gridOverlayView?.gridMode = gridMode
         view.addSubview(gridOverlayView!)
+        CATransaction.commit()
     }
 
     func removeGridOverlay() {
@@ -349,6 +432,10 @@ extension CameraController {
     func setupPinchGesture(target: UIView, selector: Selector, delegate: UIGestureRecognizerDelegate?) {
         let pinchGesture = UIPinchGestureRecognizer(target: self, action: selector)
         pinchGesture.delegate = delegate
+        // Optimize gesture recognition for better performance
+        pinchGesture.delaysTouchesBegan = false
+        pinchGesture.delaysTouchesEnded = false
+        pinchGesture.cancelsTouchesInView = false
         target.addGestureRecognizer(pinchGesture)
     }
 
@@ -751,7 +838,8 @@ extension CameraController {
             try device.lockForConfiguration()
 
             if ramp {
-                device.ramp(toVideoZoomFactor: zoomLevel, withRate: 1.0)
+                // Use a very fast ramp rate for immediate response
+                device.ramp(toVideoZoomFactor: zoomLevel, withRate: 8.0)
             } else {
                 device.videoZoomFactor = zoomLevel
             }
@@ -1051,31 +1139,42 @@ extension CameraController: UIGestureRecognizerDelegate {
         }
     }
 
-    @objc
+        @objc
     private func handlePinch(_ pinch: UIPinchGestureRecognizer) {
         guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
 
         let effectiveMaxZoom = min(device.maxAvailableVideoZoomFactor, self.saneMaxZoomFactor)
         func minMaxZoom(_ factor: CGFloat) -> CGFloat { return max(device.minAvailableVideoZoomFactor, min(factor, effectiveMaxZoom)) }
 
-        func update(scale factor: CGFloat) {
+        switch pinch.state {
+        case .began:
+            // Store the initial zoom factor when pinch begins
+            zoomFactor = device.videoZoomFactor
+
+                case .changed:
+            // Throttle zoom updates to prevent excessive CPU usage
+            let currentTime = CACurrentMediaTime()
+            guard currentTime - lastZoomUpdateTime >= zoomUpdateThrottle else { return }
+            lastZoomUpdateTime = currentTime
+
+            // Calculate new zoom factor based on pinch scale
+            let newScaleFactor = minMaxZoom(pinch.scale * zoomFactor)
+
+            // Use ramping for smooth zoom transitions during pinch
+            // This provides much smoother performance than direct setting
             do {
                 try device.lockForConfiguration()
-                defer { device.unlockForConfiguration() }
-
-                device.videoZoomFactor = factor
+                // Use a very fast ramp rate for immediate response
+                device.ramp(toVideoZoomFactor: newScaleFactor, withRate: 5.0)
+                device.unlockForConfiguration()
             } catch {
-                debugPrint(error)
+                debugPrint("Failed to set zoom: \(error)")
             }
-        }
 
-        switch pinch.state {
-        case .began: fallthrough
-        case .changed:
-            let newScaleFactor = minMaxZoom(pinch.scale * zoomFactor)
-            update(scale: newScaleFactor)
         case .ended:
+            // Update our internal zoom factor tracking
             zoomFactor = device.videoZoomFactor
+
         default: break
         }
     }