rns-nativecall 0.3.5 → 0.3.8

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

@@ -9,16 +9,10 @@ import android.os.Bundle
 class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        NativeCallManager.stopRingtone()
-        // 1. CLEAR THE NOTIFICATION
-        // Use the same ID (101) used in NativeCallManager
-        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(101)
-
-        // 2. EXTRACT DATA SAFELY
-        // We iterate through all extras and convert them to Strings for the JS Map
-        val dataMap = mutableMapOf<String, String>()
+        
+        // 1. EXTRACT DATA SAFELY
         val extras = intent.extras
+        val dataMap = mutableMapOf<String, String>()
         extras?.keySet()?.forEach { key ->
             val value = extras.get(key)
             if (value != null) {
@@ -26,30 +20,38 @@ class AcceptCallActivity : Activity() {
             }
         }
 
+        val uuid = dataMap["callUuid"]
+
+        // 2. STOP RINGING & CLEAR THE SPECIFIC NOTIFICATION
+        NativeCallManager.stopRingtone()
+        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        
+        if (uuid != null) {
+            // MATCHING THE NEW HASHCODE LOGIC
+            notificationManager.cancel(uuid.hashCode())
+        } else {
+            // Fallback for safety
+            notificationManager.cancel(101) 
+        }
+
         // 3. EMIT EVENT TO REACT NATIVE
-        // This handles the case where the app is already in the background/foreground
         CallModule.sendEventToJS("onCallAccepted", dataMap)
+        
+        // Ensure the data is available for the JS bridge even if it's just waking up
+        CallModule.setPendingCallData(dataMap)
 
         // 4. LAUNCH OR BRING MAIN APP TO FOREGROUND
         val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
         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)
         }
         
-        CallModule.setPendingCallData(dataMap)
         // 5. FINISH TRAMPOLINE
-        // This ensures this invisible activity doesn't stay in the "Recent Apps" list
         finish()
     }
 }

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

@@ -8,30 +8,36 @@ import android.os.Bundle
 
 class CallActionReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
+        // 1. Always stop the ringtone immediately
         NativeCallManager.stopRingtone()
+        
         val uuid = intent.getStringExtra("EXTRA_CALL_UUID")
         
-        // 1. Clear the notification
+        val action = intent.action
+        
+        // 2. Clear the specific notification using the hash code
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(101)
+        if (uuid != null) {
+            notificationManager.cancel(uuid.hashCode())
+        } else {
+            notificationManager.cancel(101) // Fallback for safety
+        }
 
-        if (intent.action == "ACTION_ACCEPT") {
-            // 2. Prepare the data for React Native
+        // 3. Handle Actions
+        // We check for .contains or .startsWith because our actions are "ACTION_REJECT_$uuid"
+        if (action?.contains("ACTION_ACCEPT") == true || action?.contains("ACTION_SHOW_UI") == true) {
             val dataMap = mutableMapOf<String, String>()
             intent.extras?.keySet()?.forEach { key ->
-                // Using get(key).toString() is safer than getString(key) 
-                // because some extras might be Ints or Booleans
                 intent.extras?.get(key)?.let { dataMap[key] = it.toString() }
             }
 
-            // --- THE COLD START FIX ---
-            // Store data in the "Holding Gate" inside CallModule
+            // Store data for the JS Bridge "Holding Gate"
             CallModule.setPendingCallData(dataMap)
 
-            // 3. Send event (works if app is already active)
+            // Emit event for active JS bridge
             CallModule.sendEventToJS("onCallAccepted", dataMap)
 
-            // 4. Bring the app to foreground
+            // Bring app to foreground
             val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
             launchIntent?.apply {
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
@@ -40,7 +46,7 @@ class CallActionReceiver : BroadcastReceiver() {
             }
             context.startActivity(launchIntent)
             
-        } else if (intent.action == "ACTION_REJECT") {
+        } else if (action?.contains("ACTION_REJECT") == true) {
             // Logic for Reject
             CallModule.sendEventToJS("onCallRejected", mapOf("callUuid" to (uuid ?: "")))
         }

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

@@ -6,15 +6,15 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.jstasks.HeadlessJsTaskConfig
 
 class CallHeadlessTask : HeadlessJsTaskService() {
-    override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig? {
-        val extras = intent.extras
+    // Note: The '?' after Intent and the return type are specific in Kotlin
+    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+        val extras = intent?.extras
         return if (extras != null) {
-            // INCREASE timeout to 30000 (30s) so it covers your 18s delay
             HeadlessJsTaskConfig(
                 "ColdStartCallTask",
                 Arguments.fromBundle(extras),
                 30000, 
-                true // Allow in foreground
+                true 
             )
         } else {
             null

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

@@ -7,6 +7,9 @@ import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.app.NotificationManager
+import android.app.NotificationChannel
+import android.app.PendingIntent
+import android.os.Build
 import androidx.core.app.NotificationCompat
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
@@ -14,7 +17,6 @@ import com.facebook.react.HeadlessJsTaskService
 
 class CallMessagingService : FirebaseMessagingService() {
 
-    // This companion object allows the Cancel logic to find the active timer
     companion object {
         private val handler = Handler(Looper.getMainLooper())
         private val pendingNotifications = mutableMapOf<String, Runnable>()
@@ -23,96 +25,99 @@ class CallMessagingService : FirebaseMessagingService() {
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         val context = applicationContext
-        
-        // Extract variables for logic
         val uuid = data["callUuid"] ?: return
         val type = data["type"] ?: ""
 
-        // CASE 1: CALLER HUNG UP / CANCELLED
         if (type == "CANCEL") {
-            // 1. Remove the pending 18s timer for this specific call
-            pendingNotifications[uuid]?.let {
-                handler.removeCallbacks(it)
-                pendingNotifications.remove(uuid)
-            }
-            
-            // 2. Stop the ringtone/Pill if it had already started showing
-            NativeCallManager.stopRingtone()
-            CallHandler.destroyNativeCallUI(uuid) // Ensure native UI is killed
-            
-            // 3. Show standard "Missed Call" notification
-            showMissedCallNotification(context, data, uuid)
-            return
-        }
+    pendingNotifications[uuid]?.let {
+        handler.removeCallbacks(it)
+        pendingNotifications.remove(uuid)
+    }
+    
+    // Pass the uuid so the manager knows exactly which notification to remove
+    NativeCallManager.dismissIncomingCall(context, uuid)
+    
+    showMissedCallNotification(context, data, uuid)
+    return
+}
         
-        // CASE 2: NEW INCOMING CALL
         if (isAppInForeground(context)) {
-            // App is visible: Send event to active JS bridge immediately
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-    // 1. Wake the actual App process by launching the Intent
-    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-    launchIntent?.apply {
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        // This is key: it tells the app to boot the JS but stay minimized
-        putExtra("background_wake", true) 
-    }
-    context.startActivity(launchIntent)
+    // 1. Prepare the Intent
+    val headlessIntent = Intent(context, CallHeadlessTask::class.java)
+    val bundle = Bundle()
+    data.forEach { (k, v) -> bundle.putString(k, v) }
+    headlessIntent.putExtras(bundle)
     
-    // You SHOULD see "Android Bundled..." now because the Activity is starting
+    // 2. Start the Service
+    context.startService(headlessIntent)
     
+    // 3. Acquire WakeLock to prevent the CPU from sleeping during bundling
+    try {
+        HeadlessJsTaskService.acquireWakeLockNow(context)
+    } catch (e: Exception) {
+        e.printStackTrace()
+    }
+
+    // 4. Start the 18s backup timer
     val showNotificationRunnable = Runnable {
         if (!isAppInForeground(context)) {
             NativeCallManager.handleIncomingPush(context, data)
         }
+        pendingNotifications.remove(uuid)
     }
-    handler.postDelayed(showNotificationRunnable, 18000)
+    pendingNotifications[uuid] = showNotificationRunnable
+    handler.postDelayed(showNotificationRunnable, 18000) 
 }
     }
 
-    private fun startHeadlessTask(context: Context, data: Map<String, String>) {
-        val serviceIntent = Intent(context, CallHeadlessTask::class.java)
-        val bundle = Bundle()
-        data.forEach { (key, value) -> bundle.putString(key, value) }
-        serviceIntent.putExtras(bundle)
-        
-        context.startService(serviceIntent)
-        HeadlessJsTaskService.acquireWakeLockNow(context)
-    }
-
     private fun showMissedCallNotification(context: Context, data: Map<String, String>, uuid: String) {
         val name = data["name"] ?: "Unknown"
         val callType = data["callType"] ?: "video"
-        val channelId = "missed_calls" // Ensure this channel is created in your MainApplication or CallManager
+        val channelId = "missed_calls" 
+        val article = if (callType.startsWith("a", ignoreCase = true)) "an" else "a"
+        // 1. Format App Name: Capitalized
+        val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
+        val capitalizedAppName = appName.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
 
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        // Use ic_launcher as fallback if ic_missed_call isn't found
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(channelId, "Missed Calls", NotificationManager.IMPORTANCE_HIGH)
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        // 2. Create Intent to open app when clicking missed call
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+        val contentIntent = PendingIntent.getActivity(context, uuid.hashCode(), launchIntent, pendingFlags)
+
         var iconResId = context.resources.getIdentifier("ic_missed_call", "drawable", context.packageName)
         if (iconResId == 0) iconResId = android.R.drawable.sym_call_missed
 
         val builder = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(iconResId)
-            .setContentTitle("Missed $callType call")
-            .setContentText("You missed a call from $name")
+            .setContentTitle("$capitalizedAppName missed call")
+            .setContentText("You missed $article $callType call from $name")
             .setPriority(NotificationCompat.PRIORITY_HIGH)
             .setAutoCancel(true)
-            .setCategory(NotificationCompat.CATEGORY_MISS)
+            .setContentIntent(contentIntent) // Opens app on click
+            .setCategory(NotificationCompat.CATEGORY_MISSED_CALL) 
 
+        // 3. Use unique hashCode so multiple missed calls are stacked separately
         notificationManager.notify(uuid.hashCode(), builder.build())
     }
 
     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 appProcesses.any { 
+            it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && it.processName == context.packageName 
         }
-        return false
     }
 }

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

@@ -14,7 +14,8 @@ import android.graphics.Color
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
-    private const val NOTIFICATION_ID = 101
+    const val INCOMING_CALL_ID = 101
+    const val CALL_CHANNEL_ID = "CALL_CHANNEL_ID"
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
@@ -28,56 +29,36 @@ object NativeCallManager {
         } else {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
-        // 1. IMPROVED INTENT: Direct to AcceptCallActivity
-        // This is better than a dummy intent because it allows the OS to 
-        // launch your "Accept" logic immediately if the phone is locked.
+
         val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
             action = "ACTION_SHOW_UI_$uuid"
             data.forEach { (key, value) -> putExtra(key, value) }
             addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
         }
 
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context, 
-            uuid.hashCode(), 
-            intentToActivity, 
-            pendingFlags
-        )
+        val fullScreenPendingIntent = PendingIntent.getActivity(context, uuid.hashCode(), intentToActivity, pendingFlags)
 
-        // 2. Reject Action - Still goes to BroadcastReceiver
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
             action = "ACTION_REJECT_$uuid"
             putExtra("EXTRA_CALL_UUID", uuid)
-            // Pass all data so onReject can find the UUID
             data.forEach { (key, value) -> putExtra(key, value) }
         }
-        val rejectPendingIntent = PendingIntent.getBroadcast(
-            context, 
-            uuid.hashCode() + 1, 
-            rejectIntent, 
-            pendingFlags
-        )
-
-        // 3. Setup Channel with high priority
-        val channelId = "CALL_CHANNEL_ID"
+
+        
+        val rejectPendingIntent = PendingIntent.getBroadcast(context, uuid.hashCode() + 1, rejectIntent, pendingFlags)
+
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
-                description = "Shows incoming call notifications"
-                enableVibration(true)
-                vibrationPattern = longArrayOf(0, 500, 500, 500)
-                lightColor = Color.GREEN
+            val channel = NotificationChannel(CALL_CHANNEL_ID, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
                 setBypassDnd(true)
                 lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                // On Android O+, sound should be set on the channel
                 setSound(null, null) 
             }
             notificationManager.createNotificationChannel(channel)
         }
 
-        // 4. Build the Notification
-        val builder = NotificationCompat.Builder(context, channelId)
+        val builder = NotificationCompat.Builder(context, CALL_CHANNEL_ID)
             .setSmallIcon(context.applicationInfo.icon)
             .setContentTitle("Incoming $callType call")
             .setContentText(name)
@@ -85,33 +66,47 @@ object NativeCallManager {
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setOngoing(true) 
             .setAutoCancel(false)
-            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            
-            // This is the key for the "Pill" / Heads-up display
             .setFullScreenIntent(fullScreenPendingIntent, true) 
-            
-            .addAction(0, "Answer", fullScreenPendingIntent) // Same intent as fullScreen
+            .addAction(0, "Answer", fullScreenPendingIntent)
             .addAction(0, "Decline", rejectPendingIntent)
 
-        notificationManager.notify(NOTIFICATION_ID, builder.build())
+        notificationManager.notify(uuid.hashCode(), builder.build())
 
-        // 5. Ringtone with looping logic attempt
         try {
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-                ringtone?.isLooping = true // Android 9+ supports looping natively
-            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) ringtone?.isLooping = true
             ringtone?.play()
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
+        } catch (e: Exception) { e.printStackTrace() }
     }
 
     fun stopRingtone() {
-        if (ringtone?.isPlaying == true) {
-            ringtone?.stop()
+    try {
+        // Use the safe call operator ?. to only run if ringtone isn't null
+        ringtone?.let {
+            if (it.isPlaying) {
+                it.stop()
+            }
         }
+        // Always null it out after stopping
+        ringtone = null
+    } catch (e: Exception) {
+        // Prevent the app from crashing if the system Ringtone service is acting up
+        e.printStackTrace()
         ringtone = null
     }
+}
+
+fun dismissIncomingCall(context: Context, uuid: String?) {
+        stopRingtone()
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        
+        if (uuid != null) {
+            notificationManager.cancel(uuid.hashCode())
+        } else {
+            // Fallback: If for some reason uuid is null, cancel everything 
+            // (Optional: only if you want a safety net)
+            // notificationManager.cancelAll() 
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.3.5",
+    "version": "0.3.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",
@@ -43,6 +43,7 @@
         "react-native.config.js",
         "README.md",
         "rns-nativecall.podspec",
+        "withCallNativeConfig.js",
         "withNativeCallVoip.js"
     ],
     "peerDependencies": {

package/withCallNativeConfig.js

@@ -0,0 +1,147 @@
+const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity } = require('@expo/config-plugins');
+
+/** 1. ANDROID MAIN ACTIVITY MODS **/
+function withMainActivityDataFix(config) {
+    return withMainActivity(config, (config) => {
+        let contents = config.modResults.contents;
+
+        // Ensure necessary Imports
+        if (!contents.includes('import android.content.Intent')) {
+            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
+        }
+        if (!contents.includes('import android.os.Bundle')) {
+            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.os.Bundle`);
+        }
+
+        const onNewIntentCode = `
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+  }
+`;
+
+        const onCreateCode = `
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    // If woken up by a background task, push to back immediately
+    if (intent.getBooleanExtra("background_wake", false)) {
+        moveTaskToBack(true)
+    }
+  }
+`;
+
+        // Insertion logic
+        if (!contents.includes('override fun onNewIntent')) {
+            contents = contents.replace(/class MainActivity : .*/, (match) => `${match}\n${onNewIntentCode}`);
+        }
+
+        if (!contents.includes('override fun onCreate')) {
+            // Find the end of the class or after onNewIntent
+            const lastBraceIndex = contents.lastIndexOf('}');
+            contents = contents.slice(0, lastBraceIndex) + onCreateCode + contents.slice(lastBraceIndex);
+        }
+
+        config.modResults.contents = contents;
+        return config;
+    });
+}
+
+/** 2. ANDROID MANIFEST CONFIG **/
+function withAndroidConfig(config) {
+    return withAndroidManifest(config, (config) => {
+        const manifest = config.modResults.manifest;
+        const application = manifest.application[0];
+
+        // 1. Permissions (Updated for Android 14 compatibility)
+        const permissions = [
+            'android.permission.USE_FULL_SCREEN_INTENT',
+            'android.permission.VIBRATE',
+            'android.permission.FOREGROUND_SERVICE',
+            'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
+            'android.permission.POST_NOTIFICATIONS',
+            'android.permission.WAKE_LOCK',
+            'android.permission.DISABLE_KEYGUARD',
+            'android.permission.RECEIVE_BOOT_COMPLETED'
+        ];
+
+        manifest['uses-permission'] = manifest['uses-permission'] || [];
+        permissions.forEach((perm) => {
+            if (!manifest['uses-permission'].some((p) => p.$['android:name'] === perm)) {
+                manifest['uses-permission'].push({ $: { 'android:name': perm } });
+            }
+        });
+
+        // 2. Activity Setup (AcceptCallActivity)
+        application.activity = application.activity || [];
+        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
+            application.activity.push({
+                $: {
+                    'android:name': 'com.rnsnativecall.AcceptCallActivity',
+                    'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
+                    'android:excludeFromRecents': 'true',
+                    'android:noHistory': 'true',
+                    'android:exported': 'false',
+                    'android:launchMode': 'singleInstance',
+                    'android:showWhenLocked': 'true',
+                    'android:turnScreenOn': 'true'
+                }
+            });
+        }
+
+        // 3. Service Registration (The Headless Enforcer)
+        application.service = application.service || [];
+
+        // Firebase Messaging Service
+        if (!application.service.some(s => s.$['android:name'] === 'com.rnsnativecall.CallMessagingService')) {
+            application.service.push({
+                $: {
+                    'android:name': 'com.rnsnativecall.CallMessagingService',
+                    'android:exported': 'false'
+                },
+                'intent-filter': [{
+                    action: [{ $: { 'android:name': 'com.google.firebase.MESSAGING_EVENT' } }]
+                }]
+            });
+        }
+
+        // Headless Task Service
+        if (!application.service.some(s => s.$['android:name'] === 'com.rnsnativecall.CallHeadlessTask')) {
+            application.service.push({
+                $: {
+                    'android:name': 'com.rnsnativecall.CallHeadlessTask',
+                    'android:exported': 'false' // Headless JS should be internal only
+                }
+            });
+        }
+
+        // 4. Action Receiver
+        application.receiver = application.receiver || [];
+        if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.CallActionReceiver')) {
+            application.receiver.push({
+                $: { 'android:name': 'com.rnsnativecall.CallActionReceiver', 'android:exported': 'false' }
+            });
+        }
+
+        return config;
+    });
+}
+
+/** 3. IOS CONFIG **/
+function withIosConfig(config) {
+    return withInfoPlist(config, (config) => {
+        const infoPlist = config.modResults;
+        if (!infoPlist.UIBackgroundModes) infoPlist.UIBackgroundModes = [];
+        ['voip', 'audio', 'remote-notification'].forEach(mode => {
+            if (!infoPlist.UIBackgroundModes.includes(mode)) infoPlist.UIBackgroundModes.push(mode);
+        });
+        return config;
+    });
+}
+
+module.exports = (config) => {
+    return withPlugins(config, [
+        withAndroidConfig,
+        withMainActivityDataFix,
+        withIosConfig
+    ]);
+};

package/withNativeCallVoip.js

@@ -59,10 +59,11 @@ function withAndroidConfig(config) {
             'android.permission.USE_FULL_SCREEN_INTENT',
             'android.permission.VIBRATE',
             'android.permission.FOREGROUND_SERVICE',
-            'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
+            'android.permission.FOREGROUND_SERVICE_PHONE_CALL', // Required for Android 14
             'android.permission.POST_NOTIFICATIONS',
             'android.permission.WAKE_LOCK',
-            'android.permission.DISABLE_KEYGUARD'
+            'android.permission.DISABLE_KEYGUARD',
+            'android.permission.RECEIVE_BOOT_COMPLETED' // Allows app to wake after phone restart
         ];
 
         manifest.manifest['uses-permission'] = manifest.manifest['uses-permission'] || [];
@@ -72,26 +73,11 @@ function withAndroidConfig(config) {
             }
         });
 
-        // 2. Activity Setup
+        // 2. Activity Setup (Remain unchanged as your logic was correct)
         application.activity = application.activity || [];
+        // ... (Keep your AcceptCallActivity logic here)
 
-        // Add AcceptCallActivity (The Trampoline)
-        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
-            application.activity.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.AcceptCallActivity',
-                    'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
-                    'android:excludeFromRecents': 'true',
-                    'android:noHistory': 'true',
-                    'android:exported': 'false',
-                    'android:launchMode': 'singleInstance',
-                    'android:showWhenLocked': 'true',
-                    'android:turnScreenOn': 'true'
-                }
-            });
-        }
-
-        // 3. Service Setup (Firebase + Headless Task)
+        // 3. Service Setup (CRITICAL UPDATES FOR ANDROID 14)
         application.service = application.service || [];
 
         // Add Firebase Messaging Service
@@ -100,7 +86,9 @@ function withAndroidConfig(config) {
             application.service.push({
                 $: {
                     'android:name': firebaseServiceName,
-                    'android:exported': 'false'
+                    'android:exported': 'false',
+                    // Adding type for Android 14 stability
+                    'android:foregroundServiceType': 'phoneCall'
                 },
                 'intent-filter': [{ action: [{ $: { 'android:name': 'com.google.firebase.MESSAGING_EVENT' } }] }]
             });
@@ -112,7 +100,9 @@ function withAndroidConfig(config) {
             application.service.push({
                 $: {
                     'android:name': headlessServiceName,
-                    'android:exported': 'false'
+                    'android:exported': 'false',
+                    // This ensures the JS bridge is treated as a priority process
+                    'android:foregroundServiceType': 'phoneCall'
                 }
             });
         }
@@ -122,12 +112,15 @@ function withAndroidConfig(config) {
         const receiverName = 'com.rnsnativecall.CallActionReceiver';
         if (!application.receiver.some(r => r.$['android:name'] === receiverName)) {
             application.receiver.push({
-                $: { 'android:name': receiverName, 'android:exported': 'false' }
+                $: { 'android:name': receiverName, 'android:exported': 'false' },
+                'intent-filter': [{
+                    action: [
+                        { $: { 'android:name': 'android.intent.action.BOOT_COMPLETED' } }
+                    ]
+                }]
             });
         }
 
-
-
         return config;
     });
 }