@trustchex/react-native-sdk 1.381.0 → 1.409.0

package/src/Shared/Components/EIDScanner.tsx

@@ -91,7 +91,6 @@ const EIDScanner = ({
   const appContext = React.useContext(AppContext);
   const [voiceGuidanceMessage, setVoiceGuidanceMessage] = useState<string>();
   const [attemptNumber, setAttemptNumber] = useState<number>(0);
-  const lastVoiceGuidanceMessage = useRef<string>('');
 
   const readNFC = useCallback(async () => {
     const startTime = Date.now();
@@ -102,7 +101,6 @@ const EIDScanner = ({
     setIsScanned(false);
     setProgress(0);
     setProgressStage('');
-    lastVoiceGuidanceMessage.current = '';
     resetLastMessage();
 
     // Track EID scan start using analytics helper
@@ -365,10 +363,8 @@ const EIDScanner = ({
   useEffect(() => {
     if (
       voiceGuidanceMessage &&
-      appContext.currentWorkflowStep?.data?.voiceGuidanceActive &&
-      voiceGuidanceMessage !== lastVoiceGuidanceMessage.current
+      appContext.currentWorkflowStep?.data?.voiceGuidanceActive
     ) {
-      lastVoiceGuidanceMessage.current = voiceGuidanceMessage;
       speak(voiceGuidanceMessage, true);
     }
   }, [

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -174,6 +174,7 @@ const IdentityDocumentCamera = ({
   const isHologramDetectionInProgress = useRef(false); // Prevent concurrent hologram detection calls
   const isCompletionCallbackInvoked = useRef(false); // Prevent multiple callback invocations when COMPLETED
   const isStepTransitionInProgress = useRef(false); // Prevent duplicate step transitions from rapid frames
+  const isCompletionAnnouncementSpoken = useRef(false); // Prevent duplicate "scan completed" voice guidance
 
   const faceDetectionErrorCount = useRef(0);
   const brightnessHistory = useRef<number[]>([]);
@@ -181,7 +182,6 @@ const IdentityDocumentCamera = ({
   const faceImages = useRef<string[]>([]);
   const hologramImageCountRef = useRef(0);
   const [hologramImageCount, setHologramImageCount] = useState(0);
-  const lastVoiceGuidanceMessage = useRef<string>('');
   const [latestHologramFaceImage, setLatestHologramFaceImage] = useState<
     string | undefined
   >(undefined);
@@ -264,6 +264,7 @@ const IdentityDocumentCamera = ({
       setIsActive(true);
       isCompletionCallbackInvoked.current = false; // Reset callback flag when starting new scan
       isStepTransitionInProgress.current = false;
+      isCompletionAnnouncementSpoken.current = false;
     } else {
       setIsActive(false);
       faceImages.current = [];
@@ -277,9 +278,9 @@ const IdentityDocumentCamera = ({
       lastValidMRZFields.current = null;
       validMRZConsecutiveCount.current = 0;
       cachedBarcode.current = null;
-      lastVoiceGuidanceMessage.current = '';
       isCompletionCallbackInvoked.current = false;
       isStepTransitionInProgress.current = false;
+      isCompletionAnnouncementSpoken.current = false;
       // Clear all captured image states from previous scan
       setCurrentFaceImage(undefined);
       setCurrentHologramImage(undefined);
@@ -293,9 +294,9 @@ const IdentityDocumentCamera = ({
       hologramImageCountRef.current = 0;
       setHologramImageCount(0);
       setLatestHologramFaceImage(undefined);
-      lastVoiceGuidanceMessage.current = '';
       isCompletionCallbackInvoked.current = false; // Reset callback flag on unmount
       isStepTransitionInProgress.current = false;
+      isCompletionAnnouncementSpoken.current = false;
       // Clear all captured image states on unmount
       setCurrentFaceImage(undefined);
       setCurrentHologramImage(undefined);
@@ -322,9 +323,17 @@ const IdentityDocumentCamera = ({
       t
     );
 
-    if (message && message !== lastVoiceGuidanceMessage.current) {
-      lastVoiceGuidanceMessage.current = message;
-      speak(message, true);
+    if (message) {
+      if (nextStep === 'COMPLETED') {
+        if (isCompletionAnnouncementSpoken.current) {
+          return;
+        }
+        isCompletionAnnouncementSpoken.current = true;
+      } else {
+        isCompletionAnnouncementSpoken.current = false;
+      }
+      const shouldBypassInterval = nextStep !== 'COMPLETED';
+      speak(message, shouldBypassInterval);
     }
   }, [
     appContext.currentWorkflowStep?.data?.voiceGuidanceActive,
@@ -365,6 +374,18 @@ const IdentityDocumentCamera = ({
     isStepTransitionInProgress.current = false;
   }, [nextStep]);
 
+  // Update status bar based on guide visibility
+  useEffect(() => {
+    if (hasGuideShown) {
+      // Scanning camera view - use light icons on dark background
+      StatusBar.setBarStyle('light-content', true);
+    } else {
+      // Guide screen with white background - use dark icons
+      StatusBar.setBarStyle('dark-content', true);
+      StatusBar.setBackgroundColor('#ffffff', true);
+    }
+  }, [hasGuideShown]);
+
   // Error flash animation - flash red text when wrong side detected
   useEffect(() => {
     if (status === 'INCORRECT') {
@@ -2261,8 +2282,8 @@ const IdentityDocumentCamera = ({
   return (
     <View style={StyleSheet.absoluteFill}>
       <StatusBar
-        barStyle="light-content"
-        backgroundColor="transparent"
+        barStyle={hasGuideShown ? 'light-content' : 'dark-content'}
+        backgroundColor={hasGuideShown ? 'transparent' : '#ffffff'}
         translucent
       />
       {!hasGuideShown ? (

package/src/Shared/Components/NavigationManager.tsx

@@ -45,6 +45,7 @@ const NavigationManager = forwardRef(
         IDENTITY_DOCUMENT_SCAN: 'IdentityDocumentScanningScreen',
         IDENTITY_DOCUMENT_EID_SCAN: 'IdentityDocumentEIDScanningScreen',
         LIVENESS_CHECK: 'LivenessDetectionScreen',
+        VIDEO_CALL: 'VideoCallScreen',
       },
       RESULT: 'ResultScreen',
     };
@@ -109,6 +110,10 @@ const NavigationManager = forwardRef(
           return routes.DYNAMIC_ROUTES.LIVENESS_CHECK;
         }
 
+        if (nextStep.type === 'VIDEO_CALL') {
+          return routes.DYNAMIC_ROUTES.VIDEO_CALL;
+        }
+
         return routes.VERIFICATION_SESSION_CHECK;
       },
       [
@@ -207,7 +212,14 @@ const NavigationManager = forwardRef(
             deviceInfo: '',
           },
           locale: appContext.locale || i18n.language,
+          // Explicitly reset collected data fields
+          scannedDocument: undefined,
+          livenessDetection: undefined,
+          authToken: undefined,
+          videoSessionId: undefined,
         };
+
+        // Reset branding to defaults while preserving any custom values
         appContext.branding = {
           logoUrl: appContext.branding?.logoUrl || '',
           primaryColor: appContext.branding?.primaryColor || '#000000',
@@ -220,6 +232,7 @@ const NavigationManager = forwardRef(
           appContext.setIsDemoSession?.(false);
           analyticsService.setDemoSession(false);
         }
+        appContext.isTestVideoSession = false;
 
         navigation.dispatch(
           CommonActions.reset({
@@ -238,7 +251,7 @@ const NavigationManager = forwardRef(
     }, [appContext, navigation, routes.VERIFICATION_SESSION_CHECK]);
 
     usePreventRemove(true, ({ data }) => {
-      if (data.action.type === 'RESET') {
+      if (data?.action?.type === 'RESET') {
         navigation.dispatch(data.action);
       }
     });

package/src/Shared/Contexts/AppContext.ts

@@ -18,6 +18,7 @@ export type AppContextType = {
   workflowSteps?: WorkflowStep[];
   currentWorkflowStep?: WorkflowStep;
   isDebugNavigated?: boolean;
+  isTestVideoSession?: boolean;
   onCompleted?: () => void;
   onError?: (error: string) => void;
   setSessionId?: (id: string) => void;
@@ -47,6 +48,7 @@ export default createContext<AppContextType>({
   workflowSteps: [],
   currentWorkflowStep: undefined,
   isDebugNavigated: false,
+  isTestVideoSession: false,
   onCompleted: undefined,
   onError: undefined,
   setSessionId: undefined,

package/src/Shared/Libs/SignalingClient.ts

@@ -0,0 +1,189 @@
+import EventSource, { type EventSourceListener } from 'react-native-sse';
+
+export type SignalingMessageType =
+  | 'offer'
+  | 'answer'
+  | 'ice-candidate'
+  | 'command';
+
+export interface SignalingMessage {
+  id?: string;
+  type: SignalingMessageType;
+  payload: any;
+  createdAt?: string;
+}
+
+export type SignalingEventHandler = (message: SignalingMessage) => void;
+export type SessionEndedHandler = (state: string) => void;
+
+export class SignalingClient {
+  private eventSource: EventSource | null = null;
+  private sessionId: string;
+  private baseUrl: string;
+  private onMessage: SignalingEventHandler;
+  private onConnected?: () => void;
+  private onDisconnected?: () => void;
+  private onSessionEnded?: SessionEndedHandler;
+  private identificationId?: string;
+
+  constructor(
+    baseUrl: string,
+    sessionId: string,
+    onMessage: SignalingEventHandler,
+    identificationId?: string,
+    onSessionEnded?: SessionEndedHandler
+  ) {
+    this.baseUrl = baseUrl;
+    this.sessionId = sessionId;
+    this.onMessage = onMessage;
+    this.identificationId = identificationId;
+    this.onSessionEnded = onSessionEnded;
+  }
+
+  public connect(): void {
+    if (this.eventSource) {
+      this.eventSource.close();
+    }
+
+    const urlParams = new URLSearchParams();
+    if (this.identificationId) {
+      urlParams.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/signaling/stream?${urlParams.toString()}`;
+
+    console.log('[SignalingClient] Connecting to SSE:', url);
+
+    this.eventSource = new EventSource(url, {
+      pollingInterval: 0, // 0 means default/no polling if SSE is real
+    });
+
+    const listener: EventSourceListener = (event) => {
+      if (event.type === 'open') {
+        console.log('[SignalingClient] Connected');
+        this.onConnected?.();
+      } else if (event.type === 'error') {
+        console.error(
+          '[SignalingClient] Connection error:',
+          JSON.stringify(event, null, 2)
+        );
+        this.onDisconnected?.();
+      } else if (event.type === 'message') {
+        try {
+          const data = JSON.parse(event.data || '{}');
+
+          if (
+            ['offer', 'answer', 'ice-candidate', 'command'].includes(data.type)
+          ) {
+            this.onMessage({
+              id: data.id,
+              type: data.type as SignalingMessageType,
+              payload: data.payload,
+              createdAt: data.createdAt,
+            });
+          }
+        } catch (e) {
+          console.error('[SignalingClient] Error parsing message:', e);
+        }
+      }
+    };
+
+    const customEventListener = (event: any) => {
+      try {
+        const data = JSON.parse(event.data || '{}');
+        const eventType = event.type;
+
+        if (
+          ['offer', 'answer', 'ice-candidate', 'command'].includes(eventType)
+        ) {
+          this.onMessage({
+            id: data.id,
+            type: eventType as SignalingMessageType,
+            payload: data.payload,
+            createdAt: data.createdAt,
+          });
+        }
+      } catch (e) {
+        console.error('[SignalingClient] Error parsing custom event:', e);
+      }
+    };
+
+    // Ping handler - server sends pings to keep connection alive
+    const pingListener = (event: any) => {
+      console.log('[SignalingClient] Received ping');
+      // Just acknowledge by doing nothing, server-side heartbeat keeps connection alive
+    };
+
+    // Session-ended event listener
+    const sessionEndedListener = (event: any) => {
+      try {
+        const data = JSON.parse(event.data || '{}');
+        console.log('[SignalingClient] Session ended:', data.state);
+        if (this.onSessionEnded) {
+          this.onSessionEnded(data.state);
+        }
+      } catch (e) {
+        console.error(
+          '[SignalingClient] Error parsing session-ended event:',
+          e
+        );
+      }
+    };
+
+    this.eventSource.addEventListener('open', listener);
+    this.eventSource.addEventListener('message', listener);
+    this.eventSource.addEventListener('error', listener);
+    this.eventSource.addEventListener('ping' as any, pingListener);
+    this.eventSource.addEventListener('offer' as any, customEventListener);
+    this.eventSource.addEventListener('answer' as any, customEventListener);
+    this.eventSource.addEventListener(
+      'ice-candidate' as any,
+      customEventListener
+    );
+    this.eventSource.addEventListener('command' as any, customEventListener);
+    this.eventSource.addEventListener(
+      'session-ended' as any,
+      sessionEndedListener
+    );
+  }
+
+  public async send(type: SignalingMessageType, payload: any): Promise<void> {
+    const urlParams = new URLSearchParams();
+    if (this.identificationId) {
+      urlParams.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/signaling?${urlParams.toString()}`;
+
+    try {
+      const body = {
+        type,
+        data: payload,
+      };
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to send signaling message: ${response.statusText}`
+        );
+      }
+    } catch (error) {
+      console.error('[SignalingClient] Error sending message:', error);
+      throw error;
+    }
+  }
+
+  public disconnect(): void {
+    if (this.eventSource) {
+      this.eventSource.removeAllEventListeners();
+      this.eventSource.close();
+      this.eventSource = null;
+      this.onDisconnected?.();
+    }
+  }
+}

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

@@ -289,6 +289,10 @@ const STEP_EVENT_MAP: Record<
     started: AnalyticsEventName.LIVENESS_CHECK_STARTED,
     completed: AnalyticsEventName.LIVENESS_CHECK_COMPLETED,
   },
+  video_call: {
+    started: AnalyticsEventName.VIDEO_CALL_STARTED,
+    completed: AnalyticsEventName.VIDEO_CALL_COMPLETED,
+  },
 };
 
 function getStepEventName(

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

@@ -10,7 +10,10 @@ const handleDeepLink = ({ url }: { url: string }) => {
   let sessionId = '';
 
   for (let i = 0; i < segments.length; i++) {
-    if (segments[i] === 'verification-session') {
+    if (
+      segments[i] === 'verification-session' ||
+      segments[i] === 'verification-sessions'
+    ) {
       sessionId = segments[i + 1] ?? '';
       debugLog('handleDeepLink', 'Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
@@ -19,6 +22,14 @@ const handleDeepLink = ({ url }: { url: string }) => {
     }
   }
 
+  // If no app-url segment found, derive baseUrl from the URL itself
+  if (!baseUrl && sessionId) {
+    const match = url.match(/^(https?:\/\/[^/]+)/);
+    if (match) {
+      baseUrl = match[1];
+    }
+  }
+
   debugLog('handleDeepLink', 'Returning:', { baseUrl, sessionId });
   return [baseUrl, sessionId];
 };

package/src/Shared/Libs/http-client.ts

@@ -64,6 +64,11 @@ const request = async <TResponse, TBody>(
   let statusCode = 0;
   let success = false;
 
+  console.log(`[HTTP] ${httpMethod} ${url}`);
+  if (body) {
+    console.log('[HTTP] Request body:', JSON.stringify(body).substring(0, 200) + '...');
+  }
+
   try {
     const response = await fetch(url, {
       method: httpMethod,
@@ -75,13 +80,18 @@ const request = async <TResponse, TBody>(
 
     statusCode = response.status;
     success = response.ok;
+    console.log(`[HTTP] Response status: ${statusCode} ${response.ok ? '✓' : '✗'}`);
 
     let responseJson = null;
 
     try {
       responseJson = await response.json();
+      if (responseJson) {
+        console.log('[HTTP] Response body:', JSON.stringify(responseJson).substring(0, 200) + '...');
+      }
     } catch (error) {
       // Invalid JSON response
+      console.log('[HTTP] Response body: (non-JSON)');
     }
 
     // Track API call performance (non-blocking)

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

@@ -4,17 +4,31 @@ const runWithRetry = async <T>(
   delay: number = 1000
 ): Promise<T> => {
   let retries = 0;
+  let lastError: Error | unknown;
   let result: T;
   while (retries < maxRetries) {
     try {
+      if (retries > 0) {
+        console.log(`[Retry] Attempt ${retries + 1}/${maxRetries}...`);
+      }
       result = await fn();
+      if (retries > 0) {
+        console.log(`[Retry] ✓ Success on attempt ${retries + 1}`);
+      }
       return result;
     } catch (error) {
+      lastError = error;
       retries++;
-      await new Promise((resolve) => setTimeout(resolve, delay * retries));
+      console.error(`[Retry] ✗ Attempt ${retries}/${maxRetries} failed:`, error instanceof Error ? error.message : error);
+      if (retries < maxRetries) {
+        const waitTime = delay * retries;
+        console.log(`[Retry] Waiting ${waitTime}ms before retry...`);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+      }
     }
   }
-  throw new Error('Max retries exceeded');
+  console.error('[Retry] ✗ All retries exhausted. Last error:', lastError);
+  throw new Error(`Max retries (${maxRetries}) exceeded. Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 };
 
 export { runWithRetry };

package/src/Shared/Libs/status-bar.utils.ts

@@ -0,0 +1,19 @@
+import { StatusBar } from 'react-native';
+import { useEffect } from 'react';
+
+/**
+ * Configure status bar for white background with dark content for better contrast
+ */
+export const configureStatusBarForWhiteBackground = (): void => {
+  StatusBar.setBarStyle('dark-content', true);
+  StatusBar.setBackgroundColor('#ffffff', true);
+};
+
+/**
+ * Hook to configure status bar for white background on mount
+ */
+export const useStatusBarWhiteBackground = (): void => {
+  useEffect(() => {
+    configureStatusBarForWhiteBackground();
+  }, []);
+};