@stream-io/video-react-native-sdk 1.20.16 → 1.21.0

package/ios/StreamVideoReactNative.m

@@ -3,9 +3,12 @@
 #import <React/RCTUIManager.h>
 #import <React/RCTUIManagerUtils.h>
 #import <UIKit/UIKit.h>
+#import <CallKit/CallKit.h>
 #import "StreamVideoReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
+#import <AVFoundation/AVFoundation.h>
+#import <AudioToolbox/AudioToolbox.h>
 
 // Do not change these consts, it is what is used react-native-webrtc
 NSNotificationName const kBroadcastStartedNotification = @"iOS_BroadcastStarted";
@@ -15,6 +18,8 @@ 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,
@@ -25,10 +30,14 @@ void broadcastNotificationCallback(CFNotificationCenterRef center,
     [this screenShareEventReceived: eventName];
 }
 
+@interface StreamVideoReactNative () <AVAudioPlayerDelegate>
+@end
+
 @implementation StreamVideoReactNative
 {
     bool hasListeners;
     CFNotificationCenterRef _notificationCenter;
+    AVAudioPlayer *_busyTonePlayer; // Instance variable
 }
 
 // necessary for addUIBlock usage https://github.com/facebook/react-native/issues/50800#issuecomment-2823327307
@@ -77,6 +86,13 @@ RCT_EXPORT_METHOD(currentThermalState:(RCTPromiseResolveBlock)resolve rejecter:(
 }
 
 -(void)dealloc {
+    if (_busyTonePlayer) {
+        if (_busyTonePlayer.isPlaying) {
+            [_busyTonePlayer stop];
+        }
+        _busyTonePlayer = nil;
+        [self removeAudioInterruptionHandling];
+    }
     [self clearObserver];
 }
 
@@ -356,4 +372,264 @@ RCT_EXPORT_METHOD(getBatteryState:(RCTPromiseResolveBlock)resolve
     ];
 }
 
++(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];
+    
+    for(CXCall *call in callObserver.calls){
+        if(call.hasConnected){
+            NSLog(@"[RNCallKeep] Found active call with UUID: %@", call.UUID);
+            return YES;
+        }
+    }
+    return NO;
+}
+
+
+RCT_EXPORT_METHOD(playBusyTone:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self stopBusyTone]; // Stop any existing playback first
+        
+        // Configure audio session
+        NSError *sessionError = nil;
+        AVAudioSession *session = [AVAudioSession sharedInstance];
+        [session setCategory:AVAudioSessionCategoryPlayback
+                        mode:AVAudioSessionModeDefault
+                     options:AVAudioSessionCategoryOptionMixWithOthers
+                       error:&sessionError];
+        
+        if (sessionError) {
+            NSString *errorMsg = [NSString stringWithFormat:@"Failed to set audio session category: %@", sessionError.localizedDescription];
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_SESSION_ERROR", errorMsg, sessionError);
+            return;
+        }
+        
+        [session setActive:YES error:&sessionError];
+        if (sessionError) {
+            NSString *errorMsg = [NSString stringWithFormat:@"Failed to activate audio session: %@", sessionError.localizedDescription];
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_SESSION_ERROR", errorMsg, sessionError);
+            return;
+        }
+        
+        // Generate busy tone data
+        NSData *busyToneData = [self generateBusyToneData];
+        if (!busyToneData || busyToneData.length == 0) {
+            NSString *errorMsg = @"Failed to generate busy tone data";
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_GENERATION_ERROR", errorMsg, nil);
+            return;
+        }
+        
+        // Create audio player
+        NSError *playerError = nil;
+        self->_busyTonePlayer = [[AVAudioPlayer alloc] initWithData:busyToneData error:&playerError];
+        
+        if (playerError || !self->_busyTonePlayer) {
+            NSString *errorMsg = [NSString stringWithFormat:@"Failed to create audio player: %@", playerError.localizedDescription];
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_PLAYER_ERROR", errorMsg, playerError);
+            return;
+        }
+        
+        // Configure player
+        self->_busyTonePlayer.delegate = self;
+        self->_busyTonePlayer.numberOfLoops = -1; // Loop indefinitely
+        self->_busyTonePlayer.volume = 0.5; // Set reasonable volume
+        
+        // Setup audio interruption handling
+        [self setupAudioInterruptionHandling];
+        
+        // Prepare and play
+        BOOL prepared = [self->_busyTonePlayer prepareToPlay];
+        if (!prepared) {
+            NSString *errorMsg = @"Failed to prepare audio player";
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_PLAYER_ERROR", errorMsg, nil);
+            return;
+        }
+        
+        BOOL playing = [self->_busyTonePlayer play];
+        if (playing) {
+            resolve(@YES);
+        } else {
+            NSString *errorMsg = @"Failed to start audio playback";
+            NSLog(@"%@", errorMsg);
+            reject(@"AUDIO_PLAYBACK_ERROR", errorMsg, nil);
+        }
+    });
+}
+
+- (NSData *)generateBusyToneData {
+    // Generate 1 second of busy tone pattern: 0.5s 480Hz tone, 0.5s silence
+    const int sampleRate = 44100; // Standard sample rate for better quality
+    const float duration = 1.0; // 1 second total
+    const float beepDuration = 0.5; // 0.5 seconds beep
+    const float frequency = 480.0; // 480 Hz busy tone frequency
+    
+    int totalSamples = (int)(duration * sampleRate);
+    
+    // Create PCM data buffer with proper size calculation
+    NSMutableData *audioData = [NSMutableData dataWithLength:44 + totalSamples * 2]; // WAV header + 16-bit samples
+    uint8_t *bytes = (uint8_t *)[audioData mutableBytes];
+    
+    // Helper function to write little-endian values
+    void (^writeLittleEndian32)(uint8_t *, uint32_t) = ^(uint8_t *dest, uint32_t value) {
+        dest[0] = value & 0xFF;
+        dest[1] = (value >> 8) & 0xFF;
+        dest[2] = (value >> 16) & 0xFF;
+        dest[3] = (value >> 24) & 0xFF;
+    };
+    
+    void (^writeLittleEndian16)(uint8_t *, uint16_t) = ^(uint8_t *dest, uint16_t value) {
+        dest[0] = value & 0xFF;
+        dest[1] = (value >> 8) & 0xFF;
+    };
+    
+    // Write WAV header with proper endianness
+    memcpy(bytes, "RIFF", 4);
+    writeLittleEndian32(bytes + 4, 36 + totalSamples * 2);
+    memcpy(bytes + 8, "WAVE", 4);
+    memcpy(bytes + 12, "fmt ", 4);
+    writeLittleEndian32(bytes + 16, 16); // PCM format chunk size
+    writeLittleEndian16(bytes + 20, 1);  // PCM format
+    writeLittleEndian16(bytes + 22, 1);  // Mono
+    writeLittleEndian32(bytes + 24, sampleRate);
+    writeLittleEndian32(bytes + 28, sampleRate * 2); // Bytes per second
+    writeLittleEndian16(bytes + 32, 2);  // Bytes per sample
+    writeLittleEndian16(bytes + 34, 16); // Bits per sample
+    memcpy(bytes + 36, "data", 4);
+    writeLittleEndian32(bytes + 40, totalSamples * 2);
+    
+    // Generate audio samples
+    int16_t *samples = (int16_t *)(bytes + 44);
+    for (int i = 0; i < totalSamples; i++) {
+        float t = (float)i / sampleRate;
+        float cycleTime = fmod(t, duration); // Time within current cycle
+        
+        if (cycleTime < beepDuration) {
+            // Generate 480Hz sine wave with proper amplitude
+            float sineWave = sinf(2.0f * M_PI * frequency * t);
+            float amplitude = 0.4f * sineWave; // Increased amplitude for better audibility
+            samples[i] = CFSwapInt16HostToLittle((int16_t)(amplitude * 32767.0f));
+        } else {
+            // Silence period
+            samples[i] = 0;
+        }
+    }
+    
+    return audioData;
+}
+
+RCT_EXPORT_METHOD(stopBusyTone:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self stopBusyTone];
+        resolve(@YES);
+    });
+}
+
+- (void)stopBusyTone {
+    if (_busyTonePlayer) {
+        if (_busyTonePlayer.isPlaying) {
+            [_busyTonePlayer stop];
+        }
+        
+        _busyTonePlayer = nil;
+        
+        // Remove audio interruption observers
+        [self removeAudioInterruptionHandling];
+        
+        // Only deactivate audio session if there are no active calls
+        // This prevents interfering with ongoing WebRTC audio sessions
+        BOOL hasActiveCall = [StreamVideoReactNative hasAnyActiveCall];
+        if (!hasActiveCall) {
+            NSError *error = nil;
+            [[AVAudioSession sharedInstance] setActive:NO
+                                           withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
+                                                 error:&error];
+                if (error) {
+                    NSLog(@"Error deactivating audio session: %@", error.localizedDescription);
+                }
+            }
+        }
+}
+
+#pragma mark - AVAudioPlayerDelegate
+
+- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag {
+    // Audio finished - this shouldn't happen with infinite loops
+    // Check if this is our player and handle cleanup if needed
+    if (player == _busyTonePlayer) {
+        _busyTonePlayer = nil;
+    }
+}
+
+- (void)audioPlayerDecodeErrorDidOccur:(AVAudioPlayer *)player error:(NSError *)error {
+    if (player == _busyTonePlayer) {
+        _busyTonePlayer = nil;
+    }
+}
+
+// Note: audioPlayerBeginInterruption and audioPlayerEndInterruption are deprecated
+// Audio interruptions are now handled via AVAudioSession notifications
+// These are registered in setupAudioInterruptionHandling method
+
+#pragma mark - Audio Interruption Handling
+
+- (void)setupAudioInterruptionHandling {
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(audioSessionInterrupted:)
+                                                 name:AVAudioSessionInterruptionNotification
+                                               object:[AVAudioSession sharedInstance]];
+}
+
+- (void)removeAudioInterruptionHandling {
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:AVAudioSessionInterruptionNotification
+                                                  object:[AVAudioSession sharedInstance]];
+}
+
+- (void)audioSessionInterrupted:(NSNotification *)notification {
+    AVAudioSessionInterruptionType interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
+    
+    switch (interruptionType) {
+        case AVAudioSessionInterruptionTypeBegan:
+            if (_busyTonePlayer && _busyTonePlayer.isPlaying) {
+                [_busyTonePlayer pause];
+            }
+            break;
+            
+        case AVAudioSessionInterruptionTypeEnded: {
+            AVAudioSessionInterruptionOptions options = [notification.userInfo[AVAudioSessionInterruptionOptionKey] unsignedIntegerValue];
+            
+            if (options & AVAudioSessionInterruptionOptionShouldResume) {
+                // Reactivate audio session
+                NSError *error = nil;
+                [[AVAudioSession sharedInstance] setActive:YES error:&error];
+                
+                if (!error && _busyTonePlayer) {
+                    [_busyTonePlayer play];
+                } else if (error) {
+                    NSLog(@"Failed to reactivate audio session after interruption: %@", error.localizedDescription);
+                }
+            }
+            break;
+        }
+    }
+}
+
 @end

package/ios/StreamVideoReactNative.xcodeproj/project.pbxproj

@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 46;
+	objectVersion = 70;
 	objects = {
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -42,6 +42,21 @@
 		F4FF95D5245B92E700C19C63 /* StreamVideoReactNative-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "StreamVideoReactNative-Bridging-Header.h"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
+/* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
+		05DBB1DF2E6B3F0600309346 /* PBXFileSystemSynchronizedBuildFileExceptionSet */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				busy.mp3,
+			);
+			target = 58B511DA1A9E6C8500147676 /* StreamVideoReactNative */;
+		};
+/* End PBXFileSystemSynchronizedBuildFileExceptionSet section */
+
+/* Begin PBXFileSystemSynchronizedRootGroup section */
+		05DBB1DA2E6B3ECE00309346 /* New Folder */ = {isa = PBXFileSystemSynchronizedRootGroup; explicitFileTypes = {}; explicitFolders = (); path = "New Folder"; sourceTree = "<group>"; };
+		05DBB1DB2E6B3EEC00309346 /* Resources */ = {isa = PBXFileSystemSynchronizedRootGroup; exceptions = (05DBB1DF2E6B3F0600309346 /* PBXFileSystemSynchronizedBuildFileExceptionSet */, ); explicitFileTypes = {}; explicitFolders = (); path = Resources; sourceTree = "<group>"; };
+/* End PBXFileSystemSynchronizedRootGroup section */
+
 /* Begin PBXFrameworksBuildPhase section */
 		58B511D81A9E6C8500147676 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
@@ -64,6 +79,8 @@
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
+				05DBB1DB2E6B3EEC00309346 /* Resources */,
+				05DBB1DA2E6B3ECE00309346 /* New Folder */,
 				DDCF7DCC2C90359D00420842 /* PictureInPicture */,
 				DDCF7DCA2C90359D00420842 /* RTCViewPip.swift */,
 				DDCF7DC92C90359D00420842 /* RTCViewPipManager.mm */,
@@ -114,6 +131,7 @@
 				58B511D71A9E6C8500147676 /* Sources */,
 				58B511D81A9E6C8500147676 /* Frameworks */,
 				58B511D91A9E6C8500147676 /* CopyFiles */,
+				05DBB1DD2E6B3F0100309346 /* Resources */,
 			);
 			buildRules = (
 			);
@@ -156,6 +174,16 @@
 		};
 /* End PBXProject section */
 
+/* Begin PBXResourcesBuildPhase section */
+		05DBB1DD2E6B3F0100309346 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
 /* Begin PBXSourcesBuildPhase section */
 		58B511D71A9E6C8500147676 /* Sources */ = {
 			isa = PBXSourcesBuildPhase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-react-native-sdk",
-  "version": "1.20.16",
+  "version": "1.21.0",
   "description": "Stream Video SDK for React Native",
   "author": "https://getstream.io",
   "homepage": "https://getstream.io/video/docs/react-native/",
@@ -45,8 +45,8 @@
     "!**/.*"
   ],
   "dependencies": {
-    "@stream-io/video-client": "1.31.0",
-    "@stream-io/video-react-bindings": "1.8.3",
+    "@stream-io/video-client": "1.32.0",
+    "@stream-io/video-react-bindings": "1.8.4",
     "intl-pluralrules": "2.0.1",
     "lodash.merge": "^4.6.2",
     "react-native-url-polyfill": "1.3.0",
@@ -125,9 +125,9 @@
     "@react-native-firebase/app": "^22.1.0",
     "@react-native-firebase/messaging": "^22.1.0",
     "@react-native/babel-preset": "^0.79.2",
-    "@stream-io/noise-cancellation-react-native": "^0.2.4",
+    "@stream-io/noise-cancellation-react-native": "^0.3.0",
     "@stream-io/react-native-webrtc": "125.4.3",
-    "@stream-io/video-filters-react-native": "^0.6.3",
+    "@stream-io/video-filters-react-native": "^0.7.0",
     "@testing-library/jest-native": "^5.4.3",
     "@testing-library/react-native": "13.2.0",
     "@tsconfig/node14": "14.1.3",

package/src/components/Participant/ParticipantView/VideoRenderer.tsx

@@ -104,12 +104,7 @@ export const VideoRenderer = ({
     isParticipantVideoEnabled(participant.sessionId);
 
   useEffect(() => {
-    if (
-      Platform.OS === 'ios' &&
-      registerIosScreenshot &&
-      viewRef.current &&
-      canShowVideo
-    ) {
+    if (Platform.OS === 'ios' && registerIosScreenshot && canShowVideo) {
       registerIosScreenshot(participant, trackType, viewRef);
       return () => {
         deregisterIosScreenshot(participant, trackType);

package/src/providers/BusyTonePlayer.tsx

@@ -0,0 +1,71 @@
+import { useEffect } from 'react';
+import { useStreamVideoClient } from '@stream-io/video-react-bindings';
+import { StreamVideoRN } from '../utils';
+import { getLogger } from '@stream-io/video-client';
+
+const BUSY_TONE_DURATION_IN_MS = 1500;
+
+/**
+ * This is a renderless component to play a busy tone for call rejection when the callee is busy for the user's outgoing call.
+ */
+const BusyTonePlayer = () => {
+  const client = useStreamVideoClient();
+
+  useEffect(() => {
+    if (!client) {
+      return;
+    }
+
+    const unsubscribe = client.on('call.rejected', async (event) => {
+      const isCallCreatedByMe =
+        event.call.created_by.id === client.state.connectedUser?.id;
+      const isCalleeBusy = isCallCreatedByMe && event.reason === 'busy';
+
+      let busyToneTimeout: ReturnType<typeof setTimeout> | undefined;
+
+      const logger = getLogger(['RejectCallWhenBusy']);
+
+      if (isCalleeBusy) {
+        if (busyToneTimeout) {
+          clearTimeout(busyToneTimeout);
+          busyToneTimeout = undefined;
+        }
+        logger(
+          'info',
+          `Playing busy tone for call rejection for call cid: ${event.call.cid}`,
+        );
+
+        StreamVideoRN.playBusyTone()
+          .then(() => {
+            busyToneTimeout = setTimeout(() => {
+              StreamVideoRN.stopBusyTone()
+                .then(() => {
+                  logger(
+                    'info',
+                    `Stopped busy tone for call rejection for call cid: ${event.call.cid}`,
+                  );
+                })
+                .catch((error) =>
+                  logger('error', 'stopBusyTone failed:', error),
+                );
+              busyToneTimeout = undefined;
+            }, BUSY_TONE_DURATION_IN_MS);
+          })
+          .catch((error) => {
+            logger('error', 'playBusyTone failed:', error);
+          });
+      }
+      return () => {
+        StreamVideoRN.stopBusyTone().catch((err) =>
+          logger('error', 'stopBusyTone on cleanup failed:', err),
+        );
+        clearTimeout(busyToneTimeout);
+        unsubscribe();
+      };
+    });
+  }, [client]);
+
+  return null;
+};
+
+export default BusyTonePlayer;

package/src/providers/StreamVideo.tsx

@@ -10,6 +10,7 @@ import { translations } from '../translations';
 import { type DeepPartial, StreamTheme } from '../contexts/ThemeContext';
 import { type Theme } from '../theme/theme';
 import { ScreenshotIosContextProvider } from '../contexts/internal/ScreenshotIosContext';
+import BusyTonePlayer from './BusyTonePlayer';
 
 /**
  *
@@ -59,11 +60,10 @@ export const StreamVideo = (
       translationsOverrides={translationsOverrides}
       i18nInstance={i18nInstance}
     >
+      <PushRegister />
+      <BusyTonePlayer />
       <StreamTheme style={style}>
-        <ScreenshotIosContextProvider>
-          <PushRegister />
-          {children}
-        </ScreenshotIosContextProvider>
+        <ScreenshotIosContextProvider>{children}</ScreenshotIosContextProvider>
       </StreamTheme>
     </StreamVideoProvider>
   );

package/src/utils/StreamVideoRN/index.ts

@@ -5,6 +5,7 @@ import newNotificationCallbacks, {
 } from '../internal/newNotificationCallbacks';
 import { setupIosCallKeepEvents } from '../push/setupIosCallKeepEvents';
 import { setupIosVoipPushEvents } from '../push/setupIosVoipPushEvents';
+import { NativeModules } from 'react-native';
 
 // Utility type for deep partial
 type DeepPartial<T> = {
@@ -62,6 +63,7 @@ const DEFAULT_STREAM_VIDEO_CONFIG: StreamVideoConfig = {
 
 export class StreamVideoRN {
   private static config = DEFAULT_STREAM_VIDEO_CONFIG;
+  private static busyToneTimeout: NodeJS.Timeout | null = null;
 
   /**
    * Update the global config for StreamVideoRN except for push config.
@@ -164,4 +166,18 @@ export class StreamVideoRN {
         newNotificationCallbacks.current?.filter((cb) => cb !== callback);
     };
   }
+
+  /**
+   * Play native busy tone for call rejection
+   */
+  static async playBusyTone() {
+    return NativeModules.StreamVideoReactNative?.playBusyTone();
+  }
+
+  /**
+   * Stop native busy tone
+   */
+  static async stopBusyTone() {
+    return NativeModules.StreamVideoReactNative?.stopBusyTone();
+  }
 }

package/src/utils/StreamVideoRN/types.ts

@@ -24,6 +24,7 @@ export type StreamVideoConfig = {
      * @internal
      */
     publishOptions?: ClientPublishOptions;
+
     ios: {
       /**
        * The name for the alias of push provider used for iOS

package/src/utils/push/android.ts

@@ -169,6 +169,9 @@ export const firebaseDataHandler = async (
     const created_by_id = data.created_by_id as string;
     const receiver_id = data.receiver_id as string;
 
+    const video_client = await pushConfig.createStreamVideoClient();
+    await video_client?.onRingingCall(call_cid);
+
     const shouldCallBeClosed = (callToCheck: Call) => {
       const { mustEndCall } = shouldCallBeEnded(
         callToCheck,

package/src/utils/push/internal/ios.ts

@@ -46,6 +46,7 @@ export const onVoipNotificationReceived = async (
   }
   const logger = getLogger(['setupIosVoipPushEvents']);
   const client = await pushConfig.createStreamVideoClient();
+
   if (!client) {
     logger(
       'debug',
@@ -53,6 +54,13 @@ export const onVoipNotificationReceived = async (
     );
     return;
   }
+  const shouldRejectCallWhenBusy = client['rejectCallWhenBusy'] ?? false;
+  if (shouldRejectCallWhenBusy) {
+    // inform the iOS native module that we should reject call when busy
+    NativeModules.StreamVideoReactNative.setShouldRejectCallWhenBusy(
+      shouldRejectCallWhenBusy,
+    );
+  }
   const callFromPush = await client.onRingingCall(call_cid);
   let uuid = '';
   try {

package/src/utils/push/setupIosVoipPushEvents.ts

@@ -13,11 +13,11 @@ export function setupIosVoipPushEvents(
     return;
   }
   const logger = getLogger(['setupIosVoipPushEvents']);
-  if (!pushConfig.android.incomingCallChannel) {
+  if (!pushConfig.ios.pushProviderName) {
     // 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 setupIosVoipPushEvents',
+      'ios pushProviderName is not defined, so skipping the setupIosVoipPushEvents',
     );
     return;
   }

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.20.16';
+export const version = '1.21.0';