feat(voip): migrate iOS accept/reject from DDP to REST

app/lib/methods/helpers/index.ts

@@ -8,6 +8,7 @@ export * from './getAvatarUrl';
 export * from './info';
 export * from './isReadOnly';
 export * from './media';
+export * from './normalizeDeepLinkingServerHost';
 export * from './room';
 export * from './server';
 export * from './isSsl';

app/lib/methods/helpers/normalizeDeepLinkingServerHost.test.ts

@@ -0,0 +1,24 @@
+import { normalizeDeepLinkingServerHost } from './normalizeDeepLinkingServerHost';
+
+describe('normalizeDeepLinkingServerHost', () => {
+	it('returns empty string for empty input', () => {
+		expect(normalizeDeepLinkingServerHost('')).toBe('');
+	});
+
+	it('adds https for host without scheme', () => {
+		expect(normalizeDeepLinkingServerHost('open.rocket.chat')).toBe('https://open.rocket.chat');
+	});
+
+	it('uses http for localhost', () => {
+		expect(normalizeDeepLinkingServerHost('localhost')).toBe('http://localhost');
+		expect(normalizeDeepLinkingServerHost('localhost:3000')).toBe('http://localhost:3000');
+	});
+
+	it('upgrades http to https for non-localhost', () => {
+		expect(normalizeDeepLinkingServerHost('http://example.com')).toBe('https://example.com');
+	});
+
+	it('strips trailing slash', () => {
+		expect(normalizeDeepLinkingServerHost('https://example.com/')).toBe('https://example.com');
+	});
+});

app/lib/methods/helpers/normalizeDeepLinkingServerHost.ts

@@ -0,0 +1,23 @@
+/**
+ * Normalize a Rocket.Chat server base URL for deep linking and VoIP host comparison.
+ * Matches the historical behavior in `app/sagas/deepLinking.js` (`handleOpen` host handling).
+ */
+export function normalizeDeepLinkingServerHost(rawHost: string): string {
+	let host = rawHost;
+	if (!host) {
+		return '';
+	}
+	if (!/^(http|https)/.test(host)) {
+		if (/^localhost(:\d+)?/.test(host)) {
+			host = `http://${host}`;
+		} else {
+			host = `https://${host}`;
+		}
+	} else {
+		host = host.replace('http://', 'https://');
+	}
+	if (host.slice(-1) === '/') {
+		host = host.slice(0, host.length - 1);
+	}
+	return host;
+}

app/lib/services/voip/MediaCallEvents.test.ts

@@ -18,10 +18,12 @@ jest.mock('../../methods/helpers', () => ({
 	isIOS: false
 }));
 
+const mockServerSelector = jest.fn(() => 'https://workspace-a.example.com');
 jest.mock('../../store', () => ({
 	__esModule: true,
 	default: {
-		dispatch: (...args: unknown[]) => mockDispatch(...args)
+		dispatch: (...args: unknown[]) => mockDispatch(...args),
+		getState: () => ({ server: { server: mockServerSelector() } })
 	}
 }));
 
@@ -51,7 +53,8 @@ jest.mock('react-native-callkeep', () => ({
 
 jest.mock('./MediaSessionInstance', () => ({
 	mediaSessionInstance: {
-		endCall: jest.fn()
+		endCall: jest.fn(),
+		applyRestStateSignals: jest.fn(() => Promise.resolve())
 	}
 }));
 
@@ -127,6 +130,21 @@ describe('MediaCallEvents cross-server accept (slice 3)', () => {
 				});
 			});
 
+			it('skips deepLinkingOpen and replays REST state signals when host matches active workspace', () => {
+				const { mediaSessionInstance } = jest.requireMock('./MediaSessionInstance');
+				mockServerSelector.mockReturnValueOnce('https://workspace-a.example.com');
+				const payload = buildIncomingPayload({
+					callId: 'same-ws-call',
+					host: 'https://workspace-a.example.com'
+				});
+
+				DeviceEventEmitter.emit('VoipAcceptSucceeded', payload);
+
+				expect(mockSetNativeAcceptedCallId).toHaveBeenCalledWith('same-ws-call');
+				expect(mediaSessionInstance.applyRestStateSignals).toHaveBeenCalledTimes(1);
+				expect(mockDispatch).not.toHaveBeenCalled();
+			});
+
 			it('does not dispatch or set native id when type is not incoming_call', () => {
 				DeviceEventEmitter.emit(
 					'VoipAcceptSucceeded',

app/lib/services/voip/MediaCallEvents.ts

@@ -1,7 +1,7 @@
 import RNCallKeep from 'react-native-callkeep';
 import { DeviceEventEmitter, NativeEventEmitter } from 'react-native';
 
-import { isIOS } from '../../methods/helpers';
+import { isIOS, normalizeDeepLinkingServerHost } from '../../methods/helpers';
 import store from '../../store';
 import { deepLinkingOpen } from '../../../actions/deepLinking';
 import { useCallStore } from './useCallStore';
@@ -17,6 +17,15 @@ const TAG = `[MediaCallEvents][${platform}]`;
 const EVENT_VOIP_ACCEPT_FAILED = 'VoipAcceptFailed';
 const EVENT_VOIP_ACCEPT_SUCCEEDED = 'VoipAcceptSucceeded';
 
+/** True when normalized incoming host matches the active Redux workspace (no server switch needed). */
+function isVoipIncomingHostCurrentWorkspace(incomingHost: string): boolean {
+	const active = store.getState().server.server;
+	if (!active || !incomingHost) {
+		return false;
+	}
+	return normalizeDeepLinkingServerHost(incomingHost) === normalizeDeepLinkingServerHost(active);
+}
+
 /** Dedupe native emit + stash replay for the same failed accept. */
 let lastHandledVoipAcceptFailureCallId: string | null = null;
 /** Idempotent warm delivery of native accept success. */
@@ -56,6 +65,12 @@ function handleVoipAcceptSucceededFromNative(data: VoipPayload) {
 	console.log(`${TAG} VoipAcceptSucceeded:`, data);
 	NativeVoipModule.clearInitialEvents();
 	useCallStore.getState().setNativeAcceptedCallId(data.callId);
+	if (data.host && isVoipIncomingHostCurrentWorkspace(data.host)) {
+		mediaSessionInstance.applyRestStateSignals().catch(error => {
+			console.error(`${TAG} applyRestStateSignals failed:`, error);
+		});
+		return;
+	}
 	store.dispatch(
 		deepLinkingOpen({
 			callId: data.callId,
@@ -109,8 +124,8 @@ export const setupMediaCallEvents = (): (() => void) => {
 
 		// Note: there is intentionally no 'answerCall' listener here.
 		// VoipService.swift handles accept natively: handleObservedCallChanged detects
-		// hasConnected = true and calls handleNativeAccept(), which sends the DDP accept
-		// signal before JS runs. JS receives VoipAcceptSucceeded after success.
+		// hasConnected = true and calls handleNativeAccept(), which sends the REST accept
+		// (POST /api/v1/media-calls.answer) before JS runs. JS receives VoipAcceptSucceeded after success.
 	}
 
 	/** Tracks OS-driven hold (competing call) so we only auto-resume that path, not manual hold. */
@@ -223,6 +238,14 @@ export const getInitialMediaCallEvents = async (): Promise<boolean> => {
 		if (wasAnswered) {
 			useCallStore.getState().setNativeAcceptedCallId(initialEvents.callId);
 
+			if (initialEvents.host && isVoipIncomingHostCurrentWorkspace(initialEvents.host)) {
+				mediaSessionInstance.applyRestStateSignals().catch(error => {
+					console.error(`${TAG} applyRestStateSignals (initial) failed:`, error);
+				});
+				console.log(`${TAG} Same workspace as VoIP host; skipped deepLinkingOpen`);
+				return true;
+			}
+
 			store.dispatch(
 				deepLinkingOpen({
 					callId: initialEvents.callId,