rns-nativecall 1.1.9 → 1.2.1

package/README.md

@@ -132,16 +132,17 @@ 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). |
-| **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). |
-
+| **registerHeadlessTask(callback)** | All | Registers the background task. `eventType` is 'INCOMING_CALL', 'BUSY', or 'ABORTED_CALL'. |
+| **displayCall(uuid, name, type)** | All | Android: Launches full-screen Activity. iOS: Reports incoming call to CallKit. |
+| **checkCallValidity(uuid)** | All | Android only: Returns {isValid, isCanceled} to prevent ghost/canceled calls. |
+| **checkCallStatus(uuid)** | All | Android only: Returns {isCanceled, isActive, shouldDisplay} for UI syncing. |
+| **checkOverlayPermission()** | Android | Android only: Returns true if app can draw over other apps while unlocked. |
+| **checkFullScreenPermission()** | Android | Android 14+: Checks if app can trigger full-screen intents on lockscreen. |
+| **requestOverlayPermission()** | Android | Android only: Navigates user to "Draw over other apps" system settings. |
+| **requestFullScreenSettings()** | Android | Android 14+: Navigates user to "Full Screen Intent" system settings. |
+| **destroyNativeCallUI(uuid)** | All | Android: Stops ringtone/Activity. iOS: Ends CallKit (Handoff vs Hangup logic). |
+| **getInitialCallData()** | All | Retrieves the call payload if the app was cold-started via a notification Answer. |
+| **subscribe(onAccept, onReject, onFailed)** | All | Listens for Answer/Decline button presses and system-level bridge errors. |
 ---
 
 # Implementation Notes

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

@@ -96,7 +96,7 @@ class CallModule(
     }
 
     @ReactMethod
-    fun checkFullScreenIntentPermission(promise: Promise) {
+    fun checkFullScreenPermission(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())
@@ -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.
+     * Checks if the app has permission to draw over other apps (Overlay).
      */
-    requestFullScreenSettings(): void;
+    checkOverlayPermission(): Promise<boolean>;
 
     /**
-     * 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.
+     * Checks if the app has permission to use full screen intent.
      */
-    checkOverlayPermission(): Promise<boolean>;
+    checkFullScreenPermission(): 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>;
 
     /**
-     * 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").
+     * [Android 14+] Opens the specific system settings page for Full Screen Intent.
      */
-    reportRemoteEnded(uuid: string, reason?: string): Promise<void>;
+    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.
      */
     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

@@ -8,12 +8,8 @@ import {
 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,73 +21,53 @@ 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();
-    },
-
-    openFullScreenSettings: () => {
-        if (Platform.OS === 'android' && CallModule?.openFullScreenIntentSettings) {
-            CallModule.openFullScreenIntentSettings();
-        }
-    },
-
-    checkOverlayPermission: async () => {
-        if (Platform.OS !== 'android' || !CallModule?.checkOverlayPermission) return true;
-        return await CallModule.checkOverlayPermission();
-    },
-
-    requestFullScreenSettings: () => {
-        if (Platform.OS === 'android' && CallModule?.requestOverlayPermission) {
-            CallModule.requestOverlayPermission();
-        }
-    },
-
-    // --- CALL LIFECYCLE ACTIONS ---
-
     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);
-        }
+    getInitialCallData: async () => {
+        if (!CallModule?.getInitialCallData) return null;
+        const data = await CallModule.getInitialCallData();
+
+        // Return the 'default' call data if it exists, otherwise the whole object
+        return data?.default || data;
     },
 
-    stopForegroundService: async () => {
-        if (CallModule?.stopForegroundService) {
-            await CallModule.stopForegroundService();
+    subscribe: (onAccept, onReject, onFailed) => {
+        if (!callEventEmitter) return () => { };
+        const subs = [
+            callEventEmitter.addListener('onCallAccepted', (data) => onAccept(data)),
+            callEventEmitter.addListener('onCallRejected', (data) => onReject(data)),
+        ];
+        if (onFailed) {
+            subs.push(callEventEmitter.addListener('onCallFailed', onFailed));
         }
+        return () => subs.forEach(s => s.remove());
     },
 
-    // --- STATE VERIFICATION ---
-
     checkCallValidity: async (uuid) => {
         if (!CallModule?.checkCallValidity) return { isValid: false, isCanceled: true };
         return await CallModule.checkCallValidity(uuid.toLowerCase().trim());
@@ -102,24 +78,33 @@ export const CallHandler = {
         return await CallModule.checkCallStatus(uuid.toLowerCase().trim());
     },
 
-    getInitialCallData: async () => {
-        if (!CallModule?.getInitialCallData) return null;
-        return await CallModule.getInitialCallData();
+    //--------------------------------------------------------------------------------------
+
+    requestOverlayPermission: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.requestOverlayPermission) return false;
+        return await CallModule.requestOverlayPermission();
     },
 
-    // --- EVENT SUBSCRIPTION ---
+    requestFullScreenSettings: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.requestFullScreenSettings) return false;
+        return await CallModule.requestFullScreenSettings();
+    },
 
-    subscribe: (onAccept, onReject, onFailed) => {
-        if (!callEventEmitter) return () => { };
-        const subs = [
-            callEventEmitter.addListener('onCallAccepted', (data) => onAccept(data)),
-            callEventEmitter.addListener('onCallRejected', (data) => onReject(data)),
-        ];
-        if (onFailed) {
-            subs.push(callEventEmitter.addListener('onCallFailed', onFailed));
-        }
-        return () => subs.forEach(s => s.remove());
-    }
+    checkOverlayPermission: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.checkOverlayPermission) return false;
+        return await CallModule.checkOverlayPermission();
+    },
+
+    checkFullScreenPermission: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.checkFullScreenPermission) return false;
+        return await CallModule.checkFullScreenPermission();
+    },
+
+    //--------------------------------------------------------------------------------------
 };
 
 export default CallHandler;

package/ios/CallModule.m

@@ -137,6 +137,72 @@ RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCT
     resolve(result.count > 0 ? result : [NSNull null]);
 }
 
+RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
+    if (!uuid) {
+        resolve(@{@"isValid": @NO, @"isCanceled": @YES});
+        return;
+    }
+
+    // On iOS, we check if the call is currently known to the system observer
+    CXCallObserver *callObserver = [[CXCallObserver alloc] init];
+    BOOL found = NO;
+    
+    for (CXCall *call in callObserver.calls) {
+        if ([call.uuid.UUIDString isEqualToString:uuid.UUIDString]) {
+            if (!call.hasEnded) {
+                found = YES;
+                break;
+            }
+        }
+    }
+
+    // isValid: True if CallKit is currently tracking this call
+    // isCanceled: False if the call is active and valid
+    resolve(@{
+        @"isValid": @(found),
+        @"isCanceled": @(!found)
+    });
+}
+
+RCT_EXPORT_METHOD(checkCallStatus:(NSString *)uuidString
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
+    if (!uuid) {
+        resolve(@{
+            @"isCanceled": @YES,
+            @"isActive": @NO,
+            @"shouldDisplay": @NO
+        });
+        return;
+    }
+
+    CXCallObserver *callObserver = [[CXCallObserver alloc] init];
+    BOOL isActive = NO;
+    BOOL isCanceled = YES;
+
+    for (CXCall *call in callObserver.calls) {
+        if ([call.uuid.UUIDString isEqualToString:uuid.UUIDString]) {
+            if (!call.hasEnded) {
+                isActive = YES;
+                isCanceled = NO;
+                break;
+            }
+        }
+    }
+
+    resolve(@{
+        @"isCanceled": @(isCanceled),
+        @"isActive": @(isActive),
+        @"shouldDisplay": @(isActive && !isCanceled)
+    });
+}
+
 // MARK: - CXProviderDelegate
 
 - (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {

package/package.json

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