@stream-io/video-react-native-sdk 1.31.0 → 1.31.1-beta.0

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"
@@ -22,12 +23,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,
@@ -68,11 +65,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();
@@ -199,71 +381,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
@@ -401,17 +518,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.31.0",
+  "version": "1.31.1-beta.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.44.5",
-    "@stream-io/video-react-bindings": "1.13.14",
+    "@stream-io/video-client": "1.44.6-beta.0",
+    "@stream-io/video-react-bindings": "1.13.15-beta.0",
     "intl-pluralrules": "2.0.1",
     "react-native-url-polyfill": "^3.0.0",
     "rxjs": "~7.8.2",
@@ -64,6 +64,7 @@
     "@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.3",
     "@stream-io/video-filters-react-native": ">=0.1.0",
     "expo": ">=47.0.0",
@@ -71,11 +72,9 @@
     "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": {
@@ -93,6 +92,9 @@
     "@stream-io/noise-cancellation-react-native": {
       "optional": true
     },
+    "@stream-io/react-native-callingx": {
+      "optional": true
+    },
     "@stream-io/video-filters-react-native": {
       "optional": true
     },
@@ -105,17 +107,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": {
@@ -129,9 +125,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.6.0",
+    "@stream-io/noise-cancellation-react-native": "0.6.1-beta.0",
+    "@stream-io/react-native-callingx": "0.1.1-beta.1",
     "@stream-io/react-native-webrtc": "137.1.3",
-    "@stream-io/video-filters-react-native": "^0.11.0",
+    "@stream-io/video-filters-react-native": "0.11.1-beta.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.3.3",
     "@tsconfig/node18": "^18.2.4",
@@ -146,11 +143,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,189 @@
+import { Call, CallingState, videoLoggerSystem } from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+import { useEffect, useMemo } from 'react';
+import { filter, take } from 'rxjs/operators';
+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 isIncoming =
+    (activeCall?.ringing && !activeCall?.isCreatedByMe) || false;
+
+  const callDisplayName = useMemo(
+    () => getCallDisplayName(callMembers, participants, currentUserId),
+    [callMembers, participants, currentUserId],
+  );
+
+  useEffect(() => {
+    const callingx = getCallingxLibIfAvailable();
+    if (!callingx?.isSetup || !activeCall) {
+      return;
+    }
+    // need to capture RINGING -> Joining -> Joined state change for the first time
+    // and inform callingx that the call is active
+    const shouldMakeCallActive = (call: Call): boolean => {
+      // only for outgoing calls or non-ringing ongoing calls in callingx
+      // Note: incoming calls are handled by callingx pending states instead
+      return (
+        (call.ringing && call.isCreatedByMe) ||
+        (!call.ringing && callingx.isOngoingCallsEnabled)
+      );
+    };
+    const subscription = activeCall.state.callingState$
+      .pipe(
+        filter(
+          (callingState) =>
+            shouldMakeCallActive(activeCall) &&
+            callingState === CallingState.JOINED &&
+            callingx.isCallTracked(activeCall.cid),
+        ),
+        take(1), // only need to capture the first joined state for outgoing calls
+        // then subscription completes and is automatically unsubscribed
+      )
+      .subscribe(() => {
+        callingx.setCurrentCallActive(activeCall.cid);
+      });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [activeCall]);
+
+  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,
+      isIncoming,
+    );
+  }, [activeCallCid, callDisplayName, isIncoming]);
+
+  // 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]);
+};