rns-nativecall 0.6.9 → 0.7.0

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

@@ -33,4 +33,5 @@ override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
         LinearCountingRetryPolicy(3, 1000)
     )
 }  
-}
+}
+

package/index.d.ts

@@ -1,34 +1,109 @@
+/**
+ * Represents the data payload for an incoming or active call.
+ */
 export interface CallData {
+    /** Unique identifier for the call (UUID) */
     callUuid: string;
+    /** Display name of the caller */
     name?: string;
+    /** Specify if the call is voice-only or video-enabled */
     callType?: 'audio' | 'video';
+    /** Internal flag: true if the system is currently processing another call */
     isBusySignal?: boolean;
+    /** Additional custom data passed from FCM/Push payload */
     [key: string]: any;
 }
 
-export type CallEventType = 'INCOMING_CALL' | 'BUSY';
+/**
+ * Types of events emitted to the Headless JS task.
+ */
+export type CallEventType =
+    | 'INCOMING_CALL'   // A new valid call needs to be displayed
+    | 'BUSY'            // System is busy, developer should notify caller via API
+    | 'ABORTED_CALL';   // Call was canceled or invalid before it could start
+
+/**
+ * Response object for basic call validation.
+ */
+export interface ValidityStatus {
+    /** True if the call exists and is eligible to be displayed */
+    isValid: boolean;
+    /** True if a CANCEL signal has already been received for this UUID */
+    isCanceled: boolean;
+}
+
+/**
+ * Detailed status of a specific call's lifecycle.
+ */
+export interface CallStatus {
+    /** True if the call has been terminated or canceled */
+    isCanceled: boolean;
+    /** True if this specific UUID is currently the "active" call tracked by Native */
+    isActive: boolean;
+    /** Logic helper: returns true if (isActive && !isCanceled) */
+    shouldDisplay: boolean;
+}
 
 export interface CallHandlerType {
     /**
-     * Registers the Headless JS task. 
-     * Handles Busy signals and Call Validity automatically.
+     * 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>
     ): void;
 
+    /**
+     * 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',
     ): 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>;
+
+    /**
+     * 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.
+     */
     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(
         onAccept: (data: CallData) => void,
         onReject: (data: CallData) => void,
@@ -36,5 +111,8 @@ export interface CallHandlerType {
     ): () => void;
 }
 
+/**
+ * Main handler for Native VoIP Call interactions.
+ */
 declare const CallHandler: CallHandlerType;
 export default CallHandler;

package/index.js

@@ -8,49 +8,54 @@ const { CallModule } = NativeModules;
 const callEventEmitter = CallModule ? new NativeEventEmitter(CallModule) : null;
 
 export const CallHandler = {
-    /**
-     * INTERNAL GATEKEEPER: Moves headless logic into the package.
-     * The dev just passes their "NativeCall" function.
-     */
     registerHeadlessTask: (onAction) => {
         AppRegistry.registerHeadlessTask('ColdStartCallTask', () => async (data) => {
             const { callUuid, isBusySignal } = data;
             const uuid = callUuid?.toLowerCase().trim();
 
             try {
-                // 1. Handle Busy Signal (Second Caller)
                 if (isBusySignal) {
-                    console.log(`[RNSNativeCall] System busy. Informing app to send busy signal for: ${uuid}`);
                     if (onAction) await onAction(data, 'BUSY');
                     return;
                 }
 
-                // 2. Gatekeeping: Check Validity with Native logic
+                // CallModule.checkCallValidity is now accessible via the native bridge
                 const status = await CallModule.checkCallValidity(uuid);
                 if (!status.isValid) {
-                    console.log(`[RNSNativeCall] Aborting task: ${uuid} no longer valid or canceled.`);
                     if (onAction) await onAction(data, 'ABORTED_CALL');
                     return;
                 }
 
-                // 3. Valid Incoming Call: Pass to Developer's UI logic
                 if (onAction) {
                     await onAction(data, 'INCOMING_CALL');
                 }
-
             } catch (error) {
                 console.error('[RNSNativeCall] Headless Task Error:', error);
             }
         });
     },
 
+    // --- 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());
+    },
+    // ------------------------------------
+
     displayCall: async (uuid, name, callType = "audio") => {
         if (!CallModule) return false;
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
     },
 
     stopForegroundService: async () => {
-        await CallModule.stopForegroundService()
+        if (CallModule?.stopForegroundService) {
+            await CallModule.stopForegroundService();
+        }
     },
 
     destroyNativeCallUI: (uuid) => {
@@ -66,16 +71,13 @@ export const CallHandler = {
 
     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());
     }
 };

package/package.json

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