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

package/src/callkit/callkit.ts

@@ -11,8 +11,21 @@ interface CallKitBridgeInterface {
     handle: string,
     displayName: string
   ): Promise<{ success: boolean; callUUID: string }>;
+  isCallRegistered(callUUID: string): Promise<{ registered: boolean; callUUID: string }>;
   answerCall(callUUID: string): Promise<{ success: boolean; callUUID: string }>;
   endCall(callUUID: string): Promise<{ success: boolean; callUUID: string }>;
+  completeHeldCallAction(
+    callUUID: string,
+    success: boolean
+  ): Promise<{ success: boolean; callUUID: string }>;
+  setCallHeld(
+    callUUID: string,
+    isOnHold: boolean
+  ): Promise<{ success: boolean; callUUID: string; isOnHold: boolean }>;
+  swapCalls(
+    activeCallUUID: string,
+    heldCallUUID: string
+  ): Promise<{ success: boolean; activeCallUUID: string; heldCallUUID: string }>;
   reportCallConnected(callUUID: string): Promise<{ success: boolean }>;
   reportCallEnded(callUUID: string, reason: number): Promise<{ success: boolean }>;
   updateCall(callUUID: string, displayName: string, handle: string): Promise<{ success: boolean }>;
@@ -31,13 +44,14 @@ export enum CallEndReason {
 // CallKit event types
 export interface CallKitEvent {
   callUUID: string;
+  isOnHold?: boolean;
   [key: string]: any;
 }
 
 class CallKitManager {
   private bridge: CallKitBridgeInterface | null = null;
   private eventEmitter: NativeEventEmitter | null = null;
-  private listeners: Map<string, (event: CallKitEvent) => void> = new Map();
+  private listeners: Map<string, Set<(event: CallKitEvent) => void>> = new Map();
 
   /**
    * Normalize UUID to lowercase for consistent handling in React Native
@@ -100,6 +114,12 @@ class CallKitManager {
       this.notifyListeners('endCall', normalizedEvent);
     });
 
+    this.eventEmitter.addListener('CallKitDidPerformHeldCallAction', (event) => {
+      const normalizedEvent = this.normalizeEvent(event);
+      console.log('CallKit: Received held call action', normalizedEvent);
+      this.notifyListeners('heldCall', normalizedEvent);
+    });
+
     this.eventEmitter.addListener('CallKitDidReceivePush', (event) => {
       const normalizedEvent = this.normalizeEvent(event);
       console.log('CallKit: Received push notification event', normalizedEvent);
@@ -108,9 +128,11 @@ class CallKitManager {
   }
 
   private notifyListeners(eventType: string, event: CallKitEvent) {
-    const listener = this.listeners.get(eventType);
-    if (listener) {
-      listener(event);
+    const listeners = this.listeners.get(eventType);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(event);
+      }
     }
   }
 
@@ -189,6 +211,23 @@ class CallKitManager {
     }
   }
 
+  public async isCallRegistered(callUUID: string): Promise<boolean> {
+    if (!this.bridge || Platform.OS !== 'ios') {
+      return false;
+    }
+
+    try {
+      const result = await this.bridge.isCallRegistered(this.denormalizeUUID(callUUID));
+      return result.registered;
+    } catch (error) {
+      console.error('CallKit: Failed to check incoming call registration', {
+        callUUID,
+        error,
+      });
+      return false;
+    }
+  }
+
   public async endCall(callUUID: string): Promise<boolean> {
     if (!this.bridge || Platform.OS !== 'ios') {
       console.warn('CallKit: Not available on this platform');
@@ -208,6 +247,52 @@ class CallKitManager {
     }
   }
 
+  public async completeHeldCallAction(callUUID: string, success: boolean): Promise<boolean> {
+    if (!this.bridge || Platform.OS !== 'ios') {
+      return false;
+    }
+
+    try {
+      const uppercaseUUID = this.denormalizeUUID(callUUID);
+      const result = await this.bridge.completeHeldCallAction(uppercaseUUID, success);
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to complete held call action', error);
+      return false;
+    }
+  }
+
+  public async setCallHeld(callUUID: string, isOnHold: boolean): Promise<boolean> {
+    if (!this.bridge || Platform.OS !== 'ios') {
+      return false;
+    }
+
+    try {
+      const result = await this.bridge.setCallHeld(this.denormalizeUUID(callUUID), isOnHold);
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to change held state', { callUUID, isOnHold, error });
+      return false;
+    }
+  }
+
+  public async swapCalls(activeCallUUID: string, heldCallUUID: string): Promise<boolean> {
+    if (!this.bridge || Platform.OS !== 'ios') {
+      return false;
+    }
+
+    try {
+      const result = await this.bridge.swapCalls(
+        this.denormalizeUUID(activeCallUUID),
+        this.denormalizeUUID(heldCallUUID)
+      );
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to swap calls', error);
+      return false;
+    }
+  }
+
   public async reportCallConnected(callUUID: string): Promise<boolean> {
     if (!this.bridge || Platform.OS !== 'ios') {
       return false;
@@ -283,23 +368,36 @@ class CallKitManager {
   // Event listener management
 
   public onStartCall(listener: (event: CallKitEvent) => void): () => void {
-    this.listeners.set('startCall', listener);
-    return () => this.listeners.delete('startCall');
+    return this.addListener('startCall', listener);
   }
 
   public onAnswerCall(listener: (event: CallKitEvent) => void): () => void {
-    this.listeners.set('answerCall', listener);
-    return () => this.listeners.delete('answerCall');
+    return this.addListener('answerCall', listener);
   }
 
   public onEndCall(listener: (event: CallKitEvent) => void): () => void {
-    this.listeners.set('endCall', listener);
-    return () => this.listeners.delete('endCall');
+    return this.addListener('endCall', listener);
+  }
+
+  public onHeldCall(listener: (event: CallKitEvent) => void): () => void {
+    return this.addListener('heldCall', listener);
   }
 
   public onReceivePush(listener: (event: CallKitEvent) => void): () => void {
-    this.listeners.set('receivePush', listener);
-    return () => this.listeners.delete('receivePush');
+    return this.addListener('receivePush', listener);
+  }
+
+  private addListener(eventType: string, listener: (event: CallKitEvent) => void): () => void {
+    const listeners = this.listeners.get(eventType) ?? new Set();
+    listeners.add(listener);
+    this.listeners.set(eventType, listeners);
+
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.listeners.delete(eventType);
+      }
+    };
   }
 
   // Utility methods

package/src/hooks/useAppStateHandler.ts

@@ -34,8 +34,13 @@ export const useAppStateHandler = ({
         log('AppStateHandler: App went to background, checking for active calls...');
 
         const connectionState = voipClient.currentConnectionState;
-        if (connectionState !== TelnyxConnectionState.CONNECTED) {
-          log('AppStateHandler: Not connected, skipping background handling');
+        const shouldHandleBackgroundConnection =
+          connectionState === TelnyxConnectionState.CONNECTED ||
+          connectionState === TelnyxConnectionState.CONNECTING ||
+          connectionState === TelnyxConnectionState.RECONNECTING;
+
+        if (!shouldHandleBackgroundConnection) {
+          log('AppStateHandler: Not connected or connecting, skipping background handling');
           appState.current = nextAppState;
           return;
         }

package/src/index.ts

@@ -55,5 +55,8 @@ export type { Call as TelnyxCall } from '@telnyx/react-native-voice-sdk';
 // Export CallKit functionality
 export * from './callkit';
 
+// Native push notification helpers
+export { VoicePnBridge } from './internal/voice-pn-bridge';
+
 // Export hooks
 export { useAppReadyNotifier } from './hooks/useAppReadyNotifier';

package/src/internal/CallKitHandler.tsx

@@ -1,10 +1,8 @@
 import React, { useEffect, useRef } from 'react';
 import { Platform, DeviceEventEmitter } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { useTelnyxVoice } from '../context/TelnyxVoiceContext';
-import { callKitCoordinator } from '../callkit';
 
-// Global flag to ensure only one CallKitHandler is active
+// Global flag to ensure only one CallKitHandler is active.
 let isCallKitHandlerActive = false;
 
 interface CallData {
@@ -28,6 +26,9 @@ interface CallKitHandlerProps {
  * Internal CallKit handler for iOS push notifications
  * This component is automatically included in TelnyxVoiceApp
  *
+ * The active instance removes only its own DeviceEventEmitter subscriptions on
+ * unmount via each listener's `.remove()` method.
+ *
  * @internal - Users should not use this component directly
  */
 export const CallKitHandler: React.FC<CallKitHandlerProps> = ({
@@ -35,11 +36,65 @@ export const CallKitHandler: React.FC<CallKitHandlerProps> = ({
   onNavigateToDialer,
   onNavigateBack,
 }) => {
-  const { voipClient } = useTelnyxVoice();
-
   // Store active calls by CallKit UUID for coordination
   const activeCallsRef = useRef<Map<string, any>>(new Map());
 
+  // DeviceEventEmitter listeners are registered once below, so read callbacks
+  // from refs that are updated during every render rather than stale closures.
+  const onLoginRequiredRef = useRef(onLoginRequired);
+  const onNavigateToDialerRef = useRef(onNavigateToDialer);
+  const onNavigateBackRef = useRef(onNavigateBack);
+
+  onLoginRequiredRef.current = onLoginRequired;
+  onNavigateToDialerRef.current = onNavigateToDialer;
+  onNavigateBackRef.current = onNavigateBack;
+
+  const handleIncomingCall = async (eventData: CallData) => {
+    console.log('CallKitHandler: Handling incoming call', {
+      callUUID: eventData.callUUID,
+    });
+
+    // Store the push notification payload
+    await AsyncStorage.setItem('@push_notification_payload', JSON.stringify(eventData.payload));
+
+    // Mark this call as being processed
+    activeCallsRef.current.set(eventData.callUUID, {
+      processing: true,
+      timestamp: Date.now(),
+    });
+
+    // Trigger login required callback if provided
+    if (onLoginRequiredRef.current) {
+      onLoginRequiredRef.current(eventData.payload);
+    }
+  };
+
+  const handleAnswerCall = async (eventData: CallData) => {
+    console.log('CallKitHandler: User answered call via CallKit', {
+      callUUID: eventData.callUUID,
+      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
+    });
+
+    if (onNavigateToDialerRef.current) {
+      onNavigateToDialerRef.current();
+    }
+  };
+
+  const handleEndCall = async (eventData: CallData) => {
+    console.log('CallKitHandler: User ended call via CallKit', {
+      callUUID: eventData.callUUID,
+      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
+    });
+
+    // Clean up our local tracking info
+    activeCallsRef.current.delete(eventData.callUUID);
+    await AsyncStorage.removeItem('@push_notification_payload');
+
+    if (onNavigateBackRef.current) {
+      onNavigateBackRef.current();
+    }
+  };
+
   useEffect(() => {
     if (Platform.OS !== 'ios') return;
 
@@ -51,9 +106,6 @@ export const CallKitHandler: React.FC<CallKitHandlerProps> = ({
     isCallKitHandlerActive = true;
     console.log('CallKitHandler: Setting up DeviceEventEmitter listeners (singleton instance)...');
 
-    DeviceEventEmitter.removeAllListeners('incomingVoIPCall');
-    DeviceEventEmitter.removeAllListeners('callKitAction');
-
     const incomingCallListener = DeviceEventEmitter.addListener(
       'incomingVoIPCall',
       async (eventData: CallData) => {
@@ -89,53 +141,6 @@ export const CallKitHandler: React.FC<CallKitHandlerProps> = ({
     };
   }, []);
 
-  const handleIncomingCall = async (eventData: CallData) => {
-    console.log('CallKitHandler: Handling incoming call', {
-      callUUID: eventData.callUUID,
-      hasClient: !!voipClient,
-    });
-
-    // Store the push notification payload
-    await AsyncStorage.setItem('@push_notification_payload', JSON.stringify(eventData.payload));
-
-    // Mark this call as being processed
-    activeCallsRef.current.set(eventData.callUUID, {
-      processing: true,
-      timestamp: Date.now(),
-    });
-
-    // Trigger login required callback if provided
-    if (onLoginRequired) {
-      onLoginRequired(eventData.payload);
-    }
-  };
-
-  const handleAnswerCall = async (eventData: CallData) => {
-    console.log('CallKitHandler: User answered call via CallKit', {
-      callUUID: eventData.callUUID,
-      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
-    });
-
-    if (onNavigateToDialer) {
-      onNavigateToDialer();
-    }
-  };
-
-  const handleEndCall = async (eventData: CallData) => {
-    console.log('CallKitHandler: User ended call via CallKit', {
-      callUUID: eventData.callUUID,
-      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
-    });
-
-    // Clean up our local tracking info
-    activeCallsRef.current.delete(eventData.callUUID);
-    await AsyncStorage.removeItem('@push_notification_payload');
-
-    if (onNavigateBack) {
-      onNavigateBack();
-    }
-  };
-
   // This component doesn't render anything, it just handles events
   return null;
 };