@telnyx/react-voice-commons-sdk 0.1.4 → 0.1.6

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

@@ -1,44 +1,44 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
-
-@interface RCT_EXTERN_MODULE(CallKitBridge, RCTEventEmitter)
-
-RCT_EXTERN_METHOD(startOutgoingCall:(NSString *)callUUID 
-                  handle:(NSString *)handle 
-                  displayName:(NSString *)displayName
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(reportIncomingCall:(NSString *)callUUID 
-                  handle:(NSString *)handle 
-                  displayName:(NSString *)displayName
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(answerCall:(NSString *)callUUID 
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(endCall:(NSString *)callUUID 
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(reportCallConnected:(NSString *)callUUID 
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(reportCallEnded:(NSString *)callUUID 
-                  reason:(NSNumber *)reason
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(updateCall:(NSString *)callUUID 
-                  displayName:(NSString *)displayName 
-                  handle:(NSString *)handle
-                  resolver:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getActiveCalls:(RCTPromiseResolveBlock)resolve 
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(CallKitBridge, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(startOutgoingCall:(NSString *)callUUID 
+                  handle:(NSString *)handle 
+                  displayName:(NSString *)displayName
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportIncomingCall:(NSString *)callUUID 
+                  handle:(NSString *)handle 
+                  displayName:(NSString *)displayName
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(answerCall:(NSString *)callUUID 
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(endCall:(NSString *)callUUID 
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportCallConnected:(NSString *)callUUID 
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportCallEnded:(NSString *)callUUID 
+                  reason:(NSNumber *)reason
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(updateCall:(NSString *)callUUID 
+                  displayName:(NSString *)displayName 
+                  handle:(NSString *)handle
+                  resolver:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getActiveCalls:(RCTPromiseResolveBlock)resolve 
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 @end