rns-nativecall 1.1.8 → 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

@@ -61,7 +61,6 @@ class CallModule(
         }
     }
 
-    // Inside your CallModule class
     @ReactMethod
     fun checkOverlayPermission(promise: Promise) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -71,6 +70,16 @@ 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) {
@@ -86,10 +95,39 @@ class CallModule(
         }
     }
 
-    /**
-     * Combined Validity Check:
-     * Used by Headless Task to see if it should proceed with the UI.
-     */
+    @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 requestFullScreenSettings() {
+        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)
+            }
+        }
+    }
+
     @ReactMethod
     fun checkCallValidity(
         uuid: String,
@@ -107,22 +145,6 @@ 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/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,58 +55,55 @@ 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,
         name: string,
-        callType: 'audio' | 'video',
+        callType?: 'audio' | 'video',
     ): 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>;
 
-    requestOverlayPermission(): Promise<boolean>;
+    /**
+     * Checks if the app has permission to draw over other apps (Overlay).
+     */
+    checkOverlayPermission(): Promise<boolean>;
 
-    reportRemoteEnded(uuid: string, reason: number): void;
+    /**
+     * 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(): Promise<boolean | void>;
 
-    checkOverlayPermission(): Promise<boolean>;
+    /**
+     * [Android 14+] Opens the specific system settings page for Full Screen Intent.
+     */
+    requestFullScreenSettings(): Promise<boolean | void>;
 
     /**
-     * Forcefully dismisses the native call UI, stops the ringtone, and clears state.
-     * Use this when the call is hung up or timed out.
+     * Reports to the native side that the remote party has terminated the call.
      */
-    destroyNativeCallUI(uuid: string): void;
+    reportRemoteEnded(uuid: string, reason?: string): Promise<void>;
 
     /**
-     * Stops the "Connecting..." Foreground Service.
-     * MUST be called after displayCall() or when a BUSY signal is handled to 
-     * remove the persistent system notification.
+     * Forcefully dismisses the native call UI, stops the ringtone, and clears state.
      */
-    stopForegroundService(): Promise<void>;
+    destroyNativeCallUI(uuid: string): 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(
@@ -120,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

@@ -7,6 +7,7 @@ import {
 const { CallModule } = NativeModules;
 const callEventEmitter = CallModule ? new NativeEventEmitter(CallModule) : null;
 
+
 export const CallHandler = {
     registerHeadlessTask: (onAction) => {
         AppRegistry.registerHeadlessTask('ColdStartCallTask', () => async (data) => {
@@ -57,6 +58,11 @@ export const CallHandler = {
         return await CallModule.requestOverlayPermission();
     },
 
+    requestFullScreenSettings: async () => {
+        if (!CallModule?.requestFullScreenSettings) return false;
+        return await CallModule.requestFullScreenSettings();
+    },
+
     checkOverlayPermission: async () => {
         if (!CallModule?.checkOverlayPermission) return false;
         return await CallModule.checkOverlayPermission();
@@ -67,21 +73,19 @@ export const CallHandler = {
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
     },
 
-    stopForegroundService: async () => {
-        if (CallModule?.stopForegroundService) {
-            await CallModule.stopForegroundService();
-        }
-    },
-
     destroyNativeCallUI: (uuid) => {
         if (CallModule?.endNativeCall) {
             CallModule.endNativeCall(uuid.toLowerCase().trim());
         }
     },
 
+
     getInitialCallData: async () => {
         if (!CallModule?.getInitialCallData) return null;
-        return await CallModule.getInitialCallData();
+        const data = await CallModule.getInitialCallData();
+
+        // Return the 'default' call data if it exists, otherwise the whole object
+        return data?.default || data;
     },
 
     subscribe: (onAccept, onReject, onFailed) => {

package/package.json

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