@telnyx/react-voice-commons-sdk 0.1.5 → 0.1.7-beta.0

package/android/src/main/java/com/telnyx/react_voice_commons/VoicePnBridgeModule.kt

@@ -0,0 +1,247 @@
+package com.telnyx.react_voice_commons
+
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class VoicePnBridgeModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    
+    companion object {
+        private const val TAG = "VoicePnBridgeModule"
+    }
+    
+    override fun getName(): String {
+        return "VoicePnBridge"
+    }
+    
+    @ReactMethod
+    fun getPendingPushAction(promise: Promise) {
+        try {
+            val (action, metadata) = VoicePnManager.getPendingPushAction(reactApplicationContext)
+            
+            Log.d(TAG, "Retrieved pending action: '$action'")
+            Log.d(TAG, "Retrieved metadata: '$metadata'")
+            Log.d(TAG, "Metadata length: ${metadata?.length ?: 0}")
+            
+            val result = Arguments.createMap()
+            result.putString("action", action)
+            result.putString("metadata", metadata)
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting pending push action", e)
+            promise.reject("GET_PENDING_PUSH_ACTION_ERROR", e.message, e)
+        }
+    }
+    
+    @ReactMethod
+    fun setPendingPushAction(action: String, metadata: String, promise: Promise) {
+        try {
+            Log.d(TAG, "Setting pending push action: '$action' with metadata length: ${metadata.length}")
+            val result = VoicePnManager.setPendingPushAction(reactApplicationContext, action, metadata)
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error setting pending push action", e)
+            promise.reject("SET_PENDING_PUSH_ACTION_ERROR", e.message, e)
+        }
+    }
+    
+    @ReactMethod
+    fun clearPendingPushAction(promise: Promise) {
+        try {
+            val result = VoicePnManager.clearPendingPushAction(reactApplicationContext)
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_PENDING_PUSH_ACTION_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * React Native → Android: Get any pending call action from notification buttons
+     * Uses the same reliable pattern as getPendingPushAction
+     */
+    @ReactMethod
+    fun getPendingCallAction(promise: Promise) {
+        try {
+            val (action, callId, timestamp) = VoicePnManager.getPendingCallAction(reactApplicationContext)
+            
+            Log.d(TAG, "Retrieved pending call action: '$action' for callId: '$callId'")
+            
+            val result = Arguments.createMap()
+            result.putString("action", action)
+            result.putString("callId", callId)
+            result.putDouble("timestamp", timestamp?.toDouble() ?: 0.0)
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error getting pending call action", e)
+            promise.reject("GET_PENDING_CALL_ACTION_ERROR", e.message, e)
+        }
+    }
+
+    /**
+     * React Native → Android: Clear any pending call action
+     */
+    @ReactMethod
+    fun clearPendingCallAction(promise: Promise) {
+        try {
+            val result = VoicePnManager.clearPendingCallAction(reactApplicationContext)
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error clearing pending call action", e)
+            promise.reject("CLEAR_PENDING_CALL_ACTION_ERROR", e.message, e)
+        }
+    }
+    
+    /**
+     * React Native → Android: End/hang up the current call
+     */
+    @ReactMethod
+    fun endCall(callId: String?, promise: Promise) {
+        try {
+            Log.d(TAG, "endCall called from React Native for callId: $callId")
+            
+            // Hide any ongoing call notification and stop the foreground service
+            TelnyxNotificationHelper.hideOngoingCallNotificationFromContext(reactApplicationContext)
+            
+            // Stop the foreground service that's keeping the notification alive
+            try {
+                val serviceIntent = Intent(reactApplicationContext, CallForegroundService::class.java).apply {
+                    setAction(CallForegroundService.ACTION_STOP_FOREGROUND_SERVICE)
+                }
+                reactApplicationContext.startService(serviceIntent)
+                Log.d(TAG, "Stopped CallForegroundService from endCall")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to stop CallForegroundService from endCall", e)
+                // Don't fail the call end if service stop fails
+            }
+            
+            // Store the call action for any listeners (using same pattern)
+            VoicePnManager.setPendingCallAction(reactApplicationContext, "call_ended_from_rn", callId, System.currentTimeMillis())
+            
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error ending call", e)
+            promise.reject("END_CALL_ERROR", e.message, e)
+        }
+    }
+    
+    /**
+     * React Native → Android: Show ongoing call notification
+     */
+    @ReactMethod
+    fun showOngoingCallNotification(callerName: String?, callerNumber: String?, callId: String?, promise: Promise) {
+        try {
+            Log.d(TAG, "showOngoingCallNotification called from React Native")
+            
+            val notificationHelper = TelnyxNotificationHelper(reactApplicationContext)
+            notificationHelper.showOngoingCallNotification(
+                callerName ?: "Unknown Caller",
+                callerNumber ?: "",
+                callId ?: "unknown"
+            )
+            
+            // Also start the foreground service to keep the WebRTC connection alive
+            try {
+                val serviceIntent = Intent(reactApplicationContext, CallForegroundService::class.java).apply {
+                    setAction(CallForegroundService.ACTION_START_FOREGROUND_SERVICE)
+                    putExtra(CallForegroundService.EXTRA_CALLER_NAME, callerName ?: "Unknown Caller")
+                    putExtra(CallForegroundService.EXTRA_CALLER_NUMBER, callerNumber ?: "")
+                    putExtra(CallForegroundService.EXTRA_CALL_ID, callId ?: "unknown")
+                }
+                
+                // Use startForegroundService for API 26+, startService for older versions
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    reactApplicationContext.startForegroundService(serviceIntent)
+                } else {
+                    reactApplicationContext.startService(serviceIntent)
+                }
+                Log.d(TAG, "Started CallForegroundService for ongoing call")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to start CallForegroundService", e)
+                // Don't fail the notification if service start fails
+            }
+            
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error showing ongoing call notification", e)
+            promise.reject("SHOW_ONGOING_NOTIFICATION_ERROR", e.message, e)
+        }
+    }
+    
+    /**
+     * React Native → Android: Hide ongoing call notification
+     */
+    @ReactMethod
+    fun hideOngoingCallNotification(promise: Promise) {
+        try {
+            Log.d(TAG, "hideOngoingCallNotification called from React Native")
+            
+            TelnyxNotificationHelper.hideOngoingCallNotificationFromContext(reactApplicationContext)
+            
+            // Also stop the foreground service
+            try {
+                val serviceIntent = Intent(reactApplicationContext, CallForegroundService::class.java).apply {
+                    setAction(CallForegroundService.ACTION_STOP_FOREGROUND_SERVICE)
+                }
+                reactApplicationContext.startService(serviceIntent)
+                Log.d(TAG, "Stopped CallForegroundService")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to stop CallForegroundService", e)
+                // Don't fail the notification hiding if service stop fails
+            }
+            
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error hiding ongoing call notification", e)
+            promise.reject("HIDE_ONGOING_NOTIFICATION_ERROR", e.message, e)
+        }
+    }
+    
+    /**
+     * React Native → Android: Hide any incoming call notification
+     */
+    @ReactMethod
+    fun hideIncomingCallNotification(promise: Promise) {
+        try {
+            Log.d(TAG, "hideIncomingCallNotification called from React Native")
+            
+            TelnyxNotificationHelper.hideNotificationFromContext(reactApplicationContext)
+            
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error hiding incoming call notification", e)
+            promise.reject("HIDE_INCOMING_NOTIFICATION_ERROR", e.message, e)
+        }
+    }
+    
+    /**
+     * Emit call action event to React Native (for immediate notification)
+     * Called from TelnyxMainActivity when user taps notification action
+     */
+    fun emitCallActionEvent(action: String, callId: String) {
+        try {
+            Log.d(TAG, "Emitting call action event to React Native: action=$action, callId=$callId")
+            
+            val params = Arguments.createMap()
+            params.putString("action", action)
+            params.putString("callId", callId)
+            params.putDouble("timestamp", System.currentTimeMillis().toDouble())
+            
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("TelnyxCallAction", params)
+                
+            Log.d(TAG, "Call action event emitted successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error emitting call action event", e)
+        }
+    }
+}

package/android/src/main/java/com/telnyx/react_voice_commons/VoicePnBridgePackage.kt

@@ -0,0 +1,17 @@
+package com.telnyx.react_voice_commons
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class VoicePnBridgePackage : ReactPackage {
+    
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(VoicePnBridgeModule(reactContext))
+    }
+    
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/com/telnyx/react_voice_commons/VoicePnManager.kt

@@ -0,0 +1,154 @@
+package com.telnyx.react_voice_commons
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+
+object VoicePnManager {
+    
+    private const val TAG = "VoicePnManager"
+    private const val PREFS_NAME = "telnyx_voice_prefs"
+    
+    private fun getSharedPreferences(context: Context): SharedPreferences {
+        return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    }
+    
+    // UserDefaults equivalent functions
+    fun getVoipToken(context: Context): String? {
+        Log.d(TAG, "getVoipToken called")
+        return getSharedPreferences(context).getString("voip_token", null)
+    }
+    
+    fun setVoipToken(context: Context, token: String?) {
+        Log.d(TAG, "setVoipToken called with: $token")
+        val editor = getSharedPreferences(context).edit()
+        if (token != null) {
+            editor.putString("voip_token", token)
+        } else {
+            editor.remove("voip_token")
+        }
+        editor.apply()
+    }
+
+    fun getPendingVoipPush(context: Context): String? {
+        Log.d(TAG, "getPendingVoipPush called")
+        return getSharedPreferences(context).getString("pending_voip_push", null)
+    }
+    
+    fun setPendingVoipPush(context: Context, push: String?) {
+        Log.d(TAG, "setPendingVoipPush called with: $push")
+        val editor = getSharedPreferences(context).edit()
+        if (push != null) {
+            editor.putString("pending_voip_push", push)
+        } else {
+            editor.remove("pending_voip_push")
+        }
+        editor.apply()
+    }
+
+    fun clearPendingVoipPush(context: Context): Boolean {
+        Log.d(TAG, "clearPendingVoipPush called")
+        val editor = getSharedPreferences(context).edit()
+        editor.remove("pending_voip_push")
+        editor.apply()
+        return true
+    }
+
+    fun getPendingVoipAction(context: Context): String? {
+        Log.d(TAG, "getPendingVoipAction called")
+        return getSharedPreferences(context).getString("pending_voip_action", null)
+    }
+    
+    fun setPendingVoipAction(context: Context, action: String?) {
+        Log.d(TAG, "setPendingVoipAction called with: $action")
+        val editor = getSharedPreferences(context).edit()
+        if (action != null) {
+            editor.putString("pending_voip_action", action)
+        } else {
+            editor.remove("pending_voip_action")
+        }
+        editor.apply()
+    }
+
+    fun clearPendingVoipAction(context: Context): Boolean {
+        Log.d(TAG, "clearPendingVoipAction called")
+        val editor = getSharedPreferences(context).edit()
+        editor.remove("pending_voip_action")
+        editor.apply()
+        return true
+    }
+
+    // PnModule functions
+    fun setPendingPushAction(context: Context, action: String, metadata: String) {
+        Log.d(TAG, "setPendingPushAction called with action: $action")
+        val editor = getSharedPreferences(context).edit()
+        editor.putString("pending_push_action", action)
+        editor.putString("pending_push_metadata", metadata)
+        editor.apply()
+    }
+    
+    fun getPendingPushAction(context: Context): Pair<String?, String?> {
+        Log.d(TAG, "getPendingPushAction called")
+        val prefs = getSharedPreferences(context)
+        val action = prefs.getString("pending_push_action", null)
+        val metadata = prefs.getString("pending_push_metadata", null)
+        return Pair(action, metadata)
+    }
+    
+    fun clearPendingPushAction(context: Context): Boolean {
+        Log.d(TAG, "clearPendingPushAction called")
+        val editor = getSharedPreferences(context).edit()
+        editor.remove("pending_push_action")
+        editor.remove("pending_push_metadata")
+        editor.apply()
+        return true
+    }
+    
+    fun checkPendingPushAction(context: Context): Boolean {
+        Log.d(TAG, "checkPendingPushAction called")
+        val (pendingAction, pendingMetadata) = getPendingPushAction(context)
+        
+        if (pendingAction != null && pendingMetadata != null) {
+            Log.d(TAG, "Found pending action: $pendingAction")
+            // Clear after checking
+            clearPendingPushAction(context)
+            return true
+        } else {
+            Log.d(TAG, "No pending action found")
+            return false
+        }
+    }
+
+    // Call action management (using same pattern as push actions)
+    fun setPendingCallAction(context: Context, action: String, callId: String?, timestamp: Long) {
+        Log.d(TAG, "setPendingCallAction called with action: $action, callId: $callId")
+        val editor = getSharedPreferences(context).edit()
+        editor.putString("pending_call_action", action)
+        editor.putString("pending_call_id", callId)
+        editor.putLong("pending_call_timestamp", timestamp)
+        editor.apply()
+    }
+    
+    fun getPendingCallAction(context: Context): Triple<String?, String?, Long?> {
+        Log.d(TAG, "getPendingCallAction called")
+        val prefs = getSharedPreferences(context)
+        val action = prefs.getString("pending_call_action", null)
+        val callId = prefs.getString("pending_call_id", null)
+        val timestamp = if (prefs.contains("pending_call_timestamp")) {
+            prefs.getLong("pending_call_timestamp", 0)
+        } else {
+            null
+        }
+        return Triple(action, callId, timestamp)
+    }
+    
+    fun clearPendingCallAction(context: Context): Boolean {
+        Log.d(TAG, "clearPendingCallAction called")
+        val editor = getSharedPreferences(context).edit()
+        editor.remove("pending_call_action")
+        editor.remove("pending_call_id")
+        editor.remove("pending_call_timestamp")
+        editor.apply()
+        return true
+    }
+}

package/ios/CallKitBridge.m

@@ -28,7 +28,7 @@ RCT_EXTERN_METHOD(reportCallConnected:(NSString *)callUUID
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(reportCallEnded:(NSString *)callUUID 
-                  reason:(NSNumber *)reason
+                  reason:(nonnull NSNumber *)reason
                   resolver:(RCTPromiseResolveBlock)resolve 
                   rejecter:(RCTPromiseRejectBlock)reject)
 

package/ios/CallKitBridge.swift

@@ -358,15 +358,7 @@ import React
             )
         }
 
-        func configureAudioSession() {
-            let audioSession = AVAudioSession.sharedInstance()
-            do {
-                try audioSession.setCategory(.playAndRecord, mode: .voiceChat)
-                NSLog("Succeeded to activate audio session")
-            } catch {
-                NSLog("Failed to activate audio session: \(error)")
-            }
-        }
+     
 
         private func observeAppDelegate() {
             // Automatically hook into app lifecycle if needed
@@ -760,8 +752,6 @@ import React
 
             NSLog("[TelnyxVoipPushHandler] ✅ CallKit provider ready, reporting incoming call")
 
-            // Configure audio session before reporting the call
-            //callKitManager.configureAudioSession()
 
             // Store call data manually and report to CallKit
             let isAppRunning = CallKitBridge.shared != nil

package/ios/README.md

@@ -32,7 +32,7 @@ Add the following to your iOS app's `Info.plist`:
 
 ### 2. AppDelegate Integration
 
-#### Option A: Easy Integration (Recommended)
+### Option A: Easy Integration (Recommended)
 
 Import and use the `TelnyxVoiceAppDelegate` protocol:
 
@@ -77,7 +77,7 @@ extension AppDelegate: PKPushRegistryDelegate {}
 extension AppDelegate: CXProviderDelegate {}
 ```
 
-#### Option B: Manual Integration
+### Option B: Manual Integration
 
 If you prefer to implement the delegates manually:
 

package/lib/callkit/callkit-coordinator.js

@@ -320,6 +320,12 @@ class CallKitCoordinator {
       console.log('CallKitCoordinator: End action already being processed, skipping duplicate');
       return;
     }
+    if (this.endedCalls.has(callKitUUID)) {
+      console.log('CallKitCoordinator: Call already ended, skipping duplicate end action');
+      return;
+    }
+    // Mark as ended immediately to prevent any duplicate processing
+    this.endedCalls.add(callKitUUID);
     const call = this.callMap.get(callKitUUID);
     if (!call) {
       console.warn('CallKitCoordinator: No WebRTC call found for CallKit end action', {
@@ -598,9 +604,7 @@ class CallKitCoordinator {
    * Clean up call mappings and listeners
    */
   cleanupCall(callKitUUID) {
-    // Remove from all tracking sets
     this.processingCalls.delete(callKitUUID);
-    this.endedCalls.delete(callKitUUID);
     this.connectedCalls.delete(callKitUUID);
     // Get the call before removing it
     const call = this.callMap.get(callKitUUID);

package/lib/internal/calls/call-state-controller.d.ts

@@ -31,6 +31,15 @@ export declare class CallStateController {
    * Current active call (synchronous access)
    */
   get currentActiveCall(): Call | null;
+  /**
+   * Access any active call tracked by the client.
+   * A call will be accessible until it has ended (transitioned to the ENDED state).
+   * This matches the TelnyxRTC `getCall(callId)` method for multi-call support.
+   *
+   * @param callId The unique identifier of a call.
+   * @returns The Call object that matches the requested callId, or null if not found.
+   */
+  getCall(callId: string): Call | null;
   /**
    * Set a call to connecting state (used for push notification calls when answered via CallKit)
    * @param callId The ID of the call to set to connecting state

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

@@ -18,7 +18,7 @@ class CallStateController {
     this._calls = new rxjs_1.BehaviorSubject([]);
     this._callMap = new Map();
     this._disposed = false;
-    console.log('🔧 CallStateController: Constructor called - instance created');
+    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
   }
@@ -69,6 +69,17 @@ class CallStateController {
       ) || null
     );
   }
+  /**
+   * Access any active call tracked by the client.
+   * A call will be accessible until it has ended (transitioned to the ENDED state).
+   * This matches the TelnyxRTC `getCall(callId)` method for multi-call support.
+   *
+   * @param callId The unique identifier of a call.
+   * @returns The Call object that matches the requested callId, or null if not found.
+   */
+  getCall(callId) {
+    return this._callMap.get(callId) || null;
+  }
   /**
    * Set a call to connecting state (used for push notification calls when answered via CallKit)
    * @param callId The ID of the call to set to connecting state
@@ -99,14 +110,11 @@ class CallStateController {
    * This should be called by the session manager after client creation
    */
   initializeClientListeners() {
-    console.log('🔧 CallStateController: initializeClientListeners called');
-    console.log(
-      '🔧 CallStateController: Current client exists:',
-      !!this._sessionManager.telnyxClient
-    );
+    console.log('CallStateController: initializeClientListeners called');
+    console.log('CallStateController: Current client exists:', !!this._sessionManager.telnyxClient);
     this._setupClientListeners();
     // CallKit integration now handled by CallKitCoordinator
-    console.log('🔧 CallStateController: Using CallKitCoordinator for CallKit integration');
+    console.log('CallStateController: Using CallKitCoordinator for CallKit integration');
   }
   /**
    * Initiate a new outgoing call
@@ -170,24 +178,24 @@ class CallStateController {
    * Set up event listeners for the Telnyx client
    */
   _setupClientListeners() {
-    console.log('🔧 CallStateController: Setting up client listeners...');
+    console.log('CallStateController: Setting up client listeners...');
     if (!this._sessionManager.telnyxClient) {
-      console.log('🔧 CallStateController: No telnyxClient available yet, skipping listener setup');
+      console.log('CallStateController: No telnyxClient available yet, skipping listener setup');
       return;
     }
-    console.log('🔧 CallStateController: TelnyxClient found, setting up incoming call listener');
+    console.log('CallStateController: TelnyxClient found, setting up incoming call listener');
     console.log(
-      '🔧 CallStateController: Client instance:',
+      'CallStateController: Client instance:',
       this._sessionManager.telnyxClient.constructor.name
     );
     // Listen for incoming calls
     this._sessionManager.telnyxClient.on('telnyx.call.incoming', (telnyxCall, msg) => {
-      console.log('📞 CallStateController: Incoming call received:', telnyxCall.callId);
+      console.log('CallStateController: Incoming call received:', telnyxCall.callId);
       this._handleIncomingCall(telnyxCall, msg, false);
     });
     // Listen for reattached calls (after network reconnection)
     this._sessionManager.telnyxClient.on('telnyx.call.reattached', (telnyxCall, msg) => {
-      console.log('📞 CallStateController: Reattached call received:', telnyxCall.callId);
+      console.log('CallStateController: Reattached call received:', telnyxCall.callId);
       this._handleIncomingCall(telnyxCall, msg, true);
     });
     // Verify listeners are set up
@@ -196,14 +204,33 @@ class CallStateController {
     const reattachedListeners =
       this._sessionManager.telnyxClient.listenerCount('telnyx.call.reattached');
     console.log(
-      '🔧 CallStateController: Listeners registered - incoming:',
+      'CallStateController: Listeners registered - incoming:',
       incomingListeners,
       'reattached:',
       reattachedListeners
     );
-    // Listen for other call events if needed
-    // this._sessionManager.telnyxClient.on('telnyx.call.stateChange', this._handleCallStateChange.bind(this));
-    console.log('🔧 CallStateController: Client listeners set up successfully');
+    // 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'
+        );
+      }
+    });
+    // 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
+    });
+    console.log('CallStateController: Client listeners set up successfully');
   }
   /**
    * Handle incoming call or reattached call
@@ -211,20 +238,20 @@ class CallStateController {
   _handleIncomingCall(telnyxCall, inviteMsg, isReattached = false) {
     const callId = telnyxCall.callId || this._generateCallId();
     console.log(
-      '📞 CallStateController: Handling incoming call:',
+      'CallStateController: Handling incoming call:',
       callId,
       'isReattached:',
       isReattached
     );
-    console.log('📞 CallStateController: TelnyxCall object:', telnyxCall);
-    console.log('📞 CallStateController: Invite message:', inviteMsg);
+    console.log('CallStateController: TelnyxCall object:', telnyxCall);
+    console.log('CallStateController: Invite message:', inviteMsg);
     // For reattached calls, remove existing call and create new one
     if (isReattached && this._callMap.has(callId)) {
-      console.log('📞 CallStateController: Removing existing call for reattachment');
+      console.log('CallStateController: Removing existing call for reattachment');
       const existingCall = this._callMap.get(callId);
       if (existingCall) {
         console.log(
-          '📞 CallStateController: Existing call state before removal:',
+          'CallStateController: Existing call state before removal:',
           existingCall.currentState
         );
         this._removeCall(callId);
@@ -242,7 +269,7 @@ class CallStateController {
       callerNumber = inviteMsg.params.caller_id_number || '';
       callerName = inviteMsg.params.caller_id_name || '';
       console.log(
-        '📞 CallStateController: Extracted caller info from invite - Number:',
+        'CallStateController: Extracted caller info from invite - Number:',
         callerNumber,
         'Name:',
         callerName
@@ -252,7 +279,7 @@ class CallStateController {
       callerNumber = telnyxCall.remoteCallerIdNumber || '';
       callerName = telnyxCall.remoteCallerIdName || '';
       console.log(
-        '📞 CallStateController: Extracted caller info from TelnyxCall - Number:',
+        'CallStateController: Extracted caller info from TelnyxCall - Number:',
         callerNumber,
         'Name:',
         callerName