@telnyx/react-voice-commons-sdk 0.4.3 → 1.1.0

package/src/internal/calls/call-state-controller.ts

@@ -5,7 +5,9 @@ import { Call } from '../../models/call';
 import { TelnyxCallState } from '../../models/call-state';
 import { SessionManager } from '../session/session-manager';
 import { callKitCoordinator } from '../../callkit/callkit-coordinator';
-import { VoicePnBridge } from '../voice-pn-bridge';
+
+export type CustomHeader = { name: string; value: string };
+export type CustomHeaders = Record<string, string> | CustomHeader[];
 
 /**
  * Central state machine for call management.
@@ -17,11 +19,18 @@ export class CallStateController {
   private readonly _calls = new BehaviorSubject<Call[]>([]);
   private readonly _callMap = new Map<string, Call>();
   private _disposed = false;
+  private _listenerClient?: TelnyxRTC;
 
   // Callbacks for waiting for invite logic (used for push notifications)
   private _isWaitingForInvite?: () => boolean;
   private _onInviteAutoAccepted?: () => void;
 
+  // Explicitly-tracked active call ID for multi-call scenarios.
+  // When set, activeCall$/currentActiveCall prefer this call over the
+  // first-match heuristic. Cleared automatically when the call reaches
+  // a terminal state, or manually via clearActiveCall().
+  private _activeCallId: string | null = null;
+
   constructor(private readonly _sessionManager: SessionManager) {
     console.log('CallStateController: Constructor called - instance created');
     // Don't set up client listeners here - client doesn't exist yet
@@ -41,18 +50,18 @@ export class CallStateController {
   get activeCall$(): Observable<Call | null> {
     return this.calls$.pipe(
       map((calls) => {
-        // Find the first call that is not terminated (includes RINGING, CONNECTING, ACTIVE, HELD)
-        return (
-          calls.find(
-            (call) =>
-              call.currentState === TelnyxCallState.RINGING ||
-              call.currentState === TelnyxCallState.CONNECTING ||
-              call.currentState === TelnyxCallState.ACTIVE ||
-              call.currentState === TelnyxCallState.HELD
-          ) || null
-        );
+        const call = this._selectActiveCall(calls);
+        return {
+          call,
+          callId: call?.callId ?? null,
+          state: call?.currentState ?? null,
+        };
       }),
-      distinctUntilChanged()
+      distinctUntilChanged(
+        (previous, current) =>
+          previous.callId === current.callId && previous.state === current.state
+      ),
+      map(({ call }) => call)
     );
   }
 
@@ -67,16 +76,7 @@ export class CallStateController {
    * Current active call (synchronous access)
    */
   get currentActiveCall(): Call | null {
-    const calls = this.currentCalls;
-    return (
-      calls.find(
-        (call) =>
-          call.currentState === TelnyxCallState.RINGING ||
-          call.currentState === TelnyxCallState.CONNECTING ||
-          call.currentState === TelnyxCallState.ACTIVE ||
-          call.currentState === TelnyxCallState.HELD
-      ) || null
-    );
+    return this._selectActiveCall(this.currentCalls);
   }
 
   /**
@@ -105,6 +105,34 @@ export class CallStateController {
     }
   }
 
+  /**
+   * Explicitly set the active call for multi-call scenarios.
+   * When set, activeCall$ and currentActiveCall prefer this call over
+   * the first-match heuristic. The ID is cleared automatically when the
+   * call reaches a terminal state.
+   * @param callId The ID of the call to mark as active
+   */
+  setActiveCall(callId: string): void {
+    const call = this._callMap.get(callId);
+    if (call) {
+      this._activeCallId = callId;
+      this._calls.next([...this.currentCalls]);
+    } else {
+      console.warn('CallStateController: Cannot set active call - call not found:', callId);
+    }
+  }
+
+  /**
+   * Clear the explicitly-tracked active call ID, reverting to the
+   * first-match heuristic for active call selection.
+   */
+  clearActiveCall(): void {
+    if (this._activeCallId !== null) {
+      this._activeCallId = null;
+      this._calls.next([...this.currentCalls]);
+    }
+  }
+
   /**
    * Find a call by its underlying Telnyx call ID
    * @param telnyxCall The Telnyx call object to find
@@ -118,6 +146,33 @@ export class CallStateController {
     return null;
   }
 
+  /**
+   * Select the active call, preferring the explicitly-tracked call ID
+   * over the first-match heuristic.
+   */
+  private _selectActiveCall(calls: Call[]): Call | null {
+    if (this._activeCallId) {
+      const tracked = calls.find((c) => c.callId === this._activeCallId);
+      if (tracked && this._isNonTerminal(tracked)) {
+        return tracked;
+      }
+    }
+    // Fall back to first non-terminal call (backward compatible)
+    return calls.find((c) => this._isNonTerminal(c)) || null;
+  }
+
+  /**
+   * Check if a call is in a non-terminal (active or connecting) state.
+   */
+  private _isNonTerminal(call: Call): boolean {
+    return (
+      call.currentState === TelnyxCallState.RINGING ||
+      call.currentState === TelnyxCallState.CONNECTING ||
+      call.currentState === TelnyxCallState.ACTIVE ||
+      call.currentState === TelnyxCallState.HELD
+    );
+  }
+
   /**
    * Initialize client listeners when the Telnyx client becomes available
    * This should be called by the session manager after client creation
@@ -138,7 +193,7 @@ export class CallStateController {
     destination: string,
     callerName?: string,
     callerNumber?: string,
-    customHeaders?: Record<string, string>
+    customHeaders?: CustomHeaders
   ): Promise<Call> {
     if (this._disposed) {
       throw new Error('CallStateController has been disposed');
@@ -154,7 +209,10 @@ export class CallStateController {
         destinationNumber: destination,
         callerIdName: callerName,
         callerIdNumber: callerNumber,
-        customHeaders,
+        customHeaders: this._normalizeCustomHeaders(customHeaders),
+        peerConnectionOptions: {
+          useTrickleIce: this._sessionManager.useTrickleIce,
+        },
       };
       const telnyxCall = await this._sessionManager.telnyxClient.newCall(callOptions);
 
@@ -179,6 +237,21 @@ export class CallStateController {
     }
   }
 
+  /**
+   * Normalize public custom headers into the format expected by the underlying SDK.
+   */
+  private _normalizeCustomHeaders(customHeaders?: CustomHeaders): CustomHeader[] | undefined {
+    if (!customHeaders) {
+      return undefined;
+    }
+
+    if (Array.isArray(customHeaders)) {
+      return customHeaders;
+    }
+
+    return Object.entries(customHeaders).map(([name, value]) => ({ name, value }));
+  }
+
   /**
    * Set callbacks for waiting for invite logic (used for push notifications)
    */
@@ -213,6 +286,7 @@ export class CallStateController {
       }
     }
     this._callMap.clear();
+    this._activeCallId = null;
     this._calls.next([]);
   }
 
@@ -225,10 +299,12 @@ export class CallStateController {
     }
 
     this._disposed = true;
+    this._removeClientListeners();
 
     // Dispose of all calls
     this.currentCalls.forEach((call) => call.dispose());
     this._callMap.clear();
+    this._activeCallId = null;
 
     // CallKit cleanup is now handled by CallKitCoordinator automatically
 
@@ -241,40 +317,28 @@ export class CallStateController {
   private _setupClientListeners(): void {
     console.log('CallStateController: Setting up client listeners...');
 
-    if (!this._sessionManager.telnyxClient) {
+    const telnyxClient = this._sessionManager.telnyxClient;
+
+    if (!telnyxClient) {
       console.log('CallStateController: No telnyxClient available yet, skipping listener setup');
       return;
     }
 
+    this._removeClientListeners();
+    this._listenerClient = telnyxClient;
+
     console.log('CallStateController: TelnyxClient found, setting up incoming call listener');
-    console.log(
-      'CallStateController: Client instance:',
-      this._sessionManager.telnyxClient.constructor.name
-    );
+    console.log('CallStateController: Client instance:', telnyxClient.constructor.name);
 
     // Listen for incoming calls
-    this._sessionManager.telnyxClient.on(
-      'telnyx.call.incoming',
-      (telnyxCall: TelnyxCall, msg: any) => {
-        console.log('CallStateController: Incoming call received:', telnyxCall.callId);
-        this._handleIncomingCall(telnyxCall, msg, false);
-      }
-    );
+    telnyxClient.on('telnyx.call.incoming', this._handleTelnyxIncomingCall);
 
     // Listen for reattached calls (after network reconnection)
-    this._sessionManager.telnyxClient.on(
-      'telnyx.call.reattached',
-      (telnyxCall: TelnyxCall, msg: any) => {
-        console.log('CallStateController: Reattached call received:', telnyxCall.callId);
-        this._handleIncomingCall(telnyxCall, msg, true);
-      }
-    );
+    telnyxClient.on('telnyx.call.reattached', this._handleTelnyxReattachedCall);
 
     // Verify listeners are set up
-    const incomingListeners =
-      this._sessionManager.telnyxClient.listenerCount('telnyx.call.incoming');
-    const reattachedListeners =
-      this._sessionManager.telnyxClient.listenerCount('telnyx.call.reattached');
+    const incomingListeners = telnyxClient.listenerCount('telnyx.call.incoming');
+    const reattachedListeners = telnyxClient.listenerCount('telnyx.call.reattached');
     console.log(
       'CallStateController: Listeners registered - incoming:',
       incomingListeners,
@@ -283,34 +347,57 @@ export class CallStateController {
     );
 
     // Listen for call state changes from the TelnyxRTC client (multi-call support)
-    this._sessionManager.telnyxClient.on(
-      'telnyx.call.stateChanged',
-      (telnyxCall: TelnyxCall, state: string) => {
-        console.log(
-          'CallStateController: Call state changed from TelnyxRTC:',
-          telnyxCall.callId,
-          state
-        );
-        // Find our wrapper call and update if needed
-        const call = this.findCallByTelnyxCall(telnyxCall);
-        if (call) {
-          console.log(
-            'CallStateController: Found wrapper call, state sync handled by Call subscription'
-          );
-        }
-      }
-    );
+    telnyxClient.on('telnyx.call.stateChanged', this._handleTelnyxCallStateChanged);
 
     // Listen for call removal events from TelnyxRTC (multi-call support)
-    this._sessionManager.telnyxClient.on('telnyx.call.removed', (callId: string) => {
-      console.log('CallStateController: Call removed from TelnyxRTC:', callId);
-      // The call cleanup is already handled by our call state subscription
-      // This event is informational for logging/debugging
-    });
+    telnyxClient.on('telnyx.call.removed', this._handleTelnyxCallRemoved);
 
     console.log('CallStateController: Client listeners set up successfully');
   }
 
+  private _removeClientListeners(): void {
+    if (!this._listenerClient) {
+      return;
+    }
+
+    this._listenerClient.off('telnyx.call.incoming', this._handleTelnyxIncomingCall);
+    this._listenerClient.off('telnyx.call.reattached', this._handleTelnyxReattachedCall);
+    this._listenerClient.off('telnyx.call.stateChanged', this._handleTelnyxCallStateChanged);
+    this._listenerClient.off('telnyx.call.removed', this._handleTelnyxCallRemoved);
+    this._listenerClient = undefined;
+  }
+
+  private _handleTelnyxIncomingCall = (telnyxCall: TelnyxCall, msg: any): void => {
+    console.log('CallStateController: Incoming call received:', telnyxCall.callId);
+    this._handleIncomingCall(telnyxCall, msg, false);
+  };
+
+  private _handleTelnyxReattachedCall = (telnyxCall: TelnyxCall, msg: any): void => {
+    console.log('CallStateController: Reattached call received:', telnyxCall.callId);
+    this._handleIncomingCall(telnyxCall, msg, true);
+  };
+
+  private _handleTelnyxCallStateChanged = (telnyxCall: TelnyxCall, state: string): void => {
+    console.log(
+      'CallStateController: Call state changed from TelnyxRTC:',
+      telnyxCall.callId,
+      state
+    );
+    // Find our wrapper call and update if needed
+    const call = this.findCallByTelnyxCall(telnyxCall);
+    if (call) {
+      console.log(
+        'CallStateController: Found wrapper call, state sync handled by Call subscription'
+      );
+    }
+  };
+
+  private _handleTelnyxCallRemoved = (callId: string): void => {
+    console.log('CallStateController: Call removed from TelnyxRTC:', callId);
+    // The call cleanup is already handled by our call state subscription.
+    // This event is informational for logging/debugging.
+  };
+
   /**
    * Handle incoming call or reattached call
    */
@@ -399,6 +486,11 @@ export class CallStateController {
   private _addCall(call: Call): void {
     this._callMap.set(call.callId, call);
 
+    // Auto-track as active if no active call is currently set
+    if (this._activeCallId === null) {
+      this._activeCallId = call.callId;
+    }
+
     const currentCalls = this.currentCalls;
     currentCalls.push(call);
     this._calls.next([...currentCalls]);
@@ -413,9 +505,10 @@ export class CallStateController {
 
       if (existingCallKitUUID) {
         console.log(
-          'CallStateController: Call already has CallKit integration, skipping duplicate report:',
+          'CallStateController: Linking push-created CallKit call to its signaling call:',
           existingCallKitUUID
         );
+        callKitCoordinator.linkExistingCallKitCall(telnyxCall, existingCallKitUUID);
       } else if (call.isIncoming) {
         // Handle incoming call with CallKit (only if not already integrated)
         console.log('CallStateController: Reporting incoming call to CallKitCoordinator');
@@ -432,13 +525,19 @@ export class CallStateController {
       // CallKitCoordinator automatically updates CallKit via setupWebRTCCallListeners
       console.log('CallStateController: Call state changed to:', state);
 
+      // Re-emit the call list so calls$/activeCall$ subscribers see state changes.
+      // distinctUntilChanged uses reference equality; without a new array
+      // reference, non-terminal transitions leave activeCall$ stale.
+      this._calls.next([...this.currentCalls]);
+
       // Clean up when call ends - delay to next tick so external subscribers
       // receive the ENDED/FAILED state before the call is disposed
       if (state === TelnyxCallState.ENDED || state === TelnyxCallState.FAILED) {
-        // Clear pending push data so the next app launch isn't mistaken for a push launch
-        VoicePnBridge.clearPendingVoipPush().catch((e) =>
-          console.warn('CallStateController: Failed to clear pending voip push:', e)
-        );
+        // Clear active call ID if the ending call was the tracked active call
+        if (this._activeCallId === call.callId) {
+          this._activeCallId = null;
+        }
+
         setTimeout(() => this._removeCall(call.callId), 0);
       }
     });