rns-nativecall 0.6.5 → 0.6.7

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

@@ -13,6 +13,7 @@ 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
@@ -34,36 +35,30 @@ class AcceptCallActivity : Activity() {
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         uuid?.let { notificationManager.cancel(it.hashCode()) }
 
-        // ✅ WE STOP SENDING THE JS EVENT HERE.
-        // Instead, we pass the intent to MainActivity with a specific ACTION.
+        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
         openMainApp(extras)
         finish()
     }
 
     private fun openMainApp(extras: Bundle?) {
-        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)
-            }
+        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+        launchIntent?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            putExtras(extras ?: Bundle())
+            startActivity(this)
         }
     }
 }

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

@@ -0,0 +1,70 @@
+package com.rnsnativecall
+
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import com.facebook.react.HeadlessJsTaskService
+
+class CallForegroundService : Service() {
+
+    companion object {
+        private const val NOTIFICATION_ID = 101
+        private const val CHANNEL_ID = "incoming_call_service"
+
+        fun stop(context: Context) {
+            val intent = Intent(context, CallForegroundService::class.java)
+            context.stopService(intent)
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val data = intent?.extras
+        val name = data?.getString("name") ?: "Someone"
+        
+        createNotificationChannel()
+
+        // Create a notification that shows "Connecting..."
+        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(name)
+            .setContentText("Connecting...")
+            .setSmallIcon(applicationInfo.icon)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setPriority(NotificationCompat.PRIORITY_LOW) // Keep it subtle until UI pops
+            .setOngoing(true)
+            .build()
+
+        // Start Foreground immediately to satisfy OS requirements
+        startForeground(NOTIFICATION_ID, notification)
+
+        // Launch the Headless Task while under the protection of this service
+        val headlessIntent = Intent(this, CallHeadlessTask::class.java).apply {
+            data?.let { putExtras(it) }
+        }
+        
+        try {
+            this.startService(headlessIntent)
+            HeadlessJsTaskService.acquireWakeLockNow(this)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        return START_NOT_STICKY
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Call Service",
+                NotificationManager.IMPORTANCE_LOW
+            )
+            val manager = getSystemService(NotificationManager::class.java)
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+}

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

@@ -61,17 +61,30 @@ if (!CallState.setCurrent(uuid)) {
             // }
             // ContextCompat.startForegroundService(context, serviceIntent)
 
-            val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
-                putExtras(Bundle().apply { data.forEach { (k, v) -> putString(k, v) } })
-            }
-            try {
-                context.startService(headlessIntent)
-                HeadlessJsTaskService.acquireWakeLockNow(context)
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
+            // val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
+            //     putExtras(Bundle().apply { data.forEach { (k, v) -> putString(k, v) } })
+            // }
+            // try {
+            //     context.startService(headlessIntent)
+            //     HeadlessJsTaskService.acquireWakeLockNow(context)
+            // } catch (e: Exception) {
+            //     e.printStackTrace()
+            // }
 
 
+    // Background → start foreground service (which in turn starts headless)
+    val serviceIntent = Intent(context, CallForegroundService::class.java).apply {
+        putExtras(Bundle().apply { 
+            data.forEach { (k, v) -> putString(k, v) } 
+        })
+    }
+    
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        context.startForegroundService(serviceIntent)
+    } else {
+        context.startService(serviceIntent)
+    }
+
         }
     }
 

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

@@ -4,6 +4,7 @@ import android.app.NotificationManager
 import android.content.Context
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import android.content.Intent
 
 class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -66,6 +67,18 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         promise.resolve(map)
     }
 
+    @ReactMethod
+    fun stopForegroundService(promise: Promise) {
+        try {
+            // Using the current react context to stop the service
+            val intent = Intent(reactApplicationContext, CallForegroundService::class.java)
+            reactApplicationContext.stopService(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("SERVICE_STOP_ERROR", e.message)
+        }
+    }
+
     /**
      * General Status Check:
      * Useful for checking if the UI is still relevant.

package/index.d.ts

@@ -25,6 +25,8 @@ export interface CallHandlerType {
 
     destroyNativeCallUI(uuid: string): void;
 
+    stopForegroundService(): Promise<void>;
+
     getInitialCallData(): Promise<any | null>;
 
     subscribe(

package/index.js

@@ -37,6 +37,7 @@ export const CallHandler = {
                 if (onAction) {
                     await onAction(data, 'INCOMING_CALL');
                 }
+
             } catch (error) {
                 console.error('[RNSNativeCall] Headless Task Error:', error);
             }
@@ -48,6 +49,10 @@ export const CallHandler = {
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
     },
 
+    stopForegroundService: async () => {
+        await CallModule.stopForegroundService(true)
+    },
+
     destroyNativeCallUI: (uuid) => {
         if (CallModule?.endNativeCall) {
             CallModule.endNativeCall(uuid.toLowerCase().trim());

package/package.json

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

package/withNativeCallVoip.js

@@ -5,32 +5,15 @@ function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
 
-        // Ensure imports exist
+        // Ensure Intent import for Kotlin
         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`);
-        }
 
         const onNewIntentCode = `
   override fun onNewIntent(intent: Intent) {
     super.onNewIntent(intent)
     setIntent(intent)
-    
-    // Check for the specific Answer Action
-    val isAnswerAction = intent.action == "com.rnsnativecall.ACTION_ANSWER"
-    
-    val dataMap = mutableMapOf<String, String>()
-    intent.extras?.keySet()?.forEach { key ->
-        dataMap[key] = intent.extras?.get(key)?.toString() ?: ""
-    }
-
-    // FIRE if it's the answer action, even if extras are slim
-    if (isAnswerAction) {
-        com.rnsnativecall.CallModule.setPendingCallData("onCallAccepted_pending", dataMap)
-        com.rnsnativecall.CallModule.sendEventToJS("onCallAccepted", dataMap)
-    }
   }
 `;
 
@@ -38,25 +21,12 @@ function withMainActivityDataFix(config) {
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     
-    val isAnswerAction = intent.action == "com.rnsnativecall.ACTION_ANSWER"
-    
-    // Logic for Cold Start (App was dead, user answered)
-    if (isAnswerAction) {
-        val dataMap = mutableMapOf<String, String>()
-        intent.extras?.keySet()?.forEach { key ->
-            dataMap[key] = intent.extras?.get(key)?.toString() ?: ""
-        }
-        com.rnsnativecall.CallModule.setPendingCallData(dataMap)
-    }
-
-    // Move to back if it's a background wake (FCM) and NOT an answer click
-    if (intent.getBooleanExtra("background_wake", false) && !isAnswerAction) {
+    // If background wake from FCM, move to back to let LockScreen UI show
+    if (intent.getBooleanExtra("background_wake", false)) {
         moveTaskToBack(true)
     }
   }
 `;
-
-        // Inject codes
         if (!contents.includes('override fun onNewIntent')) {
             const lastBraceIndex = contents.lastIndexOf('}');
             contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
@@ -70,11 +40,14 @@ function withMainActivityDataFix(config) {
         return config;
     });
 }
+
 /** 2. ANDROID MANIFEST CONFIG **/
 function withAndroidConfig(config) {
     return withAndroidManifest(config, (config) => {
         const manifest = config.modResults;
         const application = manifest.manifest.application[0];
+
+        // Comprehensive list for VoIP & Foreground Services
         const permissions = [
             'android.permission.USE_FULL_SCREEN_INTENT',
             'android.permission.VIBRATE',
@@ -83,15 +56,19 @@ function withAndroidConfig(config) {
             'android.permission.POST_NOTIFICATIONS',
             'android.permission.SYSTEM_ALERT_WINDOW',
             'android.permission.WAKE_LOCK',
-            'android.permission.DISABLE_KEYGUARD'
+            'android.permission.DISABLE_KEYGUARD',
+            'android.permission.MANAGE_OWN_CALLS'
         ];
+
         manifest.manifest['uses-permission'] = manifest.manifest['uses-permission'] || [];
         permissions.forEach((perm) => {
             if (!manifest.manifest['uses-permission'].some((p) => p.$['android:name'] === perm)) {
                 manifest.manifest['uses-permission'].push({ $: { 'android:name': perm } });
             }
         });
+
         application.activity = application.activity || [];
+        // AcceptCallActivity registration
         if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
             application.activity.push({
                 $: {
@@ -106,21 +83,10 @@ function withAndroidConfig(config) {
                 }
             });
         }
-        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.UnlockPromptActivity')) {
-            application.activity.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.UnlockPromptActivity',
-                    'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
-                    'android:excludeFromRecents': 'true',
-                    'android:noHistory': 'true',
-                    'android:exported': 'false',
-                    'android:launchMode': 'singleInstance',
-                    'android:showWhenLocked': 'true',
-                    'android:turnScreenOn': 'true'
-                }
-            });
-        }
+
         application.service = application.service || [];
+
+        // 1. Firebase Messaging Service
         const firebaseServiceName = 'com.rnsnativecall.CallMessagingService';
         if (!application.service.some(s => s.$['android:name'] === firebaseServiceName)) {
             application.service.push({
@@ -128,12 +94,27 @@ function withAndroidConfig(config) {
                 'intent-filter': [{ action: [{ $: { 'android:name': 'com.google.firebase.MESSAGING_EVENT' } }] }]
             });
         }
+
+        // 2. Headless Task Service
         const headlessServiceName = 'com.rnsnativecall.CallHeadlessTask';
         if (!application.service.some(s => s.$['android:name'] === headlessServiceName)) {
             application.service.push({
                 $: { 'android:name': headlessServiceName, 'android:exported': 'false' }
             });
         }
+
+        // 3. Foreground Service (The "Connecting..." spinner)
+        const foregroundServiceName = 'com.rnsnativecall.CallForegroundService';
+        if (!application.service.some(s => s.$['android:name'] === foregroundServiceName)) {
+            application.service.push({
+                $: {
+                    'android:name': foregroundServiceName,
+                    'android:foregroundServiceType': 'phoneCall',
+                    'android:exported': 'false'
+                }
+            });
+        }
+
         application.receiver = application.receiver || [];
         const receiverName = 'com.rnsnativecall.CallActionReceiver';
         if (!application.receiver.some(r => r.$['android:name'] === receiverName)) {