@trustchex/react-native-sdk 1.464.0 → 1.472.0

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -1,10 +1,13 @@
 package com.trustchex.reactnativesdk.camera
 
 import android.annotation.SuppressLint
+import android.Manifest
+import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.ImageFormat
 import android.graphics.Matrix
+import android.media.MediaMetadataRetriever
 import android.graphics.Rect
 import android.graphics.YuvImage
 import android.util.Base64
@@ -14,6 +17,8 @@ import android.util.Size
 import android.widget.FrameLayout
 import androidx.annotation.OptIn
 import androidx.camera.core.*
+import androidx.camera.core.resolutionselector.ResolutionSelector
+import androidx.camera.core.resolutionselector.ResolutionStrategy
 import androidx.camera.lifecycle.ProcessCameraProvider
 import androidx.camera.video.*
 import androidx.camera.view.PreviewView
@@ -303,10 +308,18 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                 "hd" -> Size(720, 1280)     // Portrait HD
                 else -> Size(1080, 1920)    // Portrait Full HD (default)
             }
+            val resolutionSelector = ResolutionSelector.Builder()
+                .setResolutionStrategy(
+                    ResolutionStrategy(
+                        targetResolution,
+                        ResolutionStrategy.FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER
+                    )
+                )
+                .build()
 
             // Preview use case
             preview = Preview.Builder()
-                .setTargetResolution(targetResolution)
+                .setResolutionSelector(resolutionSelector)
                 .setTargetRotation(android.view.Surface.ROTATION_0) // Portrait
                 .build()
                 .also {
@@ -315,7 +328,7 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
 
             // Image analysis use case
             imageAnalyzer = ImageAnalysis.Builder()
-                .setTargetResolution(targetResolution)
+                .setResolutionSelector(resolutionSelector)
                 .setTargetRotation(android.view.Surface.ROTATION_0) // Portrait
                 .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                 .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
@@ -777,6 +790,16 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             return
         }
 
+        val hasMicPermission = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+
+        if (!hasMicPermission) {
+            sendRecordingErrorEvent("Microphone permission is required for verbal consent recording")
+            return
+        }
+
         val videoCapture = videoCapture ?: run {
             sendRecordingErrorEvent("VideoCapture not initialized")
             return
@@ -813,7 +836,24 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                                 sendRecordingErrorEvent("Recording error: ${event.cause?.message}")
                             } else {
                                 val filePath = videoFile.absolutePath
-                                sendRecordingFinishedEvent(filePath)
+                                val hasAudioTrack = try {
+                                    val retriever = MediaMetadataRetriever()
+                                    retriever.setDataSource(filePath)
+                                    val hasAudio = retriever
+                                        .extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO)
+                                    retriever.release()
+                                    hasAudio == "yes"
+                                } catch (_: Exception) {
+                                    false
+                                }
+
+                                if (!hasAudioTrack) {
+                                    videoFile.delete()
+                                    currentRecordingFile = null
+                                    sendRecordingErrorEvent("Recorded video has no audio track")
+                                } else {
+                                    sendRecordingFinishedEvent(filePath)
+                                }
                             }
                         }
                         else -> {}

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)
+        }
+
+        // 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
+            }
         }
 
-        // 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
+        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 dual camera
-        if let dualCamera = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
-            return dualCamera
+        // Fallback: dual-camera system (manages wide + telephoto; exposes wide by default).
+        if let cam = AVCaptureDevice.default(.builtInDualCamera, for: .video, position: .back) {
+            return cam
         }
 
-        // Fallback: Try triple camera
-        if let tripleCamera = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
-            return tripleCamera
+        // Fallback: triple-camera system.
+        if let cam = AVCaptureDevice.default(.builtInTripleCamera, for: .video, position: .back) {
+            return cam
         }
 
-        // Final fallback: any back camera
+        // 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
             }
         }
     }
@@ -1047,6 +1162,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
+  }
+}

package/lib/module/Screens/Dynamic/LivenessDetectionScreen.js

@@ -117,7 +117,6 @@ const LivenessDetectionScreen = () => {
       instruction: t('livenessDetectionScreen.finish')
     }
   });
-  const [instructionList, setInstructionList] = useState([]);
   const [hasGuideShown, setHasGuideShown] = useState(false);
   const stoppingRecordingRef = useRef(false); // Track if we're already stopping to prevent multiple calls
 
@@ -143,7 +142,6 @@ const LivenessDetectionScreen = () => {
     instruction === 'LOOK_STRAIGHT_AND_BLINK' || !appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.length === 0 || appContext.currentWorkflowStep?.data?.allowedLivenessInstructionTypes.includes(instruction))).sort(() => Math.random() - 0.5);
     il.unshift('START');
     il.push('FINISH');
-    setInstructionList(il);
     setInitialState({
       brightnessLow: false,
       faceDetected: false,
@@ -440,7 +438,30 @@ const LivenessDetectionScreen = () => {
     const circleR = previewSizeInFrame / 2;
     const faceDx = faceCenterX - circleCX;
     const faceDy = faceCenterY - circleCY;
-    const previewContainsFace = faceDx * faceDx + faceDy * faceDy <= (circleR - faceCoreRadius) * (circleR - faceCoreRadius);
+    const yawAbs = Math.abs(face.yawAngle || 0);
+    const yawFactor = Math.min(1, yawAbs / TURN_ANGLE_LIMIT);
+
+    // General bound tolerance (instruction-agnostic): adapt to head pose and
+    // face box deformation so containment remains stable across all actions.
+    const faceWidthGrowth = Math.max(0, face.bounds.width - face.bounds.height);
+
+    // On iOS, close faces tend to appear larger in-frame and lateral head
+    // turns shift center more aggressively. Apply an iOS-only proximity boost
+    // to horizontal tolerance to avoid false outside-circle resets.
+    const faceRadiusRatio = Math.min(1, faceCoreRadius / Math.max(1, circleR));
+    const iosProximityBoost = Platform.OS === 'ios' ? Math.max(0, faceRadiusRatio - 0.5) : 0;
+    const baseToleranceX = previewSizeInFrame * 0.05;
+    const yawToleranceX = face.bounds.width * 0.12 * yawFactor;
+    const shapeToleranceX = faceWidthGrowth * 0.1;
+    const iosToleranceX = face.bounds.width * 0.2 * iosProximityBoost;
+    const toleranceX = Math.max(0, baseToleranceX + yawToleranceX + shapeToleranceX + iosToleranceX, face.bounds.width * 0.05);
+    const pitchAbs = Math.abs(face.pitchAngle || 0);
+    const pitchFactor = Math.min(1, pitchAbs / TURN_ANGLE_LIMIT);
+    const toleranceY = Math.max(0, previewSizeInFrame * 0.03 + face.bounds.height * 0.03 * pitchFactor, face.bounds.height * 0.04);
+    const allowedRadiusX = Math.max(1, circleR - faceCoreRadius + toleranceX);
+    const allowedRadiusY = Math.max(1, circleR - faceCoreRadius + toleranceY);
+    const normalizedDistance = faceDx * faceDx / (allowedRadiusX * allowedRadiusX) + faceDy * faceDy / (allowedRadiusY * allowedRadiusY);
+    const previewContainsFace = normalizedDistance <= 1;
     const multipleFacesDetected = faces.length > 1;
     if (!isImageBright) {
       // Brightness too low - reset progress if we've started the flow

package/lib/module/Screens/Dynamic/VerbalConsentScreen.js

@@ -575,7 +575,7 @@ const VerbalConsentScreen = () => {
     if (!currentInstructionKey) {
       return;
     }
-    speak(t(currentInstructionKey));
+    speak(t(currentInstructionKey)).catch(() => {});
   }, [appContext.currentWorkflowStep?.data?.voiceGuidanceActive, currentInstructionKey, hasGuideShown, t]);
   useEffect(() => {
     return () => {

package/lib/module/Screens/Dynamic/VideoCallScreen.js

@@ -1,11 +1,12 @@
 "use strict";
 
 import React, { useEffect, useState, useRef, useContext } from 'react';
-import { Dimensions, Platform, StyleSheet, Text, TouchableOpacity, View, ActivityIndicator, PermissionsAndroid, StatusBar } from 'react-native';
+import { Dimensions, Platform, StyleSheet, Text, TouchableOpacity, View, ActivityIndicator, StatusBar } from 'react-native';
 import { RTCView } from 'react-native-webrtc';
 import InCallManager from 'react-native-incall-manager';
 import LottieView from 'lottie-react-native';
 import { useTranslation } from 'react-i18next';
+import PermissionManager from "../../Shared/Libs/permissions.utils.js";
 import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
 import { WebRTCService } from "../../Shared/Services/WebRTCService.js";
 import { VideoSessionService } from "../../Shared/Services/VideoSessionService.js";
@@ -316,18 +317,12 @@ const VideoCallScreen = ({
       });
       serviceRef.current = service;
 
-      // Request Permissions
-      if (Platform.OS === 'android') {
-        const granted = await PermissionsAndroid.requestMultiple([PermissionsAndroid.PERMISSIONS.CAMERA, PermissionsAndroid.PERMISSIONS.RECORD_AUDIO]);
-        if (granted['android.permission.CAMERA'] !== PermissionsAndroid.RESULTS.GRANTED || granted['android.permission.RECORD_AUDIO'] !== PermissionsAndroid.RESULTS.GRANTED) {
-          if (mounted) setConnectionState('permissions_denied');
-          return;
-        }
+      // Request Camera and Microphone Permissions
+      const hasBothPermissions = await PermissionManager.requestCameraAndMicrophone();
+      if (!hasBothPermissions) {
+        if (mounted) setConnectionState('permissions_denied');
+        return;
       }
-      // For iOS, react-native-webrtc or VisionCamera usually triggers it,
-      // but explicit request via library is better if we had one.
-      // Assuming automatic or previously granted for now.
-
       try {
         const stream = await service.initialize();
         if (mounted) {

package/lib/module/Screens/Static/ResultScreen.js

@@ -695,7 +695,7 @@ const ResultScreen = () => {
                 }), /*#__PURE__*/_jsx(Text, {
                   style: styles.sectionText,
                   children: t('resultScreen.demoVideo')
-                }), /*#__PURE__*/_jsx(Video, {
+                }), consentVideo.videoPath ? /*#__PURE__*/_jsx(Video, {
                   source: {
                     uri: consentVideo.videoPath
                   },
@@ -703,6 +703,9 @@ const ResultScreen = () => {
                   style: styles.video,
                   controls: true,
                   muted: false
+                }) : /*#__PURE__*/_jsx(Text, {
+                  style: styles.sectionText,
+                  children: "N/A"
                 })]
               }, `${consentVideo.videoPath}-${index}`))]
             })]