rns-nativecall 1.2.0 → 1.2.1

package/README.md

@@ -132,18 +132,17 @@ 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

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.1",
     "description": "High-performance React Native module for handling native VoIP call UI on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",