rns-nativecall 1.1.9 → 1.2.0

package/README.md

@@ -132,16 +132,18 @@ export default function App() {
 
 | 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). |
+| **registerHeadlessTask(callback)** | Android | Registers background logic. `eventType` is `INCOMING_CALL`, `BUSY`, or `ABORTED_CALL`. |
+| **checkOverlayPermission()** | Android | Returns true if the app can draw over other apps (Required for overlay UI). |
 | **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). |
-
+| **checkFullScreenPermission()** | Android | [Android 14+] Checks if the app is allowed to show full-screen intents on the lockscreen. |
+| **requestFullScreenSettings()** | Android | [Android 14+] Opens System Settings to enable the Full Screen Intent permission. |
+| **displayCall(uuid, name, type)** | Android | Shows the native full-screen call UI and starts the ringtone. |
+| **checkCallValidity(uuid)** | Android | Returns `{isValid, isCanceled}` based on persistent state and CANCEL signals. |
+| **checkCallStatus(uuid)** | Android | Returns `{isCanceled, isActive, shouldDisplay}` for UI synchronization. |
+| **reportRemoteEnded(uuid, reason)** | Android | Tells the native side the caller hung up so the UI can dismiss automatically. |
+| **destroyNativeCallUI(uuid)** | Android | Forcefully dismisses the native interface, stops audio, and clears the current call state. |
+| **getInitialCallData()** | Android | Returns the call payload if the app was cold-started by a notification interaction. |
+| **subscribe(onAccept, onReject, onFailed)** | Android | Listens for native Answer/Decline button presses and system errors. |
 ---
 
 # Implementation Notes

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

@@ -107,7 +107,7 @@ class CallModule(
     }
 
     @ReactMethod
-    fun openFullScreenIntentSettings() {
+    fun requestFullScreenSettings() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
             try {
                 val intent =

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

@@ -1,4 +1,3 @@
-/////Users/bush/Desktop/Apps/Raiidr/package/android/src/main/java/com/rnsnativecall/CallPackage.kt
 package com.rnsnativecall
 
 import com.facebook.react.ReactPackage
@@ -7,11 +6,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 class CallPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(CallModule(reactContext))
-    }
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = listOf(CallModule(reactContext))
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/index.d.ts

@@ -48,7 +48,6 @@ 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.
      */
     registerHeadlessTask(
         callback: (data: CallData, eventType: CallEventType) => Promise<void>
@@ -56,11 +55,6 @@ 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 name Name to display on the call screen.
-     * @param callType Defaults to 'audio'.
-     * @returns Promise resolving to true if the UI was successfully launched.
      */
     displayCall(
         uuid: string,
@@ -69,69 +63,47 @@ export interface CallHandlerType {
     ): Promise<boolean>;
 
     /** * Checks if a call is still valid and has not been canceled.
-     * Useful for Splash screen "Interceptors" to prevent ghost calls.
      */
     checkCallValidity(uuid: string): Promise<ValidityStatus>;
 
     /** * Detailed check of a call's status. 
-     * Useful for determining if the UI should remain visible.
      */
     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>;
-
-    /**
-     * [Android 14+] Opens the specific system settings page for the user to 
-     * manually enable "Full Screen Intent" if it was revoked.
-     */
-    requestFullScreenSettings(): 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.
+     * Note: Returns a promise that resolves to false if module is missing.
      */
-    requestOverlayPermission(): void;
+    requestOverlayPermission(): Promise<boolean | void>;
+
+    /**
+     * [Android 14+] Opens the specific system settings page for Full Screen Intent.
+     */
+    requestFullScreenSettings(): Promise<boolean | 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.
      */
     destroyNativeCallUI(uuid: string): void;
 
     /**
-     * Stops the "Connecting..." Foreground Service.
-     * MUST be called after displayCall() or when a BUSY signal is handled to 
-     * remove the persistent system notification.
-     */
-    stopForegroundService(): Promise<void>;
-
-    /**
-     * Retrieves call data if the app was launched directly from an interaction
-     * with a notification while the app was in a "Killed" state.
+     * Retrieves call data if the app was launched directly from an interaction.
+     * Returns the 'default' payload or the raw data object.
      */
     getInitialCallData(): Promise<any | null>;
 
     /**
      * Subscribes to user interactions on the Native Call UI.
-     * @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.
      */
     subscribe(
@@ -144,5 +116,5 @@ export interface CallHandlerType {
 /**
  * Main handler for Native VoIP Call interactions.
  */
-declare const CallHandler: CallHandlerType;
+export const CallHandler: CallHandlerType;
 export default CallHandler;

package/index.js

@@ -2,18 +2,13 @@ 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,89 +20,73 @@ 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 ---
+    // --- Added missing bridge methods ---
+    checkCallValidity: async (uuid) => {
+        if (!CallModule?.checkCallValidity) return { isValid: false, isCanceled: true };
+        return await CallModule.checkCallValidity(uuid.toLowerCase().trim());
+    },
 
-    checkFullScreenPermission: async () => {
-        if (Platform.OS !== 'android' || !CallModule?.checkFullScreenIntentPermission) return true;
-        return await CallModule.checkFullScreenIntentPermission();
+    checkCallStatus: async (uuid) => {
+        if (!CallModule?.checkCallStatus) return { isCanceled: true, isActive: false, shouldDisplay: false };
+        return await CallModule.checkCallStatus(uuid.toLowerCase().trim());
     },
+    // ------------------------------------
 
-    openFullScreenSettings: () => {
-        if (Platform.OS === 'android' && CallModule?.openFullScreenIntentSettings) {
-            CallModule.openFullScreenIntentSettings();
-        }
+    reportRemoteEnded: async (uuid, endReason) => {
+        if (!CallModule?.reportRemoteEnded) return;
+        await CallModule.reportRemoteEnded(uuid.toLowerCase().trim(), endReason);
     },
 
-    checkOverlayPermission: async () => {
-        if (Platform.OS !== 'android' || !CallModule?.checkOverlayPermission) return true;
-        return await CallModule.checkOverlayPermission();
+    requestOverlayPermission: async () => {
+        if (!CallModule?.requestOverlayPermission) return false;
+        return await CallModule.requestOverlayPermission();
     },
 
-    requestFullScreenSettings: () => {
-        if (Platform.OS === 'android' && CallModule?.requestOverlayPermission) {
-            CallModule.requestOverlayPermission();
-        }
+    requestFullScreenSettings: async () => {
+        if (!CallModule?.requestFullScreenSettings) return false;
+        return await CallModule.requestFullScreenSettings();
     },
 
-    // --- 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());
-    },
 
     getInitialCallData: async () => {
         if (!CallModule?.getInitialCallData) return null;
-        return await CallModule.getInitialCallData();
-    },
+        const data = await CallModule.getInitialCallData();
 
-    // --- EVENT SUBSCRIPTION ---
+        // Return the 'default' call data if it exists, otherwise the whole object
+        return data?.default || data;
+    },
 
     subscribe: (onAccept, onReject, onFailed) => {
         if (!callEventEmitter) return () => { };

package/package.json

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