@trustchex/react-native-sdk 1.374.0 → 1.409.0

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

@@ -0,0 +1,510 @@
+"use strict";
+
+import { RTCPeerConnection, RTCIceCandidate, RTCSessionDescription, mediaDevices, MediaStream } from 'react-native-webrtc';
+import { SignalingClient } from "../Libs/SignalingClient.js";
+export class WebRTCService {
+  peerConnection = null;
+  localStream = null;
+  remoteStream = null;
+  isFlashOn = false;
+  pendingCandidates = [];
+  hasRemoteDescription = false;
+  isProcessingOffer = false;
+  lastProcessedOfferSdp = null;
+  tracksAdded = false;
+  pendingOffer = null;
+  isSwitchingCamera = false;
+  lastSwitchTime = 0;
+  facingMode = 'user';
+  videoTrackEndedHandler = null;
+  constructor(config) {
+    this.onRemoteStream = config.onRemoteStream;
+    this.onConnectionStateChange = config.onConnectionStateChange;
+    this.onCommand = config.onCommand;
+    this.onSnapshotRequest = config.onSnapshotRequest;
+    this.onLocalStreamUpdate = config.onLocalStreamUpdate;
+    this.baseUrl = config.baseUrl;
+    this.sessionId = config.sessionId;
+    this.identificationId = config.identificationId;
+    this.signalingClient = new SignalingClient(config.baseUrl, config.sessionId, this.handleSignalingMessage.bind(this), config.identificationId, config.onSessionEnded);
+  }
+  async fetchIceServers() {
+    try {
+      const params = this.identificationId ? `?identificationId=${this.identificationId}` : '';
+      const response = await fetch(`${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/ice-servers${params}`);
+      if (!response.ok) return [];
+      const data = await response.json();
+      return Array.isArray(data.iceServers) ? data.iceServers : [];
+    } catch {
+      return [];
+    }
+  }
+  async initialize() {
+    console.log('[WebRTCService] Initializing...');
+    try {
+      // Fetch ICE servers before getUserMedia so peer connection is ready sooner
+      const iceServers = await this.fetchIceServers();
+
+      // Initialize PeerConnection before getUserMedia so signaling can start
+      // immediately — avoids missing the agent's offer while camera init blocks.
+      this.peerConnection = new RTCPeerConnection({
+        iceServers,
+        iceCandidatePoolSize: 2
+      });
+
+      // Set up event handlers before signaling connects.
+      // Use addEventListener instead of property assignment for reliable
+      // delivery in react-native-webrtc (property may be overwritten).
+      this.peerConnection.addEventListener('track', event => {
+        if (event.streams && event.streams[0]) {
+          this.remoteStream = event.streams[0];
+          this.onRemoteStream(this.remoteStream);
+        } else if (event.track) {
+          const existingTracks = this.remoteStream ? this.remoteStream.getTracks() : [];
+          this.remoteStream = new MediaStream([...existingTracks, event.track]);
+          this.onRemoteStream(this.remoteStream);
+        }
+      });
+      this.peerConnection.addEventListener('icecandidate', event => {
+        if (event.candidate) {
+          this.signalingClient.send('ice-candidate', event.candidate.toJSON());
+        }
+      });
+
+      // react-native-webrtc often does not fire connectionstatechange or sets
+      // connectionState to undefined. Use iceconnectionstatechange which is
+      // reliably implemented across all versions.
+      this.peerConnection.addEventListener('iceconnectionstatechange', () => {
+        if (!this.peerConnection) return;
+        const iceState = this.peerConnection.iceConnectionState || 'new';
+        // Map ICE states to the connection states the UI expects
+        const mapped = iceState === 'connected' || iceState === 'completed' ? 'connected' : iceState === 'failed' ? 'failed' : iceState === 'disconnected' ? 'disconnected' : iceState === 'closed' ? 'closed' : iceState;
+        this.onConnectionStateChange(mapped);
+        if (mapped === 'connected') {
+          this.sendTorchAvailability();
+        }
+      });
+
+      // Connect signaling now — peer connection + handlers are ready.
+      // Any offer that arrives before local tracks are added is buffered in
+      // pendingOffer and processed once tracks are attached below.
+      this.signalingClient.connect();
+
+      // Get local stream. Avoid strict min constraints that hang on some Android
+      // devices when the camera cannot satisfy the combination.
+      const stream = await mediaDevices.getUserMedia({
+        audio: true,
+        video: {
+          facingMode: 'user',
+          frameRate: {
+            ideal: 30
+          }
+        }
+      });
+      this.localStream = stream;
+
+      // Add local tracks
+      stream.getTracks().forEach(track => {
+        this.peerConnection?.addTrack(track, stream);
+      });
+      this.tracksAdded = true;
+
+      // If the agent's offer arrived while getUserMedia was pending, process it now.
+      if (this.pendingOffer) {
+        const buffered = this.pendingOffer;
+        this.pendingOffer = null;
+        await this.handleSignalingMessage(buffered);
+      }
+      this.sendTorchAvailability();
+      return stream;
+    } catch (error) {
+      console.error('[WebRTCService] Initialization failed:', error);
+      throw error;
+    }
+  }
+  async handleSignalingMessage(message) {
+    if (!this.peerConnection) return;
+    try {
+      switch (message.type) {
+        case 'offer':
+          {
+            // Buffer the offer until local tracks have been added so the answer
+            // includes the mobile's audio/video tracks.
+            if (!this.tracksAdded) {
+              console.log('[WebRTCService] Offer received before tracks ready, buffering');
+              this.pendingOffer = message;
+              return;
+            }
+
+            // Skip if we're already processing an offer
+            if (this.isProcessingOffer) {
+              console.log('[WebRTCService] Skipping offer - already processing one');
+              return;
+            }
+            const offerSdp = message.payload?.sdp;
+            if (offerSdp && this.lastProcessedOfferSdp === offerSdp) {
+              console.log('[WebRTCService] Skipping offer - duplicate SDP');
+              return;
+            }
+            this.isProcessingOffer = true;
+            console.log('[WebRTCService] Received offer');
+            try {
+              await this.peerConnection.setRemoteDescription(new RTCSessionDescription(message.payload));
+              this.hasRemoteDescription = true;
+              // Add any pending candidates
+              await this.addPendingCandidates();
+              const answer = await this.peerConnection.createAnswer();
+              await this.peerConnection.setLocalDescription(answer);
+              await this.signalingClient.send('answer', {
+                type: answer.type,
+                sdp: answer.sdp
+              });
+              this.lastProcessedOfferSdp = offerSdp ?? null;
+            } finally {
+              this.isProcessingOffer = false;
+            }
+            break;
+          }
+        case 'answer':
+          console.log('[WebRTCService] Received answer');
+          await this.peerConnection.setRemoteDescription(new RTCSessionDescription(message.payload));
+          this.hasRemoteDescription = true;
+          // Add any pending candidates
+          await this.addPendingCandidates();
+          break;
+        case 'ice-candidate':
+          if (message.payload) {
+            const candidate = new RTCIceCandidate(message.payload);
+            if (this.hasRemoteDescription) {
+              console.log('[WebRTCService] Adding ICE candidate');
+              await this.peerConnection.addIceCandidate(candidate);
+            } else {
+              this.pendingCandidates.push(candidate);
+            }
+          }
+          break;
+        case 'command':
+          this.handleCommand(message.payload);
+          break;
+      }
+    } catch (error) {
+      console.error('[WebRTCService] Error handling signaling:', error);
+    }
+  }
+  handleCommand(payload) {
+    console.log('[WebRTCService] Received command:', payload);
+    if (this.onCommand) {
+      this.onCommand(payload);
+    }
+    switch (payload.type) {
+      case 'switchCamera':
+        this.switchCamera();
+        break;
+      case 'toggleFlash':
+        this.toggleFlash();
+        break;
+      case 'captureSnapshot':
+        this.captureSnapshot(payload.requestId);
+        break;
+      case 'takeSnapshot':
+        this.captureSnapshot(payload.requestId);
+        break;
+    }
+  }
+  async addPendingCandidates() {
+    if (this.pendingCandidates.length > 0 && this.peerConnection) {
+      console.log(`[WebRTCService] Adding ${this.pendingCandidates.length} pending ICE candidates`);
+      for (const candidate of this.pendingCandidates) {
+        try {
+          await this.peerConnection.addIceCandidate(candidate);
+        } catch (error) {
+          console.error('[WebRTCService] Error adding pending candidate:', error);
+        }
+      }
+      this.pendingCandidates = [];
+    }
+  }
+  cleanup() {
+    this.localStream?.getTracks().forEach(t => t.stop());
+    this.peerConnection?.close();
+    this.signalingClient.disconnect();
+    this.localStream = null;
+    this.remoteStream = null;
+    this.peerConnection = null;
+    this.pendingCandidates = [];
+    this.hasRemoteDescription = false;
+    this.lastProcessedOfferSdp = null;
+    this.isProcessingOffer = false;
+    this.tracksAdded = false;
+    this.pendingOffer = null;
+  }
+  async switchCamera() {
+    // Debounce: ignore if already switching or within 2s cooldown
+    const now = Date.now();
+    if (this.isSwitchingCamera || now - this.lastSwitchTime < 2000) {
+      console.warn('[WebRTCService] switchCamera ignored — cooldown');
+      return;
+    }
+    if (!this.localStream || !this.peerConnection) return;
+    const videoTrack = this.localStream.getVideoTracks()[0];
+    if (!videoTrack) return;
+    this.isSwitchingCamera = true;
+    this.lastSwitchTime = now;
+    try {
+      const newFacing = this.facingMode === 'user' ? 'environment' : 'user';
+
+      // First, remove the video track from the sender (set to null).
+      // This signals to the encoder to stop, which releases the camera HAL.
+      const senders = this.peerConnection.getSenders?.();
+      let videoSender = null;
+      if (senders) {
+        for (const sender of senders) {
+          if (sender.track?.kind === 'video') {
+            videoSender = sender;
+            await sender.replaceTrack(null);
+            break;
+          }
+        }
+      }
+
+      // Stop the old track to fully release the camera hardware.
+      videoTrack.stop();
+
+      // Small delay to let the camera HAL fully release on Android.
+      await new Promise(res => setTimeout(res, 200));
+
+      // Acquire a new stream from the target camera. Now that the old camera
+      // is fully released, there's no concurrent camera conflict.
+      const newStream = await mediaDevices.getUserMedia({
+        audio: false,
+        video: {
+          facingMode: newFacing,
+          frameRate: {
+            ideal: 30
+          }
+        }
+      });
+      const newVideoTrack = newStream.getVideoTracks()[0];
+      if (!newVideoTrack) {
+        console.warn('[WebRTCService] switchCamera: no video track from getUserMedia');
+        return;
+      }
+
+      // Replace the null track in the sender with the new camera track.
+      // This properly notifies the WebRTC encoder to start encoding from
+      // the new camera — unlike _switchCamera() which only changes the
+      // hardware source without informing the encoder/remote side.
+      if (videoSender) {
+        await videoSender.replaceTrack(newVideoTrack);
+      }
+
+      // Build a new MediaStream with existing audio + new video.
+      const audioTracks = this.localStream.getAudioTracks();
+      this.localStream = new MediaStream([...audioTracks, newVideoTrack]);
+      this.facingMode = newFacing;
+
+      // Listen for the track ending unexpectedly (Android camera HAL power
+      // management can kill the rear camera mid-call). Re-acquire on ended.
+      if (this.videoTrackEndedHandler) {
+        videoTrack.removeEventListener?.('ended', this.videoTrackEndedHandler);
+      }
+      this.videoTrackEndedHandler = () => {
+        console.warn('[WebRTCService] video track ended unexpectedly — re-acquiring');
+        this.reacquireVideoTrack();
+      };
+      newVideoTrack.addEventListener?.('ended', this.videoTrackEndedHandler);
+
+      // Notify the screen to update its local stream reference and remount RTCView
+      this.onLocalStreamUpdate?.(this.localStream);
+    } catch (error) {
+      console.warn('[WebRTCService] switchCamera failed:', error);
+    } finally {
+      this.isSwitchingCamera = false;
+    }
+  }
+  async reacquireVideoTrack() {
+    if (!this.localStream || !this.peerConnection) return;
+    try {
+      const newStream = await mediaDevices.getUserMedia({
+        audio: false,
+        video: {
+          facingMode: this.facingMode,
+          frameRate: {
+            ideal: 30
+          }
+        }
+      });
+      const newVideoTrack = newStream.getVideoTracks()[0];
+      if (!newVideoTrack) return;
+      const senders = this.peerConnection.getSenders?.();
+      if (senders) {
+        for (const sender of senders) {
+          if (sender.track?.kind === 'video' || sender.track === null) {
+            await sender.replaceTrack(newVideoTrack);
+            break;
+          }
+        }
+      }
+      if (this.videoTrackEndedHandler) {
+        newVideoTrack.addEventListener?.('ended', this.videoTrackEndedHandler);
+      }
+      const audioTracks = this.localStream.getAudioTracks();
+      this.localStream = new MediaStream([...audioTracks, newVideoTrack]);
+      this.onLocalStreamUpdate?.(this.localStream);
+    } catch (error) {
+      console.warn('[WebRTCService] reacquireVideoTrack failed:', error);
+    }
+  }
+  async toggleFlash() {
+    const videoTrack = this.localStream?.getVideoTracks()[0];
+    if (!videoTrack) {
+      console.warn('[WebRTCService] No video track available for flash toggle');
+      return;
+    }
+    this.isFlashOn = !this.isFlashOn;
+
+    // applyConstraints is the only reliable method for torch on Android.
+    // Retry up to 3 times with 300ms delay to handle "Camera switch already in progress" race.
+    let success = false;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        await videoTrack.applyConstraints({
+          advanced: [{
+            torch: this.isFlashOn
+          }]
+        });
+        success = true;
+        break;
+      } catch (error) {
+        const msg = error?.message || '';
+        if (msg.includes('Camera switch') && attempt < 2) {
+          await new Promise(res => setTimeout(res, 300));
+          continue;
+        }
+        console.warn('[WebRTCService] Failed to toggle flash:', error);
+        this.isFlashOn = !this.isFlashOn; // revert
+        this.signalingClient.send('command', {
+          type: 'torch_availability',
+          available: false
+        });
+        return;
+      }
+    }
+    if (!success) {
+      this.isFlashOn = !this.isFlashOn; // revert
+      this.signalingClient.send('command', {
+        type: 'torch_availability',
+        available: false
+      });
+      return;
+    }
+
+    // Confirm flash is available now that we know it works
+    this.signalingClient.send('command', {
+      type: 'torch_availability',
+      available: true
+    });
+    this.signalingClient.send('command', {
+      type: 'flash_state',
+      isFlashOn: this.isFlashOn
+    });
+  }
+  sendTorchAvailability() {
+    const videoTrack = this.localStream?.getVideoTracks()[0];
+    if (!videoTrack) {
+      this.signalingClient.send('command', {
+        type: 'torch_availability',
+        available: false
+      });
+      return;
+    }
+    let capabilities;
+    try {
+      capabilities = videoTrack.getCapabilities?.();
+    } catch {
+      capabilities = undefined;
+    }
+
+    // Only trust getCapabilities().torch — _setTorch exists on every Android
+    // track regardless of whether the camera actually has a flash.
+    const available = !!capabilities?.torch;
+    this.signalingClient.send('command', {
+      type: 'torch_availability',
+      available
+    });
+  }
+
+  /**
+   * Handle snapshot capture request. Captures a frame from the local video track directly.
+   */
+  async captureSnapshot(requestId) {
+    console.log('[WebRTCService] Snapshot requested, requestId:', requestId);
+    if (this.onSnapshotRequest && requestId) {
+      // Delegate to parent component which has access to the RTCView
+      this.onSnapshotRequest(requestId);
+      return;
+    }
+
+    // Capture directly from local video track via react-native-webrtc captureFrame()
+    const videoTrack = this.localStream?.getVideoTracks()[0];
+    if (!videoTrack) {
+      console.error('[WebRTCService] No local video track for snapshot');
+      return;
+    }
+    try {
+      const frame = await videoTrack.captureFrame();
+      const base64 = frame?.data;
+      if (!base64) {
+        console.error('[WebRTCService] captureFrame returned no data');
+        return;
+      }
+      await this.uploadSnapshot(requestId, base64);
+    } catch (error) {
+      console.error('[WebRTCService] captureFrame failed:', error);
+    }
+  }
+
+  /**
+   * Upload a captured snapshot image (called by parent component after capturing RTCView).
+   */
+  async uploadSnapshot(requestId, base64Image) {
+    console.log('[WebRTCService] Uploading snapshot, requestId:', requestId);
+    try {
+      const formData = new FormData();
+      // Convert base64 to Blob via fetch data URL (works in React Native)
+      const dataResponse = await fetch(`data:image/jpeg;base64,${base64Image}`);
+      const blob = await dataResponse.blob();
+      formData.append('image', blob);
+      const uploadUrl = `${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/snapshots?identificationId=${this.identificationId}`;
+      const response = await fetch(uploadUrl, {
+        method: 'POST',
+        body: formData
+      });
+      if (response.ok) {
+        const result = await response.json();
+        console.log('[WebRTCService] Snapshot uploaded:', result);
+        await this.signalingClient.send('command', {
+          type: 'snapshotReady',
+          snapshotId: result.snapshotId,
+          url: result.url,
+          createdAt: new Date().toISOString()
+        });
+      } else {
+        const errorText = await response.text();
+        console.error('[WebRTCService] Snapshot upload failed:', response.status, errorText);
+        await this.signalingClient.send('command', {
+          type: 'snapshotError',
+          requestId,
+          error: `Upload failed: ${response.status}`
+        });
+      }
+    } catch (error) {
+      console.error('[WebRTCService] Snapshot upload error:', error);
+      await this.signalingClient.send('command', {
+        type: 'snapshotError',
+        requestId,
+        error: String(error)
+      });
+    }
+  }
+}

package/lib/module/Shared/Types/analytics.types.js

@@ -68,6 +68,8 @@ export let AnalyticsEventName = /*#__PURE__*/function (AnalyticsEventName) {
   AnalyticsEventName["IDENTITY_DOCUMENT_EID_SCAN_COMPLETED"] = "identity_document_eid_scan_completed";
   AnalyticsEventName["LIVENESS_CHECK_STARTED"] = "liveness_check_started";
   AnalyticsEventName["LIVENESS_CHECK_COMPLETED"] = "liveness_check_completed";
+  AnalyticsEventName["VIDEO_CALL_STARTED"] = "video_call_started";
+  AnalyticsEventName["VIDEO_CALL_COMPLETED"] = "video_call_completed";
   // NFC Scan Events (used by trackNFCScan* helpers)
   AnalyticsEventName["NFC_SCAN_STARTED"] = "nfc_scan_started";
   AnalyticsEventName["NFC_SCAN_COMPLETED"] = "nfc_scan_completed";

package/lib/module/Translation/Resources/en.js

@@ -127,6 +127,26 @@ export default {
   'identityDocumentCamera.documentTooLarge': 'Too close. Move back.',
   'identityDocumentCamera.holdSteady': 'Keep device steady',
   'identityDocumentCamera.centerDocument': 'Center document in the frame',
+  'videoCallScreen.guideHeader': 'Get Ready for Video Call',
+  'videoCallScreen.guideText': 'Before you begin, please note the following:',
+  'videoCallScreen.guidePoint1': 'Ensure you are in a quiet environment with good lighting',
+  'videoCallScreen.guidePoint2': 'Have your identity document ready if requested',
+  'videoCallScreen.guidePoint3': 'Make sure your internet connection is stable',
+  'videoCallScreen.guidePoint4': 'The agent will guide you through the verification process',
+  'videoCallScreen.waitingForAgent': 'Waiting for agent...',
+  'videoCallScreen.queuePosition': 'Queue position: {position}',
+  'videoCallScreen.new': 'Initializing connection...',
+  'videoCallScreen.connecting': 'Connecting...',
+  'videoCallScreen.connected': 'Connected',
+  'videoCallScreen.disconnected': 'Disconnected',
+  'videoCallScreen.failed': 'Connection failed',
+  'videoCallScreen.closed': 'Connection closed',
+  'videoCallScreen.permissions_denied': 'Camera permissions required',
+  'videoCallScreen.leaveQueue': 'Leave Queue',
+  'videoCallScreen.closeSession': 'Close Session',
+  'videoCallScreen.closeSessionHint': 'You can close this session and start a new verification',
+  'videoCallScreen.agentInstructions': 'Instructions from Agent',
+  'videoCallScreen.callNotCompleted': 'Video call was not completed. This step is required to proceed.',
   'navigationManager.skipStepWarning': 'Completing this step is recommended for successful verification. Skip anyway?',
   'navigationManager.skipStepLabel': 'Skip This Step'
 };

package/lib/module/Translation/Resources/tr.js

@@ -127,6 +127,26 @@ export default {
   'identityDocumentCamera.documentTooLarge': 'Belge çok yakın. Uzaklaşın.',
   'identityDocumentCamera.holdSteady': 'Cihazı sabit tutun',
   'identityDocumentCamera.centerDocument': 'Belgeyi çerçevede ortalayın',
+  'videoCallScreen.guideHeader': 'Görüntülü Görüşme İçin Hazırlanın',
+  'videoCallScreen.guideText': 'Başlamadan önce lütfen aşağıdaki hususlara dikkat edin:',
+  'videoCallScreen.guidePoint1': 'Sessiz ve iyi aydınlatılmış bir ortamda olduğunuzdan emin olun',
+  'videoCallScreen.guidePoint2': 'İstendiğinde kimlik belgenizi hazır bulundurun',
+  'videoCallScreen.guidePoint3': 'İnternet bağlantınızın stabil olduğundan emin olun',
+  'videoCallScreen.guidePoint4': 'Temsilci sizi doğrulama sürecinde yönlendirecektir',
+  'videoCallScreen.waitingForAgent': 'Temsilci bekleniyor...',
+  'videoCallScreen.queuePosition': 'Sıra konumu: {position}',
+  'videoCallScreen.new': 'Bağlantı başlatılıyor...',
+  'videoCallScreen.connecting': 'Bağlanıyor...',
+  'videoCallScreen.connected': 'Bağlandı',
+  'videoCallScreen.disconnected': 'Bağlantı kesildi',
+  'videoCallScreen.failed': 'Bağlantı başarısız',
+  'videoCallScreen.closed': 'Bağlantı kapatıldı',
+  'videoCallScreen.permissions_denied': 'Kamera izni gerekiyor',
+  'videoCallScreen.leaveQueue': 'Kuyruktan Çık',
+  'videoCallScreen.closeSession': 'Oturumu Kapat',
+  'videoCallScreen.closeSessionHint': 'Bu oturumu kapatıp yeni bir doğrulama başlatabilirsiniz',
+  'videoCallScreen.agentInstructions': 'Temsilciden Talimatlar',
+  'videoCallScreen.callNotCompleted': 'Görüntülü görüşme tamamlanmadı. Devam etmek için bu adım zorunludur.',
   'navigationManager.skipStepWarning': 'Başarılı bir doğrulama için bu adımı tamamlamanız önerilir. Yine de atlamak istiyor musunuz?',
   'navigationManager.skipStepLabel': 'Bu Adımı Atla'
 };

package/lib/module/Trustchex.js

@@ -6,6 +6,7 @@ import { createNativeStackNavigator } from '@react-navigation/native-stack';
 import { View, ActivityIndicator, StyleSheet } from 'react-native';
 import { SafeAreaProvider } from 'react-native-safe-area-context';
 import 'react-native-get-random-values';
+import { registerGlobals } from 'react-native-webrtc';
 import { ThemeProvider } from "./Shared/Contexts/ThemeContext.js";
 import { setDebugMode, setLogLevel, logWarn } from "./Shared/Libs/debug.utils.js";
 import IdentityDocumentEIDScanningScreen from "./Screens/Dynamic/IdentityDocumentEIDScanningScreen.js";
@@ -15,8 +16,10 @@ import ResultScreen from "./Screens/Static/ResultScreen.js";
 import ContractAcceptanceScreen from "./Screens/Dynamic/ContractAcceptanceScreen.js";
 import VerificationSessionCheckScreen from "./Screens/Static/VerificationSessionCheckScreen.js";
 import QrCodeScanningScreen from "./Screens/Static/QrCodeScanningScreen.js";
+import VideoCallScreen from "./Screens/Dynamic/VideoCallScreen.js";
 import OTPVerificationScreen from "./Screens/Static/OTPVerificationScreen.js";
 import MRZTestScreen from "./Screens/Debug/MRZTestScreen.js";
+import BarcodeTestScreen from "./Screens/Debug/BarcodeTestScreen.js";
 import AppContext from "./Shared/Contexts/AppContext.js";
 import DebugNavigationPanel from "./Shared/Components/DebugNavigationPanel.js";
 import i18n from "./Translation/index.js";
@@ -24,6 +27,7 @@ import { initializeTTS } from "./Shared/Libs/tts.utils.js";
 import { analyticsService } from "./Shared/Services/AnalyticsService.js";
 import { AnalyticsEventCategory, AnalyticsEventName } from "./Shared/Types/analytics.types.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+registerGlobals();
 const Stack = createNativeStackNavigator();
 const DEFAULT_BRANDING = {
   logoUrl: '',
@@ -166,9 +170,15 @@ const Trustchex = ({
             }), /*#__PURE__*/_jsx(Stack.Screen, {
               name: "QrCodeScanningScreen",
               component: QrCodeScanningScreen
+            }), /*#__PURE__*/_jsx(Stack.Screen, {
+              name: "VideoCallScreen",
+              component: VideoCallScreen
             }), /*#__PURE__*/_jsx(Stack.Screen, {
               name: "MRZTestScreen",
               component: MRZTestScreen
+            }), /*#__PURE__*/_jsx(Stack.Screen, {
+              name: "BarcodeTestScreen",
+              component: BarcodeTestScreen
             })]
           }), /*#__PURE__*/_jsx(DebugNavigationPanel, {})]
         })

package/lib/module/version.js

@@ -2,4 +2,4 @@
 
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.374.0';
+export const SDK_VERSION = '1.409.0';

package/lib/typescript/src/Screens/Debug/BarcodeTestScreen.d.ts

@@ -0,0 +1,3 @@
+declare const BarcodeTestScreen: () => import("react/jsx-runtime").JSX.Element;
+export default BarcodeTestScreen;
+//# sourceMappingURL=BarcodeTestScreen.d.ts.map

package/lib/typescript/src/Screens/Debug/BarcodeTestScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BarcodeTestScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Debug/BarcodeTestScreen.tsx"],"names":[],"mappings":"AAgDA,QAAA,MAAM,iBAAiB,+CAuJtB,CAAC;AAqHF,eAAe,iBAAiB,CAAC"}

package/lib/typescript/src/Screens/Debug/MRZTestScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MRZTestScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Debug/MRZTestScreen.tsx"],"names":[],"mappings":"AAkBA,QAAA,MAAM,aAAa,+CAiIlB,CAAC;AA6DF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"MRZTestScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Debug/MRZTestScreen.tsx"],"names":[],"mappings":"AAyBA,QAAA,MAAM,aAAa,+CA6LlB,CAAC;AAwFF,eAAe,aAAa,CAAC"}

package/lib/typescript/src/Screens/Dynamic/ContractAcceptanceScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContractAcceptanceScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/ContractAcceptanceScreen.tsx"],"names":[],"mappings":"AA2BA,QAAA,MAAM,wBAAwB,+CAoJ7B,CAAC;AA8BF,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"ContractAcceptanceScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/ContractAcceptanceScreen.tsx"],"names":[],"mappings":"AA6BA,QAAA,MAAM,wBAAwB,+CAyK7B,CAAC;AAiCF,eAAe,wBAAwB,CAAC"}

package/lib/typescript/src/Screens/Dynamic/IdentityDocumentEIDScanningScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentityDocumentEIDScanningScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/IdentityDocumentEIDScanningScreen.tsx"],"names":[],"mappings":"AAoBA,QAAA,MAAM,iCAAiC,+CAsMtC,CAAC;AAoBF,eAAe,iCAAiC,CAAC"}
+{"version":3,"file":"IdentityDocumentEIDScanningScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/IdentityDocumentEIDScanningScreen.tsx"],"names":[],"mappings":"AAqBA,QAAA,MAAM,iCAAiC,+CA2MtC,CAAC;AAoBF,eAAe,iCAAiC,CAAC"}

package/lib/typescript/src/Screens/Dynamic/IdentityDocumentScanningScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentityDocumentScanningScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/IdentityDocumentScanningScreen.tsx"],"names":[],"mappings":"AAoBA,QAAA,MAAM,8BAA8B,+CAkJnC,CAAC;AAgBF,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"IdentityDocumentScanningScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/IdentityDocumentScanningScreen.tsx"],"names":[],"mappings":"AAqBA,QAAA,MAAM,8BAA8B,+CAuJnC,CAAC;AAgBF,eAAe,8BAA8B,CAAC"}

package/lib/typescript/src/Screens/Dynamic/LivenessDetectionScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LivenessDetectionScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/LivenessDetectionScreen.tsx"],"names":[],"mappings":"AA+EA,QAAA,MAAM,uBAAuB,+CAu1B5B,CAAC;AAoFF,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"LivenessDetectionScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/LivenessDetectionScreen.tsx"],"names":[],"mappings":"AAwFA,QAAA,MAAM,uBAAuB,+CA02B5B,CAAC;AAoFF,eAAe,uBAAuB,CAAC"}

package/lib/typescript/src/Screens/Dynamic/VideoCallScreen.d.ts

@@ -0,0 +1,3 @@
+declare const VideoCallScreen: ({ navigation }: any) => import("react/jsx-runtime").JSX.Element;
+export default VideoCallScreen;
+//# sourceMappingURL=VideoCallScreen.d.ts.map

package/lib/typescript/src/Screens/Dynamic/VideoCallScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoCallScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/VideoCallScreen.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,eAAe,GAAI,gBAAgB,GAAG,4CAiiB3C,CAAC;AAyLF,eAAe,eAAe,CAAC"}