rns-nativecall 0.1.6 → 0.1.8

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

@@ -0,0 +1,54 @@
+package com.rnsnativecall
+
+import android.app.Activity
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+
+class AcceptCallActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // 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>()
+        val extras = intent.extras
+        extras?.keySet()?.forEach { key ->
+            val value = extras.get(key)
+            if (value != null) {
+                dataMap[key] = value.toString()
+            }
+        }
+
+        // 3. EMIT EVENT TO REACT NATIVE
+        // This handles the case where the app is already in the background/foreground
+        CallModule.sendEventToJS("onCallAccepted", 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)
+        }
+
+        // 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

@@ -0,0 +1,41 @@
+package com.rnsnativecall
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.app.NotificationManager
+import android.os.Bundle
+
+class CallActionReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val uuid = intent.getStringExtra("EXTRA_CALL_UUID")
+        
+        // 1. Clear the notification
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.cancel(101)
+
+        if (intent.action == "ACTION_ACCEPT") {
+            // 2. Prepare the data for React Native
+            val dataMap = mutableMapOf<String, String>()
+            intent.extras?.keySet()?.forEach { key ->
+                intent.getStringExtra(key)?.let { dataMap[key] = it }
+            }
+
+            // 3. Send the event to JS if the app is already running in background
+            CallModule.sendEventToJS("onCallAccepted", dataMap)
+
+            // 4. Bring the app to foreground
+            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            launchIntent?.apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                // Forward the extras so the App can read them on startup/resume
+                putExtras(intent.extras ?: Bundle())
+                putExtra("navigatingToCall", true)
+            }
+            context.startActivity(launchIntent)
+        } else {
+            // Logic for Reject
+            CallModule.sendEventToJS("onCallRejected", mapOf("callUUID" to uuid))
+        }
+    }
+}

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

@@ -1,55 +1,95 @@
 package com.rnsnativecall
 
-import android.content.ComponentName
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
 import android.content.Context
-import android.net.Uri
-import android.os.Bundle
-import android.telecom.PhoneAccountHandle
-import android.telecom.TelecomManager
-import android.telecom.VideoProfile
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
 
 object NativeCallManager {
 
- // Inside NativeCallManager.kt
-fun handleIncomingPush(context: Context, data: Map<String, String>) {
-    val uuid = data["callId"] ?: ""
-    val name = data["name"] ?: "Unknown"
-    
-    // Create the Intent for the FullScreen Activity
-    val fullScreenIntent = Intent(context, IncomingCallActivity::class.java).apply {
-        flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION
-        putExtra("EXTRA_CALL_UUID", uuid)
-        putExtra("EXTRA_CALLER_NAME", name)
-    }
+    fun handleIncomingPush(context: Context, data: Map<String, String>) {
+        val uuid = data["callUuid"] ?: return
+        val name = data["name"] ?: "Incoming Call"
+        val callType = data["callType"] ?: "audio"
 
-    val fullScreenPendingIntent = PendingIntent.getActivity(context, 0,
-        fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-
-    // Build the Notification
-    val notificationBuilder = NotificationCompat.Builder(context, "CALL_CHANNEL_ID")
-        .setSmallIcon(context.applicationInfo.icon)
-        .setContentTitle("Incoming Call")
-        .setContentText(name)
-        .setPriority(NotificationCompat.PRIORITY_MAX)
-        .setCategory(NotificationCompat.CATEGORY_CALL)
-        .setFullScreenIntent(fullScreenPendingIntent, true) // High Priority HUN
-        .setOngoing(true)
-        .setAutoCancel(false)
-
-    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    
-    // Create Channel for Android O+
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        val channel = NotificationChannel("CALL_CHANNEL_ID", "Incoming Calls", NotificationManager.IMPORTANCE_HIGH)
-        notificationManager.createNotificationChannel(channel)
-    }
+        // 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: Keeps the notification "Sticky" (Persistent)
+        val dummyIntent = PendingIntent.getActivity(
+            context, 
+            0, 
+            Intent(), 
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
+        )
+
+        // 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
+        )
+
+        // 3. Reject Action - Use unique action and requestCode
+        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_REJECT_$uuid"
+            putExtra("EXTRA_CALL_UUID", uuid)
+        }
+        val rejectPendingIntent = PendingIntent.getBroadcast(
+            context, 
+            uuid.hashCode() + 1, // Unique RequestCode
+            rejectIntent, 
+            pendingFlags
+        )
+
+        // 4. Setup Channel
+        val channelId = "CALL_CHANNEL_ID"
+        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)
+                setBypassDnd(true)
+                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+            }
+            notificationManager.createNotificationChannel(channel)
+        }
 
-    notificationManager.notify(101, notificationBuilder.build())
-}
- 
+        // 5. Build the Notification
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(context.applicationInfo.icon)
+            .setContentTitle("Incoming $callType call")
+            .setContentText(name)
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setOngoing(true) 
+            .setAutoCancel(false)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            
+            // This hack keeps the Heads-Up "Pill" visible until action is taken
+            .setFullScreenIntent(dummyIntent, true) 
+            
+            .addAction(0, "Answer", acceptPendingIntent)
+            .addAction(0, "Decline", rejectPendingIntent)
 
-    private fun getPhoneAccountHandle(context: Context): PhoneAccountHandle {
-        val componentName = ComponentName(context, MyConnectionService::class.java)
-        return PhoneAccountHandle(componentName, "${context.packageName}.voip")
+        notificationManager.notify(101, builder.build())
     }
 }

package/android/src/main/res/values/styles.xml

@@ -1,3 +1,12 @@
-<style name="CircleImage">
-    <item name="cornerSize">50%</item>
-</style>
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="CircleImage" parent="">
+        <item name="cornerSize">50%</item>
+    </style>
+
+    <style name="Theme.IncomingCall" parent="Theme.AppCompat.Light.NoActionBar">
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowAnimationStyle">@android:style/Animation.Translucent</item>
+    </style>
+</resources>

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,21 +35,19 @@ 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') {
-            const hasPerms = await ensureAndroidPermissions();
-            if (!hasPerms) return false;
-        }
+        // if (Platform.OS === 'android') {
+        //     const hasPerms = await ensureAndroidPermissions();
+        //     if (!hasPerms) return false;
+        // }
 
         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.6",
+    "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,14 +1,41 @@
-const { withAndroidManifest, withInfoPlist, withPlugins } = require('@expo/config-plugins');
+const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity } = require('@expo/config-plugins');
 
-/**
- * ANDROID CONFIGURATION
- */
+/** 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. Unified Permissions List
+        // Permissions
         const permissions = [
             'android.permission.READ_PHONE_NUMBERS',
             'android.permission.CALL_PHONE',
@@ -26,84 +53,67 @@ function withAndroidConfig(config) {
             }
         });
 
-        // 2. Register IncomingCallActivity
+        // Activities
         application.activity = application.activity || [];
-        const activityName = 'com.rnsnativecall.IncomingCallActivity';
-        if (!application.activity.some(a => a.$['android:name'] === activityName)) {
+
+        // 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 (Trampoline)
+        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
             application.activity.push({
                 $: {
-                    'android:name': activityName,
-                    'android:showOnLockScreen': 'true',
-                    'android:launchMode': 'singleInstance',
+                    'android:name': 'com.rnsnativecall.AcceptCallActivity',
+                    'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
                     'android:excludeFromRecents': 'true',
-                    'android:screenOrientation': 'portrait',
-                    'android:theme': '@style/Theme.AppCompat.Light.NoActionBar'
+                    'android:noHistory': 'true',
+                    'android:exported': 'false',
+                    'android:launchMode': 'singleInstance'
                 }
             });
         }
 
-        // 3. Services (ConnectionService & FCM)
+        // Services
         application.service = application.service || [];
-
         const services = [
-            {
-                name: 'com.rnsnativecall.MyConnectionService',
-                permission: 'android.permission.BIND_CONNECTION_SERVICE',
-                action: 'android.telecom.ConnectionService',
-                exported: 'true'
-            },
-            {
-                name: 'com.rnsnativecall.CallMessagingService',
-                action: 'com.google.firebase.MESSAGING_EVENT',
-                exported: 'false'
-            }
+            { name: 'com.rnsnativecall.MyConnectionService', permission: 'android.permission.BIND_CONNECTION_SERVICE', action: 'android.telecom.ConnectionService' },
+            { name: 'com.rnsnativecall.CallMessagingService', action: 'com.google.firebase.MESSAGING_EVENT' }
         ];
 
         services.forEach(svc => {
             if (!application.service.some(s => s.$['android:name'] === svc.name)) {
-                const serviceObj = {
-                    $: { 'android:name': svc.name, 'android:exported': svc.exported },
+                application.service.push({
+                    $: { 'android:name': svc.name, 'android:exported': svc.permission ? 'true' : 'false', 'android:permission': svc.permission },
                     'intent-filter': [{ action: [{ $: { 'android:name': svc.action } }] }]
-                };
-                if (svc.permission) serviceObj.$['android:permission'] = svc.permission;
-                application.service.push(serviceObj);
+                });
             }
         });
 
+        // Receivers
+        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;
     });
 }
 
-/**
- * IOS CONFIGURATION
- */
+/** 3. IOS CONFIG **/
 function withIosConfig(config) {
     return withInfoPlist(config, (config) => {
         const infoPlist = config.modResults;
-
-        // 1. Add background modes
-        if (!infoPlist.UIBackgroundModes) {
-            infoPlist.UIBackgroundModes = [];
-        }
-
-        ['voip', 'audio'].forEach((mode) => {
-            if (!infoPlist.UIBackgroundModes.includes(mode)) {
-                infoPlist.UIBackgroundModes.push(mode);
-            }
-        });
-
-        // 2. Dynamic Microphone Description
-        const appName = config.name || 'this app';
-        infoPlist.NSMicrophoneUsageDescription =
-            infoPlist.NSMicrophoneUsageDescription || `Allow ${appName} to access your microphone for calls.`;
-
+        if (!infoPlist.UIBackgroundModes) infoPlist.UIBackgroundModes = [];
+        ['voip', 'audio'].forEach(mode => { if (!infoPlist.UIBackgroundModes.includes(mode)) infoPlist.UIBackgroundModes.push(mode); });
         return config;
     });
 }
 
 module.exports = (config) => {
-    return withPlugins(config, [
-        withAndroidConfig,
-        withIosConfig,
-    ]);
-};
+    return withPlugins(config, [withAndroidConfig, withMainActivityDataFix, withIosConfig]);
+};