feat(react-native): reject call when busy

packages/react-native-sdk/ios/StreamVideoReactNative.h

@@ -8,4 +8,10 @@
 
 + (void)setup DEPRECATED_MSG_ATTRIBUTE("No need to use setup() anymore");
 
++ (BOOL)shouldRejectCallWhenBusy;
+
++ (void)setShouldRejectCallWhenBusy:(BOOL)shouldReject;
+
++ (BOOL)hasAnyActiveCall;
+
 @end

packages/react-native-sdk/ios/StreamVideoReactNative.m

@@ -2,6 +2,7 @@
 #import <React/RCTEventEmitter.h>
 #import <React/RCTUIManager.h> 
 #import <UIKit/UIKit.h>
+#import <CallKit/CallKit.h>
 #import "StreamVideoReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
@@ -14,6 +15,8 @@
 static NSMutableDictionary *_incomingCallCidsByUUID = nil;
 static dispatch_queue_t _dictionaryQueue = nil;
 
+static BOOL _shouldRejectCallWhenBusy = NO;
+
 void broadcastNotificationCallback(CFNotificationCenterRef center,
                                    void *observer,
                                    CFStringRef name,
@@ -325,4 +328,28 @@ +(void)registerIncomingCall:(NSString *)cid uuid:(NSString *)uuid {
     return @[@"StreamVideoReactNative_Ios_Screenshare_Event", @"isLowPowerModeEnabled", @"thermalStateDidChange"];
 }
 
++(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;
+}
+
 @end

packages/react-native-sdk/src/components/Call/RingingCallContent/RingingCallContent.tsx

@@ -1,7 +1,12 @@
-import { CallingState } from '@stream-io/video-client';
-import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
-import React from 'react';
-import { StyleSheet, View } from 'react-native';
+import React, { useEffect } from 'react';
+import { CallingState, getLogger } from '@stream-io/video-client';
+import {
+  useCall,
+  useCallStateHooks,
+  useCalls,
+  useStreamVideoClient,
+} from '@stream-io/video-react-bindings';
+import { Platform, StyleSheet, View } from 'react-native';
 import {
   CallContent as DefaultCallContent,
   type CallContentProps,
@@ -23,6 +28,8 @@ import {
   type CallPreparingIndicatorProps,
 } from './CallPreparingIndicator';
 import { useTheme } from '../../../contexts';
+import InCallManager from 'react-native-incall-manager';
+import { StreamVideoRN } from '../../../utils/StreamVideoRN';
 
 /**
  * Props for the RingingCallContent component
@@ -70,10 +77,61 @@ const RingingCallPanel = ({
   onBackPress,
 }: RingingCallContentProps) => {
   const call = useCall();
+  const calls = useCalls();
   const isCallCreatedByMe = call?.isCreatedByMe;
 
   const { useCallCallingState } = useCallStateHooks();
   const callingState = useCallCallingState();
+  const client = useStreamVideoClient();
+
+  useEffect(() => {
+    if (!client) return;
+    return client?.on('call.rejected', async (event) => {
+      // Workaround needed for the busy tone:
+      // This is because the call was rejected without even starting,
+      // before calling the stop method with busy tone we need to start the call first.
+      InCallManager.start({ media: 'audio' });
+
+      const callCid = event.call_cid;
+      const callId = callCid.split(':')[1];
+      if (!callId) return;
+
+      const rejectedCall = client?.call(event.call.type, callId);
+      await rejectedCall?.getOrCreate();
+
+      const isCalleeBusy =
+        rejectedCall && rejectedCall.isCreatedByMe && event.reason === 'busy';
+
+      if (isCalleeBusy) {
+        InCallManager.stop({ busytone: '_DTMF_' });
+      }
+    });
+  }, [client]);
+
+  const pushConfig = StreamVideoRN.getConfig().push;
+  const shouldRejectCallWhenBusy = pushConfig?.shouldRejectCallWhenBusy;
+
+  useEffect(() => {
+    // android rejection is done in android's firebaseDataHandler
+    if (Platform.OS === 'android') return;
+    if (!shouldRejectCallWhenBusy) return;
+
+    const ringingCallsInProgress = calls.filter(
+      (c) => c.ringing && c.state.callingState === CallingState.JOINED,
+    );
+    const callsForRejection = calls.filter(
+      (c) => c.ringing && c.state.callingState === CallingState.RINGING,
+    );
+    const alreadyInAnotherRingingCall = ringingCallsInProgress.length > 0;
+    if (callsForRejection.length > 0 && alreadyInAnotherRingingCall) {
+      callsForRejection.forEach((c) => {
+        c.leave({ reject: true, reason: 'busy' }).catch((err) => {
+          const logger = getLogger(['RingingCallContent']);
+          logger('error', 'Error rejecting Call when busy', err);
+        });
+      });
+    }
+  }, [calls, call, shouldRejectCallWhenBusy, callingState]);
 
   switch (callingState) {
     case CallingState.RINGING:

packages/react-native-sdk/src/utils/StreamVideoRN/types.ts

@@ -24,6 +24,13 @@ export type StreamVideoConfig = {
      * @internal
      */
     publishOptions?: ClientPublishOptions;
+
+    /**
+     * Whether to reject the call when the user is busy.
+     * @default false
+     */
+    shouldRejectCallWhenBusy?: boolean;
+
     ios: {
       /**
        * The name for the alias of push provider used for iOS

packages/react-native-sdk/src/utils/push/android.ts

@@ -169,6 +169,36 @@ export const firebaseDataHandler = async (
     const created_by_id = data.created_by_id as string;
     const receiver_id = data.receiver_id as string;
 
+    const shouldRejectCallWhenBusy = pushConfig.shouldRejectCallWhenBusy;
+
+    const video_client = await pushConfig.createStreamVideoClient();
+    if (video_client && shouldRejectCallWhenBusy) {
+      try {
+        const calls = video_client.state.calls;
+        const ringingCallsInProgress = calls.filter(
+          (c) => c.ringing && c.state.callingState === CallingState.JOINED,
+        );
+
+        if (ringingCallsInProgress.length > 0) {
+          getLogger(['firebaseDataHandler'])(
+            'debug',
+            `User is already in a call. Silently rejecting incoming call: ${call_cid}`,
+          );
+
+          const callFromPush = await video_client.onRingingCall(call_cid);
+          await callFromPush.leave({ reject: true, reason: 'busy' });
+
+          return;
+        }
+      } catch (err) {
+        getLogger(['firebaseDataHandler'])(
+          'error',
+          'Error checking if user is already in a call',
+          err,
+        );
+      }
+    }
+
     const shouldCallBeClosed = (callToCheck: Call) => {
       const { mustEndCall } = shouldCallBeEnded(
         callToCheck,

sample-apps/react-native/dogfood/App.tsx

@@ -40,6 +40,7 @@ import {
   isPushNotificationiOSStreamVideoEvent,
   onPushNotificationiOSStreamVideoEvent,
   StreamTheme,
+  StreamVideoRN,
   useCalls,
 } from '@stream-io/video-react-native-sdk';
 import Toast from 'react-native-toast-message';
@@ -188,17 +189,19 @@ const StackNavigator = () => {
 const RingingWatcher = () => {
   const setState = useAppGlobalStoreSetState();
   const calls = useCalls().filter((c) => c.ringing);
+  const shouldRejectCallWhenBusy =
+    StreamVideoRN.getConfig().push?.shouldRejectCallWhenBusy;
 
   useEffect(() => {
-    if (calls.length > 1) {
+    if (!shouldRejectCallWhenBusy && calls.length > 1) {
       const lastCallCreatedBy = calls.at(-1)?.state.createdBy;
       Alert.alert(
         `Incoming call from ${
           lastCallCreatedBy?.name ?? lastCallCreatedBy?.id
         }, only 1 call at a time is supported`,
       );
     }
-  }, [calls]);
+  }, [calls, shouldRejectCallWhenBusy]);
 
   const firstCall = calls[0];
 

sample-apps/react-native/dogfood/ios/AppDelegate.swift

@@ -75,7 +75,17 @@ class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterD
       completion() // Ensure completion handler is called even if parsing fails
       return
     }
-
+
+    // Check if user is busy BEFORE registering the call
+    let shouldReject = StreamVideoReactNative.shouldRejectCallWhenBusy()
+    let hasActiveCall = StreamVideoReactNative.hasAnyActiveCall()
+
+    if shouldReject && hasActiveCall {
+        // Complete the VoIP notification without showing CallKit UI
+        completion()
+        return
+    }
+
     let uuid = UUID().uuidString
     let videoIncluded = stream["video"] as? String
     let hasVideo = videoIncluded == "false" ? false : true