@trustchex/react-native-sdk 1.381.0 → 1.464.0

package/src/Shared/Services/VideoSessionService.ts

@@ -0,0 +1,190 @@
+export interface VideoSessionInfo {
+  sessionId: string;
+  identificationId: string;
+  callState: 'WAITING' | 'CONNECTING' | 'ACTIVE' | 'COMPLETED' | 'FAILED';
+  queuePosition?: number;
+  connectedAt?: string;
+}
+
+export class VideoSessionService {
+  private baseUrl: string;
+  private identificationId?: string;
+
+  constructor(baseUrl: string, identificationId?: string) {
+    this.baseUrl = baseUrl;
+    this.identificationId = identificationId;
+  }
+
+  /**
+   * Get current active video session for customer
+   */
+  public async getCurrentSession(): Promise<VideoSessionInfo> {
+    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
+   */
+  public async joinSession(sessionId: string): Promise<VideoSessionInfo> {
+    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
+   */
+  public async sendHeartbeat(sessionId: string): Promise<void> {
+    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)
+   */
+  public async leaveSession(sessionId: string): Promise<void> {
+    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)
+   */
+  public subscribeToQueueUpdates(
+    sessionId: string,
+    onUpdate: (position: number) => void,
+    onError: (error: Error) => void
+  ): () => void {
+    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: ReturnType<typeof setInterval> | null = 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: any) => {
+        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: any) => {
+        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 () => {};
+    }
+  }
+}