@trustchex/react-native-sdk 1.253.0 → 1.266.0

package/src/Shared/Components/EIDScanner.tsx

@@ -1,6 +1,7 @@
 import React, { useState, useEffect, useCallback } from 'react';
 import { Alert, View, Text, Image, StyleSheet } from 'react-native';
 import NFCManager from 'react-native-nfc-manager';
+import DeviceInfo from 'react-native-device-info';
 import { MRZInfo } from '../EIDReader/lds/icao/mrzInfo';
 import { eidReader } from '../EIDReader/eidReader';
 import NativeProgressBar from './NativeProgressBar';
@@ -11,6 +12,11 @@ import StyledButton from './StyledButton';
 import LottieView from 'lottie-react-native';
 import { useKeepAwake } from '../Libs/native-keep-awake.utils';
 import { speakWithDebounce } from '../Libs/tts.utils';
+import {
+  trackEIDScanStart,
+  trackEIDScanComplete,
+  trackEIDScanFailed,
+} from '../Libs/analytics.utils';
 
 interface eIDScannerProps {
   documentNumber: string;
@@ -47,12 +53,58 @@ const EIDScanner = ({
   const { t } = useTranslation();
   const appContext = React.useContext(AppContext);
   const [voiceGuidanceMessage, setVoiceGuidanceMessage] = useState<string>();
+  const [attemptNumber, setAttemptNumber] = useState<number>(0);
 
   const readNFC = useCallback(async () => {
+    const startTime = Date.now();
+    const currentAttempt = attemptNumber + 1;
+    setAttemptNumber(currentAttempt);
+
     setIsScanning(true);
     setIsScanned(false);
     setProgress(0);
 
+    // Track EID scan start using analytics helper
+    const docType =
+      (documentType as 'ID' | 'PASSPORT' | 'UNKNOWN') || 'UNKNOWN';
+
+    // If device doesn't support NFC or NFC is disabled, track and abort early
+    if (!hasNfc) {
+      await trackEIDScanFailed(
+        docType,
+        'device_unsupported',
+        'Device does not support NFC',
+        0,
+        currentAttempt,
+        DeviceInfo.getModel(),
+        DeviceInfo.getSystemVersion()
+      ).catch(() => {});
+
+      // Stop scanning - user will see the not-supported UI
+      setIsScanning(false);
+      setProgress(0);
+      return;
+    }
+
+    if (!isEnabled) {
+      await trackEIDScanFailed(
+        docType,
+        'not_enabled',
+        'NFC is disabled on device',
+        0,
+        currentAttempt,
+        DeviceInfo.getModel(),
+        DeviceInfo.getSystemVersion()
+      ).catch(() => {});
+
+      // Stop scanning - allow the UI to prompt user to enable NFC
+      setIsScanning(false);
+      setProgress(0);
+      return;
+    }
+
+    await trackEIDScanStart(docType, hasNfc, isEnabled, currentAttempt).catch(()=>{});
+
     try {
       if (documentNumber && dateOfBirth && dateOfExpiry) {
         const passportData = await eidReader(
@@ -64,23 +116,95 @@ const EIDScanner = ({
           }
         );
         if (passportData) {
+          const scanDuration = Date.now() - startTime;
           setDocumentFaceImage(passportData.faceImage);
           setDocumentMRZInfo(passportData.mrz);
           setDocumentFaceImageMimeType(passportData.mimeType);
           setIsScanned(true);
+
+          // Track successful EID scan
+          await trackEIDScanComplete(docType, scanDuration, currentAttempt).catch(()=>{});
         }
       } else {
+        const scanDuration = Date.now() - startTime;
+        // MRZ input issue — track as NFC scan failure (unknown error type for NFC-specific stream)
+        await trackEIDScanFailed(
+          docType,
+          'unknown',
+          'Invalid MRZ fields',
+          scanDuration,
+          currentAttempt,
+          DeviceInfo.getModel(),
+          DeviceInfo.getSystemVersion()
+        ).catch(() => {});
         Alert.alert(t('general.error'), t('eidScannerScreen.invalidMRZFields'));
       }
     } catch (error) {
-      console.debug(error);
-      // Ignore error
+      const scanDuration = Date.now() - startTime;
+      const errorMessage =
+        error instanceof Error ? error.message : 'Unknown error';
+
+      // Determine error type
+      let errorType:
+        | 'device_unsupported'
+        | 'not_enabled'
+        | 'reading_error'
+        | 'user_cancelled'
+        | 'timeout'
+        | 'unknown' = 'unknown';
+
+      if (
+        errorMessage.includes('cancelled') ||
+        errorMessage.includes('cancel')
+      ) {
+        errorType = 'user_cancelled';
+      } else if (
+        errorMessage.includes('timeout') ||
+        errorMessage.includes('time out')
+      ) {
+        errorType = 'timeout';
+      } else if (errorMessage.includes('not supported')) {
+        errorType = 'device_unsupported';
+      } else if (
+        errorMessage.includes('not enabled') ||
+        errorMessage.includes('disabled')
+      ) {
+        errorType = 'not_enabled';
+      } else if (
+        errorMessage.includes('read') ||
+        errorMessage.includes('communication')
+      ) {
+        errorType = 'reading_error';
+      }
+
+      // Track EID scan failure with detailed metadata
+      await trackEIDScanFailed(
+        docType,
+        errorType,
+        errorMessage,
+        scanDuration,
+        currentAttempt,
+        DeviceInfo.getModel(),
+        DeviceInfo.getSystemVersion()
+      ).catch(() => {});
+
+      console.debug('NFC scan error:', error);
+      // Ignore error - let user retry
     } finally {
       setIsScanning(false);
       setProgress(0);
       setHasGuideShown(false);
     }
-  }, [documentNumber, dateOfBirth, dateOfExpiry, t]);
+  }, [
+    documentNumber,
+    dateOfBirth,
+    dateOfExpiry,
+    documentType,
+    hasNfc,
+    isEnabled,
+    attemptNumber,
+    t,
+  ]);
 
   const getFieldsFromMRZ = useCallback((mrz: MRZInfo) => {
     return {
@@ -103,8 +227,13 @@ const EIDScanner = ({
       setHasNFC(deviceIsSupported);
       isNFCSupported && isNFCSupported(deviceIsSupported);
 
+      // NFC not supported is a device limitation - not actionable by developers
+
       const deviceIsEnabled = await NFCManager.isEnabled();
       setIsEnabled(deviceIsEnabled);
+
+      // NFC disabled is a user setting - they can enable it in settings
+      // Not tracking as it's user-controllable
     };
 
     checkIsSupported();

package/src/Shared/Components/FaceCamera.tsx

@@ -9,6 +9,7 @@ import {
   Linking,
   Dimensions,
   ActivityIndicator,
+  NativeModules,
 } from 'react-native';
 import {
   useCameraDevice,
@@ -27,7 +28,7 @@ import {
 } from '../VisionCameraPlugins/FaceDetector';
 import { Worklets, useSharedValue } from 'react-native-worklets-core';
 import { crop } from '../VisionCameraPlugins/Cropper';
-import { isFrameBright } from '../Libs/camera.utils';
+import { isCircularRegionBright } from '../Libs/camera.utils';
 import { useTranslation } from 'react-i18next';
 import StyledButton from './StyledButton';
 import { useTheme } from '../Contexts/ThemeContext';
@@ -39,6 +40,12 @@ export type FaceCameraProps = {
     isImageBright: boolean
   ) => void;
   onCameraInitialized: (camera: Camera) => void;
+  previewRect?: {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+  };
 };
 
 const VIDEO_WIDTH = 1280;
@@ -50,6 +57,7 @@ const windowHeight = Dimensions.get('window').height;
 const FaceCamera = ({
   onFacesDetected,
   onCameraInitialized,
+  previewRect,
 }: FaceCameraProps) => {
   useKeepAwake();
   const theme = useTheme();
@@ -115,10 +123,74 @@ const FaceCamera = ({
     };
   }, [device, format, isFocused]);
 
+  // Set screen brightness to maximum when camera is active
+  useEffect(() => {
+    const { DeviceBrightness } = NativeModules;
+    if (!DeviceBrightness) return;
+
+    let originalBrightness = -1;
+
+    const setBrightness = async () => {
+      if (isActive) {
+        try {
+          originalBrightness = await DeviceBrightness.getBrightness();
+          await DeviceBrightness.setBrightness(1.0);
+        } catch (error) {
+          console.log('Failed to set brightness:', error);
+        }
+      }
+    };
+
+    setBrightness();
+
+    return () => {
+      if (originalBrightness >= 0) {
+        DeviceBrightness.setBrightness(originalBrightness).catch(() => { });
+      }
+    };
+  }, [isActive]);
+
   const handleWorklet = (frame: Frame) => {
     'worklet';
     try {
-      const isBright = isFrameBright(frame);
+      // Calculate brightness based on the circular preview area if provided
+      // Otherwise fall back to entire frame brightness
+      let isBright = false;
+      if (previewRect) {
+        // Convert preview rect from screen coordinates to frame coordinates
+        const scaleX = frame.width / windowWidth;
+        const scaleY = frame.height / windowHeight;
+        const frameCircleRect = {
+          minX: Math.floor(previewRect.minX * scaleX),
+          minY: Math.floor(previewRect.minY * scaleY),
+          width: Math.floor(previewRect.width * scaleX),
+          height: Math.floor(previewRect.height * scaleY),
+        };
+        isBright = isCircularRegionBright(frame, frameCircleRect, 60);
+      } else {
+        // Fallback: check entire frame brightness (use legacy method)
+        const buffer = frame.toArrayBuffer();
+        const data = new Uint8Array(buffer);
+        const width = frame.width;
+        const height = frame.height;
+        let luminanceSum = 0;
+        let pixelCount = 0;
+        const centerX = Math.floor(width / 2);
+        const centerY = Math.floor(height / 2);
+        const halfSizeX = Math.floor(width / 2);
+        const halfSizeY = Math.floor(height / 2);
+
+        for (let y = centerY - halfSizeY; y < centerY + halfSizeY; y++) {
+          for (let x = centerX - halfSizeX; x < centerX + halfSizeX; x++) {
+            const index = y * width + x;
+            if (data[index] !== undefined) {
+              luminanceSum += data[index];
+              pixelCount++;
+            }
+          }
+        }
+        isBright = (luminanceSum / pixelCount) > 60;
+      }
 
       const image = crop(frame, {
         cropRegion: {
@@ -172,6 +244,7 @@ const FaceCamera = ({
   }
 
   if (!cameraPermission.hasPermission) {
+    // Camera permission denied by user - their choice, not actionable
     return (
       <View style={styles.permissionContainer}>
         <Text style={styles.permissionText}>
@@ -190,6 +263,7 @@ const FaceCamera = ({
   }
 
   if (!microphonePermission.hasPermission) {
+    // Microphone permission denied by user - their choice, not actionable
     return (
       <View style={styles.permissionContainer}>
         <Text style={styles.permissionText}>
@@ -208,6 +282,7 @@ const FaceCamera = ({
   }
 
   if (device == null) {
+    // No camera device - device limitation, not actionable
     return (
       <View style={styles.permissionContainer}>
         <Text style={styles.permissionText}>

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -506,10 +506,10 @@ const IdentityDocumentCamera = ({
           face.bounds.x >= width ||
           face.bounds.y >= height
         ) {
-          console.warn(
-            'Invalid face bounds detected, skipping face:',
-            face.bounds
-          );
+          // console.warn(
+          //   'Invalid face bounds detected, skipping face:',
+          //   face.bounds
+          // );
           continue;
         }
 

package/src/Shared/Components/NavigationManager.tsx

@@ -15,6 +15,7 @@ import { View, StyleSheet, Alert } from 'react-native';
 import { useTranslation } from 'react-i18next';
 import i18n from '../../Translation';
 import StyledButton from './StyledButton';
+import { analyticsService } from '../Services/AnalyticsService';
 
 // Simple global navigation lock
 let isNavigating = false;
@@ -187,6 +188,7 @@ const NavigationManager = forwardRef(
         appContext.currentWorkflowStep = undefined;
         appContext.workflowSteps = undefined;
         appContext.isDemoSession = false;
+        analyticsService.setDemoSession(false);
         appContext.identificationInfo = {
           sessionId: '',
           identificationId: '',

package/src/Shared/Components/QrCodeScannerCamera.tsx

@@ -172,6 +172,7 @@ const QrCodeScannerCamera = ({ onQrCodeScanned }: QrCodeScannerCameraProps) => {
   }
 
   if (!cameraPermission.hasPermission) {
+    // Camera permission denied by user - their choice, not actionable
     return (
       <View style={styles.permissionContainer}>
         <Text style={styles.permissionText}>
@@ -190,6 +191,7 @@ const QrCodeScannerCamera = ({ onQrCodeScanned }: QrCodeScannerCameraProps) => {
   }
 
   if (device == null) {
+    // No camera device - device limitation, not actionable
     return (
       <View style={styles.permissionContainer}>
         <TextView style={styles.permissionText}>

package/src/Shared/Contexts/AppContext.ts

@@ -19,6 +19,8 @@ export type AppContextType = {
   currentWorkflowStep?: WorkflowStep;
   onCompleted?: () => void;
   onError?: (error: string) => void;
+  setSessionId?: (id: string) => void;
+  setBaseUrl?: (url: string) => void;
 };
 
 export default createContext<AppContextType>({
@@ -44,4 +46,6 @@ export default createContext<AppContextType>({
   currentWorkflowStep: undefined,
   onCompleted: undefined,
   onError: undefined,
+  setSessionId: undefined,
+  setBaseUrl: undefined,
 });