@trustchex/react-native-sdk 1.464.0 → 1.475.0

package/android/build.gradle

@@ -83,9 +83,9 @@ dependencies {
   implementation "androidx.camera:camera-video:1.4.0"
 
   // Google ML Kit dependencies
-  implementation 'com.google.mlkit:text-recognition:16.0.0'
-  implementation 'com.google.mlkit:face-detection:16.1.5'
-  implementation 'com.google.mlkit:barcode-scanning:17.1.0'
+  implementation 'com.google.mlkit:text-recognition:16.0.1'
+  implementation 'com.google.mlkit:face-detection:16.1.7'
+  implementation 'com.google.mlkit:barcode-scanning:17.3.0'
 
   // Google Play Services dependency for Tasks
   implementation 'com.google.android.gms:play-services-tasks:18.2.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)
@@ -439,9 +452,20 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             // Brightness calculation restricted to scanning frame area (between 36% from top and 36% from bottom, 5% margins on sides)
             val averageBrightness = computeYPlaneBrightness(imageProxy, reportedWidth, reportedHeight)
 
-            // Use original inputImage directly for text recognition
-            // ML Kit works best with native camera frames, not processed bitmaps
-            val textInputImage = inputImage
+            // Text recognition: process ONLY the data inside the on-screen scan
+            // frame. We capture the full image but crop to the scan-frame ROI
+            // (top 36% / bottom 36% / 5% side margins — the same rectangle the UI
+            // guide and brightness sampling use) and UPSCALE it before OCR. This
+            // (a) excludes front-of-card text and surrounding noise (screen glare,
+            // IDE/browser chrome) that pollute the MRZ read, and (b) gives ML Kit
+            // more pixels per character — ML Kit needs ≥16px/char, and a full-frame
+            // capture leaves a 30–44-char MRZ line below that floor. Block
+            // coordinates from the ROI pass are mapped back to the full portrait
+            // frame so the JS overlay/filters stay correct.
+            val roi = if (textRecognitionEnabled) {
+                buildScanFrameRoiImage(imageProxy, rotationDegrees, reportedWidth, reportedHeight)
+            } else null
+            val textInputImage = roi?.image ?: inputImage
 
             // Generate JPEG base64 only when JS side explicitly needs the image
             // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
@@ -526,13 +550,23 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                                 blockMap.putString("text", block.text)
                                 val bb = block.boundingBox
                                 if (bb != null) {
+                                    // When OCR ran on the upscaled scan-frame ROI, map
+                                    // the box back to full portrait-frame coordinates:
+                                    // divide by the ROI upscale, then add the ROI origin.
+                                    val s = roi?.scale ?: 1f
+                                    val ox = roi?.offsetX ?: 0
+                                    val oy = roi?.offsetY ?: 0
+                                    val left = (bb.left / s).toInt() + ox
+                                    val top = (bb.top / s).toInt() + oy
+                                    val w = (bb.width() / s).toInt()
+                                    val h = (bb.height() / s).toInt()
                                     val boxMap = Arguments.createMap()
-                                    boxMap.putInt("x", bb.left)
-                                    boxMap.putInt("y", bb.top)
-                                    boxMap.putInt("width", bb.width())
-                                    boxMap.putInt("height", bb.height())
-                                    boxMap.putInt("boundingCenterX", bb.centerX())
-                                    boxMap.putInt("boundingCenterY", bb.centerY())
+                                    boxMap.putInt("x", left)
+                                    boxMap.putInt("y", top)
+                                    boxMap.putInt("width", w)
+                                    boxMap.putInt("height", h)
+                                    boxMap.putInt("boundingCenterX", left + w / 2)
+                                    boxMap.putInt("boundingCenterY", top + h / 2)
                                     blockMap.putMap("blockFrame", boxMap)
                                 }
                                 blocksArray.pushMap(blockMap)
@@ -777,6 +811,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 +857,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 -> {}
@@ -977,6 +1038,123 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
         }
     }
 
+    /** A scan-frame ROI prepared for OCR, with the transform back to full-frame coords. */
+    private data class ScanFrameRoi(
+        val image: InputImage,
+        val offsetX: Int,
+        val offsetY: Int,
+        val scale: Float
+    )
+
+    /**
+     * Builds an [InputImage] cropped to the on-screen scan frame (top 36% /
+     * bottom 36% / 5% side margins — the same rectangle the UI guide draws) and
+     * UPSCALED so ML Kit gets more pixels per character. We capture the full frame
+     * but OCR only this region, which removes front-of-card text and surrounding
+     * noise and lifts a dense MRZ line above ML Kit's ≥16px/char floor. Returns
+     * null on any failure so the caller falls back to full-frame OCR.
+     */
+    private fun buildScanFrameRoiImage(
+        imageProxy: ImageProxy,
+        rotationDegrees: Int,
+        portraitWidth: Int,
+        portraitHeight: Int
+    ): ScanFrameRoi? {
+        return try {
+            val full = yuvImageToBitmap(imageProxy, rotationDegrees) ?: return null
+
+            // Scan-frame rectangle in the rotated (portrait) bitmap. Covers the
+            // lower-middle band where the MRZ lands, with generous vertical
+            // tolerance (top 25% → bottom 12%) so the band doesn't have to be
+            // perfectly centered to be OCR'd. Keep it large enough for tolerance
+            // but not the whole frame (front text/glare would creep back in).
+            val scanTopPercent = 0.25
+            val scanBottomPercent = 0.12
+            val scanLeftPercent = 0.04
+            val scanRightPercent = 0.04
+            val left = (full.width * scanLeftPercent).toInt().coerceIn(0, full.width - 1)
+            val right = (full.width * (1.0 - scanRightPercent)).toInt().coerceIn(left + 1, full.width)
+            val top = (full.height * scanTopPercent).toInt().coerceIn(0, full.height - 1)
+            val bottom = (full.height * (1.0 - scanBottomPercent)).toInt().coerceIn(top + 1, full.height)
+            val cropW = right - left
+            val cropH = bottom - top
+            if (cropW < 8 || cropH < 8) {
+                full.recycle()
+                return null
+            }
+
+            val cropped = Bitmap.createBitmap(full, left, top, cropW, cropH)
+            full.recycle()
+
+            // Upscale so a ~30–44-char MRZ line clears the per-character pixel
+            // minimum. Cap the long edge to keep OCR latency bounded.
+            val maxLongEdge = 2200
+            val longEdge = max(cropW, cropH)
+            val rawScale = if (longEdge > 0) (maxLongEdge.toFloat() / longEdge) else 1f
+            val scale = rawScale.coerceIn(1f, 2.5f)
+            val outW = (cropW * scale).toInt()
+            val outH = (cropH * scale).toInt()
+            val scaled = if (scale != 1f) {
+                val s = Bitmap.createScaledBitmap(cropped, outW, outH, true)
+                cropped.recycle()
+                s
+            } else {
+                cropped
+            }
+
+            // Grayscale + contrast boost: the MRZ is black OCR-B on a light
+            // background, so desaturating and stretching contrast makes glyphs
+            // crisp and suppresses the dominant filler confusion (the "<" angle
+            // bracket misread as C/E/K under glare). Done with a ColorMatrix on a
+            // Canvas — no OpenCV dependency.
+            val enhanced = enhanceForOcr(scaled)
+            if (enhanced !== scaled) scaled.recycle()
+
+            // The bitmap is already rotated to portrait, so rotation = 0 here.
+            ScanFrameRoi(
+                image = InputImage.fromBitmap(enhanced, 0),
+                offsetX = left,
+                offsetY = top,
+                scale = scale
+            )
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Desaturate + boost contrast to make dark OCR-B glyphs pop against the light
+     * MRZ background, which suppresses the "<" filler being misread as C/E/K under
+     * glare. Uses a single ColorMatrix (saturation 0, then a contrast scale about
+     * mid-grey). Returns the original bitmap unchanged on failure.
+     */
+    private fun enhanceForOcr(src: Bitmap): Bitmap {
+        return try {
+            val out = Bitmap.createBitmap(src.width, src.height, Bitmap.Config.ARGB_8888)
+            val canvas = android.graphics.Canvas(out)
+            val paint = android.graphics.Paint()
+
+            val gray = android.graphics.ColorMatrix().apply { setSaturation(0f) }
+            // Contrast about mid-grey (128): out = c*in + (1-c)*128.
+            val c = 1.6f
+            val t = (1f - c) * 128f
+            val contrast = android.graphics.ColorMatrix(
+                floatArrayOf(
+                    c, 0f, 0f, 0f, t,
+                    0f, c, 0f, 0f, t,
+                    0f, 0f, c, 0f, t,
+                    0f, 0f, 0f, 1f, 0f
+                )
+            )
+            gray.postConcat(contrast)
+            paint.colorFilter = android.graphics.ColorMatrixColorFilter(gray)
+            canvas.drawBitmap(src, 0f, 0f, paint)
+            out
+        } catch (e: Exception) {
+            src
+        }
+    }
+
     fun cleanup() {
         // Cancel any active recording and delete file
         if (activeRecording != null) {