rns-nativecall 0.6.6 → 0.6.8

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

@@ -0,0 +1,104 @@
+package com.rnsnativecall
+
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+import com.facebook.react.HeadlessJsTaskService
+
+import android.os.Handler // Added
+import android.os.Looper  // Added
+
+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()
+
+        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(name)
+            .setContentText("Connecting...")
+            .setSmallIcon(applicationInfo.icon)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setPriority(NotificationCompat.PRIORITY_HIGH) 
+            .setOngoing(true)
+            .build()
+
+        // --- ANDROID 14 FIX START ---
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                NOTIFICATION_ID, 
+                notification, 
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL
+            )
+        } else {
+            startForeground(NOTIFICATION_ID, notification)
+        }
+        // --- ANDROID 14 FIX END ---
+
+        // Launch the Headless Task
+        val headlessIntent = Intent(this, CallHeadlessTask::class.java).apply {
+            // Safe bundle copy
+            val bundle = Bundle()
+            data?.let { b ->
+                for (key in b.keySet()) {
+                    bundle.putString(key, b.get(key)?.toString())
+                }
+            }
+            putExtras(bundle)
+        }
+        
+        try {
+            this.startService(headlessIntent)
+            HeadlessJsTaskService.acquireWakeLockNow(this)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+
+        // Automatically stop this service if JS doesn't stop it within 30 seconds
+Handler(Looper.getMainLooper()).postDelayed({
+    try {
+        stopSelf()
+    } catch (e: Exception) {
+        // Service might already be stopped
+    }
+}, 30000)
+        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_HIGH
+        ).apply {
+            description = "Handles incoming call connection state"
+            // Optional: makes the "Connecting" notification silent 
+            // so it doesn't double-beep with the actual ringtone
+            setSound(null, null) 
+        }
+        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        manager.createNotificationChannel(channel)
+    }
+}
+
+    override fun onBind(intent: Intent?): IBinder? = null
+}

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

@@ -49,6 +49,9 @@ if (!CallState.setCurrent(uuid)) {
     return 
 }
 
+
+
+
         if (isAppInForeground(context)) {
             // Foreground → send event directly
             CallModule.sendEventToJS("onCallReceived", data)
@@ -61,16 +64,29 @@ 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.6",
+    "version": "0.6.8",
     "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,6 +5,11 @@ function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
 
+        // Ensure Intent import for Kotlin
+        if (!contents.includes('import android.content.Intent')) {
+            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
+        }
+
         const onNewIntentCode = `
   override fun onNewIntent(intent: Intent) {
     super.onNewIntent(intent)
@@ -35,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',
@@ -48,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({
                 $: {
@@ -71,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({
@@ -93,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)) {