rns-nativecall 0.3.6 → 0.3.9

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/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
@@ -17,89 +20,104 @@ class CallMessagingService : FirebaseMessagingService() {
     companion object {
         private val handler = Handler(Looper.getMainLooper())
         private val pendingNotifications = mutableMapOf<String, Runnable>()
-        // This is the standard ID used for the incoming call notification pill
-        private const val CALL_NOTIFICATION_ID = 123 
     }
 
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         val context = applicationContext
-        
         val uuid = data["callUuid"] ?: return
         val type = data["type"] ?: ""
 
         if (type == "CANCEL") {
-            pendingNotifications[uuid]?.let {
-                handler.removeCallbacks(it)
-                pendingNotifications.remove(uuid)
-            }
-            
-            // 1. Stop the ringtone
-            NativeCallManager.stopRingtone()
-            
-            // 2. DISMISS THE PILL (Direct Native Way)
-            val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            notificationManager.cancel(CALL_NOTIFICATION_ID) 
-            
-            // 3. Show Missed Call
-            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
+}
         
         if (isAppInForeground(context)) {
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-            launchIntent?.apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                putExtra("background_wake", true) 
-            }
-            context.startActivity(launchIntent)
-            
-            val showNotificationRunnable = Runnable {
-                if (!isAppInForeground(context)) {
-                    NativeCallManager.handleIncomingPush(context, data)
-                }
-                pendingNotifications.remove(uuid)
-            }
+    // 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)
+    
+    // 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()
+    }
 
-            pendingNotifications[uuid] = showNotificationRunnable
-            handler.postDelayed(showNotificationRunnable, 18000)
+    // 4. Start the 18s backup timer
+    val showNotificationRunnable = Runnable {
+        if (!isAppInForeground(context)) {
+            NativeCallManager.handleIncomingPush(context, data)
         }
+        pendingNotifications.remove(uuid)
+    }
+    pendingNotifications[uuid] = showNotificationRunnable
+    handler.postDelayed(showNotificationRunnable, 18000) 
+}
     }
 
     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" 
+        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
 
+        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)
+            .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/CallModule.kt

@@ -23,7 +23,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             writableMap
         }
         promise.resolve(data)
-        pendingCallDataMap = null // Clear after use
+        pendingCallDataMap = null
     }
 
     @ReactMethod
@@ -48,7 +48,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         pendingCallDataMap = null
         
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(101)
+        notificationManager.cancel(uuid.hashCode())
     }
 
     @ReactMethod

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

@@ -14,7 +14,7 @@ import android.graphics.Color
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
-    private const val NOTIFICATION_ID = 101
+    const val CALL_CHANNEL_ID = "CALL_CHANNEL_ID"
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
@@ -28,90 +28,87 @@ 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 Call", NotificationManager.IMPORTANCE_HIGH).apply {
                 setBypassDnd(true)
                 lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                // On Android O+, sound should be set on the channel
+                enableVibration(true) //can be removed
                 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)
-            .setPriority(NotificationCompat.PRIORITY_MAX)
+
+            .setPriority(NotificationCompat.PRIORITY_HIGH) //old was PRIORITY_MAX
             .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
+            .setFullScreenIntent(fullScreenPendingIntent, false) //can be true
+            .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/app.plugin.js

@@ -1,6 +1,13 @@
-////Users/bush/Desktop/Apps/Raiidr/package/app.plugin.js
+///app.plugin.js
+const { withPlugins } = require('@expo/config-plugins');
 const withNativeCallVoip = require('./withNativeCallVoip');
+const withCallNativeConfig = require('./withCallNativeConfig');
+const withCallPermissions = require('./withCallPermissions');
 
-module.exports = function (config) {
-    return withNativeCallVoip(config);
+module.exports = function (config, props) {
+    return withPlugins(config, [
+        [withNativeCallVoip, props],
+        [withCallNativeConfig, props],
+        [withCallPermissions, props],
+    ]);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.3.6",
+    "version": "0.3.9",
     "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,8 @@
         "react-native.config.js",
         "README.md",
         "rns-nativecall.podspec",
+        "withCallNativeConfig.js",
+        "withCallPermissions.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/withCallPermissions.js

@@ -0,0 +1,40 @@
+const { withAndroidManifest } = require("@expo/config-plugins");
+
+/** 2. ANDROID MANIFEST MOD **/
+function withCallPermissions(config) {
+    return withAndroidManifest(config, async (config) => {
+        const androidManifest = config.modResults.manifest;
+
+        // 1. Add the Full Screen Intent Permission
+        if (!androidManifest["uses-permission"]) {
+            androidManifest["uses-permission"] = [];
+        }
+
+        const hasPermission = androidManifest["uses-permission"].some(
+            (p) => p.$["android:name"] === "android.permission.USE_FULL_SCREEN_INTENT"
+        );
+
+        if (!hasPermission) {
+            androidManifest["uses-permission"].push({
+                $: { "android:name": "android.permission.USE_FULL_SCREEN_INTENT" },
+            });
+        }
+
+        // 2. Ensure the Activity has the correct flags to appear over lockscreen
+        const mainApplication = androidManifest.application[0];
+        const mainActivity = mainApplication.activity.find(
+            (a) => a.$["android:name"] === ".MainActivity"
+        );
+
+        if (mainActivity) {
+            mainActivity.$["android:showOnLockScreen"] = "true";
+            mainActivity.$["android:lockTaskMode"] = "if_whitelisted";
+        }
+
+        return config;
+    });
+}
+
+module.exports = (config) => {
+    return withPlugins(config, [withCallPermissions]);
+};

package/withNativeCallVoip.js

@@ -1,46 +1,140 @@
 const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity } = require('@expo/config-plugins');
 
+/** 1. ANDROID MAIN ACTIVITY MOD **/
+// function withMainActivityDataFix(config) {
+//     return withMainActivity(config, (config) => {
+//         let contents = config.modResults.contents;
+
+//         // 1. Ensure necessary Imports are present
+//         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`);
+//         }
+
+//         // 2. Define the code blocks
+//         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 silently, move to back to prevent UI flicker
+//     if (intent.getBooleanExtra("background_wake", false)) {
+//         moveTaskToBack(true)
+//     }
+//   }
+// `;
+
+//         // 3. Insert the codes before the last closing brace of the class
+//         if (!contents.includes('override fun onNewIntent')) {
+//             const lastBraceIndex = contents.lastIndexOf('}');
+//             contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
+//         }
+
+//         if (!contents.includes('override fun onCreate')) {
+//             // Re-calculate lastBraceIndex because contents string has changed
+//             const lastBraceIndex = contents.lastIndexOf('}');
+//             contents = contents.slice(0, lastBraceIndex) + onCreateCode + contents.slice(lastBraceIndex);
+//         }
+
+//         config.modResults.contents = contents;
+//         return config;
+//     });
+// }
+
 /** 1. ANDROID MAIN ACTIVITY MOD **/
 function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
 
-        // 1. Ensure necessary Imports are present
-        if (!contents.includes('import android.content.Intent')) {
-            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
+        // --- 1. Imports ---
+        const neededImports = [
+            'import android.view.WindowManager',
+            'import android.os.Build',
+            'import android.os.Bundle'
+        ];
+
+        neededImports.forEach(imp => {
+            if (!contents.includes(imp)) {
+                contents = contents.replace(/package .*/, (match) => `${match}\n${imp}`);
+            }
+        });
+
+        // --- 2. Replace onCreate ---
+        // We look for the existing onCreate and replace the entire block with your version
+        const editedOnCreate = `
+    // override fun onCreate(savedInstanceState: Bundle?) {
+    //     setTheme(R.style.AppTheme)
+    //     super.onCreate(savedInstanceState)
+
+    //     // --- LOCK SCREEN WAKE LOGIC ---
+    //     // This allows the Activity to appear over the lock screen when Answer is pressed
+    //     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+    //         setShowWhenLocked(true)
+    //         setTurnScreenOn(true)
+    //     } else {
+    //         @Suppress("DEPRECATION")
+    //         window.addFlags(
+    //             WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+    //             WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+    //             WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+    //         )
+    //     }
+    // }
+        override fun onCreate(savedInstanceState: Bundle?) {
+        setTheme(R.style.AppTheme)
+        super.onCreate(savedInstanceState)
+
+        // Only wake the screen/bypass lock if we are coming from a notification interaction
+        // Otherwise, let the notification pill handle the UI.
+        if (intent?.action?.startsWith("ACTION_SHOW_UI") == true) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+                setShowWhenLocked(true)
+                setTurnScreenOn(true)
+            } else {
+                @Suppress("DEPRECATION")
+                window.addFlags(
+                    WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+                    WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+                    WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+                )
+            }
         }
-        if (!contents.includes('import android.os.Bundle')) {
-            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.os.Bundle`);
+    }
+    `;
+
+
+
+
+        // Regex to find the existing onCreate block (including the setTheme and super calls)
+        const onCreateRegex = /override fun onCreate\(savedInstanceState: Bundle\?\).*?\{[\s\S]*?super\.onCreate\(null\)\n\s*\}/;
+        if (contents.match(onCreateRegex)) {
+            contents = contents.replace(onCreateRegex, editedOnCreate);
         }
 
-        // 2. Define the code blocks
+        // --- 3. Update createReactActivityDelegate ---
+        // Removing the "object :" and the empty trailing block "{})" to match your edited version
+        contents = contents.replace(
+            /return ReactActivityDelegateWrapper\([\s\S]*?object : (DefaultReactActivityDelegate\([\s\S]*?\))\{\}\)/,
+            'return ReactActivityDelegateWrapper($1)'
+        );
+
+        // --- 4. Ensure onNewIntent exists ---
         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 silently, move to back to prevent UI flicker
-    if (intent.getBooleanExtra("background_wake", false)) {
-        moveTaskToBack(true)
-    }
-  }
-`;
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+    }`;
 
-        // 3. Insert the codes before the last closing brace of the class
         if (!contents.includes('override fun onNewIntent')) {
             const lastBraceIndex = contents.lastIndexOf('}');
-            contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
-        }
-
-        if (!contents.includes('override fun onCreate')) {
-            // Re-calculate lastBraceIndex because contents string has changed
-            const lastBraceIndex = contents.lastIndexOf('}');
-            contents = contents.slice(0, lastBraceIndex) + onCreateCode + contents.slice(lastBraceIndex);
+            contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + "\n" + contents.slice(lastBraceIndex);
         }
 
         config.modResults.contents = contents;
@@ -59,10 +153,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 +167,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 +180,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 +194,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 +206,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;
     });
 }