@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/ios/Camera/TrustchexCameraView.swift

@@ -0,0 +1,1176 @@
+import Foundation
+import React
+import AVFoundation
+import UIKit
+import MLKitFaceDetection
+import MLKitTextRecognition
+import MLKitVision
+
+class TrustchexCameraView: UIView {
+
+    // MARK: - Properties
+    private var captureSession: AVCaptureSession?
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+    private var videoOutput: AVCaptureVideoDataOutput?
+    private var movieFileOutput: AVCaptureMovieFileOutput?
+    private var metadataOutput: AVCaptureMetadataOutput?
+    private var currentCamera: AVCaptureDevice?
+    private var backCameras: [AVCaptureDevice] = []
+    private var lastDetectedBarcodes: [[String: Any]] = []
+    private var barcodeDetectionQueue = DispatchQueue(label: "com.trustchex.camera.barcodeQueue")
+
+    private let sessionQueue = DispatchQueue(label: "com.trustchex.camera.sessionQueue")
+    private let videoQueue = DispatchQueue(label: "com.trustchex.camera.videoQueue")
+    private let processingQueue = DispatchQueue(label: "com.trustchex.camera.processing", qos: .userInitiated)
+
+    @objc var cameraType: String = "back" {
+        didSet {
+            if cameraType != oldValue {
+                switchCameraType(cameraType)
+            }
+        }
+    }
+    @objc var torchEnabled: Bool = false {
+        didSet {
+            if torchEnabled != oldValue {
+                updateTorchEnabled(torchEnabled)
+            }
+        }
+    }
+    @objc var enableFrameProcessing: Bool = false {
+        didSet {
+            _frameProcessingEnabled = enableFrameProcessing
+        }
+    }
+    @objc var enableFaceDetection: Bool = false
+    @objc var enableTextRecognition: Bool = false
+    @objc var enableBarcodeScanning: Bool = false
+    @objc var enableMrzValidation: Bool = false
+    @objc var includeBase64: Bool = false
+    @objc var targetFps: NSNumber = 6 {
+        didSet {
+            _targetFps = max(1, min(30, targetFps.int32Value))
+        }
+    }
+
+    private var _cameraType: String = "back"
+    private var _torchEnabled = false
+    private var _frameProcessingEnabled = false
+    private var _targetFps: Int32 = 6
+    private var lastFrameTime: TimeInterval = 0
+    private var isProcessing = false
+    private var isRecording = false
+    private var isCancelledRecording = false
+    private var currentRecordingURL: URL?
+    private var finishFallbackWorkItem: DispatchWorkItem?
+    private var finishFallbackAttempts = 0
+    private let ciContext = CIContext()
+    private var minFrameInterval: TimeInterval {
+        return 1.0 / Double(_targetFps)
+    }
+
+    // ML Kit detectors
+    private lazy var faceDetector: FaceDetector = {
+        let options = FaceDetectorOptions()
+        options.performanceMode = .accurate
+        options.landmarkMode = .none
+        options.classificationMode = .all
+        options.minFaceSize = 0.1  // 10% - small enough to detect faces reliably
+        return FaceDetector.faceDetector(options: options)
+    }()
+
+    private lazy var textRecognizer: TextRecognizer = {
+        let options = TextRecognizerOptions()
+        return TextRecognizer.textRecognizer(options: options)
+    }()
+
+    // Event callbacks
+    @objc var onFrameAvailable: RCTDirectEventBlock?
+    @objc var onCameraReady: RCTDirectEventBlock?
+    @objc var onCameraError: RCTDirectEventBlock?
+    @objc var onRecordingFinished: RCTDirectEventBlock?
+    @objc var onRecordingError: RCTDirectEventBlock?
+
+    // MARK: - Initialization
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupCamera()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    // MARK: - Setup
+    private func setupCamera() {
+        sessionQueue.async { [weak self] in
+            self?.configureCaptureSession()
+        }
+    }
+
+    private func configureCaptureSession() {
+        let session = AVCaptureSession()
+        session.beginConfiguration()
+
+        // Add video input
+        let cameraPosition: AVCaptureDevice.Position = (_cameraType == "front") ? .front : .back
+
+        // Set quality based on camera type
+        // Front camera (liveness): Full HD (1920x1080) for high-quality face detection
+        // Back camera (documents): Full HD (1920x1080) for sharp document capture
+        if cameraPosition == .front {
+            // Front camera: Use Full HD for high-quality liveness detection
+            if session.canSetSessionPreset(.hd1920x1080) {
+                session.sessionPreset = .hd1920x1080
+                print("[TrustchexCamera] Front camera: Using Full HD 1920x1080")
+            } else if session.canSetSessionPreset(.hd1280x720) {
+                session.sessionPreset = .hd1280x720
+                print("[TrustchexCamera] Front camera: Fallback to HD 1280x720")
+            } else {
+                session.sessionPreset = .high
+                print("[TrustchexCamera] Front camera: Using high preset")
+            }
+        } else {
+            // Back camera: Use Full HD for document scanning
+            if session.canSetSessionPreset(.hd1920x1080) {
+                session.sessionPreset = .hd1920x1080
+                print("[TrustchexCamera] Back camera: Using Full HD 1920x1080")
+            } else if session.canSetSessionPreset(.hd1280x720) {
+                session.sessionPreset = .hd1280x720
+                print("[TrustchexCamera] Back camera: Fallback to HD 1280x720")
+            } else {
+                session.sessionPreset = .high
+                print("[TrustchexCamera] Back camera: Using high preset")
+            }
+        }
+        let camera = selectBestCamera(for: cameraPosition)
+        guard let camera = camera,
+              let videoInput = try? AVCaptureDeviceInput(device: camera) else {
+            session.commitConfiguration()
+            sendErrorEvent(error: "Failed to access camera input")
+            return
+        }
+
+        if session.canAddInput(videoInput) {
+            session.addInput(videoInput)
+        }
+        currentCamera = camera
+
+        // Add audio input for video recording
+        if let audioDevice = AVCaptureDevice.default(for: .audio),
+           let audioInput = try? AVCaptureDeviceInput(device: audioDevice) {
+            if session.canAddInput(audioInput) {
+                session.addInput(audioInput)
+            }
+        }
+
+        // Add video output
+        let videoOutput = AVCaptureVideoDataOutput()
+        videoOutput.setSampleBufferDelegate(self, queue: videoQueue)
+        videoOutput.alwaysDiscardsLateVideoFrames = true
+        videoOutput.videoSettings = [
+            kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange
+        ]
+
+        if session.canAddOutput(videoOutput) {
+            session.addOutput(videoOutput)
+        }
+        self.videoOutput = videoOutput
+
+        // Add movie file output for video recording
+        let movieOutput = AVCaptureMovieFileOutput()
+        if session.canAddOutput(movieOutput) {
+            session.addOutput(movieOutput)
+            if let connection = movieOutput.connection(with: .video) {
+                if connection.isVideoOrientationSupported {
+                    connection.videoOrientation = .portrait
+                }
+            }
+        }
+        self.movieFileOutput = movieOutput
+
+        // Add metadata output for native barcode scanning (much faster than MLKit)
+        let metadataOutput = AVCaptureMetadataOutput()
+        if session.canAddOutput(metadataOutput) {
+            session.addOutput(metadataOutput)
+            metadataOutput.setMetadataObjectsDelegate(self, queue: barcodeDetectionQueue)
+
+            // Configure barcode types after adding output
+            let supportedTypes = metadataOutput.availableMetadataObjectTypes
+            var typesToEnable: [AVMetadataObject.ObjectType] = []
+
+            if supportedTypes.contains(.pdf417) { typesToEnable.append(.pdf417) }
+            if supportedTypes.contains(.qr) { typesToEnable.append(.qr) }
+            if supportedTypes.contains(.code128) { typesToEnable.append(.code128) }
+            if supportedTypes.contains(.code39) { typesToEnable.append(.code39) }
+            if supportedTypes.contains(.ean13) { typesToEnable.append(.ean13) }
+            if supportedTypes.contains(.ean8) { typesToEnable.append(.ean8) }
+            if supportedTypes.contains(.aztec) { typesToEnable.append(.aztec) }
+            if supportedTypes.contains(.dataMatrix) { typesToEnable.append(.dataMatrix) }
+
+            metadataOutput.metadataObjectTypes = typesToEnable
+            print("[TrustchexCamera] Native barcode scanner enabled with types: \(typesToEnable)")
+        }
+        self.metadataOutput = metadataOutput
+
+        // Configure video connection
+        if let connection = videoOutput.connection(with: .video) {
+            if connection.isVideoOrientationSupported {
+                connection.videoOrientation = .portrait
+            }
+            if connection.isVideoMirroringSupported {
+                connection.isVideoMirrored = (_cameraType == "front")
+            }
+        }
+
+        session.commitConfiguration()
+        self.captureSession = session
+
+        // Setup UI and start running
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.setupPreviewLayer(session: session)
+            self.configureCameraSettings(camera)
+            
+            self.sessionQueue.async { [weak self] in
+                self?.captureSession?.startRunning()
+                
+                let minExposure = Double(camera.minExposureTargetBias)
+                let maxExposure = Double(camera.maxExposureTargetBias)
+                DispatchQueue.main.async { [weak self] in
+                    self?.sendReadyEvent(minExposure: minExposure, maxExposure: maxExposure)
+                }
+            }
+        }
+    }
+
+    // MARK: - Camera Selection
+    private func selectBestCamera(for position: AVCaptureDevice.Position) -> AVCaptureDevice? {
+        if position == .front {
+            return AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
+        }
+
+        // For document/car scanning, prefer cameras with better close-range autofocus.
+        // Wide-angle cameras can struggle with focus at close distances.
+        // Priority: Dual Camera > Triple Camera > Wide Angle
+        
+        // Try dual camera first (iPhone 7 Plus and later with dual cameras)
+        if let dualCamera = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
+            print("[TrustchexCamera] Selected Dual Camera for document scanning (better close-range focus)")
+            return dualCamera
+        }
+        
+        // Try triple camera (iPhone 11 Pro and later)
+        if let tripleCamera = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
+            print("[TrustchexCamera] Selected Triple Camera for document scanning (better close-range focus)")
+            return tripleCamera
+        }
+        
+        // Fall back to wide angle camera
+        print("[TrustchexCamera] Selected Wide Angle camera for document scanning")
+        return AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back)
+    }
+
+
+
+    private func setupPreviewLayer(session: AVCaptureSession) {
+        let preview = AVCaptureVideoPreviewLayer(session: session)
+        preview.videoGravity = .resizeAspectFill
+        
+        // Handle mirroring for front camera
+        if let connection = preview.connection {
+            if connection.isVideoMirroringSupported {
+                connection.automaticallyAdjustsVideoMirroring = false
+                connection.isVideoMirrored = (_cameraType == "front")
+            }
+        }
+        
+        preview.frame = bounds
+        layer.insertSublayer(preview, at: 0)
+        self.previewLayer = preview
+    }
+
+    private func configureCameraSettings(_ camera: AVCaptureDevice) {
+        do {
+            try camera.lockForConfiguration()
+
+            // Configure focus based on camera position
+            // Front camera: Use continuous autofocus for liveness/face detection at arm's length
+            // Back camera: Use close-range focus lock for document scanning
+            let isFrontCamera = camera.position == .front
+
+            if isFrontCamera {
+                // Front camera: Continuous autofocus for face detection
+                if camera.isFocusModeSupported(.continuousAutoFocus) {
+                    camera.focusMode = .continuousAutoFocus
+
+                    // Enable smooth autofocus for better face tracking
+                    if camera.isSmoothAutoFocusSupported {
+                        camera.isSmoothAutoFocusEnabled = true
+                    }
+                } else if camera.isFocusModeSupported(.autoFocus) {
+                    camera.focusMode = .autoFocus
+                }
+            } else {
+                // Back camera: Close-range focus for document scanning
+                if #available(iOS 15.0, *) {
+                    if camera.isLockingFocusWithCustomLensPositionSupported {
+                        // Lock focus at close range (0.9) for document scanning
+                        camera.setFocusModeLocked(lensPosition: 0.9, completionHandler: nil)
+                    } else {
+                        // Fallback to continuous autofocus
+                        if camera.isFocusModeSupported(.continuousAutoFocus) {
+                            camera.focusMode = .continuousAutoFocus
+                        }
+                    }
+                } else {
+                    // iOS 14 and below: Use continuous autofocus
+                    if camera.isFocusModeSupported(.continuousAutoFocus) {
+                        camera.focusMode = .continuousAutoFocus
+
+                        if camera.isSmoothAutoFocusSupported {
+                            camera.isSmoothAutoFocusEnabled = true
+                        }
+                    } else if camera.isFocusModeSupported(.autoFocus) {
+                        camera.focusMode = .autoFocus
+                    }
+                }
+            }
+
+            // Enable subject area change monitoring for better focus responsiveness
+            camera.isSubjectAreaChangeMonitoringEnabled = true
+
+            // Enable continuous auto exposure
+            if camera.isExposureModeSupported(.continuousAutoExposure) {
+                camera.exposureMode = .continuousAutoExposure
+            } else if camera.isExposureModeSupported(.autoExpose) {
+                camera.exposureMode = .autoExpose
+            }
+
+            // Disable HDR
+            if camera.isVideoHDREnabled {
+                camera.automaticallyAdjustsVideoHDREnabled = false
+                camera.isVideoHDREnabled = false
+            }
+
+            camera.unlockForConfiguration()
+        } catch {
+            print("Failed to configure camera: \(error)")
+        }
+    }
+
+    // MARK: - Layout
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        previewLayer?.frame = bounds
+    }
+
+    // MARK: - Public Methods
+    private func switchCameraType(_ type: String) {
+        _cameraType = type
+        sessionQueue.async { [weak self] in
+            self?.switchCamera(to: type)
+        }
+    }
+
+    private func updateTorchEnabled(_ enabled: Bool) {
+        _torchEnabled = enabled
+        sessionQueue.async { [weak self] in
+            guard let camera = self?.currentCamera else { return }
+
+            do {
+                try camera.lockForConfiguration()
+                if camera.hasTorch && (self?.torchEnabled ?? false) {
+                    camera.torchMode = .on
+                } else {
+                    camera.torchMode = .off
+                }
+                camera.unlockForConfiguration()
+            } catch {
+                print("Failed to set torch: \(error)")
+            }
+        }
+    }
+
+    // Imperative methods called from manager
+    @objc(changeCameraType:)
+    func setCameraType(_ type: String) {
+        cameraType = type
+    }
+
+    @objc(changeTorchEnabled:)
+    func setTorchEnabled(_ enabled: Bool) {
+        torchEnabled = enabled
+    }
+
+    @objc(changeEnableFrameProcessing:)
+    func setEnableFrameProcessing(_ enabled: Bool) {
+        enableFrameProcessing = enabled
+    }
+
+    func setEnableFaceDetection(_ enabled: Bool) {
+        enableFaceDetection = enabled
+    }
+
+    func setEnableTextRecognition(_ enabled: Bool) {
+        enableTextRecognition = enabled
+    }
+
+    func setEnableBarcodeScanning(_ enabled: Bool) {
+        enableBarcodeScanning = enabled
+    }
+
+    func setEnableMrzValidation(_ enabled: Bool) {
+        enableMrzValidation = enabled
+    }
+
+    func setIncludeBase64(_ enabled: Bool) {
+        includeBase64 = enabled
+    }
+
+    @objc(changeTargetFps:)
+    func changeTargetFps(_ fps: NSNumber) {
+        targetFps = fps
+    }
+
+    @objc func setFocusPoint(_ x: NSNumber, _ y: NSNumber) {
+        sessionQueue.async { [weak self] in
+            guard let camera = self?.currentCamera else { return }
+
+            let point = CGPoint(x: x.doubleValue, y: y.doubleValue)
+
+            do {
+                try camera.lockForConfiguration()
+
+                if camera.isFocusPointOfInterestSupported {
+                    camera.focusPointOfInterest = point
+                    if camera.isFocusModeSupported(.continuousAutoFocus) {
+                        camera.focusMode = .continuousAutoFocus
+                    } else if camera.isFocusModeSupported(.autoFocus) {
+                        camera.focusMode = .autoFocus
+                    }
+                }
+
+                if camera.isExposurePointOfInterestSupported {
+                    camera.exposurePointOfInterest = point
+                }
+
+                camera.unlockForConfiguration()
+            } catch {
+                print("Failed to set focus point: \(error)")
+            }
+        }
+    }
+
+    @objc func setExposureOffset(_ offset: NSNumber) {
+        sessionQueue.async { [weak self] in
+            guard let camera = self?.currentCamera else { return }
+
+            let bias = offset.floatValue
+
+            do {
+                try camera.lockForConfiguration()
+                camera.setExposureTargetBias(bias, completionHandler: nil)
+                camera.unlockForConfiguration()
+            } catch {
+                print("Failed to set exposure: \(error)")
+            }
+        }
+    }
+
+    @objc func startRecording() {
+        sessionQueue.async { [weak self] in
+            guard let self = self else { return }
+            guard let session = self.captureSession, session.isRunning else { return }
+            guard let movieOutput = self.movieFileOutput else { return }
+
+            // Check actual AVFoundation recording state
+            if movieOutput.isRecording {
+                movieOutput.stopRecording()
+            }
+
+            // Wait for any in-progress recording to finish finalizing
+            var waitAttempts = 0
+            while movieOutput.isRecording && waitAttempts < 50 {
+                Thread.sleep(forTimeInterval: 0.02)
+                waitAttempts += 1
+            }
+
+            if movieOutput.isRecording {
+                DispatchQueue.main.async { [weak self] in
+                    self?.onRecordingError?(["error": "Previous recording still in progress"])
+                }
+                return
+            }
+
+            // Verify video connection exists
+            guard movieOutput.connection(with: .video) != nil else { return }
+
+            // Create temporary file URL
+            let tempDir = NSTemporaryDirectory()
+            let fileName = "recording_\(Date().timeIntervalSince1970).mp4"
+            let fileURL = URL(fileURLWithPath: tempDir).appendingPathComponent(fileName)
+
+            // Remove existing file if any
+            if FileManager.default.fileExists(atPath: fileURL.path) {
+                try? FileManager.default.removeItem(at: fileURL)
+            }
+
+            self.isCancelledRecording = false
+            self.finishFallbackWorkItem?.cancel()
+            self.finishFallbackWorkItem = nil
+            self.finishFallbackAttempts = 0
+            self.currentRecordingURL = fileURL
+            self.isRecording = true
+            movieOutput.startRecording(to: fileURL, recordingDelegate: self)
+        }
+    }
+
+    @objc func stopRecording() {
+        sessionQueue.async { [weak self] in
+            guard let self = self else { return }
+            guard let movieOutput = self.movieFileOutput else { return }
+
+            // Check if recording is actually active
+            if self.isRecording || movieOutput.isRecording {
+                movieOutput.stopRecording()
+            }
+
+            // Schedule fallback as a safety net
+            self.scheduleFinishFallbackCheck()
+        }
+    }
+
+    @objc func cancelRecording() {
+        sessionQueue.async { [weak self] in
+            guard let self = self else { return }
+            guard let movieOutput = self.movieFileOutput else { return }
+
+            // Check both our flag and the actual AVFoundation state
+            guard self.isRecording || movieOutput.isRecording else { return }
+
+            print("[TrustchexCameraView] *** cancelRecording: marking as cancelled ***")
+            self.isCancelledRecording = true
+            movieOutput.stopRecording()
+            // Do NOT set isRecording = false here — let the delegate handle it
+            // to avoid race conditions with startRecording
+        }
+    }
+
+    @objc func deleteRecording(_ filePath: String) {
+        sessionQueue.async {
+            do {
+                let fileURL = URL(fileURLWithPath: filePath)
+                if FileManager.default.fileExists(atPath: filePath) {
+                    try FileManager.default.removeItem(at: fileURL)
+                    print("[TrustchexCameraView] Successfully deleted recording at: \(filePath)")
+                }
+            } catch {
+                print("[TrustchexCameraView] Failed to delete recording: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    private func scheduleFinishFallbackCheck() {
+        finishFallbackWorkItem?.cancel()
+
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self else { return }
+            
+            // Execute the check on the sessionQueue
+            self.sessionQueue.async {
+                guard let movieOutput = self.movieFileOutput else { return }
+                guard let outputURL = self.currentRecordingURL else { return }
+
+                if movieOutput.isRecording {
+                    self.finishFallbackAttempts += 1
+                    if self.finishFallbackAttempts < 6 {
+                        self.scheduleFinishFallbackCheck()
+                    } else {
+                        // Force completion after max attempts
+                        self.finishFallbackAttempts = 0
+                        if !self.isCancelledRecording {
+                            DispatchQueue.main.async {
+                                self.onRecordingFinished?(["path": outputURL.path])
+                            }
+                        }
+                        self.isRecording = false
+                        self.isCancelledRecording = false
+                        self.currentRecordingURL = nil
+                    }
+                    return
+                }
+
+                self.finishFallbackAttempts = 0
+
+                if self.isCancelledRecording {
+                    try? FileManager.default.removeItem(at: outputURL)
+                } else {
+                    DispatchQueue.main.async { [weak self] in
+                        self?.onRecordingFinished?(["path": outputURL.path])
+                    }
+                }
+
+                self.isRecording = false
+                self.isCancelledRecording = false
+                self.currentRecordingURL = nil
+            }
+        }
+
+        finishFallbackWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: workItem)
+        print("[TrustchexCameraView] *** Fallback check scheduled for 0.5s from now ***")
+    }
+
+    private func switchCamera(to type: String) {
+        guard let session = captureSession else { return }
+
+        let position: AVCaptureDevice.Position = (type == "front") ? .front : .back
+
+        // Select best camera for document scanning
+        guard let newCamera = selectBestCamera(for: position),
+              let newInput = try? AVCaptureDeviceInput(device: newCamera) else {
+            return
+        }
+
+        session.beginConfiguration()
+
+        // Remove only the video input, preserve audio input
+        for input in session.inputs {
+            if let deviceInput = input as? AVCaptureDeviceInput,
+               deviceInput.device.hasMediaType(.video) {
+                session.removeInput(deviceInput)
+            }
+        }
+
+        // Add new video input
+        if session.canAddInput(newInput) {
+            session.addInput(newInput)
+        }
+
+        // Re-apply portrait orientation on connections after input swap
+        if let connection = videoOutput?.connection(with: .video) {
+            connection.videoOrientation = .portrait
+            if connection.isVideoStabilizationSupported {
+                connection.preferredVideoStabilizationMode = .standard
+            }
+        }
+        if let connection = movieFileOutput?.connection(with: .video) {
+            connection.videoOrientation = .portrait
+        }
+
+        session.commitConfiguration()
+
+        currentCamera = newCamera
+        configureCameraSettings(newCamera)
+
+        // Update mirroring on preview layer
+        DispatchQueue.main.async { [weak self] in
+            if let connection = self?.previewLayer?.connection {
+                if connection.isVideoMirroringSupported {
+                    connection.isVideoMirrored = (type == "front")
+                }
+            }
+        }
+    }
+
+    // MARK: - Events
+    private func sendFrameEvent(frame: [String: Any]) {
+        onFrameAvailable?(["frame": frame])
+    }
+
+    private func sendReadyEvent(minExposure: Double, maxExposure: Double) {
+        onCameraReady?([
+            "minExposureOffset": minExposure,
+            "maxExposureOffset": maxExposure
+        ])
+    }
+
+    private func sendErrorEvent(error: String) {
+        onCameraError?(["error": error])
+    }
+
+    // MARK: - Cleanup
+    deinit {
+        captureSession?.stopRunning()
+    }
+}
+
+// MARK: - AVCaptureVideoDataOutputSampleBufferDelegate
+extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
+
+    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
+        autoreleasepool {
+            let hasAnyDetection = _frameProcessingEnabled && (enableFaceDetection || enableTextRecognition || enableBarcodeScanning)
+            guard hasAnyDetection else { return }
+            
+            // Check flag on videoQueue (serial) to prevent re-entry
+            guard !isProcessing else { return }
+
+            let currentTime = CACurrentMediaTime()
+            if (currentTime - lastFrameTime) < minFrameInterval {
+                return
+            }
+            lastFrameTime = currentTime
+            
+            // Mark as processing on videoQueue
+            isProcessing = true
+
+            // Dispatch to background queue to unblock videoQueue immediately
+            processingQueue.async { [weak self] in
+                guard let self = self else { return }
+                
+                self.processSampleBuffer(sampleBuffer)
+            }
+        }
+    }
+    
+    private func processSampleBuffer(_ sampleBuffer: CMSampleBuffer) {
+        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            resetProcessingState()
+            return
+        }
+
+        let pixelWidth = CVPixelBufferGetWidth(pixelBuffer)
+        let pixelHeight = CVPixelBufferGetHeight(pixelBuffer)
+        
+        // Report portrait dimensions (width < height)
+        let portraitWidth = min(pixelWidth, pixelHeight)
+        let portraitHeight = max(pixelWidth, pixelHeight)
+
+        CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
+        // Ensure we unlock at the end of function
+        defer {
+            CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
+            resetProcessingState()
+        }
+        
+        let isBufferLandscape = pixelWidth > pixelHeight
+
+        // Log VisionImage metadata to understand coordinate space
+        NSLog("[VisionImage] Buffer: \(pixelWidth)x\(pixelHeight) | Orientation: \(isBufferLandscape ? "landscape→portrait (.right)" : "portrait (.up)") | Will report as: \(portraitWidth)x\(portraitHeight)")
+
+        // Create oriented CIImage for ML Kit processing
+        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
+        let orientedImage = isBufferLandscape ? ciImage.oriented(.right) : ciImage
+
+        // Create VisionImage from the oriented CIImage for better text recognition
+        // This ensures MLKit processes the image in the correct orientation
+        guard let cgImage = self.ciContext.createCGImage(orientedImage, from: orientedImage.extent) else {
+            resetProcessingState()
+            return
+        }
+        let visionImage = VisionImage(image: UIImage(cgImage: cgImage))
+        visionImage.orientation = .up  // Already oriented correctly
+
+        // Generate JPEG base64 only when JS side explicitly needs the image
+        // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
+        var base64Image: String? = nil
+        if includeBase64 {
+            let uiImage = UIImage(cgImage: cgImage)
+            if let data = uiImage.jpegData(compressionQuality: 0.75) {
+                base64Image = data.base64EncodedString()
+            }
+        }
+
+        // Synchronous processing using a semaphore to keep the buffer locked
+        // This blocks processingQueue, which is fine (we are off videoQueue)
+        let semaphore = DispatchSemaphore(value: 0)
+        var facesArray: [[String: Any]] = []
+        var textBlocksArray: [[String: Any]] = []
+        var barcodesArray: [[String: Any]] = []
+
+        if enableFaceDetection {
+            faceDetector.process(visionImage) { faces, error in
+                if let faces = faces {
+                    for face in faces {
+                        var faceMap: [String: Any] = [:]
+                        let isFront = self._cameraType == "front"
+                        let faceX = isFront ? CGFloat(portraitWidth) - face.frame.origin.x - face.frame.width : face.frame.origin.x
+                        
+                        faceMap["bounds"] = [
+                            "x": Int(faceX),
+                            "y": Int(face.frame.origin.y),
+                            "width": Int(face.frame.width),
+                            "height": Int(face.frame.height)
+                        ]
+                        faceMap["yawAngle"] = face.hasHeadEulerAngleY ? Double(face.headEulerAngleY) : 0.0
+                        faceMap["pitchAngle"] = face.hasHeadEulerAngleX ? Double(face.headEulerAngleX) : 0.0
+                        faceMap["rollAngle"] = face.hasHeadEulerAngleZ ? Double(face.headEulerAngleZ) : 0.0
+                        if face.hasTrackingID {
+                            faceMap["trackingId"] = face.trackingID
+                        }
+                        // Only include probability fields when available (matching Android behavior)
+                        if face.hasSmilingProbability {
+                            faceMap["smilingProbability"] = Double(face.smilingProbability)
+                        }
+                        if face.hasLeftEyeOpenProbability {
+                            faceMap["leftEyeOpenProbability"] = Double(face.leftEyeOpenProbability)
+                        }
+                        if face.hasRightEyeOpenProbability {
+                            faceMap["rightEyeOpenProbability"] = Double(face.rightEyeOpenProbability)
+                        }
+                        facesArray.append(faceMap)
+                    }
+                }
+                semaphore.signal()
+            }
+        } else {
+            semaphore.signal()
+        }
+        
+        // Text recognition
+        let textSemaphore = DispatchSemaphore(value: 0)
+        var resultText = ""
+        if enableTextRecognition {
+            textRecognizer.process(visionImage) { text, error in
+                if let text = text {
+                    resultText = text.text
+                    NSLog("[Text Recognition] Found \(text.blocks.count) blocks | Buffer: \(pixelWidth)x\(pixelHeight) | Portrait: \(portraitWidth)x\(portraitHeight) | Landscape: \(isBufferLandscape)")
+                    for block in text.blocks {
+                        var blockMap: [String: Any] = ["text": block.text]
+                        let bb = block.frame
+                        
+                        // When buffer is landscape (1920x1080) but we set orientation to .right,
+                        // ML Kit might still return coordinates in landscape space.
+                        // We need to rotate them to portrait space (1080x1920) to match face detection.
+                        let blockX: Int
+                        let blockY: Int
+                        let blockWidth: Int
+                        let blockHeight: Int
+                        
+                        if isBufferLandscape {
+                            // Rotate from landscape (1920x1080) to portrait (1080x1920)
+                            // When rotating 90° clockwise (.right):
+                            // new_x = old_y
+                            // new_y = landscape_width - old_x - width
+                            // new_width = old_height
+                            // new_height = old_width
+                            blockX = Int(bb.origin.y)
+                            blockY = pixelWidth - Int(bb.origin.x) - Int(bb.width)
+                            blockWidth = Int(bb.height)
+                            blockHeight = Int(bb.width)
+                            NSLog("[Text Block] '\(block.text.prefix(8))...' | ROTATED: landscape(\(Int(bb.origin.x)),\(Int(bb.origin.y)),\(Int(bb.width)),\(Int(bb.height))) → portrait(x:\(blockX) y:\(blockY) w:\(blockWidth) h:\(blockHeight))")
+                        } else {
+                            // Already portrait, use directly
+                            blockX = Int(bb.origin.x)
+                            blockY = Int(bb.origin.y)
+                            blockWidth = Int(bb.width)
+                            blockHeight = Int(bb.height)
+                            NSLog("[Text Block] '\(block.text.prefix(8))...' | DIRECT: x:\(blockX) y:\(blockY) w:\(blockWidth) h:\(blockHeight)")
+                        }
+                        
+                        blockMap["blockFrame"] = [
+                            "x": blockX,
+                            "y": blockY,
+                            "width": blockWidth,
+                            "height": blockHeight,
+                            "boundingCenterX": blockX + blockWidth / 2,
+                            "boundingCenterY": blockY + blockHeight / 2
+                        ]
+                        textBlocksArray.append(blockMap)
+                    }
+                }
+                textSemaphore.signal()
+            }
+        } else {
+            textSemaphore.signal()
+        }
+        
+        // Barcode scanning - use native AVFoundation results (captured via metadata delegate)
+        // This is much faster than MLKit barcode scanning
+        let barcodeSemaphore = DispatchSemaphore(value: 0)
+        if enableBarcodeScanning {
+            // Use the barcodes detected by the native AVCaptureMetadataOutput
+            barcodesArray = lastDetectedBarcodes
+            barcodeSemaphore.signal()
+        } else {
+            barcodeSemaphore.signal()
+        }
+
+        // Wait for vision tasks (with timeout to prevent hang)
+        _ = semaphore.wait(timeout: .now() + 2.0)
+        _ = textSemaphore.wait(timeout: .now() + 2.0)
+
+        // MRZ validation (if enabled and text was recognized)
+        var mrzResultDict: [String: Any]? = nil
+        if enableMrzValidation && enableTextRecognition && !resultText.isEmpty {
+            let mrzResult = MRZValidator().validateWithCorrections(resultText)
+            mrzResultDict = mrzResult.toDictionary()
+        }
+
+        // Only compute brightness if we haven't timed out or crashed
+        // Brightness calculation restricted to scanning frame area (between 36% from top and 36% from bottom, 5% margins on sides)
+        let brightness = computeBrightness(from: pixelBuffer, width: portraitWidth, height: portraitHeight)
+
+        let currentTime = CACurrentMediaTime() * 1000 // Convert to milliseconds to match Android
+
+        var frameData: [String: Any] = [
+            "width": portraitWidth,
+            "height": portraitHeight,
+            "orientation": 0, // Already corrected to portrait
+            "timestamp": currentTime,
+            "faces": facesArray,
+            "brightness": brightness
+        ]
+
+        if let base64 = base64Image {
+            frameData["base64Image"] = base64
+        }
+        
+        // Only include text/barcode data if recognition is enabled
+        if enableTextRecognition {
+            frameData["resultText"] = resultText
+            frameData["textBlocks"] = textBlocksArray
+        }
+        if enableBarcodeScanning {
+            frameData["barcodes"] = barcodesArray
+        }
+        if let mrzDict = mrzResultDict {
+            frameData["mrzResult"] = mrzDict
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            self?.onFrameAvailable?(["frame": frameData])
+        }
+    }
+    
+    private func resetProcessingState() {
+        videoQueue.async { [weak self] in
+            self?.isProcessing = false
+        }
+    }
+
+    private func computeBrightness(from pixelBuffer: CVPixelBuffer, width: Int, height: Int) -> Double {
+        guard let yPlane = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0) else { return 128.0 }
+        let pixelWidth = CVPixelBufferGetWidthOfPlane(pixelBuffer, 0)
+        let pixelHeight = CVPixelBufferGetHeightOfPlane(pixelBuffer, 0)
+        let yBytesPerRow = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0)
+        
+        // Define scanning frame area (from IdentityDocumentCamera.tsx styles)
+        // top: 36%, left: 5%, right: 5%, bottom: 36%
+        let scanTopPercent = 0.36
+        let scanBottomPercent = 0.36
+        let scanLeftPercent = 0.05
+        let scanRightPercent = 0.05
+        
+        // Convert percentages to pixel coordinates in the portrait frame
+        let scanTop = Int(Double(height) * scanTopPercent)
+        let scanBottom = Int(Double(height) * (1.0 - scanBottomPercent))
+        let scanLeft = Int(Double(width) * scanLeftPercent)
+        let scanRight = Int(Double(width) * (1.0 - scanRightPercent))
+        
+        // Map from portrait coordinates to pixel buffer coordinates
+        // The pixel buffer is in landscape, so we need to rotate the coordinates
+        // Portrait frame (1080x1920) -> Landscape buffer (1920x1080)
+        // When rotating, the mapping is:
+        // buffer_x = height - portrait_y
+        // buffer_y = portrait_x
+        
+        let bufferScanTop = scanLeft  // portrait_x -> buffer_y
+        let bufferScanBottom = scanRight  // portrait_x -> buffer_y
+        let bufferScanLeft = height - scanBottom  // height - portrait_y -> buffer_x
+        let bufferScanRight = height - scanTop  // height - portrait_y -> buffer_x
+        
+        let ptr = yPlane.assumingMemoryBound(to: UInt8.self)
+        var sum: UInt64 = 0
+        let sampleCount = 100 // Sample 100 points within scanning frame
+        
+        for i in 0..<sampleCount {
+            // Sample evenly within the scanning frame bounds
+            let relativeX = (i * 17) % sampleCount
+            let relativeY = (i * 23) % sampleCount
+            
+            let x = bufferScanLeft + (relativeX * (bufferScanRight - bufferScanLeft)) / max(1, sampleCount - 1)
+            let y = bufferScanTop + (relativeY * (bufferScanBottom - bufferScanTop)) / max(1, sampleCount - 1)
+            
+            // Clamp to buffer bounds
+            let clampedX = min(max(0, x), pixelWidth - 1)
+            let clampedY = min(max(0, y), pixelHeight - 1)
+            
+            sum += UInt64(ptr[clampedY * yBytesPerRow + clampedX])
+        }
+        
+        return Double(sum) / Double(sampleCount)
+    }
+}
+
+// MARK: - AVCaptureFileOutputRecordingDelegate
+extension TrustchexCameraView: AVCaptureFileOutputRecordingDelegate {
+    func fileOutput(_ output: AVCaptureFileOutput, didStartRecordingTo fileURL: URL, from connections: [AVCaptureConnection]) {
+        // Recording started successfully
+    }
+
+    func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {
+
+        // Cancel fallback since delegate fired
+        finishFallbackWorkItem?.cancel()
+        finishFallbackWorkItem = nil
+        finishFallbackAttempts = 0
+
+        // Check if this was a cancelled recording
+        let wasCancelled = isCancelledRecording
+        
+        // Reset recording state
+        isRecording = false
+        isCancelledRecording = false
+        currentRecordingURL = nil
+
+        // If recording was cancelled, clean up the temp file and don't send any callback
+        if wasCancelled {
+            print("[TrustchexCameraView] *** Recording was cancelled, cleaning up temp file ***")
+            try? FileManager.default.removeItem(at: outputFileURL)
+            return
+        }
+
+        // Check if recording succeeded
+        var recordingSucceeded = (error == nil)
+        if let error = error as NSError? {
+            let successfullyFinished = (error.userInfo[AVErrorRecordingSuccessfullyFinishedKey as String] as? Bool) == true
+            if successfullyFinished {
+                recordingSucceeded = true
+            }
+        }
+
+        // Fire callback
+        if recordingSucceeded {
+            DispatchQueue.main.async { [weak self] in
+                self?.onRecordingFinished?(["path": outputFileURL.path])
+            }
+        } else {
+            DispatchQueue.main.async { [weak self] in
+                self?.onRecordingError?(["error": error?.localizedDescription ?? "Unknown recording error"])
+            }
+        }
+    }
+}
+
+// MARK: - AVCaptureMetadataOutputObjectsDelegate (Native Barcode Scanner)
+extension TrustchexCameraView: AVCaptureMetadataOutputObjectsDelegate {
+    func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
+        guard enableBarcodeScanning else {
+            lastDetectedBarcodes = []
+            return
+        }
+
+        var barcodes: [[String: Any]] = []
+
+        // Get the current capture session preset to determine frame dimensions
+        let frameWidth: Int
+        let frameHeight: Int
+        if let preset = captureSession?.sessionPreset {
+            switch preset {
+            case .hd1920x1080:
+                frameWidth = 1080  // Portrait mode
+                frameHeight = 1920
+            case .hd1280x720:
+                frameWidth = 720   // Portrait mode
+                frameHeight = 1280
+            default:
+                frameWidth = 1080
+                frameHeight = 1920
+            }
+        } else {
+            frameWidth = 1080
+            frameHeight = 1920
+        }
+
+        for metadata in metadataObjects {
+            guard let barcodeObject = metadata as? AVMetadataMachineReadableCodeObject,
+                  let stringValue = barcodeObject.stringValue else {
+                continue
+            }
+
+            // Map AVMetadataObject type to format number (matching MLKit format numbers)
+            let format: Int
+            let formatName: String
+            switch barcodeObject.type {
+            case .pdf417:
+                format = 2048  // BarcodeFormat.PDF417
+                formatName = "PDF417"
+            case .qr:
+                format = 256   // BarcodeFormat.qrCode
+                formatName = "QR_CODE"
+            case .code128:
+                format = 128   // BarcodeFormat.code128
+                formatName = "CODE_128"
+            case .code39:
+                format = 16    // BarcodeFormat.code39
+                formatName = "CODE_39"
+            case .ean13:
+                format = 32    // BarcodeFormat.EAN13
+                formatName = "EAN_13"
+            case .ean8:
+                format = 64    // BarcodeFormat.EAN8
+                formatName = "EAN_8"
+            case .aztec:
+                format = 4096  // BarcodeFormat.aztec
+                formatName = "AZTEC"
+            case .dataMatrix:
+                format = 512   // BarcodeFormat.dataMatrix
+                formatName = "DATA_MATRIX"
+            default:
+                format = 0
+                formatName = "UNKNOWN"
+            }
+
+            let valuePreview = String(stringValue.prefix(50))
+            NSLog("[Native Barcode] ✓ FAST DETECTION: \(formatName) - \(valuePreview)")
+
+            var barcodeMap: [String: Any] = [
+                "rawValue": stringValue,
+                "displayValue": stringValue,
+                "format": format
+            ]
+
+            // CRITICAL: AVFoundation metadata coordinates are in a LANDSCAPE-RIGHT coordinate system
+            // even when video orientation is portrait. This is because the sensor data is landscape.
+            // For portrait video (1080x1920), metadata bounds are in (0-1) range where:
+            //   - X axis goes LEFT TO RIGHT (corresponds to portrait Y axis, top to bottom)
+            //   - Y axis goes TOP TO BOTTOM (corresponds to portrait X axis, left to right)
+            // We need to rotate these coordinates 90° counter-clockwise to get portrait coordinates
+
+            let bounds = barcodeObject.bounds
+
+            // Transform from landscape-right (metadata) to portrait (video frame) coordinates
+            // Landscape-right to Portrait transformation:
+            //   portrait_x = (1 - landscape_y) * frameWidth
+            //   portrait_y = landscape_x * frameHeight
+            //   portrait_width = landscape_height * frameWidth
+            //   portrait_height = landscape_width * frameHeight
+
+            let portraitLeft = Int((1.0 - bounds.maxY) * CGFloat(frameWidth))
+            let portraitTop = Int(bounds.minX * CGFloat(frameHeight))
+            let portraitRight = Int((1.0 - bounds.minY) * CGFloat(frameWidth))
+            let portraitBottom = Int(bounds.maxX * CGFloat(frameHeight))
+
+            NSLog("[Native Barcode] Normalized bounds: (%.3f, %.3f) to (%.3f, %.3f)", bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
+            NSLog("[Native Barcode] Frame: \(frameWidth)x\(frameHeight), Portrait coords: (\(portraitLeft), \(portraitTop)) to (\(portraitRight), \(portraitBottom))")
+
+            barcodeMap["boundingBox"] = [
+                "left": portraitLeft,
+                "top": portraitTop,
+                "right": portraitRight,
+                "bottom": portraitBottom
+            ]
+
+            barcodeMap["cornerPoints"] = barcodeObject.corners.map { point in
+                // Transform each corner point from landscape-right to portrait
+                let portraitX = Int((1.0 - point.y) * CGFloat(frameWidth))
+                let portraitY = Int(point.x * CGFloat(frameHeight))
+                return ["x": portraitX, "y": portraitY]
+            }
+
+            barcodes.append(barcodeMap)
+        }
+
+        lastDetectedBarcodes = barcodes
+    }
+}
+
+// MARK: - Helper Extensions
+extension Comparable {
+    func clamped(to limits: ClosedRange<Self>) -> Self {
+        return min(max(self, limits.lowerBound), limits.upperBound)
+    }
+}