@trustchex/react-native-sdk 1.253.0 → 1.266.1

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

@@ -4,17 +4,19 @@ import React, { useCallback, useContext, useEffect, useMemo, useRef, useState }
 import { SafeAreaView, Text, StyleSheet, Alert, View, Image, Dimensions, KeyboardAvoidingView, Platform, ScrollView } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import AppContext from "../../Shared/Contexts/AppContext.js";
-import httpClient, { NotFoundError } from "../../Shared/Libs/http-client.js";
+import httpClient, { BadRequestError, NotFoundError } from "../../Shared/Libs/http-client.js";
 import { useTranslation } from 'react-i18next';
 import LanguageSelector from "../../Shared/Components/LanguageSelector.js";
 import NavigationManager from "../../Shared/Components/NavigationManager.js";
 import StyledButton from "../../Shared/Components/StyledButton.js";
 import StyledTextInput from "../../Shared/Components/StyledTextInput.js";
+import { analyticsService } from "../../Shared/Services/AnalyticsService.js";
 import { useTheme } from "../../Shared/Contexts/ThemeContext.js";
 import LottieView from 'lottie-react-native';
 import { getSimulatedDemoData, isDemoSession } from "../../Shared/Libs/demo.utils.js";
 import { useNavigation } from '@react-navigation/native';
 import { SESSION_CODE_CHARSET_PATTERN, SESSION_CODE_VALIDATION_PATTERN } from "../../Shared/Constants/validation.constants.js";
+import { trackError, trackFunnelStep, useScreenTracking } from "../../Shared/Libs/analytics.utils.js";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 const VerificationSessionCheckScreen = () => {
   const [sessionCode, setSessionCode] = useState('');
@@ -33,6 +35,9 @@ const VerificationSessionCheckScreen = () => {
   const insets = useSafeAreaInsets();
   const theme = useTheme();
   const primaryColor = theme.colors.primary;
+
+  // Track screen view and exit
+  useScreenTracking('verification_session_check');
   const apiUrl = useMemo(() => `${appContext.baseUrl}/api/app/mobile`, [appContext.baseUrl]);
   const validateSessionCode = useCallback(value => {
     return SESSION_CODE_VALIDATION_PATTERN.test(value.toUpperCase());
@@ -43,21 +48,37 @@ const VerificationSessionCheckScreen = () => {
       return response;
     } catch (error) {
       if (error instanceof NotFoundError) {
+        // User entered invalid session ID - expected user behavior, not actionable
         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.noVerificationSessionFound'));
+      } else {
+        trackError('SESSION_CHECK_ERROR', error instanceof Error ? error.message : 'Unknown error', 'verification_session_check', 'high', {
+          recoverable: false,
+          userAction: 'check_session'
+        });
       }
     }
   }, [apiUrl, appContext.isDemoSession, t]);
   const getSessionByCode = useCallback(async inputCode => {
     try {
       appContext.isDemoSession = isDemoSession(inputCode);
+      analyticsService.setDemoSession(appContext.isDemoSession);
       const response = await httpClient.get(`${apiUrl}/verification-sessions?sessionCode=${inputCode.toUpperCase()}`, appContext.isDemoSession ? getSimulatedDemoData('GET_SESSION_BY_CODE') : undefined);
       if (!response || !response.id) {
         throw new NotFoundError();
       }
+
+      // Track successful session start as funnel step
+      trackFunnelStep('Session Started', 1, 5, undefined, true);
       return response;
     } catch (error) {
       if (error instanceof NotFoundError) {
+        // User entered invalid session code - expected user behavior, not actionable
         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.noVerificationSessionFound'));
+      } else {
+        trackError('SESSION_CODE_CHECK_ERROR', error instanceof Error ? error.message : 'Unknown error', 'verification_session_check', 'high', {
+          recoverable: false,
+          userAction: 'check_session_code'
+        });
       }
     }
   }, [apiUrl, appContext, t]);
@@ -67,8 +88,13 @@ const VerificationSessionCheckScreen = () => {
       return true;
     } catch (error) {
       if (error instanceof NotFoundError) {
+        // Session expired or invalid - expected behavior, not actionable
         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.noVerificationSessionFound'));
       } else {
+        trackError('VERIFICATION_CODE_SEND_FAILED', 'Failed to send verification code', 'verification_session_check', 'high', {
+          recoverable: true,
+          userAction: 'send_verification_code'
+        });
         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.cannotSendVerificationCode'));
       }
     }
@@ -84,7 +110,15 @@ const VerificationSessionCheckScreen = () => {
       return response;
     } catch (error) {
       if (error instanceof NotFoundError) {
+        // Session expired or invalid - expected behavior, not actionable
         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.noVerificationSessionFound'));
+      } else if (error instanceof BadRequestError) {
+        // Wrong OTP code - expected user behavior, not actionable
+      } else {
+        trackError('VERIFIED_SESSION_CHECK_ERROR', error instanceof Error ? error.message : 'Unknown error', 'verification_session_check', 'high', {
+          recoverable: false,
+          userAction: 'check_verified_session'
+        });
       }
     }
   }, [apiUrl, appContext.isDemoSession, t]);
@@ -176,7 +210,11 @@ const VerificationSessionCheckScreen = () => {
                       setIsCheckingSession(true);
                       const session = await getSessionByCode(alphanumericText);
                       if (session?.id) {
-                        appContext.identificationInfo.sessionId = session.id;
+                        if (appContext.setSessionId) {
+                          appContext.setSessionId(session.id);
+                        } else {
+                          appContext.identificationInfo.sessionId = session.id;
+                        }
                       } else {
                         setSessionCode('');
                       }
@@ -240,6 +278,7 @@ const VerificationSessionCheckScreen = () => {
                         setIsCodeSent(false);
                         navigationManagerRef.current?.navigateToNextStep();
                       } else {
+                        // User entered wrong OTP code - expected behavior, not actionable
                         appContext.onError?.('Invalid OTP code');
                         Alert.alert(t('general.error'), t('verificationSessionCheckScreen.codeError'));
                         setCode('');

package/lib/module/Shared/Components/EIDScanner.js

@@ -3,6 +3,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 { eidReader } from "../EIDReader/eidReader.js";
 import NativeProgressBar from "./NativeProgressBar.js";
 import { useTranslation } from 'react-i18next';
@@ -11,6 +12,7 @@ import StyledButton from "./StyledButton.js";
 import LottieView from 'lottie-react-native';
 import { useKeepAwake } from "../Libs/native-keep-awake.utils.js";
 import { speakWithDebounce } from "../Libs/tts.utils.js";
+import { trackEIDScanStart, trackEIDScanComplete, trackEIDScanFailed } from "../Libs/analytics.utils.js";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 const EIDScanner = ({
   documentNumber,
@@ -35,33 +37,85 @@ const EIDScanner = ({
   } = useTranslation();
   const appContext = React.useContext(AppContext);
   const [voiceGuidanceMessage, setVoiceGuidanceMessage] = useState();
+  const [attemptNumber, setAttemptNumber] = useState(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 || '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(documentNumber, dateOfBirth, dateOfExpiry, progressValue => {
           setProgress(progressValue);
         });
         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 = '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 => {
     return {
       documentCode: mrz.getDocumentCode(),
@@ -81,8 +135,14 @@ const EIDScanner = ({
       const deviceIsSupported = await NFCManager.isSupported();
       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();
   }, [isNFCSupported, isScanning]);

package/lib/module/Shared/Components/FaceCamera.js

@@ -3,13 +3,13 @@
 import { useIsFocused } from '@react-navigation/native';
 import { useKeepAwake } from "../Libs/native-keep-awake.utils.js";
 import React, { useEffect, useState } from 'react';
-import { StyleSheet, Text, View, Platform, Linking, Dimensions, ActivityIndicator } from 'react-native';
+import { StyleSheet, Text, View, Platform, Linking, Dimensions, ActivityIndicator, NativeModules } from 'react-native';
 import { useCameraDevice, useCameraPermission, Camera, useFrameProcessor, useCameraFormat, runAtTargetFps, useMicrophonePermission } from 'react-native-vision-camera';
 import { runAsync } from "../Libs/worklet.utils.js";
 import { useFaceDetector } from "../VisionCameraPlugins/FaceDetector/index.js";
 import { Worklets, useSharedValue } from 'react-native-worklets-core';
 import { crop } from "../VisionCameraPlugins/Cropper/index.js";
-import { isFrameBright } from "../Libs/camera.utils.js";
+import { isCircularRegionBright } from "../Libs/camera.utils.js";
 import { useTranslation } from 'react-i18next';
 import StyledButton from "./StyledButton.js";
 import { useTheme } from "../Contexts/ThemeContext.js";
@@ -20,7 +20,8 @@ const windowWidth = Dimensions.get('window').width;
 const windowHeight = Dimensions.get('window').height;
 const FaceCamera = ({
   onFacesDetected,
-  onCameraInitialized
+  onCameraInitialized,
+  previewRect
 }) => {
   useKeepAwake();
   const theme = useTheme();
@@ -84,11 +85,72 @@ const FaceCamera = ({
       setIsActive(false);
     };
   }, [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 => {
     '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: {
           top: 0,
@@ -139,6 +201,7 @@ const FaceCamera = ({
     });
   }
   if (!cameraPermission.hasPermission) {
+    // Camera permission denied by user - their choice, not actionable
     return /*#__PURE__*/_jsxs(View, {
       style: styles.permissionContainer,
       children: [/*#__PURE__*/_jsx(Text, {
@@ -154,6 +217,7 @@ const FaceCamera = ({
     });
   }
   if (!microphonePermission.hasPermission) {
+    // Microphone permission denied by user - their choice, not actionable
     return /*#__PURE__*/_jsxs(View, {
       style: styles.permissionContainer,
       children: [/*#__PURE__*/_jsx(Text, {
@@ -169,6 +233,7 @@ const FaceCamera = ({
     });
   }
   if (device == null) {
+    // No camera device - device limitation, not actionable
     return /*#__PURE__*/_jsx(View, {
       style: styles.permissionContainer,
       children: /*#__PURE__*/_jsx(Text, {

package/lib/module/Shared/Components/IdentityDocumentCamera.js

@@ -299,7 +299,10 @@ const IdentityDocumentCamera = ({
 
         // Add validation for face bounds to prevent invalid crop operations
         if (face.bounds.x < 0 || face.bounds.y < 0 || face.bounds.width <= 0 || face.bounds.height <= 0 || 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/lib/module/Shared/Components/NavigationManager.js

@@ -7,6 +7,7 @@ import { View, StyleSheet, Alert } from 'react-native';
 import { useTranslation } from 'react-i18next';
 import i18n from "../../Translation/index.js";
 import StyledButton from "./StyledButton.js";
+import { analyticsService } from "../Services/AnalyticsService.js";
 
 // Simple global navigation lock
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -107,6 +108,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
       appContext.currentWorkflowStep = undefined;
       appContext.workflowSteps = undefined;
       appContext.isDemoSession = false;
+      analyticsService.setDemoSession(false);
       appContext.identificationInfo = {
         sessionId: '',
         identificationId: '',

package/lib/module/Shared/Components/QrCodeScannerCamera.js

@@ -131,6 +131,7 @@ const QrCodeScannerCamera = ({
     });
   }
   if (!cameraPermission.hasPermission) {
+    // Camera permission denied by user - their choice, not actionable
     return /*#__PURE__*/_jsxs(View, {
       style: styles.permissionContainer,
       children: [/*#__PURE__*/_jsx(Text, {
@@ -146,6 +147,7 @@ const QrCodeScannerCamera = ({
     });
   }
   if (device == null) {
+    // No camera device - device limitation, not actionable
     return /*#__PURE__*/_jsx(View, {
       style: styles.permissionContainer,
       children: /*#__PURE__*/_jsx(TextView, {

package/lib/module/Shared/Contexts/AppContext.js

@@ -23,5 +23,7 @@ export default /*#__PURE__*/createContext({
   workflowSteps: [],
   currentWorkflowStep: undefined,
   onCompleted: undefined,
-  onError: undefined
+  onError: undefined,
+  setSessionId: undefined,
+  setBaseUrl: undefined
 });