@trustchex/react-native-sdk 1.381.0 → 1.409.0

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

@@ -29,7 +29,8 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
       CONTRACT_ACCEPTANCE: 'ContractAcceptanceScreen',
       IDENTITY_DOCUMENT_SCAN: 'IdentityDocumentScanningScreen',
       IDENTITY_DOCUMENT_EID_SCAN: 'IdentityDocumentEIDScanningScreen',
-      LIVENESS_CHECK: 'LivenessDetectionScreen'
+      LIVENESS_CHECK: 'LivenessDetectionScreen',
+      VIDEO_CALL: 'VideoCallScreen'
     },
     RESULT: 'ResultScreen'
   };
@@ -69,6 +70,9 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
     if (nextStep.type === 'LIVENESS_CHECK') {
       return routes.DYNAMIC_ROUTES.LIVENESS_CHECK;
     }
+    if (nextStep.type === 'VIDEO_CALL') {
+      return routes.DYNAMIC_ROUTES.VIDEO_CALL;
+    }
     return routes.VERIFICATION_SESSION_CHECK;
   }, [appContext, routes.VERIFICATION_SESSION_CHECK, routes.DYNAMIC_ROUTES.CONTRACT_ACCEPTANCE, routes.DYNAMIC_ROUTES.IDENTITY_DOCUMENT_EID_SCAN, routes.DYNAMIC_ROUTES.IDENTITY_DOCUMENT_SCAN, routes.DYNAMIC_ROUTES.LIVENESS_CHECK, routes.RESULT]);
   const goToNextRoute = useCallback(() => {
@@ -124,8 +128,15 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
           contractIds: [],
           deviceInfo: ''
         },
-        locale: appContext.locale || i18n.language
+        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',
@@ -138,6 +149,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
         appContext.setIsDemoSession?.(false);
         analyticsService.setDemoSession(false);
       }
+      appContext.isTestVideoSession = false;
       navigation.dispatch(CommonActions.reset({
         index: 0,
         routes: [{
@@ -155,7 +167,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
   usePreventRemove(true, ({
     data
   }) => {
-    if (data.action.type === 'RESET') {
+    if (data?.action?.type === 'RESET') {
       navigation.dispatch(data.action);
     }
   });

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

@@ -23,6 +23,7 @@ export default /*#__PURE__*/createContext({
   workflowSteps: [],
   currentWorkflowStep: undefined,
   isDebugNavigated: false,
+  isTestVideoSession: false,
   onCompleted: undefined,
   onError: undefined,
   setSessionId: undefined,

package/lib/module/Shared/Libs/SignalingClient.js

@@ -0,0 +1,128 @@
+"use strict";
+
+import EventSource from 'react-native-sse';
+export class SignalingClient {
+  eventSource = null;
+  constructor(baseUrl, sessionId, onMessage, identificationId, onSessionEnded) {
+    this.baseUrl = baseUrl;
+    this.sessionId = sessionId;
+    this.onMessage = onMessage;
+    this.identificationId = identificationId;
+    this.onSessionEnded = onSessionEnded;
+  }
+  connect() {
+    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 = 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,
+              payload: data.payload,
+              createdAt: data.createdAt
+            });
+          }
+        } catch (e) {
+          console.error('[SignalingClient] Error parsing message:', e);
+        }
+      }
+    };
+    const customEventListener = event => {
+      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,
+            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 => {
+      console.log('[SignalingClient] Received ping');
+      // Just acknowledge by doing nothing, server-side heartbeat keeps connection alive
+    };
+
+    // Session-ended event listener
+    const sessionEndedListener = event => {
+      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', pingListener);
+    this.eventSource.addEventListener('offer', customEventListener);
+    this.eventSource.addEventListener('answer', customEventListener);
+    this.eventSource.addEventListener('ice-candidate', customEventListener);
+    this.eventSource.addEventListener('command', customEventListener);
+    this.eventSource.addEventListener('session-ended', sessionEndedListener);
+  }
+  async send(type, payload) {
+    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;
+    }
+  }
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.removeAllEventListeners();
+      this.eventSource.close();
+      this.eventSource = null;
+      this.onDisconnected?.();
+    }
+  }
+}

package/lib/module/Shared/Libs/analytics.utils.js

@@ -188,6 +188,10 @@ const STEP_EVENT_MAP = {
   liveness_check: {
     started: AnalyticsEventName.LIVENESS_CHECK_STARTED,
     completed: AnalyticsEventName.LIVENESS_CHECK_COMPLETED
+  },
+  video_call: {
+    started: AnalyticsEventName.VIDEO_CALL_STARTED,
+    completed: AnalyticsEventName.VIDEO_CALL_COMPLETED
   }
 };
 function getStepEventName(stepType, suffix) {

package/lib/module/Shared/Libs/deeplink.utils.js

@@ -12,7 +12,7 @@ const handleDeepLink = ({
   let baseUrl = '';
   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') {
@@ -20,6 +20,14 @@ const handleDeepLink = ({
       debugLog('handleDeepLink', 'Found baseUrl:', baseUrl);
     }
   }
+
+  // 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

package/lib/module/Shared/Libs/http-client.js

@@ -47,6 +47,10 @@ const request = async (httpMethod, url, body, simulatedResponse) => {
   const startTime = Date.now();
   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,
@@ -57,11 +61,16 @@ const request = async (httpMethod, url, body, simulatedResponse) => {
     });
     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/lib/module/Shared/Libs/promise.utils.js

@@ -2,16 +2,30 @@
 
 const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
   let retries = 0;
+  let lastError;
   let result;
   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/lib/module/Shared/Libs/status-bar.utils.js

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

package/lib/module/Shared/Services/DataUploadService.js

@@ -0,0 +1,294 @@
+"use strict";
+
+import RNFS from 'react-native-fs';
+import { Platform } from 'react-native';
+import { getSessionKey, encryptWithAes } from "../Libs/crypto.utils.js";
+import mrzUtils from "../Libs/mrz.utils.js";
+import httpClient from "../Libs/http-client.js";
+import { NotFoundError } from "../Libs/http-client.js";
+import { runWithRetry } from "../Libs/promise.utils.js";
+
+/**
+ * Service to upload collected identification data to the backend.
+ * This is used to send data before/during video call so agents can see it.
+ */
+export class DataUploadService {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.apiUrl = `${baseUrl}/api/app/mobile`;
+  }
+  async ensureIdentificationExists(identificationId) {
+    console.log('[DataUploadService] POST', `${this.apiUrl}/identifications/${identificationId}`);
+    await httpClient.post(`${this.apiUrl}/identifications/${identificationId}`, {});
+    console.log('[DataUploadService] ✓ Identification created/verified');
+  }
+
+  /**
+   * Submit document data to the backend (same approach as ResultScreen)
+   */
+  async submitDocumentData(identificationId, scannedDocument, sessionKey) {
+    if (!scannedDocument || scannedDocument.documentType === 'UNKNOWN') {
+      console.log('[DataUploadService] No document data to submit');
+      return;
+    }
+    const mrzFields = scannedDocument.mrzFields;
+    if (!mrzFields) {
+      console.log('[DataUploadService] No MRZ fields to submit');
+      return;
+    }
+    const identificationDocument = {
+      type: mrzFields.documentCode,
+      name: mrzFields.firstName,
+      surname: mrzFields.lastName,
+      gender: this.getGenderEnumType(mrzFields.sex),
+      number: mrzFields.documentNumber,
+      country: mrzFields.issuingState,
+      barcodeValue: scannedDocument.barcodeValue,
+      personalNumber: mrzFields.personalNumber || mrzFields.optional1,
+      birthDate: mrzUtils.convertMRZDateToISODate(mrzFields.birthDate),
+      expiryDate: mrzUtils.convertMRZDateToISODate(mrzFields.expirationDate),
+      dataSource: scannedDocument.dataSource,
+      mrzText: scannedDocument.mrzText
+    };
+    console.log('[DataUploadService] Submitting document data:', identificationDocument.type, identificationDocument.number);
+    const {
+      encryptedData,
+      nonce
+    } = encryptWithAes(JSON.stringify(identificationDocument), sessionKey);
+    console.log('[DataUploadService] POST', `${this.apiUrl}/identifications/${identificationId}/documents`);
+    await runWithRetry(() => httpClient.post(`${this.apiUrl}/identifications/${identificationId}/documents`, {
+      encryptedData,
+      nonce
+    }));
+    console.log('[DataUploadService] ✓ Document data submitted');
+  }
+
+  /**
+   * Upload media files (document images, selfies, etc.)
+   */
+  async uploadMedia(identificationId, scannedDocument, livenessDetection, onProgress) {
+    const uploadFileOptions = {
+      toUrl: `${this.apiUrl}/identifications/${identificationId}/media`,
+      method: 'POST',
+      headers: {
+        Accept: 'application/json'
+      },
+      files: [],
+      progress: res => {
+        const progress = res.totalBytesSent / res.totalBytesExpectedToSend;
+        onProgress?.(progress);
+      }
+    };
+
+    // Add document front image
+    const frontImage = scannedDocument?.frontImage;
+    if (frontImage && frontImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_FRONT_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), frontImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_FRONT_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add document back image
+    const backImage = scannedDocument?.backImage;
+    if (backImage && backImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_BACK_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), backImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_BACK_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add face image from document
+    const faceImage = scannedDocument?.faceImage;
+    if (faceImage && faceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/FACE_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), faceImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add secondary face image from document (optional)
+    const secondaryFaceImage = scannedDocument?.secondaryFaceImage;
+    if (secondaryFaceImage && secondaryFaceImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_SECONDARY_FACE_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), secondaryFaceImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_SECONDARY_FACE_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add hologram image from document (optional)
+    const hologramImage = scannedDocument?.hologramImage;
+    if (hologramImage && hologramImage !== '') {
+      const filePath = `${RNFS.TemporaryDirectoryPath}/DOCUMENT_HOLOGRAM_IMAGE.jpg`;
+      await RNFS.writeFile(decodeURIComponent(filePath), hologramImage, 'base64');
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'DOCUMENT_HOLOGRAM_IMAGE.jpg',
+        filepath: decodeURIComponent(filePath),
+        filetype: 'image/jpeg'
+      });
+    }
+
+    // Add liveness images and selfie from liveness detection
+    if (livenessDetection?.instructions) {
+      for (const instruction of livenessDetection.instructions) {
+        if (instruction?.photo) {
+          const filePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_${instruction.instruction}_IMAGE.jpg`;
+          await RNFS.writeFile(decodeURIComponent(filePath), instruction.photo, 'base64');
+          uploadFileOptions.files.push({
+            name: 'files',
+            filename: `LIVENESS_${instruction.instruction}_IMAGE.jpg`,
+            filepath: decodeURIComponent(filePath),
+            filetype: 'image/jpeg'
+          });
+          if (instruction.instruction === 'LOOK_STRAIGHT_AND_BLINK') {
+            uploadFileOptions.files.push({
+              name: 'files',
+              filename: 'SELFIE_IMAGE.jpg',
+              filepath: decodeURIComponent(filePath),
+              filetype: 'image/jpeg'
+            });
+          }
+        }
+      }
+    }
+
+    // Add liveness video (optional)
+    if (livenessDetection?.videoPath) {
+      let videoFilePath;
+      if (Platform.OS === 'ios') {
+        const tempDir = `${RNFS.TemporaryDirectoryPath}/${new Date().getTime()}`;
+        await RNFS.mkdir(tempDir);
+        videoFilePath = `${tempDir}/LIVENESS_VIDEO.mp4`;
+      } else {
+        videoFilePath = `${RNFS.TemporaryDirectoryPath}/LIVENESS_VIDEO.mp4`;
+      }
+      await RNFS.copyFile(livenessDetection.videoPath, videoFilePath);
+      uploadFileOptions.files.push({
+        name: 'files',
+        filename: 'LIVENESS_VIDEO.mp4',
+        filepath: decodeURIComponent(videoFilePath),
+        filetype: 'video/mp4'
+      });
+    }
+
+    // Skip upload if no files
+    if (uploadFileOptions.files.length === 0) {
+      console.log('[DataUploadService] No media files to upload');
+      return;
+    }
+    console.log('[DataUploadService] Uploading', uploadFileOptions.files.length, 'media files to', uploadFileOptions.toUrl);
+    const response = await runWithRetry(() => RNFS.uploadFiles(uploadFileOptions).promise);
+    console.log('[DataUploadService] Upload response status:', response.statusCode);
+    if (![200, 201, 204].includes(response.statusCode)) {
+      console.error('[DataUploadService] Media upload failed:', response.statusCode, response.body);
+      throw new Error(`Media upload failed: ${response.statusCode}`);
+    }
+    console.log('[DataUploadService] ✓ Media uploaded successfully');
+  }
+
+  /**
+   * Upload all collected data (document + media) before video call
+   */
+  async uploadCollectedData(identificationInfo, onProgress) {
+    const {
+      identificationId,
+      sessionId,
+      scannedDocument,
+      livenessDetection
+    } = identificationInfo;
+    let {
+      authToken
+    } = identificationInfo;
+    if (!identificationId) {
+      console.log('[DataUploadService] No identification ID, skipping upload');
+      return false;
+    }
+    console.log('[DataUploadService] ========== UPLOADING COLLECTED DATA ==========');
+    console.log('[DataUploadService] Identification ID:', identificationId);
+    console.log('[DataUploadService] Has document:', !!scannedDocument);
+    console.log('[DataUploadService] Has liveness:', !!livenessDetection);
+    console.log('[DataUploadService] Has auth token:', !!authToken);
+    try {
+      await runWithRetry(() => this.ensureIdentificationExists(identificationId));
+
+      // Always refresh session key for current session (required for encrypted submission)
+      if (sessionId) {
+        const existingAuthToken = authToken;
+        console.log('[DataUploadService] Getting session key...');
+        try {
+          authToken = await runWithRetry(() => getSessionKey(this.apiUrl, sessionId));
+          console.log('[DataUploadService] ✓ Session key obtained');
+        } catch (error) {
+          if (existingAuthToken) {
+            console.warn('[DataUploadService] Session key refresh failed, using existing token');
+            authToken = existingAuthToken;
+          } else {
+            throw error;
+          }
+        }
+      }
+      if (!authToken) {
+        console.log('[DataUploadService] No session key available, skipping upload');
+        return false;
+      }
+
+      // Step 1: Submit document data (using same encryption as ResultScreen)
+      if (scannedDocument) {
+        onProgress?.(0.1);
+        await runWithRetry(() => this.submitDocumentData(identificationId, scannedDocument, authToken));
+        onProgress?.(0.3);
+      }
+
+      // Step 2: Upload media files (images only, skip video for now - too slow)
+      onProgress?.(0.4);
+      await runWithRetry(() => this.uploadMedia(identificationId, scannedDocument, livenessDetection, p => {
+        onProgress?.(0.4 + p * 0.5);
+      }));
+      onProgress?.(1.0);
+      console.log('[DataUploadService] ✓ All collected data uploaded');
+
+      // Mark media as uploaded during video call
+      identificationInfo.mediaUploadedDuringVideoCall = true;
+
+      // Store the auth token back for future use
+      identificationInfo.authToken = authToken;
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        console.warn('[DataUploadService] Upload skipped: identification is not active anymore');
+        return false;
+      }
+      console.error('[DataUploadService] Failed to upload collected data:', error);
+      return false;
+    }
+  }
+  getGenderEnumType(sex) {
+    switch (sex?.toLowerCase()) {
+      case 'male':
+      case 'm':
+        return 'M';
+      case 'female':
+      case 'f':
+        return 'F';
+      default:
+        return 'X';
+    }
+  }
+}