rns-nativecall 0.7.1 → 0.7.3

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

@@ -13,7 +13,6 @@ class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // Ensure we show over the lockscreen
         window.addFlags(
             WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
             WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
@@ -23,6 +22,14 @@ class AcceptCallActivity : Activity() {
         val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
         keyguardManager.requestDismissKeyguard(this, null)
 
+        // Check: Did the user actually press "Answer" or did the system auto-launch?
+    // If the action is null or doesn't match your Answer action, 
+    // it means the system is just "preparing" the activity.
+    if (intent.action?.startsWith("ACTION_ANSWER") != true) {
+        // If it's just an auto-launch, we don't fire the JS event!
+        // We can either finish() or show a tiny "Swipe to Answer" UI.
+        return 
+    }
         processCallIntent(intent)
     }
 
@@ -35,30 +42,36 @@ class AcceptCallActivity : Activity() {
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         uuid?.let { notificationManager.cancel(it.hashCode()) }
 
-        val dataMap = mutableMapOf<String, String>()
-        extras?.keySet()?.forEach { key ->
-            extras.get(key)?.let { dataMap[key] = it.toString() }
-        }
-
-        // 1. Set the data for JS (Cold start support)
-        CallModule.setPendingCallData("onCallAccepted_pending", dataMap)
-        
-        // 2. Fire event immediately if JS is alive
-        if (CallModule.isReady()) {
-            CallModule.sendEventToJS("onCallAccepted", dataMap)
-        }
-
-        // 3. Bring the Main App to the front
+        // ✅ WE STOP SENDING THE JS EVENT HERE.
+        // Instead, we pass the intent to MainActivity with a specific ACTION.
         openMainApp(extras)
         finish()
     }
 
     private fun openMainApp(extras: Bundle?) {
-        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-        launchIntent?.apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            putExtras(extras ?: Bundle())
-            startActivity(this)
+        try {
+            // Get the actual MainActivity class name (e.g., com.yourapp.MainActivity)
+            val mainActivityClassName = "${packageName}.MainActivity"
+            
+            val intent = Intent().apply {
+                setClassName(packageName, mainActivityClassName)
+                action = "com.rnsnativecall.ACTION_ANSWER"
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                
+                // Ensure extras are carried over
+                extras?.let { putExtras(it) }
+            }
+            
+            startActivity(intent)
+        } catch (e: Exception) {
+            // Fallback: If explicit mapping fails, try the launch intent but force the action
+            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+            launchIntent?.apply {
+                action = "com.rnsnativecall.ACTION_ANSWER"
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                extras?.let { putExtras(it) }
+                startActivity(this)
+            }
         }
     }
 }

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

@@ -24,28 +24,18 @@ class CallMessagingService : FirebaseMessagingService() {
 
         val uuid = data["callUuid"] ?: return
         val type = data["type"] ?: ""
-          
+
         if (type == "CANCEL") {
     NativeCallManager.stopRingtone()
-    CallState.markCanceled(uuid)
+    // Pass context here to persist the cancellation
+    CallState.markCanceled(uuid, context) 
     
-    try {
-        // Direct disk-level cleanup of AsyncStorage
-        val prefs = context.getSharedPreferences("RKStorage", Context.MODE_PRIVATE)
-        prefs.edit()
-            .remove("pending_call_uuid")
-            .remove("offer_$uuid")
-            .apply()
-        
-        // Kill the 'Connecting...' service if it's visible
-        context.stopService(Intent(context, CallForegroundService::class.java))
-    } catch (e: Exception) {
-        e.printStackTrace()
-    }
-
     if (CallState.getCurrent() == uuid) {
-        CallState.clear(uuid) 
+        CallState.clear(uuid, context) 
     }
+    
+    // Dismiss the "Connecting..." or "Incoming Call" UI
+    NativeCallManager.dismissIncomingCall(context, uuid)
     showMissedCallNotification(context, data, uuid)
     return
 }

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

@@ -50,6 +50,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             promise.reject("CALL_ERROR", e.message)
         }
     }
+    
 
     /**
      * Combined Validity Check: 
@@ -57,13 +58,14 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
      */
     @ReactMethod
     fun checkCallValidity(uuid: String, promise: Promise) {
-        val isValid = CallState.shouldProceed(uuid)
-        val isCanceled = CallState.isCanceled(uuid)
-        
-        val map = Arguments.createMap().apply {
-            putBoolean("isValid", isValid)
-            putBoolean("isCanceled", isCanceled)
-        }
+       // Pass context so it can check the persistent disk storage
+       val isValid = CallState.shouldProceed(uuid, reactApplicationContext)
+       val isCanceled = CallState.isCanceled(uuid, reactApplicationContext)
+    
+       val map = Arguments.createMap().apply {
+           putBoolean("isValid", isValid)
+           putBoolean("isCanceled", isCanceled)
+       }
         promise.resolve(map)
     }
 

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

@@ -1,9 +1,17 @@
 package com.rnsnativecall
 
+import android.content.Context
+import android.content.SharedPreferences
+
 object CallState {
     @Volatile private var currentUuid: String? = null
     @Volatile private var canceledUuids = mutableSetOf<String>()
 
+    // Helper to access persistent storage
+    private fun getPrefs(context: Context): SharedPreferences {
+        return context.getSharedPreferences("RNS_CALL_STATE_INTERNAL", Context.MODE_PRIVATE)
+    }
+
     @Synchronized
     fun isBusy(): Boolean = currentUuid != null
 
@@ -19,37 +27,56 @@ object CallState {
     fun getCurrent(): String? = currentUuid
 
     @Synchronized
-    fun markCanceled(uuid: String) {
+    fun markCanceled(uuid: String, context: Context? = null) {
         canceledUuids.add(uuid)
         if (currentUuid == uuid) {
             currentUuid = null
         }
+        // PERSISTENCE: Save to disk so Splash screen can see it after app restart
+        context?.let {
+            getPrefs(it).edit().putBoolean("canceled_$uuid", true).apply()
+        }
     }
 
-    // ✅ Fixes the "Unresolved reference 'isCanceled'" error
     @Synchronized
-    fun isCanceled(uuid: String?): Boolean {
+    fun isCanceled(uuid: String?, context: Context? = null): Boolean {
         if (uuid == null) return false
-        return canceledUuids.contains(uuid)
+        // Check memory first
+        if (canceledUuids.contains(uuid)) return true
+        
+        // PERSISTENCE: Check disk if memory was wiped (App was killed)
+        return context?.let { 
+            getPrefs(it).getBoolean("canceled_$uuid", false) 
+        } ?: false
     }
 
     @Synchronized
-    fun clear(uuid: String?) {
+    fun clear(uuid: String?, context: Context? = null) {
         if (uuid == null) return
         if (currentUuid == uuid) currentUuid = null
         canceledUuids.remove(uuid)
+        
+        // PERSISTENCE: Cleanup disk entry
+        context?.let {
+            getPrefs(it).edit().remove("canceled_$uuid").apply()
+        }
     }
 
     @Synchronized
-    fun shouldProceed(uuid: String?): Boolean {
+    fun shouldProceed(uuid: String?, context: Context? = null): Boolean {
         if (uuid == null) return false
-        return (currentUuid == uuid) && !canceledUuids.contains(uuid)
+        
+        // A call should proceed if it is the current UUID AND it hasn't been canceled
+        // We use the context-aware isCanceled to check the disk if necessary
+        val canceled = isCanceled(uuid, context)
+        return (currentUuid == uuid || currentUuid == null) && !canceled
     }
 
     @Synchronized
     fun clearAll() {
         currentUuid = null
         canceledUuids.clear()
+        // Note: clearAll usually doesn't have context, 
+        // specific UUIDs are usually cleared via the clear(uuid, context) method
     }
-}
-
+}

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

@@ -11,92 +11,158 @@ import android.media.Ringtone
 import android.media.RingtoneManager
 import android.graphics.Color
 
+import androidx.core.app.Person
+import androidx.core.app.NotificationCompat
+
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
     const val channelId = "CALL_CHANNEL_ID"
 
-    fun handleIncomingPush(context: Context, data: Map<String, String>) {
-        val uuid = data["callUuid"] ?: return
-        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
-        }
-
-        val noOpIntent = PendingIntent.getActivity(
-            context,
-            notificationId + 1,
-            Intent(), 
-            pendingFlags
-        )
-
-        val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            this.action = "ACTION_SHOW_UI_$uuid"
-            data.forEach { (key, value) -> this.putExtra(key, value) }
-            this.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-        }
+    // fun handleIncomingPush(context: Context, data: Map<String, String>) {
+    //     val uuid = data["callUuid"] ?: return
+    //     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
+    //     }
+
+    //     val noOpIntent = PendingIntent.getActivity(
+    //         context,
+    //         notificationId + 1,
+    //         Intent(), 
+    //         pendingFlags
+    //     )
+
+    //     val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
+    //         this.action = "ACTION_SHOW_UI_$uuid"
+    //         data.forEach { (key, value) -> this.putExtra(key, value) }
+    //         this.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+    //     }
+
+    //     val fullScreenPendingIntent = PendingIntent.getActivity(
+    //         context,
+    //         notificationId,
+    //         intentToActivity,
+    //         pendingFlags
+    //     )
+
+    //     val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+    //         this.action = "ACTION_REJECT_$uuid"
+    //         this.putExtra("EXTRA_CALL_UUID", uuid)
+    //         data.forEach { (key, value) -> this.putExtra(key, value) }
+    //     }
+
+    //     val rejectPendingIntent = PendingIntent.getBroadcast(
+    //         context,
+    //         notificationId,
+    //         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 // 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)
+    //     }
+
+    //     val builder = NotificationCompat.Builder(context, channelId)
+    //         .setSmallIcon(context.applicationInfo.icon)
+    //         .setContentTitle("Incoming $callType call")
+    //         .setContentText(name)
+    //         .setPriority(NotificationCompat.PRIORITY_MAX) // PRIORITY_HIGH
+    //         .setCategory(NotificationCompat.CATEGORY_CALL) // CATEGORY_CALL
+    //         .setOngoing(true)
+    //         .setAutoCancel(false)
+    //         .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+    //         .setFullScreenIntent(fullScreenPendingIntent, true)
+    //         .setContentIntent(noOpIntent)
+    //         .addAction(0, "Answer", fullScreenPendingIntent)
+    //         .addAction(0, "Decline", rejectPendingIntent)
+
+    //     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 handleIncomingPush(context: Context, data: Map<String, String>) {
+    val uuid = data["callUuid"] ?: return
+    stopRingtone()
+
+    val name = data["name"] ?: "Incoming Call"
+    val callType = data["callType"] ?: "audio"
+    val notificationId = uuid.hashCode()
 
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context,
-            notificationId,
-            intentToActivity,
-            pendingFlags
-        )
+    // 1. Create the Person object (Required for CallStyle)
+    val caller = Person.Builder()
+        .setName(name)
+        .setImportant(true)
+        .build()
+
+    // 2. Intents (Keep your existing intent logic)
+    val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
+        this.action = "ACTION_ANSWER_$uuid"
+        data.forEach { (key, value) -> this.putExtra(key, value) }
+        this.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+    }
 
-        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            this.action = "ACTION_REJECT_$uuid"
-            this.putExtra("EXTRA_CALL_UUID", uuid)
-            data.forEach { (key, value) -> this.putExtra(key, value) }
-        }
+    val fullScreenPendingIntent = PendingIntent.getActivity(
+        context, notificationId, intentToActivity,
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) 
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE 
+        else PendingIntent.FLAG_UPDATE_CURRENT
+    )
 
-        val rejectPendingIntent = PendingIntent.getBroadcast(
-            context,
-            notificationId,
-            rejectIntent,
-            pendingFlags
+    // 3. Build the Notification with CallStyle
+    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)
+        // This makes it show on the lock screen WITHOUT auto-launching the activity
+        .setFullScreenIntent(fullScreenPendingIntent, true) 
+        .setStyle(
+            NotificationCompat.CallStyle.forIncomingCall(
+                caller, 
+                rejectPendingIntent, // Use your existing rejectIntent
+                fullScreenPendingIntent
+            )
         )
 
-        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 // 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)
-        }
-
-        val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(context.applicationInfo.icon)
-            .setContentTitle("Incoming $callType call")
-            .setContentText(name)
-            .setPriority(NotificationCompat.PRIORITY_MAX) // PRIORITY_HIGH
-            .setCategory(NotificationCompat.CATEGORY_CALL) // CATEGORY_CALL
-            .setOngoing(true)
-            .setAutoCancel(false)
-            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            .setFullScreenIntent(fullScreenPendingIntent, true)
-            .setContentIntent(noOpIntent)
-            .addAction(0, "Answer", fullScreenPendingIntent)
-            .addAction(0, "Decline", rejectPendingIntent)
-
-        notificationManager.notify(notificationId, builder.build())
-
+    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    // ... ensure channel is created ...
+    notificationManager.notify(notificationId, builder.build())
+    
         try {
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
@@ -107,7 +173,7 @@ object NativeCallManager {
         } catch (e: Exception) {
             e.printStackTrace()
         }
-    }
+}
 
     fun stopRingtone() {
         try {

package/package.json

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