rns-nativecall 0.9.8 → 1.0.0

package/README.md

@@ -49,8 +49,8 @@ CallHandler.registerHeadlessTask(async (data, eventType) => {
 
 AppRegistry.registerComponent('main', () => App);
 ```
-### 2. Handling Events (Index.js/App.js)
-Use the subscribe method to handle user interaction (Accept/Reject) from the native UI.
+## Handling Events (Index.js)
+
 ```javascript
 // Index.js Setup Foreground Listeners
 CallHandler.subscribe(
@@ -79,8 +79,7 @@ CallHandler.subscribe(
 
 ````
 
-## App.js version
-
+## Handling Events (App.js)
 
 ```javascript
 import React, { useEffect } from 'react';
@@ -112,15 +111,129 @@ export default function App() {
 ```
 ---
 ### 📖 API Reference
-| Method | Description |
-| :--- | :--- |
-| **registerHeadlessTask(callback)** | Registers background logic. `eventType` is `INCOMING_CALL` or `BUSY`. |
-| **displayCall(uuid, name, type)** | Shows the native call UI. Type is `audio` or `video`. |
-| **checkCallValidity(uuid)** | Returns boolen value for `isValid` and `isCanceled` |
-| **destroyNativeCallUI(uuid)** | Dismisses the native call interface. |
-| **getInitialCallData()** | Returns call data if the app was launched by clicking `Answer`. |
-| **subscribe(onAccept, onReject)** | Listens for native button presses `(Answer/End)`. |
+# rns-nativecall API Reference
+
+| Method | Platform | Description |
+| :--- | :--- | :--- |
+| **registerHeadlessTask(callback)** | Android | Registers background logic. `eventType` is `INCOMING_CALL` or `BUSY`. |
+| **checkOverlayPermission()** | Android | Returns true if the app can draw over other apps (Required for Android Lockscreen). |
+| **requestOverlayPermission()** | Android | Opens System Settings to let the user enable "Draw over other apps". |
+| **displayCall(uuid, name, type)** | All | Shows the native call UI (Standard Notification on Android / CallKit on iOS). |
+| **checkCallValidity(uuid)** | All | Returns boolean values for `isValid` and `isCanceled`. |
+| **stopForegroundService()** | Android | Stops the ongoing service and clears the persistent notification/pill. |
+| **destroyNativeCallUI(uuid)** | All | Dismisses the native call interface and stops the ringtone. |
+| **getInitialCallData()** | All | Returns call data if the app was launched by clicking `Answer` from a killed state. |
+| **subscribe(onAccept, onReject)** | All | Listens for native button presses (Answer/End). |
+
+---
+
+# Implementation Notes
+
+1. Android Persistence:
+Because this library uses a Foreground Service on Android, the notification will persist and show a "Call Pill" in the status bar. To remove this after the call ends or connects, you MUST call 'CallHandler.stopForegroundService()'.
+
+2. Android Overlay:
+For your React Native call screen to show up when the phone is locked, the user must grant the "Overlay Permission". Use 'checkOverlayPermission()' and 'requestOverlayPermission()' during your app's onboarding or call initiation.
+
+3. iOS CallKit:
+On iOS, 'displayCall' uses the native system CallKit UI. This works automatically in the background and on the lockscreen without extra overlay permissions.
+
+4. Single Call Gate:
+The library automatically prevents multiple overlapping native UIs. If a call is already active, subsequent calls will trigger the 'BUSY' event in your Headless Task.
 ---
 
+## FULL Example Use Case
+```javascript
+import React, { useEffect, useState } from 'react';
+import { StyleSheet, Text, View, TouchableOpacity, Alert } from 'react-native';
+import { CallHandler } from 'rns-nativecall';
+
+export default function App() {
+  const [activeCall, setActiveCall] = useState(null);
+
+  useEffect(() => {
+    // 1. Handle app launched from a notification "Answer" click
+    CallHandler.getInitialCallData().then((data) => {
+      if (data && data.default) {
+        console.log("App launched from call:", data.default);
+        setActiveCall(data.default);
+      }
+    });
+
+    // 2. Subscribe to foreground events
+    const unsubscribe = CallHandler.subscribe(
+      (data) => {
+        console.log("Call Accepted:", data.callUuid);
+        setActiveCall(data);
+        // Logic: Open your Video/Audio Call UI here
+      },
+      (data) => {
+        console.log("Call Rejected/Ended:", data.callUuid);
+        setActiveCall(null);
+      }
+    );
+
+    return () => unsubscribe();
+  }, []);
+
+  const startTestCall = async () => {
+    // Android Only: Check for overlay permission to show UI over lockscreen
+    const hasPermission = await CallHandler.checkOverlayPermission();
+    if (!hasPermission) {
+      Alert.alert(
+        "Permission Required",
+        "Please enable 'Draw over other apps' to see calls while the phone is locked.",
+        [
+          { text: "Cancel" },
+          { text: "Settings", onPress: () => CallHandler.requestOverlayPermission() }
+        ]
+      );
+      return;
+    }
+
+    // Trigger the native UI
+    CallHandler.displayCall(
+      "test-uuid-" + Date.now(),
+      "John Doe",
+      "video"
+    );
+  };
+
+  const endCallManually = () => {
+    if (activeCall) {
+      CallHandler.stopForegroundService();
+      setActiveCall(null);
+    }
+  };
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>RNS Native Call Pro</Text>
+      
+      {activeCall ? (
+        <View style={styles.callBox}>
+          <Text>Active Call with: {activeCall.name}</Text>
+          <TouchableOpacity style={styles.btnEnd} onPress={endCallManually}>
+            <Text style={styles.btnText}>End Call</Text>
+          </TouchableOpacity>
+        </View>
+      ) : (
+        <TouchableOpacity style={styles.btnStart} onPress={startTestCall}>
+          <Text style={styles.btnText}>Simulate Incoming Call</Text>
+        </TouchableOpacity>
+      )}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, justifyContent: 'center', alignItems: 'center', backgroundColor: '#F5FCFF' },
+  title: { fontSize: 20, fontWeight: 'bold', marginBottom: 20 },
+  callBox: { padding: 20, backgroundColor: '#e1f5fe', borderRadius: 10, alignItems: 'center' },
+  btnStart: { backgroundColor: '#4CAF50', padding: 15, borderRadius: 5 },
+  btnEnd: { backgroundColor: '#F44336', padding: 15, borderRadius: 5, marginTop: 10 },
+  btnText: { color: 'white', fontWeight: 'bold' }
+});
+```
 ## 🛡 License
 ---

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

@@ -52,6 +52,9 @@ class CallForegroundService : Service() {
     ): Int {
         val data = intent?.extras
         val name = data?.getString("name") ?: "Someone"
+        val uuid = data?.getString("callUuid") ?: "default_uuid"
+
+        val notificationId = uuid.hashCode()
 
         createNotificationChannel()
 
@@ -68,12 +71,12 @@ class CallForegroundService : Service() {
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             startForeground(
-                NOTIFICATION_ID,
+                notificationId,
                 notification,
                 ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL,
             )
         } else {
-            startForeground(NOTIFICATION_ID, notification)
+            startForeground(notificationId, notification)
         }
 
         // Launch the Headless Task
@@ -95,26 +98,13 @@ class CallForegroundService : Service() {
             e.printStackTrace()
         }
 
-        // // Trigger the incoming call notification UI handled by NativeCallManager
-        // try {
-        //     val map = mutableMapOf<String, String>()
-        //     data?.let { b ->
-        //         for (key in b.keySet()) {
-        //             map[key] = b.get(key)?.toString() ?: ""
-        //         }
-        //     }
-        //     NativeCallManager.handleIncomingPush(this, map)
-        // } catch (e: Exception) {
-        //     e.printStackTrace()
-        // }
-
         // Auto-stop after 30s
-        Handler(Looper.getMainLooper()).postDelayed({
-            try {
-                stopSelf()
-            } catch (e: Exception) {
-            }
-        }, 30000)
+        // Handler(Looper.getMainLooper()).postDelayed({
+        //     try {
+        //         stopSelf()
+        //     } catch (e: Exception) {
+        //     }
+        // }, 30000)
 
         return START_NOT_STICKY
     }

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

@@ -1,8 +1,8 @@
 package com.rnsnativecall
 
 import android.app.ActivityManager
-import android.app.NotificationManager
 import android.app.NotificationChannel
+import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
@@ -10,14 +10,12 @@ import android.os.Build
 import android.os.Bundle
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
+import com.facebook.react.HeadlessJsTaskService
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
-import com.facebook.react.HeadlessJsTaskService
-
 import com.rnsnativecall.CallState
 
 class CallMessagingService : FirebaseMessagingService() {
-
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         val context = applicationContext
@@ -26,78 +24,62 @@ class CallMessagingService : FirebaseMessagingService() {
         val type = data["type"] ?: ""
 
         if (type == "CANCEL") {
-    NativeCallManager.stopRingtone()
-    // Pass context here to persist the cancellation
-    CallState.markCanceled(uuid, context) 
-    
-    if (CallState.getCurrent() == uuid) {
-        CallState.clear(uuid, context) 
-    }
-    
-    NativeCallManager.dismissIncomingCall(context, uuid)
-    showMissedCallNotification(context, data, uuid)
-    return
-}
-
-        // Inside onMessageReceived
-if (!CallState.setCurrent(uuid)) {
-    // We are busy! Start a SILENT headless task to send the WebSocket busy msg
-    val busyIntent = Intent(context, CallHeadlessTask::class.java).apply {
-        putExtras(Bundle().apply { 
-            data.forEach { (k, v) -> putString(k, v) }
-            putBoolean("isBusySignal", true) 
-        })
-    }
-    context.startService(busyIntent)
-    return 
-}
+            NativeCallManager.stopRingtone()
+            // Pass context here to persist the cancellation
+            CallState.markCanceled(uuid, context)
 
+            if (CallState.getCurrent() == uuid) {
+                CallState.clear(uuid, context)
+            }
 
+            NativeCallManager.dismissIncomingCall(context, uuid)
+            showMissedCallNotification(context, data, uuid)
+            return
+        }
 
+        // Inside onMessageReceived
+        if (!CallState.setCurrent(uuid)) {
+            // We are busy! Start a SILENT headless task to send the WebSocket busy msg
+            val busyIntent =
+                Intent(context, CallHeadlessTask::class.java).apply {
+                    putExtras(
+                        Bundle().apply {
+                            data.forEach { (k, v) -> putString(k, v) }
+                            putBoolean("isBusySignal", true)
+                        },
+                    )
+                }
+            context.startService(busyIntent)
+            return
+        }
 
         if (isAppInForeground(context)) {
             // Foreground → send event directly
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-            // Show incoming call notification instantly 
-            //NativeCallManager.handleIncomingPush(context, data) /// i will use headless instead
-            // Background → start foreground service + headless task
-            // val serviceIntent = Intent(context, CallForegroundService::class.java).apply {
-            //     putExtras(Bundle().apply { data.forEach { (k, v) -> putString(k, v) } })
-            // }
-            // 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()
-            // }
-
-
-    // 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)
-    }
-
+            // Background → start foreground service (which in turn starts headless)
+            val serviceIntent =
+                Intent(context, CallForegroundService::class.java).apply {
+                    putExtra("callUuid", uuid) // Key: Pass the UUID here
+                    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)
+            }
         }
     }
 
     private fun showMissedCallNotification(
         context: Context,
         data: Map<String, String>,
-        uuid: String
+        uuid: String,
     ) {
         val name = data["name"] ?: "Unknown"
         val callType = data["callType"] ?: "video"
@@ -107,40 +89,46 @@ if (!CallState.setCurrent(uuid)) {
             context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                channelId,
-                "Missed Calls",
-                NotificationManager.IMPORTANCE_DEFAULT
-            ).apply { description = "Missed call notifications" }
+            val channel =
+                NotificationChannel(
+                    channelId,
+                    "Missed Calls",
+                    NotificationManager.IMPORTANCE_DEFAULT,
+                ).apply { description = "Missed call notifications" }
             notificationManager.createNotificationChannel(channel)
         }
 
         val iconResId =
-            context.resources.getIdentifier("ic_missed_call", "drawable", context.packageName)
+            context.resources
+                .getIdentifier("ic_missed_call", "drawable", context.packageName)
                 .takeIf { it != 0 } ?: android.R.drawable.sym_call_missed
         val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
 
         val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
         launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-        val pendingIntent = PendingIntent.getActivity(
-            context,
-            uuid.hashCode(),
-            launchIntent,
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-            else
-                PendingIntent.FLAG_UPDATE_CURRENT
-        )
-
-        val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(iconResId)
-            .setContentTitle("$appName • Missed $callType call")
-            .setContentText("You missed a call from $name")
-            .setPriority(NotificationCompat.PRIORITY_HIGH)
-            .setAutoCancel(true)
-            .setCategory(NotificationCompat.CATEGORY_MISSED_CALL)
-            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            .setContentIntent(pendingIntent)
+        val pendingIntent =
+            PendingIntent.getActivity(
+                context,
+                uuid.hashCode(),
+                launchIntent,
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                } else {
+                    PendingIntent.FLAG_UPDATE_CURRENT
+                },
+            )
+
+        val builder =
+            NotificationCompat
+                .Builder(context, channelId)
+                .setSmallIcon(iconResId)
+                .setContentTitle("$appName • Missed $callType call")
+                .setContentText("You missed a call from $name")
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setAutoCancel(true)
+                .setCategory(NotificationCompat.CATEGORY_MISSED_CALL)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setContentIntent(pendingIntent)
 
         notificationManager.notify(uuid.hashCode(), builder.build())
     }
@@ -152,7 +140,7 @@ if (!CallState.setCurrent(uuid)) {
         val packageName = context.packageName
         return appProcesses.any {
             it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND &&
-            it.processName == packageName
+                it.processName == packageName
         }
     }
 }

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

@@ -19,7 +19,7 @@ object NativeCallManager {
     // because the system NotificationManager handles the sound.
 
     // Incrementing version to V3 to force fresh channel settings on the device
-    const val channelId = "CALL_CHANNEL_V6_URGENT"
+    const val channelId = "CALL_CHANNEL_V9_URGENT"
     private var currentCallData: Map<String, String>? = null
 
     fun getCurrentCallData(): Map<String, String>? = currentCallData
@@ -139,8 +139,15 @@ object NativeCallManager {
     ) {
         this.currentCallData = null
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
         if (uuid != null) {
+            // 1. Kill the notification UI
             notificationManager.cancel(uuid.hashCode())
+
+            // 2. IMPORTANT: Stop the Foreground Service process
+            // This ensures the "Pill" in the status bar goes away
+            val serviceIntent = Intent(context, CallForegroundService::class.java)
+            context.stopService(serviceIntent)
         }
     }
 

package/package.json

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