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/providers/StreamCall/RejectCallWhenBusy.tsx

@@ -0,0 +1,68 @@
+import { useEffect } from 'react';
+import {
+  useCalls,
+  useStreamVideoClient,
+} from '@stream-io/video-react-bindings';
+import { CallingState, getLogger } from '@stream-io/video-client';
+import InCallManager from 'react-native-incall-manager';
+import { StreamVideoRN } from '../../utils';
+import { Platform } from 'react-native';
+
+/**
+ * This is a renderless component to reject calls when the user is busy.
+ */
+export const RejectCallWhenBusy = () => {
+  const client = useStreamVideoClient();
+  const calls = useCalls();
+
+  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(['RejectCallWhenBusy']);
+          logger('error', 'Error rejecting Call when busy', err);
+        });
+      });
+    }
+  }, [calls, shouldRejectCallWhenBusy]);
+
+  return null;
+};

packages/react-native-sdk/src/providers/StreamCall/index.tsx

@@ -9,6 +9,7 @@ import {
 import { useAndroidKeepCallAliveEffect } from '../../hooks/useAndroidKeepCallAliveEffect';
 import { AppStateListener } from './AppStateListener';
 import { DeviceStats } from './DeviceStats';
+import { RejectCallWhenBusy } from './RejectCallWhenBusy';
 
 // const PIP_CHANGE_EVENT = 'StreamVideoReactNative_PIP_CHANGE_EVENT';
 
@@ -39,6 +40,7 @@ export const StreamCall = ({
       <IosInformCallkeepCallEnd />
       <ClearPushWSSubscriptions />
       <DeviceStats />
+      <RejectCallWhenBusy />
       {children}
     </StreamCallProvider>
   );

packages/react-native-sdk/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, Platform } from 'react-native';
 
 // Utility type for deep partial
 type DeepPartial<T> = {
@@ -121,6 +122,12 @@ export class StreamVideoRN {
 
     this.config.push = pushConfig;
 
+    // Configure native iOS module if shouldRejectCallWhenBusy is set
+    if (Platform.OS === 'ios') {
+      NativeModules.StreamVideoReactNative?.setShouldRejectCallWhenBusy(
+        pushConfig?.shouldRejectCallWhenBusy ?? false,
+      );
+    }
     setupIosCallKeepEvents(pushConfig);
     setupIosVoipPushEvents(pushConfig);
   }

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/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 hasAnyActiveCall = StreamVideoReactNative.hasAnyActiveCall()
+
+    if shouldReject && hasAnyActiveCall {
+        // 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