@telnyx/react-voice-commons-sdk 0.1.0

package/lib/internal/session/session-manager.js

@@ -0,0 +1,385 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const TelnyxSDK = __importStar(require("@telnyx/react-native-voice-sdk"));
+const connection_state_1 = require("../../models/connection-state");
+const config_1 = require("../../models/config");
+/**
+ * Manages the connection lifecycle to the Telnyx platform.
+ *
+ * This class handles authentication, connection state management,
+ * and automatic reconnection logic.
+ */
+class SessionManager {
+    constructor() {
+        this._connectionState = new rxjs_1.BehaviorSubject(connection_state_1.TelnyxConnectionState.DISCONNECTED);
+        this._disposed = false;
+        this._sessionId = this._generateSessionId();
+    }
+    /**
+     * Observable stream of connection state changes
+     */
+    get connectionState$() {
+        return this._connectionState.asObservable().pipe((0, operators_1.distinctUntilChanged)());
+    }
+    /**
+     * Set callback to be called when the Telnyx client is ready
+     */
+    setOnClientReady(callback) {
+        this._onClientReady = callback;
+    }
+    /**
+     * Current connection state (synchronous access)
+     */
+    get currentState() {
+        return this._connectionState.value;
+    }
+    /**
+     * Current session ID
+     */
+    get sessionId() {
+        return this._sessionId;
+    }
+    /**
+     * Get the underlying Telnyx client instance
+     */
+    get telnyxClient() {
+        return this._telnyxClient;
+    }
+    /**
+     * Connect using credential authentication
+     */
+    async connectWithCredential(config) {
+        if (this._disposed) {
+            throw new Error('SessionManager has been disposed');
+        }
+        this._currentConfig = config;
+        await this._connect();
+    }
+    /**
+     * Connect using token authentication
+     */
+    async connectWithToken(config) {
+        if (this._disposed) {
+            throw new Error('SessionManager has been disposed');
+        }
+        this._currentConfig = config;
+        await this._connect();
+    }
+    /**
+     * Disconnect from the Telnyx platform
+     */
+    async disconnect() {
+        if (this._disposed) {
+            return;
+        }
+        this._currentConfig = undefined;
+        if (this._telnyxClient) {
+            try {
+                await this._telnyxClient.disconnect();
+            }
+            catch (error) {
+                console.error('Error during disconnect:', error);
+            }
+        }
+        this._connectionState.next(connection_state_1.TelnyxConnectionState.DISCONNECTED);
+    }
+    /**
+     * Disable push notifications for the current session
+     */
+    disablePushNotifications() {
+        if (this._telnyxClient && this.currentState === connection_state_1.TelnyxConnectionState.CONNECTED) {
+            // Implementation depends on the actual Telnyx SDK API
+            // This is a placeholder for the actual implementation
+            console.log('Disabling push notifications for session:', this._sessionId);
+        }
+    }
+    /**
+     * Handle push notification with stored config
+     */
+    handlePushNotificationWithConfig(pushMetaData, config) {
+        if (this._disposed) {
+            return;
+        }
+        this._currentConfig = config;
+        // Implementation for handling push notifications
+        // This would integrate with the actual Telnyx SDK push handling
+        console.log('Handling push notification with config:', { pushMetaData, config: config.type });
+    }
+    /**
+     * Handle push notification (async version)
+     */
+    async handlePushNotification(payload) {
+        if (this._disposed) {
+            return;
+        }
+        console.log('SessionManager: RELEASE DEBUG - Processing push notification, payload:', JSON.stringify(payload));
+        // Store the push notification payload for when the client is created
+        this._pendingPushPayload = payload;
+        // If we don't have a config yet but we're processing a push notification,
+        // attempt to load stored config first (for terminated app startup)
+        if (!this._currentConfig && !this._telnyxClient) {
+            console.log('SessionManager: RELEASE DEBUG - No config available, attempting to load from stored config for push notification');
+            try {
+                // Try to retrieve stored credentials and token from AsyncStorage
+                const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+                const storedUsername = await AsyncStorage.getItem('@telnyx_username');
+                const storedPassword = await AsyncStorage.getItem('@telnyx_password');
+                const storedCredentialToken = await AsyncStorage.getItem('@credential_token');
+                const storedPushToken = await AsyncStorage.getItem('@push_token');
+                // Check if we have credential-based authentication data
+                if (storedUsername && storedPassword) {
+                    console.log('SessionManager: RELEASE DEBUG - Found stored credentials, creating config');
+                    const { createCredentialConfig } = require('../../models/config');
+                    this._currentConfig = createCredentialConfig(storedUsername, storedPassword, {
+                        pushNotificationDeviceToken: storedPushToken,
+                    });
+                }
+                // Check if we have token-based authentication data
+                else if (storedCredentialToken) {
+                    console.log('SessionManager: RELEASE DEBUG - Found stored token, creating config');
+                    const { createTokenConfig } = require('../../models/config');
+                    this._currentConfig = createTokenConfig(storedCredentialToken, {
+                        pushNotificationDeviceToken: storedPushToken,
+                    });
+                }
+                if (this._currentConfig) {
+                    console.log('SessionManager: RELEASE DEBUG - Successfully loaded stored config for push notification');
+                }
+                else {
+                    console.log('SessionManager: RELEASE DEBUG - No stored authentication data found');
+                }
+            }
+            catch (error) {
+                console.warn('SessionManager: Failed to load stored config for push notification:', error);
+            }
+        }
+        // If we already have a client, process the push notification immediately
+        if (this._telnyxClient) {
+            console.log('SessionManager: RELEASE DEBUG - Client available, processing push notification immediately');
+            // Use type assertion to access the processVoIPNotification method
+            // This method sets the isCallFromPush flag which is needed for proper push handling
+            if (typeof this._telnyxClient.processVoIPNotification === 'function') {
+                console.log('SessionManager: RELEASE DEBUG - Calling processVoIPNotification with payload:', JSON.stringify(payload));
+                // Extract the actual push notification metadata that the client expects
+                const actualPayload = this._extractPushPayload(payload);
+                this._telnyxClient.processVoIPNotification(actualPayload);
+                console.log('SessionManager: RELEASE DEBUG - Called processVoIPNotification successfully');
+            }
+            else {
+                console.warn('SessionManager: processVoIPNotification method not available on TelnyxRTC client');
+            }
+            // Clear the pending payload since it was processed
+            this._pendingPushPayload = null;
+        }
+        else {
+            console.log('SessionManager: RELEASE DEBUG - No client available, checking if we can trigger immediate connection');
+            // If we have config (either existing or newly loaded from storage) and are disconnected, trigger immediate connection
+            // The _connect() method will process the pending push payload BEFORE calling connect()
+            if (this._currentConfig && this.currentState === connection_state_1.TelnyxConnectionState.DISCONNECTED) {
+                console.log('SessionManager: RELEASE DEBUG - Triggering immediate connection for push notification with config type:', this._currentConfig.type || 'credential');
+                try {
+                    await this._connect();
+                    console.log('SessionManager: RELEASE DEBUG - Successfully connected after push notification trigger');
+                }
+                catch (error) {
+                    console.error('SessionManager: Failed to connect after push notification trigger:', error);
+                }
+            }
+            else {
+                console.log('SessionManager: RELEASE DEBUG - Cannot trigger connection, config available:', !!this._currentConfig, 'current state:', this.currentState);
+                console.log('SessionManager: RELEASE DEBUG - Push payload stored for later processing when client becomes available');
+            }
+        }
+        console.log('SessionManager: RELEASE DEBUG - Push notification handling complete');
+    }
+    /**
+     * Dispose of the session manager and clean up resources
+     */
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        this.disconnect();
+        this._connectionState.complete();
+    }
+    /**
+     * Internal method to establish connection
+     */
+    async _connect() {
+        if (!this._currentConfig) {
+            throw new Error('No configuration provided');
+        }
+        this._connectionState.next(connection_state_1.TelnyxConnectionState.CONNECTING);
+        try {
+            // Clean up existing client
+            if (this._telnyxClient) {
+                await this._telnyxClient.disconnect();
+            }
+            // Create new client instance with authentication options
+            let clientOptions;
+            if ((0, config_1.isCredentialConfig)(this._currentConfig)) {
+                clientOptions = {
+                    login: this._currentConfig.sipUser,
+                    password: this._currentConfig.sipPassword,
+                    logLevel: this._currentConfig.debug ? 'debug' : 'warn',
+                    pushNotificationDeviceToken: this._currentConfig.pushNotificationDeviceToken,
+                };
+                console.log('🔧 SessionManager: Creating TelnyxRTC with credential config, logLevel:', clientOptions.logLevel, 'pushToken:', !!this._currentConfig.pushNotificationDeviceToken);
+            }
+            else if ((0, config_1.isTokenConfig)(this._currentConfig)) {
+                clientOptions = {
+                    login_token: this._currentConfig.token,
+                    logLevel: this._currentConfig.debug ? 'debug' : 'warn',
+                    pushNotificationDeviceToken: this._currentConfig.pushNotificationDeviceToken,
+                };
+                console.log('🔧 SessionManager: Creating TelnyxRTC with token config, logLevel:', clientOptions.logLevel, 'pushToken:', !!this._currentConfig.pushNotificationDeviceToken);
+            }
+            else {
+                throw new Error('Invalid configuration type');
+            }
+            this._telnyxClient = new TelnyxSDK.TelnyxRTC(clientOptions);
+            // CRITICAL: Process any pending push notification payload BEFORE connecting
+            // This ensures voice_sdk_id and other payload variables are set before connect() is called
+            const pendingPushPayload = this._pendingPushPayload;
+            if (pendingPushPayload) {
+                console.log('SessionManager: RELEASE DEBUG - Processing pending push notification BEFORE connect:', JSON.stringify(pendingPushPayload));
+                if (typeof this._telnyxClient.processVoIPNotification === 'function') {
+                    console.log('SessionManager: RELEASE DEBUG - Calling processVoIPNotification BEFORE connect to set voice_sdk_id');
+                    // Extract the actual push notification metadata that the client expects
+                    const actualPayload = this._extractPushPayload(pendingPushPayload);
+                    this._telnyxClient.processVoIPNotification(actualPayload);
+                    console.log('SessionManager: RELEASE DEBUG - Successfully processed pending push notification before connect');
+                }
+                else {
+                    console.warn('SessionManager: processVoIPNotification method not available on new client');
+                }
+                // Clear the pending payload
+                this._pendingPushPayload = null;
+            }
+            this._setupClientListeners();
+            // Set up CallStateController listeners immediately after client creation
+            // This ensures they're ready before any incoming call events are emitted
+            console.log('🔧 SessionManager: Setting up CallStateController listeners before connection...');
+            if (this._onClientReady) {
+                this._onClientReady();
+            }
+            // Connect to the platform AFTER processing push notification
+            console.log('SessionManager: RELEASE DEBUG - About to call connect() after processing push notification');
+            await this._telnyxClient.connect();
+            // Notify that client is ready for event listeners
+            console.log('🔧 SessionManager: Client connected successfully');
+        }
+        catch (error) {
+            console.error('Connection failed:', error);
+            this._connectionState.next(connection_state_1.TelnyxConnectionState.ERROR);
+            throw error;
+        }
+    }
+    /**
+     * Set up event listeners for the Telnyx client
+     */
+    _setupClientListeners() {
+        if (!this._telnyxClient) {
+            return;
+        }
+        this._telnyxClient.on('telnyx.client.ready', () => {
+            console.log('Telnyx client ready');
+            this._connectionState.next(connection_state_1.TelnyxConnectionState.CONNECTED);
+        });
+        this._telnyxClient.on('telnyx.client.error', (error) => {
+            console.error('Telnyx client error:', error);
+            this._connectionState.next(connection_state_1.TelnyxConnectionState.ERROR);
+        });
+        // Note: Socket-level events are not exposed in the current SDK
+        // We'll rely on the client-level events for now
+    }
+    /**
+     * Attempt to reconnect after connection loss
+     */
+    async _attemptReconnection() {
+        if (this._disposed || !this._currentConfig) {
+            return;
+        }
+        // Simple reconnection logic - in production, this should include
+        // exponential backoff and maximum retry attempts
+        setTimeout(async () => {
+            if (this.currentState === connection_state_1.TelnyxConnectionState.RECONNECTING) {
+                try {
+                    await this._connect();
+                }
+                catch (error) {
+                    console.error('Reconnection failed:', error);
+                    // Could implement retry logic here
+                }
+            }
+        }, 3000);
+    }
+    /**
+     * Extract the actual payload metadata from wrapped push notification payload
+     */
+    _extractPushPayload(payload) {
+        // The payload might be wrapped, so we need to extract the core metadata
+        let actualPayload = payload;
+        if (payload.metadata && typeof payload.metadata === 'object') {
+            // If there's a metadata wrapper, use that
+            actualPayload = payload.metadata;
+            console.log('SessionManager: RELEASE DEBUG - Using metadata portion of payload:', JSON.stringify(actualPayload));
+        }
+        else if (payload.action === 'incoming_call' && payload.metadata) {
+            // Handle the case where metadata is a string that needs parsing
+            try {
+                const parsedMetadata = typeof payload.metadata === 'string' ? JSON.parse(payload.metadata) : payload.metadata;
+                actualPayload = parsedMetadata;
+                console.log('SessionManager: RELEASE DEBUG - Using parsed metadata:', JSON.stringify(actualPayload));
+            }
+            catch (error) {
+                console.warn('SessionManager: Failed to parse metadata:', error);
+            }
+        }
+        return actualPayload;
+    }
+    /**
+     * Generate a unique session ID
+     */
+    _generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.SessionManager = SessionManager;

package/lib/internal/user-defaults-helpers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helper functions that use VoicePnBridge for UserDefaults functionality on iOS
+ * These functions provide the same interface as the UserDefaultsModule from main branch
+ * but route through the VoicePnBridge instead
+ */
+export declare function getVoipToken(): Promise<string | null>;
+export declare function getPendingVoipPush(): Promise<string | null>;
+export declare function clearPendingVoipPush(): Promise<boolean>;
+export declare function getPendingVoipAction(): Promise<string | null>;
+export declare function clearPendingVoipAction(): Promise<boolean>;

package/lib/internal/user-defaults-helpers.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVoipToken = getVoipToken;
+exports.getPendingVoipPush = getPendingVoipPush;
+exports.clearPendingVoipPush = clearPendingVoipPush;
+exports.getPendingVoipAction = getPendingVoipAction;
+exports.clearPendingVoipAction = clearPendingVoipAction;
+const voice_pn_bridge_1 = require("./voice-pn-bridge");
+const react_native_1 = require("react-native");
+/**
+ * Helper functions that use VoicePnBridge for UserDefaults functionality on iOS
+ * These functions provide the same interface as the UserDefaultsModule from main branch
+ * but route through the VoicePnBridge instead
+ */
+async function getVoipToken() {
+    if (react_native_1.Platform.OS !== 'ios')
+        return null;
+    try {
+        return await voice_pn_bridge_1.VoicePnBridge.getVoipToken();
+    }
+    catch (error) {
+        console.warn('[UserDefaults] getVoipToken error:', error);
+        return null;
+    }
+}
+async function getPendingVoipPush() {
+    if (react_native_1.Platform.OS !== 'ios')
+        return null;
+    try {
+        return await voice_pn_bridge_1.VoicePnBridge.getPendingVoipPush();
+    }
+    catch (error) {
+        console.warn('[UserDefaults] getPendingVoipPush error:', error);
+        return null;
+    }
+}
+async function clearPendingVoipPush() {
+    if (react_native_1.Platform.OS !== 'ios')
+        return true;
+    try {
+        return await voice_pn_bridge_1.VoicePnBridge.clearPendingVoipPush();
+    }
+    catch (error) {
+        console.warn('[UserDefaults] clearPendingVoipPush error:', error);
+        return false;
+    }
+}
+async function getPendingVoipAction() {
+    if (react_native_1.Platform.OS !== 'ios')
+        return null;
+    try {
+        return await voice_pn_bridge_1.VoicePnBridge.getPendingVoipAction();
+    }
+    catch (error) {
+        console.warn('[UserDefaults] getPendingVoipAction error:', error);
+        return null;
+    }
+}
+async function clearPendingVoipAction() {
+    if (react_native_1.Platform.OS !== 'ios')
+        return true;
+    try {
+        return await voice_pn_bridge_1.VoicePnBridge.clearPendingVoipAction();
+    }
+    catch (error) {
+        console.warn('[UserDefaults] clearPendingVoipAction error:', error);
+        return false;
+    }
+}

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

@@ -0,0 +1,14 @@
+export interface VoicePnBridgeInterface {
+    getPendingPushAction(): Promise<{
+        action: string | null;
+        metadata: string | null;
+    }>;
+    setPendingPushAction(action: string, metadata: string): Promise<boolean>;
+    clearPendingPushAction(): 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;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoicePnBridge = void 0;
+const react_native_1 = require("react-native");
+exports.VoicePnBridge = react_native_1.NativeModules.VoicePnBridge;

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

@@ -0,0 +1,61 @@
+/**
+ * Represents the state of a call in the Telnyx system.
+ *
+ * This enum provides a simplified view of call states, abstracting away
+ * the complexity of the underlying SIP call states.
+ */
+export declare enum TelnyxCallState {
+    /** Call is being initiated (outgoing) or received (incoming) */
+    RINGING = "RINGING",
+    /** Call is connecting after being answered (usually from push notification) */
+    CONNECTING = "CONNECTING",
+    /** Call has been answered and media is flowing */
+    ACTIVE = "ACTIVE",
+    /** Call is on hold */
+    HELD = "HELD",
+    /** Call has ended normally */
+    ENDED = "ENDED",
+    /** Call failed to connect or was rejected */
+    FAILED = "FAILED"
+}
+/**
+ * Type guard to check if a value is a valid TelnyxCallState
+ */
+export declare function isTelnyxCallState(value: any): value is TelnyxCallState;
+/**
+ * Helper functions to determine what actions are available in each state
+ */
+export declare const CallStateHelpers: {
+    /**
+     * Can the call be answered in this state?
+     */
+    canAnswer(state: TelnyxCallState): boolean;
+    /**
+     * Can the call be hung up in this state?
+     */
+    canHangup(state: TelnyxCallState): boolean;
+    /**
+     * Can the call be put on hold in this state?
+     */
+    canHold(state: TelnyxCallState): boolean;
+    /**
+     * Can the call be resumed from hold in this state?
+     */
+    canResume(state: TelnyxCallState): boolean;
+    /**
+     * Can the call be muted/unmuted in this state?
+     */
+    canToggleMute(state: TelnyxCallState): boolean;
+    /**
+     * Is the call in a terminated state?
+     */
+    isTerminated(state: TelnyxCallState): boolean;
+    /**
+     * Is the call in an active state (can have media)?
+     */
+    isActive(state: TelnyxCallState): boolean;
+    /**
+     * Is the call in a connecting state (answered but not yet active)?
+     */
+    isConnecting(state: TelnyxCallState): boolean;
+};

package/lib/models/call-state.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallStateHelpers = exports.TelnyxCallState = void 0;
+exports.isTelnyxCallState = isTelnyxCallState;
+/**
+ * Represents the state of a call in the Telnyx system.
+ *
+ * This enum provides a simplified view of call states, abstracting away
+ * the complexity of the underlying SIP call states.
+ */
+var TelnyxCallState;
+(function (TelnyxCallState) {
+    /** Call is being initiated (outgoing) or received (incoming) */
+    TelnyxCallState["RINGING"] = "RINGING";
+    /** Call is connecting after being answered (usually from push notification) */
+    TelnyxCallState["CONNECTING"] = "CONNECTING";
+    /** Call has been answered and media is flowing */
+    TelnyxCallState["ACTIVE"] = "ACTIVE";
+    /** Call is on hold */
+    TelnyxCallState["HELD"] = "HELD";
+    /** Call has ended normally */
+    TelnyxCallState["ENDED"] = "ENDED";
+    /** Call failed to connect or was rejected */
+    TelnyxCallState["FAILED"] = "FAILED";
+})(TelnyxCallState || (exports.TelnyxCallState = TelnyxCallState = {}));
+/**
+ * Type guard to check if a value is a valid TelnyxCallState
+ */
+function isTelnyxCallState(value) {
+    return Object.values(TelnyxCallState).includes(value);
+}
+/**
+ * Helper functions to determine what actions are available in each state
+ */
+exports.CallStateHelpers = {
+    /**
+     * Can the call be answered in this state?
+     */
+    canAnswer(state) {
+        return state === TelnyxCallState.RINGING;
+    },
+    /**
+     * Can the call be hung up in this state?
+     */
+    canHangup(state) {
+        return (state === TelnyxCallState.RINGING ||
+            state === TelnyxCallState.CONNECTING ||
+            state === TelnyxCallState.ACTIVE ||
+            state === TelnyxCallState.HELD);
+    },
+    /**
+     * Can the call be put on hold in this state?
+     */
+    canHold(state) {
+        return state === TelnyxCallState.ACTIVE;
+    },
+    /**
+     * Can the call be resumed from hold in this state?
+     */
+    canResume(state) {
+        return state === TelnyxCallState.HELD;
+    },
+    /**
+     * Can the call be muted/unmuted in this state?
+     */
+    canToggleMute(state) {
+        return state === TelnyxCallState.ACTIVE || state === TelnyxCallState.HELD;
+    },
+    /**
+     * Is the call in a terminated state?
+     */
+    isTerminated(state) {
+        return state === TelnyxCallState.ENDED || state === TelnyxCallState.FAILED;
+    },
+    /**
+     * Is the call in an active state (can have media)?
+     */
+    isActive(state) {
+        return state === TelnyxCallState.ACTIVE || state === TelnyxCallState.HELD;
+    },
+    /**
+     * Is the call in a connecting state (answered but not yet active)?
+     */
+    isConnecting(state) {
+        return state === TelnyxCallState.CONNECTING;
+    },
+};