fix(conference) Fix different bugs with startMuted policy. (#2777)

* fix(conference) Fix different bugs with startMuted policy.
If the user changes mute state after joining the call and before the other participats join the call, make sure those state changes are honored.

* feat(startMuted) Ignore startMuted in Jingle from focus.
Apply startMuted policy based on startMuted setting in room meta data.
Moderator settings and AV moderation settings will now be propagated to new endpoints joining the call through room meta data.
Advertise a new capability 'start-muted-room-metadata' to Jicofo for feature detection.

JitsiConference.js

     this.dtmfManager = null;
     this.somebodySupportsDTMF = false;
     this.authEnabled = false;
-    this.startAudioMuted = false;
-    this.startVideoMuted = false;
     this.startMutedPolicy = {
         audio: false,
         video: false
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track, actorParticipant);
 };
 
-/**
- * Returns the list of local tracks that need to be added to the peerconnection on join.
- * This takes the startAudioMuted/startVideoMuted flags into consideration since we do not
- * want to add the tracks if the user joins the call audio/video muted. The tracks will be
- * added when the user unmutes for the first time.
- * @returns {Array<JitsiLocalTrack>} - list of local tracks that are unmuted.
- */
-JitsiConference.prototype._getInitialLocalTracks = function() {
-    // Always add the audio track on certain platforms:
-    //  * Safari / WebKit: because of a known issue where audio playout doesn't happen
-    //    if the user joins audio and video muted.
-    //  * React Native: after iOS 15, if a user joins muted they won't be able to unmute.
-    return this.getLocalTracks()
-        .filter(track => {
-            const trackType = track.getType();
-
-            if (trackType === MediaType.AUDIO
-                    && (!(this.isStartAudioMuted() || this.startMutedPolicy.audio)
-                    || browser.isWebKitBased()
-                    || browser.isReactNative())) {
-                return true;
-            } else if (trackType === MediaType.VIDEO && !this.isStartVideoMuted() && !this.startMutedPolicy.video) {
-                return true;
-            }
-
-            // Remove the track from the conference.
-            this.onLocalTrackRemoved(track);
-
-            return false;
-        });
-};
-
 /**
  * Clear JitsiLocalTrack properties and listeners.
  * @param track the JitsiLocalTrack object.
     }
 
     this._maybeSetSITimeout();
+    const { startAudioMuted, startVideoMuted } = this.options.config;
+
+    // Ignore startAudio/startVideoMuted settings if the media session has already been established.
+    // Apply the policy if the number of participants exceeds the startMuted thresholds.
+    if ((this.jvbJingleSession && this.getActiveMediaSession() === this.jvbJingleSession)
+        || ((typeof startAudioMuted === 'undefined' || startAudioMuted === -1)
+            && (typeof startVideoMuted === 'undefined' || startVideoMuted === -1))) {
+        return;
+    }
+
+    let audioMuted = false;
+    let videoMuted = false;
+    const numberOfParticipants = this.getParticipantCount();
+
+    if (numberOfParticipants > this.options.config.startAudioMuted) {
+        audioMuted = true;
+    }
+
+    if (numberOfParticipants > this.options.config.startVideoMuted) {
+        videoMuted = true;
+    }
+
+    if ((audioMuted && !this.startMutedPolicy.audio) || (videoMuted && !this.startMutedPolicy.video)) {
+        this._updateStartMutedPolicy(audioMuted, videoMuted);
+    }
 };
 
 /* eslint-enable max-params */
     // Open a channel with the videobridge.
     this._setBridgeChannel(jingleOffer, jingleSession.peerconnection);
 
-    const localTracks = this._getInitialLocalTracks();
+    const localTracks = this.getLocalTracks();
 
     try {
         jingleSession.acceptOffer(
         return;
     }
 
-    // Do not apply the startMutedPolicy locally on the moderator, the moderator should join with available local
-    // sources and the policy needs to be applied only on users that join the call after.
-    // this.startMutedPolicy = policy;
-    // TODO: to remove using presence for startmuted policy after old clients update
-    // we keep presence to update UI of old clients
+    logger.info(`Setting start muted policy: ${JSON.stringify(policy)} in presence and in conference metadata`);
+
+    // TODO: to remove using presence for startmuted policy after old clients update to using metadata always.
     this.room.addOrReplaceInPresence('startmuted', {
         attributes: {
             audio: policy.audio,
         }
     }) && this.room.sendPresence();
 
-    // we want to ignore applying startMutedPolicy locally when we set it
-    this._ignoreFirstStartMutedPolicyUpdate = true;
-
     this.getMetadataHandler().setMetadata('startMuted', {
         audio: policy.audio,
         video: policy.video
  * @param {boolean} video if video should be muted.
  */
 JitsiConference.prototype._updateStartMutedPolicy = function(audio, video) {
-    if (this._ignoreFirstStartMutedPolicyUpdate) {
-        this._ignoreFirstStartMutedPolicyUpdate = false;
-
+    // Update the start muted policy for the conference only if the meta data is received before conference join.
+    if (this.isJoined()) {
         return;
     }
 
     return this.startMutedPolicy;
 };
 
-/**
- * Check if audio is muted on join.
- */
-JitsiConference.prototype.isStartAudioMuted = function() {
-    return this.startAudioMuted;
-};
-
-/**
- * Check if video is muted on join.
- */
-JitsiConference.prototype.isStartVideoMuted = function() {
-    return this.startVideoMuted;
-};
-
 /**
  * Returns measured connectionTimes.
  */

JitsiConferenceEventManager.js

     // Room metadata.
     chatRoom.addListener(XMPPEvents.ROOM_METADATA_UPDATED, metadata => {
         if (metadata.startMuted) {
-            conference._updateStartMutedPolicy(
-                metadata.startMuted.audio || false,
-                metadata.startMuted.video || false
-            );
+            const audio = metadata.startMuted.audio || false;
+            const video = metadata.startMuted.video || false;
+
+            audio && (conference.isMutedByFocus = true);
+            video && (conference.isVideoMutedByFocus = true);
+            conference._updateStartMutedPolicy(audio, video);
         }
         conference.eventEmitter.emit(JitsiConferenceEvents.METADATA_UPDATED, metadata);
     });
         XMPPEvents.CALL_ENDED,
         conference.onCallEnded.bind(conference));
 
-    this._addConferenceXMPPListener(XMPPEvents.START_MUTED_FROM_FOCUS,
-        (audioMuted, videoMuted) => {
-            if (conference.options.config.ignoreStartMuted) {
-                return;
-            }
-
-            conference.startAudioMuted = audioMuted;
-            conference.startVideoMuted = videoMuted;
-
-            if (audioMuted) {
-                conference.isMutedByFocus = true;
-            }
-
-            if (videoMuted) {
-                conference.isVideoMutedByFocus = true;
-            }
-
-            // mute existing local tracks because this is initial mute from
-            // Jicofo
-            conference.getLocalTracks().forEach(track => {
-                switch (track.getType()) {
-                case MediaType.AUDIO:
-                    conference.startAudioMuted && track.mute();
-                    break;
-                case MediaType.VIDEO:
-                    conference.startVideoMuted && track.mute();
-                    break;
-                }
-            });
-
-            conference.eventEmitter.emit(JitsiConferenceEvents.STARTED_MUTED);
-        });
-
     this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_CHANGED,
         (value, mediaType, actorJid) => {
             const actorParticipant = conference.getParticipants().find(p => p.getJid() === actorJid);

JitsiConferenceEvents.spec.ts

         VIDEO_SIP_GW_AVAILABILITY_CHANGED,
         VIDEO_SIP_GW_SESSION_STATE_CHANGED,
         START_MUTED_POLICY_CHANGED,
-        STARTED_MUTED,
         SUBJECT_CHANGED,
         SUSPEND_DETECTED,
         TALK_WHILE_MUTED,
         expect( VIDEO_SIP_GW_SESSION_STATE_CHANGED ).toBe( 'conference.videoSIPGWSessionStateChanged' );
         expect( VISITORS_SUPPORTED_CHANGED ).toBe( 'conference.visitorsSupported' );
         expect( START_MUTED_POLICY_CHANGED ).toBe( 'conference.start_muted_policy_changed' );
-        expect( STARTED_MUTED ).toBe( 'conference.started_muted' );
         expect( SUBJECT_CHANGED ).toBe( 'conference.subjectChanged' );
         expect( SUSPEND_DETECTED ).toBe( 'conference.suspendDetected' );
         expect( TALK_WHILE_MUTED ).toBe( 'conference.talk_while_muted' );
         expect( JitsiConferenceEvents.VIDEO_SIP_GW_AVAILABILITY_CHANGED ).toBe( 'conference.videoSIPGWAvailabilityChanged' );
         expect( JitsiConferenceEvents.VIDEO_SIP_GW_SESSION_STATE_CHANGED ).toBe( 'conference.videoSIPGWSessionStateChanged' );
         expect( JitsiConferenceEvents.START_MUTED_POLICY_CHANGED ).toBe( 'conference.start_muted_policy_changed' );
-        expect( JitsiConferenceEvents.STARTED_MUTED ).toBe( 'conference.started_muted' );
         expect( JitsiConferenceEvents.SUBJECT_CHANGED ).toBe( 'conference.subjectChanged' );
         expect( JitsiConferenceEvents.SUSPEND_DETECTED ).toBe( 'conference.suspendDetected' );
         expect( JitsiConferenceEvents.TALK_WHILE_MUTED ).toBe( 'conference.talk_while_muted' );

JitsiConferenceEvents.ts

      */
     SILENT_STATUS_CHANGED = 'conference.silentStatusChanged',
 
-    /**
-     * Indicates that the local user has started muted.
-     */
-    STARTED_MUTED = 'conference.started_muted',
-
     /**
      * Indicates that start muted settings changed.
      */
 export const SERVER_REGION_CHANGED = JitsiConferenceEvents.SERVER_REGION_CHANGED;
 export const SILENT_STATUS_CHANGED = JitsiConferenceEvents.SILENT_STATUS_CHANGED;
 export const START_MUTED_POLICY_CHANGED = JitsiConferenceEvents.START_MUTED_POLICY_CHANGED;
-export const STARTED_MUTED = JitsiConferenceEvents.STARTED_MUTED;
 export const SUBJECT_CHANGED = JitsiConferenceEvents.SUBJECT_CHANGED;
 export const SUSPEND_DETECTED = JitsiConferenceEvents.SUSPEND_DETECTED;
 export const TALK_WHILE_MUTED = JitsiConferenceEvents.TALK_WHILE_MUTED;

modules/xmpp/RoomMetadata.ts

         }
 
         this._metadata = metadata;
+        logger.debug('Received metadata update', metadata);
         this.room.eventEmitter.emit(XMPPEvents.ROOM_METADATA_UPDATED, metadata);
     }
 

modules/xmpp/strophe.jingle.js

 import { cloneDeep } from 'lodash-es';
 import { $iq, Strophe } from 'strophe.js';
 
-import { MediaType } from '../../service/RTC/MediaType';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import RandomUtil from '../util/RandomUtil';
 
         switch (action) {
         case 'session-initiate': {
             logger.info('(TIME) received session-initiate:\t', now);
-            const startMuted = $(iq).find('jingle>startmuted');
 
             isP2P && logger.debug(`Received ${action} from ${fromJid}`);
-            if (startMuted?.length) {
-                const audioMuted = startMuted.attr(MediaType.AUDIO);
-                const videoMuted = startMuted.attr(MediaType.VIDEO);
-
-                this.eventEmitter.emit(
-                    XMPPEvents.START_MUTED_FROM_FOCUS,
-                    audioMuted === 'true',
-                    videoMuted === 'true');
-            }
             const pcConfig = isP2P ? this.p2pIceConfig : this.jvbIceConfig;
 
             sess

modules/xmpp/xmpp.js

         // for keeping stats, since it is not made available to jocofo at
         // the time of the initial conference-request.
         this.caps.addFeature('http://jitsi.org/visitors-1');
+
+        // Advertise support for startMuted policy through room metadata.
+        this.caps.addFeature('http://jitsi.org/start-muted-room-metadata');
     }
 
     /**

service/xmpp/XMPPEvents.spec.ts

         expect( XMPPEvents.BREAKOUT_ROOMS_UPDATED ).toBe( 'xmpp.breakout-rooms.updated' );
         expect( XMPPEvents.ROOM_METADATA_EVENT ).toBe( 'xmpp.room-metadata.event' );
         expect( XMPPEvents.ROOM_METADATA_UPDATED ).toBe( 'xmpp.room-metadata.updated' );
-        expect( XMPPEvents.START_MUTED_FROM_FOCUS ).toBe( 'xmpp.start_muted_from_focus' );
         expect( XMPPEvents.SUBJECT_CHANGED ).toBe( 'xmpp.subject_changed' );
         expect( XMPPEvents.SUSPEND_DETECTED ).toBe( 'xmpp.suspend_detected' );
         expect( XMPPEvents.TRANSCRIPTION_STATUS_CHANGED ).toBe( 'xmpp.transcription_status_changed' );

service/xmpp/XMPPEvents.ts

      */
     SPEAKER_STATS_RECEIVED = 'xmpp.speaker_stats_received',
 
-    // Designates an event indicating that we should join the conference with
-    // audio and/or video muted.
-    START_MUTED_FROM_FOCUS = 'xmpp.start_muted_from_focus',
-
     // Designates an event indicating that the subject of the XMPP MUC has
     // changed.
     SUBJECT_CHANGED = 'xmpp.subject_changed',

types/hand-crafted/JitsiConference.d.ts

   getConnectionState: () => string | null;
   setStartMutedPolicy: ( policy: { audio: boolean, video: boolean } ) => void;
   getStartMutedPolicy: () => { audio: boolean, video: boolean };
-  isStartAudioMuted: () => boolean;
-  isStartVideoMuted: () => boolean;
   getConnectionTimes: () => unknown;
   setLocalParticipantProperty: ( name: string, value: unknown ) => void;
   removeLocalParticipantProperty: ( name: string ) => void;

types/hand-crafted/JitsiConferenceEvents.d.ts

   VIDEO_SIP_GW_AVAILABILITY_CHANGED = 'conference.videoSIPGWAvailabilityChanged',
   VIDEO_SIP_GW_SESSION_STATE_CHANGED = 'conference.videoSIPGWSessionStateChanged',
   START_MUTED_POLICY_CHANGED = 'conference.start_muted_policy_changed',
-  STARTED_MUTED = 'conference.started_muted',
   SUBJECT_CHANGED = 'conference.subjectChanged',
   SUSPEND_DETECTED = 'conference.suspendDetected',
   TALK_WHILE_MUTED = 'conference.talk_while_muted',

types/hand-crafted/service/xmpp/XMPPEvents.d.ts

   AV_MODERATION_RECEIVED = 'xmpp.av_moderation.received',
   AV_MODERATION_CHANGED = 'xmpp.av_moderation.changed',
   AV_MODERATION_PARTICIPANT_APPROVED = 'xmpp.av_moderation.participant.approved',
-  START_MUTED_FROM_FOCUS = 'xmpp.start_muted_from_focus',
   SUBJECT_CHANGED = 'xmpp.subject_changed',
   SUSPEND_DETECTED = 'xmpp.suspend_detected',
   TRANSCRIPTION_STATUS_CHANGED = 'xmpp.transcription_status_changed',