rns-nativecall 1.2.1 → 1.2.3

package/README.md

@@ -133,30 +133,28 @@ export default function App() {
 | Method | Platform | Description |
 | :--- | :--- | :--- |
 | **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. |
+| **displayCall(uuid, name, type)** | All |  Launches full-screen Activity. iOS: Reports incoming call to CallKit. |
+| **checkCallValidity(uuid)** | All | Returns {isValid, isCanceled} to prevent ghost/canceled calls. |
+| **checkCallStatus(uuid)** | All |  Returns {isCanceled, isActive, shouldDisplay} for UI syncing. |
+| **showMissedCall(uuid, name, type)** | All | Shows miss call on the deivce notification tray|
+| **destroyNativeCallUI(uuid)** | All |  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. |
 | **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

@@ -162,6 +162,27 @@ class CallModule(
         promise.resolve(map)
     }
 
+    @ReactMethod
+    fun showMissedCall(
+        uuid: String,
+        name: String,
+        callType: String,
+        promise: Promise,
+    ) {
+        try {
+            val data =
+                mapOf(
+                    "callUuid" to uuid,
+                    "name" to name,
+                    "callType" to callType,
+                )
+            NativeCallManager.showMissedCallNotification(reactApplicationContext, data)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("MISSED_CALL_ERROR", e.message)
+        }
+    }
+
     @ReactMethod
     fun endNativeCall(uuid: String) {
         NativeCallManager.dismissIncomingCall(reactApplicationContext, uuid)

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

@@ -14,7 +14,7 @@ import androidx.core.app.Person
 import androidx.core.content.ContextCompat
 
 object NativeCallManager {
-    const val channelId = "CALL_CHANNEL_V15_URGENT"
+    const val channelId = "CALL_CHANNEL_V0_URGENT"
     private var currentCallData: Map<String, String>? = null
 
     @JvmStatic internal var pendingCallNotification: Notification? = null
@@ -28,10 +28,13 @@ object NativeCallManager {
         data: Map<String, String>,
     ) {
         Handler(Looper.getMainLooper()).post {
-            val uuid = data["callUuid"] ?: return@post
             this.currentCallData = data
-            val name = data["name"] ?: "Incoming Call"
+            val uuid = data["callUuid"] ?: return@post
+            val name = data["name"] ?: "Someone"
+            val callType = data["callType"] ?: "audio"
+            val isVideo = callType.equals("video", ignoreCase = true)
             val notificationId = uuid.hashCode()
+
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
 
             val pendingFlags =
@@ -86,6 +89,29 @@ object NativeCallManager {
                 notificationManager.createNotificationChannel(channel)
             }
 
+            val iconId =
+                context.resources
+                    .getIdentifier("notification_icon", "drawable", context.packageName)
+                    .let { id ->
+                        if (id != 0) {
+                            id // Found the one you saw in the folder!
+                        } else {
+                            // Fallback chain if notification_icon is missing
+                            val shellId = context.resources.getIdentifier("shell_notification_icon", "drawable", context.packageName)
+                            if (shellId != 0) shellId else context.applicationInfo.icon
+                        }
+                    }
+
+            val colorId = context.resources.getIdentifier("notification_icon_color", "color", context.packageName)
+
+            val iconColor =
+                if (colorId != 0) {
+                    ContextCompat.getColor(context, colorId)
+                } else {
+                    // Fallback to a default blue or grey if they didn't provide a color
+                    Color.parseColor("#ffffff")
+                }
+
             val caller =
                 Person
                     .Builder()
@@ -93,15 +119,38 @@ object NativeCallManager {
                     .setImportant(true)
                     .build()
 
+            val incomingCallTemplate =
+                NotificationCompat.CallStyle.forIncomingCall(
+                    caller,
+                    rejectPendingIntent,
+                    answerPendingIntent,
+                )
+
+            if (isVideo) {
+                try {
+                    incomingCallTemplate.setIsVideo(true)
+                } catch (e: Exception) {
+                    // Some versions of Android may throw here; ignore
+                }
+            }
+
             val builder =
                 NotificationCompat
                     .Builder(context, channelId)
-                    .setSmallIcon(context.applicationInfo.icon)
+                    .setSmallIcon(iconId)
+                    // 1. FOR ANDROID 8/9: They prioritize ContentTitle over the Style's internal logic.
+                    // We include the name here so it's impossible to miss.
+                    .setContentTitle("Incoming $callType Call from $name")
+                    // 2. FOR ALL VERSIONS: This helps fill the "Status" line below the name.
+                    .setContentText("Incoming $callType Call")
+                    // 3. FOR ANDROID 12+: This places the text in the header next to the App Name.
+                    .setSubText("Incoming $callType Call")
+                    .setColor(iconColor)
                     .setPriority(NotificationCompat.PRIORITY_MAX)
                     .setCategory(NotificationCompat.CATEGORY_CALL)
                     .setOngoing(true)
                     .setFullScreenIntent(fullScreenPendingIntent, true)
-                    .setStyle(NotificationCompat.CallStyle.forIncomingCall(caller, rejectPendingIntent, answerPendingIntent))
+                    .setStyle(incomingCallTemplate)
                     .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
 
             val notification = builder.build()
@@ -125,6 +174,66 @@ object NativeCallManager {
         manager.cancel(uuid.hashCode())
     }
 
+    fun showMissedCallNotification(
+        context: Context,
+        data: Map<String, String>,
+    ) {
+        val uuid = data["callUuid"] ?: return
+        val name = data["name"] ?: "Unknown"
+        val callType = data["callType"] ?: "video"
+        val channelId = "missed_calls"
+
+        val notificationManager =
+            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel =
+                NotificationChannel(
+                    channelId,
+                    "Missed Calls",
+                    NotificationManager.IMPORTANCE_DEFAULT,
+                ).apply { description = "Missed call notifications" }
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        // Use your custom notification icon if available, fallback to system missed call icon
+        val iconResId =
+            context.resources
+                .getIdentifier("notification_icon", "drawable", context.packageName)
+                .takeIf { it != 0 } ?: android.R.drawable.sym_call_missed
+
+        val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
+
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+        val pendingIntent =
+            PendingIntent.getActivity(
+                context,
+                uuid.hashCode(),
+                launchIntent,
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                } else {
+                    PendingIntent.FLAG_UPDATE_CURRENT
+                },
+            )
+
+        val builder =
+            NotificationCompat
+                .Builder(context, channelId)
+                .setSmallIcon(iconResId)
+                .setContentTitle("Missed $callType call")
+                .setContentText("You missed a call from $name")
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setAutoCancel(true)
+                .setCategory(NotificationCompat.CATEGORY_MISSED_CALL)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setContentIntent(pendingIntent)
+
+        notificationManager.notify(uuid.hashCode(), builder.build())
+    }
+
     fun dismissIncomingCall(
         context: Context,
         uuid: String?,

package/index.d.ts

@@ -62,6 +62,15 @@ export interface CallHandlerType {
         callType?: 'audio' | 'video',
     ): Promise<boolean>;
 
+    /**
+     * Displays the full-screen Native Incoming Call UI.
+     */
+    showMissedCall(
+        uuid: string,
+        name: string,
+        callType?: 'audio' | 'video',
+    ): Promise<boolean>;
+
     /** * Checks if a call is still valid and has not been canceled.
      */
     checkCallValidity(uuid: string): Promise<ValidityStatus>;

package/index.js

@@ -78,6 +78,11 @@ export const CallHandler = {
         return await CallModule.checkCallStatus(uuid.toLowerCase().trim());
     },
 
+    showMissedCall: async (uuid, name, callType) => {
+        if (!CallModule?.showMissedCall) return false;
+        return await CallModule.showMissedCall(uuid.toLowerCase().trim(), name, callType);
+    },
+
     //--------------------------------------------------------------------------------------
 
     requestOverlayPermission: async () => {

package/ios/CallModule.m

@@ -4,7 +4,8 @@
 @interface CallModule ()
 @property (nonatomic, strong) NSString *pendingCallUuid;
 @property (nonatomic, strong) NSMutableDictionary *pendingEvents;
-@property (nonatomic, assign) BOOL isCallActive; // Track state for handoff vs hangup
+@property (nonatomic, assign) BOOL isCallActive;
+@property (nonatomic, strong) CXCallObserver *callObserver;
 @end
 
 @implementation CallModule
@@ -21,9 +22,10 @@ RCT_EXPORT_MODULE();
     self = [super init];
     if (self) {
         self.pendingEvents = [NSMutableDictionary new];
+        self.callObserver = [[CXCallObserver alloc] init];
+        
         NSString *appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleDisplayName"] ?: [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleName"];
 
-        // Corrected initialization for modern iOS
         CXProviderConfiguration *config = [[CXProviderConfiguration alloc] initWithLocalizedName:appName];
         config.supportsVideo = YES;
         config.maximumCallGroups = 1;
@@ -38,65 +40,47 @@ RCT_EXPORT_MODULE();
     return self;
 }
 
-/**
- * Modern helper to find the active UIWindow without using deprecated .keyWindow or .windows
- */
 - (UIWindow *)getActiveWindow {
     if (@available(iOS 13.0, *)) {
         NSSet<UIScene *> *scenes = [[UIApplication sharedApplication] connectedScenes];
         for (UIScene *scene in scenes) {
-            // We look for a foreground active window scene
             if (scene.activationState == UISceneActivationStateForegroundActive &&
                 [scene isKindOfClass:[UIWindowScene class]]) {
                 UIWindowScene *windowScene = (UIWindowScene *)scene;
-                
-                // On iOS 15+, we use windowScene.keyWindow if available,
-                // otherwise iterate the windows array of that scene
                 if (@available(iOS 15.0, *)) {
                     if (windowScene.keyWindow) return windowScene.keyWindow;
                 }
-                
                 for (UIWindow *window in windowScene.windows) {
                     if (window.isKeyWindow) return window;
                 }
             }
         }
     }
-    
-    // Fallback for older devices or edge cases where scene is not yet active
     #pragma clang diagnostic push
     #pragma clang diagnostic ignored "-Wdeprecated-declarations"
     return [UIApplication sharedApplication].keyWindow;
     #pragma clang diagnostic pop
 }
 
-// MARK: - Unified Export Method
+// MARK: - Exported Methods
 
 RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString) {
     NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
     if (!uuid) return;
-
+    
     dispatch_async(dispatch_get_main_queue(), ^{
         if (self.isCallActive) {
-            // REAL HANG UP
-            [self.provider reportCallWithUUID:uuid
-                                  endedAtDate:[NSDate date]
-                                       reason:CXCallEndedReasonRemoteEnded];
+            [self.provider reportCallWithUUID:uuid endedAtDate:[NSDate date] reason:CXCallEndedReasonRemoteEnded];
             self.isCallActive = NO;
         } else {
-            // HANDOFF (Hide the CallKit banner/UI)
-            [self.provider reportCallWithUUID:uuid
-                                  endedAtDate:[NSDate date]
-                                       reason:CXCallEndedReasonAnsweredElsewhere];
+            [self.provider reportCallWithUUID:uuid endedAtDate:[NSDate date] reason:CXCallEndedReasonAnsweredElsewhere];
             self.isCallActive = YES;
         }
         self.currentCallUUID = nil;
         self.pendingCallUuid = nil;
-    });
+    }); // <--- FIXED: Added the missing ');' here
 }
 
-// MARK: - Core Logic
-
 RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
                   name:(NSString *)name
                   callType:(NSString *)callType
@@ -128,15 +112,6 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
     }];
 }
 
-RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    NSMutableDictionary *result = [NSMutableDictionary new];
-    if (self.pendingCallUuid) {
-        result[@"default"] = @{@"callUuid": self.pendingCallUuid};
-        self.pendingCallUuid = nil;
-    }
-    resolve(result.count > 0 ? result : [NSNull null]);
-}
-
 RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
@@ -147,12 +122,9 @@ RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString
         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]) {
+    for (CXCall *call in self.callObserver.calls) {
+        if ([call.UUID.UUIDString.lowercaseString isEqualToString:uuidString.lowercaseString]) {
             if (!call.hasEnded) {
                 found = YES;
                 break;
@@ -160,8 +132,6 @@ RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString
         }
     }
 
-    // isValid: True if CallKit is currently tracking this call
-    // isCanceled: False if the call is active and valid
     resolve(@{
         @"isValid": @(found),
         @"isCanceled": @(!found)
@@ -172,22 +142,11 @@ 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]) {
+    for (CXCall *call in self.callObserver.calls) {
+        if ([call.UUID.UUIDString.lowercaseString isEqualToString:uuidString.lowercaseString]) {
             if (!call.hasEnded) {
                 isActive = YES;
                 isCanceled = NO;
@@ -206,22 +165,13 @@ RCT_EXPORT_METHOD(checkCallStatus:(NSString *)uuidString
 // MARK: - CXProviderDelegate
 
 - (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {
-    AVAudioSession *session = [AVAudioSession sharedInstance];
-    [session setCategory:AVAudioSessionCategoryPlayAndRecord mode:AVAudioSessionModeVoiceChat options:AVAudioSessionCategoryOptionAllowBluetoothHFP | AVAudioSessionCategoryOptionDefaultToSpeaker error:nil];
-    [session setActive:YES error:nil];
-
     [action fulfill];
-
     NSString *uuidStr = [action.callUUID.UUIDString lowercaseString];
     self.pendingCallUuid = uuidStr;
 
     dispatch_async(dispatch_get_main_queue(), ^{
-        // Use our non-deprecated helper to bring app to front
         UIWindow *window = [self getActiveWindow];
-        if (window) {
-            [window makeKeyAndVisible];
-        }
-        
+        if (window) [window makeKeyAndVisible];
         [self sendEventWithName:@"onCallAccepted" body:@{@"callUuid": uuidStr}];
     });
 }

package/package.json

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

package/withNativeCallVoip.js

@@ -1,4 +1,4 @@
-const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity, withAppDelegate } = require('@expo/config-plugins');
+const { withAndroidStyles, AndroidConfig, withAndroidManifest, withInfoPlist, withPlugins, withMainActivity, withAppDelegate } = require('@expo/config-plugins');
 
 function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
@@ -69,6 +69,21 @@ function withMainActivityDataFix(config) {
         return config;
     });
 }
+function withNotificationColor(config) {
+    // 1. Find the color in app.json (fallback to #218aff)
+    const notificationPlugin = config.plugins?.find(p => Array.isArray(p) && p[0] === 'expo-notifications');
+    const iconColor = notificationPlugin?.[1]?.color || '#218aff';
+
+    return withAndroidStyles(config, (config) => {
+        config.modResults = AndroidConfig.Styles.assignStylesValue(config.modResults, {
+            name: 'notification_icon_color',
+            value: iconColor,
+            parent: 'AppTheme', // or your primary theme
+            type: 'color',
+        });
+        return config;
+    });
+}
 /** 2. ANDROID MANIFEST CONFIG **/
 function withAndroidConfig(config) {
     return withAndroidManifest(config, (config) => {
@@ -210,7 +225,8 @@ module.exports = (config, props) => {
     return withPlugins(config, [
         withAndroidConfig,
         withMainActivityDataFix,
-        withIosAppDelegateMod, // <--- ADDED THIS HERE
+        withNotificationColor,
+        withIosAppDelegateMod,
         [withIosConfig, props]
     ]);
 };