@trustchex/react-native-sdk 1.409.0 → 1.472.0

package/android/src/main/java/com/trustchex/reactnativesdk/TrustchexSDKModule.kt

@@ -17,20 +17,14 @@ class TrustchexSDKModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   override fun enableKeepAwake() {
     UiThreadUtil.runOnUiThread {
-      val activity = currentActivity
-      activity?.runOnUiThread {
-        activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      }
+      currentActivity?.window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
     }
   }
 
   @ReactMethod
   override fun disableKeepAwake() {
     UiThreadUtil.runOnUiThread {
-      val activity = currentActivity
-      activity?.runOnUiThread {
-        activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-      }
+      currentActivity?.window?.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
     }
   }
 

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

@@ -1,17 +1,24 @@
 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
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
 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
@@ -154,7 +161,7 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
 
     private fun selectBestCamera(type: String): CameraSelector {
         if (type == "front") {
-            return CameraSelector.DEFAULT_FRONT_CAMERA
+            return selectWidestFrontCamera()
         }
 
         // For back camera, try to select Ultra Wide camera for document scanning
@@ -181,6 +188,62 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
         return CameraSelector.DEFAULT_BACK_CAMERA
     }
 
+    /**
+     * Select the front camera with the widest field of view.
+     * Many devices (e.g. Pixel 9a, Samsung S24) have multiple front cameras;
+     * the wider lens gives a better framing experience for face detection.
+     */
+    @OptIn(androidx.camera.camera2.interop.ExperimentalCamera2Interop::class)
+    private fun selectWidestFrontCamera(): CameraSelector {
+        try {
+            val provider = cameraProvider ?: return CameraSelector.DEFAULT_FRONT_CAMERA
+            val cameraManager = context.getSystemService(android.content.Context.CAMERA_SERVICE) as? CameraManager
+                ?: return CameraSelector.DEFAULT_FRONT_CAMERA
+
+            val frontCameras = provider.availableCameraInfos.filter { info ->
+                try {
+                    val c2Info = androidx.camera.camera2.interop.Camera2CameraInfo.from(info)
+                    val chars = cameraManager.getCameraCharacteristics(c2Info.cameraId)
+                    chars.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT
+                } catch (_: Exception) { false }
+            }
+
+            if (frontCameras.size <= 1) return CameraSelector.DEFAULT_FRONT_CAMERA
+
+            // Pick the camera with the shortest focal length (widest FoV)
+            var bestInfo: androidx.camera.core.CameraInfo? = null
+            var shortestFocal = Float.MAX_VALUE
+
+            for (info in frontCameras) {
+                try {
+                    val c2Info = androidx.camera.camera2.interop.Camera2CameraInfo.from(info)
+                    val chars = cameraManager.getCameraCharacteristics(c2Info.cameraId)
+                    val focalLengths = chars.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+                    if (focalLengths != null && focalLengths.isNotEmpty()) {
+                        val minFocal = focalLengths.min()
+                        if (minFocal < shortestFocal) {
+                            shortestFocal = minFocal
+                            bestInfo = info
+                        }
+                    }
+                } catch (_: Exception) { /* skip */ }
+            }
+
+            if (bestInfo != null) {
+                val selectedInfo = bestInfo
+                return CameraSelector.Builder()
+                    .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
+                    .addCameraFilter { cameraInfos ->
+                        cameraInfos.filter { it == selectedInfo }.ifEmpty { cameraInfos }
+                    }
+                    .build()
+            }
+        } catch (_: Exception) {
+            // Fall back to default
+        }
+        return CameraSelector.DEFAULT_FRONT_CAMERA
+    }
+
     fun setTorchEnabled(enabled: Boolean) {
         torchEnabled = enabled
         camera?.cameraControl?.enableTorch(enabled)
@@ -245,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 {
@@ -257,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)
@@ -719,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
@@ -755,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,28 +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 {
+            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: 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)
     }
 
@@ -296,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) {
@@ -468,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()
@@ -487,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
@@ -647,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
             }
         }
     }
@@ -1039,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
+  }
+}