rns-nativecall 0.8.0 → 0.8.2

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

@@ -1,73 +1,88 @@
 package com.rnsnativecall
 
+import android.app.NotificationManager
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import android.app.NotificationManager
 import android.os.Bundle
+import android.util.Log
 
 class CallActionReceiver : BroadcastReceiver() {
-    override fun onReceive(context: Context, intent: Intent) {
-        // Stop sound immediately
-        NativeCallManager.stopRingtone()
-
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
         val uuid = intent.getStringExtra("EXTRA_CALL_UUID") ?: return
         val action = intent.action ?: ""
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        // 1. Reconstruct the full data map from Intent Extras
         val fullDataMap = mutableMapOf<String, String>()
         intent.extras?.keySet()?.forEach { key ->
             intent.extras?.get(key)?.let { fullDataMap[key] = it.toString() }
         }
 
-        val name = fullDataMap["name"] ?: "Someone"
-        val callType = fullDataMap["callType"] ?: "audio"
-
         // --- HANDLE REJECT ---
         if (action == "ACTION_REJECT") {
+            NativeCallManager.dismissIncomingCall(context, uuid)
+            CallForegroundService.stop(context)
+
             if (CallModule.isReady()) {
                 CallModule.sendEventToJS("onCallRejected", fullDataMap)
-                notificationManager.cancel(uuid.hashCode())
-                CallForegroundService.stop(context)
             } else {
                 CallModule.setPendingCallData("onCallRejected_pending", fullDataMap)
-                NativeCallManager.aborting(context, uuid, name, callType)
             }
+            // Just close the shade
+            collapseNotificationShade(context)
         }
 
         // --- HANDLE ANSWER ---
         if (action == "ACTION_ANSWER") {
-            // Dismiss the "Incoming" pill immediately
-            notificationManager.cancel(uuid.hashCode())
+            NativeCallManager.dismissIncomingCall(context, uuid)
 
             if (CallModule.isReady()) {
-                // Inform JS with full payload
                 CallModule.sendEventToJS("onCallAccepted", fullDataMap)
-                CallForegroundService.stop(context)
-                
-                // Open the app
-                launchApp(context, intent.extras)
             } else {
-                // Cold start: Queue full payload and show connecting
                 CallModule.setPendingCallData("onCallAccepted_pending", fullDataMap)
-                NativeCallManager.connecting(context, uuid, name, callType)
-                
-                launchApp(context, intent.extras)
             }
+
+            // This will open your app and the system usually collapses the shade automatically
+            launchApp(context, intent.extras)
+            collapseNotificationShade(context)
         }
     }
 
+    private fun launchApp(
+        context: Context,
+        extras: Bundle?,
+    ) {
+        CallForegroundService.stop(context)
 
-private fun launchApp(context: Context, extras: Bundle?) {
-    val intent = Intent(context, AcceptCallActivity::class.java).apply {
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or 
-                 Intent.FLAG_ACTIVITY_SINGLE_TOP or 
-                 Intent.FLAG_ACTIVITY_CLEAR_TOP)
-        
-        if (extras != null) putExtras(extras)
+        val intent =
+            Intent(context, AcceptCallActivity::class.java).apply {
+                // Use these flags to ensure the app jumps to the front
+                addFlags(
+                    Intent.FLAG_ACTIVITY_NEW_TASK or
+                        Intent.FLAG_ACTIVITY_SINGLE_TOP or
+                        Intent.FLAG_ACTIVITY_REORDER_TO_FRONT,
+                )
+
+                if (extras != null) putExtras(extras)
+            }
+        context.startActivity(intent)
     }
-    context.startActivity(intent)
-}
 
-}
+    private fun collapseNotificationShade(context: Context) {
+        try {
+            // Using reflection for StatusBarManager is safe because we wrap it
+            // in a try-catch. If it fails, it just won't close the shade, but won't crash.
+            val statusBarService = context.getSystemService("statusbar")
+            val statusBarManager = Class.forName("android.app.StatusBarManager")
+            val method = statusBarManager.getMethod("collapsePanels")
+            method.isAccessible = true
+            method.invoke(statusBarService)
+        } catch (e: Exception) {
+            // Log it, but don't do anything else.
+            // DO NOT send ACTION_CLOSE_SYSTEM_DIALOGS here.
+            Log.e("CallActionReceiver", "Safe collapse failed: ${e.message}")
+        }
+    }
+}

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

@@ -8,14 +8,13 @@ import android.content.IntentFilter
 import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
 import android.os.IBinder
+import android.os.Looper
 import androidx.core.app.NotificationCompat
 import com.facebook.react.HeadlessJsTaskService
-import android.os.Handler
-import android.os.Looper
 
 class CallForegroundService : Service() {
-
     private var unlockReceiver: UnlockReceiver? = null // Store reference for unregistering
 
     companion object {
@@ -30,65 +29,91 @@ class CallForegroundService : Service() {
 
     override fun onCreate() {
         super.onCreate()
-        
+
         // --- DYNAMIC REGISTRATION FIX ---
         // Registering here makes the system allow the USER_PRESENT broadcast
         // because the app is already in the Foreground (via this service).
         unlockReceiver = UnlockReceiver()
         val filter = IntentFilter(Intent.ACTION_USER_PRESENT)
-        
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            // Android 13+ requires the RECEIVER_EXPORTED flag for system broadcasts
-            registerReceiver(unlockReceiver, filter, Context.RECEIVER_EXPORTED)
+            // Prefer NOT_EXPORTED for dynamically-registered receivers to avoid
+            // background delivery issues and to restrict broadcasts to our process.
+            registerReceiver(unlockReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
         } else {
             registerReceiver(unlockReceiver, filter)
         }
     }
 
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    override fun onStartCommand(
+        intent: Intent?,
+        flags: Int,
+        startId: Int,
+    ): Int {
         val data = intent?.extras
         val name = data?.getString("name") ?: "Someone"
-        
+
         createNotificationChannel()
 
-        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle(name)
-            .setContentText("Incoming Call...")
-            .setSmallIcon(applicationInfo.icon)
-            .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setPriority(NotificationCompat.PRIORITY_HIGH) 
-            .setOngoing(true)
-            .build()
+        val notification =
+            NotificationCompat
+                .Builder(this, CHANNEL_ID)
+                .setContentTitle(name)
+                .setContentText("Incoming Call...")
+                .setSmallIcon(applicationInfo.icon)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setOngoing(true)
+                .build()
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             startForeground(
-                NOTIFICATION_ID, 
-                notification, 
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
+                NOTIFICATION_ID,
+                notification,
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL,
             )
         } else {
             startForeground(NOTIFICATION_ID, notification)
         }
 
         // Launch the Headless Task
-        val headlessIntent = Intent(this, CallHeadlessTask::class.java).apply {
-            val bundle = Bundle()
-            data?.let { b ->
-                for (key in b.keySet()) {
-                    bundle.putString(key, b.get(key)?.toString())
+        val headlessIntent =
+            Intent(this, CallHeadlessTask::class.java).apply {
+                val bundle = Bundle()
+                data?.let { b ->
+                    for (key in b.keySet()) {
+                        bundle.putString(key, b.get(key)?.toString())
+                    }
                 }
+                putExtras(bundle)
             }
-            putExtras(bundle)
-        }
-        
+
         try {
             this.startService(headlessIntent)
             HeadlessJsTaskService.acquireWakeLockNow(this)
-        } catch (e: Exception) { e.printStackTrace() }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        // // Trigger the incoming call notification UI handled by NativeCallManager
+        // try {
+        //     val map = mutableMapOf<String, String>()
+        //     data?.let { b ->
+        //         for (key in b.keySet()) {
+        //             map[key] = b.get(key)?.toString() ?: ""
+        //         }
+        //     }
+        //     NativeCallManager.handleIncomingPush(this, map)
+        // } catch (e: Exception) {
+        //     e.printStackTrace()
+        // }
 
         // Auto-stop after 30s
         Handler(Looper.getMainLooper()).postDelayed({
-            try { stopSelf() } catch (e: Exception) {}
+            try {
+                stopSelf()
+            } catch (e: Exception) {
+            }
         }, 30000)
 
         return START_NOT_STICKY
@@ -99,29 +124,35 @@ class CallForegroundService : Service() {
         // Unregister to prevent memory leaks once the call ends or service stops
         try {
             unlockReceiver?.let { unregisterReceiver(it) }
-        } catch (e: Exception) { e.printStackTrace() }
-        
-        try { stopForeground(true) } catch (_: Exception) {}
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        try {
+            stopForeground(true)
+        } catch (_: Exception) {
+        }
         super.onDestroy()
     }
 
     private fun createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                "Call Service",
-                NotificationManager.IMPORTANCE_LOW
-            ).apply {
-                description = "Handles incoming call connection state"
-                setSound(null, null) 
-                enableVibration(false)
-                setBypassDnd(true)
-                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-            }
+            val channel =
+                NotificationChannel(
+                    CHANNEL_ID,
+                    "Call Service",
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    description = "Incoming call connection state"
+                    setSound(null, null)
+                    enableVibration(false)
+                    setBypassDnd(true)
+                    lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+                }
             val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
             manager.createNotificationChannel(channel)
         }
     }
 
     override fun onBind(intent: Intent?): IBinder? = null
-}
+}

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

@@ -5,170 +5,186 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
+import android.graphics.Color
+import android.media.AudioAttributes
+import android.media.RingtoneManager
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
 import androidx.core.app.NotificationCompat
-import android.media.Ringtone
-import android.media.RingtoneManager
-import android.graphics.Color
-import android.app.KeyguardManager
+import androidx.core.app.Person
 
 object NativeCallManager {
+    // Note: We no longer need the private 'ringtone' variable here
+    // because the system NotificationManager handles the sound.
 
-    private var ringtone: Ringtone? = null
-    const val channelId = "CALL_CHANNEL_ID"
-
+    // Incrementing version to V3 to force fresh channel settings on the device
+    const val channelId = "CALL_CHANNEL_V5_URGENT"
     private var currentCallData: Map<String, String>? = null
 
     fun getCurrentCallData(): Map<String, String>? = currentCallData
 
-    fun handleIncomingPush(context: Context, data: Map<String, String>) {
-        val uuid = data["callUuid"] ?: return
-        this.currentCallData = data
-        stopRingtone()
-
-        val name = data["name"] ?: "Incoming Call"
-        val callType = data["callType"] ?: "audio"
-        val notificationId = uuid.hashCode()
-
-        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
-        } else {
-            PendingIntent.FLAG_UPDATE_CURRENT
-        }
-
-        // Dummy intent for content click
-        val noOpIntent = PendingIntent.getActivity(context, notificationId + 3, Intent(), pendingFlags)
-
-        // 1. Define the flags properly (DO NOT MIX THEM)
-val mutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
-} else {
-    PendingIntent.FLAG_UPDATE_CURRENT
-}
-
-val immutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-} else {
-    PendingIntent.FLAG_UPDATE_CURRENT
-}
-
-// 2. Setup the Overlay Intent
-val overlayIntent = Intent(context, NotificationOverlayActivity::class.java).apply { 
-    this.putExtra("EXTRA_CALL_UUID", uuid)
-    data.forEach { (k, v) -> this.putExtra(k, v) }
-    // No User Action flag prevents the intent from triggering an auto-dismiss of notifications
-    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION)
-}
-
-// 3. Create the Full Screen PendingIntent (Use IMMUTABLE)
-val fullScreenPendingIntent = PendingIntent.getActivity(
-    context, 
-    notificationId, 
-    overlayIntent, 
-    immutableFlags // <--- Use the immutable version here
-)
-
+    fun handleIncomingPush(
+        context: Context,
+        data: Map<String, String>,
+    ) {
+        Handler(Looper.getMainLooper()).post {
+            val uuid = data["callUuid"] ?: return@post
+            this.currentCallData = data
 
+            val name = data["name"] ?: "Incoming Call"
+            val notificationId = uuid.hashCode()
+            val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
 
-        // --- ANSWER ACTION ---
-        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
-            this.action = "ACTION_ANSWER"
-            this.putExtra("EXTRA_CALL_UUID", uuid)
-            
-            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
-        }
-
-        val answerPendingIntent = PendingIntent.getBroadcast(context, notificationId + 1, answerIntent, mutableFlags)
+            val pendingFlags =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                } else {
+                    PendingIntent.FLAG_UPDATE_CURRENT
+                }
+
+            // 1. Content Intent (Tap notification)
+            val noOpIntent =
+                Intent("com.rnsnativecall.ACTION_NOTIFICATION_TAP_NOOP").apply {
+                    `package` = context.packageName
+                    putExtra("EXTRA_CALL_UUID", uuid)
+                }
+            val contentIntent = PendingIntent.getBroadcast(context, notificationId + 3, noOpIntent, pendingFlags)
+
+            // 2. Full Screen Intent (Wake lockscreen)
+            val overlayIntent =
+                Intent(context, NotificationOverlayActivity::class.java).apply {
+                    putExtra("EXTRA_CALL_UUID", uuid)
+                    data.forEach { (k, v) -> putExtra(k, v) }
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION)
+                }
+            val fullScreenPendingIntent = PendingIntent.getActivity(context, notificationId, overlayIntent, pendingFlags)
+
+            // 3. Answer Action
+            val answerIntent =
+                Intent(context, CallActionReceiver::class.java).apply {
+                    action = "ACTION_ANSWER"
+                    putExtra("EXTRA_CALL_UUID", uuid)
+                    data.forEach { (k, v) -> putExtra(k, v) }
+                }
+            val answerPendingIntent = PendingIntent.getBroadcast(context, notificationId + 1, answerIntent, pendingFlags)
+
+            // 4. Reject Action
+            val rejectIntent =
+                Intent(context, CallActionReceiver::class.java).apply {
+                    action = "ACTION_REJECT"
+                    putExtra("EXTRA_CALL_UUID", uuid)
+                    data.forEach { (k, v) -> putExtra(k, v) }
+                }
+            val rejectPendingIntent = PendingIntent.getBroadcast(context, notificationId + 2, rejectIntent, pendingFlags)
+
+            // Setup Channel with System-Managed Sound
+            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 {
+                        lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+                        enableVibration(true)
+                        setBypassDnd(true)
+                        // System-managed sound ensures the "pill" pops up correctly
+                        setSound(
+                            ringtoneUri,
+                            AudioAttributes
+                                .Builder()
+                                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                                .build(),
+                        )
+                    }
+                notificationManager.createNotificationChannel(channel)
+            }
 
-        // --- REJECT ACTION ---
-        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            this.action = "ACTION_REJECT"
-            this.putExtra("EXTRA_CALL_UUID", uuid)
-            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
+            val caller =
+                Person
+                    .Builder()
+                    .setName(name)
+                    .setImportant(true)
+                    .build()
+
+            val builder =
+                NotificationCompat
+                    .Builder(context, channelId)
+                    .setSmallIcon(context.applicationInfo.icon)
+                    .setPriority(NotificationCompat.PRIORITY_MAX)
+                    .setCategory(NotificationCompat.CATEGORY_CALL)
+                    .setOngoing(true)
+                    .setAutoCancel(false)
+                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                    .setContentIntent(contentIntent)
+                    .setFullScreenIntent(fullScreenPendingIntent, true)
+                    .setStyle(
+                        NotificationCompat.CallStyle
+                            .forIncomingCall(caller, rejectPendingIntent, answerPendingIntent)
+                            .setAnswerButtonColorHint(Color.GREEN)
+                            .setDeclineButtonColorHint(Color.RED),
+                    ).setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+
+            // Sending this notification will now trigger the system ringtone automatically
+            notificationManager.notify(notificationId, builder.build())
         }
-        
-        val rejectPendingIntent = PendingIntent.getBroadcast(context, notificationId + 2, rejectIntent, mutableFlags)
+    }
 
+    /**
+     * Stop the ringtone by canceling the notification itself.
+     * The system manages the sound, so when the notification dies, the sound dies.
+     */
+    fun dismissIncomingCall(
+        context: Context,
+        uuid: String?,
+    ) {
+        this.currentCallData = null
         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 {
-                enableVibration(true)
-                vibrationPattern = longArrayOf(0, 500, 500, 500)
-                lightColor = Color.GREEN
-                setBypassDnd(true)
-                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                setSound(null, null)
-            }
-            notificationManager.createNotificationChannel(channel)
+        if (uuid != null) {
+            notificationManager.cancel(uuid.hashCode())
         }
-
-        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-        val isLocked = keyguardManager.isKeyguardLocked
-
-
-        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)
-            .setContentIntent(noOpIntent)
-            .addAction(0, "Answer", answerPendingIntent)
-            .addAction(0, "Decline", rejectPendingIntent)
-            .setDefaults(NotificationCompat.DEFAULT_ALL)
-       
-              builder.setFullScreenIntent(fullScreenPendingIntent, true)
-   
-
-        notificationManager.notify(notificationId, builder.build())
-
-        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
-            ringtone?.play()
-        } catch (e: Exception) { e.printStackTrace() }
-    }
-
-    fun stopRingtone() {
-        try {
-            ringtone?.let { if (it.isPlaying) it.stop() }
-            ringtone = null
-        } catch (e: Exception) { ringtone = null }
     }
 
-    fun connecting(context: Context, uuid: String, name: String, callType: String) {
+    fun connecting(
+        context: Context,
+        uuid: String,
+        name: String,
+        callType: String,
+    ) {
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(context.applicationInfo.icon)
-            .setContentTitle("Incoming $callType call")
-            .setContentText("Connecting…")
-            .setPriority(NotificationCompat.PRIORITY_MAX)
-            .setOngoing(true)
-            .setProgress(0, 0, true)
+        val builder =
+            NotificationCompat
+                .Builder(context, channelId)
+                .setSmallIcon(context.applicationInfo.icon)
+                .setContentTitle(name)
+                .setContentText("Connecting…")
+                .setPriority(NotificationCompat.PRIORITY_MAX)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setOngoing(true)
+                .setStyle(NotificationCompat.BigTextStyle().bigText("Connecting…"))
         notificationManager.notify(uuid.hashCode(), builder.build())
     }
 
-    fun aborting(context: Context, uuid: String, name: String, callType: String) {
+    fun aborting(
+        context: Context,
+        uuid: String,
+        name: String,
+        callType: String,
+    ) {
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(context.applicationInfo.icon)
-            .setContentTitle("Incoming $callType call")
-            .setContentText("Aborting…")
-            .setPriority(NotificationCompat.PRIORITY_MAX)
-            .setOngoing(true)
-            .setProgress(0, 0, true)
+        val builder =
+            NotificationCompat
+                .Builder(context, channelId)
+                .setSmallIcon(context.applicationInfo.icon)
+                .setContentTitle(name)
+                .setContentText("Aborting…")
+                .setPriority(NotificationCompat.PRIORITY_MAX)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setOngoing(true)
         notificationManager.notify(uuid.hashCode(), builder.build())
     }
 
-    fun dismissIncomingCall(context: Context, uuid: String?) {
-        this.currentCallData = null
-        stopRingtone()
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        if (uuid != null) notificationManager.cancel(uuid.hashCode())
+    // Deprecated manual method - kept for signature compatibility but does nothing
+    fun stopRingtone() {
+        // No-op: Sound is now managed by the Notification Channel life-cycle
     }
-}
+}

package/index.d.ts

@@ -80,6 +80,8 @@ export interface CallHandlerType {
 
     requestOverlayPermission(): Promise<boolean>;
 
+    reportRemoteEnded(uuid: string, reason: number): void;
+
     checkOverlayPermission(): Promise<boolean>;
 
     /**

package/index.js

@@ -47,6 +47,11 @@ export const CallHandler = {
     },
     // ------------------------------------
 
+    reportRemoteEnded: async (uuid, endReason) => {
+        if (!CallModule?.reportRemoteEnded) return;
+        await CallModule.reportRemoteEnded(uuid.toLowerCase().trim(), endReason);
+    },
+
     requestOverlayPermission: async () => {
         if (!CallModule?.requestOverlayPermission) return false;
         return await CallModule.requestOverlayPermission();

package/ios/CallModule.m

@@ -3,6 +3,7 @@
 
 @interface CallModule ()
 @property (nonatomic, strong) NSString *pendingCallUuid;
+@property (nonatomic, strong) NSMutableDictionary *pendingEvents;
 @end
 
 @implementation CallModule
@@ -20,6 +21,7 @@ RCT_EXPORT_MODULE();
 - (instancetype)init {
     self = [super init];
     if (self) {
+        self.pendingEvents = [NSMutableDictionary new];
         NSString *appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleDisplayName"] ?: [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleName"];
 
         CXProviderConfiguration *config = [[CXProviderConfiguration alloc] initWithLocalizedName:appName];
@@ -35,6 +37,34 @@ RCT_EXPORT_MODULE();
     return self;
 }
 
+// MARK: - New Parity Methods (Synced with Android)
+
+RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    BOOL isCurrent = [uuidString isEqualToString:self.currentCallUUID.UUIDString];
+    resolve(@{
+        @"isValid": @(isCurrent),
+        @"isCanceled": @(!isCurrent)
+    });
+}
+
+RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    
+    if (self.pendingCallUuid) {
+        result[@"default"] = @{@"callUuid": self.pendingCallUuid};
+        self.pendingCallUuid = nil;
+    }
+    
+    if (self.pendingEvents.count > 0) {
+        [result addEntriesFromDictionary:self.pendingEvents];
+        [self.pendingEvents removeAllObjects];
+    }
+    
+    resolve(result.count > 0 ? result : [NSNull null]);
+}
+
+// MARK: - Core Logic
+
 RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
                   name:(NSString *)name
                   callType:(NSString *)callType
@@ -50,9 +80,9 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
     self.currentCallUUID = uuid;
 
     AVAudioSession *session = [AVAudioSession sharedInstance];
-    [session setCategory:AVAudioSessionCategoryPlayAndRecord 
-                    mode:AVAudioSessionModeVoiceChat 
-                 options:AVAudioSessionCategoryOptionAllowBluetooth | AVAudioSessionCategoryOptionDefaultToSpeaker
+    [session setCategory:AVAudioSessionCategoryPlayAndRecord
+                    mode:AVAudioSessionModeVoiceChat
+                 options:AVAudioSessionCategoryOptionAllowBluetoothHFP | AVAudioSessionCategoryOptionDefaultToSpeaker
                    error:nil];
 
     CXCallUpdate *update = [[CXCallUpdate alloc] init];
@@ -68,38 +98,35 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
     }];
 }
 
-RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString)
-{
+// Handles programmatic ending (e.g., via FCM "CANCEL")
+RCT_EXPORT_METHOD(reportRemoteEnded:(NSString *)uuidString reason:(NSInteger)reason) {
     NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
     if (!uuid) return;
 
-    [self.provider reportCallWithUUID:uuid 
-                          endedAtDate:[NSDate date] 
-                               reason:CXCallEndedReasonRemoteEnded];
-    self.currentCallUUID = nil;
-    self.pendingCallUuid = nil;
-}
-
-RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    if (self.pendingCallUuid) {
-        resolve(@{@"callUuid": self.pendingCallUuid});
-        self.pendingCallUuid = nil; 
-    } else {
-        resolve([NSNull null]);
+    // Report to CallKit that the remote user ended the call
+    [self.provider reportCallWithUUID:uuid
+                          endedAtDate:[NSDate date]
+                               reason:(CXCallEndedReason)reason];
+    
+    // Clear local tracking
+    if ([uuid isEqual:self.currentCallUUID]) {
+        self.currentCallUUID = nil;
+        self.pendingCallUuid = nil;
     }
 }
 
-RCT_EXPORT_METHOD(checkTelecomPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    resolve(@YES);
+RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString)
+{
+    [self reportRemoteEnded:uuidString reason:CXCallEndedReasonRemoteEnded];
 }
 
 // MARK: - CXProviderDelegate
 
 - (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {
     AVAudioSession *session = [AVAudioSession sharedInstance];
-    [session setCategory:AVAudioSessionCategoryPlayAndRecord 
-                    mode:AVAudioSessionModeVoiceChat 
-                 options:AVAudioSessionCategoryOptionAllowBluetooth | AVAudioSessionCategoryOptionDefaultToSpeaker 
+    [session setCategory:AVAudioSessionCategoryPlayAndRecord
+                    mode:AVAudioSessionModeVoiceChat
+                 options:AVAudioSessionCategoryOptionAllowBluetoothHFP | AVAudioSessionCategoryOptionDefaultToSpeaker
                    error:nil];
     [session setActive:YES error:nil];
 
@@ -108,9 +135,12 @@ RCT_EXPORT_METHOD(checkTelecomPermissions:(RCTPromiseResolveBlock)resolve reject
     NSString *uuidStr = [action.callUUID.UUIDString lowercaseString];
     self.pendingCallUuid = uuidStr;
 
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-        // NUDGE: Force the window to become visible. 
-        // This helps transition from "Ghost Mode" to "Active UI" once the user unlocks.
+    // Switch from system UI to App UI
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        [self.provider reportCallWithUUID:action.callUUID
+                          endedAtDate:[NSDate date]
+                                reason:CXCallEndedReasonAnsweredElsewhere];
+        
         dispatch_async(dispatch_get_main_queue(), ^{
             [[[UIApplication sharedApplication] keyWindow] makeKeyAndVisible];
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.8.0",
+    "version": "0.8.2",
     "description": "High-performance React Native module for handling native VoIP call UI on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",

package/withNativeCallVoip.js

@@ -9,7 +9,9 @@ function withMainActivityDataFix(config) {
             'import android.content.Intent',
             'import android.os.Bundle',
             'import android.view.WindowManager',
-            'import android.os.Build'
+            'import android.os.Build',
+            'import androidx.core.app.ActivityCompat', // ADDED
+            'import android.Manifest' // ADDED
         ];
 
         // Add imports if they don't exist
@@ -22,8 +24,18 @@ function withMainActivityDataFix(config) {
         const onCreateCode = `
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
+    
+    // Request Notification Permissions for Android 13+ (Required for Pill UI)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        ActivityCompat.requestPermissions(
+            this,
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            101
+        )
+    }
+
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-        setShowWhenLocked(false)
+        setShowWhenLocked(true) // Set to TRUE so call UI can show over lockscreen
         setTurnScreenOn(true)
     } else {
         window.addFlags(
@@ -32,6 +44,7 @@ function withMainActivityDataFix(config) {
             WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
         )
     }
+
     if (intent.getBooleanExtra("background_wake", false)) {
         moveTaskToBack(true)
     }
@@ -43,7 +56,6 @@ function withMainActivityDataFix(config) {
     setIntent(intent)
   }`;
 
-        // Use a more flexible regex for the class definition
         const classRegex = /class MainActivity\s*:\s*ReactActivity\(\)\s*\{/;
 
         if (!contents.includes('override fun onCreate')) {
@@ -51,7 +63,6 @@ function withMainActivityDataFix(config) {
         }
 
         if (!contents.includes('override fun onNewIntent')) {
-            // Re-run match check because contents might have changed from onCreate injection
             contents = contents.replace(classRegex, (match) => `${match}${onNewIntentCode}`);
         }
 
@@ -70,7 +81,7 @@ function withAndroidConfig(config) {
         const mainActivity = application.activity.find((a) => a.$['android:name'] === '.MainActivity');
         if (mainActivity) {
             mainActivity.$['android:launchMode'] = 'singleTop';
-            mainActivity.$['android:showWhenLocked'] = 'false';
+            mainActivity.$['android:showWhenLocked'] = 'true'; // Changed to true
             mainActivity.$['android:turnScreenOn'] = 'true';
         }
 
@@ -82,19 +93,17 @@ function withAndroidConfig(config) {
             'android.permission.POST_NOTIFICATIONS',
             'android.permission.WAKE_LOCK',
             'android.permission.DISABLE_KEYGUARD',
-            'android.permission.SYSTEM_ALERT_WINDOW'
+            'android.permission.MANAGE_ONGOING_CALLS'
         ];
 
-        // Initialize permissions array if missing
         manifest.manifest['uses-permission'] = manifest.manifest['uses-permission'] || [];
-
         permissions.forEach((perm) => {
             if (!manifest.manifest['uses-permission'].some((p) => p.$['android:name'] === perm)) {
                 manifest.manifest['uses-permission'].push({ $: { 'android:name': perm } });
             }
         });
 
-        // Initialize components if missing
+        // Components Setup
         application.service = application.service || [];
         application.activity = application.activity || [];
         application.receiver = application.receiver || [];
@@ -117,7 +126,7 @@ function withAndroidConfig(config) {
             }
         });
 
-        // 2. Activities (Trampoline & Overlay)
+        // 2. Activities (NotificationOverlayActivity is critical for Foldables)
         const activities = [
             {
                 name: 'com.rnsnativecall.AcceptCallActivity',
@@ -158,26 +167,6 @@ function withAndroidConfig(config) {
             });
         }
 
-        // ADD THIS: UnlockReceiver with USER_PRESENT filter
-        if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.UnlockReceiver')) {
-            application.receiver.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.UnlockReceiver',
-                    'android:exported': 'true',
-                    'android:enabled': 'true',
-                    'android:directBootAware': 'true', // Helps bypass some background restrictions
-                },
-                'intent-filter': [
-                    {
-                        $: { 'android:priority': '1000' },
-                        action: [
-                            { $: { 'android:name': 'android.intent.action.USER_PRESENT' } }
-                        ]
-                    }
-                ]
-            });
-        }
-
         return config;
     });
 }
@@ -203,4 +192,4 @@ module.exports = (config) => {
         withMainActivityDataFix,
         withIosConfig
     ]);
-};  
+};