capacitor-camera-view 1.0.0

package/ios/Sources/CameraViewPlugin/CameraSessionConfiguration.swift

@@ -0,0 +1,32 @@
+import AVFoundation
+import Capacitor
+
+public struct CameraSessionConfiguration {
+    let deviceId: String?
+    let enableBarcodeDetection: Bool
+    let position: AVCaptureDevice.Position
+    let preferredCameraDeviceTypes: [String]?
+    let useTripleCameraIfAvailable: Bool
+    let zoomFactor: CGFloat?
+}
+
+/// Maps a Capacitor plugin call to a CameraSessionConfiguration struct.
+///
+/// - Parameter call: The Capacitor plugin call.
+public func sessionConfigFromPluginCall(_ call: CAPPluginCall) -> CameraSessionConfiguration {
+    let deviceId = call.getString("deviceId")
+    let enableBarcodeDetection = call.getBool("enableBarcodeDetection", false)
+    let position: AVCaptureDevice.Position = call.getString("position") == "front" ? .front : .back
+    let preferredCameraDeviceTypes = call.getArray("preferredCameraDeviceTypes") as? [String]
+    let useTripleCameraIfAvailable = call.getBool("useTripleCameraIfAvailable",  false)
+    let zoomFactor = call.getDouble("zoomFactor").map { CGFloat($0) }
+
+    return CameraSessionConfiguration(
+        deviceId: deviceId,
+        enableBarcodeDetection: enableBarcodeDetection,
+        position: position,
+        preferredCameraDeviceTypes: preferredCameraDeviceTypes,
+        useTripleCameraIfAvailable: useTripleCameraIfAvailable,
+        zoomFactor: zoomFactor
+    )
+}

package/ios/Sources/CameraViewPlugin/CameraViewManager+BarcodeScan.swift

@@ -0,0 +1,91 @@
+import AVFoundation
+import Foundation
+
+extension CameraViewManager: AVCaptureMetadataOutputObjectsDelegate {
+    /// Set up metadata output for the capture session in case it's not configured yet
+    /// Make sure to call `captureSession.beginConfiguration` before calling this
+    ///
+    /// - Throws: An error if the output cannot be set.
+    internal func setupMetadataOutput() throws {
+        let metadataOutput = AVCaptureMetadataOutput()
+
+        if (captureSession.outputs.contains { $0 is AVCaptureMetadataOutput }) {
+            // Nothing todo, we already have an output
+            return
+        }
+
+        if !captureSession.canAddOutput(metadataOutput) {
+            throw CameraError.outputAdditionFailed
+        }
+
+        captureSession.addOutput(metadataOutput)
+
+        metadataOutput.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
+
+        // Set all available barcode types
+        metadataOutput.metadataObjectTypes = [
+            .qr,
+            .code128,
+            .code39,
+            .code39Mod43,
+            .code93,
+            .ean8,
+            .ean13,
+            .interleaved2of5,
+            .itf14,
+            .pdf417,
+            .aztec,
+            .dataMatrix,
+            .upce,
+        ]
+    }
+
+    /// Delegate method called when metadata objects are detected in the camera feed
+    ///
+    /// This method processes barcode data detected in the camera stream. When a barcode is detected,
+    /// it extracts the barcode value and type, then emits a Capacitor event with the barcode data.
+    ///
+    /// - Parameters:
+    ///   - output: The metadata output object that captured the data.
+    ///   - metadataObjects: An array of detected metadata objects, potentially including barcodes.
+    ///   - connection: The connection through which the metadata objects were captured.
+    public func metadataOutput(
+        _ output: AVCaptureMetadataOutput,
+        didOutput metadataObjects: [AVMetadataObject],
+        from connection: AVCaptureConnection
+    ) {
+        guard let metadataObject = metadataObjects.first as? AVMetadataMachineReadableCodeObject
+        else {
+            return
+        }
+        guard let barcodeValue = metadataObject.stringValue else { return }
+
+        let barcodeType = metadataObject.type.rawValue
+
+        // Transform the metadata object to the coordinate space of the video preview layer
+        // This is necessary to get the correct bounding box for the detected barcode
+        // Which in our case should always equal to the device's screen
+        // This way we can simply use pixel coordinates to get the bounding box of the detected barcode and easily show it in the webview
+        guard let transformedMetadataObject = videoPreviewLayer.transformedMetadataObject(for: metadataObject)
+        else { 
+            return 
+        }
+
+        let boundingRect: [String: Double] = [
+            "x": Double(transformedMetadataObject.bounds.origin.x),
+            "y": Double(transformedMetadataObject.bounds.origin.y),
+            "width": Double(transformedMetadataObject.bounds.width),
+            "height": Double(transformedMetadataObject.bounds.height),
+        ]
+
+        NotificationCenter.default.post(
+            name: Notification.Name("barcodeDetected"),
+            object: nil,
+            userInfo: [
+                "value": barcodeValue,
+                "type": barcodeType,
+                "boundingRect": boundingRect,
+            ]
+        )
+    }
+}

package/ios/Sources/CameraViewPlugin/CameraViewManager+PhotoCapture.swift

@@ -0,0 +1,52 @@
+import AVFoundation
+import Foundation
+import UIKit
+
+extension CameraViewManager: AVCapturePhotoCaptureDelegate {
+    /// Set up output for the capture session in case it's not configured yet
+    /// Make sure to call `captureSession.beginConfiguration` before calling this
+    ///
+    /// - Throws: An error if the output cannot be set.
+    internal func setupPhotoOutput() throws {
+        if (captureSession.outputs.contains { $0 is AVCapturePhotoOutput }) {
+            // Nothing todo, we already have an output and since we only
+            // use outputs for taking photos here we don't need a new one
+            return
+        }
+
+        // Balanced should be a good choice for most use cases
+        avPhotoOutput.maxPhotoQualityPrioritization = .balanced
+
+        if !captureSession.canAddOutput(avPhotoOutput) {
+            throw CameraError.outputAdditionFailed
+        }
+
+        captureSession.addOutput(avPhotoOutput)
+    }
+
+    /// Delegate method called when a photo has been captured via `AVCapturePhotoCaptureDelegate`
+    ///
+    /// - Parameters:
+    ///   - output: The photo output that captured the photo.
+    ///   - photo: The captured photo.
+    ///   - error: An error that occurred during photo capture.
+    public func photoOutput(
+        _ output: AVCapturePhotoOutput,
+        didFinishProcessingPhoto photo: AVCapturePhoto,
+        error: Error?
+    ) {
+        if let error = error {
+            photoCaptureHandler?(nil, error)
+            return
+        }
+
+        guard let data = photo.fileDataRepresentation(), let image = UIImage(data: data) else {
+            photoCaptureHandler?(nil, CameraError.photoOutputError)
+            return
+        }
+
+        photoCaptureHandler?(image, nil)
+    }
+
+}
+

package/ios/Sources/CameraViewPlugin/CameraViewManager+VideoDataOutput.swift

@@ -0,0 +1,78 @@
+import AVFoundation
+import CoreImage
+import Foundation
+import UIKit
+
+extension CameraViewManager: AVCaptureVideoDataOutputSampleBufferDelegate {
+    /// Set up video data output for the capture session in case it's not configured yet
+    /// This is used for taking snapshots of the camera feed
+    /// Make sure to call `captureSession.beginConfiguration` before calling this
+    ///
+    /// - Throws: An error if the output cannot be set.
+    /// - Note: This method does not set the delegate for the output. The delegate is set
+    ///         when a snapshot is requested.
+    internal func setupVideoDataOutput() throws {
+        if (captureSession.outputs.contains { $0 is AVCaptureVideoDataOutput }) {
+            // Nothing todo, we already have an output and since we only
+            // use video outputs for taking snapshots here we don't need a new one
+            return
+        }
+
+        // Configure video data output
+        avVideoDataOutput.videoSettings = [
+            kCVPixelBufferPixelFormatTypeKey as String: Int(kCVPixelFormatType_32BGRA)
+        ]
+        avVideoDataOutput.alwaysDiscardsLateVideoFrames = true
+
+        // We're not setting the delegate here as we'll set it only when needed for snapshot capture
+
+        if !captureSession.canAddOutput(avVideoDataOutput) {
+            throw CameraError.outputAdditionFailed
+        }
+
+        captureSession.addOutput(avVideoDataOutput)
+    }
+
+    /// Capture a snapshot from the camera feed
+    public func captureOutput(
+        _ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
+        from connection: AVCaptureConnection
+    ) {
+        // Only process if we have a completion handler set
+        guard let completionHandler = snapshotCompletionHandler else { return }
+
+        // Clear the completion handler to ensure we only capture one frame
+        snapshotCompletionHandler = nil
+
+        avVideoDataOutput.setSampleBufferDelegate(nil, queue: nil)
+
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            completionHandler(nil, CameraError.frameCaptureError)
+            return
+        }
+
+        let ciImage = CIImage(cvPixelBuffer: imageBuffer)
+        let context = CIContext()
+        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else {
+            completionHandler(nil, CameraError.frameCaptureError)
+            return
+        }
+
+        let image = UIImage(cgImage: cgImage)
+        completionHandler(image, nil)
+    }
+
+    /// Delegate method called when a frame is dropped via `AVCaptureVideoDataOutputSampleBufferDelegate`
+    public func captureOutput(
+        _ output: AVCaptureOutput, didDrop sampleBuffer: CMSampleBuffer,
+        from connection: AVCaptureConnection
+    ) {
+        // If we have a completion handler and a frame was dropped, report the error
+        if let completionHandler = snapshotCompletionHandler {
+            snapshotCompletionHandler = nil
+            avVideoDataOutput.setSampleBufferDelegate(nil, queue: nil)
+
+            completionHandler(nil, CameraError.frameCaptureError)
+        }
+    }
+}