rns-nativecall 0.8.7 → 0.8.9

package/ios/CallModule.m

@@ -4,15 +4,14 @@
 @interface CallModule ()
 @property (nonatomic, strong) NSString *pendingCallUuid;
 @property (nonatomic, strong) NSMutableDictionary *pendingEvents;
+@property (nonatomic, assign) BOOL isCallActive; // Track state for handoff vs hangup
 @end
 
 @implementation CallModule
 
 RCT_EXPORT_MODULE();
 
-+ (BOOL)requiresMainQueueSetup {
-    return YES;
-}
++ (BOOL)requiresMainQueueSetup { return YES; }
 
 - (NSArray<NSString *> *)supportedEvents {
     return @[ @"onCallAccepted", @"onCallRejected", @"onCallFailed" ];
@@ -24,6 +23,7 @@ RCT_EXPORT_MODULE();
         self.pendingEvents = [NSMutableDictionary new];
         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;
@@ -33,34 +33,66 @@ RCT_EXPORT_MODULE();
         
         self.provider = [[CXProvider alloc] initWithConfiguration:config];
         [self.provider setDelegate:self queue:nil];
+        self.isCallActive = NO;
     }
     return self;
 }
 
-// MARK: - New Parity Methods (Synced with Android)
-
-RCT_EXPORT_METHOD(checkCallValidity:(NSString *)uuidString resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    BOOL isCurrent = [uuidString isEqualToString:self.currentCallUUID.UUIDString];
-    resolve(@{
-        @"isValid": @(isCurrent),
-        @"isCanceled": @(!isCurrent)
-    });
+/**
+ * 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
 }
 
-RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    NSMutableDictionary *result = [NSMutableDictionary new];
-    
-    if (self.pendingCallUuid) {
-        result[@"default"] = @{@"callUuid": self.pendingCallUuid};
+// MARK: - Unified Export Method
+
+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.isCallActive = NO;
+        } else {
+            // HANDOFF (Hide the CallKit banner/UI)
+            [self.provider reportCallWithUUID:uuid
+                                  endedAtDate:[NSDate date]
+                                       reason:CXCallEndedReasonAnsweredElsewhere];
+            self.isCallActive = YES;
+        }
+        self.currentCallUUID = nil;
         self.pendingCallUuid = nil;
-    }
-    
-    if (self.pendingEvents.count > 0) {
-        [result addEntriesFromDictionary:self.pendingEvents];
-        [self.pendingEvents removeAllObjects];
-    }
-    
-    resolve(result.count > 0 ? result : [NSNull null]);
+    });
 }
 
 // MARK: - Core Logic
@@ -77,9 +109,9 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
         return;
     }
     
+    self.isCallActive = NO;
     self.currentCallUUID = uuid;
 
-    // Pre-configure audio session
     AVAudioSession *session = [AVAudioSession sharedInstance];
     [session setCategory:AVAudioSessionCategoryPlayAndRecord
                     mode:AVAudioSessionModeVoiceChat
@@ -91,82 +123,51 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
     update.hasVideo = [callType isEqualToString:@"video"];
 
     [self.provider reportNewIncomingCallWithUUID:uuid update:update completion:^(NSError * _Nullable error) {
-        if (error) {
-            reject(@"CALL_ERROR", error.localizedDescription, error);
-        } else {
-            resolve(@YES);
-        }
+        if (error) { reject(@"CALL_ERROR", error.localizedDescription, error); }
+        else { resolve(@YES); }
     }];
 }
 
-RCT_EXPORT_METHOD(reportRemoteEnded:(NSString *)uuidString reason:(NSInteger)reason) {
-    NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
-    if (!uuid) return;
-
-    [self.provider reportCallWithUUID:uuid
-                          endedAtDate:[NSDate date]
-                               reason:(CXCallEndedReason)reason];
-    
-    if ([uuid isEqual:self.currentCallUUID]) {
-        self.currentCallUUID = nil;
+RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if (self.pendingCallUuid) {
+        result[@"default"] = @{@"callUuid": self.pendingCallUuid};
         self.pendingCallUuid = nil;
     }
-}
-
-RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString)
-{
-    [self reportRemoteEnded:uuidString reason:CXCallEndedReasonRemoteEnded];
+    resolve(result.count > 0 ? result : [NSNull null]);
 }
 
 // MARK: - CXProviderDelegate
 
 - (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {
-    // 1. Force the Audio Session active immediately so the system hands off the hardware
     AVAudioSession *session = [AVAudioSession sharedInstance];
-    NSError *audioError = nil;
-    [session setCategory:AVAudioSessionCategoryPlayAndRecord
-                    mode:AVAudioSessionModeVoiceChat
-                 options:AVAudioSessionCategoryOptionAllowBluetoothHFP | AVAudioSessionCategoryOptionDefaultToSpeaker
-                   error:nil];
-    [session setActive:YES error:&audioError];
+    [session setCategory:AVAudioSessionCategoryPlayAndRecord mode:AVAudioSessionModeVoiceChat options:AVAudioSessionCategoryOptionAllowBluetoothHFP | AVAudioSessionCategoryOptionDefaultToSpeaker error:nil];
+    [session setActive:YES error:nil];
 
-    // 2. Fulfill the system action
     [action fulfill];
 
     NSString *uuidStr = [action.callUUID.UUIDString lowercaseString];
     self.pendingCallUuid = uuidStr;
 
-    // 3. Move to Main Queue for UI Handoff
     dispatch_async(dispatch_get_main_queue(), ^{
+        // Use our non-deprecated helper to bring app to front
+        UIWindow *window = [self getActiveWindow];
+        if (window) {
+            [window makeKeyAndVisible];
+        }
         
-        // This is the trigger that "destroys" the CallKit UI without failing the call
-        // It tells iOS the call is being handled by another device/interface (the app)
-        [self.provider reportCallWithUUID:action.callUUID
-                          endedAtDate:[NSDate date]
-                                reason:CXCallEndedReasonAnsweredElsewhere];
-        
-        // Ensure the app window is visible/active
-        [[[UIApplication sharedApplication] keyWindow] makeKeyAndVisible];
-        
-        // Notify React Native that the call is accepted
         [self sendEventWithName:@"onCallAccepted" body:@{@"callUuid": uuidStr}];
-        
-        // Clear local tracking so displayIncomingCall can be used again
-        self.currentCallUUID = nil;
     });
 }
 
 - (void)provider:(CXProvider *)provider performEndCallAction:(CXEndCallAction *)action {
     [action fulfill];
-    self.currentCallUUID = nil;
-    self.pendingCallUuid = nil;
+    self.isCallActive = NO;
     [self sendEventWithName:@"onCallRejected" body:@{@"callUuid": [action.callUUID.UUIDString lowercaseString]}];
 }
 
 - (void)providerDidReset:(CXProvider *)provider {
-    // Important: Do NOT deactivate audio if a call is transitioning to the app
-    self.currentCallUUID = nil;
-    self.pendingCallUuid = nil;
+    self.isCallActive = NO;
 }
 
-@end
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.8.7",
+    "version": "0.8.9",
     "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,6 +1,5 @@
-const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity } = require('@expo/config-plugins');
+const { withAndroidManifest, withInfoPlist, withPlugins, withMainActivity, withAppDelegate } = require('@expo/config-plugins');
 
-/** 1. ANDROID MAIN ACTIVITY MOD **/
 function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
@@ -70,7 +69,6 @@ function withMainActivityDataFix(config) {
         return config;
     });
 }
-
 /** 2. ANDROID MANIFEST CONFIG **/
 function withAndroidConfig(config) {
     return withAndroidManifest(config, (config) => {
@@ -154,32 +152,51 @@ function withAndroidConfig(config) {
         return config;
     });
 }
+/** 2. IOS APP DELEGATE MOD (The fix for Lock Screen Answer) **/
+function withIosAppDelegateMod(config) {
+    return withAppDelegate(config, (config) => {
+        let contents = config.modResults.contents;
 
-/** 3. IOS CONFIG **/
-// Notice we accept (config, props) directly
-function withIosConfig(config, props = {}) {
-    const iosBackgroundAudio = props.iosBackgroundAudio;
+        // 1. Check for the import
+        if (!contents.includes('#import <React/RCTLinkingManager.h>')) {
+            contents = '#import <React/RCTLinkingManager.h>\n' + contents;
+        }
 
-    console.log(`[rns-nativecall] iosBackgroundAudio setting:`, iosBackgroundAudio);
+        // 2. Only inject if the method name doesn't exist AT ALL
+        // This prevents the "Duplicate Method" error
+        if (!contents.includes('continueUserActivity')) {
+            const linkingCode = `
+- (BOOL)application:(UIApplication *)application
+   continueUserActivity:(NSUserActivity *)userActivity
+     restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler
+{
+  return [RCTLinkingManager application:application
+                   continueUserActivity:userActivity
+                     restorationHandler:restorationHandler];
+}
+`;
+            // Inject before the LAST @end in the file
+            const parts = contents.split('@end');
+            const lastPart = parts.pop();
+            contents = parts.join('@end') + linkingCode + '\n@end' + lastPart;
+        } else {
+            // 3. If it DOES exist, ensure RCTLinkingManager is inside it
+            // Many Expo apps have an empty continueUserActivity or one that only handles notifications
+            if (!contents.includes('RCTLinkingManager')) {
+                console.warn("[rns-nativecall] continueUserActivity exists but doesn't have RCTLinkingManager. Manual check required.");
+            }
+        }
 
+        config.modResults.contents = contents;
+        return config;
+    });
+}
+/** 3. IOS INFO.PLIST CONFIG (Existing) **/
+function withIosConfig(config, props = {}) {
     return withInfoPlist(config, (config) => {
         const infoPlist = config.modResults;
         if (!infoPlist.UIBackgroundModes) infoPlist.UIBackgroundModes = [];
 
-        // Explicit check: only disable if strictly false
-        const enableAudio = iosBackgroundAudio !== false;
-
-        // if (enableAudio) {
-        //     if (!infoPlist.UIBackgroundModes.includes('audio')) {
-        //         infoPlist.UIBackgroundModes.push('audio');
-        //     }
-        // } else {
-        //     infoPlist.UIBackgroundModes = infoPlist.UIBackgroundModes.filter(
-        //         (mode) => mode !== 'audio'
-        //     );
-        //     console.log(`[rns-nativecall] 'audio' background mode removed.`);
-        // }
-
         ['voip', 'remote-notification'].forEach(mode => {
             if (!infoPlist.UIBackgroundModes.includes(mode)) {
                 infoPlist.UIBackgroundModes.push(mode);
@@ -189,13 +206,12 @@ function withIosConfig(config, props = {}) {
         return config;
     });
 }
-
 // Main Plugin Entry
 module.exports = (config, props) => {
     return withPlugins(config, [
         withAndroidConfig,
         withMainActivityDataFix,
-        // Standard way to pass props to a plugin function
+        withIosAppDelegateMod, // <--- ADDED THIS HERE
         [withIosConfig, props]
     ]);
 };