rns-nativecall 1.2.0 → 1.2.2

package/README.md

@@ -132,32 +132,28 @@ export default function App() {
 
 | Method | Platform | Description |
 | :--- | :--- | :--- |
-| **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". |
-| **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. |
+| **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
 
-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:
+1. 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.
 
-3. iOS CallKit:
+2. 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.
 
-4. Single Call Gate:
+3. 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

@@ -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())

package/index.d.ts

@@ -75,6 +75,11 @@ export interface CallHandlerType {
      */
     checkOverlayPermission(): Promise<boolean>;
 
+    /**
+     * Checks if the app has permission to use full screen intent.
+     */
+    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.
@@ -86,11 +91,6 @@ export interface CallHandlerType {
      */
     requestFullScreenSettings(): Promise<boolean | void>;
 
-    /**
-     * Reports to the native side that the remote party has terminated the call.
-     */
-    reportRemoteEnded(uuid: string, reason?: string): Promise<void>;
-
     /**
      * Forcefully dismisses the native call UI, stops the ringtone, and clears state.
      */

package/index.js

@@ -2,6 +2,7 @@ import {
     NativeModules,
     NativeEventEmitter,
     AppRegistry,
+    Platform,
 } from 'react-native';
 
 const { CallModule } = NativeModules;
@@ -36,38 +37,6 @@ export const CallHandler = {
         });
     },
 
-    // --- Added missing bridge methods ---
-    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());
-    },
-    // ------------------------------------
-
-    reportRemoteEnded: async (uuid, endReason) => {
-        if (!CallModule?.reportRemoteEnded) return;
-        await CallModule.reportRemoteEnded(uuid.toLowerCase().trim(), endReason);
-    },
-
-    requestOverlayPermission: async () => {
-        if (!CallModule?.requestOverlayPermission) return false;
-        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();
-    },
-
     displayCall: async (uuid, name, callType = "audio") => {
         if (!CallModule) return false;
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
@@ -79,7 +48,6 @@ export const CallHandler = {
         }
     },
 
-
     getInitialCallData: async () => {
         if (!CallModule?.getInitialCallData) return null;
         const data = await CallModule.getInitialCallData();
@@ -98,7 +66,45 @@ export const CallHandler = {
             subs.push(callEventEmitter.addListener('onCallFailed', onFailed));
         }
         return () => subs.forEach(s => s.remove());
-    }
+    },
+
+    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());
+    },
+
+    //--------------------------------------------------------------------------------------
+
+    requestOverlayPermission: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.requestOverlayPermission) return false;
+        return await CallModule.requestOverlayPermission();
+    },
+
+    requestFullScreenSettings: async () => {
+        if (Platform.OS === 'ios') return true;
+        if (!CallModule?.requestFullScreenSettings) return false;
+        return await CallModule.requestFullScreenSettings();
+    },
+
+    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.2.0",
+    "version": "1.2.2",
     "description": "High-performance React Native module for handling native VoIP call UI on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",