rns-nativecall 1.1.5 → 1.1.6

package/README.md

@@ -130,31 +130,32 @@ export default function App() {
 ### 📖 API Reference
 # rns-nativecall API Reference
 
-| Method                       | Platform    | Description                                                                           |
-|:-----------------------------|:------------|:--------------------------------------------------------------------------------------|
-| checkFullScreenPermission()  | Android 14+ | Returns true if the app is allowed to show calls over the lockscreen (FSI).           |
-| openFullScreenSettings()     | Android 14+ | Deep-links the user to the specific system page to enable Full-Screen Intent.         |
-| checkOverlayPermission()     | Android     | Returns true if the app can draw over other apps (Overlay/Draw over apps).            |
-| requestOverlayPermission()   | Android     | Opens System Settings to let the user enable "Draw over other apps".                  |
-| displayCall(uuid, name, type)| All         | Launches the native call UI (CallStyle on Android / CallKit on iOS).                  |
-| checkCallValidity(uuid)      | All         | Returns boolean values for `isValid` and `isCanceled` to prevent "ghost" calls.        |
-| checkCallStatus(uuid)        | All         | Detailed check of a call's status; useful for determining if UI should remain active. |
-| reportRemoteEnded(uuid, res) | All         | Notifies the native side that the caller hung up (prevents infinite ringing).         |
-| destroyNativeCallUI(uuid)    | All         | Forcefully dismisses the native call interface and stops the ringtone immediately.    |
-| 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/Failed) and returns a cleanup function. |
+| 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 Overlay:
+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.
 
-2. iOS CallKit:
+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.
 
-3. Single Call Gate:
+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.
 ---
 

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

@@ -61,6 +61,7 @@ class CallModule(
         }
     }
 
+    // Inside your CallModule class
     @ReactMethod
     fun checkOverlayPermission(promise: Promise) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -70,16 +71,6 @@ class CallModule(
         }
     }
 
-    @ReactMethod
-    fun reportRemoteEnded(
-        uuid: String,
-        reason: String,
-        promise: Promise,
-    ) {
-        NativeCallManager.dismissIncomingCall(reactApplicationContext, uuid)
-        promise.resolve(true)
-    }
-
     @ReactMethod
     fun requestOverlayPermission() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -95,39 +86,10 @@ class CallModule(
         }
     }
 
-    @ReactMethod
-    fun checkFullScreenIntentPermission(promise: Promise) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            promise.resolve(notificationManager.canUseFullScreenIntent())
-        } else {
-            // Automatically true for Android 13 and below
-            promise.resolve(true)
-        }
-    }
-
-    @ReactMethod
-    fun openFullScreenIntentSettings() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            try {
-                val intent =
-                    Intent(Settings.ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT).apply {
-                        data = Uri.fromParts("package", reactApplicationContext.packageName, null)
-                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                    }
-                reactApplicationContext.startActivity(intent)
-            } catch (e: Exception) {
-                // Fallback for some OEM skins that might not support the direct intent
-                val intent =
-                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
-                        data = Uri.fromParts("package", reactApplicationContext.packageName, null)
-                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                    }
-                reactApplicationContext.startActivity(intent)
-            }
-        }
-    }
-
+    /**
+     * Combined Validity Check:
+     * Used by Headless Task to see if it should proceed with the UI.
+     */
     @ReactMethod
     fun checkCallValidity(
         uuid: String,
@@ -145,6 +107,22 @@ class CallModule(
         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.
+     */
     @ReactMethod
     fun checkCallStatus(
         uuid: String,

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

@@ -14,7 +14,7 @@ import androidx.core.app.Person
 import androidx.core.content.ContextCompat
 
 object NativeCallManager {
-    const val channelId = "CALL_CHANNEL_V0_URGENT"
+    const val channelId = "CALL_CHANNEL_V15_URGENT"
     private var currentCallData: Map<String, String>? = null
 
     @JvmStatic internal var pendingCallNotification: Notification? = null
@@ -102,7 +102,6 @@ object NativeCallManager {
                     .setOngoing(true)
                     .setFullScreenIntent(fullScreenPendingIntent, true)
                     .setStyle(NotificationCompat.CallStyle.forIncomingCall(caller, rejectPendingIntent, answerPendingIntent))
-                    .setAutoCancel(false)
                     .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
 
             val notification = builder.build()
@@ -118,14 +117,6 @@ object NativeCallManager {
         }
     }
 
-    fun refreshNotificationOnly(
-        context: Context,
-        uuid: String,
-    ) {
-        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        manager.cancel(uuid.hashCode())
-    }
-
     fun dismissIncomingCall(
         context: Context,
         uuid: String?,

package/index.d.ts

@@ -48,7 +48,7 @@ export interface CallHandlerType {
     /**
      * Registers the background "Headless" task.
      * This is the bridge between a Native push notification and your React Native UI.
-     * @param callback Async function receiving call data and the event type.
+     * * @param callback Async function receiving call data and the event type.
      */
     registerHeadlessTask(
         callback: (data: CallData, eventType: CallEventType) => Promise<void>
@@ -57,7 +57,7 @@ export interface CallHandlerType {
     /**
      * Displays the full-screen Native Incoming Call UI.
      * Usually called inside registerHeadlessTask after validating the call.
-     * @param uuid The unique call ID.
+     * * @param uuid The unique call ID.
      * @param name Name to display on the call screen.
      * @param callType Defaults to 'audio'.
      * @returns Promise resolving to true if the UI was successfully launched.
@@ -65,7 +65,7 @@ export interface CallHandlerType {
     displayCall(
         uuid: string,
         name: string,
-        callType?: 'audio' | 'video',
+        callType: 'audio' | 'video',
     ): Promise<boolean>;
 
     /** * Checks if a call is still valid and has not been canceled.
@@ -78,36 +78,12 @@ export interface CallHandlerType {
      */
     checkCallStatus(uuid: string): Promise<CallStatus>;
 
-    /**
-     * [Android 14+] Checks if the user has granted the special "Full Screen Intent" permission.
-     * This is required for the call to show over the lockscreen.
-     */
-    checkFullScreenPermission(): Promise<boolean>;
+    requestOverlayPermission(): Promise<boolean>;
 
-    /**
-     * [Android 14+] Opens the specific system settings page for the user to 
-     * manually enable "Full Screen Intent" if it was revoked.
-     */
-    openFullScreenSettings(): void;
+    reportRemoteEnded(uuid: string, reason: number): void;
 
-    /**
-     * Checks if the app has permission to draw over other apps (Overlay).
-     * Necessary for showing the "Pill" or answer buttons while the phone is unlocked.
-     */
     checkOverlayPermission(): Promise<boolean>;
 
-    /**
-     * Opens system settings to request the "Draw over other apps" (Overlay) permission.
-     */
-    requestOverlayPermission(): void;
-
-    /**
-     * Reports to the native side that the remote party has terminated the call.
-     * @param uuid The unique call ID.
-     * @param reason Custom string reason (e.g., "RemoteEnded", "TimedOut").
-     */
-    reportRemoteEnded(uuid: string, reason?: string): Promise<void>;
-
     /**
      * Forcefully dismisses the native call UI, stops the ringtone, and clears state.
      * Use this when the call is hung up or timed out.
@@ -129,7 +105,7 @@ export interface CallHandlerType {
 
     /**
      * Subscribes to user interactions on the Native Call UI.
-     * @param onAccept Callback when user presses the Answer button.
+     * * @param onAccept Callback when user presses the Answer button.
      * @param onReject Callback when user presses the Decline button.
      * @param onFailed Callback for system errors (optional).
      * @returns A cleanup function to unsubscribe.

package/index.js

@@ -2,18 +2,12 @@ import {
     NativeModules,
     NativeEventEmitter,
     AppRegistry,
-    Platform,
 } from 'react-native';
 
 const { CallModule } = NativeModules;
 const callEventEmitter = CallModule ? new NativeEventEmitter(CallModule) : null;
 
 export const CallHandler = {
-    /**
-     * REGISTER HEADLESS TASK
-     * This is the "Engine" that listens for incoming push notifications 
-     * while the app is killed or in the background.
-     */
     registerHeadlessTask: (onAction) => {
         AppRegistry.registerHeadlessTask('ColdStartCallTask', () => async (data) => {
             const { callUuid, isBusySignal } = data;
@@ -25,81 +19,64 @@ export const CallHandler = {
                     return;
                 }
 
-                // Check if the call is still valid before showing UI
+                // CallModule.checkCallValidity is now accessible via the native bridge
                 const status = await CallModule.checkCallValidity(uuid);
                 if (!status.isValid) {
                     if (onAction) await onAction(data, 'ABORTED_CALL');
                     return;
                 }
 
-                if (onAction) await onAction(data, 'INCOMING_CALL');
+                if (onAction) {
+                    await onAction(data, 'INCOMING_CALL');
+                }
             } catch (error) {
                 console.error('[RNSNativeCall] Headless Task Error:', error);
             }
         });
     },
 
-    // --- PERMISSION HEALTH CHECKS ---
-
-    checkFullScreenPermission: async () => {
-        if (Platform.OS !== 'android' || !CallModule?.checkFullScreenIntentPermission) return true;
-        return await CallModule.checkFullScreenIntentPermission();
+    // --- Added missing bridge methods ---
+    checkCallValidity: async (uuid) => {
+        if (!CallModule?.checkCallValidity) return { isValid: false, isCanceled: true };
+        return await CallModule.checkCallValidity(uuid.toLowerCase().trim());
     },
 
-    openFullScreenSettings: () => {
-        if (Platform.OS === 'android' && CallModule?.openFullScreenIntentSettings) {
-            CallModule.openFullScreenIntentSettings();
-        }
+    checkCallStatus: async (uuid) => {
+        if (!CallModule?.checkCallStatus) return { isCanceled: true, isActive: false, shouldDisplay: false };
+        return await CallModule.checkCallStatus(uuid.toLowerCase().trim());
     },
+    // ------------------------------------
 
-    checkOverlayPermission: async () => {
-        if (Platform.OS !== 'android' || !CallModule?.checkOverlayPermission) return true;
-        return await CallModule.checkOverlayPermission();
+    reportRemoteEnded: async (uuid, endReason) => {
+        if (!CallModule?.reportRemoteEnded) return;
+        await CallModule.reportRemoteEnded(uuid.toLowerCase().trim(), endReason);
     },
 
-    requestOverlayPermission: () => {
-        if (Platform.OS === 'android' && CallModule?.requestOverlayPermission) {
-            CallModule.requestOverlayPermission();
-        }
+    requestOverlayPermission: async () => {
+        if (!CallModule?.requestOverlayPermission) return false;
+        return await CallModule.requestOverlayPermission();
     },
 
-    // --- CALL LIFECYCLE ACTIONS ---
+    checkOverlayPermission: async () => {
+        if (!CallModule?.checkOverlayPermission) return false;
+        return await CallModule.checkOverlayPermission();
+    },
 
     displayCall: async (uuid, name, callType = "audio") => {
         if (!CallModule) return false;
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
     },
 
-    /** Stops the UI and the Foreground Service */
-    destroyNativeCallUI: (uuid) => {
-        if (CallModule?.endNativeCall) {
-            CallModule.endNativeCall(uuid.toLowerCase().trim());
-        }
-    },
-
-    /** Reports to the native side that the other person hung up */
-    reportRemoteEnded: async (uuid, endReason = "RemoteEnded") => {
-        if (CallModule?.reportRemoteEnded) {
-            await CallModule.reportRemoteEnded(uuid.toLowerCase().trim(), endReason);
-        }
-    },
-
     stopForegroundService: async () => {
         if (CallModule?.stopForegroundService) {
             await CallModule.stopForegroundService();
         }
     },
 
-    // --- STATE VERIFICATION ---
-
-    checkCallValidity: async (uuid) => {
-        if (!CallModule?.checkCallValidity) return { isValid: false, isCanceled: true };
-        return await CallModule.checkCallValidity(uuid.toLowerCase().trim());
-    },
-
-    checkCallStatus: async (uuid) => {
-        if (!CallModule?.checkCallStatus) return { isCanceled: true, isActive: false, shouldDisplay: false };
-        return await CallModule.checkCallStatus(uuid.toLowerCase().trim());
+    destroyNativeCallUI: (uuid) => {
+        if (CallModule?.endNativeCall) {
+            CallModule.endNativeCall(uuid.toLowerCase().trim());
+        }
     },
 
     getInitialCallData: async () => {
@@ -107,8 +84,6 @@ export const CallHandler = {
         return await CallModule.getInitialCallData();
     },
 
-    // --- EVENT SUBSCRIPTION ---
-
     subscribe: (onAccept, onReject, onFailed) => {
         if (!callEventEmitter) return () => { };
         const subs = [

package/package.json

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

@@ -1,6 +1,5 @@
 const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity, withAppDelegate } = require('@expo/config-plugins');
 
-/** 1. MAIN ACTIVITY MOD **/
 function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
@@ -14,61 +13,62 @@ function withMainActivityDataFix(config) {
             'import android.Manifest'
         ];
 
-        // 1. Add missing imports
+        // Add imports if they don't exist
         imports.forEach(imp => {
             if (!contents.includes(imp)) {
                 contents = contents.replace(/package .*/, (match) => `${match}\n${imp}`);
             }
         });
 
-        // 2. Inject VoIP logic into EXISTING onCreate
-        const voipOnCreateLogic = `
+        const onCreateCode = `
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    
+    // Request Notification Permissions for Android 13+ (Required for Pill UI)
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-        ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.POST_NOTIFICATIONS), 101)
+        ActivityCompat.requestPermissions(
+            this,
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            101
+        )
     }
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
         setShowWhenLocked(true)
         setTurnScreenOn(true)
     } else {
-        window.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        window.addFlags(
+            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+        )
     }
 
     if (intent.getBooleanExtra("background_wake", false)) {
         moveTaskToBack(true)
     }
-  `;
-
-        if (contents.includes('override fun onCreate')) {
-            if (!contents.includes('setShowWhenLocked(true)')) {
-                contents = contents.replace(
-                    /super\.onCreate\(.*\)/,
-                    (match) => `${match}\n${voipOnCreateLogic}`
-                );
-            }
-        }
+  }`;
 
-        // 3. Handle onNewIntent (Inject method if missing, or fix if exists)
-        if (!contents.includes('override fun onNewIntent')) {
-            const onNewIntentCode = `
+        const onNewIntentCode = `
   override fun onNewIntent(intent: Intent) {
     super.onNewIntent(intent)
     setIntent(intent)
-  }
-`;
-            contents = contents.replace(/class MainActivity\s*:\s*ReactActivity\(\)\s*\{/, (match) => `${match}${onNewIntentCode}`);
-        } else if (!contents.includes('setIntent(intent)')) {
-            contents = contents.replace(
-                /super\.onNewIntent\(intent\)/,
-                (match) => `super.onNewIntent(intent)\n    setIntent(intent)`
-            );
+  }`;
+
+        const classRegex = /class MainActivity\s*:\s*ReactActivity\(\)\s*\{/;
+
+        if (!contents.includes('override fun onCreate')) {
+            contents = contents.replace(classRegex, (match) => `${match}${onCreateCode}`);
+        }
+
+        if (!contents.includes('override fun onNewIntent')) {
+            contents = contents.replace(classRegex, (match) => `${match}${onNewIntentCode}`);
         }
 
         config.modResults.contents = contents;
         return config;
     });
 }
-
 /** 2. ANDROID MANIFEST CONFIG **/
 function withAndroidConfig(config) {
     return withAndroidManifest(config, (config) => {
@@ -149,37 +149,22 @@ function withAndroidConfig(config) {
             application.receiver.push({ $: { 'android:name': 'com.rnsnativecall.CallActionReceiver', 'android:exported': 'false' } });
         }
 
-        // 2. ADDED UnlockReceiver with intent-filter
-        if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.UnlockReceiver')) {
-            application.receiver.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.UnlockReceiver',
-                    'android:exported': 'false'
-                },
-                'intent-filter': [
-                    {
-                        action: [
-                            { $: { 'android:name': 'android.intent.action.USER_PRESENT' } }
-                        ]
-                    }
-                ]
-            });
-        }
-
         return config;
     });
 }
-
-/** 2. IOS APP DELEGATE MOD **/
+/** 2. IOS APP DELEGATE MOD (The fix for Lock Screen Answer) **/
 function withIosAppDelegateMod(config) {
     return withAppDelegate(config, (config) => {
         let contents = config.modResults.contents;
 
+        // 1. Surgical Import: Add 'import React' at the very top if missing
         if (!contents.includes('import React')) {
             contents = 'import React\n' + contents;
         }
 
+        // 2. Check for the continue userActivity method
         if (!contents.includes('continue userActivity')) {
+            // Method is missing, inject it before the final closing brace of the class
             const swiftLinkingCode = `
   // Universal Links
   public override func application(
@@ -191,8 +176,10 @@ function withIosAppDelegateMod(config) {
     return super.application(application, continue: userActivity, restorationHandler: restorationHandler) || result
   }
 `;
+            // This regex finds the last '}' in the file (closing the AppDelegate class)
             contents = contents.replace(/\n}\s*$/, `\n${swiftLinkingCode}\n}`);
         } else if (!contents.includes('RCTLinkingManager.application')) {
+            // Method exists but is missing our logic, inject it inside
             contents = contents.replace(
                 /continue userActivity: NSUserActivity,[\s\S]*?\) -> Bool \{/,
                 `continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {\n    let result = RCTLinkingManager.application(application, continue: userActivity, restorationHandler: restorationHandler)`
@@ -203,8 +190,7 @@ function withIosAppDelegateMod(config) {
         return config;
     });
 }
-
-/** 3. IOS INFO.PLIST CONFIG **/
+/** 3. IOS INFO.PLIST CONFIG (Existing) **/
 function withIosConfig(config, props = {}) {
     return withInfoPlist(config, (config) => {
         const infoPlist = config.modResults;
@@ -219,13 +205,12 @@ function withIosConfig(config, props = {}) {
         return config;
     });
 }
-
 // Main Plugin Entry
 module.exports = (config, props) => {
     return withPlugins(config, [
         withAndroidConfig,
         withMainActivityDataFix,
-        withIosAppDelegateMod,
+        withIosAppDelegateMod, // <--- ADDED THIS HERE
         [withIosConfig, props]
     ]);
 };