capacitor-camera-view 2.0.1 → 2.1.0

package/ios/Sources/CameraViewPlugin/CameraViewManager.swift

@@ -1,5 +1,7 @@
 import AVFoundation
+import CoreImage
 import Foundation
+import Metal
 import UIKit
 import WebKit
 
@@ -11,16 +13,44 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     .builtInDualCamera,
     .builtInDualWideCamera,
     .builtInTripleCamera,
-    .builtInTrueDepthCamera
+    .builtInTrueDepthCamera,
 ]
 
 /// A camera implementation that handles camera session management and photo capture.
 @objc public class CameraViewManager: NSObject {
+    // MARK: - Shared Resources
+
+    /// Metal-backed CIContext singleton for efficient image processing.
+    /// Creating CIContext per frame is extremely expensive (80%+ CPU waste).
+    /// This shared instance uses Metal for GPU acceleration when available.
+    internal static let sharedCIContext: CIContext = {
+        if let metalDevice = MTLCreateSystemDefaultDevice() {
+            return CIContext(mtlDevice: metalDevice, options: [.cacheIntermediates: false])
+        }
+        return CIContext(options: [.useSoftwareRenderer: true])
+    }()
+
+    // MARK: - Capture Session Components
+
     internal let captureSession = AVCaptureSession()
     internal let avPhotoOutput = AVCapturePhotoOutput()
     internal let avVideoDataOutput = AVCaptureVideoDataOutput()
     internal let videoPreviewLayer = AVCaptureVideoPreviewLayer()
 
+    /// Dedicated queue for all capture session operations.
+    /// Using a consistent queue prevents race conditions and ensures thread safety.
+    private let sessionQueue = DispatchQueue(
+        label: "com.michaelwolz.capacitorcameraview.session",
+        qos: .userInitiated
+    )
+
+    /// Reusable queue for sample buffer processing during snapshot capture.
+    /// Creating a new queue per snapshot causes memory allocation churn.
+    private let sampleBufferQueue = DispatchQueue(
+        label: "com.michaelwolz.capacitorcameraview.sampleBuffer",
+        qos: .userInitiated
+    )
+
     /// The currently active camera device.
     private var currentCameraDevice: AVCaptureDevice?
 
@@ -36,12 +66,19 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     /// Reference to the webView that is used by the Capacitor plugin for the preview layer is shown on
     private var webView: UIView?
 
-    /// Callback for when photo capture completes.
+    /// Callback for when photo capture completes (legacy UIImage-based API).
     internal var photoCaptureHandler: ((UIImage?, Error?) -> Void)?
 
+    /// Callback for when photo capture completes with raw Data (optimized API).
+    /// This avoids double JPEG encoding by returning the camera's JPEG data directly.
+    internal var photoDataCaptureHandler: ((Data?, Error?) -> Void)?
+
     /// Callback for when snapshot capture completes.
     internal var snapshotCompletionHandler: ((UIImage?, Error?) -> Void)?
 
+    /// Emits typed camera events to the delegate and NotificationCenter.
+    internal let eventEmitter = CameraEventEmitter()
+
     override public init() {
         super.init()
         setupOrientationObserver()
@@ -66,11 +103,15 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         webView: UIView,
         completion: @escaping (Error?) -> Void
     ) {
-        if let preferredCameraDeviceTypes = configuration.preferredCameraDeviceTypes {
-            self.preferredCameraDeviceTypes = convertToNativeCameraTypes(preferredCameraDeviceTypes)
+        if let preferredCameraDeviceTypes = configuration
+            .preferredCameraDeviceTypes
+        {
+            self.preferredCameraDeviceTypes = convertToNativeCameraTypes(
+                preferredCameraDeviceTypes
+            )
         }
 
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+        sessionQueue.async { [weak self] in
             guard let self = self else { return }
 
             do {
@@ -89,12 +130,15 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
             self.displayPreview(
                 on: webView,
                 completion: { error in
-                    if error != nil { completion(error) }
+                    if error != nil {
+                        completion(error)
+                        return
+                    }
 
                     // Handle barcode detection after session is running
                     if configuration.enableBarcodeDetection {
                         do {
-                            try self.enableBarcodeDetection()
+                            try self.enableBarcodeDetection(barcodeTypes: configuration.barcodeTypes)
                         } catch {
                             completion(error)
                             return
@@ -110,34 +154,38 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
                             await self.upgradeToTripleCameraIfAvailable()
                         }
                     }
-                })
+                }
+            )
         }
     }
 
-    /// Stops the current capture session.
+    /// Stops the current capture session and cleans up temporary files.
     public func stopSession(completion: (() -> Void)? = nil) {
         guard captureSession.isRunning else {
             completion?()
             return
         }
 
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+        sessionQueue.async { [weak self] in
             self?.captureSession.stopRunning()
-        }
 
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            self.videoPreviewLayer.removeFromSuperlayer()
-            self.webView?.isOpaque = true
-            self.webView?.backgroundColor = nil
-            self.webView = nil
-
-            if let blurOverlayView = self.blurOverlayView {
-                blurOverlayView.removeFromSuperview()
-                self.blurOverlayView = nil
-            }
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else {
+                    completion?()
+                    return
+                }
+                self.videoPreviewLayer.removeFromSuperlayer()
+                self.webView?.isOpaque = true
+                self.webView?.backgroundColor = nil
+                self.webView = nil
 
-            completion?()
+                if let blurOverlayView = self.blurOverlayView {
+                    blurOverlayView.removeFromSuperview()
+                    self.blurOverlayView = nil
+                }
+
+                completion?()
+            }
         }
     }
 
@@ -168,7 +216,8 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
 
         // Ensure proper orientation
         if let photoConnection = avPhotoOutput.connection(with: .video),
-           let previewConnection = videoPreviewLayer.connection {
+           let previewConnection = videoPreviewLayer.connection
+        {
             if photoConnection.isVideoOrientationSupported {
                 photoConnection.videoOrientation = previewConnection.videoOrientation
             }
@@ -178,10 +227,48 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         photoCaptureHandler = completion
     }
 
+    /// Captures a photo and returns the raw JPEG data directly.
+    /// This optimized method avoids double JPEG encoding by returning the camera's
+    /// native JPEG data instead of converting through UIImage.
+    ///
+    /// - Parameter completion: Called with the captured JPEG data or an error.
+    public func capturePhotoData(completion: @escaping (Data?, Error?) -> Void) {
+        guard let cameraDevice = currentCameraDevice else {
+            completion(nil, CameraError.cameraUnavailable)
+            return
+        }
+
+        guard captureSession.isRunning else {
+            completion(nil, CameraError.sessionNotRunning)
+            return
+        }
+
+        let photoSettings = AVCapturePhotoSettings()
+        if cameraDevice.hasFlash {
+            photoSettings.flashMode = flashMode
+        } else {
+            photoSettings.flashMode = .off
+        }
+
+        // Ensure proper orientation
+        if let photoConnection = avPhotoOutput.connection(with: .video),
+           let previewConnection = videoPreviewLayer.connection
+        {
+            if photoConnection.isVideoOrientationSupported {
+                photoConnection.videoOrientation = previewConnection.videoOrientation
+            }
+        }
+
+        avPhotoOutput.capturePhoto(with: photoSettings, delegate: self)
+        photoDataCaptureHandler = completion
+    }
+
     /// Capture a snapshot of the current camera view. This is faster than actually processing a
     /// photo via capturePhoto
     /// - Parameter completion: called with the captured UIImage or an error.
-    public func captureSnapshot(completion: @escaping (UIImage?, Error?) -> Void) {
+    public func captureSnapshot(
+        completion: @escaping (UIImage?, Error?) -> Void
+    ) {
         guard currentCameraDevice != nil else {
             completion(nil, CameraError.cameraUnavailable)
             return
@@ -194,24 +281,27 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
 
         // Ensure proper orientation
         if let videoConnection = avVideoDataOutput.connection(with: .video),
-           let previewConnection = videoPreviewLayer.connection {
+           let previewConnection = videoPreviewLayer.connection
+        {
             if videoConnection.isVideoOrientationSupported {
                 videoConnection.videoOrientation = previewConnection.videoOrientation
             }
         }
 
-        // Create a serial queue for sample buffer processing
-        let sampleBufferQueue = DispatchQueue(label: "com.michaelwolz.capacitorcameraview.snapshotQueue")
-
-        // Set the delegate for a single frame capture
+        // Set the delegate for a single frame capture using the reusable queue
         snapshotCompletionHandler = completion
-        avVideoDataOutput.setSampleBufferDelegate(self, queue: sampleBufferQueue)
+        avVideoDataOutput.setSampleBufferDelegate(
+            self,
+            queue: sampleBufferQueue
+        )
     }
 
     /// Flips the camera to the opposite position (front to back or back to front).
     public func flipCamera() throws {
-        let currentPosition: AVCaptureDevice.Position = currentCameraDevice?.position ?? .back
-        let newPosition: AVCaptureDevice.Position = currentPosition == .back ? .front : .back
+        let currentPosition: AVCaptureDevice.Position =
+        currentCameraDevice?.position ?? .back
+        let newPosition: AVCaptureDevice.Position =
+        currentPosition == .back ? .front : .back
 
         let newCamera = try getCameraDevice(for: newPosition)
         try setInput(with: newCamera)
@@ -222,7 +312,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     /// - Parameter mode: The desired flash mode (.on, .of, or .auto).
     /// - Throws: An error if the flash mode cannot be set or is not supported.
     public func setFlashMode(_ mode: AVCaptureDevice.FlashMode) throws {
-        guard let camera = currentCameraDevice else { throw CameraError.cameraUnavailable }
+        guard let camera = currentCameraDevice else {
+            throw CameraError.cameraUnavailable
+        }
         guard camera.hasFlash else { throw CameraError.unsupportedFlashMode }
         guard avPhotoOutput.supportedFlashModes.contains(mode)
         else {
@@ -275,7 +367,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///   - level: The torch intensity level (0.0 to 1.0)
     /// - Throws: An error if the torch mode cannot be set or is not supported.
     public func setTorchMode(enabled: Bool, level: Float = 1.0) throws {
-        guard let camera = currentCameraDevice else { throw CameraError.cameraUnavailable }
+        guard let camera = currentCameraDevice else {
+            throw CameraError.cameraUnavailable
+        }
         guard camera.hasTorch else { throw CameraError.torchUnavailable }
 
         do {
@@ -297,7 +391,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     /// because some devices report very high zoom factors that aren't useful.
     ///
     /// - Returns: A tuple containing the minimum, maximum, and current zoom factors.
-    public func getSupportedZoomFactors() -> (min: CGFloat, max: CGFloat, current: CGFloat) {
+    public func getSupportedZoomFactors() -> (
+        min: CGFloat, max: CGFloat, current: CGFloat
+    ) {
         guard let currentDevice = currentCameraDevice else {
             return (
                 min: 1.0,
@@ -307,7 +403,10 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         }
 
         let minZoomFactor = currentDevice.minAvailableVideoZoomFactor
-        let maxZoomFactor = min(currentDevice.activeFormat.videoMaxZoomFactor, 10.0)
+        let maxZoomFactor = min(
+            currentDevice.activeFormat.videoMaxZoomFactor,
+            10.0
+        )
         let currentZoomFactor = currentDevice.videoZoomFactor
 
         return (
@@ -324,10 +423,15 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///   - ramp: If enabled the zoom will be applied via ramp
     /// - Throws: An error if the zoom factor cannot be set.
     public func setZoomFactor(_ factor: CGFloat, ramp: Bool = true) throws {
-        guard let device = currentCameraDevice else { throw CameraError.cameraUnavailable }
+        guard let device = currentCameraDevice else {
+            throw CameraError.cameraUnavailable
+        }
 
         let supportedZoomFactors = getSupportedZoomFactors()
-        guard factor >= supportedZoomFactors.min && factor <= supportedZoomFactors.max else {
+        guard
+            factor >= supportedZoomFactors.min
+                && factor <= supportedZoomFactors.max
+        else {
             throw CameraError.zoomFactorOutOfRange
         }
 
@@ -349,7 +453,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///
     /// - Parameters:
     ///   - configuration: The configuration object for the camera session.
-    private func initiateCaptureSession(configuration: CameraSessionConfiguration) throws {
+    private func initiateCaptureSession(
+        configuration: CameraSessionConfiguration
+    ) throws {
         captureSession.beginConfiguration()
         defer { captureSession.commitConfiguration() }
 
@@ -418,7 +524,6 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         }
     }
 
-
     /// Enables barcode detection by adding metadata output to the running session.
     /// Somehow adding the metadata output with the session not being started yet
     /// caused issues on some devices (iPad 7th Gen) where the session would just
@@ -426,8 +531,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     /// figure out the root cause of this but it might generally be a good idea
     /// to only add the metadata output when the session is already running.
     ///
+    /// - Parameter barcodeTypes: Optional array of barcode types to detect. If nil, all supported types are used.
     /// - Throws: An error if the metadata output cannot be added.
-    private func enableBarcodeDetection() throws {
+    private func enableBarcodeDetection(barcodeTypes: [AVMetadataObject.ObjectType]? = nil) throws {
         guard captureSession.isRunning else {
             throw CameraError.sessionNotRunning
         }
@@ -435,7 +541,7 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         captureSession.beginConfiguration()
         defer { captureSession.commitConfiguration() }
 
-        try setupMetadataOutput()
+        try setupMetadataOutput(barcodeTypes: barcodeTypes)
     }
 
     /// Retrieve a list of a available camera devices
@@ -468,11 +574,14 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///   - position: The position of the camera device to get
     /// - Returns: The camera device for the specified position
     /// - Throws: An error if no camera device is found.
-    private func getCameraDevice(for position: AVCaptureDevice.Position?) throws -> AVCaptureDevice {
+    private func getCameraDevice(for position: AVCaptureDevice.Position?) throws
+    -> AVCaptureDevice
+    {
         let preferredDevices = getPreferredCameraDevices()
 
         // First try to get the best match based on the users preferred camera device types
-        if let match = preferredDevices.first(where: { $0.position == position }) {
+        if let match = preferredDevices.first(where: { $0.position == position }
+        ) {
             return match
         }
 
@@ -480,7 +589,10 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         // Only doing this when preferredCameraDeviceTypes size differs from SUPPORTED_CAMERA_DEVICE_TYPES, otherwise
         // we don't have to initialize a new discovery session
         if preferredCameraDeviceTypes.count < SUPPORTED_CAMERA_DEVICE_TYPES.count,
-           let match = getAvailableDevices().first(where: { $0.position == position }) {
+           let match = getAvailableDevices().first(where: {
+               $0.position == position
+           })
+        {
             return match
         }
 
@@ -490,8 +602,11 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
         }
 
         // Log when we're falling back to a device with different position than requested
-        if let requestedPosition = position, device.position != requestedPosition {
-            print("Warning: Falling back to camera at position \(device.position) when \(requestedPosition) was requested")
+        if let requestedPosition = position, device.position != requestedPosition
+        {
+            print(
+                "Warning: Falling back to camera at position \(device.position) when \(requestedPosition) was requested"
+            )
         }
 
         return device
@@ -503,8 +618,14 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///   - deviceId: The unique identifier of the camera device to get
     /// - Returns: The camera device for the specified position
     /// - Throws: An error if no camera device is found.
-    private func getCameraDeviceById(_ deviceId: String) throws -> AVCaptureDevice {
-        guard let device = getAvailableDevices().first(where: { $0.uniqueID == deviceId }) else {
+    private func getCameraDeviceById(_ deviceId: String) throws
+    -> AVCaptureDevice
+    {
+        guard
+            let device = getAvailableDevices().first(where: {
+                $0.uniqueID == deviceId
+            })
+        else {
             throw CameraError.cameraUnavailable
         }
         return device
@@ -519,7 +640,10 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     ///   - view: The view that will display the camera preview.
     ///   - completion: The completion handler after successfully adding the previewLayer to the provided view
     /// - Throws: An error if the preview layer cannot be set up.
-    private func displayPreview(on view: UIView, completion: @escaping (Error?) -> Void) {
+    private func displayPreview(
+        on view: UIView,
+        completion: @escaping (Error?) -> Void
+    ) {
         guard captureSession.isRunning else {
             completion(CameraError.sessionNotRunning)
             return
@@ -580,7 +704,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
                 try self.setZoomFactor(2.0, ramp: false)
             } catch {
                 // Fail silently if we can't upgrade to the triple camera
-                print("Failed to upgrade to triple camera: \(error.localizedDescription)")
+                print(
+                    "Failed to upgrade to triple camera: \(error.localizedDescription)"
+                )
             }
 
             self.captureSession.commitConfiguration()
@@ -612,7 +738,9 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     /// Removes the blur overlay with a fade out animation to have a smooth transition
     /// - Parameter duration: The duration of the fade out animation
     @MainActor
-    private func removeBlurOverlayWithAnimation(duration: TimeInterval = 0.3) async {
+    private func removeBlurOverlayWithAnimation(duration: TimeInterval = 0.3)
+    async
+    {
         guard let blurEffectView = blurOverlayView else { return }
 
         await withCheckedContinuation { continuation in
@@ -625,7 +753,8 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
                     blurEffectView.removeFromSuperview()
                     self.blurOverlayView = nil
                     continuation.resume()
-                })
+                }
+            )
         }
     }
 
@@ -644,11 +773,15 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
 
     /// Updates the preview layer orientation based on the current device orientation.
     private func updatePreviewOrientation() {
-        guard let connection = self.videoPreviewLayer.connection, connection.isVideoOrientationSupported else {
+        guard let connection = self.videoPreviewLayer.connection,
+              connection.isVideoOrientationSupported
+        else {
             return
         }
 
-        let interfaceOrientation = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation ?? .portrait
+        let interfaceOrientation = UIApplication.shared.connectedScenes
+            .compactMap({ $0 as? UIWindowScene })
+            .first?.interfaceOrientation ?? .portrait
         let videoOrientation: AVCaptureVideoOrientation
 
         switch interfaceOrientation {
@@ -688,14 +821,15 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
             self,
             selector: #selector(handleAppDidBecomeActive),
             name: UIApplication.didBecomeActiveNotification,
-            object: nil)
+            object: nil
+        )
     }
 
     /// Handles the app going to background by pausing the camera session.
     @objc private func handleAppWillResignActive() {
         // Pause the session when app goes to background to save resources
         if captureSession.isRunning {
-            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            sessionQueue.async { [weak self] in
                 self?.captureSession.stopRunning()
             }
         }
@@ -705,7 +839,7 @@ internal let SUPPORTED_CAMERA_DEVICE_TYPES: [AVCaptureDevice.DeviceType] = [
     @objc private func handleAppDidBecomeActive() {
         // Resume the session when app comes back to foreground
         if !captureSession.isRunning && webView != nil {
-            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            sessionQueue.async { [weak self] in
                 self?.captureSession.startRunning()
             }
         }