fix(connection-quality) Trigger ramp up on codec and session changes.

JitsiConference.js

 import ComponentsVersions from './modules/version/ComponentsVersions';
 import VideoSIPGW from './modules/videosipgw/VideoSIPGW';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
+import MediaSessionEvents from './modules/xmpp/MediaSessionEvents';
 import SignalingLayerImpl from './modules/xmpp/SignalingLayerImpl';
 import {
     FEATURE_E2EE,
                 if (!this.isP2PActive()) {
                     this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, jingleSession);
                 }
+
+                jingleSession.addEventListener(MediaSessionEvents.VIDEO_CODEC_CHANGED, () => {
+                    this.eventEmitter.emit(JitsiConferenceEvents.VIDEO_CODEC_CHANGED);
+                });
             },
             error => {
                 logger.error('Failed to accept incoming Jingle session', error);
             this.eventEmitter.emit(
                 JitsiConferenceEvents._MEDIA_SESSION_STARTED,
                 jingleSession);
+
+            jingleSession.addEventListener(MediaSessionEvents.VIDEO_CODEC_CHANGED, () => {
+                this.eventEmitter.emit(JitsiConferenceEvents.VIDEO_CODEC_CHANGED);
+            });
         },
         error => {
             logger.error(
     const localTracks = this.getLocalTracks();
 
     this.p2pJingleSession.invite(localTracks);
+
+    this.p2pJingleSession.addEventListener(MediaSessionEvents.VIDEO_CODEC_CHANGED, () => {
+        this.eventEmitter.emit(JitsiConferenceEvents.VIDEO_CODEC_CHANGED);
+    });
 };
 
 /**

JitsiConferenceEvents.spec.ts

         PHONE_NUMBER_CHANGED,
         PROPERTIES_CHANGED,
         RECORDER_STATE_CHANGED,
+        VIDEO_CODEC_CHANGED,
         VIDEO_SIP_GW_AVAILABILITY_CHANGED,
         VIDEO_SIP_GW_SESSION_STATE_CHANGED,
         START_MUTED_POLICY_CHANGED,
         expect( PHONE_NUMBER_CHANGED ).toBe( 'conference.phoneNumberChanged' );
         expect( PROPERTIES_CHANGED ).toBe( 'conference.propertiesChanged' );
         expect( RECORDER_STATE_CHANGED ).toBe( 'conference.recorderStateChanged' );
+        expect( VIDEO_CODEC_CHANGED ).toBe( 'conference.videoCodecChanged' );
         expect( VIDEO_SIP_GW_AVAILABILITY_CHANGED ).toBe( 'conference.videoSIPGWAvailabilityChanged' );
         expect( VIDEO_SIP_GW_SESSION_STATE_CHANGED ).toBe( 'conference.videoSIPGWSessionStateChanged' );
         expect( VISITORS_SUPPORTED_CHANGED ).toBe( 'conference.visitorsSupported' );

JitsiConferenceEvents.ts

      */
     USER_STATUS_CHANGED = 'conference.statusChanged',
 
+    /**
+     * Indicates that the video codec of the local video track has changed.
+     */
+    VIDEO_CODEC_CHANGED = 'conference.videoCodecChanged',
+
     /**
      * Indicates that video SIP GW state changed.
      * @param {VideoSIPGWConstants} status.
 export const USER_LEFT = JitsiConferenceEvents.USER_LEFT;
 export const USER_ROLE_CHANGED = JitsiConferenceEvents.USER_ROLE_CHANGED;
 export const USER_STATUS_CHANGED = JitsiConferenceEvents.USER_STATUS_CHANGED;
+export const VIDEO_CODEC_CHANGED = JitsiConferenceEvents.VIDEO_CODEC_CHANGED;
 export const VIDEO_SIP_GW_AVAILABILITY_CHANGED = JitsiConferenceEvents.VIDEO_SIP_GW_AVAILABILITY_CHANGED;
 export const VIDEO_SIP_GW_SESSION_STATE_CHANGED = JitsiConferenceEvents.VIDEO_SIP_GW_SESSION_STATE_CHANGED;
 export const VIDEO_UNMUTE_PERMISSIONS_CHANGED = JitsiConferenceEvents.VIDEO_UNMUTE_PERMISSIONS_CHANGED;

modules/RTC/TraceablePeerConnection.js

  *
  * @param {Array<CodecMimeType>} codecList - Preferred codecs for video.
  * @param {CodecMimeType} screenshareCodec - The preferred codec for screenshare.
- * @returns {void}
+ * @returns {boolean} - Returns true if the codec settings were updated, false otherwise.
  */
 TraceablePeerConnection.prototype.setVideoCodecs = function(codecList, screenshareCodec) {
+    let updated = false;
+
     if (!this.codecSettings || !codecList?.length) {
-        return;
+        return updated;
     }
 
     this.codecSettings.codecList = codecList;
     }
 
     if (!this.usesCodecSelectionAPI()) {
-        return;
+        return updated;
     }
 
     for (const track of this.getLocalVideoTracks()) {
 
         if (screenshareCodec && track.getVideoType() === VideoType.DESKTOP && screenshareCodec !== currentCodec) {
             this.configureVideoSenderEncodings(track, screenshareCodec);
+            updated = true;
         } else if (currentCodec !== codecList[0]) {
             this.configureVideoSenderEncodings(track);
+            updated = true;
         }
     }
+
+    return updated;
 };
 
 /**

modules/connectivity/ConnectionQuality.js

                     this._maybeUpdateUnmuteTime();
                 }
             });
+
+        conference.on(ConferenceEvents.VIDEO_CODEC_CHANGED, this._resetVideoUnmuteTime.bind(this));
+
+        conference.on(ConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, this._resetVideoUnmuteTime.bind(this));
+
         conference.rtc.on(
             RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED,
             track => {
         );
     }
 
+    /**
+     * Resets the time video was unmuted and triggers a new ramp-up.
+     *
+     * @private
+     * @returns {void}
+     */
+    _resetVideoUnmuteTime() {
+        this._timeVideoUnmuted = -1;
+        this._maybeUpdateUnmuteTime();
+    }
+
     /**
      * Sets _timeVideoUnmuted if it was previously unset. If it was already set,
      * doesn't change it.

modules/xmpp/JingleSessionPC.js

      */
     setVideoCodecs(codecList, screenshareCodec) {
         if (this._assertNotEnded()) {
-            this.peerconnection.setVideoCodecs(codecList, screenshareCodec);
+            const updated = this.peerconnection.setVideoCodecs(codecList, screenshareCodec);
+
+            if (updated) {
+                this.eventEmitter.emit(MediaSessionEvents.VIDEO_CODEC_CHANGED);
+            }
 
             // Browser throws an error when H.264 is set on the encodings. Therefore, munge the SDP when H.264 needs to
             // be selected.
                 return;
             }
 
+            this.eventEmitter.emit(MediaSessionEvents.VIDEO_CODEC_CHANGED);
             Statistics.sendAnalytics(
                 VIDEO_CODEC_CHANGED,
                 {

modules/xmpp/MediaSessionEvents.spec.ts

 describe( "/modules/xmpp/MediaSessionEvents members", () => {
     const {
         REMOTE_SOURCE_CONSTRAINTS_CHANGED,
+        VIDEO_CODEC_CHANGED,
         ...others
     } = exported;
 
     it( "known members", () => {
         expect( REMOTE_SOURCE_CONSTRAINTS_CHANGED ).toBe( 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED' );
+        expect( VIDEO_CODEC_CHANGED ).toBe( 'media_session.VIDEO_CODEC_CHANGED' );
     } );
 
     it( "unknown members", () => {

modules/xmpp/MediaSessionEvents.ts

     /**
      * Event triggered when the remote party signals video max frame heights for its local sources.
      */
-    REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED'
+    REMOTE_SOURCE_CONSTRAINTS_CHANGED = 'media_session.REMOTE_SOURCE_CONSTRAINTS_CHANGED',
+
+    /**
+     * Event triggered when the video codec of the local video track has changed.
+     */
+    VIDEO_CODEC_CHANGED = 'media_session.VIDEO_CODEC_CHANGED'
 }
 
 export default MediaSessionEvents;