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

package/lib/internal/calls/call-state-controller.js

@@ -6,7 +6,6 @@ const operators_1 = require('rxjs/operators');
 const call_1 = require('../../models/call');
 const call_state_1 = require('../../models/call-state');
 const callkit_coordinator_1 = require('../../callkit/callkit-coordinator');
-const voice_pn_bridge_1 = require('../voice-pn-bridge');
 /**
  * Central state machine for call management.
  *
@@ -19,6 +18,38 @@ class CallStateController {
     this._calls = new rxjs_1.BehaviorSubject([]);
     this._callMap = new Map();
     this._disposed = false;
+    // 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().
+    this._activeCallId = null;
+    this._handleTelnyxIncomingCall = (telnyxCall, msg) => {
+      console.log('CallStateController: Incoming call received:', telnyxCall.callId);
+      this._handleIncomingCall(telnyxCall, msg, false);
+    };
+    this._handleTelnyxReattachedCall = (telnyxCall, msg) => {
+      console.log('CallStateController: Reattached call received:', telnyxCall.callId);
+      this._handleIncomingCall(telnyxCall, msg, true);
+    };
+    this._handleTelnyxCallStateChanged = (telnyxCall, state) => {
+      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'
+        );
+      }
+    };
+    this._handleTelnyxCallRemoved = (callId) => {
+      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.
+    };
     console.log('CallStateController: Constructor called - instance created');
     // Don't set up client listeners here - client doesn't exist yet
     // Will be called when client is available
@@ -35,18 +66,18 @@ class CallStateController {
   get activeCall$() {
     return this.calls$.pipe(
       (0, operators_1.map)((calls) => {
-        // Find the first call that is not terminated (includes RINGING, CONNECTING, ACTIVE, HELD)
-        return (
-          calls.find(
-            (call) =>
-              call.currentState === call_state_1.TelnyxCallState.RINGING ||
-              call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
-              call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
-              call.currentState === call_state_1.TelnyxCallState.HELD
-          ) || null
-        );
+        const call = this._selectActiveCall(calls);
+        return {
+          call,
+          callId: call?.callId ?? null,
+          state: call?.currentState ?? null,
+        };
       }),
-      (0, operators_1.distinctUntilChanged)()
+      (0, operators_1.distinctUntilChanged)(
+        (previous, current) =>
+          previous.callId === current.callId && previous.state === current.state
+      ),
+      (0, operators_1.map)(({ call }) => call)
     );
   }
   /**
@@ -59,16 +90,7 @@ class CallStateController {
    * Current active call (synchronous access)
    */
   get currentActiveCall() {
-    const calls = this.currentCalls;
-    return (
-      calls.find(
-        (call) =>
-          call.currentState === call_state_1.TelnyxCallState.RINGING ||
-          call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
-          call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
-          call.currentState === call_state_1.TelnyxCallState.HELD
-      ) || null
-    );
+    return this._selectActiveCall(this.currentCalls);
   }
   /**
    * Access any active call tracked by the client.
@@ -94,6 +116,32 @@ class CallStateController {
       console.warn('CallStateController: Could not find call to set connecting:', callId);
     }
   }
+  /**
+   * 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) {
+    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() {
+    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
@@ -106,6 +154,31 @@ class CallStateController {
     }
     return null;
   }
+  /**
+   * Select the active call, preferring the explicitly-tracked call ID
+   * over the first-match heuristic.
+   */
+  _selectActiveCall(calls) {
+    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.
+   */
+  _isNonTerminal(call) {
+    return (
+      call.currentState === call_state_1.TelnyxCallState.RINGING ||
+      call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
+      call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
+      call.currentState === call_state_1.TelnyxCallState.HELD
+    );
+  }
   /**
    * Initialize client listeners when the Telnyx client becomes available
    * This should be called by the session manager after client creation
@@ -133,7 +206,10 @@ 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);
       // Create our wrapper Call object
@@ -154,6 +230,18 @@ class CallStateController {
       throw error;
     }
   }
+  /**
+   * Normalize public custom headers into the format expected by the underlying SDK.
+   */
+  _normalizeCustomHeaders(customHeaders) {
+    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)
    */
@@ -182,6 +270,7 @@ class CallStateController {
       }
     }
     this._callMap.clear();
+    this._activeCallId = null;
     this._calls.next([]);
   }
   /**
@@ -192,9 +281,11 @@ class CallStateController {
       return;
     }
     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
     this._calls.complete();
   }
@@ -203,30 +294,22 @@ class CallStateController {
    */
   _setupClientListeners() {
     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, msg) => {
-      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, msg) => {
-      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,
@@ -234,28 +317,21 @@ class CallStateController {
       reattachedListeners
     );
     // Listen for call state changes from the TelnyxRTC client (multi-call support)
-    this._sessionManager.telnyxClient.on('telnyx.call.stateChanged', (telnyxCall, state) => {
-      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) => {
-      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');
   }
+  _removeClientListeners() {
+    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;
+  }
   /**
    * Handle incoming call or reattached call
    */
@@ -330,6 +406,10 @@ class CallStateController {
    */
   _addCall(call) {
     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]);
@@ -342,7 +422,11 @@ class CallStateController {
         callkit_coordinator_1.callKitCoordinator.getCallKitUUID(telnyxCall);
       if (existingCallKitUUID) {
         console.log(
-          'CallStateController: Call already has CallKit integration, skipping duplicate report:',
+          'CallStateController: Linking push-created CallKit call to its signaling call:',
+          existingCallKitUUID
+        );
+        callkit_coordinator_1.callKitCoordinator.linkExistingCallKitCall(
+          telnyxCall,
           existingCallKitUUID
         );
       } else if (call.isIncoming) {
@@ -367,16 +451,20 @@ class CallStateController {
     call.callState$.subscribe((state) => {
       // 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 === call_state_1.TelnyxCallState.ENDED ||
         state === call_state_1.TelnyxCallState.FAILED
       ) {
-        // Clear pending push data so the next app launch isn't mistaken for a push launch
-        voice_pn_bridge_1.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);
       }
     });

package/lib/internal/session/session-manager.d.ts

@@ -14,6 +14,10 @@ export declare class SessionManager {
   private _currentConfig?;
   private _sessionId;
   private _disposed;
+  private _disposing;
+  private _connectionGeneration;
+  private _disposePromise?;
+  private _connectPromise?;
   private _onClientReady?;
   private _onDisconnect?;
   constructor();
@@ -42,6 +46,7 @@ export declare class SessionManager {
    * Get the underlying Telnyx client instance
    */
   get telnyxClient(): TelnyxSDK.TelnyxRTC | undefined;
+  get useTrickleIce(): boolean;
   /**
    * Connect using credential authentication
    */
@@ -75,14 +80,17 @@ export declare class SessionManager {
    * Handle push notification (async version)
    */
   handlePushNotification(payload: Record<string, any>): Promise<void>;
+  private _hasActiveOrHeldCall;
   /**
    * Dispose of the session manager and clean up resources
    */
-  dispose(): void;
+  dispose(): Promise<void>;
   /**
    * Internal method to establish connection with or without push notification handling
    */
   private _connect;
+  private _dispose;
+  private _runConnect;
   /**
    * Set up event listeners for the Telnyx client
    */
@@ -95,4 +103,11 @@ export declare class SessionManager {
    * Generate a unique session ID
    */
   private _generateSessionId;
+  private _assertCanStartConnection;
+  private _isTeardownActive;
+  private _isConnectCanceled;
+  private _throwIfConnectCanceled;
+  private _createConnectCanceledError;
+  private _disconnectClient;
+  private _disconnectAndForgetClient;
 }