rns-nativecall 0.3.0 → 0.3.2

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,8 @@ package com.rnsnativecall
 
 import android.app.ActivityManager
 import android.content.Context
+import android.os.Handler
+import android.os.Looper
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 
@@ -10,17 +12,33 @@ class CallMessagingService : FirebaseMessagingService() {
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         
-        // 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(applicationContext)) {
+            // 1. App is OPEN: Send to JS immediately (No delay)
             CallModule.sendEventToJS("onCallReceived", data)
+        } else {
+            // 2. App is CLOSED/BACKGROUND: Delay the system pill by 18 seconds
+            val handler = Handler(Looper.getMainLooper())
+            handler.postDelayed({
+                // Re-check: If the user opened the app during these 18 seconds, 
+                // we might want to cancel the pill.
+                if (!isAppInForeground(applicationContext)) {
+                    NativeCallManager.handleIncomingPush(applicationContext, data)
+                }
+            }, 18000)
         }
     }
+
+    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,14 +1,7 @@
 package com.rnsnativecall
 
 import android.app.NotificationManager
-import android.content.ComponentName
 import android.content.Context
-import android.content.Intent
-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
 
@@ -16,16 +9,12 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     init {
         instance = this
-        registerPhoneAccount()
     }
 
     override fun getName() = "CallModule"
 
-    // ... getPhoneAccountHandle and registerPhoneAccount remain the same ...
-
     @ReactMethod
     fun getInitialCallData(promise: Promise) {
-        // Convert our stored simple Map into a WritableMap for JS
         val data = pendingCallDataMap?.let { map ->
             val writableMap = Arguments.createMap()
             map.forEach { (key, value) ->
@@ -33,9 +22,8 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             }
             writableMap
         }
-        
         promise.resolve(data)
-        pendingCallDataMap = null // Clear after consumption
+        pendingCallDataMap = null // Clear after use
     }
 
     @ReactMethod
@@ -46,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) {
@@ -56,26 +45,25 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     @ReactMethod
     fun endNativeCall(uuid: String) {
         NativeCallManager.stopRingtone()
-        pendingCallDataMap = null // Clear any pending data
+        pendingCallDataMap = null
         
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
+    }
 
-        val connection = MyConnectionService.getConnection(uuid)
-        connection?.let {
-            it.setDisconnected(DisconnectCause(DisconnectCause.MISSED))
-            it.destroy()
-            MyConnectionService.removeConnection(uuid)
-        }
+    @ReactMethod
+    fun checkTelecomPermissions(promise: Promise) {
+        promise.resolve(true)
     }
 
-    // ... checkTelecomPermissions remains the same ...
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
 
     companion object {
         private var instance: CallModule? = null
-        // Use a standard Map to store data so we don't depend on React Context being alive
         private var pendingCallDataMap: Map<String, String>? = null
 
+        // This is the static gate accessible from AcceptCallActivity
         @JvmStatic
         fun setPendingCallData(data: Map<String, String>) {
             pendingCallDataMap = data
@@ -85,7 +73,6 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         fun sendEventToJS(eventName: String, params: Any?) {
             val reactContext = instance?.reactApplicationContext
 
-            // Convert params to WritableMap
             val bridgeData = when (params) {
                 is Map<*, *> -> {
                     val map = Arguments.createMap()
@@ -97,12 +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<*, *>) {
-                // FALLBACK: Store data for polling if JS isn't ready
+            } 
+            // 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.0",
+    "version": "0.3.2",
     "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",