chore: test branch - sync on hold state

packages/media-signaling/src/definition/call/IClientMediaCall.ts

@@ -78,6 +78,8 @@ export interface IClientMediaCall {
 	held: boolean;
 	/* busy = state >= 'accepted' && state < 'hangup' */
 	busy: boolean;
+	/* if the other side has put the call on hold */
+	remoteHeld: boolean;
 
 	contact: CallContact;
 	transferredBy: CallContact | null;

packages/media-signaling/src/definition/services/webrtc/IWebRTCProcessor.ts

@@ -42,6 +42,7 @@ export interface IWebRTCProcessor extends IServiceProcessor<WebRTCInternalStateM
 	localAudioLevel: number;
 
 	getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport | null>;
+	isRemoteHeld(): boolean;
 }
 
 export type WebRTCProcessorConfig = {

packages/media-signaling/src/lib/Call.ts

@@ -125,6 +125,12 @@ export class ClientMediaCall implements IClientMediaCall {
 		return this.webrtcProcessor.held;
 	}
 
+	private _remoteHeld: boolean;
+
+	public get remoteHeld(): boolean {
+		return this._remoteHeld;
+	}
+
 	/** indicates the call is past the "dialing" stage and not yet over */
 	public get busy(): boolean {
 		return !this.isPendingAcceptance() && !this.isOver();
@@ -208,6 +214,7 @@ export class ClientMediaCall implements IClientMediaCall {
 		this._contact = null;
 		this._transferredBy = null;
 		this._service = null;
+		this._remoteHeld = false;
 
 		this.negotiationManager = new NegotiationManager(this, { logger: config.logger });
 	}
@@ -987,6 +994,20 @@ export class ClientMediaCall implements IClientMediaCall {
 		this.stateTimeoutHandlers.clear();
 	}
 
+	private updateRemoteHeld(): void {
+		if (!this.webrtcProcessor) {
+			return;
+		}
+
+		const isRemoteHeld = this.webrtcProcessor.isRemoteHeld();
+		if (isRemoteHeld === this._remoteHeld) {
+			return;
+		}
+
+		this._remoteHeld = isRemoteHeld;
+		this.emitter.emit('trackStateChange');
+	}
+
 	private onWebRTCInternalStateChange(stateName: keyof WebRTCInternalStateMap): void {
 		this.config.logger?.debug('ClientMediaCall.onWebRTCInternalStateChange');
 		if (!this.webrtcProcessor) {
@@ -1006,6 +1027,8 @@ export class ClientMediaCall implements IClientMediaCall {
 
 			this.requestStateReport();
 		}
+
+		this.updateRemoteHeld();
 	}
 
 	private onNegotiationNeeded(oldNegotiationId: string): void {

packages/media-signaling/src/lib/services/webrtc/Processor.ts

@@ -145,6 +145,8 @@ export class MediaCallWebRTCProcessor implements IWebRTCProcessor {
 		this._held = held;
 		this.localStream.setEnabled(!held && !this._muted);
 		this.remoteStream.setEnabled(!held);
+
+		this.updateAudioDirectionWithoutNegotiation();
 	}
 
 	public stop(): void {
@@ -257,6 +259,33 @@ export class MediaCallWebRTCProcessor implements IWebRTCProcessor {
 		return this.peer.signalingState === 'stable';
 	}
 
+	public isRemoteHeld(): boolean {
+		if (this.stopped) {
+			return false;
+		}
+
+		if (['closed', 'failed', 'new'].includes(this.peer.connectionState)) {
+			return false;
+		}
+
+		let anyTransceiverNotSending = false;
+		const transceivers = this.getAudioTransceivers();
+
+		for (const transceiver of transceivers) {
+			if (!transceiver.currentDirection || transceiver.currentDirection === 'stopped') {
+				continue;
+			}
+
+			if (transceiver.currentDirection.includes('send')) {
+				return false;
+			}
+
+			anyTransceiverNotSending = true;
+		}
+
+		return anyTransceiverNotSending;
+	}
+
 	public getLocalDescription(): RTCSessionDescriptionInit | null {
 		this.config.logger?.debug('MediaCallWebRTCProcessor.getLocalDescription');
 		if (this.stopped) {
@@ -354,6 +383,28 @@ export class MediaCallWebRTCProcessor implements IWebRTCProcessor {
 		}
 	}
 
+	private updateAudioDirectionWithoutNegotiation(): void {
+		// If the signaling state is not stable, then a negotiation is already happening and the audio direction will be updated by them
+		if (this.peer.signalingState !== 'stable') {
+			return;
+		}
+
+		const desiredDirection = this.held ? 'sendonly' : 'sendrecv';
+		const acceptableDirection = this.held ? 'inactive' : 'recvonly';
+
+		const transceivers = this.getAudioTransceivers();
+		for (const transceiver of transceivers) {
+			// If the last direction we requested still matches our current requirements, then we don't need to change our request
+			if ([desiredDirection, acceptableDirection, 'stopped'].includes(transceiver.direction)) {
+				continue;
+			}
+
+			// If the current state of the call doesn't match what we are requesting here, the browser will trigger the negotiation-needed event for us
+			this.config.logger?.debug(`Changing desired audio direction from ${transceiver.direction} to ${desiredDirection}.`);
+			transceiver.direction = desiredDirection;
+		}
+	}
+
 	private getAudioTransceivers(): RTCRtpTransceiver[] {
 		return this.peer
 			.getTransceivers()