Remove support for legacy endpoint based signaling. (#2147)

* Remove support for legacy endpoint based signaling and make source-name signaling as the only signaling mode. The legacy screensharing mode will no longer be supported. The client will still be able to process remote presence sent in the old format to support interop with very old mobile clients and jigasi that do not support source-name signaling.
* remove code related to presenter mode.

JitsiConference.js

 import { SS_DEFAULT_FRAME_RATE } from './modules/RTC/ScreenObtainer';
 import browser from './modules/browser';
 import ConnectionQuality from './modules/connectivity/ConnectionQuality';
-import IceFailedHandling
-    from './modules/connectivity/IceFailedHandling';
-import ParticipantConnectionStatusHandler
-    from './modules/connectivity/ParticipantConnectionStatus';
+import IceFailedHandling from './modules/connectivity/IceFailedHandling';
 import * as DetectionEvents from './modules/detection/DetectionEvents';
 import NoAudioSignalDetection from './modules/detection/NoAudioSignalDetection';
 import P2PDominantSpeakerDetection from './modules/detection/P2PDominantSpeakerDetection';
     if (!this.rtc) {
         this.rtc = new RTC(this, options);
         this.eventManager.setupRTCListeners();
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            this._registerRtcListeners(this.rtc);
-        }
+        this._registerRtcListeners(this.rtc);
     }
 
     this.receiveVideoController = new ReceiveVideoController(this, this.rtc);
     this.sendVideoController = new SendVideoController(this, this.rtc);
 
-    // Do not initialize ParticipantConnectionStatusHandler when source-name signaling is enabled.
-    if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-        this.participantConnectionStatus
-        = new ParticipantConnectionStatusHandler(
-            this.rtc,
-            this,
-            {
-                // These options are not public API, leaving it here only as an entry point through config for tuning
-                // up purposes. Default values should be adjusted as soon as optimal values are discovered.
-                p2pRtcMuteTimeout: config._p2pConnStatusRtcMuteTimeout,
-                rtcMuteTimeout: config._peerConnStatusRtcMuteTimeout,
-                outOfLastNTimeout: config._peerConnStatusOutOfLastNTimeout
-            });
-        this.participantConnectionStatus.init();
-    }
-
     // Add the ability to enable callStats only on a percentage of users based on config.js settings.
     let enableCallStats = true;
 
         videoType = BridgeVideoType.DESKTOP_HIGH_FPS;
     }
 
-    if (FeatureFlags.isSourceNameSignalingEnabled() && localtrack) {
-        this.rtc.sendSourceVideoType(localtrack.getSourceName(), videoType);
-    } else if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-        this.rtc.setVideoType(videoType);
-    }
+    localtrack && this.rtc.sendSourceVideoType(localtrack.getSourceName(), videoType);
 };
 
 /**
 
         // Currently, only adding multiple video streams of different video types is supported.
         // TODO - remove this limitation once issues with jitsi-meet trying to add multiple camera streams is fixed.
-        if (FeatureFlags.isMultiStreamSupportEnabled()
+        if (FeatureFlags.isMultiStreamSendSupportEnabled()
             && mediaType === MediaType.VIDEO
             && !localTracks.find(t => t.getVideoType() === track.getVideoType())) {
             const sourceName = getSourceNameForJitsiTrack(
             // Presence needs to be sent here for desktop track since we need the presence to reach the remote peer
             // before signaling so that a fake participant tile is created for screenshare. Otherwise, presence will
             // only be sent after a session-accept or source-add is ack'ed.
-            if (track.getVideoType() === VideoType.DESKTOP && FeatureFlags.isMultiStreamSupportEnabled()) {
+            if (track.getVideoType() === VideoType.DESKTOP && FeatureFlags.isMultiStreamSendSupportEnabled()) {
                 this._updateRoomPresence(this.getActiveMediaSession());
             }
         });
     const mediaType = oldTrack?.getType() || newTrack?.getType();
     const newVideoType = newTrack?.getVideoType();
 
-    if (FeatureFlags.isMultiStreamSupportEnabled() && oldTrack && newTrack && oldVideoType !== newVideoType) {
+    if (FeatureFlags.isMultiStreamSendSupportEnabled() && oldTrack && newTrack && oldVideoType !== newVideoType) {
         throw new Error(`Replacing a track of videoType=${oldVideoType} with a track of videoType=${newVideoType} is`
             + ' not supported in this mode.');
     }
 
-    if (FeatureFlags.isSourceNameSignalingEnabled() && newTrack) {
-        if (oldTrack) {
-            newTrack.setSourceName(oldTrack.getSourceName());
-        } else {
-            const sourceName = getSourceNameForJitsiTrack(
+    if (newTrack) {
+        const sourceName = oldTrack
+            ? oldTrack.getSourceName()
+            : getSourceNameForJitsiTrack(
                 this.myUserId(),
                 mediaType,
                 this.getLocalTracks(mediaType)?.length);
 
-            newTrack.setSourceName(sourceName);
-        }
+        newTrack.setSourceName(sourceName);
     }
     const oldTrackBelongsToConference = this === oldTrack?.conference;
 
     }
 
     // Create a source name for this track if it doesn't exist.
-    if (FeatureFlags.isSourceNameSignalingEnabled() && !newTrack.getSourceName()) {
+    if (!newTrack.getSourceName()) {
         const sourceName = getSourceNameForJitsiTrack(
             this.myUserId(),
             mediaType,
 JitsiConference.prototype._setNewVideoType = function(track) {
     let videoTypeChanged = false;
 
-    if (FeatureFlags.isSourceNameSignalingEnabled() && track) {
+    if (track) {
         videoTypeChanged = this._signalingLayer.setTrackVideoType(track.getSourceName(), track.videoType);
     }
 
-    if (!FeatureFlags.isMultiStreamSupportEnabled()) {
-        const videoTypeTagName = 'videoType';
-
-        // If track is missing we revert to default type Camera, the case where we screenshare and
-        // we return to be video muted.
-        const trackVideoType = track ? track.videoType : VideoType.CAMERA;
-
-        // If video type is camera and there is no videoType in presence, we skip adding it, as this is the default one
-        if (trackVideoType !== VideoType.CAMERA || this.room.getFromPresence(videoTypeTagName)) {
-            // We will not use this.sendCommand here to avoid sending the presence immediately, as later we may also
-            // set the mute status.
-            const legacyTypeChanged = this.room.addOrReplaceInPresence(videoTypeTagName, { value: trackVideoType });
-
-            videoTypeChanged = videoTypeChanged || legacyTypeChanged;
-        }
-    }
-
     return videoTypeChanged;
 };
 
 JitsiConference.prototype._setTrackMuteStatus = function(mediaType, localTrack, isMuted) {
     let presenceChanged = false;
 
-    if (FeatureFlags.isSourceNameSignalingEnabled() && localTrack) {
+    if (localTrack) {
         presenceChanged = this._signalingLayer.setTrackMuteStatus(localTrack.getSourceName(), isMuted);
     }
 
-    // Add the 'audioMuted' and 'videoMuted' tags when source name signaling is enabled for backward compatibility.
-    // It won't be used anymore when multiple stream support is enabled.
-    if (!FeatureFlags.isMultiStreamSupportEnabled()) {
-        let audioMuteChanged, videoMuteChanged;
-
-        if (!this.room) {
-            return false;
-        }
-
-        if (mediaType === MediaType.AUDIO) {
-            audioMuteChanged = this.room.addAudioInfoToPresence(isMuted);
-        } else {
-            videoMuteChanged = this.room.addVideoInfoToPresence(isMuted);
-        }
-
-        presenceChanged = presenceChanged || audioMuteChanged || videoMuteChanged;
-    }
-
     return presenceChanged;
 };
 
     }
 };
 
-/**
- * Checks if the participant given by participantId is currently included in
- * the last N.
- * @param {string} participantId the identifier of the participant we would
- * like to check.
- * @return {boolean} true if the participant with id is in the last N set or
- * if there's no last N set, false otherwise.
- * @deprecated this method should never be used to figure out the UI, but
- * {@link ParticipantConnectionStatus} should be used instead.
- */
-JitsiConference.prototype.isInLastN = function(participantId) {
-    return this.rtc.isInLastN(participantId);
-};
-
 /**
  * @return Array<JitsiParticipant> an array of all participants in this
  * conference.
     let presenceChanged = false;
     let muteStatusChanged, videoTypeChanged;
     const localTracks = jingleSession.peerconnection.getLocalTracks();
-    const localAudioTracks = localTracks.filter(track => track.getType() === MediaType.AUDIO);
-    const localVideoTracks = localTracks.filter(track => track.getType() === MediaType.VIDEO);
 
     // Set presence for all the available local tracks.
     for (const track of localTracks) {
         presenceChanged = presenceChanged || muteStatusChanged || videoTypeChanged;
     }
 
-    // Set the presence in the legacy format if there are no local tracks and multi stream support is not enabled.
-    if (!FeatureFlags.isMultiStreamSupportEnabled()) {
-        let audioMuteStatusChanged, videoMuteStatusChanged;
-
-        if (!localAudioTracks?.length) {
-            audioMuteStatusChanged = this._setTrackMuteStatus(MediaType.AUDIO, undefined, true);
-        }
-        if (!localVideoTracks?.length) {
-            videoMuteStatusChanged = this._setTrackMuteStatus(MediaType.VIDEO, undefined, true);
-            videoTypeChanged = this._setNewVideoType();
-        }
-
-        presenceChanged = presenceChanged || audioMuteStatusChanged || videoMuteStatusChanged || videoTypeChanged;
-    }
-
     presenceChanged && this.room.sendPresence();
 };
 

JitsiConferenceEvents.spec.ts

         NOISY_MIC,
         NON_PARTICIPANT_MESSAGE_RECEIVED,
         PRIVATE_MESSAGE_RECEIVED,
-        PARTICIPANT_CONN_STATUS_CHANGED,
         PARTCIPANT_FEATURES_CHANGED,
         PARTICIPANT_PROPERTY_CHANGED,
         P2P_STATUS,
         expect( NOISY_MIC ).toBe( 'conference.noisy_mic' );
         expect( NON_PARTICIPANT_MESSAGE_RECEIVED ).toBe( 'conference.non_participant_message_received' );
         expect( PRIVATE_MESSAGE_RECEIVED ).toBe( 'conference.privateMessageReceived' );
-        expect( PARTICIPANT_CONN_STATUS_CHANGED ).toBe( 'conference.participant_conn_status_changed' );
         expect( PARTCIPANT_FEATURES_CHANGED ).toBe( 'conference.partcipant_features_changed' );
         expect( PARTICIPANT_PROPERTY_CHANGED ).toBe( 'conference.participant_property_changed' );
         expect( P2P_STATUS ).toBe( 'conference.p2pStatus' );
         expect( JitsiConferenceEvents.NOISY_MIC ).toBe( 'conference.noisy_mic' );
         expect( JitsiConferenceEvents.NON_PARTICIPANT_MESSAGE_RECEIVED ).toBe( 'conference.non_participant_message_received' );
         expect( JitsiConferenceEvents.PRIVATE_MESSAGE_RECEIVED ).toBe( 'conference.privateMessageReceived' );
-        expect( JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED ).toBe( 'conference.participant_conn_status_changed' );
         expect( JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED ).toBe( 'conference.partcipant_features_changed' );
         expect( JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED ).toBe( 'conference.participant_property_changed' );
         expect( JitsiConferenceEvents.P2P_STATUS ).toBe( 'conference.p2pStatus' );

JitsiConferenceEvents.ts

      */
     PRIVATE_MESSAGE_RECEIVED = 'conference.privateMessageReceived',
 
-    /**
-     * Event fired when JVB sends notification about interrupted/restored user's
-     * ICE connection status or we detect local problem with the video track.
-     * First argument is the ID of the participant and
-     * the seconds is a string indicating if the connection is currently
-     * - active - the connection is active
-     * - inactive - the connection is inactive, was intentionally interrupted by
-     * the bridge
-     * - interrupted - a network problem occurred
-     * - restoring - the connection was inactive and is restoring now
-     *
-     * The current status value can be obtained by calling
-     * JitsiParticipant.getConnectionStatus().
-     */
-    PARTICIPANT_CONN_STATUS_CHANGED = 'conference.participant_conn_status_changed',
-
     /**
      * Indicates that the features of the participant has been changed.
      * TODO: there is a spelling mistake in this event name and associated constants
 export const NOISY_MIC = JitsiConferenceEvents.NOISY_MIC;
 export const NON_PARTICIPANT_MESSAGE_RECEIVED = JitsiConferenceEvents.NON_PARTICIPANT_MESSAGE_RECEIVED;
 export const PRIVATE_MESSAGE_RECEIVED = JitsiConferenceEvents.PRIVATE_MESSAGE_RECEIVED;
-export const PARTICIPANT_CONN_STATUS_CHANGED = JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED;
 export const PARTCIPANT_FEATURES_CHANGED = JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED;
 export const PARTICIPANT_PROPERTY_CHANGED = JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED;
 export const P2P_STATUS = JitsiConferenceEvents.P2P_STATUS;

JitsiMeetJS.ts

 import RTC from './modules/RTC/RTC';
 import browser from './modules/browser';
 import NetworkInfo from './modules/connectivity/NetworkInfo';
-import { ParticipantConnectionStatus }
-    from './modules/connectivity/ParticipantConnectionStatus';
 import { TrackStreamingStatus } from './modules/connectivity/TrackStreamingStatus';
 import getActiveAudioDevice from './modules/detection/ActiveDeviceDetector';
 import * as DetectionEvents from './modules/detection/DetectionEvents';
     enableWindowOnErrorHandler?: boolean;
     externalStorage?: Storage;
     flags?: {
-        enableUnifiedOnChrome?: boolean;
-        receiveMultipleVideoStreams?: boolean;
         runInLiteMode?: boolean;
-        sendMultipleVideoStreams?: boolean;
-        sourceNameSignaling?: boolean;
         ssrcRewritingEnabled?: boolean;
     }
 }
     ProxyConnectionService,
 
     constants: {
-        participantConnectionStatus: ParticipantConnectionStatus,
         recording: recordingConstants,
         sipVideoGW: VideoSIPGWConstants,
         transcriptionStatus: JitsiTranscriptionStatus,
         Statistics.init(options);
         const flags = options.flags || {};
 
-        // Multi-stream is supported only on endpoints running in Unified plan mode and the flag to disable unified
-        // plan also needs to be taken into consideration.
-        if (typeof options.enableUnifiedOnChrome !== 'undefined') {
-            flags.enableUnifiedOnChrome = options.enableUnifiedOnChrome;
-        }
-
         // Configure the feature flags.
         FeatureFlags.init(flags);
 

JitsiParticipant.js

 
 
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
-import { ParticipantConnectionStatus }
-    from './modules/connectivity/ParticipantConnectionStatus';
 import { MediaType } from './service/RTC/MediaType';
 
 /**
         this._status = status;
         this._hidden = hidden;
         this._statsID = statsID;
-        this._connectionStatus = ParticipantConnectionStatus.ACTIVE;
         this._properties = {};
         this._identity = identity;
         this._isReplacing = isReplacing;
                         && jitsiTrack.isWebRTCTrackMuted()));
     }
 
-    /**
-     * Updates participant's connection status.
-     * @param {string} state the current participant connection state.
-     * {@link ParticipantConnectionStatus}.
-     * @private
-     */
-    _setConnectionStatus(status) {
-        this._connectionStatus = status;
-    }
-
-    /**
-     * Return participant's connectivity status.
-     *
-     * @returns {string} the connection status
-     * <tt>ParticipantConnectionStatus</tt> of the user.
-     * {@link ParticipantConnectionStatus}.
-     */
-    getConnectionStatus() {
-        return this._connectionStatus;
-    }
-
     /**
      * Sets the value of a property of this participant, and fires an event if
      * the value has changed.

modules/RTC/BridgeChannel.js

 
 import RTCEvents from '../../service/RTC/RTCEvents';
 import { createBridgeChannelClosedEvent } from '../../service/statistics/AnalyticsEvents';
-import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 
                 break;
             }
-            case 'LastNEndpointsChangeEvent': {
-                if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-                    // The new/latest list of last-n endpoint IDs (i.e. endpoints for which the bridge is sending
-                    // video).
-                    const lastNEndpoints = obj.lastNEndpoints;
-
-                    logger.info(`New forwarded endpoints: ${lastNEndpoints}`);
-                    emitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED, lastNEndpoints);
-                }
-
-                break;
-            }
             case 'ForwardedSources': {
-                if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                    // The new/latest list of forwarded sources
-                    const forwardedSources = obj.forwardedSources;
+                const forwardedSources = obj.forwardedSources;
 
-                    logger.info(`New forwarded sources: ${forwardedSources}`);
-                    emitter.emit(RTCEvents.FORWARDED_SOURCES_CHANGED, forwardedSources);
-                }
+                logger.info(`New forwarded sources: ${forwardedSources}`);
+                emitter.emit(RTCEvents.FORWARDED_SOURCES_CHANGED, forwardedSources);
 
                 break;
             }
                 break;
             }
             case 'SenderSourceConstraints': {
-                if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                    const { sourceName, maxHeight } = obj;
-
-                    if (typeof sourceName === 'string' && typeof maxHeight === 'number') {
-                        // eslint-disable-next-line object-property-newline
-                        logger.info(`SenderSourceConstraints: ${JSON.stringify({ sourceName, maxHeight })}`);
-                        emitter.emit(
-                            RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED, {
-                                sourceName,
-                                maxHeight
-                            }
-                        );
-                    } else {
-                        logger.error(`Invalid SenderSourceConstraints: ${JSON.stringify(obj)}`);
-                    }
+                if (typeof obj.sourceName === 'string' && typeof obj.maxHeight === 'number') {
+                    logger.info(`SenderSourceConstraints: ${obj.sourceName} - ${obj.maxHeight}`);
+                    emitter.emit(RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED, obj);
+                } else {
+                    logger.error(`Invalid SenderSourceConstraints: ${obj.sourceName} - ${obj.maxHeight}`);
                 }
                 break;
             }

modules/RTC/JitsiLocalTrack.js

      */
     _setMuted(muted) {
         if (this.isMuted() === muted
-            && !(this.videoType === VideoType.DESKTOP && FeatureFlags.isMultiStreamSupportEnabled())) {
+            && !(this.videoType === VideoType.DESKTOP && FeatureFlags.isMultiStreamSendSupportEnabled())) {
             return Promise.resolve();
         }
 
         // the desktop track when screenshare is stopped. Later when screenshare is started again, the same sender will
         // be re-used without the need for signaling a new ssrc through source-add.
         if (this.isAudioTrack()
-                || (this.videoType === VideoType.DESKTOP && !FeatureFlags.isMultiStreamSupportEnabled())
+                || (this.videoType === VideoType.DESKTOP && !FeatureFlags.isMultiStreamSendSupportEnabled())
                 || !browser.doesVideoMuteByStreamRemove()) {
             logMuteInfo();
 
                     { constraints: { video: this._constraints } }));
 
             promise = promise.then(streamsInfo => {
-                // The track kind for presenter track is video as well.
-                const mediaType = this.getType() === MediaType.PRESENTER ? MediaType.VIDEO : this.getType();
-                const streamInfo = streamsInfo.find(info => info.track.kind === mediaType);
+                const streamInfo = streamsInfo.find(info => info.track.kind === this.getType());
 
                 if (streamInfo) {
                     this._setStream(streamInfo.stream);

modules/RTC/JitsiRemoteTrack.js

 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import { createTtfmEvent } from '../../service/statistics/AnalyticsEvents';
 import TrackStreamingStatusImpl, { TrackStreamingStatus } from '../connectivity/TrackStreamingStatus';
-import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
 
 import JitsiTrack from './JitsiTrack';
     _addEventListener(event, handler) {
         super.addListener(event, handler);
 
-        if (FeatureFlags.isSourceNameSignalingEnabled()
-            && event === JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED
+        if (event === JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED
             && this.listenerCount(JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED)
             && !this._trackStreamingStatusImpl
         ) {
     _removeEventListener(event, handler) {
         super.removeListener(event, handler);
 
-        if (FeatureFlags.isSourceNameSignalingEnabled()
-            && event === JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED
+        if (event === JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED
             && !this.listenerCount(JitsiTrackEvents.TRACK_STREAMING_STATUS_CHANGED)
         ) {
             this._disposeTrackStreamingStatus();
      * @returns {Promise}
      */
     dispose() {
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            this._disposeTrackStreamingStatus();
-        }
+        this._disposeTrackStreamingStatus();
 
         return super.dispose();
     }

modules/RTC/RTC.js

 import { MediaType } from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import browser from '../browser';
-import FeatureFlags from '../flags/FeatureFlags';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 import { safeCounterIncrement } from '../util/MathUtil';
          */
         this._selectedEndpoints = null;
 
-        // The last N change listener.
-        this._lastNChangeListener = this._onLastNChanged.bind(this);
-
         // The forwarded sources change listener.
         this._forwardedSourcesChangeListener = this._onForwardedSourcesChanged.bind(this);
 
                     logError(error, 'LastNChangedEvent', this._lastN);
                 }
             }
-            if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-                try {
-                    this._channel.sendVideoTypeMessage(this._videoType);
-                } catch (error) {
-                    logError(error, 'VideoTypeMessage', this._videoType);
-                }
-            }
         };
         this.addListener(RTCEvents.DATA_CHANNEL_OPEN, this._channelOpenListener);
 
-        // Add Last N change listener.
-        this.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED, this._lastNChangeListener);
-
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            // Add forwarded sources change listener.
-            this.addListener(RTCEvents.FORWARDED_SOURCES_CHANGED, this._forwardedSourcesChangeListener);
-        }
+        // Add forwarded sources change listener.
+        this.addListener(RTCEvents.FORWARDED_SOURCES_CHANGED, this._forwardedSourcesChangeListener);
     }
 
     /**
         this._updateAudioOutputForAudioTracks(RTCUtils.getAudioOutputDevice());
     }
 
-    /**
-     * Receives events when Last N had changed.
-     * @param {array} lastNEndpoints The new Last N endpoints.
-     * @private
-     */
-    _onLastNChanged(lastNEndpoints = []) {
-        const oldLastNEndpoints = this._lastNEndpoints || [];
-        let leavingLastNEndpoints = [];
-        let enteringLastNEndpoints = [];
-
-        this._lastNEndpoints = lastNEndpoints;
-
-        leavingLastNEndpoints = oldLastNEndpoints.filter(
-            id => !this.isInLastN(id));
-
-        enteringLastNEndpoints = lastNEndpoints.filter(
-            id => oldLastNEndpoints.indexOf(id) === -1);
-
-        this.conference.eventEmitter.emit(
-            JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
-            leavingLastNEndpoints,
-            enteringLastNEndpoints);
-    }
-
     /**
      * Receives events when forwarded sources had changed.
      *
     setVideoMute(value) {
         const mutePromises = [];
 
-        this.getLocalTracks(MediaType.VIDEO).concat(this.getLocalTracks(MediaType.PRESENTER))
+        this.getLocalTracks(MediaType.VIDEO)
             .forEach(videoTrack => {
                 // this is a Promise
                 mutePromises.push(value ? videoTrack.mute() : videoTrack.unmute());
         if (this._channel) {
             this._channel.close();
             this._channel = null;
-
-            this.removeListener(RTCEvents.LASTN_ENDPOINT_CHANGED, this._lastNChangeListener);
         }
     }
 
         }
     }
 
-    /**
-     * Indicates if the endpoint id is currently included in the last N.
-     * @param {string} id The endpoint id that we check for last N.
-     * @returns {boolean} true if the endpoint id is in the last N or if we
-     * don't have bridge channel support, otherwise we return false.
-     */
-    isInLastN(id) {
-        return !this._lastNEndpoints // lastNEndpoints not initialised yet.
-            || this._lastNEndpoints.indexOf(id) > -1;
-    }
-
     /**
      * Indicates if the source name is currently included in the forwarded sources.
      *

modules/RTC/TPCUtils.js

     calculateEncodingsBitrates(localVideoTrack) {
         const videoType = localVideoTrack.getVideoType();
         const desktopShareBitrate = this.pc.options?.videoQuality?.desktopBitrate || DESKTOP_SHARE_RATE;
-        const presenterEnabled = localVideoTrack._originalStream
-            && localVideoTrack._originalStream.id !== localVideoTrack.getStreamId();
         const lowFpsScreenshare = localVideoTrack.getVideoType() === VideoType.DESKTOP
             && this.pc._capScreenshareBitrate
             && !browser.isWebKitBased();
         const encodingsBitrates = this.localStreamEncodingsConfig
         .map(encoding => {
             const bitrate = lowFpsScreenshare
-
-                // For low fps screensharing, set a max bitrate of 500 Kbps when presenter is not turned on, 2500 Kbps
-                // otherwise.
-                ? presenterEnabled ? HD_BITRATE : desktopShareBitrate
+                ? desktopShareBitrate
 
                 // For high fps screenshare, 'maxBitrate' setting must be cleared on Chrome in plan-b, because
                 // if simulcast is enabled for screen and maxBitrates are set then Chrome will not send the
         const mediaType = newTrack?.getType() ?? oldTrack?.getType();
         const localTracks = this.pc.getLocalTracks(mediaType);
         const track = newTrack?.getTrack() ?? null;
-        const isNewLocalSource = FeatureFlags.isMultiStreamSupportEnabled()
+        const isNewLocalSource = FeatureFlags.isMultiStreamSendSupportEnabled()
             && localTracks?.length
             && !oldTrack
             && newTrack

modules/RTC/TraceablePeerConnection.js

         return;
     }
 
+    let sourceName = this.signalingLayer.getTrackSourceName(trackSsrc);
 
-    let sourceName;
-
-    if (FeatureFlags.isSourceNameSignalingEnabled()) {
-        sourceName = this.signalingLayer.getTrackSourceName(trackSsrc);
-
-        // If source name was not signaled, we'll generate one which allows testing signaling
-        // when mixing legacy(mobile) with new clients.
-        if (!sourceName) {
-            sourceName = getSourceNameForJitsiTrack(ownerEndpointId, mediaType, 0);
-        }
+    // If source name was not signaled, we'll generate one which allows testing signaling
+    // when mixing legacy(mobile) with new clients.
+    if (!sourceName) {
+        sourceName = getSourceNameForJitsiTrack(ownerEndpointId, mediaType, 0);
     }
 
     // eslint-disable-next-line no-undef
         logger.info(`${this} ignored duplicated track event for track[endpoint=${ownerEndpointId},type=${mediaType}]`);
 
         return;
-    } else if (userTracksByMediaType?.size && !FeatureFlags.isSourceNameSignalingEnabled()) {
-        logger.error(`${this} received a second remote track for track[endpoint=${ownerEndpointId},type=${mediaType}]`
-            + 'deleting the existing track');
-        const existingTrack = Array.from(userTracksByMediaType)[0];
-
-        // The existing track needs to be removed here. This happens on Safari sometimes when an SSRC is removed from
-        // the remote description and the browser doesn't fire a 'removetrack' event on the associated MediaStream.
-        this._remoteTrackRemoved(existingTrack.getOriginalStream(), existingTrack.getTrack());
     }
 
     const remoteTrack
 
     let media = session.media;
 
-    // For unified plan clients, only the first audio and video mlines will have ssrcs for the local sources.
-    // The rest of the m-lines are for the recv-only sources, one for each remote source.
     if (this._usesUnifiedPlan) {
-        if (FeatureFlags.isMultiStreamSupportEnabled()) {
-            media = media.filter(mline => mline.direction === MediaDirection.SENDONLY
-                || mline.direction === MediaDirection.SENDRECV);
-        } else {
-            media = [];
-            [ MediaType.AUDIO, MediaType.VIDEO ].forEach(mediaType => {
-                const mLine = session.media.find(m => m.type === mediaType);
+        media = media.filter(mline => mline.direction === MediaDirection.SENDONLY
+            || mline.direction === MediaDirection.SENDRECV);
+    } else {
+        media = [];
+        [ MediaType.AUDIO, MediaType.VIDEO ].forEach(mediaType => {
+            const mLine = session.media.find(m => m.type === mediaType);
 
-                mLine && media.push(mLine);
-            });
-        }
+            mLine && media.push(mLine);
+        });
     }
 
     let index = 0;
             // the standard and the unified plan SDPs do not have a proper msid attribute for the sources.
             // Also the ssrcs for sources do not change for Unified plan clients since RTCRtpSender#replaceTrack is
             // used for switching the tracks so it is safe to use the mediaType as the key for the TrackSSRCInfo map.
-            const key = this._usesUnifiedPlan
-                ? FeatureFlags.isMultiStreamSupportEnabled() ? `${mLine.type}-${index}` : mLine.type
-                : ssrc.value;
+            const key = this._usesUnifiedPlan ? `${mLine.type}-${index}` : ssrc.value;
             const ssrcNumber = ssrc.id;
             let ssrcInfo = ssrcMap.get(key);
 
 
     // Find all the m-lines associated with the local sources.
     const direction = isLocalSdp ? MediaDirection.RECVONLY : MediaDirection.SENDONLY;
-    const mLines = FeatureFlags.isMultiStreamSupportEnabled()
-        ? parsedSdp.media.filter(m => m.type === MediaType.VIDEO && m.direction !== direction)
-        : [ parsedSdp.media.find(m => m.type === MediaType.VIDEO) ];
+    const mLines = parsedSdp.media.filter(m => m.type === MediaType.VIDEO && m.direction !== direction);
 
     for (const mLine of mLines) {
         if (this.codecPreference.mimeType === CodecMimeType.VP9) {
             const bitrates = this.tpcUtils.videoBitrates.VP9 || this.tpcUtils.videoBitrates;
             const hdBitrate = bitrates.high ? bitrates.high : HD_BITRATE;
             const mid = mLine.mid;
-            const isSharingScreen = FeatureFlags.isMultiStreamSupportEnabled()
+            const isSharingScreen = FeatureFlags.isMultiStreamSendSupportEnabled()
                 ? mid === this._getDesktopTrackMid()
                 : this._isSharingScreen();
             const limit = Math.floor((isSharingScreen ? HD_BITRATE : hdBitrate) / 1000);
  * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
 TraceablePeerConnection.prototype.configureSenderVideoEncodings = function(localVideoTrack = null) {
-    if (FeatureFlags.isSourceNameSignalingEnabled()) {
-        if (localVideoTrack) {
-            return this.setSenderVideoConstraints(
-                this._senderMaxHeights.get(localVideoTrack.getSourceName()),
-                localVideoTrack);
-        }
-        const promises = [];
-
-        for (const track of this.getLocalVideoTracks()) {
-            promises.push(this.setSenderVideoConstraints(this._senderMaxHeights.get(track.getSourceName()), track));
-        }
-
-        return Promise.allSettled(promises);
+    if (localVideoTrack) {
+        return this.setSenderVideoConstraints(
+            this._senderMaxHeights.get(localVideoTrack.getSourceName()),
+            localVideoTrack);
     }
+    const promises = [];
 
-    let localTrack = localVideoTrack;
-
-    if (!localTrack) {
-        localTrack = this.getLocalVideoTracks()[0];
+    for (const track of this.getLocalVideoTracks()) {
+        promises.push(this.setSenderVideoConstraints(this._senderMaxHeights.get(track.getSourceName()), track));
     }
 
-    return this.setSenderVideoConstraints(this._senderVideoMaxHeight, localTrack);
+    return Promise.allSettled(promises);
 };
 
 TraceablePeerConnection.prototype.setLocalDescription = function(description) {
         return Promise.resolve();
     }
 
-    if (FeatureFlags.isSourceNameSignalingEnabled()) {
-        const sourceName = localVideoTrack.getSourceName();
+    const sourceName = localVideoTrack.getSourceName();
 
-        if (this._senderMaxHeights.get(sourceName) === frameHeight) {
-            return Promise.resolve();
-        }
-        this._senderMaxHeights.set(sourceName, frameHeight);
-    } else {
-        this._senderVideoMaxHeight = frameHeight;
+    if (this._senderMaxHeights.get(sourceName) === frameHeight) {
+        return Promise.resolve();
     }
+    this._senderMaxHeights.set(sourceName, frameHeight);
 
     if (!localVideoTrack || localVideoTrack.isMuted()) {
         return Promise.resolve();
  */
 TraceablePeerConnection.prototype._processLocalSSRCsMap = function(ssrcMap) {
     for (const track of this.localTracks.values()) {
-        let sourceIndex, sourceName;
-
-        if (FeatureFlags.isMultiStreamSupportEnabled()) {
-            sourceName = track.getSourceName();
-            sourceIndex = getSourceIndexFromSourceName(sourceName);
-        }
-
+        const sourceName = track.getSourceName();
+        const sourceIndex = getSourceIndexFromSourceName(sourceName);
         const sourceIdentifier = this._usesUnifiedPlan
-            ? FeatureFlags.isMultiStreamSupportEnabled()
-                ? `${track.getType()}-${sourceIndex}` : track.getType()
+            ? `${track.getType()}-${sourceIndex}`
             : track.storedMSID;
 
         if (ssrcMap.has(sourceIdentifier)) {

modules/connectivity/ParticipantConnectionStatus.js

-import { getLogger } from '@jitsi/logger';
-
-import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
-import * as JitsiTrackEvents from '../../JitsiTrackEvents';
-import { MediaType } from '../../service/RTC/MediaType';
-import RTCEvents from '../../service/RTC/RTCEvents';
-import { createParticipantConnectionStatusEvent } from '../../service/statistics/AnalyticsEvents';
-import browser from '../browser';
-import Statistics from '../statistics/statistics';
-
-const logger = getLogger(__filename);
-
-/**
- * Default value of 500 milliseconds for {@link ParticipantConnectionStatus.outOfLastNTimeout}.
- *
- * @type {number}
- */
-const DEFAULT_NOT_IN_LAST_N_TIMEOUT = 500;
-
-/**
- * Default value of 2500 milliseconds for {@link ParticipantConnectionStatus.p2pRtcMuteTimeout}.
- */
-const DEFAULT_P2P_RTC_MUTE_TIMEOUT = 2500;
-
-/**
- * Default value of 10000 milliseconds for {@link ParticipantConnectionStatus.rtcMuteTimeout}.
- *
- * @type {number}
- */
-const DEFAULT_RTC_MUTE_TIMEOUT = 10000;
-
-/**
- * The time to wait a track to be restored. Track which was out of lastN
- * should be inactive and when entering lastN it becomes restoring and when
- * data is received from bridge it will become active, but if no data is
- * received for some time we set status of that participant connection to
- * interrupted.
- * @type {number}
- */
-const DEFAULT_RESTORING_TIMEOUT = 10000;
-
-/**
- * Participant connection statuses.
- *
- * @type {{
- *      ACTIVE: string,
- *      INACTIVE: string,
- *      INTERRUPTED: string,
- *      RESTORING: string
- * }}
- */
-export const ParticipantConnectionStatus = {
-    /**
-     * Status indicating that connection is currently active.
-     */
-    ACTIVE: 'active',
-
-    /**
-     * Status indicating that connection is currently inactive.
-     * Inactive means the connection was stopped on purpose from the bridge,
-     * like exiting lastN or adaptivity decided to drop video because of not
-     * enough bandwidth.
-     */
-    INACTIVE: 'inactive',
-
-    /**
-     * Status indicating that connection is currently interrupted.
-     */
-    INTERRUPTED: 'interrupted',
-
-    /**
-     * Status indicating that connection is currently restoring.
-     */
-    RESTORING: 'restoring'
-};
-
-/**
- * Class is responsible for emitting
- * JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED events.
- */
-export default class ParticipantConnectionStatusHandler {
-    /* eslint-disable max-params*/
-    /**
-     * Calculates the new {@link ParticipantConnectionStatus} based on
-     * the values given for some specific remote user. It is assumed that
-     * the conference is currently in the JVB mode (in contrary to the P2P mode)
-     * @param {boolean} isConnectionActiveByJvb true if the JVB did not get any
-     * data from the user for the last 15 seconds.
-     * @param {boolean} isInLastN indicates whether the user is in the last N
-     * set. When set to false it means that JVB is not sending any video for
-     * the user.
-     * @param {boolean} isRestoringTimedout if true it means that the user has
-     * been outside of last N too long to be considered
-     * {@link ParticipantConnectionStatus.RESTORING}.
-     * @param {boolean} isVideoMuted true if the user is video muted and we
-     * should not expect to receive any video.
-     * @param {boolean} isVideoTrackFrozen if the current browser support video
-     * frozen detection then it will be set to true when the video track is
-     * frozen. If the current browser does not support frozen detection the it's
-     * always false.
-     * @return {ParticipantConnectionStatus} the new connection status for
-     * the user for whom the values above were provided.
-     * @private
-     */
-    static _getNewStateForJvbMode(
-            isConnectionActiveByJvb,
-            isInLastN,
-            isRestoringTimedout,
-            isVideoMuted,
-            isVideoTrackFrozen) {
-        if (!isConnectionActiveByJvb) {
-            // when there is a connection problem signaled from jvb
-            // it means no media was flowing for at least 15secs, so both audio
-            // and video are most likely interrupted
-            return ParticipantConnectionStatus.INTERRUPTED;
-        } else if (isVideoMuted) {
-            // If the connection is active according to JVB and the user is
-            // video muted there is no way for the connection to be inactive,
-            // because the detection logic below only makes sense for video.
-            return ParticipantConnectionStatus.ACTIVE;
-        }
-
-        // Logic when isVideoTrackFrozen is supported
-        if (browser.supportsVideoMuteOnConnInterrupted()) {
-            if (!isVideoTrackFrozen) {
-                // If the video is playing we're good
-                return ParticipantConnectionStatus.ACTIVE;
-            } else if (isInLastN) {
-                return isRestoringTimedout
-                    ? ParticipantConnectionStatus.INTERRUPTED
-                    : ParticipantConnectionStatus.RESTORING;
-            }
-
-            return ParticipantConnectionStatus.INACTIVE;
-        }
-
-        // Because this browser is incapable of detecting frozen video we must
-        // rely on the lastN value
-        return isInLastN
-            ? ParticipantConnectionStatus.ACTIVE
-            : ParticipantConnectionStatus.INACTIVE;
-    }
-
-    /* eslint-enable max-params*/
-
-    /**
-     * In P2P mode we don't care about any values coming from the JVB and
-     * the connection status can be only active or interrupted.
-     * @param {boolean} isVideoMuted the user if video muted
-     * @param {boolean} isVideoTrackFrozen true if the video track for
-     * the remote user is currently frozen. If the current browser does not
-     * support video frozen detection then it's always false.
-     * @return {ParticipantConnectionStatus}
-     * @private
-     */
-    static _getNewStateForP2PMode(isVideoMuted, isVideoTrackFrozen) {
-        if (!browser.supportsVideoMuteOnConnInterrupted()) {
-            // There's no way to detect problems in P2P when there's no video
-            // track frozen detection...
-            return ParticipantConnectionStatus.ACTIVE;
-        }
-
-        return isVideoMuted || !isVideoTrackFrozen
-            ? ParticipantConnectionStatus.ACTIVE
-            : ParticipantConnectionStatus.INTERRUPTED;
-    }
-
-    /**
-     * Creates new instance of <tt>ParticipantConnectionStatus</tt>.
-     *
-     * @constructor
-     * @param {RTC} rtc the RTC service instance
-     * @param {JitsiConference} conference parent conference instance
-     * @param {Object} options
-     * @param {number} [options.p2pRtcMuteTimeout=2500] custom value for
-     * {@link ParticipantConnectionStatus.p2pRtcMuteTimeout}.
-     * @param {number} [options.rtcMuteTimeout=10000] custom value for
-     * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
-     * @param {number} [options.outOfLastNTimeout=500] custom value for
-     * {@link ParticipantConnectionStatus.outOfLastNTimeout}.
-     */
-    constructor(rtc, conference, options) {
-        this.rtc = rtc;
-        this.conference = conference;
-
-        /**
-         * A map of the "endpoint ID"(which corresponds to the resource part
-         * of MUC JID(nickname)) to the timeout callback IDs scheduled using
-         * window.setTimeout.
-         * @type {Object.<string, number>}
-         */
-        this.trackTimers = {};
-
-        /**
-         * This map holds the endpoint connection status received from the JVB
-         * (as it might be different than the one stored in JitsiParticipant).
-         * Required for getting back in sync when remote video track is removed.
-         * @type {Object.<string, boolean>}
-         */
-        this.connStatusFromJvb = { };
-
-        /**
-         * If video track frozen detection through RTC mute event is supported,
-         * we wait some time until video track is considered frozen. But because
-         * when the user falls out of last N it is expected for the video to
-         * freeze this timeout must be significantly reduced in "out of last N"
-         * case.
-         *
-         * Basically this value is used instead of {@link rtcMuteTimeout} when
-         * user is not in last N.
-         * @type {number}
-         */
-        this.outOfLastNTimeout
-            = typeof options.outOfLastNTimeout === 'number'
-                ? options.outOfLastNTimeout : DEFAULT_NOT_IN_LAST_N_TIMEOUT;
-
-        /**
-         * How long we are going to wait for the corresponding signaling mute event after the RTC video track muted
-         * event is fired on the Media stream, before the connection interrupted is fired. The default value is
-         * {@link DEFAULT_P2P_RTC_MUTE_TIMEOUT}.
-         *
-         * @type {number} amount of time in milliseconds.
-         */
-        this.p2pRtcMuteTimeout = typeof options.p2pRtcMuteTimeout === 'number'
-            ? options.p2pRtcMuteTimeout : DEFAULT_P2P_RTC_MUTE_TIMEOUT;
-
-        /**
-         * How long we're going to wait after the RTC video track muted event
-         * for the corresponding signalling mute event, before the connection
-         * interrupted is fired. The default value is
-         * {@link DEFAULT_RTC_MUTE_TIMEOUT}.
-         *
-         * @type {number} amount of time in milliseconds
-         */
-        this.rtcMuteTimeout
-            = typeof options.rtcMuteTimeout === 'number'
-                ? options.rtcMuteTimeout : DEFAULT_RTC_MUTE_TIMEOUT;
-
-        /**
-         * This map holds a timestamp indicating  when participant's video track
-         * was RTC muted (it is assumed that each participant can have only 1
-         * video track at a time). The purpose of storing the timestamp is to
-         * avoid the transition to disconnected status in case of legitimate
-         * video mute operation where the signalling video muted event can
-         * arrive shortly after RTC muted event.
-         *
-         * The key is participant's ID which is the same as endpoint id in
-         * the Colibri conference allocated on the JVB.
-         *
-         * The value is a timestamp measured in milliseconds obtained with
-         * <tt>Date.now()</tt>.
-         *
-         * FIXME merge this logic with NO_DATA_FROM_SOURCE event
-         *       implemented in JitsiLocalTrack by extending the event to
-         *       the remote track and allowing to set different timeout for
-         *       local and remote tracks.
-         *
-         * @type {Object.<string, number>}
-         */
-        this.rtcMutedTimestamp = { };
-        logger.info(`RtcMuteTimeout set to: ${this.rtcMuteTimeout}`);
-
-        /**
-         * This map holds the timestamps indicating when participant's video
-         * entered lastN set. Participants entering lastN will have connection
-         * status restoring and when we start receiving video will become
-         * active, but if video is not received for certain time
-         * {@link DEFAULT_RESTORING_TIMEOUT} that participant connection status
-         * will become interrupted.
-         *
-         * @type {Map<string, number>}
-         */
-        this.enteredLastNTimestamp = new Map();
-
-        /**
-         * A map of the "endpoint ID"(which corresponds to the resource part
-         * of MUC JID(nickname)) to the restoring timeout callback IDs
-         * scheduled using window.setTimeout.
-         *
-         * @type {Map<string, number>}
-         */
-        this.restoringTimers = new Map();
-
-        /**
-         * A map that holds the current connection status (along with all the internal events that happen
-         * while in that state).
-         *
-         * The goal is to send this information to the analytics backend for post-mortem analysis.
-         */
-        this.connectionStatusMap = new Map();
-    }
-
-    /**
-     * Gets the video frozen timeout for given user.
-     * @param {string} id endpoint/participant ID
-     * @return {number} how long are we going to wait since RTC video muted
-     * even, before a video track is considered frozen.
-     * @private
-     */
-    _getVideoFrozenTimeout(id) {
-        return this.rtc.isInLastN(id)
-            ? this.rtcMuteTimeout
-            : this.conference.isP2PActive() ? this.p2pRtcMuteTimeout : this.outOfLastNTimeout;
-    }
-
-    /**
-     * Initializes <tt>ParticipantConnectionStatus</tt> and bind required event
-     * listeners.
-     */
-    init() {
-
-        this._onEndpointConnStatusChanged
-            = this.onEndpointConnStatusChanged.bind(this);
-
-        this.rtc.addListener(
-            RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
-            this._onEndpointConnStatusChanged);
-
-        // Handles P2P status changes
-        this._onP2PStatus = this.refreshConnectionStatusForAll.bind(this);
-        this.conference.on(JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
-
-        // Used to send analytics events for the participant that left the call.
-        this._onUserLeft = this.onUserLeft.bind(this);
-        this.conference.on(JitsiConferenceEvents.USER_LEFT, this._onUserLeft);
-
-        // On some browsers MediaStreamTrack trigger "onmute"/"onunmute"
-        // events for video type tracks when they stop receiving data which is
-        // often a sign that remote user is having connectivity issues
-        if (browser.supportsVideoMuteOnConnInterrupted()) {
-
-            this._onTrackRtcMuted = this.onTrackRtcMuted.bind(this);
-            this.rtc.addListener(
-                RTCEvents.REMOTE_TRACK_MUTE, this._onTrackRtcMuted);
-
-            this._onTrackRtcUnmuted = this.onTrackRtcUnmuted.bind(this);
-            this.rtc.addListener(
-                RTCEvents.REMOTE_TRACK_UNMUTE, this._onTrackRtcUnmuted);
-
-            // Track added/removed listeners are used to bind "mute"/"unmute"
-            // event handlers
-            this._onRemoteTrackAdded = this.onRemoteTrackAdded.bind(this);
-            this.conference.on(
-                JitsiConferenceEvents.TRACK_ADDED,
-                this._onRemoteTrackAdded);
-
-            this._onRemoteTrackRemoved = this.onRemoteTrackRemoved.bind(this);
-            this.conference.on(
-                JitsiConferenceEvents.TRACK_REMOVED,
-                this._onRemoteTrackRemoved);
-
-            // Listened which will be bound to JitsiRemoteTrack to listen for
-            // signalling mute/unmute events.
-            this._onSignallingMuteChanged
-                = this.onSignallingMuteChanged.bind(this);
-
-            // Used to send an analytics event when the video type changes.
-            this._onTrackVideoTypeChanged
-                = this.onTrackVideoTypeChanged.bind(this);
-        }
-
-        this._onLastNChanged = this._onLastNChanged.bind(this);
-        this.conference.on(
-            JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
-            this._onLastNChanged);
-
-        this._onLastNValueChanged
-            = this.refreshConnectionStatusForAll.bind(this);
-        this.rtc.on(
-            RTCEvents.LASTN_VALUE_CHANGED, this._onLastNValueChanged);
-    }
-
-    /**
-     * Removes all event listeners and disposes of all resources held by this
-     * instance.
-     */
-    dispose() {
-
-        this.rtc.removeListener(
-            RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
-            this._onEndpointConnStatusChanged);
-
-        if (browser.supportsVideoMuteOnConnInterrupted()) {
-            this.rtc.removeListener(
-                RTCEvents.REMOTE_TRACK_MUTE,
-                this._onTrackRtcMuted);
-            this.rtc.removeListener(
-                RTCEvents.REMOTE_TRACK_UNMUTE,
-                this._onTrackRtcUnmuted);
-
-            this.conference.off(
-                JitsiConferenceEvents.TRACK_ADDED,
-                this._onRemoteTrackAdded);
-            this.conference.off(
-                JitsiConferenceEvents.TRACK_REMOVED,
-                this._onRemoteTrackRemoved);
-        }
-
-        this.conference.off(
-            JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
-            this._onLastNChanged);
-
-        this.rtc.removeListener(
-            RTCEvents.LASTN_VALUE_CHANGED, this._onLastNValueChanged);
-
-        this.conference.off(
-            JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
-
-        this.conference.off(
-            JitsiConferenceEvents.USER_LEFT, this._onUserLeft);
-
-        const participantIds = Object.keys(this.trackTimers);
-
-        for (const participantId of participantIds) {
-            this.clearTimeout(participantId);
-            this.clearRtcMutedTimestamp(participantId);
-        }
-
-        for (const id in this.connectionStatusMap) {
-            if (this.connectionStatusMap.hasOwnProperty(id)) {
-                this.onUserLeft(id);
-            }
-        }
-
-        // Clear RTC connection status cache
-        this.connStatusFromJvb = {};
-    }
-
-    /**
-     * Handles RTCEvents.ENDPOINT_CONN_STATUS_CHANGED triggered when we receive
-     * notification over the data channel from the bridge about endpoint's
-     * connection status update.
-     * @param {string} endpointId - The endpoint ID(MUC nickname/resource JID).
-     * @param {boolean} isActive - true if the connection is OK or false otherwise.
-     */
-    onEndpointConnStatusChanged(endpointId, isActive) {
-
-        logger.debug(
-            `Detector RTCEvents.ENDPOINT_CONN_STATUS_CHANGED(${Date.now()}): ${
-                endpointId}: ${isActive}`);
-
-        // Filter out events for the local JID for now
-        if (endpointId !== this.conference.myUserId()) {
-            // Store the status received over the data channels
-            this.connStatusFromJvb[endpointId] = isActive;
-            this.figureOutConnectionStatus(endpointId);
-        }
-    }
-
-    /**
-     * Changes connection status.
-     * @param {JitsiParticipant} participant
-     * @param newStatus
-     */
-    _changeConnectionStatus(participant, newStatus) {
-        if (participant.getConnectionStatus() !== newStatus) {
-
-            const endpointId = participant.getId();
-
-            participant._setConnectionStatus(newStatus);
-
-            logger.debug(
-                `Emit endpoint conn status(${Date.now()}) ${endpointId}: ${
-                    newStatus}`);
-
-            // Log the event on CallStats
-            Statistics.sendLog(
-                JSON.stringify({
-                    id: 'peer.conn.status',
-                    participant: endpointId,
-                    status: newStatus
-                }));
-
-
-            this.conference.eventEmitter.emit(
-                JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
-                endpointId, newStatus);
-        }
-    }
-
-    /**
-     * Reset the postponed "connection interrupted" event which was previously
-     * scheduled as a timeout on RTC 'onmute' event.
-     *
-     * @param {string} participantId - The participant for which the "connection
-     * interrupted" timeout was scheduled.
-     */
-    clearTimeout(participantId) {
-        if (this.trackTimers[participantId]) {
-            window.clearTimeout(this.trackTimers[participantId]);
-            this.trackTimers[participantId] = null;
-        }
-    }
-
-    /**
-     * Clears the timestamp of the RTC muted event for participant's video track
-     * @param {string} participantId the id of the conference participant which
-     * is the same as the Colibri endpoint ID of the video channel allocated for
-     * the user on the videobridge.
-     */
-    clearRtcMutedTimestamp(participantId) {
-        this.rtcMutedTimestamp[participantId] = null;
-    }
-
-    /**
-     * Bind signalling mute event listeners for video {JitsiRemoteTrack} when
-     * a new one is added to the conference.
-     *
-     * @param {JitsiTrack} remoteTrack - The {JitsiTrack} which is being added to
-     * the conference.
-     */
-    onRemoteTrackAdded(remoteTrack) {
-        if (!remoteTrack.isLocal()
-                && remoteTrack.getType() === MediaType.VIDEO) {
-
-            logger.debug(
-                `Detector on remote track added for: ${
-                    remoteTrack.getParticipantId()}`);
-
-            remoteTrack.on(
-                JitsiTrackEvents.TRACK_MUTE_CHANGED,
-                this._onSignallingMuteChanged);
-            remoteTrack.on(
-                JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED,
-                videoType => this._onTrackVideoTypeChanged(remoteTrack, videoType));
-        }
-    }
-
-    /**
-     * Removes all event listeners bound to the remote video track and clears
-     * any related timeouts.
-     *
-     * @param {JitsiRemoteTrack} remoteTrack - The remote track which is being
-     * removed from the conference.
-     */
-    onRemoteTrackRemoved(remoteTrack) {
-        if (!remoteTrack.isLocal()
-                && remoteTrack.getType() === MediaType.VIDEO) {
-
-            const endpointId = remoteTrack.getParticipantId();
-
-            logger.debug(`Detector on remote track removed: ${endpointId}`);
-
-            remoteTrack.off(
-                JitsiTrackEvents.TRACK_MUTE_CHANGED,
-                this._onSignallingMuteChanged);
-
-            this.clearTimeout(endpointId);
-            this.clearRtcMutedTimestamp(endpointId);
-
-            this.figureOutConnectionStatus(endpointId);
-        }
-    }
-
-    /**
-     * Checks if given participant's video is considered frozen.
-     * @param {JitsiParticipant} participant - The participant.
-     * @return {boolean} <tt>true</tt> if the video has frozen for given
-     * participant or <tt>false</tt> when it's either not considered frozen
-     * (yet) or if freeze detection is not supported by the current browser.
-     *
-     * FIXME merge this logic with NO_DATA_FROM_SOURCE event
-     *       implemented in JitsiLocalTrack by extending the event to
-     *       the remote track and allowing to set different timeout for
-     *       local and remote tracks.
-     *
-     */
-    isVideoTrackFrozen(participant) {
-        if (!browser.supportsVideoMuteOnConnInterrupted()) {
-            return false;
-        }
-
-        const id = participant.getId();
-        const hasAnyVideoRTCMuted = participant.hasAnyVideoTrackWebRTCMuted();
-        const rtcMutedTimestamp = this.rtcMutedTimestamp[id];
-        const timeout = this._getVideoFrozenTimeout(id);
-
-        return hasAnyVideoRTCMuted
-            && typeof rtcMutedTimestamp === 'number'
-            && (Date.now() - rtcMutedTimestamp) >= timeout;
-    }
-
-    /**
-     * Goes over every participant and updates connectivity status.
-     * Should be called when a parameter which affects all of the participants
-     * is changed (P2P for example).
-     */
-    refreshConnectionStatusForAll() {
-        const participants = this.conference.getParticipants();
-
-        for (const participant of participants) {
-            this.figureOutConnectionStatus(participant.getId());
-        }
-    }
-
-    /**
-     * Figures out (and updates) the current connectivity status for
-     * the participant identified by the given id.
-     *
-     * @param {string} id - The participant's id (MUC nickname or Colibri endpoint ID).
-     */
-    figureOutConnectionStatus(id) {
-        const participant = this.conference.getParticipantById(id);
-
-        if (!participant) {
-            // Probably the participant is no longer in the conference
-            // (at the time of writing this code, participant is
-            // detached from the conference and TRACK_REMOVED events are
-            // fired),
-            // so we don't care, but let's print a log message for debugging purposes.
-            logger.debug(`figure out conn status - no participant for: ${id}`);
-
-            return;
-        }
-
-        const inP2PMode = this.conference.isP2PActive();
-        const isRestoringTimedOut = this._isRestoringTimedout(id);
-        const audioOnlyMode = this.conference.getLastN() === 0;
-
-        // NOTE Overriding videoMuted to true for audioOnlyMode should disable
-        // any detection based on video playback or the last N.
-        const isVideoMuted = participant.isVideoMuted() || audioOnlyMode;
-        const isVideoTrackFrozen = this.isVideoTrackFrozen(participant);
-        const isInLastN = this.rtc.isInLastN(id);
-        let isConnActiveByJvb = this.connStatusFromJvb[id];
-
-        if (typeof isConnActiveByJvb !== 'boolean') {
-            // If no status was received from the JVB it means that it's active
-            // (the bridge does not send notification unless there is a problem)
-            isConnActiveByJvb = true;
-        }
-
-        const newState
-            = inP2PMode
-                ? ParticipantConnectionStatusHandler._getNewStateForP2PMode(
-                    isVideoMuted,
-                    isVideoTrackFrozen)
-                : ParticipantConnectionStatusHandler._getNewStateForJvbMode(
-                    isConnActiveByJvb,
-                    isInLastN,
-                    isRestoringTimedOut,
-                    isVideoMuted,
-                    isVideoTrackFrozen);
-
-        // if the new state is not restoring clear timers and timestamps
-        // that we use to track the restoring state
-        if (newState !== ParticipantConnectionStatus.RESTORING) {
-            this._clearRestoringTimer(id);
-        }
-
-        logger.debug(
-            `Figure out conn status for ${id}, is video muted: ${
-                isVideoMuted} is active(jvb): ${
-                isConnActiveByJvb} video track frozen: ${
-                isVideoTrackFrozen} p2p mode: ${
-                inP2PMode} is in last N: ${
-                isInLastN} currentStatus => newStatus: ${
-                participant.getConnectionStatus()} => ${newState}`);
-
-        const oldConnectionStatus = this.connectionStatusMap[id] || {};
-
-        // Send an analytics event (guard on either the p2p flag or the connection status has changed
-        // since the last time this code block run).
-        if (!('p2p' in oldConnectionStatus)
-            || !('connectionStatus' in oldConnectionStatus)
-            || oldConnectionStatus.p2p !== inP2PMode
-            || oldConnectionStatus.connectionStatus !== newState) {
-
-            const nowMs = Date.now();
-
-            this.maybeSendParticipantConnectionStatusEvent(id, nowMs);
-
-            this.connectionStatusMap[id] = {
-                ...oldConnectionStatus,
-                connectionStatus: newState,
-                p2p: inP2PMode,
-                startedMs: nowMs
-            };
-
-            // sometimes (always?) we're late to hook the TRACK_VIDEOTYPE_CHANGED event and the
-            // video type is not in oldConnectionStatus.
-            if (!('videoType' in this.connectionStatusMap[id])) {
-                const videoTracks = participant.getTracksByMediaType(MediaType.VIDEO);
-
-                if (Array.isArray(videoTracks) && videoTracks.length !== 0) {
-                    this.connectionStatusMap[id].videoType = videoTracks[0].videoType;
-                }
-            }
-        }
-        this._changeConnectionStatus(participant, newState);
-    }
-
-    /**
-     * Computes the duration of the current connection status for the participant with the specified id (i.e. 15 seconds
-     * in the INTERRUPTED state) and sends a participant connection status event.
-     * @param {string} id - The jid of the participant.
-     * @param {Number} nowMs - The current time (in millis).
-     * @returns {void}
-     */
-    maybeSendParticipantConnectionStatusEvent(id, nowMs) {
-        const participantConnectionStatus = this.connectionStatusMap[id];
-
-        if (participantConnectionStatus
-            && 'startedMs' in participantConnectionStatus
-            && 'videoType' in participantConnectionStatus
-            && 'connectionStatus' in participantConnectionStatus
-            && 'p2p' in participantConnectionStatus) {
-            participantConnectionStatus.value = nowMs - participantConnectionStatus.startedMs;
-            Statistics.sendAnalytics(
-                createParticipantConnectionStatusEvent(participantConnectionStatus));
-        }
-    }
-
-    /**
-     * On change in Last N set check all leaving and entering participants to
-     * change their corresponding statuses.
-     *
-     * @param {Array<string>} leavingLastN - The array of ids leaving lastN.
-     * @param {Array<string>} enteringLastN - The array of ids entering lastN.
-     * @private
-     */
-    _onLastNChanged(leavingLastN = [], enteringLastN = []) {
-        const now = Date.now();
-
-        logger.debug(`LastN endpoints changed leaving=${leavingLastN}, entering=${enteringLastN} at ${now}`);
-
-        // If the browser doesn't fire the mute/onmute events when the remote peer stops/starts sending media,
-        // calculate the connection status for all the endpoints since it won't get triggered automatically on
-        // the endpoint that has started/stopped receiving media.
-        if (!browser.supportsVideoMuteOnConnInterrupted()) {
-            this.refreshConnectionStatusForAll();
-        }
-
-        for (const id of leavingLastN) {
-            this.enteredLastNTimestamp.delete(id);
-            this._clearRestoringTimer(id);
-            browser.supportsVideoMuteOnConnInterrupted() && this.figureOutConnectionStatus(id);
-        }
-        for (const id of enteringLastN) {
-            // store the timestamp this id is entering lastN
-            this.enteredLastNTimestamp.set(id, now);
-            browser.supportsVideoMuteOnConnInterrupted() && this.figureOutConnectionStatus(id);
-        }
-    }
-
-    /**
-     * Clears the restoring timer for participant's video track and the
-     * timestamp for entering lastN.
-     *
-     * @param {string} participantId - The id of the conference participant which
-     * is the same as the Colibri endpoint ID of the video channel allocated for
-     * the user on the videobridge.
-     */
-    _clearRestoringTimer(participantId) {
-        const rTimer = this.restoringTimers.get(participantId);
-
-        if (rTimer) {
-            clearTimeout(rTimer);
-            this.restoringTimers.delete(participantId);
-        }
-    }
-
-    /**
-     * Checks whether a track had stayed enough in restoring state, compares
-     * current time and the time the track entered in lastN. If it hasn't
-     * timedout and there is no timer added, add new timer in order to give it
-     * more time to become active or mark it as interrupted on next check.
-     *
-     * @param {string} participantId - The id of the conference participant which
-     * is the same as the Colibri endpoint ID of the video channel allocated for
-     * the user on the videobridge.
-     * @returns {boolean} <tt>true</tt> if the track was in restoring state
-     * more than the timeout ({@link DEFAULT_RESTORING_TIMEOUT}.) in order to
-     * set its status to interrupted.
-     * @private
-     */
-    _isRestoringTimedout(participantId) {
-        const enteredLastNTimestamp
-            = this.enteredLastNTimestamp.get(participantId);
-
-        if (enteredLastNTimestamp
-            && (Date.now() - enteredLastNTimestamp)
-                >= DEFAULT_RESTORING_TIMEOUT) {
-            return true;
-        }
-
-        // still haven't reached timeout, if there is no timer scheduled,
-        // schedule one so we can track the restoring state and change it after
-        // reaching the timeout
-        const rTimer = this.restoringTimers.get(participantId);
-
-        if (!rTimer) {
-            this.restoringTimers.set(participantId, setTimeout(
-                () => this.figureOutConnectionStatus(participantId),
-                DEFAULT_RESTORING_TIMEOUT));
-        }
-
-        return false;
-    }
-
-    /**
-     * Sends a last/final participant connection status event for the participant that left the conference.
-     * @param {string} id - The id of the participant that left the conference.
-     * @returns {void}
-     */
-    onUserLeft(id) {
-        this.maybeSendParticipantConnectionStatusEvent(id, Date.now());
-        delete this.connectionStatusMap[id];
-    }
-
-    /**
-     * Handles RTC 'onmute' event for the video track.
-     *
-     * @param {JitsiRemoteTrack} track - The video track for which 'onmute' event
-     * will be processed.
-     */
-    onTrackRtcMuted(track) {
-        const participantId = track.getParticipantId();
-        const participant = this.conference.getParticipantById(participantId);
-
-        logger.debug(`Detector track RTC muted: ${participantId}`, Date.now());
-        if (!participant) {
-            logger.error(`No participant for id: ${participantId}`);
-
-            return;
-        }
-        this.rtcMutedTimestamp[participantId] = Date.now();
-        if (!participant.isVideoMuted()) {
-            // If the user is not muted according to the signalling we'll give
-            // it some time, before the connection interrupted event is
-            // triggered.
-            this.clearTimeout(participantId);
-
-            // The timeout is reduced when user is not in the last N
-            const timeout = this._getVideoFrozenTimeout(participantId);
-
-            this.trackTimers[participantId] = window.setTimeout(() => {
-                logger.debug(
-                    `Set RTC mute timeout for: ${participantId}\
-                     of ${timeout} ms`);
-                this.clearTimeout(participantId);
-                this.figureOutConnectionStatus(participantId);
-            }, timeout);
-        }
-    }
-
-    /**
-     * Handles RTC 'onunmute' event for the video track.
-     *
-     * @param {JitsiRemoteTrack} track - The video track for which 'onunmute'
-     * event will be processed.
-     */
-    onTrackRtcUnmuted(track) {
-        const participantId = track.getParticipantId();
-
-        logger.debug(
-            `Detector track RTC unmuted: ${participantId}`, Date.now());
-
-        this.clearTimeout(participantId);
-        this.clearRtcMutedTimestamp(participantId);
-
-        this.figureOutConnectionStatus(participantId);
-    }
-
-    /**
-     * Here the signalling "mute"/"unmute" events are processed.
-     *
-     * @param {JitsiRemoteTrack} track - The remote video track for which
-     * the signalling mute/unmute event will be processed.
-     */
-    onSignallingMuteChanged(track) {
-        const participantId = track.getParticipantId();
-
-        logger.debug(
-            `Detector on track signalling mute changed: ${participantId}`,
-            track.isMuted());
-
-        this.figureOutConnectionStatus(participantId);
-    }
-
-    /**
-     * Sends a participant connection status event as a result of the video type
-     * changing.
-     * @param {JitsiRemoteTrack} track - The track.
-     * @param {VideoType} type - The video type.
-     * @returns {void}
-     */
-    onTrackVideoTypeChanged(track, type) {
-        const id = track.getParticipantId();
-        const nowMs = Date.now();
-
-        this.maybeSendParticipantConnectionStatusEvent(id, nowMs);
-
-        this.connectionStatusMap[id] = {
-            ...this.connectionStatusMap[id] || {},
-            videoType: type,
-            startedMs: nowMs
-        };
-    }
-}

modules/flags/FeatureFlags.js

-import { getLogger } from '@jitsi/logger';
 
 import browser from '../browser';
 
-const logger = getLogger('FeatureFlags');
-
 /**
  * A global module for accessing information about different feature flags state.
  */
      *
      * @param {object} flags - The feature flags.
      * @param {boolean=} flags.runInLiteMode - Enables lite mode for testing to disable media decoding.
-     * @param {boolean=} flags.receiveMultipleVideoStreams - Signal support for receiving multiple video streams.
-     * @param {boolean=} flags.sendMultipleVideoStreams - Signal support for sending multiple video streams.
-     * @param {boolean=} flags.sourceNameSignaling - Enables source names in the signaling.
      * @param {boolean=} flags.ssrcRewritingEnabled - Use SSRC rewriting. Requires sourceNameSignaling to be enabled.
-     * @param {boolean=} flags.enableUnifiedOnChrome - Use unified plan signaling on chrome browsers.
      */
     init(flags) {
         this._runInLiteMode = Boolean(flags.runInLiteMode);
-        this._receiveMultipleVideoStreams = flags.receiveMultipleVideoStreams ?? true;
-        this._sendMultipleVideoStreams = flags.sendMultipleVideoStreams ?? true;
-        this._sourceNameSignaling = flags.sourceNameSignaling ?? true;
-        this._ssrcRewriting = this._sourceNameSignaling && Boolean(flags.ssrcRewritingEnabled);
-
-        // For Chromium, check if Unified plan is enabled.
-        this._usesUnifiedPlan = browser.supportsUnifiedPlan()
-            && (!browser.isChromiumBased() || (flags.enableUnifiedOnChrome ?? true));
-
-        logger.info(`Send multiple video streams: ${this._sendMultipleVideoStreams},`
-            + ` Source name signaling: ${this._sourceNameSignaling},`
-            + ` Unified plan: ${this._usesUnifiedPlan}`);
+        this._ssrcRewriting = Boolean(flags.ssrcRewritingEnabled);
     }
 
     /**
      *
      * @returns {boolean}
      */
-    isMultiStreamSupportEnabled() {
-        return this._sourceNameSignaling && this._sendMultipleVideoStreams && this._usesUnifiedPlan;
-    }
-
-    /**
-     * Checks if receiving multiple video streams is supported.
-     *
-     * @returns {boolean}
-     */
-    isReceiveMultipleVideoStreamsSupported() {
-        return this._receiveMultipleVideoStreams;
+    isMultiStreamSendSupportEnabled() {
+        return browser.supportsUnifiedPlan();
     }
 
     /**
         return this._runInLiteMode;
     }
 
-    /**
-     * Checks if the source name signaling is enabled.
-     *
-     * @returns {boolean}
-     */
-    isSourceNameSignalingEnabled() {
-        return this._sourceNameSignaling;
-    }
-
     /**
      * Checks if the clients supports re-writing of the SSRCs on the media streams by the bridge.
      * @returns {boolean}

modules/proxyconnection/ProxyConnectionPC.js

             addPresenceListener: () => { /* no-op */ },
             connectionTimes: [],
             eventEmitter: { emit: emitter },
-            getMediaPresenceInfo: () => {
-                // Errors occur if this function does not return an object
-
-                return {};
-            },
             removeEventListener: () => { /* no op */ },
             removePresenceListener: () => { /* no-op */ },
             supportsRestartByTerminate: () => false

modules/qualitycontrol/ReceiveVideoController.js

 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import { MediaType } from '../../service/RTC/MediaType';
-import FeatureFlags from '../flags/FeatureFlags';
 
 const logger = getLogger(__filename);
 const MAX_HEIGHT_ONSTAGE = 2160;
      * @returns
      */
     _getDefaultSourceReceiverConstraints(mediaSession, maxFrameHeight) {
-        if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-            return null;
-        }
         const remoteVideoTracks = mediaSession.peerconnection?.getRemoteTracks(null, MediaType.VIDEO) || [];
         const receiverConstraints = new Map();
 
      * @param {Object} constraints The video constraints.
      */
     setReceiverConstraints(constraints) {
-        if (!this._receiverVideoConstraints) {
-            this._receiverVideoConstraints = new ReceiverVideoConstraints();
+        if (!constraints) {
+            return;
         }
-
         const isEndpointsFormat = Object.keys(constraints).includes('onStageEndpoints', 'selectedEndpoints');
-        const isSourcesFormat = Object.keys(constraints).includes('onStageSources', 'selectedSources');
 
-        if (!FeatureFlags.isSourceNameSignalingEnabled() && isSourcesFormat) {
-            throw new Error(
-                '"onStageSources" and "selectedSources" are not supported when sourceNameSignaling is disabled.'
-            );
-        }
-
-        if (FeatureFlags.isSourceNameSignalingEnabled() && isEndpointsFormat) {
+        if (isEndpointsFormat) {
             throw new Error(
                 '"onStageEndpoints" and "selectedEndpoints" are not supported when sourceNameSignaling is enabled.'
             );
                 return;
             }
 
-            if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                const mappedConstraints = Array.from(Object.entries(constraints.constraints))
-                    .map(constraint => {
-                        constraint[1] = constraint[1].maxHeight;
+            const mappedConstraints = Array.from(Object.entries(constraints.constraints))
+                .map(constraint => {
+                    constraint[1] = constraint[1].maxHeight;
 
-                        return constraint;
-                    });
+                    return constraint;
+                });
 
-                this._sourceReceiverConstraints = new Map(mappedConstraints);
+            this._sourceReceiverConstraints = new Map(mappedConstraints);
 
-                // Send the receiver constraints to the peer through a "content-modify" message.
-                p2pSession.setReceiverVideoConstraint(null, this._sourceReceiverConstraints);
-            } else {
-                let maxFrameHeight = Object.values(constraints.constraints)[0]?.maxHeight;
-
-                if (!maxFrameHeight) {
-                    maxFrameHeight = constraints.defaultConstraints?.maxHeight;
-                }
-                maxFrameHeight && p2pSession.setReceiverVideoConstraint(maxFrameHeight);
-            }
+            // Send the receiver constraints to the peer through a "content-modify" message.
+            p2pSession.setReceiverVideoConstraint(null, this._sourceReceiverConstraints);
         }
     }
 }

modules/qualitycontrol/ReceiveVideoController.spec.js

             }
         });
     });
-
-    describe('when sourceNameSignaling is disabled', () => {
-        beforeEach(() => {
-            FeatureFlags.init({ sourceNameSignaling: false });
-        });
-
-        it('should call setNewReceiverVideoConstraints with the endpoints format.', () => {
-            const rtcSpy = spyOn(rtc, 'setNewReceiverVideoConstraints');
-            const constraints = {
-                onStageEndpoints: [ 'A', 'B', 'C' ],
-                selectedEndpoints: [ 'A' ]
-            };
-
-            receiveVideoController.setReceiverConstraints(constraints);
-            expect(rtcSpy).toHaveBeenCalledWith(constraints);
-        });
-
-        it('should not allow the source names format.', () => {
-            const constraints = {
-                onStageSources: [ 'A_camera_1', 'B_screen_2', 'C_camera_1' ],
-                selectedSources: [ 'A_camera_1' ]
-            };
-
-            try {
-                receiveVideoController.setReceiverConstraints(constraints);
-                fail();
-            } catch (error) {
-                expect(error).toEqual(new Error(
-                    '"onStageSources" and "selectedSources" are not supported when sourceNameSignaling is disabled.'
-                ));
-            }
-        });
-    });
 });

modules/qualitycontrol/SendVideoController.js

 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import RTCEvents from '../../service/RTC/RTCEvents';
-import FeatureFlags from '../flags/FeatureFlags';
 import MediaSessionEvents from '../xmpp/MediaSessionEvents';
 
 const logger = getLogger(__filename);
      * @private
      */
     _configureConstraintsForLocalSources() {
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            for (const track of this._rtc.getLocalVideoTracks()) {
-                const sourceName = track.getSourceName();
+        for (const track of this._rtc.getLocalVideoTracks()) {
+            const sourceName = track.getSourceName();
 
-                sourceName && this._propagateSendMaxFrameHeight(sourceName);
-            }
-        } else {
-            this._propagateSendMaxFrameHeight();
+            sourceName && this._propagateSendMaxFrameHeight(sourceName);
         }
     }
 
      * @private
      */
     _onMediaSessionStarted(mediaSession) {
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            mediaSession.addListener(
-                MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED,
-                (session, sourceConstraints) => {
-                    session === this._conference.getActiveMediaSession()
-                        && sourceConstraints.forEach(constraint => this._onSenderConstraintsReceived(constraint));
-                });
-        } else {
-            mediaSession.addListener(
-                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
-                session => session === this._conference.getActiveMediaSession()
-                    && this._configureConstraintsForLocalSources());
-        }
+        mediaSession.addListener(
+            MediaSessionEvents.REMOTE_SOURCE_CONSTRAINTS_CHANGED,
+            (session, sourceConstraints) => {
+                session === this._conference.getActiveMediaSession()
+                    && sourceConstraints.forEach(constraint => this._onSenderConstraintsReceived(constraint));
+            });
     }
 
     /**
      * @private
      */
     _onSenderConstraintsReceived(videoConstraints) {
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            const { maxHeight, sourceName } = videoConstraints;
-            const localVideoTracks = this._conference.getLocalVideoTracks() ?? [];
-
-            for (const track of localVideoTracks) {
-                // Propagate the sender constraint only if it has changed.
-                if (track.getSourceName() === sourceName
-                    && (!this._sourceSenderConstraints.has(sourceName)
-                    || this._sourceSenderConstraints.get(sourceName) !== maxHeight)) {
-                    this._sourceSenderConstraints.set(
-                        sourceName,
-                        maxHeight === -1
-                            ? Math.min(MAX_LOCAL_RESOLUTION, this._preferredSendMaxFrameHeight)
-                            : maxHeight);
-                    logger.debug(`Sender constraints for source:${sourceName} changed to maxHeight:${maxHeight}`);
-                    this._propagateSendMaxFrameHeight(sourceName);
-                }
+        const { maxHeight, sourceName } = videoConstraints;
+        const localVideoTracks = this._conference.getLocalVideoTracks() ?? [];
+
+        for (const track of localVideoTracks) {
+            // Propagate the sender constraint only if it has changed.
+            if (track.getSourceName() === sourceName
+                && this._sourceSenderConstraints.get(sourceName) !== maxHeight) {
+                this._sourceSenderConstraints.set(
+                    sourceName,
+                    maxHeight === -1
+                        ? Math.min(MAX_LOCAL_RESOLUTION, this._preferredSendMaxFrameHeight)
+                        : maxHeight);
+                logger.debug(`Sender constraints for source:${sourceName} changed to maxHeight:${maxHeight}`);
+                this._propagateSendMaxFrameHeight(sourceName);
             }
-        } else if (this._senderVideoConstraints?.idealHeight !== videoConstraints.idealHeight) {
-            this._senderVideoConstraints = videoConstraints;
-            this._propagateSendMaxFrameHeight();
         }
     }
 
      * @returns {Promise<void[]>}
      * @private
      */
-    _propagateSendMaxFrameHeight(sourceName = null) {
-        if (FeatureFlags.isSourceNameSignalingEnabled() && !sourceName) {
+    _propagateSendMaxFrameHeight(sourceName) {
+        if (!sourceName) {
             throw new Error('sourceName missing for calculating the sendMaxHeight for video tracks');
         }
         const sendMaxFrameHeight = this._selectSendMaxFrameHeight(sourceName);
      * @returns {number|undefined}
      * @private
      */
-    _selectSendMaxFrameHeight(sourceName = null) {
-        if (FeatureFlags.isSourceNameSignalingEnabled() && !sourceName) {
+    _selectSendMaxFrameHeight(sourceName) {
+        if (!sourceName) {
             throw new Error('sourceName missing for calculating the sendMaxHeight for video tracks');
         }
         const activeMediaSession = this._conference.getActiveMediaSession();
         const remoteRecvMaxFrameHeight = activeMediaSession
-            ? activeMediaSession.isP2P
-                ? sourceName
-                    ? this._sourceSenderConstraints.get(sourceName)
-                    : activeMediaSession.getRemoteRecvMaxFrameHeight()
-                : sourceName ? this._sourceSenderConstraints.get(sourceName) : this._senderVideoConstraints?.idealHeight
+            ? this._sourceSenderConstraints.get(sourceName)
             : undefined;
 
         if (this._preferredSendMaxFrameHeight >= 0 && remoteRecvMaxFrameHeight >= 0) {
      */
     setPreferredSendMaxFrameHeight(maxFrameHeight) {
         this._preferredSendMaxFrameHeight = maxFrameHeight;
+        const promises = [];
 
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            const promises = [];
-
-            for (const sourceName of this._sourceSenderConstraints.keys()) {
-                promises.push(this._propagateSendMaxFrameHeight(sourceName));
-            }
-
-            return Promise.allSettled(promises);
+        for (const sourceName of this._sourceSenderConstraints.keys()) {
+            promises.push(this._propagateSendMaxFrameHeight(sourceName));
         }
 
-        return this._propagateSendMaxFrameHeight();
+        return Promise.allSettled(promises);
     }
 }

modules/qualitycontrol/SendVideoController.spec.js

-import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
-import RTCEvents from '../../service/RTC/RTCEvents';
-import FeatureFlags from '../flags/FeatureFlags';
-import Listenable from '../util/Listenable';
-import MediaSessionEvents from '../xmpp/MediaSessionEvents';
-
-import SendVideoController from './SendVideoController';
-
-// JSDocs disabled for Mock classes to avoid duplication - check on the original classes for info.
-/* eslint-disable require-jsdoc */
-/**
- * A mock JingleSessionPC impl that fit the needs of the SendVideoController module.
- * Should a generic, shared one exist in the future this test file should switch to use it too.
- */
-class MockJingleSessionPC extends Listenable {
-    constructor(rtc, isP2P) {
-        super();
-        this.rtc = rtc;
-        this.isP2P = isP2P;
-        this._remoteRecvMaxFrameHeight = undefined;
-        this.senderVideoConstraint = undefined;
-    }
-
-    getRemoteRecvMaxFrameHeight() {
-        return this._remoteRecvMaxFrameHeight;
-    }
-
-    setSenderVideoConstraint(senderVideoConstraint) {
-        this.senderVideoConstraint = senderVideoConstraint;
-    }
-
-    setRemoteRecvMaxFrameHeight(remoteRecvMaxFrameHeight) {
-        this._remoteRecvMaxFrameHeight = remoteRecvMaxFrameHeight;
-        if (this.isP2P) {
-            this.eventEmitter.emit(
-                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
-                this);
-        } else {
-            this.rtc.eventEmitter.emit(
-                RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED,
-                { idealHeight: remoteRecvMaxFrameHeight });
-        }
-    }
-}
-
-/**
- * Mock conference for the purpose of this test file.
- */
-class MockConference extends Listenable {
-    /**
-     * A constructor...
-     */
-    constructor() {
-        super();
-        this.options = {};
-        this.activeMediaSession = undefined;
-        this.mediaSessions = [];
-    }
-
-    addMediaSession(mediaSession) {
-        this.mediaSessions.push(mediaSession);
-
-        this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_STARTED, mediaSession);
-    }
-
-    setActiveMediaSession(mediaSession) {
-        if (this.mediaSessions.indexOf(mediaSession) === -1) {
-            throw new Error('Given session is not part of this conference');
-        }
-
-        this.activeMediaSession = mediaSession;
-
-        this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, this.activeMediaSession);
-    }
-
-    getActiveMediaSession() {
-        return this.activeMediaSession;
-    }
-
-    getLocalVideoTracks() {
-        return [];
-    }
-
-    getMediaSessions() {
-        return this.mediaSessions;
-    }
-}
-
-/**
- * Mock {@link RTC} - add things as needed, but only things useful for all tests.
- */
-export class MockRTC extends Listenable {
-    /**
-     * constructor
-     */
-    /* eslint-disable no-useless-constructor */
-    constructor() {
-        super();
-    }
-}
-
-/* eslint-enable require-jsdoc */
-
-describe('SendVideoController', () => {
-    let conference;
-    let rtc;
-    let sendVideoController;
-    let jvbConnection;
-    let p2pConnection;
-
-    beforeEach(() => {
-        conference = new MockConference();
-        rtc = new MockRTC();
-        FeatureFlags.init({ sourceNameSignaling: false });
-        sendVideoController = new SendVideoController(conference, rtc);
-        jvbConnection = new MockJingleSessionPC(rtc, false /* isP2P */);
-        p2pConnection = new MockJingleSessionPC(rtc, true /* isP2P */);
-
-        conference.addMediaSession(jvbConnection);
-        conference.addMediaSession(p2pConnection);
-    });
-    describe('handles 0 as receiver/sender video constraint', () => {
-        it('0 if it\'s the active sessions\'s remote recv constraint', () => {
-            jvbConnection.setRemoteRecvMaxFrameHeight(0);
-            p2pConnection.setRemoteRecvMaxFrameHeight(720);
-
-            conference.setActiveMediaSession(jvbConnection);
-
-            expect(jvbConnection.senderVideoConstraint).toBe(0);
-            expect(p2pConnection.senderVideoConstraint).toBe(0);
-        });
-        it('720 if 0 is set on the non-active session', () => {
-            jvbConnection.setRemoteRecvMaxFrameHeight(0);
-            p2pConnection.setRemoteRecvMaxFrameHeight(720);
-
-            conference.setActiveMediaSession(p2pConnection);
-
-            expect(jvbConnection.senderVideoConstraint).toBe(720);
-            expect(p2pConnection.senderVideoConstraint).toBe(720);
-        });
-        it('0 if it\'s the local send preference while remote are 720', () => {
-            conference.setActiveMediaSession(p2pConnection);
-
-            jvbConnection.setRemoteRecvMaxFrameHeight(720);
-            p2pConnection.setRemoteRecvMaxFrameHeight(720);
-
-            sendVideoController.setPreferredSendMaxFrameHeight(0);
-
-            expect(jvbConnection.senderVideoConstraint).toBe(0);
-            expect(p2pConnection.senderVideoConstraint).toBe(0);
-        });
-    });
-});

modules/sdp/LocalSdpMunger.js

                     let streamId = streamAndTrackIDs[0];
                     const trackId = streamAndTrackIDs[1];
 
-                    if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                        // Always overwrite streamId since we want the msid to be in this format even if the browser
-                        // generates one (in p2p mode).
-                        streamId = `${this.localEndpointId}-${mediaType}`;
+                    // Always overwrite streamId since we want the msid to be in this format even if the browser
+                    // generates one (in p2p mode).
+                    streamId = `${this.localEndpointId}-${mediaType}`;
 
+                    // eslint-disable-next-line max-depth
+                    if (mediaType === MediaType.VIDEO) {
                         // eslint-disable-next-line max-depth
-                        if (mediaType === MediaType.VIDEO) {
-                            // eslint-disable-next-line max-depth
-                            if (!this.videoSourcesToMsidMap.has(trackId)) {
-                                streamId = `${streamId}-${this.videoSourcesToMsidMap.size}`;
-                                this.videoSourcesToMsidMap.set(trackId, streamId);
-                            }
-                        } else if (!this.audioSourcesToMsidMap.has(trackId)) {
-                            streamId = `${streamId}-${this.audioSourcesToMsidMap.size}`;
-                            this.audioSourcesToMsidMap.set(trackId, streamId);
+                        if (!this.videoSourcesToMsidMap.has(trackId)) {
+                            streamId = `${streamId}-${this.videoSourcesToMsidMap.size}`;
+                            this.videoSourcesToMsidMap.set(trackId, streamId);
                         }
-
-                        streamId = mediaType === MediaType.VIDEO
-                            ? this.videoSourcesToMsidMap.get(trackId)
-                            : this.audioSourcesToMsidMap.get(trackId);
+                    } else if (!this.audioSourcesToMsidMap.has(trackId)) {
+                        streamId = `${streamId}-${this.audioSourcesToMsidMap.size}`;
+                        this.audioSourcesToMsidMap.set(trackId, streamId);
                     }
+
+                    streamId = mediaType === MediaType.VIDEO
+                        ? this.videoSourcesToMsidMap.get(trackId)
+                        : this.audioSourcesToMsidMap.get(trackId);
+
                     ssrcLine.value = this._generateMsidAttribute(mediaType, trackId, streamId);
                 } else {
                     logger.warn(`Unable to munge local MSID - weird format detected: ${ssrcLine.value}`);
 
         const videoMlines = transformer.selectMedia(MediaType.VIDEO);
 
-        if (!FeatureFlags.isMultiStreamSupportEnabled()) {
+        if (!FeatureFlags.isMultiStreamSendSupportEnabled()) {
             videoMlines.splice(1);
         }
 
 
         // Plan-b clients generate new SSRCs and trackIds whenever tracks are removed and added back to the
         // peerconnection, therefore local track based map for msids needs to be reset after every transformation.
-        if (FeatureFlags.isSourceNameSignalingEnabled() && !this.tpc._usesUnifiedPlan) {
+        if (!this.tpc._usesUnifiedPlan) {
             this.audioSourcesToMsidMap.clear();
             this.videoSourcesToMsidMap.clear();
         }
      * @private
      */
     _injectSourceNames(mediaSection) {
-        if (!FeatureFlags.isSourceNameSignalingEnabled()) {
-            return;
-        }
-
         const sources = [ ...new Set(mediaSection.mLine?.ssrcs?.map(s => s.id)) ];
         const mediaType = mediaSection.mLine?.type;
 

modules/sdp/LocalSdpMunger.spec.js

     const localEndpointId = 'sRdpsdg';
 
     beforeEach(() => {
-        FeatureFlags.init({ sourceNameSignaling: false });
+        FeatureFlags.init({ });
         localSdpMunger = new LocalSdpMunger(tpc, localEndpointId);
     });
     describe('dontStripSsrcs', () => {
             const audioSsrcs = getSsrcLines(newSdp, 'audio');
             const videoSsrcs = getSsrcLines(newSdp, 'video');
 
-            expect(audioSsrcs.length).toEqual(1);
-            expect(videoSsrcs.length).toEqual(1);
+            expect(audioSsrcs.length).toEqual(2);
+            expect(videoSsrcs.length).toEqual(2);
         });
 
         describe('should do nothing to an sdp with msid', () => {
                 videoSsrcs = getSsrcLines(newSdp, 'video');
             };
 
-            it('without source name signaling enabled (no injected source name)', () => {
-                transformStreamIdentifiers();
-
-                expect(audioSsrcs.length).toEqual(4);
-                expect(videoSsrcs.length).toEqual(6);
-            });
             it('with source name signaling enabled (injected source name)', () => {
-                FeatureFlags.init({ });
                 transformStreamIdentifiers();
 
                 expect(audioSsrcs.length).toEqual(4 + 1 /* injected source name */);
                 if (ssrcLine.attribute === 'msid') {
                     const msid = ssrcLine.value.split(' ')[0];
 
-                    expect(msid).toBe(`${localEndpointId}-video-${tpc.id}`);
+                    expect(msid).toBe(`${localEndpointId}-video-0-${tpc.id}`);
                 }
             }
         });
     const localEndpointId = 'sRdpsdg';
 
     beforeEach(() => {
-        FeatureFlags.init({ sourceNameSignaling: false });
         localSdpMunger = new LocalSdpMunger(tpc, localEndpointId);
     });
     describe('stripSsrcs', () => {
                 videoSsrcs = getSsrcLines(newSdp, 'video');
             };
 
-            it('without source name signaling', () => {
-                transformStreamIdentifiers();
-
-                expect(audioSsrcs.length).toEqual(1);
-                expect(videoSsrcs.length).toEqual(1);
-            });
             it('with source name signaling', () => {
                 FeatureFlags.init({ });
                 transformStreamIdentifiers();
         videoMsid = videoMsidLine.split(' ')[0];
     };
 
-    it('should not transform', () => {
-        FeatureFlags.init({ sourceNameSignaling: false });
-        transformStreamIdentifiers();
-
-        expect(audioMsid).toBe('dcbb0236-cea5-402e-9e9a-595c65ffcc2a-1');
-        expect(videoMsid).toBe('0836cc8e-a7bb-47e9-affb-0599414bc56d-1');
-    });
-
     it('should transform', () => {
         FeatureFlags.init({ });
         transformStreamIdentifiers();

modules/sdp/SDP.js

 
 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import browser from '../browser';
-import FeatureFlags from '../flags/FeatureFlags';
 
 import SDPUtil from './SDPUtil';
 
 
                     elem.c('source', {
                         ssrc: availableSsrc,
-                        name: FeatureFlags.isSourceNameSignalingEnabled() ? sourceName : undefined,
+                        name: sourceName,
                         videoType,
                         xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0'
                     });

modules/sdp/SDPDiffer.js

-import FeatureFlags from '../flags/FeatureFlags';
 
 import SDPUtil from './SDPUtil';
 
 
             modify.c('source', { xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0' });
             modify.attrs({
-                name: FeatureFlags.isSourceNameSignalingEnabled() ? sourceName : undefined,
+                name: sourceName,
                 videoType,
                 ssrc: mediaSsrc.ssrc
             });

modules/xmpp/ChatRoom.js

 import { $iq, $msg, $pres, Strophe } from 'strophe.js';
 
 import * as JitsiTranscriptionStatus from '../../JitsiTranscriptionStatus';
-import { MediaType } from '../../service/RTC/MediaType';
-import { VideoType } from '../../service/RTC/VideoType';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
         return null;
     }
 
-    /**
-     *
-     * @param mute
-     */
-    addAudioInfoToPresence(mute) {
-        const audioMutedTagName = 'audiomuted';
-
-        // we skip adding it as muted is default value
-        if (mute && !this.getFromPresence(audioMutedTagName)) {
-            return false;
-        }
-
-        return this.addOrReplaceInPresence(
-            audioMutedTagName,
-            {
-                value: mute.toString()
-            });
-    }
-
-    /**
-     *
-     * @param mute
-     */
-    addVideoInfoToPresence(mute) {
-        const videoMutedTagName = 'videomuted';
-
-        // we skip adding it as muted is default value
-        if (mute && !this.getFromPresence(videoMutedTagName)) {
-            return false;
-        }
-
-        return this.addOrReplaceInPresence(
-            videoMutedTagName,
-            {
-                value: mute.toString()
-            });
-    }
-
-    /**
-     * Obtains the info about given media advertised in the MUC presence of
-     * the participant identified by the given endpoint JID.
-     * @param {string} endpointId the endpoint ID mapped to the participant
-     * which corresponds to MUC nickname.
-     * @param {MediaType} mediaType the type of the media for which presence
-     * info will be obtained.
-     * @return {PeerMediaInfo} presenceInfo an object with media presence
-     * info or <tt>null</tt> either if there is no presence available or if
-     * the media type given is invalid.
-     */
-    getMediaPresenceInfo(endpointId, mediaType) {
-        // Will figure out current muted status by looking up owner's presence
-        const pres = this.lastPresences[`${this.roomjid}/${endpointId}`];
-
-        if (!pres) {
-            // No presence available
-            return null;
-        }
-        const data = {
-            muted: true, // muted by default
-            videoType: mediaType === MediaType.VIDEO ? VideoType.CAMERA : undefined // 'camera' by default
-        };
-        let mutedNode = null;
-
-        if (mediaType === MediaType.AUDIO) {
-            mutedNode = filterNodeFromPresenceJSON(pres, 'audiomuted');
-        } else if (mediaType === MediaType.VIDEO) {
-            mutedNode = filterNodeFromPresenceJSON(pres, 'videomuted');
-            const codecTypeNode = filterNodeFromPresenceJSON(pres, 'jitsi_participant_codecType');
-            const videoTypeNode = filterNodeFromPresenceJSON(pres, 'videoType');
-
-            if (videoTypeNode.length > 0) {
-                data.videoType = videoTypeNode[0].value;
-            }
-            if (codecTypeNode.length > 0) {
-                data.codecType = codecTypeNode[0].value;
-            }
-        } else {
-            logger.error(`Unsupported media type: ${mediaType}`);
-
-            return null;
-        }
-
-        if (mutedNode.length > 0) {
-            data.muted = mutedNode[0].value === 'true';
-        }
-
-        return data;
-    }
-
     /**
      * Returns the last presence advertised by a MUC member.
      * @param {string} mucNick

modules/xmpp/JingleHelperFunctions.js

 import { $build } from 'strophe.js';
 
 import { MediaType } from '../../service/RTC/MediaType';
-import FeatureFlags from '../flags/FeatureFlags';
 
 const logger = getLogger(__filename);
 
     const node = $build('source', {
         xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0',
         ssrc: sourceCompactJson.s,
-        name: FeatureFlags.isSourceNameSignalingEnabled() ? sourceCompactJson.n : undefined
+        name: sourceCompactJson.n
     });
 
     if (sourceCompactJson.m) {

modules/xmpp/JingleSessionPC.js

         ssrcs.each((i, ssrcElement) => {
             const ssrc = Number(ssrcElement.getAttribute('ssrc'));
 
-            if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                if (ssrcElement.hasAttribute('name')) {
-                    const sourceName = ssrcElement.getAttribute('name');
+            if (ssrcElement.hasAttribute('name')) {
+                const sourceName = ssrcElement.getAttribute('name');
 
-                    this._signalingLayer.setTrackSourceName(ssrc, sourceName);
-                }
+                this._signalingLayer.setTrackSourceName(ssrc, sourceName);
             }
 
             if (this.isP2P) {
                     const videoTracks = localTracks.filter(track => track.getType() === MediaType.VIDEO);
 
                     videoTracks.length && videoTracks.splice(0, 1);
-                    if (FeatureFlags.isMultiStreamSupportEnabled() && videoTracks.length) {
+                    if (FeatureFlags.isMultiStreamSendSupportEnabled() && videoTracks.length) {
                         this.addTracks(videoTracks);
                     }
                 },
             // Add only 1 video track at a time. Adding 2 or more video tracks to the peerconnection at the same time
             // makes the browser go into a renegotiation loop by firing 'negotiationneeded' event after every
             // renegotiation.
-            if (FeatureFlags.isMultiStreamSupportEnabled() && videoTracks.length > 1) {
+            if (FeatureFlags.isMultiStreamSendSupportEnabled() && videoTracks.length > 1) {
                 tracks = [ ...audioTracks, videoTracks[0] ];
             }
             for (const track of tracks) {
         logger.info(`${this} setReceiverVideoConstraint - max frame height: ${maxFrameHeight}`
             + ` sourceReceiverConstraints: ${sourceReceiverConstraints}`);
 
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            this._sourceReceiverConstraints = sourceReceiverConstraints;
-        } else {
-            this.localRecvMaxFrameHeight = maxFrameHeight;
-        }
+        this._sourceReceiverConstraints = sourceReceiverConstraints;
 
         if (this.isP2P) {
             // Tell the remote peer about our receive constraint. If Jingle session is not yet active the state will
 
             // In p2p unified mode with multi-stream enabled, the new sources will have content name that doesn't exist
             // in the current remote description. Add a new m-line for this newly signaled source.
-            if (!midFound && this.isP2P && FeatureFlags.isSourceNameSignalingEnabled()) {
+            if (!midFound && this.isP2P) {
                 addSsrcInfo[name] = lines;
             }
         });
                 // Reject the m-line so that the browser removes the associated transceiver from the list of available
                 // transceivers. This will prevent the client from trying to re-use these inactive transceivers when
                 // additional video sources are added to the peerconnection.
-                if (mid > -1 && !this.isP2P && FeatureFlags.isMultiStreamSupportEnabled()) {
+                if (mid > -1 && !this.isP2P && FeatureFlags.isMultiStreamSendSupportEnabled()) {
                     const { media, port } = SDPUtil.parseMLine(remoteSdp.media[mid].split('\r\n')[0]);
 
                     remoteSdp.media[mid] = remoteSdp.media[mid].replace(`m=${media} ${port}`, `m=${media} 0`);
         // Add a new m-line in the remote description if the source info for a secondary video source is recceived from
         // the remote p2p peer when multi-stream support is enabled.
         if (addSsrcInfo.length > remoteSdp.media.length
-            && FeatureFlags.isSourceNameSignalingEnabled()
             && this.isP2P
             && this.usesUnifiedPlan) {
             remoteSdp.addMlineForNewLocalSource(MediaType.VIDEO);
      * otherwise.
      */
     addTracks(localTracks = null) {
-        if (!FeatureFlags.isMultiStreamSupportEnabled()
+        if (!FeatureFlags.isMultiStreamSendSupportEnabled()
             || !localTracks?.length
             || localTracks.find(track => track.getType() !== MediaType.VIDEO)) {
             return Promise.reject(new Error('Multiple tracks of the given media type are not supported'));
 
                     return promise.then(() => {
                         // Set the source name of the new track.
-                        if (FeatureFlags.isSourceNameSignalingEnabled()
-                            && oldTrack
+                        if (oldTrack
                             && newTrack
                             && oldTrack.isVideoTrack()) {
                             newTrack.setSourceName(oldTrack.getSourceName());

modules/xmpp/JingleSessionPC.spec.js

 import MediaSessionEvents from './MediaSessionEvents';
 import { MockChatRoom, MockStropheConnection } from './MockClasses';
 
-/**
- * Creates 'content-modify' Jingle IQ.
- * @param {string} senders - 'both' or 'none'.
- * @param {number|undefined} maxFrameHeight - the receive max video frame height.
- * @returns {jQuery}
- */
-function createContentModify(senders = 'both', maxFrameHeight) {
-    const modifyContentsIq = $.parseXML(
-        '<jingle action="content-modify" initiator="peer2" sid="sid12345" xmlns="urn:xmpp:jingle:1">'
-        + `<content name="video" senders="${senders}">`
-        + `<max-frame-height xmlns="http://jitsi.org/jitmeet/video">${maxFrameHeight}</max-frame-height>`
-        + '</content>'
-        + '</jingle>');
-
-    return $(modifyContentsIq).find('>jingle');
-}
-
 /**
  * Creates 'content-modify' Jingle IQ.
  * @returns {jQuery}
         // connection.connect('jid', undefined, () => { }); */
     });
 
-    describe('send/receive video constraints w/o source-name', () => {
-        beforeEach(() => {
-            FeatureFlags.init({ sourceNameSignaling: false });
-        });
-
-        it('sends content-modify with recv frame size', () => {
-            const sendIQSpy = spyOn(connection, 'sendIQ').and.callThrough();
-
-            jingleSession.setReceiverVideoConstraint(180);
-
-            expect(jingleSession.getState()).toBe(JingleSessionState.PENDING);
-
-            return new Promise((resolve, reject) => {
-                jingleSession.acceptOffer(
-                    offerIQ,
-                    resolve,
-                    reject,
-                    /* local tracks */ []);
-            }).then(() => {
-                expect(jingleSession.getState()).toBe(JingleSessionState.ACTIVE);
-
-                // FIXME content-modify is sent before session-accept
-                expect(sendIQSpy.calls.count()).toBe(2);
-
-                expect(sendIQSpy.calls.first().args[0].toString()).toBe(
-                    '<iq to="peer2" type="set" xmlns="jabber:client">'
-                    + '<jingle action="content-modify" initiator="peer2" sid="sid12345" xmlns="urn:xmpp:jingle:1">'
-                    + '<content name="video" senders="both">'
-                    + '<max-frame-height xmlns="http://jitsi.org/jitmeet/video">180</max-frame-height>'
-                    + '</content>'
-                    + '</jingle>'
-                    + '</iq>');
-            });
-        });
-        it('fires an event when remote peer sends content-modify', () => {
-            let remoteRecvMaxFrameHeight;
-            const remoteVideoConstraintsListener = session => {
-                remoteRecvMaxFrameHeight = session.getRemoteRecvMaxFrameHeight();
-            };
-
-            jingleSession.addListener(
-                MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
-                remoteVideoConstraintsListener);
-
-            return new Promise((resolve, reject) => {
-                jingleSession.acceptOffer(
-                    offerIQ,
-                    resolve,
-                    reject,
-                    /* local tracks */ []);
-            }).then(() => {
-                jingleSession.modifyContents(createContentModify('both', 180));
-                expect(remoteRecvMaxFrameHeight).toBe(180);
-
-                jingleSession.modifyContents(createContentModify('both', 360));
-                expect(remoteRecvMaxFrameHeight).toBe(360);
-
-                jingleSession.modifyContents(createContentModify('both', 180));
-                expect(remoteRecvMaxFrameHeight).toBe(180);
-            });
-        });
-    });
-
     describe('send/receive video constraints w/ source-name', () => {
         beforeEach(() => {
             FeatureFlags.init({ sourceNameSignaling: true });

modules/xmpp/SignalingLayerImpl.js

 import SignalingLayer, { getMediaTypeFromSourceName } from '../../service/RTC/SignalingLayer';
 import { VideoType } from '../../service/RTC/VideoType';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
-import FeatureFlags from '../flags/FeatureFlags';
 
 import { filterNodeFromPresenceJSON } from './ChatRoom';
 
                 'videomuted', this._videoMuteHandler);
             oldChatRoom.removePresenceListener(
                 'videoType', this._videoTypeHandler);
-            if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                this._sourceInfoHandler
-                    && oldChatRoom.removePresenceListener(
-                        SOURCE_INFO_PRESENCE_ELEMENT, this._sourceInfoHandler);
-                this._memberLeftHandler
-                    && oldChatRoom.removeEventListener(
-                        XMPPEvents.MUC_MEMBER_LEFT, this._memberLeftHandler);
-            }
+            this._sourceInfoHandler
+                && oldChatRoom.removePresenceListener(SOURCE_INFO_PRESENCE_ELEMENT, this._sourceInfoHandler);
+            this._memberLeftHandler
+                && oldChatRoom.removeEventListener(XMPPEvents.MUC_MEMBER_LEFT, this._memberLeftHandler);
         }
         if (room) {
-            if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                this._bindChatRoomEventHandlers(room);
-                this._addLocalSourceInfoToPresence();
-            } else {
-                // TODO the logic below has been duplicated in _bindChatRoomEventHandlers, clean this up once
-                //  the new impl has been tested well enough
-                // SignalingEvents
-                this._audioMuteHandler = (node, from) => {
-                    this.eventEmitter.emit(
-                        SignalingEvents.PEER_MUTED_CHANGED,
-                        from, MediaType.AUDIO, node.value === 'true');
-                };
-                room.addPresenceListener('audiomuted', this._audioMuteHandler);
-
-                this._videoMuteHandler = (node, from) => {
-                    this.eventEmitter.emit(
-                        SignalingEvents.PEER_MUTED_CHANGED,
-                        from, MediaType.VIDEO, node.value === 'true');
-                };
-                room.addPresenceListener('videomuted', this._videoMuteHandler);
-
-                this._videoTypeHandler = (node, from) => {
-                    this.eventEmitter.emit(
-                        SignalingEvents.PEER_VIDEO_TYPE_CHANGED,
-                        from, node.value);
-                };
-                room.addPresenceListener('videoType', this._videoTypeHandler);
-            }
+            this._bindChatRoomEventHandlers(room);
+            this._addLocalSourceInfoToPresence();
         }
     }
 
      * @returns {void}
      */
     _bindChatRoomEventHandlers(room) {
+        // Add handlers for 'audiomuted', 'videomuted' and 'videoType' fields in presence in order to support interop
+        // with very old versions of mobile clients and jigasi that do not support source-name signaling.
         const emitAudioMutedEvent = (endpointId, muted) => {
             this.eventEmitter.emit(
                 SignalingEvents.PEER_MUTED_CHANGED,
                 MediaType.AUDIO,
                 muted);
         };
-        const emitVideoMutedEvent = (endpointId, muted) => {
-            this.eventEmitter.emit(
-                SignalingEvents.PEER_MUTED_CHANGED,
-                endpointId,
-                MediaType.VIDEO,
-                muted);
-        };
 
-        // SignalingEvents
         this._audioMuteHandler = (node, from) => {
             if (!this._doesEndpointSendNewSourceInfo(from)) {
                 emitAudioMutedEvent(from, node.value === 'true');
         };
         room.addPresenceListener('audiomuted', this._audioMuteHandler);
 
+        const emitVideoMutedEvent = (endpointId, muted) => {
+            this.eventEmitter.emit(
+                SignalingEvents.PEER_MUTED_CHANGED,
+                endpointId,
+                MediaType.VIDEO,
+                muted);
+        };
+
         this._videoMuteHandler = (node, from) => {
             if (!this._doesEndpointSendNewSourceInfo(from)) {
                 emitVideoMutedEvent(from, node.value === 'true');
                 emitVideoTypeEvent(from, node.value);
             }
         };
+        room.addPresenceListener('videoType', this._videoTypeHandler);
 
-        if (!FeatureFlags.isMultiStreamSupportEnabled()) {
-            room.addPresenceListener('videoType', this._videoTypeHandler);
-        }
-
+        // Add handlers for presence in the new format.
         this._sourceInfoHandler = (node, mucNick) => {
             const endpointId = mucNick;
             const { value } = node;
 
             delete this._remoteSourceState[endpointId];
 
-            if (FeatureFlags.isSourceNameSignalingEnabled()) {
-                for (const [ key, value ] of this.ssrcOwners.entries()) {
-                    if (value === endpointId) {
-                        delete this._sourceNames[key];
-                    }
+            for (const [ key, value ] of this.ssrcOwners.entries()) {
+                if (value === endpointId) {
+                    delete this._sourceNames[key];
                 }
             }
         };
-
         room.addEventListener(XMPPEvents.MUC_MEMBER_LEFT, this._memberLeftHandler);
     }
 
             logger.warn('Requested peer media info, before room was set');
         };
 
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            const lastPresence = this.chatRoom?.getLastPresence(owner);
+        const lastPresence = this.chatRoom?.getLastPresence(owner);
 
-            if (!lastPresence) {
-                logger.warn(`getPeerMediaInfo - no presence stored for: ${owner}`);
+        if (!lastPresence) {
+            logger.warn(`getPeerMediaInfo - no presence stored for: ${owner}`);
 
-                return;
-            }
-            if (!this._doesEndpointSendNewSourceInfo(owner)) {
-                return legacyGetPeerMediaInfo();
-            }
+            return;
+        }
+        if (!this._doesEndpointSendNewSourceInfo(owner)) {
+            return legacyGetPeerMediaInfo();
+        }
 
-            if (sourceName) {
-                return this.getPeerSourceInfo(owner, sourceName);
-            }
+        if (sourceName) {
+            return this.getPeerSourceInfo(owner, sourceName);
+        }
 
-            /**
-             * @type {PeerMediaInfo}
-             */
-            const mediaInfo = {};
-            const endpointMediaSource = this._findEndpointSourceInfoForMediaType(owner, mediaType);
-
-            // The defaults are provided only, because getPeerMediaInfo is a legacy method. This will be eventually
-            // changed into a getSourceInfo method which returns undefined if there's no source. Also there will be
-            // no mediaType argument there.
-            if (mediaType === MediaType.AUDIO) {
-                mediaInfo.muted = endpointMediaSource ? endpointMediaSource.muted : true;
-            } else if (mediaType === MediaType.VIDEO) {
-                mediaInfo.muted = endpointMediaSource ? endpointMediaSource.muted : true;
-                mediaInfo.videoType = endpointMediaSource ? endpointMediaSource.videoType : undefined;
-
-                const codecTypeNode = filterNodeFromPresenceJSON(lastPresence, 'jitsi_participant_codecType');
-
-                if (codecTypeNode.length > 0) {
-                    mediaInfo.codecType = codecTypeNode[0].value;
-                }
-            } else {
-                throw new Error(`Unsupported media type: ${mediaType}`);
-            }
+        const mediaInfo = {
+            muted: true
+        };
 
-            return mediaInfo;
+        if (mediaType === MediaType.VIDEO) {
+            mediaInfo.videoType = undefined;
+            const codecTypeNode = filterNodeFromPresenceJSON(lastPresence, 'jitsi_participant_codecType');
+
+            if (codecTypeNode.length > 0) {
+                mediaInfo.codecType = codecTypeNode[0].value;
+            }
         }
 
-        return legacyGetPeerMediaInfo();
+        return mediaInfo;
     }
 
     /**
         this._localSourceState[sourceName].muted = muted;
 
         if (this.chatRoom) {
-            // FIXME This only adjusts the presence, but doesn't actually send it. Here we temporarily rely on
-            // the legacy signaling part to send the presence. Remember to add "send presence" here when the legacy
-            // signaling is removed.
             return this._addLocalSourceInfoToPresence();
         }
 
             // Include only if not a camera (default)
             this._localSourceState[sourceName].videoType = videoType === VideoType.CAMERA ? undefined : videoType;
 
-            // NOTE this doesn't send the actual presence, because is called from the same place where the legacy video
-            // type is emitted which does the actual sending. A send presence statement needs to be added when
-            // the legacy part is removed.
             return this._addLocalSourceInfoToPresence();
         }
 

modules/xmpp/SignalingLayerImpl.spec.js

         let chatRoom = createMockChatRoom();
 
         beforeEach(() => {
-            FeatureFlags.init({ sourceNameSignaling: true });
             signalingLayer = new SignalingLayerImpl();
             chatRoom = createMockChatRoom();
             signalingLayer.setChatRoom(chatRoom);
             let chatRoom = createMockChatRoom();
 
             beforeEach(() => {
-                FeatureFlags.init({ sourceNameSignaling: true });
                 signalingLayer = new SignalingLayerImpl();
                 chatRoom = createMockChatRoom();
                 signalingLayer.setChatRoom(chatRoom);
                 );
             });
         });
-        describe('with:  sourceNameSignaling: false', () => {
-            let signalingLayer;
-            let chatRoom;
-
-            beforeEach(() => {
-                FeatureFlags.init({ sourceNameSignaling: false });
-                signalingLayer = new SignalingLayerImpl();
-                chatRoom = createMockChatRoom();
-                signalingLayer.setChatRoom(chatRoom);
-            });
-            it('does not react to SourceInfo', () => {
-                const emitterSpy = spyOn(signalingLayer.eventEmitter, 'emit');
-                const sourceInfo = {
-                    '12345678-a0': {
-                        muted: true
-                    }
-                };
-
-                chatRoom.mockSourceInfoPresence('endpoint1', sourceInfo);
-
-                expect(emitterSpy).not.toHaveBeenCalled();
-            });
-        });
     });
     describe('getPeerMediaInfo', () => {
         describe('with:  sourceNameSignaling: true', () => {
             let chatRoom;
 
             beforeEach(() => {
-                FeatureFlags.init({ sourceNameSignaling: true });
                 signalingLayer = new SignalingLayerImpl();
                 chatRoom = createMockChatRoom();
                 signalingLayer.setChatRoom(chatRoom);
 
                     chatRoom.mockSourceInfoPresence(endpointId, sourceInfo);
 
-                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endpointId, MediaType.AUDIO);
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endpointId, MediaType.AUDIO, '12345678-a0');
 
-                    expect(peerMediaInfo).toEqual({ muted: true });
+                    expect(peerMediaInfo).toEqual({
+                        muted: true,
+                        sourceName: '12345678-a0'
+                    });
                 });
                 it('for video', () => {
                     const endointId = '12345678';
 
                     chatRoom.mockSourceInfoPresence(endointId, sourceInfo);
 
-                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
-
-                    expect(peerMediaInfo).toEqual({
-                        muted: true,
-                        videoType: 'desktop'
-                    });
-                });
-            });
-            describe('if there\'s no SourceInfo then will read from the legacy element', () => {
-                const endointId = '12345678';
-
-                it('for audio', () => {
-                    // There's no 'SourceInfo' in the presence
-                    chatRoom.getLastPresence = () => [ { } ];
-
-                    // This test is very implementation specific and relies on the fact that the backwards compat logic
-                    // is supposed to call into 'chatRoom.getMediaPresenceInfo' and return whatever it returns.
-                    // To be removed once legacy signaling is deprecated.
-                    chatRoom.getMediaPresenceInfo = () => {
-                        return {
-                            muted: true
-                        };
-                    };
-
-                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.AUDIO);
-
-                    expect(peerMediaInfo).toEqual({ muted: true });
-                });
-                it('for video', () => {
-                    // There's no 'SourceInfo' in the presence
-                    chatRoom.getLastPresence = () => [ { } ];
-
-                    // This test is very implementation specific and relies on the fact that the backwards compat logic
-                    // is supposed to call into 'chatRoom.getMediaPresenceInfo' and return whatever it returns.
-                    // To be removed once legacy signaling is deprecated.
-                    chatRoom.getMediaPresenceInfo = () => {
-                        return {
-                            muted: true,
-                            videoType: 'desktop'
-                        };
-                    };
-
-                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO, '12345678-v0');
 
                     expect(peerMediaInfo).toEqual({
                         muted: true,
+                        sourceName: '12345678-v0',
                         videoType: 'desktop'
                     });
                 });
             });
         });
-        describe('with:  sourceNameSignaling: false', () => {
-            beforeEach(() => {
-                FeatureFlags.init({ sourceNameSignaling: false });
-            });
-            it('should not read from SourceInfo element', () => {
-                const signalingLayer = new SignalingLayerImpl();
-                const chatRoom = createMockChatRoom();
-
-                signalingLayer.setChatRoom(chatRoom);
-
-                const endointId = '12345678';
-                const sourceInfo = {
-                    '12345678-v0': {
-                        muted: true,
-                        videoType: 'desktop'
-                    }
-                };
-
-                chatRoom.mockSourceInfoPresence(endointId, sourceInfo);
-
-                // This is the value the legacy flow will use (the values are different that the SourceInfo one).
-                const legacyMediaInfoValue = {
-                    muted: false,
-                    videoType: 'camera'
-                };
-
-                chatRoom.getMediaPresenceInfo = () => legacyMediaInfoValue;
-
-                const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
-
-                expect(peerMediaInfo).toEqual(legacyMediaInfoValue);
-            });
-        });
     });
     describe('will remove source info(cleanup corner cases)', () => {
         let signalingLayer;
         const endpointId = '12345678';
 
         beforeEach(() => {
-            FeatureFlags.init({ sourceNameSignaling: true });
-
             signalingLayer = new SignalingLayerImpl();
             chatRoom = createMockChatRoom();
 

modules/xmpp/xmpp.js

 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import browser from '../browser';
 import { E2EEncryption } from '../e2ee/E2EEncryption';
-import FeatureFlags from '../flags/FeatureFlags';
 import Statistics from '../statistics/statistics';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
         }
 
         // Advertise source-name signaling when the endpoint supports it.
-        if (FeatureFlags.isSourceNameSignalingEnabled()) {
-            logger.info('Source-name signaling is enabled');
-            this.caps.addFeature('http://jitsi.org/source-name');
-        }
-        if (FeatureFlags.isReceiveMultipleVideoStreamsSupported()) {
-            logger.info('Receiving multiple video streams is enabled');
-            this.caps.addFeature('http://jitsi.org/receive-multiple-video-streams');
-        }
+        logger.debug('Source-name signaling is enabled');
+        this.caps.addFeature('http://jitsi.org/source-name');
+
+        logger.debug('Receiving multiple video streams is enabled');
+        this.caps.addFeature('http://jitsi.org/receive-multiple-video-streams');
     }
 
     /**

service/RTC/MediaType.spec.ts

         expect( MediaType ).toBeDefined();
 
         expect( MediaType.AUDIO ).toBe( 'audio' );
-        expect( MediaType.PRESENTER ).toBe( 'presenter' );
         expect( MediaType.VIDEO ).toBe( 'video' );
     } );
 

service/RTC/MediaType.ts

      */
     AUDIO = 'audio',
 
-    /**
-     * The presenter type.
-     */
-    PRESENTER = 'presenter',
-
     /**
      * The video type.
      */

service/RTC/RTCEvents.spec.ts

         DATA_CHANNEL_OPEN,
         ENDPOINT_CONN_STATUS_CHANGED,
         DOMINANT_SPEAKER_CHANGED,
-        LASTN_ENDPOINT_CHANGED,
         FORWARDED_SOURCES_CHANGED,
         PERMISSIONS_CHANGED,
         SENDER_VIDEO_CONSTRAINTS_CHANGED,
         expect( DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
         expect( ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
         expect( DOMINANT_SPEAKER_CHANGED ).toBe( 'rtc.dominant_speaker_changed' );
-        expect( LASTN_ENDPOINT_CHANGED ).toBe( 'rtc.lastn_endpoint_changed' );
         expect( FORWARDED_SOURCES_CHANGED ).toBe( 'rtc.forwarded_sources_changed' );
         expect( PERMISSIONS_CHANGED ).toBe( 'rtc.permissions_changed' );
         expect( SENDER_VIDEO_CONSTRAINTS_CHANGED ).toBe( 'rtc.sender_video_constraints_changed' );
             expect( RTCEvents.DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
             expect( RTCEvents.ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
             expect( RTCEvents.DOMINANT_SPEAKER_CHANGED ).toBe( 'rtc.dominant_speaker_changed' );
-            expect( RTCEvents.LASTN_ENDPOINT_CHANGED ).toBe( 'rtc.lastn_endpoint_changed' );
             expect( RTCEvents.PERMISSIONS_CHANGED ).toBe( 'rtc.permissions_changed' );
             expect( RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED ).toBe( 'rtc.sender_video_constraints_changed' );
             expect( RTCEvents.LASTN_VALUE_CHANGED ).toBe( 'rtc.lastn_value_changed' );
             expect( RTCEventsDefault.DATA_CHANNEL_OPEN ).toBe( 'rtc.data_channel_open' );
             expect( RTCEventsDefault.ENDPOINT_CONN_STATUS_CHANGED ).toBe( 'rtc.endpoint_conn_status_changed' );
             expect( RTCEventsDefault.DOMINANT_SPEAKER_CHANGED ).toBe( 'rtc.dominant_speaker_changed' );
-            expect( RTCEventsDefault.LASTN_ENDPOINT_CHANGED ).toBe( 'rtc.lastn_endpoint_changed' );
             expect( RTCEventsDefault.PERMISSIONS_CHANGED ).toBe( 'rtc.permissions_changed' );
             expect( RTCEventsDefault.SENDER_VIDEO_CONSTRAINTS_CHANGED ).toBe( 'rtc.sender_video_constraints_changed' );
             expect( RTCEventsDefault.LASTN_VALUE_CHANGED ).toBe( 'rtc.lastn_value_changed' );

service/RTC/RTCEvents.ts

     DATA_CHANNEL_OPEN = 'rtc.data_channel_open',
     ENDPOINT_CONN_STATUS_CHANGED = 'rtc.endpoint_conn_status_changed',
     DOMINANT_SPEAKER_CHANGED = 'rtc.dominant_speaker_changed',
-    LASTN_ENDPOINT_CHANGED = 'rtc.lastn_endpoint_changed',
     FORWARDED_SOURCES_CHANGED = 'rtc.forwarded_sources_changed',
 
     /**
 export const DATA_CHANNEL_OPEN = RTCEvents.DATA_CHANNEL_OPEN;
 export const ENDPOINT_CONN_STATUS_CHANGED = RTCEvents.ENDPOINT_CONN_STATUS_CHANGED;
 export const DOMINANT_SPEAKER_CHANGED = RTCEvents.DOMINANT_SPEAKER_CHANGED;
-export const LASTN_ENDPOINT_CHANGED = RTCEvents.LASTN_ENDPOINT_CHANGED;
 export const FORWARDED_SOURCES_CHANGED = RTCEvents.FORWARDED_SOURCES_CHANGED;
 export const PERMISSIONS_CHANGED = RTCEvents.PERMISSIONS_CHANGED;
 export const SENDER_VIDEO_CONSTRAINTS_CHANGED = RTCEvents.SENDER_VIDEO_CONSTRAINTS_CHANGED;

types/hand-crafted/JitsiConference.d.ts

   selectParticipants: ( participantIds: string[] ) => void;
   getLastN: () => number;
   setLastN: ( lastN: number ) => void;
-  isInLastN: ( participantId: string ) => boolean;
   getParticipants: () => JitsiParticipant[];
   getParticipantCount: ( countHidden?: boolean ) => number;
   getParticipantById: ( id: string ) => JitsiParticipant;

types/hand-crafted/JitsiConferenceEvents.d.ts

   NOISY_MIC = 'conference.noisy_mic',
   NON_PARTICIPANT_MESSAGE_RECEIVED = 'conference.non_participant_message_received',
   PRIVATE_MESSAGE_RECEIVED = 'conference.privateMessageReceived',
-  PARTICIPANT_CONN_STATUS_CHANGED = 'conference.participant_conn_status_changed',
   PARTCIPANT_FEATURES_CHANGED = 'conference.partcipant_features_changed',
   PARTICIPANT_PROPERTY_CHANGED = 'conference.participant_property_changed',
   P2P_STATUS = 'conference.p2pStatus',

types/hand-crafted/JitsiMeetJS.d.ts

 import { JitsiConferenceEvents } from './JitsiConferenceEvents';
 import { JitsiTranscriptionStatus } from './JitsiTranscriptionStatus';
 import BrowserCapabilities from './modules/browser/BrowserCapabilities';
-import { ParticipantConnectionStatus } from './modules/connectivity/ParticipantConnectionStatus';
 import { DetectionEvents } from './modules/detection/DetectionEvents';
 import TrackVADEmitter, { VADProcessor } from './modules/detection/TrackVADEmitter';
 import RecordingConstants from './modules/recording/recordingConstants';
   //USER_MEDIA_SLOW_PROMISE_TIMEOUT: 1000;
 
   constants: {
-    participantConnectionStatus: typeof ParticipantConnectionStatus,
     recording: typeof RecordingConstants,
     sipVideoGW: typeof VideoSIPGWConstants,
     transcriptionStatus: typeof JitsiTranscriptionStatus,

types/hand-crafted/modules/RTC/RTC.d.ts

   setAudioLevel: ( tpc: TraceablePeerConnection, ssrc: number, audioLevel: number, isLocal: boolean ) => void;
   sendChannelMessage: ( to: string, payload: unknown ) => void; // TODO:
   setLastN: ( value: number ) => void;
-  isInLastN: ( id: string ) => boolean;
   isInForwardedSources: ( sourceName: string ) => boolean;
   setNewReceiverVideoConstraints: ( constraints: unknown ) => void; // TODO:
   setVideoType: ( videoType: string ) => void;

types/hand-crafted/modules/xmpp/ChatRoom.d.ts

   sendAudioInfoPresence: ( mute: unknown, callback: ( params: unknown ) => unknown ) => void; // TODO:
   addVideoInfoToPresence: ( mute: unknown ) => void; // TODO:
   sendVideoInfoPresence: ( mute: unknown ) => void; // TODO:
-  getMediaPresenceInfo: ( endpointId: string, mediaType: MediaType ) => unknown; // TODO: what is PeerMediaInfo
   isSIPCallingSupported: () => boolean;
   dial: ( number: string ) => unknown; // TODO:
   hangup: () => unknown; // TODO:

types/hand-crafted/service/RTC/MediaType.d.ts

 export enum MediaType {
   AUDIO = 'audio',
-  PRESENTER = 'presenter',
   VIDEO = 'video'
 }