rns-nativecall 0.3.4 → 0.3.5

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

@@ -9,11 +9,12 @@ class CallHeadlessTask : HeadlessJsTaskService() {
     override fun getTaskConfig(intent: Intent): HeadlessJsTaskConfig? {
         val extras = intent.extras
         return if (extras != null) {
+            // INCREASE timeout to 30000 (30s) so it covers your 18s delay
             HeadlessJsTaskConfig(
-                "ColdStartCallTask", // This name must match JS registration
+                "ColdStartCallTask",
                 Arguments.fromBundle(extras),
-                5000, // Timeout for the task
-                true  // Allowed in foreground
+                30000, 
+                true // Allow in foreground
             )
         } else {
             null

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

@@ -6,58 +6,108 @@ import android.content.Intent
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.app.NotificationManager
+import androidx.core.app.NotificationCompat
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 import com.facebook.react.HeadlessJsTaskService
 
 class CallMessagingService : FirebaseMessagingService() {
 
+    // This companion object allows the Cancel logic to find the active timer
+    companion object {
+        private val handler = Handler(Looper.getMainLooper())
+        private val pendingNotifications = mutableMapOf<String, Runnable>()
+    }
+
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         val context = applicationContext
         
+        // Extract variables for logic
+        val uuid = data["callUuid"] ?: return
+        val type = data["type"] ?: ""
+
+        // CASE 1: CALLER HUNG UP / CANCELLED
+        if (type == "CANCEL") {
+            // 1. Remove the pending 18s timer for this specific call
+            pendingNotifications[uuid]?.let {
+                handler.removeCallbacks(it)
+                pendingNotifications.remove(uuid)
+            }
+            
+            // 2. Stop the ringtone/Pill if it had already started showing
+            NativeCallManager.stopRingtone()
+            CallHandler.destroyNativeCallUI(uuid) // Ensure native UI is killed
+            
+            // 3. Show standard "Missed Call" notification
+            showMissedCallNotification(context, data, uuid)
+            return
+        }
+        
+        // CASE 2: NEW INCOMING CALL
         if (isAppInForeground(context)) {
-            // App is visible: Send event to active JS bridge
+            // App is visible: Send event to active JS bridge immediately
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-            // App is killed/background: Start the Headless JS Task
-            // This wakes up the JS engine and connects your WebSocket
-            startHeadlessTask(context, data)
-
-            // Start the 18-second "System Pill" backup timer
-            val handler = Handler(Looper.getMainLooper())
-            handler.postDelayed({
-                // Final safety check: if the user hasn't brought the app to foreground,
-                // show the native full-screen notification (The Pill)
-                if (!isAppInForeground(context)) {
-                    NativeCallManager.handleIncomingPush(context, data)
-                }
-            }, 18000)
+    // 1. Wake the actual App process by launching the Intent
+    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+    launchIntent?.apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        // This is key: it tells the app to boot the JS but stay minimized
+        putExtra("background_wake", true) 
+    }
+    context.startActivity(launchIntent)
+    
+    // You SHOULD see "Android Bundled..." now because the Activity is starting
+    
+    val showNotificationRunnable = Runnable {
+        if (!isAppInForeground(context)) {
+            NativeCallManager.handleIncomingPush(context, data)
         }
     }
+    handler.postDelayed(showNotificationRunnable, 18000)
+}
+    }
 
     private fun startHeadlessTask(context: Context, data: Map<String, String>) {
         val serviceIntent = Intent(context, CallHeadlessTask::class.java)
         val bundle = Bundle()
-        
-        // Pass all FCM data to the JS task
         data.forEach { (key, value) -> bundle.putString(key, value) }
         serviceIntent.putExtras(bundle)
         
-        // Start the service. This triggers the 'ColdStartCallTask' in index.js
         context.startService(serviceIntent)
         HeadlessJsTaskService.acquireWakeLockNow(context)
     }
 
+    private fun showMissedCallNotification(context: Context, data: Map<String, String>, uuid: String) {
+        val name = data["name"] ?: "Unknown"
+        val callType = data["callType"] ?: "video"
+        val channelId = "missed_calls" // Ensure this channel is created in your MainApplication or CallManager
+
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        // Use ic_launcher as fallback if ic_missed_call isn't found
+        var iconResId = context.resources.getIdentifier("ic_missed_call", "drawable", context.packageName)
+        if (iconResId == 0) iconResId = android.R.drawable.sym_call_missed
+
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(iconResId)
+            .setContentTitle("Missed $callType call")
+            .setContentText("You missed a call from $name")
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setAutoCancel(true)
+            .setCategory(NotificationCompat.CATEGORY_MISS)
+
+        notificationManager.notify(uuid.hashCode(), builder.build())
+    }
+
     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) {
-            // IMPORTANCE_FOREGROUND only triggers if a real Activity is on screen.
-            // Running a Headless Task counts as IMPORTANCE_VISIBLE or lower, 
-            // so this check remains accurate.
             if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && 
                 appProcess.processName == packageName) {
                 return true

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

@@ -28,7 +28,6 @@ object NativeCallManager {
         } else {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
-
         // 1. IMPROVED INTENT: Direct to AcceptCallActivity
         // This is better than a dummy intent because it allows the OS to 
         // launch your "Accept" logic immediately if the phone is locked.

package/package.json

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

package/withNativeCallVoip.js

@@ -5,10 +5,15 @@ function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
 
+        // 1. Ensure necessary Imports are present
         if (!contents.includes('import android.content.Intent')) {
             contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
         }
+        if (!contents.includes('import android.os.Bundle')) {
+            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.os.Bundle`);
+        }
 
+        // 2. Define the code blocks
         const onNewIntentCode = `
   override fun onNewIntent(intent: Intent) {
     super.onNewIntent(intent)
@@ -16,11 +21,28 @@ function withMainActivityDataFix(config) {
   }
 `;
 
+        const onCreateCode = `
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    // If woken up silently, move to back to prevent UI flicker
+    if (intent.getBooleanExtra("background_wake", false)) {
+        moveTaskToBack(true)
+    }
+  }
+`;
+
+        // 3. Insert the codes before the last closing brace of the class
         if (!contents.includes('override fun onNewIntent')) {
             const lastBraceIndex = contents.lastIndexOf('}');
             contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
         }
 
+        if (!contents.includes('override fun onCreate')) {
+            // Re-calculate lastBraceIndex because contents string has changed
+            const lastBraceIndex = contents.lastIndexOf('}');
+            contents = contents.slice(0, lastBraceIndex) + onCreateCode + contents.slice(lastBraceIndex);
+        }
+
         config.modResults.contents = contents;
         return config;
     });
@@ -104,6 +126,8 @@ function withAndroidConfig(config) {
             });
         }
 
+
+
         return config;
     });
 }