rns-nativecall 0.6.2 → 0.6.3

package/README.md

@@ -1,174 +1,94 @@
-# RNS Native Call
+# rns-nativecall
 
-RNS Native Call is a React Native package that provides fully native VoIP call handling on Android and iOS. It supports self-managed calls, video calls, and allows dismissing native call UI programmatically.
+A professional VoIP incoming call handler for React Native. Features a "Single Call Gate" on Android to manage busy states and full CallKit integration for iOS.
 
----
-
-## Features
-
-* Display incoming calls with native UI.
-* Support for video and audio calls.
-* Self-managed calls on Android (prevents polluting the device call log).
-* Prevents iOS call log from being saved using `includesCallsInRecents = NO`.
-* Subscribe to call events (accepted, rejected, failed).
-* Cross-platform (Android & iOS) ready.
+## 🚀 Highlights
+- **Expo Support**: Built-in config plugin handles all native setup.
+- **Single Call Gate**: Automatically detects if the user is in a call and flags secondary calls as "BUSY".
+- **Headless Mode**: Works even when the app is killed or the screen is locked.
 
 ---
 
-## Installation
+## 📦 Installation
 
 ```bash
 npm install rns-nativecall
-# or
-yarn add rns-nativecall
-```
-
----
-
-## Expo Integration
 
-If you are using **Expo managed workflow**, the package provides a plugin that automatically modifies the `AndroidManifest.xml` for required permissions and services.
-
-In your `app.json` / `app.config.js`:
-
-```js
-export default {
-  expo: {
-    name: 'YourApp',
-    slug: 'your-app',
-    plugins: [
-      "rns-nativecall"
-    ],
-  },
-};
 ```
-
-> The plugin ensures the following Android permissions are added automatically:
->
-> ```xml
-> <uses-permission android:name="android.permission.READ_PHONE_NUMBERS"/>
-> <uses-permission android:name="android.permission.CALL_PHONE"/>
-> ```
->
-> It also registers the `MyConnectionService` for Telecom integration:
->
-> ```xml
-> <service
->     android:name="com.rnsnativecall.MyConnectionService"
->     android:permission="android.permission.BIND_CONNECTION_SERVICE"
->     android:exported="true">
->     <intent-filter>
->         <action android:name="android.telecom.ConnectionService"/>
->     </intent-filter>
-> </service>
-> ```
-
----
-
-## iOS Setup
-
-1. Make sure you have the pod installed:
-
-```bash
-cd ios
-pod install
+--- 
+Add the plugin to your app.json or app.config.js:
+```json
+{
+  "expo": {
+    "plugins": ["rns-nativecall"]
+  }
+}
 ```
-
-2. CallKit is automatically used, so you need to enable it in your project, thats all and call log entries are prevented using:
-
-```objc
-config.includesCallsInRecents = NO;
-```
-
-> The native iOS module handles showing the call UI and managing call events.
-
 ---
-
-## Usage
-
-```ts
-import CallHandler from 'rns-nativecall';
-
-// Subscribe to call events
-const unsubscribe = CallHandler.subscribe(
-  (data) => console.log('Call Accepted', data),
-  (data) => console.log('Call Rejected', data),
-  (data) => console.log('Call Failed', data)
-);
-
-// Display an incoming call
-await CallHandler.displayCall(
-  'uuid-string', // use uuid.v4();
-  '+1234567890',
-  'John Doe',
-  true,   // hasVideo
-  true    // shouldRing
-);
-
-// Dismiss call UI programmatically
-CallHandler.destroyNativeCallUI('uuid-string');
-
-// Remove event listeners when done
-unsubscribe();
+### 🛠 Usage
+
+1. Initialize Headless Task (index.js)
+Register the task at the very top of your entry file. This handles background calls and "Busy" signals for secondary callers.
+```javascript
+import { AppRegistry } from 'react-native';
+import App from './App';
+import { CallHandler } from 'rns-nativecall';
+
+CallHandler.registerHeadlessTask(async (data, eventType) => {
+    if (eventType === 'BUSY') {
+        // User is already on a call. Notify the second caller via WebSocket/API.
+        console.log("System Busy for UUID:", data.callUuid);
+        return;
+    }
+
+    if (eventType === 'INCOMING_CALL') {
+        // App is waking up for a new call. 
+        // Trigger your custom UI or logic here.
+    }
+});
+
+AppRegistry.registerComponent('main', () => App);
+```
+### 2. Handling Events (App.js)
+Use the subscribe method to handle user interaction (Accept/Reject) from the native UI.
+```javascript
+import React, { useEffect } from 'react';
+import { CallHandler } from 'rns-nativecall';
+
+export default function App() {
+  useEffect(() => {
+    const unsubscribe = CallHandler.subscribe(
+      (data) => {
+        console.log("Call Accepted:", data.callUuid);
+        // Navigate to your call screen
+      },
+      (data) => {
+        console.log("Call Rejected:", data.callUuid);
+        // Send 'Hangup' signal to your server
+      }
+    );
+
+    return () => unsubscribe();
+  }, []);
+
+  // To manually trigger the UI (e.g., from an FCM data message)
+  const showCall = () => {
+    CallHandler.displayCall("unique-uuid", "Caller Name", "video");
+  };
+
+  return <YourUI />;
+}
 ```
-
----
-
-## API
-
-### `displayCall(uuid, number, name, hasVideo?, shouldRing?) => Promise<boolean>`
-
-Displays native incoming call UI.
-
-* **uuid**: Unique call identifier.
-* **number**: Caller number.
-* **name**: Caller display name.
-* **hasVideo**: Boolean, true for video call.
-* **shouldRing**: Boolean, true to play native ringtone.
-
-Returns a promise that resolves to `true` if UI was successfully displayed.
-
-### `destroyNativeCallUI(uuid)`
-
-Dismisses the native call UI.
-
-* **uuid**: Call identifier.
-
-### `subscribe(onAccept, onReject, onFailed) => () => void`
-
-Subscribe to native call events.
-
-* **onAccept**: Callback for accepted calls.
-* **onReject**: Callback for rejected calls.
-* **onFailed**: Optional callback for failed calls.
-
-Returns a function to unsubscribe all listeners.
-
 ---
-
-## Permissions
-
-### Android
-
-* `READ_PHONE_NUMBERS`
-* `CALL_PHONE`
-
-The Expo plugin ensures these are automatically added to `AndroidManifest.xml`.
-
-### iOS
-
-* Uses CallKit (`CXProvider`) internally.
-* Prevents call log pollution using `includesCallsInRecents = NO`.
-
+### 📖 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'`. |
+| **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). |
 ---
 
-## Notes
-
-* Android uses `Connection.CAPABILITY_SELF_MANAGED` to prevent calls from showing in the system call log.
-* iOS uses `CXCallEndedReasonRemoteEnded` for clean UI dismissal without showing failed call overlays.
-
+## 🛡 License
 ---
-
-## License
-
-MIT

package/android/build.gradle

@@ -68,7 +68,4 @@ dependencies {
     // Glide for profile pictures
     implementation "com.github.bumptech.glide:glide:4.15.1"
     annotationProcessor "com.github.bumptech.glide:compiler:4.15.1"
-    
-    implementation "androidx.core:core-ktx:1.12.0"
-    implementation "androidx.appcompat:appcompat:1.6.1"
 }

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

@@ -5,51 +5,78 @@ import android.app.NotificationManager
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
+import android.view.WindowManager
+import android.app.KeyguardManager
 
 class AcceptCallActivity : Activity() {
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        
-        val dataMap = mutableMapOf<String, String>()
-        val extras = intent.extras
 
-        // Extract every single extra passed in from NativeCallManager
-        extras?.keySet()?.forEach { key ->
-            val value = extras.get(key)
-            if (value != null) {
-                dataMap[key] = value.toString()
-            }
-        }
+        // Wake + lock flags
+        window.addFlags(
+            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or
+            WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+        )
 
-        val uuid = dataMap["callUuid"]
+        // Optionally dismiss keyguard
+        val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        keyguardManager.requestDismissKeyguard(this, null)
 
-        if (uuid != null) {
-            // Kill background processes
-            CallMessagingService.stopBackupTimer(uuid)
-            val stopHeadlessIntent = Intent(applicationContext, CallHeadlessTask::class.java)
-            applicationContext.stopService(stopHeadlessIntent)
+        processCallIntent(intent)
+    }
 
-            // Stop Ringtone & Notification
-            NativeCallManager.stopRingtone()
-            val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            notificationManager.cancel(uuid.hashCode())
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        processCallIntent(intent)
+    }
 
-            // SYNC WITH JS
-            CallModule.setPendingCallData(dataMap)
-            CallModule.sendEventToJS("onCallAccepted", dataMap)
+    private fun processCallIntent(intent: Intent) {
+        NativeCallManager.stopRingtone()
+
+        val extras = intent.extras
+        val uuid = extras?.getString("callUuid")
+        val name = extras?.getString("name") ?: "Someone"
+        val callType = extras?.getString("callType") ?: "audio"
 
-            // OPEN THE APP
-            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            launchIntent?.apply {
-                // Pass ALL data forward to the main app
-                putExtras(extras ?: Bundle())
-                putExtra("navigatingToCall", true)
-                
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        uuid?.let { notificationManager.cancel(it.hashCode()) }
+
+        val dataMap = mutableMapOf<String, String>()
+        extras?.keySet()?.forEach { key ->
+            extras.get(key)?.let { dataMap[key] = it.toString() }
+        }
+
+        if (CallModule.isReady()) {
+            CallModule.sendEventToJS("onCallAccepted", dataMap)
+            openMainApp(extras)
+            finish()
+        } else {
+            CallModule.setPendingCallData("onCallAccepted_pending", dataMap)
+            if (uuid != null) {
+                NativeCallManager.connecting(this, uuid, name, callType)
+            }
+            // Register callback to auto‑open app once RN is ready
+            CallModule.registerOnReadyCallback {
+                runOnUiThread {
+                    openMainApp(extras)
+                    finish()
+                }
             }
-            startActivity(launchIntent)
         }
-        
-        finish()
     }
-}
+
+    // ✅ Now a proper member function
+    private fun openMainApp(extras: Bundle?) {
+        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+        launchIntent?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            putExtras(extras ?: Bundle())
+            putExtra("navigatingToCall", true)
+            startActivity(this)
+        }
+    }
+}

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

@@ -4,44 +4,49 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.app.NotificationManager
+import android.app.KeyguardManager
 
 class CallActionReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
-        val uuid = intent.getStringExtra("EXTRA_CALL_UUID") ?: return
-        val action = intent.action ?: return
-
-        // 1. KILL THE BACKUP TIMER (Stop MessagingService from re-triggering)
-        CallMessagingService.stopBackupTimer(uuid)
+        NativeCallManager.stopRingtone()
 
-        // 2. STOP THE HEADLESS SERVICE (Stop JS from initializing WebRTC)
-        val stopHeadlessIntent = Intent(context, CallHeadlessTask::class.java)
-        context.stopService(stopHeadlessIntent)
+        val uuid = intent.getStringExtra("EXTRA_CALL_UUID") ?: return
+        val action = intent.action ?: ""
 
-        // 3. STOP NATIVE UI
-        NativeCallManager.stopRingtone()
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(uuid.hashCode())
+        val notificationManager =
+            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         val dataMap = mutableMapOf<String, String>()
         intent.extras?.keySet()?.forEach { key ->
             intent.extras?.get(key)?.let { dataMap[key] = it.toString() }
         }
 
-        if (action.contains("ACTION_ACCEPT")) {
-            CallModule.setPendingCallData(dataMap)
-            CallModule.sendEventToJS("onCallAccepted", dataMap)
-
-            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-            launchIntent?.apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                putExtras(intent.extras ?: android.os.Bundle())
-                putExtra("navigatingToCall", true)
+        val name = intent.extras?.getString("name") ?: "Someone"
+        val callType = intent.extras?.getString("callType") ?: "audio"
+
+        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+
+        if (action.contains("ACTION_REJECT")) {
+            if (CallModule.isReady()) {
+                CallModule.sendEventToJS("onCallRejected", mapOf("callUuid" to uuid))
+                notificationManager.cancel(uuid.hashCode())
+            } else {
+                // Queue pending event
+                CallModule.setPendingCallData("onCallRejected_pending", mapOf("callUuid" to uuid))
+                // Update notification pill to "Aborting…" state
+                NativeCallManager.aborting(context, uuid, name, callType)
+
+                // Register callback to auto‑open app once RN is ready
+                CallModule.registerOnReadyCallback {
+                    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+                    launchIntent?.apply {
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                        putExtras(intent.extras ?: android.os.Bundle())
+                        putExtra("navigatingToCall", true)
+                        context.startActivity(this)
+                    }
+                }
             }
-            context.startActivity(launchIntent)
-            
-        } else if (action.contains("ACTION_REJECT")) {
-            // Tell JS call is dead
-            CallModule.sendEventToJS("onCallRejected", dataMap)
         }
     }
-}
+}

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

@@ -1,64 +1,36 @@
 package com.rnsnativecall
 
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.content.Context
 import android.content.Intent
-import android.content.pm.ServiceInfo
-import android.os.Build
-import androidx.core.app.NotificationCompat
 import com.facebook.react.HeadlessJsTaskService
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.jstasks.HeadlessJsTaskConfig
 import com.facebook.react.jstasks.LinearCountingRetryPolicy
 
-class CallHeadlessTask : HeadlessJsTaskService() {
+import com.rnsnativecall.CallState
 
-    override fun onCreate() {
-        super.onCreate()
-        val channelId = "call_service"
-        val notificationId = 1 // Constant ID for the foreground service
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                channelId, 
-                "Call Connection Service", 
-                NotificationManager.IMPORTANCE_LOW
-            )
-            val manager = getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
-        }
+class CallHeadlessTask : HeadlessJsTaskService() {
 
-        // IMPORTANT: Must have a setSmallIcon or the service will crash on modern Android
-        val notification: Notification = NotificationCompat.Builder(this, channelId)
-            .setContentTitle("Incoming call...")
-            .setContentText("Establishing connection")
-            .setSmallIcon(android.R.drawable.sym_action_call) // Built-in icon as fallback
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .setCategory(NotificationCompat.CATEGORY_SERVICE)
-            .build()
+override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+    val extras = intent?.extras ?: return null
+    val uuid = extras.getString("callUuid")
+    val isBusySignal = extras.getBoolean("isBusySignal", false)
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            // Android 14+ requires the FOREGROUND_SERVICE_TYPE_PHONE_CALL type
-            startForeground(notificationId, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL)
-        } else {
-            startForeground(notificationId, notification)
-        }
+    // GATE: If the call was canceled before we even started the task, 
+    // we don't need to show the UI OR send a busy signal.
+    if (CallState.isCanceled(uuid)) {
+        return null
     }
 
-    override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
-        val extras = intent?.extras
-        return if (extras != null) {
-            // Linear retry helps if the JS bridge is busy or mid-reload
-            val retryPolicy = LinearCountingRetryPolicy(3, 1000)
-            HeadlessJsTaskConfig(
-                "ColdStartCallTask",
-                Arguments.fromBundle(extras),
-                60000, // Timeout after 60s
-                true,  // Allow task to run in foreground
-                retryPolicy
-            )
-        } else null
-    }
+    // Use a shorter timeout for Busy Signals (30s) vs real calls (60s)
+    val timeout = if (isBusySignal) 30000L else 60000L
+
+    return HeadlessJsTaskConfig(
+        "ColdStartCallTask",
+        Arguments.fromBundle(extras),
+        timeout,
+        true, // Allow in foreground
+        LinearCountingRetryPolicy(3, 1000)
+    )
+}  
 }