@trustchex/react-native-sdk 1.464.0 → 1.475.0

package/ios/Camera/TrustchexCameraView.swift

@@ -115,7 +115,24 @@ class TrustchexCameraView: UIView {
         }
     }
 
+    private func configureAudioSession() {
+        do {
+            let audioSession = AVAudioSession.sharedInstance()
+            // Set category to playAndRecord so we can record audio during video
+            try audioSession.setCategory(
+                .playAndRecord,
+                options: [.defaultToSpeaker, .duckOthers]
+            )
+            try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
+        } catch {
+            // Audio session configuration failed - recording may not have audio
+        }
+    }
+
     private func configureCaptureSession() {
+        // Configure audio session for recording with microphone
+        configureAudioSession()
+        
         let session = AVCaptureSession()
         session.beginConfiguration()
 
@@ -178,11 +195,16 @@ class TrustchexCameraView: UIView {
         let movieOutput = AVCaptureMovieFileOutput()
         if session.canAddOutput(movieOutput) {
             session.addOutput(movieOutput)
+            // Configure video connection
             if let connection = movieOutput.connection(with: .video) {
                 if connection.isVideoOrientationSupported {
                     connection.videoOrientation = .portrait
                 }
             }
+            // Configure audio connection for recording
+            if let audioConnection = movieOutput.connection(with: .audio) {
+                audioConnection.isEnabled = true
+            }
         }
         self.movieFileOutput = movieOutput
 
@@ -235,36 +257,85 @@ class TrustchexCameraView: UIView {
     }
 
     // MARK: - Camera Selection
+
+    /// Selects the best camera for the requested position using the same strategy
+    /// as the Android side:
+    ///   • Front (face detection / verbal consent): pick the device with the widest
+    ///     field of view by measuring `videoFieldOfView` across all available front
+    ///     cameras — mirrors Android's focal-length comparison via Camera2.
+    ///   • Back (document / EID / barcode scanning): wide-angle camera gives the
+    ///     least barrel distortion and best optical sharpness; ultra-wide is avoided
+    ///     intentionally because its distortion degrades OCR/MRZ accuracy.
     private func selectBestCamera(for position: AVCaptureDevice.Position) -> AVCaptureDevice? {
         if position == .front {
-            // Prefer the widest front camera available for better face framing
-            let discovery = AVCaptureDevice.DiscoverySession(
-                deviceTypes: [.builtInUltraWideCamera, .builtInWideAngleCamera],
-                mediaType: .video,
-                position: .front
-            )
-            // DiscoverySession lists in the order of deviceTypes, so ultra-wide comes first if available
-            return discovery.devices.first
-                ?? AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
+            return selectWidestFrontCamera()
+        }
+        return selectBestBackCamera()
+    }
+
+    /// Enumerates every front-facing camera the device exposes and returns the one
+    /// with the highest reported field-of-view, matching Android's
+    /// `selectWidestFrontCamera()` which picks the shortest focal length.
+    private func selectWidestFrontCamera() -> AVCaptureDevice? {
+        let discovery = AVCaptureDevice.DiscoverySession(
+            deviceTypes: [
+                .builtInUltraWideCamera,
+                .builtInTrueDepthCamera,
+                .builtInWideAngleCamera,
+            ],
+            mediaType: .video,
+            position: .front
+        )
+
+        let devices = discovery.devices
+        guard !devices.isEmpty else {
+            return AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
         }
 
-        // For document scanning, prefer wide angle camera for all models
-        // This provides consistent behavior across iPhone 15, 15 Pro, and other devices
-        if let wideAngleCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) {
-            return wideAngleCamera
+        // Single device — no comparison needed.
+        if devices.count == 1 { return devices.first }
+
+        // Multiple front cameras: measure the maximum videoFieldOfView each device
+        // supports across all its formats and return the highest (widest) one.
+        var bestDevice: AVCaptureDevice? = nil
+        var widestFoV: Float = 0
+
+        for device in devices {
+            let maxFoV = device.formats
+                .map { $0.videoFieldOfView }
+                .max() ?? 0
+            if maxFoV > widestFoV {
+                widestFoV = maxFoV
+                bestDevice = device
+            }
         }
 
-        // Fallback: Try dual camera
-        if let dualCamera = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
-            return dualCamera
+        return bestDevice
+            ?? AVCaptureDevice.default(.builtInTrueDepthCamera, for: .video, position: .front)
+            ?? AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front)
+    }
+
+    /// Returns the best back-facing camera for document scanning scenarios.
+    /// Wide-angle is preferred over ultra-wide because it has negligible barrel
+    /// distortion — critical for OCR/MRZ accuracy. This matches Android which
+    /// resolves to DEFAULT_BACK_CAMERA (the main wide-angle lens).
+    private func selectBestBackCamera() -> AVCaptureDevice? {
+        // Primary: main wide-angle lens — best for document/EID/barcode scanning.
+        if let cam = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) {
+            return cam
         }
 
-        // Fallback: Try triple camera
-        if let tripleCamera = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
-            return tripleCamera
+        // Fallback: dual-camera system (manages wide + telephoto; exposes wide by default).
+        if let cam = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
+            return cam
         }
 
-        // Final fallback: any back camera
+        // Fallback: triple-camera system.
+        if let cam = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
+            return cam
+        }
+
+        // Final fallback: any available camera.
         return AVCaptureDevice.default(for: .video)
     }
 
@@ -304,6 +375,12 @@ class TrustchexCameraView: UIView {
                 } else if camera.isFocusModeSupported(.autoFocus) {
                     camera.focusMode = .autoFocus
                 }
+
+                // Use the widest front-camera framing available on the device.
+                let widestZoom = camera.minAvailableVideoZoomFactor
+                if camera.videoZoomFactor != widestZoom {
+                    camera.videoZoomFactor = widestZoom
+                }
             } else {
                 // Back camera: Optimized focus for document scanning across all models
                 if camera.isFocusModeSupported(.continuousAutoFocus) {
@@ -476,6 +553,22 @@ class TrustchexCameraView: UIView {
             guard let session = self.captureSession, session.isRunning else { return }
             guard let movieOutput = self.movieFileOutput else { return }
 
+            // Ensure recording session is configured for video + microphone capture.
+            do {
+                let audioSession = AVAudioSession.sharedInstance()
+                try audioSession.setCategory(
+                    .playAndRecord,
+                    mode: .videoRecording,
+                    options: [.defaultToSpeaker, .allowBluetooth, .allowBluetoothA2DP]
+                )
+                try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
+            } catch {
+                DispatchQueue.main.async { [weak self] in
+                    self?.onRecordingError?(["error": "Failed to activate audio session for recording"]) 
+                }
+                return
+            }
+
             // Check actual AVFoundation recording state
             if movieOutput.isRecording {
                 movieOutput.stopRecording()
@@ -495,12 +588,26 @@ class TrustchexCameraView: UIView {
                 return
             }
 
-            // Verify video connection exists
-            guard movieOutput.connection(with: .video) != nil else { return }
+            // Verify both video and audio connections exist before recording
+            guard movieOutput.connection(with: .video) != nil else {
+                DispatchQueue.main.async { [weak self] in
+                    self?.onRecordingError?(["error": "Video connection not available"])
+                }
+                return
+            }
+
+            // Audio connection is required for verbal consent recordings.
+            guard let audioConnection = movieOutput.connection(with: .audio) else {
+                DispatchQueue.main.async { [weak self] in
+                    self?.onRecordingError?(["error": "Microphone audio connection not available"]) 
+                }
+                return
+            }
+            audioConnection.isEnabled = true
 
             // Create temporary file URL
             let tempDir = NSTemporaryDirectory()
-            let fileName = "recording_\(Date().timeIntervalSince1970).mp4"
+            let fileName = "recording_\(Date().timeIntervalSince1970).mov"
             let fileURL = URL(fileURLWithPath: tempDir).appendingPathComponent(fileName)
 
             // Remove existing file if any
@@ -655,10 +762,18 @@ class TrustchexCameraView: UIView {
 
         // Update mirroring on preview layer
         DispatchQueue.main.async { [weak self] in
-            if let connection = self?.previewLayer?.connection {
-                if connection.isVideoMirroringSupported {
-                    connection.isVideoMirrored = (type == "front")
-                }
+            guard let connection = self?.previewLayer?.connection else { return }
+            guard connection.isVideoMirroringSupported else { return }
+
+            // Avoid AVFoundation exception when setting explicit mirroring while
+            // automatic mirroring is still enabled on the connection.
+            if connection.automaticallyAdjustsVideoMirroring {
+                connection.automaticallyAdjustsVideoMirroring = false
+            }
+
+            let shouldMirror = (type == "front")
+            if connection.isVideoMirrored != shouldMirror {
+                connection.isVideoMirrored = shouldMirror
             }
         }
     }
@@ -749,28 +864,30 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         // Compute brightness early for OCR-B enhancement decision
         let brightness = computeBrightness(from: pixelBuffer, width: portraitWidth, height: portraitHeight)
 
-        // For text recognition, use original image directly
-        // ML Kit works best with native camera frames
-        let textEnhancedImage = orientedImage
-
-        // Create VisionImage from the image (enhanced or original) for better text recognition
-        // This ensures MLKit processes the image in the correct orientation
-        guard let cgImage = self.ciContext.createCGImage(textEnhancedImage, from: textEnhancedImage.extent) else {
+        // Face detection / base64 use the full portrait frame.
+        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
-        
-        // Use image for text recognition
-        // ML Kit text recognition best practices (iOS):
-        // - Requires minimum 16x16 pixels per character (ideal 16-24px per character)
-        // - Input image: 1080x1920 (portrait Full HD) provides excellent accuracy at real-time speed
-        // - Each character at ~30px = 36 characters per line @ 1080px width
-        // - Use synchronous results(in:) API from captureOutput(_:didOutput:from:)
-        // - Set AVCaptureVideoDataOutput.alwaysDiscardsLateVideoFrames = true (throttle)
-        // - Get results then render overlay in single step for optimal performance
-        let textVisionImage = visionImage
+
+        // Text recognition: process ONLY the data inside the on-screen scan frame
+        // (matching Android). We crop the portrait frame to the scan-frame ROI
+        // (top 25% / bottom 12% / 4% side margins), UPSCALE it, and grayscale +
+        // contrast-enhance before OCR. This removes front-of-card text and glare
+        // noise and lifts a dense MRZ line above ML Kit's ~16px/char floor.
+        // `mrzRoi` carries the transform back to full portrait-frame coordinates.
+        let mrzRoi = enableTextRecognition
+            ? buildScanFrameRoiImage(orientedImage, portraitWidth: portraitWidth, portraitHeight: portraitHeight)
+            : nil
+        var textVisionImage = visionImage
+        if let roi = mrzRoi,
+           let roiCg = self.ciContext.createCGImage(roi.image, from: roi.image.extent) {
+            let img = VisionImage(image: UIImage(cgImage: roiCg))
+            img.orientation = .up
+            textVisionImage = img
+        }
 
         // Generate JPEG base64 only when JS side explicitly needs the image
         // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
@@ -846,8 +963,16 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
                     let blockY: Int
                     let blockWidth: Int
                     let blockHeight: Int
-                    
-                    if isBufferLandscape {
+
+                    if let roi = mrzRoi {
+                        // OCR ran on the upscaled, already-portrait scan-frame ROI.
+                        // Map the box back to full portrait-frame coordinates:
+                        // divide out the ROI upscale, then add the ROI origin.
+                        blockX = Int(bb.origin.x / roi.scale) + roi.offsetX
+                        blockY = Int(bb.origin.y / roi.scale) + roi.offsetY
+                        blockWidth = Int(bb.width / roi.scale)
+                        blockHeight = Int(bb.height / roi.scale)
+                    } else if isBufferLandscape {
                         // Rotate from landscape (1920x1080) to portrait (1080x1920)
                         // When rotating 90° clockwise (.right):
                         // new_x = old_y
@@ -926,6 +1051,69 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         }
     }
 
+    /// A scan-frame ROI prepared for OCR, with the transform back to full-frame coords.
+    private struct ScanFrameRoi {
+        let image: CIImage
+        let offsetX: Int
+        let offsetY: Int
+        let scale: CGFloat
+    }
+
+    /// Crops the portrait frame to the on-screen scan frame (top 25% / bottom 12%
+    /// / 4% side margins — the same rectangle the UI guide draws), UPSCALES it so a
+    /// dense MRZ line clears ML Kit's ~16px/char floor, and grayscale + contrast
+    /// enhances it (the MRZ is dark OCR-B on a light background, so this makes
+    /// glyphs pop and suppresses the "<" filler being misread as a letter under
+    /// glare). Returns nil on failure so the caller falls back to full-frame OCR.
+    /// Mirrors the Android `buildScanFrameRoiImage`.
+    private func buildScanFrameRoiImage(_ portrait: CIImage, portraitWidth: Int, portraitHeight: Int) -> ScanFrameRoi? {
+        let w = portrait.extent.width
+        let h = portrait.extent.height
+        if w < 8 || h < 8 { return nil }
+
+        // Scan-frame rectangle. CIImage origin is BOTTOM-left, so "top 25%" maps to
+        // a y measured from the bottom: cropY = h*0.12 (bottom margin), height =
+        // h*(1 - 0.25 - 0.12).
+        let leftPct: CGFloat = 0.04
+        let rightPct: CGFloat = 0.04
+        let topPct: CGFloat = 0.25
+        let bottomPct: CGFloat = 0.12
+        let cropX = (w * leftPct).rounded()
+        let cropW = (w * (1 - leftPct - rightPct)).rounded()
+        let cropY = (h * bottomPct).rounded()
+        let cropH = (h * (1 - topPct - bottomPct)).rounded()
+        if cropW < 8 || cropH < 8 { return nil }
+
+        let cropRect = CGRect(x: portrait.extent.origin.x + cropX,
+                              y: portrait.extent.origin.y + cropY,
+                              width: cropW, height: cropH)
+        var img = portrait.cropped(to: cropRect)
+        // Move the crop origin to (0,0) so downstream extents are simple.
+        img = img.transformed(by: CGAffineTransform(translationX: -cropRect.origin.x, y: -cropRect.origin.y))
+
+        // Upscale (≤2.5×, long edge capped at 2200) for more pixels per character.
+        let longEdge = max(cropW, cropH)
+        let rawScale = longEdge > 0 ? (2200.0 / longEdge) : 1.0
+        let scale = min(max(rawScale, 1.0), 2.5)
+        if scale != 1.0 {
+            img = img.transformed(by: CGAffineTransform(scaleX: scale, y: scale))
+        }
+
+        // Grayscale (saturation 0) + contrast boost.
+        img = img.applyingFilter("CIColorControls", parameters: [
+            kCIInputSaturationKey: 0.0,
+            kCIInputContrastKey: 1.6
+        ])
+
+        // The crop is taken from the TOP of the portrait frame (UIKit coords), but
+        // CIImage y is bottom-up. The block coords ML Kit returns are top-left in
+        // the OCR image, so the offset back to the portrait frame is the UIKit top
+        // edge (= portraitHeight * topPct) and left edge.
+        let offsetX = Int(cropX)
+        let offsetY = Int((CGFloat(portraitHeight) * topPct).rounded())
+        return ScanFrameRoi(image: img, offsetX: offsetX, offsetY: offsetY, scale: scale)
+    }
+
     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)
@@ -1047,6 +1235,16 @@ extension TrustchexCameraView: AVCaptureFileOutputRecordingDelegate {
 
         // Fire callback
         if recordingSucceeded {
+            let asset = AVURLAsset(url: outputFileURL)
+            let hasAudioTrack = !asset.tracks(withMediaType: .audio).isEmpty
+
+            if !hasAudioTrack {
+                DispatchQueue.main.async { [weak self] in
+                    self?.onRecordingError?(["error": "Recorded video has no audio track"]) 
+                }
+                return
+            }
+
             DispatchQueue.main.async { [weak self] in
                 self?.onRecordingFinished?(["path": outputFileURL.path])
             }

package/ios/Permission/PermissionModule.m

@@ -0,0 +1,22 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(PermissionModule, NSObject)
+
+RCT_EXTERN_METHOD(requestCameraPermission:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(requestMicrophonePermission:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(checkCameraPermission:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(checkMicrophonePermission:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/Permission/PermissionModule.swift

@@ -0,0 +1,67 @@
+import React
+import AVFoundation
+
+@objc(PermissionModule)
+class PermissionModule: NSObject {
+  
+  @objc(requestCameraPermission:withRejecter:)
+  func requestCameraPermission(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      let status = AVCaptureDevice.authorizationStatus(for: .video)
+      
+      switch status {
+      case .authorized:
+        resolve(true)
+      case .denied, .restricted:
+        resolve(false)
+      case .notDetermined:
+        AVCaptureDevice.requestAccess(for: .video) { granted in
+          resolve(granted)
+        }
+      @unknown default:
+        resolve(false)
+      }
+    }
+  }
+  
+  @objc(requestMicrophonePermission:withRejecter:)
+  func requestMicrophonePermission(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      let status = AVAudioSession.sharedInstance().recordPermission
+      
+      switch status {
+      case .granted:
+        resolve(true)
+      case .denied:
+        resolve(false)
+      case .undetermined:
+        AVAudioSession.sharedInstance().requestRecordPermission { granted in
+          resolve(granted)
+        }
+      @unknown default:
+        resolve(false)
+      }
+    }
+  }
+  
+  @objc(checkCameraPermission:withRejecter:)
+  func checkCameraPermission(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      let status = AVCaptureDevice.authorizationStatus(for: .video)
+      resolve(status == .authorized)
+    }
+  }
+  
+  @objc(checkMicrophonePermission:withRejecter:)
+  func checkMicrophonePermission(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      let status = AVAudioSession.sharedInstance().recordPermission
+      resolve(status == .granted)
+    }
+  }
+  
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+}