@stream-io/video-react-native-sdk 1.29.0-beta.1 → 1.29.0

package/ios/StreamVideoReactNative.m

@@ -4,7 +4,6 @@
 #import <React/RCTUIManagerUtils.h>
 #import <UIKit/UIKit.h>
 #import <CallKit/CallKit.h>
-#import <PushKit/PushKit.h>
 #import "StreamVideoReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
@@ -15,8 +14,12 @@
 NSNotificationName const kBroadcastStartedNotification = @"iOS_BroadcastStarted";
 NSNotificationName const kBroadcastStoppedNotification = @"iOS_BroadcastStopped";
 
+static NSMutableDictionary *_incomingCallUUIDsByCallID = nil;
+static NSMutableDictionary *_incomingCallCidsByUUID = nil;
 static dispatch_queue_t _dictionaryQueue = nil;
 
+static BOOL _shouldRejectCallWhenBusy = NO;
+
 void broadcastNotificationCallback(CFNotificationCenterRef center,
                                    void *observer,
                                    CFStringRef name,
@@ -57,198 +60,11 @@ RCT_EXPORT_MODULE();
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
         _dictionaryQueue = dispatch_queue_create("com.stream.video.dictionary", DISPATCH_QUEUE_SERIAL);
+        _incomingCallUUIDsByCallID = [NSMutableDictionary dictionary];
+        _incomingCallCidsByUUID = [NSMutableDictionary dictionary];
     });
 }
 
-+(BOOL)canRegisterCall {
-    Class callingxClass = NSClassFromString(@"Callingx");
-    if (!callingxClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][canRegisterCall] Callingx not available");
-        #endif
-        return YES;
-    }
-    
-    SEL selector = @selector(canRegisterCall);
-    if (![callingxClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][canRegisterCall] Callingx does not respond to canRegisterCall selector");
-        #endif
-        return YES;
-    }
-    
-    NSMethodSignature *signature = [callingxClass methodSignatureForSelector:selector];
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:callingxClass];
-    [invocation setSelector:selector];
-    [invocation invoke];
-    
-    BOOL canRegister = NO;
-    [invocation getReturnValue:&canRegister];
-    
-    #if DEBUG
-    NSLog(@"[StreamVideoReactNative][canRegisterCall] canRegisterCall = %@", canRegister ? @"YES" : @"NO");
-    #endif
-    
-    return canRegister;
-}
-
-+(void)voipRegistration {
-    Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
-    if (!voipManagerClass) {
-        // Fallback: Try the unmangled name (might work depending on Swift version)
-        voipManagerClass = NSClassFromString(@"VoipNotificationsManager");
-    }
-    
-    if (!voipManagerClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][voipRegistration] VoipNotificationsManager not available");
-        #endif
-        return;
-    }
-    
-    SEL selector = @selector(voipRegistration);
-    if (![voipManagerClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][voipRegistration] VoipNotificationsManager does not respond to voipRegistration");
-        #endif
-        return;
-    }
-    
-    [voipManagerClass voipRegistration];
-}
-
-+(void)didUpdatePushCredentials:(PKPushCredentials *)credentials forType:(NSString *)type {
-    Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
-    if (!voipManagerClass) {
-        // Fallback: Try the unmangled name (might work depending on Swift version)
-        voipManagerClass = NSClassFromString(@"VoipNotificationsManager");
-    }
-    
-    if (!voipManagerClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didUpdatePushCredentials] VoipNotificationsManager not available");
-        #endif
-        return;
-    }
-    
-    SEL selector = @selector(didUpdatePushCredentials:forType:);
-    if (![voipManagerClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didUpdatePushCredentials] VoipNotificationsManager does not respond to didUpdatePushCredentials:forType:");
-        #endif
-        return;
-    }
-    
-    [voipManagerClass didUpdatePushCredentials:credentials forType:type];
-}
-
-+(void)didReceiveIncomingPush:(PKPushPayload *)payload forType:(NSString *)type completionHandler: (void (^_Nullable)(void)) completion {
-    NSDictionary *streamPayload = payload.dictionaryPayload[@"stream"];
-    if (!streamPayload) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Stream payload not found");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-    
-    NSString *createdCallerName = streamPayload[@"created_by_display_name"];
-    NSString *callCid = streamPayload[@"call_cid"];
-    if (!createdCallerName || !callCid) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Missing required fields: created_by_display_name or call_cid");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-    
-    if (![StreamVideoReactNative canRegisterCall]) {
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    [StreamVideoReactNative reportNewIncomingCall:streamPayload forType:type completionHandler:completion];
-    [StreamVideoReactNative didReceiveIncomingPushWithPayload:payload forType:type];
-}
-
-+(void)reportNewIncomingCall:(NSDictionary *)streamPayload forType:(NSString *)type completionHandler: (void (^_Nullable)(void)) completion {
-    Class callingxClass = NSClassFromString(@"Callingx");
-    if (!callingxClass) {
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Callingx not available");
-        return;
-    }
-    
-    SEL selector = @selector(reportNewIncomingCall:handle:handleType:hasVideo:localizedCallerName:supportsHolding:supportsDTMF:supportsGrouping:supportsUngrouping:fromPushKit:payload:withCompletionHandler:);
-    if (![callingxClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Callingx does not respond to selector");
-        #endif
-        return;
-    }
-    
-    NSString *callCid = streamPayload[@"call_cid"];
-    NSString *createdCallerName = streamPayload[@"created_by_display_name"];
-    NSString *videoIncluded = streamPayload[@"video"];
-    BOOL hasVideo = [videoIncluded isEqualToString:@"false"] ? NO : YES;
-    NSString *handleType = @"generic";
-    BOOL supportsHolding = NO;
-    BOOL supportsDTMF = NO;
-    BOOL supportsGrouping = NO;
-    BOOL supportsUngrouping = NO;
-    BOOL fromPushKit = YES;
-    void (^completionHandler)(void) = completion;
-    
-    NSMethodSignature *signature = [callingxClass methodSignatureForSelector:selector];
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:callingxClass];
-    [invocation setSelector:selector];
-    [invocation setArgument:&callCid atIndex:2];
-    [invocation setArgument:&createdCallerName atIndex:3];
-    [invocation setArgument:&handleType atIndex:4];
-    [invocation setArgument:&hasVideo atIndex:5];
-    [invocation setArgument:&createdCallerName atIndex:6];
-    [invocation setArgument:&supportsHolding atIndex:7];
-    [invocation setArgument:&supportsDTMF atIndex:8];
-    [invocation setArgument:&supportsGrouping atIndex:9];
-    [invocation setArgument:&supportsUngrouping atIndex:10];
-    [invocation setArgument:&fromPushKit atIndex:11];
-    [invocation setArgument:&streamPayload atIndex:12];
-    [invocation setArgument:&completionHandler atIndex:13];
-    [invocation invoke];
-}
-
-+(void)didReceiveIncomingPushWithPayload:(PKPushPayload *)payload forType:(NSString *)type {
-    Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
-    if (!voipManagerClass) {
-        // Fallback: Try the unmangled name (might work depending on Swift version)
-        voipManagerClass = NSClassFromString(@"VoipNotificationsManager");
-    }
-    
-    if (!voipManagerClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPushWithPayload] VoipNotificationsManager not available");
-        #endif
-        return;
-    }
-    
-    SEL selector = @selector(didReceiveIncomingPushWithPayload:forType:);
-    if (![voipManagerClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPushWithPayload] VoipNotificationsManager does not respond to didReceiveIncomingPushWithPayload:forType:");
-        #endif
-        return;
-    }
-    
-    [voipManagerClass didReceiveIncomingPushWithPayload:payload forType:type];
-}
-
 -(instancetype)init {
     if ((self = [super init])) {
         _notificationCenter = CFNotificationCenterGetDarwinNotifyCenter();
@@ -375,6 +191,71 @@ RCT_EXPORT_METHOD(currentThermalState:(RCTPromiseResolveBlock)resolve rejecter:(
     }
 }
 
++(void)registerIncomingCall:(NSString *)cid uuid:(NSString *)uuid {
+    [StreamVideoReactNative initializeSharedDictionaries];
+    dispatch_sync(_dictionaryQueue, ^{
+        
+#ifdef DEBUG
+        NSLog(@"registerIncomingCall cid:%@ -> uuid:%@",cid,uuid);
+#endif
+        NSString *lowercaseUUID = [uuid lowercaseString];
+        _incomingCallUUIDsByCallID[cid] = lowercaseUUID;
+        _incomingCallCidsByUUID[lowercaseUUID] = cid;
+    });
+}
+
+RCT_EXPORT_METHOD(getIncomingCallUUid:(NSString *)cid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_sync(_dictionaryQueue, ^{
+        NSString *uuid = _incomingCallUUIDsByCallID[cid];
+        if (uuid) {
+            resolve(uuid);
+        } else {
+            NSString *errorString = [NSString stringWithFormat:@"requested incoming call not found for cid: %@", cid];
+            reject(@"access_failure", errorString, nil);
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(getIncomingCallCid:(NSString *)uuid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_sync(_dictionaryQueue, ^{
+        NSString *lowercaseUUID = [uuid lowercaseString];
+        NSString *foundCid = _incomingCallCidsByUUID[lowercaseUUID];
+        
+        if (foundCid) {
+            resolve(foundCid);
+        } else {
+            NSString *errorString = [NSString stringWithFormat:@"requested incoming call not found for uuid: %@", uuid];
+            reject(@"access_failure", errorString, nil);
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(removeIncomingCall:(NSString *)cid
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_sync(_dictionaryQueue, ^{
+        NSString *uuid = _incomingCallUUIDsByCallID[cid];
+        if (uuid) {
+#ifdef DEBUG
+            NSLog(@"removeIncomingCall cid:%@ -> uuid:%@",cid,uuid);
+#endif
+            
+            [_incomingCallUUIDsByCallID removeObjectForKey:cid];
+            [_incomingCallCidsByUUID removeObjectForKey:uuid];
+            resolve(@YES);
+        } else {
+            resolve(@NO);
+        }
+    });
+}
+
 RCT_EXPORT_METHOD(captureRef:(nonnull NSNumber *)reactTag
                   options:(NSDictionary *)options
                   resolver:(RCTPromiseResolveBlock)resolve
@@ -492,7 +373,17 @@ RCT_EXPORT_METHOD(getBatteryState:(RCTPromiseResolveBlock)resolve
     ];
 }
 
-//current implementation will return any registered calls not only stream calls
++(BOOL)shouldRejectCallWhenBusy {
+    return _shouldRejectCallWhenBusy;
+}
+
+RCT_EXPORT_METHOD(setShouldRejectCallWhenBusy:(BOOL)shouldReject) {
+    _shouldRejectCallWhenBusy = shouldReject;
+#ifdef DEBUG
+    NSLog(@"setShouldRejectCallWhenBusy: %@", shouldReject ? @"YES" : @"NO");
+#endif
+}
+
 + (BOOL)hasAnyActiveCall
 {
     CXCallObserver *callObserver = [[CXCallObserver alloc] init];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.29.0-beta.1",
+  "version": "1.29.0",
   "description": "Stream Video SDK for React Native",
   "author": "https://getstream.io",
   "homepage": "https://getstream.io/video/docs/react-native/",
@@ -50,8 +50,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.41.3",
-    "@stream-io/video-react-bindings": "1.13.3",
+    "@stream-io/video-client": "1.42.0",
+    "@stream-io/video-react-bindings": "1.13.4",
     "intl-pluralrules": "2.0.1",
     "lodash.merge": "^4.6.2",
     "react-native-url-polyfill": "^3.0.0",
@@ -65,7 +65,6 @@
     "@react-native-firebase/app": ">=17.5.0",
     "@react-native-firebase/messaging": ">=17.5.0",
     "@stream-io/noise-cancellation-react-native": ">=0.1.0",
-    "@stream-io/react-native-callingx": ">=0.1.0",
     "@stream-io/react-native-webrtc": ">=137.1.0",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
@@ -73,9 +72,11 @@
     "expo-notifications": "*",
     "react": ">=17.0.0",
     "react-native": ">=0.73.0",
+    "react-native-callkeep": ">=4.3.11",
     "react-native-gesture-handler": ">=2.8.0",
     "react-native-reanimated": ">=2.7.0",
-    "react-native-svg": ">=13.6.0"
+    "react-native-svg": ">=13.6.0",
+    "react-native-voip-push-notification": ">=3.3.1"
   },
   "peerDependenciesMeta": {
     "@notifee/react-native": {
@@ -93,9 +94,6 @@
     "@stream-io/noise-cancellation-react-native": {
       "optional": true
     },
-    "@stream-io/react-native-callingx": {
-      "optional": true
-    },
     "@stream-io/video-filters-react-native": {
       "optional": true
     },
@@ -108,11 +106,17 @@
     "expo-notifications": {
       "optional": true
     },
+    "react-native-callkeep": {
+      "optional": true
+    },
     "react-native-gesture-handler": {
       "optional": true
     },
     "react-native-reanimated": {
       "optional": true
+    },
+    "react-native-voip-push-notification": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -126,10 +130,9 @@
     "@react-native-firebase/app": "^23.4.0",
     "@react-native-firebase/messaging": "^23.4.0",
     "@react-native/babel-preset": "^0.81.5",
-    "@stream-io/noise-cancellation-react-native": "0.5.0",
-    "@stream-io/react-native-callingx": "0.1.0-beta.1",
+    "@stream-io/noise-cancellation-react-native": "^0.5.0",
     "@stream-io/react-native-webrtc": "137.1.0",
-    "@stream-io/video-filters-react-native": "0.10.0",
+    "@stream-io/video-filters-react-native": "^0.10.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.4",
@@ -145,9 +148,11 @@
     "react": "19.1.0",
     "react-native": "^0.81.5",
     "react-native-builder-bob": "~0.23",
+    "react-native-callkeep": "^4.3.16",
     "react-native-gesture-handler": "^2.28.0",
     "react-native-reanimated": "~4.1.2",
     "react-native-svg": "^15.14.0",
+    "react-native-voip-push-notification": "3.3.3",
     "react-native-worklets": "^0.5.0",
     "react-test-renderer": "19.1.0",
     "rimraf": "^6.0.1",
@@ -162,4 +167,4 @@
       "typescript"
     ]
   }
-}
+}

package/src/hooks/push/useIosCallkeepWithCallingStateEffect.ts

@@ -0,0 +1,235 @@
+import {
+  CallingState,
+  RxUtils,
+  videoLoggerSystem,
+} from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+import { NativeModules, Platform } from 'react-native';
+import { useEffect, useState } from 'react';
+import { StreamVideoRN } from '../../utils';
+import { getCallKeepLib } from '../../utils/push/libs';
+import {
+  voipCallkeepAcceptedCallOnNativeDialerMap$,
+  voipCallkeepCallOnForegroundMap$,
+  voipPushNotificationCallCId$,
+} from '../../utils/push/internal/rxSubjects';
+
+const isNonActiveCallingState = (callingState: CallingState) => {
+  return (
+    callingState === CallingState.IDLE ||
+    callingState === CallingState.UNKNOWN ||
+    callingState === CallingState.LEFT
+  );
+};
+
+const isAcceptedCallingState = (callingState: CallingState) => {
+  return (
+    callingState === CallingState.JOINING ||
+    callingState === CallingState.JOINED
+  );
+};
+
+const unsubscribeCallkeepEvents = async (activeCallCid: string | undefined) => {
+  const voipPushNotificationCallCId = RxUtils.getCurrentValue(
+    voipPushNotificationCallCId$,
+  );
+  if (activeCallCid && activeCallCid === voipPushNotificationCallCId) {
+    // callkeep events should not be listened anymore so clear the call cid
+    voipPushNotificationCallCId$.next(undefined);
+  }
+  return await NativeModules.StreamVideoReactNative?.removeIncomingCall(
+    activeCallCid,
+  );
+};
+
+const logger = videoLoggerSystem.getLogger(
+  'useIosCallkeepWithCallingStateEffect',
+);
+const log = (message: string) => {
+  logger.warn(message);
+};
+
+/**
+ * This hook is used to inform the callkeep library that the call has been joined or ended.
+ */
+export const useIosCallkeepWithCallingStateEffect = () => {
+  const activeCall = useCall();
+  const { useCallCallingState } = useCallStateHooks();
+  const callingState = useCallCallingState();
+  const [acceptedForegroundCallkeepMap, setAcceptedForegroundCallkeepMap] =
+    useState<{
+      uuid: string;
+      cid: string;
+    }>();
+
+  useEffect(() => {
+    return () => {
+      const pushConfig = StreamVideoRN.getConfig().push;
+      if (
+        Platform.OS !== 'ios' ||
+        !pushConfig ||
+        !pushConfig.ios?.pushProviderName
+      ) {
+        return;
+      }
+      if (!pushConfig.android.incomingCallChannel) {
+        // TODO: remove this check and find a better way once we have telecom integration for android
+        return;
+      }
+
+      const callkeep = getCallKeepLib();
+      // if the component is unmounted and the callID was not reported to callkeep, then report it now
+      if (acceptedForegroundCallkeepMap) {
+        log(
+          `Ending call in callkeep: ${acceptedForegroundCallkeepMap.cid}, reason: component unmounted and call was present in acceptedForegroundCallkeepMap`,
+        );
+        unsubscribeCallkeepEvents(acceptedForegroundCallkeepMap.cid).then(() =>
+          callkeep.endCall(acceptedForegroundCallkeepMap.uuid),
+        );
+      }
+    };
+  }, [acceptedForegroundCallkeepMap]);
+
+  const activeCallCid = activeCall?.cid;
+
+  useEffect(() => {
+    return () => {
+      const pushConfig = StreamVideoRN.getConfig().push;
+      if (
+        Platform.OS !== 'ios' ||
+        !pushConfig ||
+        !pushConfig.ios?.pushProviderName ||
+        !activeCallCid
+      ) {
+        return;
+      }
+      if (!pushConfig.android.incomingCallChannel) {
+        // TODO: remove this check and find a better way once we have telecom integration for android
+        return;
+      }
+      const nativeDialerAcceptedCallMap = RxUtils.getCurrentValue(
+        voipCallkeepAcceptedCallOnNativeDialerMap$,
+      );
+      const foregroundIncomingCallkeepMap = RxUtils.getCurrentValue(
+        voipCallkeepCallOnForegroundMap$,
+      );
+      const callkeep = getCallKeepLib();
+      if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+        log(
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in nativeDialerAcceptedCallMap`,
+        );
+        unsubscribeCallkeepEvents(activeCallCid).then(() =>
+          callkeep.endCall(nativeDialerAcceptedCallMap.uuid),
+        );
+        // no need to keep this reference anymore
+        voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
+      } else if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+        log(
+          `Ending call in callkeep: ${activeCallCid}, reason: activeCallCid changed or was removed and call was present in foregroundIncomingCallkeepMap`,
+        );
+        unsubscribeCallkeepEvents(activeCallCid).then(() =>
+          callkeep.endCall(foregroundIncomingCallkeepMap.uuid),
+        );
+      }
+    };
+  }, [activeCallCid]);
+
+  const pushConfig = StreamVideoRN.getConfig().push;
+  if (
+    Platform.OS !== 'ios' ||
+    !pushConfig ||
+    !pushConfig.ios.pushProviderName ||
+    !activeCallCid
+  ) {
+    return;
+  }
+  if (!pushConfig.android.incomingCallChannel) {
+    // TODO: remove this check and find a better way once we have telecom integration for android
+    return;
+  }
+
+  /**
+   * Check if current call is still needed to be accepted in callkeep
+   */
+  if (
+    isAcceptedCallingState(callingState) &&
+    acceptedForegroundCallkeepMap?.cid !== activeCallCid
+  ) {
+    const callkeep = getCallKeepLib();
+    // push notification was displayed
+    // but the call has been accepted through the app and not through the native dialer
+    const foregroundCallkeepMap = RxUtils.getCurrentValue(
+      voipCallkeepCallOnForegroundMap$,
+    );
+    if (foregroundCallkeepMap && foregroundCallkeepMap.cid === activeCallCid) {
+      log(
+        // @ts-expect-error - types issue
+        `Accepting call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundCallkeepMap`,
+      );
+      // no need to keep this reference anymore
+      voipCallkeepCallOnForegroundMap$.next(undefined);
+      NativeModules.StreamVideoReactNative?.removeIncomingCall(
+        activeCallCid,
+      ).then(() => callkeep.answerIncomingCall(foregroundCallkeepMap.uuid));
+      // this call should be accepted in callkeep
+      setAcceptedForegroundCallkeepMap(foregroundCallkeepMap);
+    }
+  }
+
+  /**
+   * Check if current call is still needed to be ended in callkeep
+   */
+  if (isNonActiveCallingState(callingState)) {
+    const callkeep = getCallKeepLib();
+
+    // this was a previously joined call which had push notification displayed
+    // the call was accepted through the app and not through native dialer
+    // the call was left using the leave button in the app and not through native dialer
+    if (activeCallCid === acceptedForegroundCallkeepMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in acceptedForegroundCallkeepMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(acceptedForegroundCallkeepMap.uuid),
+      );
+      setAcceptedForegroundCallkeepMap(undefined);
+      return;
+    }
+    // this was a call which had push notification displayed but never joined
+    // the user rejected in the app and not from native dialer
+    const foregroundIncomingCallkeepMap = RxUtils.getCurrentValue(
+      voipCallkeepCallOnForegroundMap$,
+    );
+    if (activeCallCid === foregroundIncomingCallkeepMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in foregroundIncomingCallkeepMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(foregroundIncomingCallkeepMap.uuid),
+      );
+      // no need to keep this reference anymore
+      voipCallkeepCallOnForegroundMap$.next(undefined);
+      return;
+    }
+    // this was a previously joined call
+    // it was an accepted call from native dialer and not from the app
+    // the user left using the leave button in the app
+    const nativeDialerAcceptedCallMap = RxUtils.getCurrentValue(
+      voipCallkeepAcceptedCallOnNativeDialerMap$,
+    );
+    if (activeCallCid === nativeDialerAcceptedCallMap?.cid) {
+      log(
+        // @ts-expect-error - types issue
+        `Ending call in callkeep: ${activeCallCid}, reason: callingstate went to ${CallingState[callingState]} and call was present in nativeDialerAcceptedCallMap`,
+      );
+      unsubscribeCallkeepEvents(activeCallCid).then(() =>
+        callkeep.endCall(nativeDialerAcceptedCallMap.uuid),
+      );
+      // no need to keep this reference anymore
+      voipCallkeepAcceptedCallOnNativeDialerMap$.next(undefined);
+      return;
+    }
+  }
+};