rns-nativecall 0.7.0 → 0.7.2

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

@@ -24,17 +24,21 @@ class CallMessagingService : FirebaseMessagingService() {
 
         val uuid = data["callUuid"] ?: return
         val type = data["type"] ?: ""
-          
+
         if (type == "CANCEL") {
-            NativeCallManager.stopRingtone()
-            CallState.markCanceled(uuid)
-            // Gate future headless runs for this UUID 
-            if (CallState.getCurrent() == uuid) {
-                CallState.clear(uuid) 
-            }
-            showMissedCallNotification(context, data, uuid)
-            return
-        }
+    NativeCallManager.stopRingtone()
+    // Pass context here to persist the cancellation
+    CallState.markCanceled(uuid, context) 
+    
+    if (CallState.getCurrent() == uuid) {
+        CallState.clear(uuid, context) 
+    }
+    
+    // Dismiss the "Connecting..." or "Incoming Call" UI
+    NativeCallManager.dismissIncomingCall(context, uuid)
+    showMissedCallNotification(context, data, uuid)
+    return
+}
 
         // Inside onMessageReceived
 if (!CallState.setCurrent(uuid)) {

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,36 +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/package.json

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