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

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

@@ -0,0 +1,216 @@
+package com.telnyx.react_voice_commons
+
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactApplication
+
+/**
+ * Base MainActivity class that provides Telnyx voice push notification handling
+ * Your app's MainActivity should extend this class to get Telnyx functionality
+ */
+abstract class TelnyxMainActivity : ReactActivity() {
+    companion object {
+        private const val TAG = "TelnyxMainActivity"
+    }
+
+    // Store pending push notification data
+    private var pendingPushAction: String? = null
+    private var pendingPushMetadata: String? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        // Handle any intent extras (from push notifications or deep links)
+        handleIntent(intent)
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        super.onNewIntent(intent)
+        Log.d(TAG, "onNewIntent called")
+        intent?.let { handleIntent(it) }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        Log.d(TAG, "onResume called")
+        // Check and send any pending push actions when app resumes
+        checkAndSendPendingPushAction()
+    }
+
+    /**
+     * Handle incoming intent data (from push notifications, deep links, etc.)
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun handleIntent(intent: Intent) {
+        Log.d(TAG, "Handling intent: ${intent.action}")
+        
+        val extras = intent.extras
+        if (extras != null) {
+            Log.d(TAG, "Intent extras found: ${extras.keySet()}")
+
+            
+            // Handle push notification data
+            val callId = extras.getString("call_id")
+            val action = extras.getString("action")
+            val fromNotificationAction = extras.getBoolean("from_notification_action", false)
+            val metadata = extras.getString("meta_data")
+            if (callId != null && action != null) {
+                Log.d(TAG, "Found push notification data - callId: $callId, action: $action, fromNotificationAction: $fromNotificationAction")
+                
+                // If this was opened from a notification action, handle it appropriately
+                if (fromNotificationAction) {
+                    Log.d(TAG, "App opened from notification action - action: $action")
+                    
+                    when (action) {
+                        "answer" -> {
+                            Log.d(TAG, "User answered call - showing ongoing call notification")
+                            // Dismiss incoming call notification
+                            TelnyxNotificationHelper.hideNotificationFromContext(this)
+                            
+                            // Show ongoing call notification to keep app alive
+                            val callerName = extras.getString("caller_name") ?: extras.getString("caller_id_name") ?: "Unknown Caller"
+                            val callerNumber = extras.getString("caller_number") ?: extras.getString("caller_id_number") ?: ""
+                            
+                            val notificationHelper = TelnyxNotificationHelper(this)
+                            notificationHelper.showOngoingCallNotification(callerName, callerNumber, callId)
+                            
+                            // Start foreground service to keep WebRTC connection alive
+                            try {
+                                val serviceIntent = Intent(this, CallForegroundService::class.java).apply {
+                                    setAction(CallForegroundService.ACTION_START_FOREGROUND_SERVICE)
+                                    putExtra(CallForegroundService.EXTRA_CALLER_NAME, callerName)
+                                    putExtra(CallForegroundService.EXTRA_CALLER_NUMBER, callerNumber)
+                                    putExtra(CallForegroundService.EXTRA_CALL_ID, callId)
+                                }
+                                
+                                // Use startForegroundService for API 26+, startService for older versions
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                                    startForegroundService(serviceIntent)
+                                } else {
+                                    startService(serviceIntent)
+                                }
+                                Log.d(TAG, "Started CallForegroundService for answered call")
+                            } catch (e: Exception) {
+                                Log.e(TAG, "Failed to start CallForegroundService", e)
+                                // Continue without foreground service if it fails
+                            }
+                        }
+                        "reject", "hangup" -> {
+                            Log.d(TAG, "User rejected/ended call - dismissing all notifications")
+                            // Dismiss any call notifications
+                            TelnyxNotificationHelper.hideNotificationFromContext(this)
+                        }
+                        else -> {
+                            Log.d(TAG, "Unknown notification action, dismissing notification")
+                            TelnyxNotificationHelper.hideNotificationFromContext(this)
+                        }
+                    }
+                }
+                
+                // Store the push action for when React Native is ready
+                pendingPushAction = action
+                pendingPushMetadata = metadata
+                
+                // Store the call action for React Native to retrieve
+                notifyReactNativeOfCallAction(action!!, callId!!)
+                
+                // Also store as push action for backward compatibility
+                checkAndSendPendingPushAction()
+            }
+        }
+        
+        // Allow subclasses to handle additional intent processing
+        onHandleIntent(intent)
+    }
+
+    /**
+     * Create push metadata string from intent extras
+     */
+    private fun createPushMetadata(callId: String, action: String, extras: Bundle): String {
+        val metadata = mutableMapOf<String, String>()
+        metadata["call_id"] = callId
+        metadata["action"] = action
+        
+        // Add any other relevant extras
+        extras.getString("caller_name")?.let { metadata["caller_name"] = it }
+        extras.getString("caller_number")?.let { metadata["caller_number"] = it }
+        extras.getString("caller_id_name")?.let { metadata["caller_id_name"] = it }
+        extras.getString("caller_id_number")?.let { metadata["caller_id_number"] = it }
+        
+        return metadata.toString()
+    }
+
+    /**
+     * Check and send pending push action to React Native via VoicePnModule
+     * This method is called via reflection from VoicePnModule
+     */
+    fun checkAndSendPendingPushAction(): Boolean {
+        Log.d(TAG, "checkAndSendPendingPushAction called")
+        // Fallback: handle instance variables (from intent extras)
+        if (pendingPushAction != null && pendingPushMetadata != null) {
+            Log.d(TAG, "Found instance push action: $pendingPushAction")
+            
+            try {
+                // Store the intent-based action in VoicePnManager
+                VoicePnManager.setPendingPushAction(this, pendingPushAction!!, pendingPushMetadata!!)
+                
+                // Clear the pending action
+                pendingPushAction = null
+                pendingPushMetadata = null
+                
+                Log.d(TAG, "Instance push action stored successfully")
+                return true
+            } catch (e: Exception) {
+                Log.e(TAG, "Error storing instance push action", e)
+            }
+        }
+        
+        Log.d(TAG, "No pending push action found")
+        return false
+    }
+
+    /**
+     * Notify React Native of call actions that happen from notification buttons
+     */
+    private fun notifyReactNativeOfCallAction(action: String, callId: String) {
+        try {
+            Log.d(TAG, "Notifying React Native of call action: $action for callId: $callId")
+            
+            // Store the call action using VoicePnManager for reliable retrieval (fallback)
+            VoicePnManager.setPendingCallAction(this, action, callId, System.currentTimeMillis())
+            
+            // Send immediate event to React Native if available (for active calls)
+            try {
+                val reactApplication = application as? ReactApplication
+                val reactContext = reactApplication?.reactNativeHost?.reactInstanceManager?.currentReactContext
+                
+                if (reactContext != null) {
+                    Log.d(TAG, "React Native context available, emitting immediate call action event")
+                    
+                    // Use VoicePnBridgeModule to emit the event
+                    val bridgeModule = reactContext.getNativeModule(VoicePnBridgeModule::class.java)
+                    bridgeModule?.emitCallActionEvent(action, callId)
+                } else {
+                    Log.d(TAG, "React Native context not available, action stored for later retrieval")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error emitting immediate call action event", e)
+                // Action is still stored in VoicePnManager as fallback
+            }
+            
+            Log.d(TAG, "Call action notification completed: $action")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error notifying React Native of call action", e)
+        }
+    }
+
+    /**
+     * Override this method in your MainActivity to handle additional intent processing
+     */
+    protected open fun onHandleIntent(intent: Intent) {
+        // Default implementation does nothing
+    }
+}

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

@@ -0,0 +1,177 @@
+package com.telnyx.react_voice_commons
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import org.json.JSONObject
+
+/**
+ * Base broadcast receiver for handling notification actions for Telnyx voice calls (Answer/Reject)
+ * Your app should extend this class to customize behavior if needed
+ */
+open class TelnyxNotificationActionReceiver : BroadcastReceiver() {
+    private val tag = "TelnyxNotification"
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        val callId = intent.getStringExtra("call_id")
+
+        Log.d(tag, "Received notification action: $action for call: $callId")
+
+        if (callId == null) {
+            Log.e(tag, "No call ID provided in notification action")
+            return
+        }
+
+        when (action) {
+            "ANSWER_CALL" -> {
+                Log.d(tag, "Answer action triggered for call: $callId")
+                handleAnswerCall(context, callId)
+            }
+            "REJECT_CALL" -> {
+                Log.d(tag, "Reject action triggered for call: $callId")
+                handleRejectCall(context, callId)
+            }
+            else -> {
+                Log.w(tag, "Unknown notification action: $action")
+            }
+        }
+
+        // Hide the notification after action
+        val notificationHelper = TelnyxNotificationHelper(context)
+        notificationHelper.hideIncomingCallNotification()
+    }
+
+    protected open fun handleAnswerCall(context: Context, callId: String) {
+        try {
+            Log.d(tag, "Processing answer action through VoicePnManager")
+            
+            // Get the existing metadata from VoicePnManager (contains original FCM data including voice_sdk_id)
+            val (existingAction, existingMetadata) = VoicePnManager.getPendingPushAction(context)
+            
+            Log.d(tag, "Existing action: '$existingAction'")
+            Log.d(tag, "Existing metadata: '$existingMetadata'")
+            Log.d(tag, "Existing metadata length: ${existingMetadata?.length ?: 0}")
+            
+            var finalMetadata: String
+            
+            if (existingMetadata != null && existingMetadata.isNotEmpty()) {
+                // Try to parse existing metadata and add action info
+                try {
+                    Log.d(tag, "Attempting to preserve original metadata")
+                    
+                    // The existing metadata from FCM service is the raw FCM data string
+                    // It looks like: {metadata={"call_id":"...","voice_sdk_id":"..."}, message=...}
+                    if (existingMetadata.contains("\"voice_sdk_id\"")) {
+                        // Extract just the JSON part that contains the voice_sdk_id
+                        val startIndex = existingMetadata.indexOf("{\"call_id\"")
+                        val endIndex = existingMetadata.lastIndexOf("}") + 1
+                        
+                        if (startIndex in 0..<endIndex) {
+                            val originalJson = existingMetadata.substring(startIndex, endIndex)
+                            Log.d(tag, "Extracted original JSON: $originalJson")
+                            
+                            // Parse and add action
+                            val metadata = JSONObject(originalJson)
+                            metadata.put("action", "answer")
+                            finalMetadata = metadata.toString()
+                            
+                            Log.d(tag, "Enhanced metadata with action: $finalMetadata")
+                        } else {
+                            throw Exception("Could not extract JSON from FCM data")
+                        }
+                    } else {
+                        // Try to parse as direct JSON and add action
+                        val metadata = JSONObject(existingMetadata)
+                        metadata.put("action", "answer")
+                        finalMetadata = metadata.toString()
+                        
+                        Log.d(tag, "Updated existing JSON metadata with action: $finalMetadata")
+                    }
+                } catch (e: Exception) {
+                    Log.w(tag, "Could not parse existing metadata, creating new one", e)
+                    // Fallback to simple metadata
+                    finalMetadata = JSONObject().apply {
+                        put("call_id", callId)
+                        put("action", "answer")
+                    }.toString()
+                    Log.d(tag, "Created fallback metadata: $finalMetadata")
+                }
+            } else {
+                // No existing metadata, create simple one
+                Log.d(tag, "No existing metadata found, creating simple metadata")
+                finalMetadata = JSONObject().apply {
+                    put("call_id", callId)
+                    put("action", "answer")
+                }.toString()
+                Log.d(tag, "Created simple metadata: $finalMetadata")
+            }
+            
+            VoicePnManager.setPendingPushAction(context, "answer", finalMetadata)
+            
+            Log.d(tag, "Answer action stored - app should open via direct PendingIntent")
+        } catch (e: Exception) {
+            Log.e(tag, "Error handling answer call action", e)
+        }
+    }
+
+    protected open fun handleRejectCall(context: Context, callId: String) {
+        try {
+            Log.d(tag, "Processing reject action through VoicePnManager")
+            
+            // Get the existing metadata from VoicePnManager (contains original FCM data including voice_sdk_id)
+            val (existingAction, existingMetadata) = VoicePnManager.getPendingPushAction(context)
+            
+            var finalMetadata: String
+            
+            if (existingMetadata != null && existingMetadata.isNotEmpty()) {
+                // Try to parse existing metadata and add action info
+                try {
+                    // The existing metadata might be FCM data string or JSON
+                    if (existingMetadata.startsWith("{") && existingMetadata.contains("metadata=")) {
+                        // This is FCM data string format: {metadata={"call_id":"...","voice_sdk_id":"..."}, message=...}
+                        // Extract the JSON part from metadata field
+                        val metadataStart = existingMetadata.indexOf("metadata=") + 9
+                        val metadataEnd = existingMetadata.indexOf("}", metadataStart) + 1
+                        val metadataJson = existingMetadata.substring(metadataStart, metadataEnd)
+                        
+                        // Parse and add action
+                        val metadata = JSONObject(metadataJson)
+                        metadata.put("action", "reject")
+                        finalMetadata = metadata.toString()
+                        
+                        Log.d(tag, "Preserved original FCM metadata with action: $finalMetadata")
+                    } else {
+                        // Try to parse as direct JSON
+                        val metadata = JSONObject(existingMetadata)
+                        metadata.put("action", "reject")
+                        finalMetadata = metadata.toString()
+                        
+                        Log.d(tag, "Updated existing JSON metadata with action: $finalMetadata")
+                    }
+                } catch (e: Exception) {
+                    Log.w(tag, "Could not parse existing metadata, creating new one", e)
+                    // Fallback to simple metadata
+                    finalMetadata = mapOf(
+                        "call_id" to callId,
+                        "action" to "reject"
+                    ).toString()
+                }
+            } else {
+                // No existing metadata, create simple one
+                Log.d(tag, "No existing metadata found, creating simple metadata")
+                finalMetadata = mapOf(
+                    "call_id" to callId,
+                    "action" to "reject"
+                ).toString()
+            }
+            
+            VoicePnManager.setPendingPushAction(context, "reject", finalMetadata)
+            
+            Log.d(tag, "Reject action processed successfully")
+        } catch (e: Exception) {
+            Log.e(tag, "Error handling reject call action", e)
+        }
+    }
+}

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

@@ -0,0 +1,277 @@
+package com.telnyx.react_voice_commons
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import android.graphics.Color
+import android.util.Log
+
+/**
+ * Helper class for managing Telnyx voice call notifications
+ */
+class TelnyxNotificationHelper(private val context: Context) {
+    companion object {
+        const val CHANNEL_ID = "telnyx_voice_calls"
+        const val CHANNEL_NAME = "Telnyx Voice Calls"
+        const val NOTIFICATION_ID = 1001
+        const val ONGOING_CALL_NOTIFICATION_ID = 1002
+        private const val TAG = "TelnyxNotifications"
+        
+        /**
+         * Static method to hide notifications from anywhere in the app
+         * Useful for dismissing notifications when the app opens from Answer button
+         */
+        fun hideNotificationFromContext(context: Context) {
+            val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.cancel(NOTIFICATION_ID)
+            Log.d(TAG, "Dismissed Telnyx notification from static context")
+        }
+        
+        /**
+         * Static method to hide ongoing call notification from anywhere in the app
+         * Should be called when a call ends to dismiss the ongoing call notification
+         */
+        fun hideOngoingCallNotificationFromContext(context: Context) {
+            val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.cancel(ONGOING_CALL_NOTIFICATION_ID)
+            Log.d(TAG, "Dismissed ongoing call notification from static context")
+        }
+    }
+
+    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+    init {
+        createNotificationChannel()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                CHANNEL_NAME,
+                NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                description = "Notifications for incoming Telnyx voice calls"
+                enableLights(true)
+                lightColor = Color.GREEN
+                enableVibration(true)
+                setSound(null, null) // Disable sound, CallKit will handle audio
+            }
+            notificationManager.createNotificationChannel(channel)
+            Log.d(TAG, "Created notification channel: $CHANNEL_ID")
+        }
+    }
+
+    fun createIncomingCallNotification(
+        callerName: String?,
+        callerNumber: String?,
+        callId: String,
+        metadata: String,
+        mainActivityClass: Class<*>? = null
+    ): Notification {
+        val displayName = callerName ?: callerNumber ?: "Unknown Caller"
+        val displayNumber = if (callerName != null && callerNumber != null) callerNumber else ""
+
+        // Use provided MainActivity class or try to find it dynamically
+        val activityClass = mainActivityClass ?: try {
+            // Try TelnyxMainActivity first (apps should extend this)
+            Class.forName("${context.packageName}.TelnyxMainActivity")
+        } catch (e1: Exception) {
+            try {
+                // Fallback to MainActivity
+                Class.forName("${context.packageName}.MainActivity")
+            } catch (e2: Exception) {
+                Log.w(TAG, "Could not find TelnyxMainActivity or MainActivity, using context class", e2)
+                context.javaClass
+            }
+        }
+
+        // Intent to open the app when notification is tapped
+        val appIntent = Intent(context, activityClass).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("call_id", callId)
+            putExtra("action", "open_call")
+        }
+        val appPendingIntent = PendingIntent.getActivity(
+            context, 0, appIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setContentTitle("Incoming Call")
+            .setContentText("$displayName")
+            .setSmallIcon(android.R.drawable.ic_menu_call)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setAutoCancel(true)
+            .setOngoing(true)
+            .setFullScreenIntent(appPendingIntent, true)
+            .setContentIntent(appPendingIntent)
+            .setColor(Color.GREEN)
+
+        // Add action buttons - use direct activity PendingIntents to avoid trampoline restrictions
+        // Answer action - direct activity launch to avoid BAL restrictions
+        val answerActivityIntent = Intent(context, activityClass).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("call_id", callId)
+            putExtra("action", "answer")
+            putExtra("from_notification_action", true)
+            putExtra("meta_data", metadata)
+            putExtra("caller_name", callerName)
+            putExtra("caller_number", callerNumber)
+        }
+        val answerPendingIntent = PendingIntent.getActivity(
+            context, 1, answerActivityIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        // Reject action - direct activity launch to avoid BAL restrictions
+        val rejectActivityIntent = Intent(context, activityClass).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("call_id", callId)
+            putExtra("action", "reject")
+            putExtra("from_notification_action", true)
+            putExtra("meta_data",metadata)
+        }
+        val rejectPendingIntent = PendingIntent.getActivity(
+            context, 2, rejectActivityIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        builder.addAction(android.R.drawable.ic_menu_call, "Answer", answerPendingIntent)
+        builder.addAction(android.R.drawable.ic_menu_close_clear_cancel, "Reject", rejectPendingIntent)
+
+        return builder.build()
+    }
+
+    fun showIncomingCallNotification(
+        callerName: String?, 
+        callerNumber: String?, 
+        callId: String,
+        metadata: String,
+        mainActivityClass: Class<*>? = null,
+    ) {
+        // First, hide any existing notification to avoid conflicts
+        hideIncomingCallNotification()
+        
+        val notification = createIncomingCallNotification(callerName, callerNumber, callId,metadata, mainActivityClass)
+        notificationManager.notify(NOTIFICATION_ID, notification)
+        Log.d(TAG, "Showed incoming call notification for: $callerName ($callerNumber)")
+    }
+
+    fun showMissedCallNotification(
+        callerName: String?,
+        callerNumber: String?,
+        callId: String
+    ) {
+        // Hide any existing incoming call notification first
+        hideIncomingCallNotification()
+        
+        val displayName = callerName ?: callerNumber ?: "Unknown Caller"
+        val displayNumber = if (callerName != null && callerNumber != null) callerNumber else ""
+        
+        val notification = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setContentTitle("Missed Call")
+            .setContentText("$displayName${if (displayNumber.isNotEmpty()) "\n$displayNumber" else ""}")
+            .setSmallIcon(android.R.drawable.ic_menu_call)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setAutoCancel(true)
+            .setOngoing(false) // Not ongoing for missed calls
+            .setColor(Color.RED)
+            .build()
+            
+        notificationManager.notify(NOTIFICATION_ID, notification)
+        Log.d(TAG, "Showed missed call notification for: $callerName ($callerNumber)")
+    }
+
+    fun showOngoingCallNotification(
+        callerName: String?,
+        callerNumber: String?,
+        callId: String,
+        mainActivityClass: Class<*>? = null
+    ) {
+        val notification = createOngoingCallNotification(callerName, callerNumber, callId, mainActivityClass)
+        notificationManager.notify(ONGOING_CALL_NOTIFICATION_ID, notification)
+        Log.d(TAG, "Showed ongoing call notification for: $callerName ($callerNumber)")
+    }
+
+    /**
+     * Create ongoing call notification (for foreground services)
+     * Returns the notification object instead of showing it directly
+     */
+    fun createOngoingCallNotification(
+        callerName: String?,
+        callerNumber: String?,
+        callId: String,
+        mainActivityClass: Class<*>? = null
+    ): Notification {
+        val displayName = callerName ?: callerNumber ?: "Unknown Caller"
+        val displayNumber = if (callerName != null && callerNumber != null) callerNumber else ""
+
+        // Use provided MainActivity class or try to find it dynamically
+        val activityClass = mainActivityClass ?: try {
+            // Try TelnyxMainActivity first (apps should extend this)
+            Class.forName("${context.packageName}.TelnyxMainActivity")
+        } catch (e1: Exception) {
+            try {
+                // Fallback to MainActivity
+                Class.forName("${context.packageName}.MainActivity")
+            } catch (e2: Exception) {
+                Log.w(TAG, "Could not find TelnyxMainActivity or MainActivity, using context class", e2)
+                context.javaClass
+            }
+        }
+
+        // Intent to open the app when notification is tapped
+        val appIntent = Intent(context, activityClass).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("call_id", callId)
+            putExtra("action", "return_to_call")
+        }
+        val appPendingIntent = PendingIntent.getActivity(
+            context, 0, appIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        // End call action
+        val endCallIntent = Intent(context, activityClass).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("call_id", callId)
+            putExtra("action", "hangup")
+            putExtra("from_notification_action", true)
+        }
+        val endCallPendingIntent = PendingIntent.getActivity(
+            context, 3, endCallIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        return NotificationCompat.Builder(context, CHANNEL_ID)
+            .setContentTitle("Ongoing Call")
+            .setContentText("$displayName${if (displayNumber.isNotEmpty()) " ($displayNumber)" else ""}")
+            .setSmallIcon(android.R.drawable.ic_menu_call)
+            .setPriority(NotificationCompat.PRIORITY_LOW) // Low priority for ongoing calls
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setAutoCancel(false) // Don't auto-cancel ongoing call notifications
+            .setOngoing(true) // This is the key - makes it persistent and keeps app alive
+            .setContentIntent(appPendingIntent)
+            .setColor(Color.GREEN)
+            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "End Call", endCallPendingIntent)
+            .build()
+    }
+
+    fun hideIncomingCallNotification() {
+        notificationManager.cancel(NOTIFICATION_ID)
+        Log.d(TAG, "Hid incoming call notification")
+    }
+
+    fun hideOngoingCallNotification() {
+        notificationManager.cancel(ONGOING_CALL_NOTIFICATION_ID)
+        Log.d(TAG, "Hid ongoing call notification")
+    }
+}