@telnyx/react-voice-commons-sdk 0.1.1 → 0.1.3

package/lib/internal/voice-pn-bridge.d.ts

@@ -1,3 +1,9 @@
+import { EmitterSubscription } from 'react-native';
+export interface CallActionEvent {
+    action: string;
+    callId?: string;
+    timestamp: number;
+}
 export interface VoicePnBridgeInterface {
     getPendingPushAction(): Promise<{
         action: string | null;
@@ -5,10 +11,106 @@ export interface VoicePnBridgeInterface {
     }>;
     setPendingPushAction(action: string, metadata: string): Promise<boolean>;
     clearPendingPushAction(): Promise<boolean>;
+    getPendingCallAction(): Promise<{
+        action: string | null;
+        callId: string | null;
+        timestamp: number | null;
+    }>;
+    clearPendingCallAction(): Promise<boolean>;
+    endCall(callId: string | null): Promise<boolean>;
+    showOngoingCallNotification(callerName: string | null, callerNumber: string | null, callId: string | null): Promise<boolean>;
+    hideOngoingCallNotification(): Promise<boolean>;
+    hideIncomingCallNotification(): Promise<boolean>;
     getVoipToken(): Promise<string | null>;
     getPendingVoipPush(): Promise<string | null>;
     clearPendingVoipPush(): Promise<boolean>;
     getPendingVoipAction(): Promise<string | null>;
     clearPendingVoipAction(): Promise<boolean>;
 }
-export declare const VoicePnBridge: VoicePnBridgeInterface;
+declare const NativeBridge: VoicePnBridgeInterface;
+/**
+ * Enhanced VoicePnBridge with call control and event handling capabilities
+ */
+export declare class VoicePnBridge {
+    /**
+     * Get any pending push notification action from native side
+     */
+    static getPendingPushAction(): Promise<{
+        action?: string;
+        metadata?: string;
+    }>;
+    /**
+     * Set a pending push notification action to native side
+     */
+    static setPendingPushAction(action: string, metadata: string): Promise<boolean>;
+    /**
+     * Get any pending call action from native side (reliable polling pattern)
+     */
+    static getPendingCallAction(): Promise<{
+        action?: string;
+        callId?: string;
+        timestamp?: number;
+    }>;
+    /**
+     * Clear any pending call action
+     */
+    static clearPendingCallAction(): Promise<boolean>;
+    /**
+     * Clear any pending push notification action
+     */
+    static clearPendingPushAction(): Promise<boolean>;
+    /**
+     * React Native → Android: End/hang up the current call
+     * This will hide the ongoing call notification and notify the native side
+     */
+    static endCall(callId?: string): Promise<boolean>;
+    /**
+     * React Native → Android: Show ongoing call notification to keep app alive
+     * Should be called when a call becomes active to prevent background termination
+     */
+    static showOngoingCallNotification(callerName?: string, callerNumber?: string, callId?: string): Promise<boolean>;
+    /**
+     * React Native → Android: Hide ongoing call notification
+     * Should be called when a call ends to clean up notifications
+     */
+    static hideOngoingCallNotification(): Promise<boolean>;
+    /**
+     * React Native → Android: Hide incoming call notification
+     * Useful for dismissing notifications when call is answered/rejected in app
+     */
+    static hideIncomingCallNotification(): Promise<boolean>;
+    /**
+     * Get VoIP token from native storage
+     */
+    static getVoipToken(): Promise<string | null>;
+    /**
+     * Get pending VoIP push from native storage
+     */
+    static getPendingVoipPush(): Promise<string | null>;
+    /**
+     * Clear pending VoIP push from native storage
+     */
+    static clearPendingVoipPush(): Promise<boolean>;
+    /**
+     * Get pending VoIP action from native storage
+     */
+    static getPendingVoipAction(): Promise<string | null>;
+    /**
+     * Clear pending VoIP action from native storage
+     */
+    static clearPendingVoipAction(): Promise<boolean>;
+    /**
+     * Android → React Native: Listen for immediate call action events from notification buttons
+     * Use this for active calls where immediate response is needed (e.g., ending ongoing calls)
+     */
+    static addCallActionListener(listener: (event: CallActionEvent) => void): EmitterSubscription;
+    /**
+     * Remove call action listener
+     */
+    static removeCallActionListener(subscription: EmitterSubscription): void;
+    /**
+     * Remove all call action listeners
+     */
+    static removeAllCallActionListeners(): void;
+}
+export { NativeBridge as VoicePnBridgeNative };

package/lib/internal/voice-pn-bridge.js

@@ -1,5 +1,212 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VoicePnBridge = void 0;
+exports.VoicePnBridgeNative = exports.VoicePnBridge = void 0;
 const react_native_1 = require("react-native");
-exports.VoicePnBridge = react_native_1.NativeModules.VoicePnBridge;
+const NativeBridge = react_native_1.NativeModules.VoicePnBridge;
+exports.VoicePnBridgeNative = NativeBridge;
+/**
+ * Enhanced VoicePnBridge with call control and event handling capabilities
+ */
+class VoicePnBridge {
+    /**
+     * Get any pending push notification action from native side
+     */
+    static async getPendingPushAction() {
+        try {
+            const result = await NativeBridge.getPendingPushAction();
+            return {
+                action: result?.action || undefined,
+                metadata: result?.metadata || undefined,
+            };
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error getting pending push action:', error);
+            return {};
+        }
+    }
+    /**
+     * Set a pending push notification action to native side
+     */
+    static async setPendingPushAction(action, metadata) {
+        try {
+            return await NativeBridge.setPendingPushAction(action, metadata);
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error setting pending push action:', error);
+            return false;
+        }
+    }
+    /**
+     * Get any pending call action from native side (reliable polling pattern)
+     */
+    static async getPendingCallAction() {
+        try {
+            const result = await NativeBridge.getPendingCallAction();
+            return {
+                action: result?.action || undefined,
+                callId: result?.callId || undefined,
+                timestamp: result?.timestamp || undefined,
+            };
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error getting pending call action:', error);
+            return {};
+        }
+    }
+    /**
+     * Clear any pending call action
+     */
+    static async clearPendingCallAction() {
+        try {
+            return await NativeBridge.clearPendingCallAction();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error clearing pending call action:', error);
+            return false;
+        }
+    }
+    /**
+     * Clear any pending push notification action
+     */
+    static async clearPendingPushAction() {
+        try {
+            return await NativeBridge.clearPendingPushAction();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error clearing pending push action:', error);
+            return false;
+        }
+    }
+    /**
+     * React Native → Android: End/hang up the current call
+     * This will hide the ongoing call notification and notify the native side
+     */
+    static async endCall(callId) {
+        try {
+            return await NativeBridge.endCall(callId || null);
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error ending call:', error);
+            return false;
+        }
+    }
+    /**
+     * React Native → Android: Show ongoing call notification to keep app alive
+     * Should be called when a call becomes active to prevent background termination
+     */
+    static async showOngoingCallNotification(callerName, callerNumber, callId) {
+        try {
+            return await NativeBridge.showOngoingCallNotification(callerName || null, callerNumber || null, callId || null);
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error showing ongoing call notification:', error);
+            return false;
+        }
+    }
+    /**
+     * React Native → Android: Hide ongoing call notification
+     * Should be called when a call ends to clean up notifications
+     */
+    static async hideOngoingCallNotification() {
+        try {
+            return await NativeBridge.hideOngoingCallNotification();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error hiding ongoing call notification:', error);
+            return false;
+        }
+    }
+    /**
+     * React Native → Android: Hide incoming call notification
+     * Useful for dismissing notifications when call is answered/rejected in app
+     */
+    static async hideIncomingCallNotification() {
+        try {
+            return await NativeBridge.hideIncomingCallNotification();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error hiding incoming call notification:', error);
+            return false;
+        }
+    }
+    /**
+     * Get VoIP token from native storage
+     */
+    static async getVoipToken() {
+        try {
+            return await NativeBridge.getVoipToken();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error getting VoIP token:', error);
+            return null;
+        }
+    }
+    /**
+     * Get pending VoIP push from native storage
+     */
+    static async getPendingVoipPush() {
+        try {
+            return await NativeBridge.getPendingVoipPush();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error getting pending VoIP push:', error);
+            return null;
+        }
+    }
+    /**
+     * Clear pending VoIP push from native storage
+     */
+    static async clearPendingVoipPush() {
+        try {
+            return await NativeBridge.clearPendingVoipPush();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error clearing pending VoIP push:', error);
+            return false;
+        }
+    }
+    /**
+     * Get pending VoIP action from native storage
+     */
+    static async getPendingVoipAction() {
+        try {
+            return await NativeBridge.getPendingVoipAction();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error getting pending VoIP action:', error);
+            return null;
+        }
+    }
+    /**
+     * Clear pending VoIP action from native storage
+     */
+    static async clearPendingVoipAction() {
+        try {
+            return await NativeBridge.clearPendingVoipAction();
+        }
+        catch (error) {
+            console.error('VoicePnBridge: Error clearing pending VoIP action:', error);
+            return false;
+        }
+    }
+    /**
+     * Android → React Native: Listen for immediate call action events from notification buttons
+     * Use this for active calls where immediate response is needed (e.g., ending ongoing calls)
+     */
+    static addCallActionListener(listener) {
+        return react_native_1.DeviceEventEmitter.addListener('TelnyxCallAction', listener);
+    }
+    /**
+     * Remove call action listener
+     */
+    static removeCallActionListener(subscription) {
+        subscription.remove();
+    }
+    /**
+     * Remove all call action listeners
+     */
+    static removeAllCallActionListeners() {
+        react_native_1.DeviceEventEmitter.removeAllListeners('TelnyxCallAction');
+    }
+}
+exports.VoicePnBridge = VoicePnBridge;

package/lib/models/call-state.d.ts

@@ -16,7 +16,9 @@ export declare enum TelnyxCallState {
     /** Call has ended normally */
     ENDED = "ENDED",
     /** Call failed to connect or was rejected */
-    FAILED = "FAILED"
+    FAILED = "FAILED",
+    /** Call was dropped due to network issues */
+    DROPPED = "DROPPED"
 }
 /**
  * Type guard to check if a value is a valid TelnyxCallState

package/lib/models/call-state.js

@@ -22,6 +22,8 @@ var TelnyxCallState;
     TelnyxCallState["ENDED"] = "ENDED";
     /** Call failed to connect or was rejected */
     TelnyxCallState["FAILED"] = "FAILED";
+    /** Call was dropped due to network issues */
+    TelnyxCallState["DROPPED"] = "DROPPED";
 })(TelnyxCallState || (exports.TelnyxCallState = TelnyxCallState = {}));
 /**
  * Type guard to check if a value is a valid TelnyxCallState
@@ -70,7 +72,9 @@ exports.CallStateHelpers = {
      * Is the call in a terminated state?
      */
     isTerminated(state) {
-        return state === TelnyxCallState.ENDED || state === TelnyxCallState.FAILED;
+        return (state === TelnyxCallState.ENDED ||
+            state === TelnyxCallState.FAILED ||
+            state === TelnyxCallState.DROPPED);
     },
     /**
      * Is the call in an active state (can have media)?

package/lib/models/call.d.ts

@@ -13,13 +13,15 @@ export declare class Call {
     private readonly _callId;
     private readonly _destination;
     private readonly _isIncoming;
+    private readonly _originalCallerName?;
+    private readonly _originalCallerNumber?;
     private readonly _callState;
     private readonly _isMuted;
     private readonly _isHeld;
     private readonly _duration;
     private _durationTimer?;
     private _startTime?;
-    constructor(_telnyxCall: TelnyxCall, _callId: string, _destination: string, _isIncoming: boolean);
+    constructor(_telnyxCall: TelnyxCall, _callId: string, _destination: string, _isIncoming: boolean, isReattached?: boolean, _originalCallerName?: string, _originalCallerNumber?: string);
     /**
      * Unique identifier for this call
      */
@@ -52,6 +54,24 @@ export declare class Call {
      * Current call duration in seconds (synchronous access)
      */
     get currentDuration(): number;
+    /**
+     * Custom headers received from the WebRTC INVITE message.
+     * These headers are passed during call initiation and can contain application-specific information.
+     * Format should be [{"name": "X-Header-Name", "value": "Value"}] where header names must start with "X-".
+     */
+    get inviteCustomHeaders(): {
+        name: string;
+        value: string;
+    }[] | null;
+    /**
+     * Custom headers received from the WebRTC ANSWER message.
+     * These headers are passed during call acceptance and can contain application-specific information.
+     * Format should be [{"name": "X-Header-Name", "value": "Value"}] where header names must start with "X-".
+     */
+    get answerCustomHeaders(): {
+        name: string;
+        value: string;
+    }[] | null;
     /**
      * Get the underlying Telnyx Call object (for internal use)
      * @internal
@@ -91,12 +111,20 @@ export declare class Call {
     get canResume$(): Observable<boolean>;
     /**
      * Answer the incoming call
+     * @param customHeaders Optional custom headers to include with the answer
      */
-    answer(): Promise<void>;
+    answer(customHeaders?: {
+        name: string;
+        value: string;
+    }[]): Promise<void>;
     /**
      * Hang up the call
+     * @param customHeaders Optional custom headers to include with the hangup request
      */
-    hangup(): Promise<void>;
+    hangup(customHeaders?: {
+        name: string;
+        value: string;
+    }[]): Promise<void>;
     /**
      * Put the call on hold
      */

package/lib/models/call.js

@@ -46,15 +46,22 @@ const react_native_1 = require("react-native");
  * integrate with any state management solution.
  */
 class Call {
-    constructor(_telnyxCall, _callId, _destination, _isIncoming) {
+    constructor(_telnyxCall, _callId, _destination, _isIncoming, isReattached = false, _originalCallerName, _originalCallerNumber) {
         this._telnyxCall = _telnyxCall;
         this._callId = _callId;
         this._destination = _destination;
         this._isIncoming = _isIncoming;
+        this._originalCallerName = _originalCallerName;
+        this._originalCallerNumber = _originalCallerNumber;
         this._callState = new rxjs_1.BehaviorSubject(call_state_1.TelnyxCallState.RINGING);
         this._isMuted = new rxjs_1.BehaviorSubject(false);
         this._isHeld = new rxjs_1.BehaviorSubject(false);
         this._duration = new rxjs_1.BehaviorSubject(0);
+        // Set initial state based on whether this is a reattached call
+        if (isReattached) {
+            console.log('Call: Setting initial state to ACTIVE for reattached call');
+            this._callState.next(call_state_1.TelnyxCallState.ACTIVE);
+        }
         this._setupCallListeners();
     }
     /**
@@ -105,6 +112,22 @@ class Call {
     get currentDuration() {
         return this._duration.value;
     }
+    /**
+     * Custom headers received from the WebRTC INVITE message.
+     * These headers are passed during call initiation and can contain application-specific information.
+     * Format should be [{"name": "X-Header-Name", "value": "Value"}] where header names must start with "X-".
+     */
+    get inviteCustomHeaders() {
+        return this._telnyxCall.inviteCustomHeaders;
+    }
+    /**
+     * Custom headers received from the WebRTC ANSWER message.
+     * These headers are passed during call acceptance and can contain application-specific information.
+     * Format should be [{"name": "X-Header-Name", "value": "Value"}] where header names must start with "X-".
+     */
+    get answerCustomHeaders() {
+        return this._telnyxCall.answerCustomHeaders;
+    }
     /**
      * Get the underlying Telnyx Call object (for internal use)
      * @internal
@@ -162,8 +185,9 @@ class Call {
     }
     /**
      * Answer the incoming call
+     * @param customHeaders Optional custom headers to include with the answer
      */
-    async answer() {
+    async answer(customHeaders) {
         if (!call_state_1.CallStateHelpers.canAnswer(this.currentState)) {
             throw new Error(`Cannot answer call in state: ${this.currentState}`);
         }
@@ -180,7 +204,8 @@ class Call {
             // Fallback for Android or when CallKit is not available
             console.log('Call: Setting state to CONNECTING before answering');
             this._callState.next(call_state_1.TelnyxCallState.CONNECTING);
-            await this._telnyxCall.answer();
+            // Pass custom headers to the underlying Telnyx call
+            await this._telnyxCall.answer(customHeaders);
         }
         catch (error) {
             console.error('Failed to answer call:', error);
@@ -189,8 +214,9 @@ class Call {
     }
     /**
      * Hang up the call
+     * @param customHeaders Optional custom headers to include with the hangup request
      */
-    async hangup() {
+    async hangup(customHeaders) {
         if (!call_state_1.CallStateHelpers.canHangup(this.currentState)) {
             throw new Error(`Cannot hang up call in state: ${this.currentState}`);
         }
@@ -205,7 +231,19 @@ class Call {
                 }
             }
             // Fallback for Android or when CallKit is not available
-            await this._telnyxCall.hangup();
+            await this._telnyxCall.hangup(customHeaders);
+            // On Android, also notify the native side to hide ongoing notification
+            if (react_native_1.Platform.OS === 'android') {
+                try {
+                    const { VoicePnBridge } = await Promise.resolve().then(() => __importStar(require('../internal/voice-pn-bridge')));
+                    await VoicePnBridge.endCall(this._callId);
+                    console.log('Call: Notified Android to hide ongoing notification');
+                }
+                catch (error) {
+                    console.error('Call: Failed to notify Android about call end:', error);
+                    // Don't fail the hangup if notification hiding fails
+                }
+            }
         }
         catch (error) {
             console.error('Failed to hang up call:', error);
@@ -314,10 +352,68 @@ class Call {
             // Start duration timer when call becomes active
             if (telnyxState === call_state_1.TelnyxCallState.ACTIVE && !this._startTime) {
                 this._startDurationTimer();
+                // Show ongoing call notification on Android when call becomes active
+                // This covers both locally answered calls and calls that become active from remote side
+                if (react_native_1.Platform.OS === 'android') {
+                    (async () => {
+                        try {
+                            const { VoicePnBridge } = await Promise.resolve().then(() => __importStar(require('../internal/voice-pn-bridge')));
+                            // Extract caller information based on call direction
+                            let callerNumber;
+                            let callerName;
+                            if (this._isIncoming) {
+                                // For incoming calls, use the remote caller ID (who's calling us)
+                                callerNumber = this._telnyxCall.remoteCallerIdNumber;
+                                callerName = this._telnyxCall.remoteCallerIdName;
+                            }
+                            else {
+                                // For outgoing calls, use our own caller ID (what we're showing to them)
+                                // These are the values we set when making the call
+                                callerNumber = this._telnyxCall.localCallerIdNumber || this._originalCallerNumber;
+                                callerName = this._telnyxCall.localCallerIdName || this._originalCallerName;
+                            }
+                            // Fallback logic for better notification display - avoid "Unknown" when possible
+                            let displayName;
+                            let displayNumber;
+                            if (this._isIncoming) {
+                                // For incoming calls: use caller name or fall back to caller number, then destination
+                                displayName = callerName || callerNumber || this._destination;
+                                displayNumber = callerNumber || this._destination;
+                            }
+                            else {
+                                // For outgoing calls: use our caller ID or descriptive text
+                                displayName = callerName || `${this._destination}`;
+                                displayNumber = callerNumber || this._destination;
+                            }
+                            await VoicePnBridge.showOngoingCallNotification(displayName, displayNumber, this._callId);
+                            console.log('Call: Showed ongoing call notification on Android (call active)', {
+                                isIncoming: this._isIncoming,
+                                callerName: displayName,
+                                callerNumber: displayNumber,
+                            });
+                        }
+                        catch (error) {
+                            console.error('Call: Failed to show ongoing call notification on active:', error);
+                        }
+                    })();
+                }
             }
             // Stop duration timer when call ends
             if (call_state_1.CallStateHelpers.isTerminated(telnyxState)) {
                 this._stopDurationTimer();
+                // Clean up ongoing call notification on Android when call ends
+                if (react_native_1.Platform.OS === 'android') {
+                    (async () => {
+                        try {
+                            const { VoicePnBridge } = await Promise.resolve().then(() => __importStar(require('../internal/voice-pn-bridge')));
+                            await VoicePnBridge.endCall(this._callId);
+                            console.log('Call: Cleaned up ongoing call notification (call terminated)');
+                        }
+                        catch (error) {
+                            console.error('Call: Failed to clean up ongoing call notification on termination:', error);
+                        }
+                    })();
+                }
             }
         });
     }
@@ -331,6 +427,8 @@ class Call {
             case 'ringing':
             case 'new':
                 return call_state_1.TelnyxCallState.RINGING;
+            case 'connecting':
+                return call_state_1.TelnyxCallState.CONNECTING;
             case 'active':
             case 'answered':
                 return call_state_1.TelnyxCallState.ACTIVE;
@@ -342,6 +440,8 @@ class Call {
             case 'failed':
             case 'rejected':
                 return call_state_1.TelnyxCallState.FAILED;
+            case 'dropped':
+                return call_state_1.TelnyxCallState.DROPPED;
             default:
                 console.warn(`Unknown call state: ${telnyxState}`);
                 return call_state_1.TelnyxCallState.RINGING;