rns-nativecall 1.2.2 → 1.2.3

package/README.md

@@ -133,16 +133,17 @@ 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

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.2",
+    "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]
     ]);
 };