@trustchex/react-native-sdk 1.381.0 → 1.409.0

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

@@ -0,0 +1,156 @@
+"use strict";
+
+export class VideoSessionService {
+  constructor(baseUrl, identificationId) {
+    this.baseUrl = baseUrl;
+    this.identificationId = identificationId;
+  }
+
+  /**
+   * Get current active video session for customer
+   */
+  async getCurrentSession() {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/current${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to get current session: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('[VideoSessionService] Error getting current session:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Join a video session
+   */
+  async joinSession(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/join${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to join session: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error('[VideoSessionService] Error joining session:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Send a heartbeat to keep the queue-status SSE watchdog alive
+   */
+  async sendHeartbeat(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/heartbeat${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      await fetch(url, {
+        method: 'POST'
+      });
+    } catch {
+      // best-effort, ignore errors
+    }
+  }
+
+  /**
+   * Leave the session queue (drops customer from WAITING state)
+   */
+  async leaveSession(sessionId) {
+    const params = new URLSearchParams();
+    if (this.identificationId) {
+      params.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/join${params.toString() ? '?' + params.toString() : ''}`;
+    try {
+      await fetch(url, {
+        method: 'DELETE'
+      });
+    } catch (error) {
+      console.error('[VideoSessionService] Error leaving session:', error);
+    }
+  }
+
+  /**
+   * Subscribe to queue status updates via Server-Sent Events (SSE)
+   */
+  subscribeToQueueUpdates(sessionId, onUpdate, onError) {
+    try {
+      // Use react-native-sse for real SSE support
+      const EventSource = require('react-native-sse').default;
+      const url = `${this.baseUrl}/api/app/mobile/video-sessions/${sessionId}/queue-status?identificationId=${this.identificationId}`;
+      console.log('[VideoSessionService] Creating SSE connection to:', url);
+      const es = new EventSource(url);
+      let heartbeatInterval = null;
+      es.addEventListener('open', () => {
+        console.log('[VideoSessionService] Queue SSE connected');
+        // Send initial heartbeat
+        this.sendHeartbeat(sessionId).catch(() => {});
+        // Set up periodic heartbeat (every 20s to stay under 30s watchdog)
+        heartbeatInterval = setInterval(() => {
+          this.sendHeartbeat(sessionId).catch(() => {});
+        }, 20000);
+      });
+      es.addEventListener('ping', () => {
+        // Server sent a ping, respond with heartbeat
+        this.sendHeartbeat(sessionId).catch(() => {});
+      });
+      es.addEventListener('message', event => {
+        try {
+          const data = JSON.parse(event.data);
+          console.log('[VideoSessionService] Queue update:', data);
+          if (data.queuePosition !== undefined) {
+            onUpdate(data.queuePosition);
+          }
+
+          // Close connection if no longer waiting
+          if (data.callState !== 'WAITING') {
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+            es.close();
+          }
+        } catch (error) {
+          console.error('[SSE] Failed to parse queue update:', error);
+        }
+      });
+      es.addEventListener('error', event => {
+        console.error('[SSE] Connection error:', event);
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        onError(new Error('SSE connection failed'));
+        es.close();
+      });
+
+      // Return cleanup function
+      return () => {
+        if (heartbeatInterval) clearInterval(heartbeatInterval);
+        es.close();
+      };
+    } catch (error) {
+      console.error('[VideoSessionService] Failed to create SSE connection:', error);
+      onError(error instanceof Error ? error : new Error('Failed to create SSE connection'));
+      return () => {};
+    }
+  }
+}

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";