rns-nativecall 0.3.1 → 0.3.3

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

@@ -10,12 +10,13 @@ class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         NativeCallManager.stopRingtone()
-
         // 1. CLEAR THE NOTIFICATION
+        // Use the same ID (101) used in NativeCallManager
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
 
         // 2. EXTRACT DATA SAFELY
+        // We iterate through all extras and convert them to Strings for the JS Map
         val dataMap = mutableMapOf<String, String>()
         val extras = intent.extras
         extras?.keySet()?.forEach { key ->
@@ -25,26 +26,30 @@ class AcceptCallActivity : Activity() {
             }
         }
 
-        // --- THE COLD START FIX ---
-        // 3. STORE DATA FOR JS POLLING
-        // We save this in a static variable inside CallModule so getInitialCallData() can find it
-        CallModule.setPendingCallData(dataMap)
-
-        // 4. EMIT EVENT TO REACT NATIVE
-        // This works if the app is already running
+        // 3. EMIT EVENT TO REACT NATIVE
+        // This handles the case where the app is already in the background/foreground
         CallModule.sendEventToJS("onCallAccepted", dataMap)
 
-        // 5. LAUNCH OR BRING MAIN APP TO FOREGROUND
+        // 4. LAUNCH OR BRING MAIN APP TO FOREGROUND
         val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
         if (launchIntent != null) {
             launchIntent.apply {
+                // FLAG_ACTIVITY_SINGLE_TOP: Updates the app if it's already open
+                // FLAG_ACTIVITY_NEW_TASK: Required when starting from a non-activity context
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                
+                // Copy all call data to the launch intent
                 putExtras(extras ?: Bundle())
+                
+                // Helper flag for your React Native logic
                 putExtra("navigatingToCall", true)
             }
             startActivity(launchIntent)
         }
-
+        
+        CallModule.setPendingCallData(dataMap)
+        // 5. FINISH TRAMPOLINE
+        // This ensures this invisible activity doesn't stay in the "Recent Apps" list
         finish()
     }
 }

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

@@ -2,6 +2,9 @@ package com.rnsnativecall
 
 import android.app.ActivityManager
 import android.content.Context
+import android.content.Intent
+import android.os.Handler
+import android.os.Looper
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 
@@ -9,18 +12,59 @@ class CallMessagingService : FirebaseMessagingService() {
 
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
+        val context = applicationContext
         
-        // Ensure this is actually a call offer before proceeding
-        if (data["type"] == "offer" || data.containsKey("callUuid")) {
-            
-            // ALWAYS trigger the native logic. 
-            // The NativeCallManager should decide if it needs to show a Notification 
-            // or just play a sound. This ensures the "Ringtone" starts natively 
-            // which is more reliable than JS audio.
-            NativeCallManager.handleIncomingPush(applicationContext, data)
-            
-            // Still notify JS so it can update the UI or pre-load the call screen
+        if (isAppInForeground(context)) {
             CallModule.sendEventToJS("onCallReceived", data)
+        } else {
+            // 1. START WAKING THE APP IMMEDIATELY
+            // We launch the "AcceptCallActivity" with a special flag 
+            // OR just trigger the Bridge via an Intent.
+            wakeUpReactContext(context, data)
+
+            // 2. Start the 18-second "Safety" timer
+            val handler = Handler(Looper.getMainLooper())
+            handler.postDelayed({
+                // Re-check: If the bridge woke up and the user navigated in-app, 
+                // isAppInForeground will now be true.
+                if (!isAppInForeground(context)) {
+                    NativeCallManager.handleIncomingPush(context, data)
+                }
+            }, 18000)
+        }
+    }
+
+    private fun wakeUpReactContext(context: Context, data: Map<String, String>) {
+        try {
+            // We use the Launch Intent to trigger the splash/main activity boot sequence
+            // but we don't bring it to the front yet (it stays in background process)
+            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            launchIntent?.apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                // Add a hidden flag so your Splash screen knows it's a "silent boot"
+                putExtra("silent_wake", true) 
+                data.forEach { (key, value) -> putExtra(key, value) }
+            }
+            
+            // This starts the process and the React Native Bridge
+            // Note: On Android 10+, this won't show the UI, but it WILL start the process.
+            context.startActivity(launchIntent)
+        } catch (e: Exception) {
+            // Log error
+        }
+    }
+
+    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

@@ -23,7 +23,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             writableMap
         }
         promise.resolve(data)
-        pendingCallDataMap = null 
+        pendingCallDataMap = null // Clear after use
     }
 
     @ReactMethod
@@ -34,6 +34,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 "name" to name,
                 "callType" to callType
             )
+            // Use reactApplicationContext safely here
             NativeCallManager.handleIncomingPush(reactApplicationContext, data)
             promise.resolve(true)
         } catch (e: Exception) {
@@ -43,17 +44,13 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     @ReactMethod
     fun endNativeCall(uuid: String) {
-        // Since we aren't using Telecom, we just stop the ringtone and clear notification
         NativeCallManager.stopRingtone()
         pendingCallDataMap = null
         
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
-        
-        // No more ConnectionService to destroy!
     }
 
-    // This is a dummy now since we don't need PhoneAccount permissions anymore
     @ReactMethod
     fun checkTelecomPermissions(promise: Promise) {
         promise.resolve(true)
@@ -66,6 +63,7 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         private var instance: CallModule? = null
         private var pendingCallDataMap: Map<String, String>? = null
 
+        // This is the static gate accessible from AcceptCallActivity
         @JvmStatic
         fun setPendingCallData(data: Map<String, String>) {
             pendingCallDataMap = data
@@ -86,11 +84,15 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 else -> null
             }
 
+            // If app is alive, send via Bridge
             if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
                 reactContext
                     .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                     ?.emit(eventName, bridgeData)
-            } else if (eventName == "onCallAccepted" && params is Map<*, *>) {
+            } 
+            // If app is in killed state, save for polling
+            else if (eventName == "onCallAccepted" && params is Map<*, *>) {
+                @Suppress("UNCHECKED_CAST")
                 setPendingCallData(params as Map<String, String>)
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.3.1",
+    "version": "0.3.3",
     "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",