@trustchex/react-native-sdk 1.334.0 → 1.354.0

package/src/Shared/Components/NavigationManager.tsx

@@ -13,6 +13,7 @@ import {
 } from '@react-navigation/native';
 import { View, StyleSheet, Alert } from 'react-native';
 import { useTranslation } from 'react-i18next';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import i18n from '../../Translation';
 import StyledButton from './StyledButton';
 import { analyticsService } from '../Services/AnalyticsService';
@@ -35,6 +36,7 @@ const NavigationManager = forwardRef(
     const appContext = useContext(AppContext);
     const navigation = useNavigation();
     const { t } = useTranslation();
+    const insets = useSafeAreaInsets();
 
     const routes = {
       VERIFICATION_SESSION_CHECK: 'VerificationSessionCheckScreen',
@@ -65,6 +67,13 @@ const NavigationManager = forwardRef(
         workflowSteps?: WorkflowStep[],
         currentWorkFlowStep?: WorkflowStep
       ): string => {
+        // If this was a debug navigation, go directly to result screen
+        if (appContext.isDebugNavigated) {
+          appContext.isDebugNavigated = false;
+          appContext.currentWorkflowStep = undefined;
+          return routes.RESULT;
+        }
+
         const currentStepIndex =
           workflowSteps?.findIndex((step) =>
             step.id
@@ -185,10 +194,11 @@ const NavigationManager = forwardRef(
       isNavigating = true;
 
       try {
+        // Preserve demo session state when resetting
+        const wasDemoSession = appContext.isDemoSession;
+
         appContext.currentWorkflowStep = undefined;
         appContext.workflowSteps = undefined;
-        appContext.isDemoSession = false;
-        analyticsService.setDemoSession(false);
         appContext.identificationInfo = {
           sessionId: '',
           identificationId: '',
@@ -205,6 +215,12 @@ const NavigationManager = forwardRef(
           tertiaryColor: appContext.branding?.tertiaryColor || '#FF0000',
         };
 
+        // Only reset demo mode if it wasn't a demo session
+        if (!wasDemoSession) {
+          appContext.setIsDemoSession?.(false);
+          analyticsService.setDemoSession(false);
+        }
+
         navigation.dispatch(
           CommonActions.reset({
             index: 0,
@@ -236,7 +252,7 @@ const NavigationManager = forwardRef(
     return (
       appContext.currentWorkflowStep &&
       (!appContext.currentWorkflowStep?.required || canSkipStep) && (
-        <View style={styles.container}>
+        <View style={[styles.container, { paddingBottom: insets.bottom }]}>
           <StyledButton mode="text" onPress={goToNextRouteWithAlert}>
             {t('navigationManager.skipStepLabel')}
           </StyledButton>

package/src/Shared/Config/camera-enhancement.config.ts

@@ -0,0 +1,46 @@
+/**
+ * Centralized configuration for camera enhancements
+ * Including autofocus, brightness/exposure, and contrast enhancement
+ */
+
+export const ENHANCEMENT_CONFIG = {
+  autofocus: {
+    enabled: true,
+    intervalMs: 2500,
+    suspendOnDetection: true,
+  },
+
+  brightness: {
+    thresholds: {
+      general: { low: 40, high: 120, target: 80 },
+      faceDetection: { low: 50, high: 110, target: 85 },
+      mrzScanning: { low: 45, high: 130, target: 80 },
+    },
+    adaptiveStep: true,
+    maxStepSize: 2,  // Reduced from 3 for smoother transitions
+    hysteresis: 5,   // Dead zone to prevent oscillation
+  },
+
+  contrast: {
+    enabled: true,
+    clahe: {
+      clipLimit: 2.0,
+      tileGridSize: [8, 8] as [number, number],
+    },
+    applyWhen: {
+      mrzFailing: true,
+      faceFailing: true,
+      documentBackSide: true,
+      retryThreshold: 2,
+    },
+    performanceMode: 'adaptive' as 'always' | 'selective' | 'adaptive',
+  },
+
+  performance: {
+    maxFrameProcessingTime: 180, // ms
+    autoDisableThreshold: 200, // ms
+    cachingEnabled: true,
+  },
+} as const;
+
+export type EnhancementConfig = typeof ENHANCEMENT_CONFIG;

package/src/Shared/Contexts/AppContext.ts

@@ -17,10 +17,12 @@ export type AppContextType = {
   identificationInfo: IdentificationInfo;
   workflowSteps?: WorkflowStep[];
   currentWorkflowStep?: WorkflowStep;
+  isDebugNavigated?: boolean;
   onCompleted?: () => void;
   onError?: (error: string) => void;
   setSessionId?: (id: string) => void;
   setBaseUrl?: (url: string) => void;
+  setIsDemoSession?: (isDemoSession: boolean) => void;
 };
 
 export default createContext<AppContextType>({
@@ -44,6 +46,7 @@ export default createContext<AppContextType>({
   },
   workflowSteps: [],
   currentWorkflowStep: undefined,
+  isDebugNavigated: false,
   onCompleted: undefined,
   onError: undefined,
   setSessionId: undefined,

package/src/Shared/Libs/camera.utils.ts

@@ -7,6 +7,64 @@ interface Rect {
   height: number;
 }
 
+/**
+ * Check if frame is blurry using Laplacian variance
+ * Uses both horizontal and vertical gradients for more accurate blur detection
+ * Lower variance indicates a blurrier image
+ * @param frame - The camera frame to analyze
+ * @param threshold - Variance threshold below which image is considered blurry (default: 10)
+ * @returns true if image is blurry, false otherwise
+ */
+const isBlurry = (frame: Frame, threshold: number = 10): boolean => {
+  'worklet';
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  let sum = 0;
+  let sumSq = 0;
+  let count = 0;
+
+  // Sample central 50% region (matching Flutter algorithm)
+  const startY = Math.floor(height / 4);
+  const endY = Math.floor((3 * height) / 4) - 1;
+  const startX = Math.floor(width / 4);
+  const endX = Math.floor((3 * width) / 4) - 1;
+
+  // Sample at 5-pixel intervals for better accuracy (matching Flutter)
+  for (let y = startY; y < endY; y += 5) {
+    for (let x = startX; x < endX; x += 5) {
+      const idx = y * width + x;
+      const idxRight = idx + 1;
+      const idxDown = idx + width;
+
+      // Check bounds for both horizontal and vertical neighbors
+      if (idxRight < data.length && idxDown < data.length &&
+        data[idx] !== undefined && data[idxRight] !== undefined && data[idxDown] !== undefined) {
+        // Horizontal gradient
+        const diffH = Math.abs(data[idx] - data[idxRight]);
+        // Vertical gradient
+        const diffV = Math.abs(data[idx] - data[idxDown]);
+        // Combined Laplacian-like measure
+        const laplacian = diffH + diffV;
+
+        sum += laplacian;
+        sumSq += laplacian * laplacian;
+        count++;
+      }
+    }
+  }
+
+  if (count === 0) return false;
+
+  // Calculate variance: E[X²] - E[X]²
+  const mean = sum / count;
+  const variance = sumSq / count - mean * mean;
+
+  return variance < threshold;
+};
+
 /**
  * Get average brightness for entire frame (center area)
  */
@@ -98,9 +156,190 @@ const isCircularRegionBright = (frame: Frame, circleRect: Rect, threshold: numbe
   return getCircularRegionBrightness(frame, circleRect) > threshold;
 };
 
+/**
+ * Get average brightness for a specific rectangular region
+ */
+const getRegionBrightness = (frame: Frame, bounds: Rect): number => {
+  'worklet';
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  const minX = Math.max(0, Math.floor(bounds.minX));
+  const maxX = Math.min(width - 1, Math.floor(bounds.minX + bounds.width));
+  const minY = Math.max(0, Math.floor(bounds.minY));
+  const maxY = Math.min(height - 1, Math.floor(bounds.minY + bounds.height));
+
+  let luminanceSum = 0;
+  let pixelCount = 0;
+
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      const index = y * width + x;
+      if (data[index] !== undefined) {
+        luminanceSum += data[index];
+        pixelCount++;
+      }
+    }
+  }
+
+  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
+};
+
+/**
+ * Calculate adaptive exposure step based on distance from target brightness
+ * Uses smooth scaling to prevent abrupt exposure changes that could cause dark frames
+ */
+const calculateExposureStep = (currentBrightness: number, targetBrightness: number): number => {
+  'worklet';
+  const difference = Math.abs(targetBrightness - currentBrightness);
+  // Use smaller steps for smoother transitions: max 2, min 1
+  // Use floor + 1 to ensure at least step of 1 and prevent over-correction
+  const step = Math.min(2, Math.max(1, Math.floor(difference / 25)));
+  return step;
+};
+
+/**
+ * Get the center point of the scan area
+ * Scan area is typically 36%-64% of vertical space
+ */
+const getScanAreaCenterPoint = (width: number, height: number): { x: number; y: number } => {
+  const scanAreaTop = height * 0.36;
+  const scanAreaBottom = height * 0.64;
+  const scanAreaCenterY = (scanAreaTop + scanAreaBottom) / 2;
+  const scanAreaCenterX = width / 2;
+
+  return {
+    x: scanAreaCenterX,
+    y: scanAreaCenterY,
+  };
+};
+
+/**
+ * Document dimensions (in mm) for reference
+ */
+const DOCUMENT_DIMENSIONS = {
+  ID_CARD: { width: 85.6, height: 53.98, ratio: 1.586 },
+  PASSPORT: { width: 125, height: 88, ratio: 1.42 },
+};
+
+/**
+ * Detected document information
+ */
+export interface DetectedDocument {
+  type: 'ID_CARD' | 'PASSPORT' | 'UNKNOWN';
+  size: 'TOO_SMALL' | 'TOO_LARGE' | 'GOOD';
+  aspectRatio: number;
+  confidence: number; // 0-1, how confident we are in the detection
+  framePercentage: number; // How much of frame the document occupies
+}
+
+/**
+ * Detect document contours and estimate document type based on aspect ratio
+ * This is a simplified detection that looks for rectangular contours in the scan area
+ * @param frame - The camera frame to analyze
+ * @param scanAreaBounds - The bounds of the scan area {x, y, width, height}
+ * @returns Detected document info or null if no document detected
+ */
+const detectDocumentInFrame = (
+  frame: Frame,
+  scanAreaBounds: { x: number; y: number; width: number; height: number }
+): DetectedDocument | null => {
+  'worklet';
+
+  // For now, we'll use a simple edge-based detection
+  // In production, this would integrate with OpenCV findContours
+  // This is a placeholder that estimates based on brightness patterns
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const frameWidth = frame.width;
+  const frameHeight = frame.height;
+
+  // Sample edges of scan area to detect document boundaries
+  const scanX = Math.floor(scanAreaBounds.x * frameWidth);
+  const scanY = Math.floor(scanAreaBounds.y * frameHeight);
+  const scanWidth = Math.floor(scanAreaBounds.width * frameWidth);
+  const scanHeight = Math.floor(scanAreaBounds.height * frameHeight);
+
+  // Calculate average brightness in scan area to detect presence of document
+  // Documents typically have good contrast against backgrounds
+  let totalBrightness = 0;
+  let sampleCount = 0;
+  const sampleStep = 20; // Sample every 20 pixels for performance
+
+  // Sample brightness across the scan area
+  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
+    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
+      const idx = y * frameWidth + x;
+      if (idx >= 0 && idx < data.length) {
+        totalBrightness += data[idx];
+        sampleCount++;
+      }
+    }
+  }
+
+  const avgBrightness = sampleCount > 0 ? totalBrightness / sampleCount : 0;
+
+  // Calculate standard deviation to measure contrast
+  let variance = 0;
+  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
+    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
+      const idx = y * frameWidth + x;
+      if (idx >= 0 && idx < data.length) {
+        const diff = data[idx] - avgBrightness;
+        variance += diff * diff;
+      }
+    }
+  }
+  const stdDev = sampleCount > 0 ? Math.sqrt(variance / sampleCount) : 0;
+
+  // Document is present if there's ANY reasonable content in scan area
+  // Lower threshold: stdDev > 10 indicates some content (not blank surface)
+  // Brightness between 20-240 covers most lighting conditions
+  const documentPresent = stdDev > 10 && avgBrightness > 20 && avgBrightness < 240;
+
+  if (!documentPresent) {
+    return null;
+  }
+
+  // Default to ID_CARD since scan area matches ID card proportions
+  // Passport detection would require actual contour detection
+  const type: 'ID_CARD' | 'PASSPORT' | 'UNKNOWN' = 'ID_CARD';
+  const confidence = Math.min(1, stdDev / 50);
+
+  // Calculate how much of frame the document occupies
+  const framePercentage = (scanWidth * scanHeight) / (frameWidth * frameHeight);
+  const aspectRatio = scanWidth / scanHeight;
+
+  // Determine size feedback based on contrast level
+  // Higher contrast usually means document is closer/larger
+  let size: 'TOO_SMALL' | 'TOO_LARGE' | 'GOOD' = 'GOOD';
+  if (stdDev < 25) {
+    size = 'TOO_SMALL'; // Low contrast - probably far away
+  } else if (stdDev > 80) {
+    size = 'TOO_LARGE'; // Very high contrast - probably too close
+  }
+
+  return {
+    type,
+    size,
+    aspectRatio,
+    confidence: Math.min(1, confidence),
+    framePercentage,
+  };
+};
+
 export {
+  isBlurry,
   isFrameBright,
   getAverageBrightness,
   getCircularRegionBrightness,
-  isCircularRegionBright
+  isCircularRegionBright,
+  getRegionBrightness,
+  calculateExposureStep,
+  getScanAreaCenterPoint,
+  detectDocumentInFrame,
+  DOCUMENT_DIMENSIONS,
 };

package/src/Shared/Libs/frame-enhancement.utils.ts

@@ -0,0 +1,217 @@
+import type { Frame } from 'react-native-vision-camera';
+import {
+  ColorConversionCodes,
+  DataTypes,
+  type Mat,
+  ObjectType,
+  OpenCV,
+} from 'react-native-fast-opencv';
+import { ENHANCEMENT_CONFIG } from '../Config/camera-enhancement.config';
+
+// Cast OpenCV for methods not in type definitions
+const OpenCVAny = OpenCV as any;
+
+/**
+ * Convert YUV frame to BGR Mat for OpenCV processing
+ */
+const convertYUVToBGR = (frame: Frame): Mat => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  // Create YUV Mat from frame buffer
+  const yuvMat = OpenCV.createObject(
+    ObjectType.Mat,
+    height + height / 2,
+    width,
+    DataTypes.CV_8UC1
+  );
+
+  // Copy frame data to YUV Mat
+  OpenCVAny.invoke('matSetData', yuvMat, data);
+
+  // Convert YUV to BGR
+  const bgrMat = OpenCV.createObject(
+    ObjectType.Mat,
+    height,
+    width,
+    DataTypes.CV_8UC3
+  );
+
+  OpenCV.invoke(
+    'cvtColor',
+    yuvMat,
+    bgrMat,
+    ColorConversionCodes.COLOR_YUV2BGR_NV21
+  );
+
+  return bgrMat;
+};
+
+/**
+ * Apply CLAHE (Contrast Limited Adaptive Histogram Equalization) to enhance frame
+ * This improves text and face recognition in varying lighting conditions
+ */
+const enhanceFrameForOCR = (
+  frame: Frame,
+  options?: {
+    clipLimit?: number;
+    tileGridSize?: number;
+  }
+): Mat => {
+  'worklet';
+
+  const clipLimit = options?.clipLimit ?? ENHANCEMENT_CONFIG.contrast.clahe.clipLimit;
+  const tileGridSize = options?.tileGridSize ?? ENHANCEMENT_CONFIG.contrast.clahe.tileGridSize[0];
+
+  try {
+    // 1. Convert YUV to BGR
+    const bgrMat = convertYUVToBGR(frame);
+
+    // 2. Convert BGR to LAB color space (better for luminance enhancement)
+    const labMat = OpenCV.createObject(
+      ObjectType.Mat,
+      frame.height,
+      frame.width,
+      DataTypes.CV_8UC3
+    );
+
+    OpenCV.invoke('cvtColor', bgrMat, labMat, ColorConversionCodes.COLOR_BGR2Lab);
+
+    // 3. Split LAB channels
+    const channels = OpenCVAny.invoke('split', labMat);
+    const lChannel = channels[0]; // Luminance channel
+    const aChannel = channels[1]; // a channel
+    const bChannel = channels[2]; // b channel
+
+    // 4. Apply CLAHE to L channel
+    const clahe = OpenCVAny.invoke('createCLAHE', clipLimit, [
+      tileGridSize,
+      tileGridSize,
+    ]);
+
+    const enhancedL = OpenCV.createObject(
+      ObjectType.Mat,
+      frame.height,
+      frame.width,
+      DataTypes.CV_8UC1
+    );
+
+    OpenCVAny.invoke('apply', clahe, lChannel, enhancedL);
+
+    // 5. Merge enhanced L channel with original a and b channels
+    const enhancedLab = OpenCVAny.invoke('merge', [enhancedL, aChannel, bChannel]);
+
+    // 6. Convert back to BGR
+    const enhancedBGR = OpenCV.createObject(
+      ObjectType.Mat,
+      frame.height,
+      frame.width,
+      DataTypes.CV_8UC3
+    );
+
+    OpenCV.invoke(
+      'cvtColor',
+      enhancedLab,
+      enhancedBGR,
+      ColorConversionCodes.COLOR_Lab2BGR
+    );
+
+    // Cleanup intermediate Mats
+    OpenCVAny.invoke('delete', bgrMat);
+    OpenCVAny.invoke('delete', labMat);
+    OpenCVAny.invoke('delete', lChannel);
+    OpenCVAny.invoke('delete', aChannel);
+    OpenCVAny.invoke('delete', bChannel);
+    OpenCVAny.invoke('delete', enhancedL);
+    OpenCVAny.invoke('delete', enhancedLab);
+
+    return enhancedBGR;
+  } catch (error) {
+    console.warn('Error enhancing frame:', error);
+    // Return original frame converted to BGR if enhancement fails
+    return convertYUVToBGR(frame);
+  }
+};
+
+/**
+ * Apply sharpening to enhance text clarity
+ * Uses unsharp mask technique
+ */
+const sharpenForText = (mat: Mat, amount: number = 1.5): Mat => {
+  'worklet';
+
+  try {
+    const blurred = OpenCV.createObject(
+      ObjectType.Mat,
+      0,
+      0,
+      DataTypes.CV_8UC3
+    );
+
+    // Apply Gaussian blur
+    OpenCVAny.invoke('GaussianBlur', mat, blurred, [0, 0], 3.0);
+
+    // Create sharpened image: original * (1 + amount) - blurred * amount
+    const sharpened = OpenCV.createObject(
+      ObjectType.Mat,
+      0,
+      0,
+      DataTypes.CV_8UC3
+    );
+
+    OpenCV.invoke('addWeighted', mat, 1.0 + amount, blurred, -amount, 0, sharpened);
+
+    // Cleanup
+    OpenCVAny.invoke('delete', blurred);
+
+    return sharpened;
+  } catch (error) {
+    console.warn('Error sharpening frame:', error);
+    return mat;
+  }
+};
+
+/**
+ * Determine if frame should be enhanced based on current scanning state
+ */
+const shouldEnhanceFrame = (
+  nextStep: string,
+  detectedFaces: number,
+  mrzRetryCount: number
+): boolean => {
+  'worklet';
+
+  const config = ENHANCEMENT_CONFIG.contrast.applyWhen;
+
+  // Always enhance for document back side (MRZ scanning)
+  if (config.documentBackSide && nextStep === 'SCAN_ID_BACK') {
+    return true;
+  }
+
+  // Enhance if faces are failing to detect on front/passport
+  if (
+    config.faceFailing &&
+    nextStep === 'SCAN_ID_FRONT_OR_PASSPORT' &&
+    detectedFaces === 0
+  ) {
+    return true;
+  }
+
+  // Enhance if MRZ detection is failing
+  if (config.mrzFailing && mrzRetryCount >= config.retryThreshold) {
+    return true;
+  }
+
+  return false;
+};
+
+export {
+  convertYUVToBGR,
+  enhanceFrameForOCR,
+  sharpenForText,
+  shouldEnhanceFrame,
+};

package/src/Shared/Libs/mrz.utils.ts

@@ -55,11 +55,88 @@ const getMRZText = (fixedText: string) => {
   return null;
 };
 
+/**
+ * Apply common OCR corrections for MRZ text
+ * Common confusions: 0/O, 1/I, 8/B, 5/S, 2/Z
+ */
+const applyOCRCorrections = (mrzText: string): string[] => {
+  const corrections: string[] = [];
+
+  // Common OCR substitutions to try
+  // In MRZ: letters should be in name fields, numbers in date/checksum fields
+  const substitutions = [
+    // Try replacing O with 0 in numeric positions (dates, checksums)
+    { from: /O/g, to: '0' },
+    // Try replacing 0 with O in alphabetic positions (names, country codes)
+    { from: /0/g, to: 'O' },
+    // I and 1 confusion
+    { from: /I(?=\d)/g, to: '1' }, // I followed by digit -> likely 1
+    { from: /1(?=[A-Z])/g, to: 'I' }, // 1 followed by letter -> likely I
+    // B and 8 confusion
+    { from: /B(?=\d)/g, to: '8' },
+    { from: /8(?=[A-Z])/g, to: 'B' },
+    // S and 5 confusion
+    { from: /S(?=\d)/g, to: '5' },
+    { from: /5(?=[A-Z])/g, to: 'S' },
+    // Z and 2 confusion
+    { from: /Z(?=\d)/g, to: '2' },
+    { from: /2(?=[A-Z])/g, to: 'Z' },
+  ];
+
+  for (const sub of substitutions) {
+    const corrected = mrzText.replace(sub.from, sub.to);
+    if (corrected !== mrzText) {
+      corrections.push(corrected);
+    }
+  }
+
+  return corrections;
+};
+
 const getMRZData = (ocrText: string) => {
   const fixedText = fixMRZ(ocrText);
   const mrzText = getMRZText(fixedText);
+
   if (mrzText) {
-    const parsedResult = parse(mrzText, { autocorrect: true });
+    // First attempt with original text
+    let parsedResult = parse(mrzText, { autocorrect: true });
+
+    // Check if parse is valid with all required fields
+    const isValidParse = (result: typeof parsedResult) => {
+      return result.valid &&
+        result.fields.firstName &&
+        result.fields.lastName &&
+        result.fields.birthDate &&
+        result.fields.expirationDate &&
+        result.fields.documentNumber &&
+        result.fields.issuingState;
+    };
+
+    if (isValidParse(parsedResult)) {
+      return {
+        mrzText,
+        parsedResult,
+      };
+    }
+
+    // If not valid, try OCR corrections
+    const corrections = applyOCRCorrections(mrzText);
+    for (const correctedMRZ of corrections) {
+      try {
+        const correctedResult = parse(correctedMRZ, { autocorrect: true });
+        if (isValidParse(correctedResult)) {
+          console.log('[MRZ] OCR correction applied successfully');
+          return {
+            mrzText: correctedMRZ,
+            parsedResult: correctedResult,
+          };
+        }
+      } catch (e) {
+        // Continue trying other corrections
+      }
+    }
+
+    // Return original result even if not fully valid (for partial matches)
     if (
       parsedResult.fields.firstName &&
       parsedResult.fields.lastName &&