feat(voip): call waiting, busy detection, and videoconf blocking

android/app/src/main/java/chat/rocket/reactnative/voip/VoipNotification.kt

@@ -1,14 +1,17 @@
 package chat.rocket.reactnative.voip
 
+import android.Manifest
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.media.AudioAttributes
+import android.media.AudioManager
 import android.media.RingtoneManager
 import android.os.Build
 import android.os.Bundle
@@ -17,6 +20,7 @@ import android.os.Looper
 import android.provider.Settings
 import android.util.Log
 import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import android.content.ComponentName
 import android.net.Uri
@@ -477,6 +481,70 @@ class VoipNotification(private val context: Context) {
             }
         }
 
+        /**
+         * True when the user is already in a call: this app's Telecom connections (ringing, dialing,
+         * active, hold — same idea as iOS CXCallObserver "any non-ended"), any system in-call state
+         * (API 26+ when READ_PHONE_STATE is granted), or audio in communication mode (fallback on all
+         * API levels when Telecom is unavailable or denied).
+         */
+        private fun hasActiveCall(context: Context): Boolean {
+            val ownBusy = VoiceConnectionService.currentConnections.values.any { connection ->
+                when (connection.state) {
+                    android.telecom.Connection.STATE_RINGING,
+                    android.telecom.Connection.STATE_DIALING,
+                    android.telecom.Connection.STATE_ACTIVE,
+                    android.telecom.Connection.STATE_HOLDING -> true
+                    else -> false
+                }
+            }
+            if (ownBusy) {
+                return true
+            }
+            return hasSystemLevelActiveCallIndicators(context)
+        }
+
+        /**
+         * Telecom in-call check (API 26+) requires [READ_PHONE_STATE]; without it, [TelecomManager.isInCall]
+         * can throw [SecurityException]. Always falls back to [AudioManager.MODE_IN_COMMUNICATION] on all APIs.
+         */
+        private fun hasSystemLevelActiveCallIndicators(context: Context): Boolean {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val granted = ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE) ==
+                    PackageManager.PERMISSION_GRANTED
+                if (granted) {
+                    val telecom = context.getSystemService(Context.TELECOM_SERVICE) as? TelecomManager
+                    try {
+                        if (telecom?.isInCall == true) {
+                            return true
+                        }
+                    } catch (e: SecurityException) {
+                        Log.w(TAG, "TelecomManager.isInCall not allowed", e)
+                    }
+                }
+            }
+            val audio = context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+            if (audio?.mode == AudioManager.MODE_IN_COMMUNICATION) {
+                return true
+            }
+            return false
+        }
+
+        /**
+         * Rejects an incoming call because the user is already on another call.
+         * Sends a reject signal via DDP and cleans up without showing any UI.
+         */
+        @JvmStatic
+        fun rejectBusyCall(context: Context, payload: VoipPayload) {
+            Log.d(TAG, "Rejected busy call ${payload.callId} — user already on a call")
+            cancelTimeout(payload.callId)
+            startListeningForCallEnd(context, payload)
+            if (isDdpLoggedIn) {
+                sendRejectSignal(context, payload)
+            } else {
+                queueRejectSignal(context, payload)
+            }
+        }
+
         // -- Native DDP Listener (Call End Detection) --
 
         @JvmStatic
@@ -613,7 +681,13 @@ class VoipNotification(private val context: Context) {
 
     fun onMessageReceived(voipPayload: VoipPayload) {
         when {
-            voipPayload.isVoipIncomingCall() -> showIncomingCall(voipPayload)
+            voipPayload.isVoipIncomingCall() -> {
+                if (hasActiveCall(context)) {
+                    rejectBusyCall(context, voipPayload)
+                } else {
+                    showIncomingCall(voipPayload)
+                }
+            }
             else -> Log.w(TAG, "Ignoring unsupported VoIP payload type: ${voipPayload.type}")
         }
     }

app/i18n/locales/en.json

@@ -662,6 +662,8 @@
   "Permalink_copied_to_clipboard": "Permalink copied to clipboard!",
   "Person_or_channel": "Person or channel",
   "Phone": "Phone",
+  "Phone_state_permission_message": "This lets Rocket.Chat detect when you are already on a phone or VoIP call so incoming calls can be handled correctly.",
+  "Phone_state_permission_title": "Allow phone state access",
   "Pin": "Pin",
   "Pinned": "Pinned",
   "Pinned_a_message": "Pinned a message:",

app/lib/methods/voipPhoneStatePermission.test.ts

@@ -0,0 +1,62 @@
+import { PermissionsAndroid } from 'react-native';
+
+describe('requestPhoneStatePermission', () => {
+	afterEach(() => {
+		jest.restoreAllMocks();
+	});
+
+	it('does not call PermissionsAndroid.request when not on Android', () => {
+		jest.resetModules();
+		jest.doMock('./helpers', () => ({
+			...jest.requireActual<typeof import('./helpers')>('./helpers'),
+			isAndroid: false
+		}));
+		const spy = jest.spyOn(PermissionsAndroid, 'request').mockResolvedValue('granted' as never);
+		const { requestPhoneStatePermission } = require('./voipPhoneStatePermission');
+
+		requestPhoneStatePermission();
+
+		expect(spy).not.toHaveBeenCalled();
+	});
+
+	it('requests READ_PHONE_STATE on Android with i18n rationale keys', () => {
+		jest.resetModules();
+		jest.doMock('../../i18n', () => ({
+			__esModule: true,
+			default: { t: (key: string) => key }
+		}));
+		jest.doMock('./helpers', () => ({
+			...jest.requireActual<typeof import('./helpers')>('./helpers'),
+			isAndroid: true
+		}));
+		const spy = jest.spyOn(PermissionsAndroid, 'request').mockResolvedValue('granted' as never);
+		const { requestPhoneStatePermission } = require('./voipPhoneStatePermission');
+
+		requestPhoneStatePermission();
+
+		expect(spy).toHaveBeenCalledWith(PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE, {
+			buttonPositive: 'Ok',
+			message: 'Phone_state_permission_message',
+			title: 'Phone_state_permission_title'
+		});
+	});
+
+	it('does not prompt again in the same session on Android', () => {
+		jest.resetModules();
+		jest.doMock('../../i18n', () => ({
+			__esModule: true,
+			default: { t: (key: string) => key }
+		}));
+		jest.doMock('./helpers', () => ({
+			...jest.requireActual<typeof import('./helpers')>('./helpers'),
+			isAndroid: true
+		}));
+		const spy = jest.spyOn(PermissionsAndroid, 'request').mockResolvedValue('granted' as never);
+		const { requestPhoneStatePermission } = require('./voipPhoneStatePermission');
+
+		requestPhoneStatePermission();
+		requestPhoneStatePermission();
+
+		expect(spy).toHaveBeenCalledTimes(1);
+	});
+});

app/lib/methods/voipPhoneStatePermission.ts

@@ -0,0 +1,22 @@
+import { PermissionsAndroid } from 'react-native';
+
+import i18n from '../../i18n';
+import { isAndroid } from './helpers';
+
+let askedThisSession = false;
+
+export const requestPhoneStatePermission = (): void => {
+	if (!isAndroid) {
+		return;
+	}
+	if (askedThisSession) {
+		return;
+	}
+	askedThisSession = true;
+
+	PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE, {
+		buttonPositive: 'Ok',
+		message: i18n.t('Phone_state_permission_message'),
+		title: i18n.t('Phone_state_permission_title')
+	});
+};