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

package/ios/StreamVideoReactNative.m

@@ -4,6 +4,7 @@
 #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"
@@ -14,12 +15,8 @@
 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,
@@ -60,11 +57,196 @@ 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: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;
+    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:&streamPayload atIndex:11];
+    [invocation setArgument:&completionHandler atIndex:12];
+    [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();
@@ -191,71 +373,6 @@ 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
@@ -393,17 +510,7 @@ RCT_EXPORT_METHOD(checkPermission:(NSString *)permission
     ];
 }
 
-+(BOOL)shouldRejectCallWhenBusy {
-    return _shouldRejectCallWhenBusy;
-}
-
-RCT_EXPORT_METHOD(setShouldRejectCallWhenBusy:(BOOL)shouldReject) {
-    _shouldRejectCallWhenBusy = shouldReject;
-#ifdef DEBUG
-    NSLog(@"setShouldRejectCallWhenBusy: %@", shouldReject ? @"YES" : @"NO");
-#endif
-}
-
+//current implementation will return any registered calls not only stream calls
 + (BOOL)hasAnyActiveCall
 {
     CXCallObserver *callObserver = [[CXCallObserver alloc] init];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.30.0",
+  "version": "1.30.1-beta.1",
   "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.44.0",
-    "@stream-io/video-react-bindings": "1.13.9",
+    "@stream-io/video-client": "1.44.1-beta.2",
+    "@stream-io/video-react-bindings": "1.13.10-beta.2",
     "intl-pluralrules": "2.0.1",
     "lodash.merge": "^4.6.2",
     "react-native-url-polyfill": "^3.0.0",
@@ -65,18 +65,17 @@
     "@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-webrtc": ">=137.1.0",
+    "@stream-io/react-native-callingx": ">=0.1.0",
+    "@stream-io/react-native-webrtc": ">=137.1.2",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
     "expo-build-properties": "*",
     "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-voip-push-notification": ">=3.3.1"
+    "react-native-svg": ">=13.6.0"
   },
   "peerDependenciesMeta": {
     "@notifee/react-native": {
@@ -94,6 +93,9 @@
     "@stream-io/noise-cancellation-react-native": {
       "optional": true
     },
+    "@stream-io/react-native-callingx": {
+      "optional": true
+    },
     "@stream-io/video-filters-react-native": {
       "optional": true
     },
@@ -106,17 +108,11 @@
     "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": {
@@ -130,9 +126,10 @@
     "@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-webrtc": "137.1.0",
-    "@stream-io/video-filters-react-native": "^0.10.0",
+    "@stream-io/noise-cancellation-react-native": "0.5.1-beta.0",
+    "@stream-io/react-native-callingx": "0.1.1-beta.0",
+    "@stream-io/react-native-webrtc": "137.1.2",
+    "@stream-io/video-filters-react-native": "0.10.1-beta.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.4",
@@ -148,11 +145,9 @@
     "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",

package/src/hooks/push/index.ts

@@ -1,5 +1,4 @@
 import { useIosVoipPushEventsSetupEffect } from './useIosVoipPushEventsSetupEffect';
-import { useProcessPushCallEffect } from './useProcessPushCallEffect';
 import { useInitAndroidTokenAndRest } from './useInitAndroidTokenAndRest';
 import { useIosInitRemoteNotifications } from './useIosInitRemoteNotifications';
 import { useProcessPushNonRingingCallEffect } from './useProcessPushNonRingingCallEffect';
@@ -12,6 +11,5 @@ export const usePushRegisterEffect = () => {
   useIosInitRemoteNotifications();
   useIosVoipPushEventsSetupEffect();
   useProcessPushNonRingingCallEffect();
-  useProcessPushCallEffect();
   useInitAndroidTokenAndRest();
 };

package/src/hooks/push/useCallingExpWithCallingStateEffect.ts

@@ -0,0 +1,147 @@
+import { videoLoggerSystem } from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+import { useEffect, useMemo } from 'react';
+import { getCallDisplayName } from '../../utils/internal/callingx/callingx';
+import { getCallingxLibIfAvailable } from '../../utils/push/libs/callingx';
+
+const logger = videoLoggerSystem.getLogger('callingx');
+
+/**
+ * This hook is used to inform sync call state with CallKit/Telecom (i.e. start call, end call, mute/unmute call).
+ */
+export const useCallingExpWithCallingStateEffect = () => {
+  const { useMicrophoneState, useParticipants, useCallMembers } =
+    useCallStateHooks();
+
+  const activeCall = useCall();
+  const { isMute, microphone } = useMicrophoneState();
+  const callMembers = useCallMembers();
+  const participants = useParticipants();
+
+  const activeCallCid = activeCall?.cid;
+  const currentUserId = activeCall?.currentUserId;
+
+  const callDisplayName = useMemo(
+    () => getCallDisplayName(callMembers, participants, currentUserId),
+    [callMembers, participants, currentUserId],
+  );
+
+  useEffect(() => {
+    return () => {
+      const callingx = getCallingxLibIfAvailable();
+      if (!callingx?.isSetup || !activeCallCid) {
+        return;
+      }
+
+      const isCallTracked = callingx.isCallTracked(activeCallCid);
+      if (!isCallTracked) {
+        logger.debug(
+          `useCallingExpWithCallingStateEffect:No active call cid to end in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked}`,
+        );
+        return;
+      }
+      //if incoming stream call was unmounted, we need to end the call in CallKit/Telecom
+      logger.debug(
+        `useCallingExpWithCallingStateEffect: Ending call in callingx: ${activeCallCid}`,
+      );
+      callingx
+        .endCallWithReason(activeCallCid, 'local')
+        .catch((error: unknown) => {
+          logger.error(
+            `useCallingExpWithCallingStateEffect: Error ending call in callingx: ${activeCallCid}`,
+            error,
+          );
+        });
+    };
+  }, [activeCallCid]);
+
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (!callingx?.isSetup || !activeCallCid) {
+      return;
+    }
+
+    const isCallTracked = callingx.isCallTracked(activeCallCid);
+    if (!isCallTracked) {
+      logger.debug(
+        `useCallingExpWithCallingStateEffect:No active call cid to update callingx: ${activeCallCid} isCallTracked: ${isCallTracked}`,
+      );
+      return;
+    }
+
+    callingx.updateDisplay(activeCallCid, activeCallCid, callDisplayName);
+  }, [activeCallCid, callDisplayName]);
+
+  // Sync microphone mute state from app → CallKit
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (!callingx?.isSetup || !activeCallCid) {
+      return;
+    }
+
+    const isCallTracked = callingx.isCallTracked(activeCallCid);
+    if (!isCallTracked) {
+      logger.debug(
+        `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked}`,
+      );
+      return;
+    }
+
+    callingx.setMutedCall(activeCallCid, isMute);
+  }, [activeCallCid, isMute]);
+
+  // Sync mute state from CallKit → app (only for system-initiated mute actions)
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (!callingx?.isSetup || !activeCallCid) {
+      logger.debug(
+        `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} callingx isSetup: ${callingx?.isSetup}`,
+      );
+      return;
+    }
+
+    // Listen to mic toggle events from CallKit/Telecom and update stream call microphone state.
+    // Only system-initiated mute actions (e.g. user tapped mute on the native CallKit UI)
+    // are sent here — app-initiated actions are filtered out on the native side to prevent
+    // the feedback loop: app mutes mic → setMutedCall → CallKit delegate → event to JS → loop.
+    const subscription = callingx.addEventListener(
+      'didPerformSetMutedCallAction',
+      async (event: { callId: string; muted: boolean }) => {
+        const { callId, muted } = event;
+
+        const isCallTracked = callingx.isCallTracked(activeCallCid);
+        if (!isCallTracked || callId !== activeCallCid) {
+          logger.debug(
+            `useCallingExpWithCallingStateEffect: No active call cid to set muted in calling exp: ${activeCallCid} isCallTracked: ${isCallTracked} callId: ${callId}`,
+          );
+          return;
+        }
+
+        const isCurrentlyMuted = microphone.state.status === 'disabled';
+        if (isCurrentlyMuted === muted) {
+          logger.debug(
+            `useCallingExpWithCallingStateEffect: Mic toggle is already in the desired state: ${muted} for call: ${activeCallCid}`,
+          );
+          return;
+        }
+
+        try {
+          if (muted) {
+            await microphone.disable();
+          } else {
+            await microphone.enable();
+          }
+        } catch (error: unknown) {
+          logger.error(
+            `useCallingExpWithCallingStateEffect: Error toggling mic in calling exp: ${activeCallCid}`,
+            error,
+          );
+        }
+      },
+    );
+
+    return () => {
+      subscription.remove();
+    };
+  }, [activeCallCid, microphone]);
+};

package/src/hooks/push/useIosVoipPushEventsSetupEffect.ts

@@ -1,6 +1,4 @@
 import { type MutableRefObject, useEffect, useRef, useState } from 'react';
-import { getVoipPushNotificationLib } from '../../utils/push/libs';
-
 import { Platform } from 'react-native';
 import { StreamVideoRN } from '../../utils';
 import { onVoipNotificationReceived } from '../../utils/push/internal/ios';
@@ -10,6 +8,7 @@ import {
 } from '@stream-io/video-react-bindings';
 import { setPushLogoutCallback } from '../../utils/internal/pushLogoutCallback';
 import { StreamVideoClient, videoLoggerSystem } from '@stream-io/video-client';
+import { getCallingxLibIfAvailable } from '../../utils/push/libs';
 
 const logger = videoLoggerSystem.getLogger('useIosVoipPushEventsSetupEffect');
 
@@ -28,6 +27,7 @@ function setLogoutCallback(
     lastVoipTokenRef.current = { token: '', userId: '' };
     try {
       await client.removeDevice(token);
+      logger.debug('PushLogoutCallback - Removed voip token', token);
     } catch (err) {
       logger.warn('PushLogoutCallback - Failed to remove voip token', err);
     }
@@ -89,24 +89,12 @@ export const useIosVoipPushEventsSetupEffect = () => {
   useEffect(() => {
     const pushConfig = StreamVideoRN.getConfig().push;
     const pushProviderName = pushConfig?.ios.pushProviderName;
-    if (Platform.OS !== 'ios' || !client || !pushProviderName) {
-      return;
-    }
-    if (!pushConfig.android.incomingCallChannel) {
-      // TODO: remove this check and find a better way once we have telecom integration for android
-      logger.debug(
-        'android incomingCallChannel is not defined, so skipping the useIosVoipPushEventsSetupEffect',
-      );
+    const callingx = getCallingxLibIfAvailable();
+
+    if (Platform.OS !== 'ios' || !client || !pushProviderName || !callingx) {
       return;
     }
 
-    const voipPushNotification = getVoipPushNotificationLib();
-
-    // even though we do this natively, we have to still register here again
-    // natively this will make sure "register" event for JS is sent with the last push token
-    // Necessary if client changed before we got the event here or user logged out and logged in again
-    voipPushNotification.registerVoipToken();
-
     const onTokenReceived = (token: string) => {
       const userId = client.streamClient._user?.id ?? '';
       if (client.streamClient.anonymous || !token || !userId) {
@@ -145,24 +133,24 @@ export const useIosVoipPushEventsSetupEffect = () => {
         });
     };
     // fired when PushKit give us the latest token
-    voipPushNotification.addEventListener('register', (token) => {
-      onTokenReceived(token);
-    });
+    const voipRegisterListener = callingx.addEventListener(
+      'voipNotificationsRegistered',
+      ({ token }) => {
+        onTokenReceived(token);
+      },
+    );
 
-    // this will fire when there are events occured before js bridge initialized
-    voipPushNotification.addEventListener('didLoadWithEvents', (events) => {
-      if (!events || !Array.isArray(events) || events.length < 1) {
-        return;
-      }
-      for (const voipPushEvent of events) {
-        const { name, data } = voipPushEvent;
-        if (name === 'RNVoipPushRemoteNotificationsRegisteredEvent') {
-          onTokenReceived(data);
-        } else if (name === 'RNVoipPushRemoteNotificationReceivedEvent') {
-          onVoipNotificationReceived(data, pushConfig);
-        }
+    // this will return events that were fired before js bridge initialized
+    callingx.getInitialVoipEvents().forEach(({ eventName, params }) => {
+      if (eventName === 'voipNotificationsRegistered' && 'token' in params) {
+        onTokenReceived(params.token);
+      } else if (eventName === 'voipNotificationReceived') {
+        onVoipNotificationReceived(params, pushConfig);
       }
     });
+
+    callingx.registerVoipToken();
+
     lastListener.count += 1;
     const currentListenerCount = lastListener.count;
 
@@ -175,8 +163,7 @@ export const useIosVoipPushEventsSetupEffect = () => {
         return;
       }
       logger.debug(`Voip event listeners are removed for user: ${userId}`);
-      voipPushNotification.removeEventListener('didLoadWithEvents');
-      voipPushNotification.removeEventListener('register');
+      voipRegisterListener.remove();
     };
   }, [client]);
 };