refactor(voip): split MediaSessionInstance into Controller + Orchestrator

.gitignore

@@ -83,4 +83,8 @@ e2e/e2e_account.ts
 **/e2e_account.js
 **/e2e_account.ts
 
-*.p8
+*.p8
+
+# Local tooling
+.claude/
+.superset/

app/containers/NewMediaCall/CreateCall.test.tsx

@@ -8,25 +8,17 @@ import { mockedStore } from '../../reducers/mockedStore';
 import type { TPeerItem } from '../../lib/services/voip/getPeerAutocompleteOptions';
 import * as stories from './CreateCall.stories';
 import { generateSnapshots } from '../../../.rnstorybook/generateSnapshots';
+import { mediaSessionInstance } from '../../lib/services/voip/MediaSessionInstance';
 
-const mockStartCall = jest.fn();
 const mockHideActionSheet = jest.fn();
 
-jest.mock('../../lib/services/voip/MediaSessionInstance', () => {
-	const instance = {};
-	Object.defineProperty(instance, 'startCall', {
-		value: (...args: unknown[]) => mockStartCall(...args),
-		writable: false,
-		configurable: false
-	});
-	return { mediaSessionInstance: instance };
-});
-
 jest.mock('../ActionSheet', () => ({
 	...jest.requireActual('../ActionSheet'),
 	hideActionSheetRef: () => mockHideActionSheet()
 }));
 
+jest.spyOn(mediaSessionInstance, 'startCall').mockReturnValue({ success: true, callId: '' });
+
 const setStoreState = (selectedPeer: TPeerItem | null) => {
 	usePeerAutocompleteStore.setState({ selectedPeer });
 };
@@ -50,6 +42,7 @@ describe('CreateCall', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
 		usePeerAutocompleteStore.setState({ selectedPeer: null });
+		jest.spyOn(mediaSessionInstance, 'startCall').mockReturnValue({ success: true, callId: '' });
 	});
 
 	it('should render the call button', () => {
@@ -83,7 +76,7 @@ describe('CreateCall', () => {
 		);
 
 		fireEvent.press(getByTestId('new-media-call-button'));
-		expect(mockStartCall).not.toHaveBeenCalled();
+		expect(mediaSessionInstance.startCall).not.toHaveBeenCalled();
 		expect(mockHideActionSheet).not.toHaveBeenCalled();
 	});
 
@@ -108,8 +101,8 @@ describe('CreateCall', () => {
 		);
 
 		fireEvent.press(getByTestId('new-media-call-button'));
-		expect(mockStartCall).toHaveBeenCalledTimes(1);
-		expect(mockStartCall).toHaveBeenCalledWith('user-1', 'user');
+		expect(mediaSessionInstance.startCall).toHaveBeenCalledTimes(1);
+		expect(mediaSessionInstance.startCall).toHaveBeenCalledWith('user-1', 'user');
 		expect(mockHideActionSheet).toHaveBeenCalledTimes(1);
 	});
 
@@ -122,8 +115,8 @@ describe('CreateCall', () => {
 		);
 
 		fireEvent.press(getByTestId('new-media-call-button'));
-		expect(mockStartCall).toHaveBeenCalledTimes(1);
-		expect(mockStartCall).toHaveBeenCalledWith('+5511999999999', 'sip');
+		expect(mediaSessionInstance.startCall).toHaveBeenCalledTimes(1);
+		expect(mediaSessionInstance.startCall).toHaveBeenCalledWith('+5511999999999', 'sip');
 		expect(mockHideActionSheet).toHaveBeenCalledTimes(1);
 	});
 });

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

@@ -51,6 +51,7 @@ jest.mock('react-native-callkeep', () => ({
 
 jest.mock('./MediaSessionInstance', () => ({
 	mediaSessionInstance: {
+		startCall: (...args: unknown[]) => ({ success: true, callId: '' }),
 		endCall: jest.fn()
 	}
 }));

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

@@ -0,0 +1,127 @@
+import type { IClientMediaCall } from '@rocket.chat/media-signaling';
+
+import { mediaSessionStore } from './MediaSessionStore';
+import { MediaSessionController } from './MediaSessionController';
+
+jest.mock('./MediaSessionStore', () => ({
+	mediaSessionStore: {
+		setWebRTCProcessorFactory: jest.fn(),
+		getInstance: jest.fn(),
+		dispose: jest.fn(),
+		onChange: jest.fn(() => jest.fn())
+	}
+}));
+
+jest.mock('../sdk', () => ({
+	default: {
+		onStreamData: jest.fn(() => ({ stop: jest.fn() }))
+	}
+}));
+
+jest.mock('react-native-device-info', () => ({
+	getUniqueIdSync: () => 'device-123'
+}));
+
+jest.mock('../../store/auxStore', () => ({
+	store: {
+		getState: () => ({
+			settings: {
+				VoIP_TeamCollab_Ice_Servers: 'stun:stun.l.google.com:19302',
+				VoIP_TeamCollab_Ice_Gathering_Timeout: 5000
+			}
+		}),
+		subscribe: jest.fn(() => jest.fn())
+	}
+}));
+
+type MockMediaSignalingSession = {
+	userId: string;
+	on: jest.Mock;
+	setIceGatheringTimeout: jest.Mock;
+};
+
+jest.mock('@rocket.chat/media-signaling', () => ({
+	MediaCallWebRTCProcessor: jest.fn().mockImplementation(function (this: unknown) {
+		return this;
+	}),
+	MediaSignalingSession: jest
+		.fn()
+		.mockImplementation(function MockMediaSignalingSession(this: MockMediaSignalingSession, config: { userId: string }) {
+			this.userId = config.userId;
+			this.on = jest.fn();
+			this.setIceGatheringTimeout = jest.fn();
+		})
+}));
+
+jest.mock('react-native-webrtc', () => ({
+	registerGlobals: jest.fn()
+}));
+
+describe('MediaSessionController', () => {
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe('constructor', () => {
+		it('should initialize with empty session', () => {
+			const controller = new MediaSessionController('user-123');
+			expect(controller.getSession()).toBeNull();
+		});
+	});
+
+	describe('configure', () => {
+		it('should set WebRTC processor factory with ICE servers', () => {
+			const controller = new MediaSessionController('user-123');
+			controller.configure();
+
+			expect(mediaSessionStore.setWebRTCProcessorFactory).toHaveBeenCalledTimes(1);
+			const factory = (mediaSessionStore.setWebRTCProcessorFactory as jest.Mock).mock.calls[0][0];
+			const processor = factory({
+				rtc: { iceServers: [] },
+				iceGatheringTimeout: 5000
+			});
+			expect(processor).toBeDefined();
+		});
+
+		it('should create session via mediaSessionStore', () => {
+			const mockInstance = { startCall: jest.fn() };
+			(mediaSessionStore.getInstance as jest.Mock).mockReturnValue(mockInstance);
+
+			const controller = new MediaSessionController('user-123');
+			controller.configure();
+
+			expect(mediaSessionStore.getInstance).toHaveBeenCalledWith('user-123');
+		});
+	});
+
+	describe('getSession', () => {
+		it('should return null before configure', () => {
+			const controller = new MediaSessionController('user-123');
+			expect(controller.getSession()).toBeNull();
+		});
+
+		it('should return session after configure', () => {
+			const mockInstance = { startCall: jest.fn() };
+			(mediaSessionStore.getInstance as jest.Mock).mockReturnValue(mockInstance);
+
+			const controller = new MediaSessionController('user-123');
+			controller.configure();
+
+			expect(controller.getSession()).toBe(mockInstance);
+		});
+	});
+
+	describe('reset', () => {
+		it('should dispose mediaSessionStore and set session to null', () => {
+			const mockInstance = { startCall: jest.fn() };
+			(mediaSessionStore.getInstance as jest.Mock).mockReturnValue(mockInstance);
+
+			const controller = new MediaSessionController('user-123');
+			controller.configure();
+			controller.reset();
+
+			expect(mediaSessionStore.dispose).toHaveBeenCalled();
+			expect(controller.getSession()).toBeNull();
+		});
+	});
+});

app/lib/services/voip/MediaSessionController.ts

@@ -0,0 +1,87 @@
+import {
+	MediaCallWebRTCProcessor,
+	type WebRTCProcessorConfig,
+	type MediaSignalingSession
+} from '@rocket.chat/media-signaling';
+import { registerGlobals } from 'react-native-webrtc';
+
+import { mediaSessionStore } from './MediaSessionStore';
+import { parseStringToIceServers } from './parseStringToIceServers';
+import { store } from '../../store/auxStore';
+import type { IceServer } from '../../../definitions/Voip';
+
+export class MediaSessionController {
+	private userId: string;
+	private session: MediaSignalingSession | null = null;
+	private iceServers: IceServer[] = [];
+	private iceGatheringTimeout: number = 5000;
+	private storeTimeoutUnsubscribe: (() => void) | null = null;
+	private storeIceServersUnsubscribe: (() => void) | null = null;
+
+	constructor(userId: string) {
+		this.userId = userId;
+	}
+
+	public configure(): void {
+		registerGlobals();
+		this.configureIceServers();
+
+		mediaSessionStore.setWebRTCProcessorFactory(
+			(config: WebRTCProcessorConfig) =>
+				new MediaCallWebRTCProcessor({
+					...config,
+					rtc: { ...config.rtc, iceServers: this.iceServers },
+					iceGatheringTimeout: this.iceGatheringTimeout
+				})
+		);
+
+		this.session = mediaSessionStore.getInstance(this.userId);
+	}
+
+	public getSession(): MediaSignalingSession | null {
+		return this.session;
+	}
+
+	public refreshSession(): MediaSignalingSession | null {
+		this.session = mediaSessionStore.getInstance(this.userId);
+		return this.session;
+	}
+
+	public reset(): void {
+		if (this.storeTimeoutUnsubscribe) {
+			this.storeTimeoutUnsubscribe();
+			this.storeTimeoutUnsubscribe = null;
+		}
+		if (this.storeIceServersUnsubscribe) {
+			this.storeIceServersUnsubscribe();
+			this.storeIceServersUnsubscribe = null;
+		}
+		mediaSessionStore.dispose();
+		this.session = null;
+	}
+
+	private getIceServers(): IceServer[] {
+		const iceServers = store.getState().settings.VoIP_TeamCollab_Ice_Servers as string;
+		return parseStringToIceServers(iceServers);
+	}
+
+	private configureIceServers(): void {
+		this.iceServers = this.getIceServers();
+		this.iceGatheringTimeout = store.getState().settings.VoIP_TeamCollab_Ice_Gathering_Timeout as number;
+
+		this.storeTimeoutUnsubscribe = store.subscribe(() => {
+			const currentTimeout = store.getState().settings.VoIP_TeamCollab_Ice_Gathering_Timeout as number;
+			if (currentTimeout !== this.iceGatheringTimeout) {
+				this.iceGatheringTimeout = currentTimeout;
+				this.session?.setIceGatheringTimeout(this.iceGatheringTimeout);
+			}
+		});
+
+		this.storeIceServersUnsubscribe = store.subscribe(() => {
+			const currentIceServers = this.getIceServers();
+			if (currentIceServers !== this.iceServers) {
+				this.iceServers = currentIceServers;
+			}
+		});
+	}
+}