rns-nativecall 0.1.7 → 0.1.8

package/android/src/main/java/com/rnsnativecall/AcceptCallActivity.kt

@@ -10,29 +10,45 @@ class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // 1. CLEAR THE PILL IMMEDIATELY
+        // 1. CLEAR THE NOTIFICATION
+        // Use the same ID (101) used in NativeCallManager
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
 
-        // 2. PREPARE DATA FOR JS
+        // 2. EXTRACT DATA SAFELY
+        // We iterate through all extras and convert them to Strings for the JS Map
         val dataMap = mutableMapOf<String, String>()
-        intent.extras?.keySet()?.forEach { key ->
-            intent.getStringExtra(key)?.let { dataMap[key] = it }
+        val extras = intent.extras
+        extras?.keySet()?.forEach { key ->
+            val value = extras.get(key)
+            if (value != null) {
+                dataMap[key] = value.toString()
+            }
         }
 
-        // 3. SEND EVENT TO REACT NATIVE
+        // 3. EMIT EVENT TO REACT NATIVE
+        // This handles the case where the app is already in the background/foreground
         CallModule.sendEventToJS("onCallAccepted", dataMap)
 
-        // 4. OPEN THE MAIN APP
+        // 4. LAUNCH OR BRING MAIN APP TO FOREGROUND
         val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-        launchIntent?.apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            putExtras(intent.extras ?: Bundle())
-            putExtra("navigatingToCall", true)
+        if (launchIntent != null) {
+            launchIntent.apply {
+                // FLAG_ACTIVITY_SINGLE_TOP: Updates the app if it's already open
+                // FLAG_ACTIVITY_NEW_TASK: Required when starting from a non-activity context
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                
+                // Copy all call data to the launch intent
+                putExtras(extras ?: Bundle())
+                
+                // Helper flag for your React Native logic
+                putExtra("navigatingToCall", true)
+            }
+            startActivity(launchIntent)
         }
-        startActivity(launchIntent)
 
-        // 5. KILL THIS INVISIBLE WINDOW
+        // 5. FINISH TRAMPOLINE
+        // This ensures this invisible activity doesn't stay in the "Recent Apps" list
         finish()
     }
 }

package/android/src/main/java/com/rnsnativecall/CallMessagingService.kt

@@ -1,14 +1,34 @@
-///
-// Users/bush/Desktop/Packages/rns-nativecall/android/src/main/java/com/rnsnativecall/CallMessagingService.kt
 package com.rnsnativecall
 
+import android.app.ActivityManager
+import android.content.Context
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 
 class CallMessagingService : FirebaseMessagingService() {
 
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
-        // Directly forward to your native call manager
-        NativeCallManager.handleIncomingPush(applicationContext, remoteMessage.data)
+        if (isAppInForeground(applicationContext)) {
+            // 1. App is OPEN: Don't show the system pill.
+            // Just send the data to your React Native listeners.
+            CallModule.sendEventToJS("onCallReceived", remoteMessage.data)
+        } else {
+            // 2. App is CLOSED/BACKGROUND: Show the sticky system pill.
+            NativeCallManager.handleIncomingPush(applicationContext, remoteMessage.data)
+        }
     }
-}
+
+    private fun isAppInForeground(context: Context): Boolean {
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val appProcesses = activityManager.runningAppProcesses ?: return false
+        val packageName = context.packageName
+        
+        for (appProcess in appProcesses) {
+            if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && 
+                appProcess.processName == packageName) {
+                return true
+            }
+        }
+        return false
+    }
+}

package/android/src/main/java/com/rnsnativecall/CallModule.kt

@@ -1,5 +1,6 @@
 package com.rnsnativecall
 
+import android.app.NotificationManager
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
@@ -9,11 +10,9 @@ import android.telecom.DisconnectCause
 import android.telecom.PhoneAccount
 import android.telecom.PhoneAccountHandle
 import android.telecom.TelecomManager
+import android.widget.Toast
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import android.widget.Toast
-import com.google.android.material.snackbar.Snackbar
-import android.view.View
 
 class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -30,45 +29,33 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     }
 
     private fun registerPhoneAccount() {
-    val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-    val phoneAccountHandle = getPhoneAccountHandle()
-
-    val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
-
-    // ✅ FIXED: Removed CAPABILITY_CALL_PROVIDER
-    // Self-managed apps only need these specific flags
-    val capabilities = PhoneAccount.CAPABILITY_VIDEO_CALLING or
-                          PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING
-
-    val phoneAccount = PhoneAccount.builder(phoneAccountHandle, appName)
-        .setCapabilities(capabilities)
-        .setShortDescription(appName)
-        .addSupportedUriScheme("sip")
-        .addSupportedUriScheme("tel")
-        .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
-        .setCapabilities(PhoneAccount.CAPABILITY_CALL_PROVIDER)
-        .build()
-
-    telecomManager.registerPhoneAccount(phoneAccount)
-}
-
-    @ReactMethod
-    fun displayIncomingCall(uuid: String, number: String, name: String, hasVideo: Boolean, playRing: Boolean, promise: Promise) {
         val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle()
+        val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
 
-         val extras = Bundle().apply {
-            putParcelable(TelecomManager.EXTRA_INCOMING_CALL_ADDRESS, Uri.fromParts("sip", number, null))
-            putString("EXTRA_CALL_UUID", uuid)
+        val capabilities = PhoneAccount.CAPABILITY_VIDEO_CALLING or
+                PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING or
+                PhoneAccount.CAPABILITY_SELF_MANAGED
 
-            putString("EXTRA_CALLER_NAME", name)
-            putString(TelecomManager.EXTRA_CALL_SUBJECT, number)
-            putBoolean("EXTRA_PLAY_RING", false)
-            putBoolean(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, hasVideo)
+        val phoneAccount = PhoneAccount.builder(phoneAccountHandle, appName)
+            .setCapabilities(capabilities)
+            .setShortDescription(appName)
+            .addSupportedUriScheme("sip")
+            .addSupportedUriScheme("tel")
+            .build()
 
-        }
+        telecomManager.registerPhoneAccount(phoneAccount)
+    }
+
+    @ReactMethod
+    fun displayIncomingCall(uuid: String, name: String, callType: String, promise: Promise) {
         try {
-            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+            val data = mapOf(
+                "callUuid" to uuid,
+                "name" to name,
+                "callType" to callType
+            )
+            NativeCallManager.handleIncomingPush(reactApplicationContext, data)
             promise.resolve(true)
         } catch (e: Exception) {
             promise.reject("CALL_ERROR", e.message)
@@ -77,68 +64,56 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     @ReactMethod
     fun endNativeCall(uuid: String) {
+        val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.cancel(101)
+
         val connection = MyConnectionService.getConnection(uuid)
         connection?.let {
-            it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+            it.setDisconnected(DisconnectCause(DisconnectCause.MISSED))
             it.destroy()
             MyConnectionService.removeConnection(uuid)
         }
     }
 
-    //done             //     val fallbackIntent = Intent(Intent.ACTION_MAIN).apply {
-            //     addCategory(Intent.CATEGORY_LAUNCHER)
-            //     component = ComponentName("com.android.phone", "com.android.phone.CallFeaturesSetting")
-            //     addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            //    }
-            // reactApplicationContext.startActivity(fallbackIntent)
-
     @ReactMethod
-  fun checkTelecomPermissions(promise: Promise) {
-    val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-    val phoneAccountHandle = getPhoneAccountHandle()
-    val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
-
-    val account = telecomManager.getPhoneAccount(phoneAccountHandle)
-    if (account != null && account.isEnabled) {
-        promise.resolve(true)
-    } else {
-        try {
-            // Show a quick message to guide the user
-            val text = "Tap 'Active calling accounts' and then enable $appName"
-val duration = Toast.LENGTH_LONG
-val toast = Toast.makeText(reactApplicationContext, text, duration)
-
-toast.show()
-
-// Show again after 3.5s
-android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
-    toast.show()
-}, 3500)
-
-
-            // Open Calling Accounts settings
-            val intent = Intent(TelecomManager.ACTION_CHANGE_PHONE_ACCOUNTS)
-            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            reactApplicationContext.startActivity(intent)
+    fun checkTelecomPermissions(promise: Promise) {
+        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val phoneAccountHandle = getPhoneAccountHandle()
+        val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
 
-            promise.resolve(false)
-        } catch (e: Exception) {
-            promise.reject("PERMISSION_ERROR", "Could not open settings: ${e.message}")
+        val account = telecomManager.getPhoneAccount(phoneAccountHandle)
+        if (account != null && account.isEnabled) {
+            promise.resolve(true)
+        } else {
+            try {
+                Toast.makeText(reactApplicationContext, "Tap 'Active calling accounts' and then enable $appName", Toast.LENGTH_LONG).show()
+                val intent = Intent(TelecomManager.ACTION_CHANGE_PHONE_ACCOUNTS)
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                reactApplicationContext.startActivity(intent)
+                promise.resolve(false)
+            } catch (e: Exception) {
+                promise.reject("PERMISSION_ERROR", e.message)
+            }
         }
     }
-}
 
+    @ReactMethod
+    fun getInitialCallData(promise: Promise) {
+        promise.resolve(pendingCallData)
+        pendingCallData = null // Clear after consumption
+    }
 
     @ReactMethod fun addListener(eventName: String) {}
     @ReactMethod fun removeListeners(count: Int) {}
 
     companion object {
         private var instance: CallModule? = null
+        private var pendingCallData: WritableMap? = null
 
         @JvmStatic
         fun sendEventToJS(eventName: String, params: Any?) {
-            val reactContext = instance?.reactApplicationContext ?: return
-            
+            val reactContext = instance?.reactApplicationContext
+
             val bridgeData = when (params) {
                 is Map<*, *> -> {
                     val map = Arguments.createMap()
@@ -148,14 +123,21 @@ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
                     map
                 }
                 is String -> {
-                    Arguments.createMap().apply { putString("callUUID", params) }
+                    Arguments.createMap().apply { putString("callUuid", params) }
                 }
                 else -> null
             }
 
-            reactContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                ?.emit(eventName, bridgeData)
+            if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit(eventName, bridgeData)
+            } else {
+                // If app is dead/cold-starting, cache the accept event
+                if (eventName == "onCallAccepted") {
+                    pendingCallData = bridgeData
+                }
+            }
         }
     }
 }

package/android/src/main/java/com/rnsnativecall/NativeCallManager.kt

@@ -11,49 +11,55 @@ import androidx.core.app.NotificationCompat
 object NativeCallManager {
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
-        val uuid = data["callId"] ?: return
+        val uuid = data["callUuid"] ?: return
         val name = data["name"] ?: "Incoming Call"
         val callType = data["callType"] ?: "audio"
 
-        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        // Use MUTABLE flag to ensure extras are properly passed on Android 12+
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
         } else {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        // 1. DUMMY INTENT: This is the key to making the Pill "Sticky".
-        // It prevents the notification from disappearing but doesn't open a screen.
+        // 1. DUMMY INTENT: Keeps the notification "Sticky" (Persistent)
         val dummyIntent = PendingIntent.getActivity(
             context, 
             0, 
             Intent(), 
-            pendingFlags
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
         )
 
-// 2. Accept Action
-val acceptIntent = Intent(context, AcceptCallActivity::class.java).apply {
-    action = "ACTION_ACCEPT"
-    putExtra("EXTRA_CALL_UUID", uuid)
-    data.forEach { (key, value) -> putExtra(key, value) }
-    // Crucial for launching from a notification
-    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
-}
+        // 2. Accept Action - Use unique action and requestCode
+        val acceptIntent = Intent(context, AcceptCallActivity::class.java).apply {
+            // Unique action string prevents intent caching issues
+            action = "ACTION_ACCEPT_$uuid" 
+            putExtra("EXTRA_CALL_UUID", uuid)
+            // Flatten the map into the intent extras
+            data.forEach { (key, value) -> putExtra(key, value) }
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        }
+
+        val acceptPendingIntent = PendingIntent.getActivity(
+            context, 
+            uuid.hashCode(), // Unique RequestCode
+            acceptIntent, 
+            pendingFlags
+        )
 
-// Keep this as getActivity
-val acceptPendingIntent = PendingIntent.getActivity(
-    context, 
-    1001, 
-    acceptIntent, 
-    pendingFlags
-)
-        // 3. Reject Action
+        // 3. Reject Action - Use unique action and requestCode
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            action = "ACTION_REJECT"
+            action = "ACTION_REJECT_$uuid"
             putExtra("EXTRA_CALL_UUID", uuid)
         }
-        val rejectPendingIntent = PendingIntent.getBroadcast(context, 1002, rejectIntent, pendingFlags)
+        val rejectPendingIntent = PendingIntent.getBroadcast(
+            context, 
+            uuid.hashCode() + 1, // Unique RequestCode
+            rejectIntent, 
+            pendingFlags
+        )
 
-        // 4. Setup Channel (Ensure Importance is HIGH)
+        // 4. Setup Channel
         val channelId = "CALL_CHANNEL_ID"
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -61,7 +67,6 @@ val acceptPendingIntent = PendingIntent.getActivity(
             val channel = NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
                 description = "Shows incoming call notifications"
                 enableVibration(true)
-                // Critical for bypassing "Do Not Disturb"
                 setBypassDnd(true)
                 lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
             }
@@ -75,10 +80,11 @@ val acceptPendingIntent = PendingIntent.getActivity(
             .setContentText(name)
             .setPriority(NotificationCompat.PRIORITY_MAX)
             .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setOngoing(true) // Prevents user from swiping it away
+            .setOngoing(true) 
             .setAutoCancel(false)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
             
-            // This is what keeps the Heads-Up "Pill" visible indefinitely:
+            // This hack keeps the Heads-Up "Pill" visible until action is taken
             .setFullScreenIntent(dummyIntent, true) 
             
             .addAction(0, "Answer", acceptPendingIntent)

package/index.d.ts

@@ -18,18 +18,14 @@ export interface CallHandlerType {
     /**
      * Display an incoming call UI using ConnectionService (Android) or CallKit (iOS).
      * @param uuid Unique call identifier
-     * @param number Caller number (or URI)
      * @param name Caller display name
-     * @param hasVideo True if video call (default: false)
-     * @param shouldRing True to play native ringtone (default: true)
+     * @param callType True if video call (default: false)
      * @returns Promise resolving to true if successfully displayed
      */
     displayCall(
         uuid: string,
-        number: string,
         name: string,
-        hasVideo?: boolean,
-        shouldRing?: boolean
+        callType: string,
     ): Promise<boolean>;
 
     /**

package/index.js

@@ -35,7 +35,7 @@ export async function ensureAndroidPermissions() {
 }
 
 export const CallHandler = {
-    displayCall: async (uuid, number, name, hasVideo = false, shouldRing = true) => {
+    displayCall: async (uuid, name, callType) => {
         if (!CallModule) return false;
 
         // if (Platform.OS === 'android') {
@@ -46,10 +46,8 @@ export const CallHandler = {
         try {
             return await CallModule.displayIncomingCall(
                 uuid.toLowerCase().trim(),
-                number,
                 name,
-                hasVideo,
-                shouldRing
+                callType,
             );
         } catch (e) {
             // console.log("Native Call Error:", e);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.1.7",
+    "version": "0.1.8",
     "description": "RNS nativecall component with native Android/iOS for handling native call ui, when app is not open or open.",
     "main": "index.js",
     "types": "index.d.ts",

package/withNativeCallVoip.js

@@ -1,11 +1,41 @@
-const { withAndroidManifest, withInfoPlist, withPlugins } = require('@expo/config-plugins');
+const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity } = require('@expo/config-plugins');
 
+/** 1. ANDROID MAIN ACTIVITY MOD (Fixes data passing) **/
+function withMainActivityDataFix(config) {
+    return withMainActivity(config, (config) => {
+        let contents = config.modResults.contents;
+
+        // Add necessary import
+        if (!contents.includes('import android.content.Intent')) {
+            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
+        }
+
+        // Add onNewIntent override to ensure data is updated when app is already open
+        const onNewIntentCode = `
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+  }
+`;
+
+        if (!contents.includes('override fun onNewIntent')) {
+            // Find the last closing brace and insert before it
+            const lastBraceIndex = contents.lastIndexOf('}');
+            contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
+        }
+
+        config.modResults.contents = contents;
+        return config;
+    });
+}
+
+/** 2. ANDROID MANIFEST CONFIG **/
 function withAndroidConfig(config) {
     return withAndroidManifest(config, (config) => {
         const manifest = config.modResults;
         const application = manifest.manifest.application[0];
 
-        // 1. Permissions
+        // Permissions
         const permissions = [
             'android.permission.READ_PHONE_NUMBERS',
             'android.permission.CALL_PHONE',
@@ -23,22 +53,16 @@ function withAndroidConfig(config) {
             }
         });
 
-        // 2. Activities (UI Components)
+        // Activities
         application.activity = application.activity || [];
 
-        // IncomingCallActivity (Optional lock screen UI)
-        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.IncomingCallActivity')) {
-            application.activity.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.IncomingCallActivity',
-                    'android:showOnLockScreen': 'true',
-                    'android:launchMode': 'singleInstance',
-                    'android:theme': '@style/Theme.AppCompat.Light.NoActionBar'
-                }
-            });
+        // Update MainActivity to use singleTask for better call handling
+        const mainActivity = application.activity.find(a => a.$['android:name'] === '.MainActivity');
+        if (mainActivity) {
+            mainActivity.$['android:launchMode'] = 'singleTask';
         }
 
-        // AcceptCallActivity (The "Trampoline" that fixes the Answer button)
+        // AcceptCallActivity (Trampoline)
         if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
             application.activity.push({
                 $: {
@@ -52,7 +76,7 @@ function withAndroidConfig(config) {
             });
         }
 
-        // 3. Services (FCM and Telecom)
+        // Services
         application.service = application.service || [];
         const services = [
             { name: 'com.rnsnativecall.MyConnectionService', permission: 'android.permission.BIND_CONNECTION_SERVICE', action: 'android.telecom.ConnectionService' },
@@ -68,7 +92,7 @@ function withAndroidConfig(config) {
             }
         });
 
-        // 4. Receivers (The Decline Button)
+        // Receivers
         application.receiver = application.receiver || [];
         if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.CallActionReceiver')) {
             application.receiver.push({
@@ -80,7 +104,7 @@ function withAndroidConfig(config) {
     });
 }
 
-/** IOS Config remains the same **/
+/** 3. IOS CONFIG **/
 function withIosConfig(config) {
     return withInfoPlist(config, (config) => {
         const infoPlist = config.modResults;
@@ -91,5 +115,5 @@ function withIosConfig(config) {
 }
 
 module.exports = (config) => {
-    return withPlugins(config, [withAndroidConfig, withIosConfig]);
+    return withPlugins(config, [withAndroidConfig, withMainActivityDataFix, withIosConfig]);
 };