Takes disabled encodings into account when calculating the local resolution. (#1242)

* fix: Takes disabled encodings into account when calculating local resolution.
* feat: Adds a new event that's triggered when the max enabled resolution changes.
* feat: Broadcasts the max enabled resolution value along with other stats.

modules/RTC/JitsiLocalTrack.js

             // Get the resolution from the track itself because it cannot be
             // certain which resolution webrtc has fallen back to using.
             this.resolution = track.getSettings().height;
+            this.maxEnabledResolution = resolution;
 
             // Cache the constraints of the track in case of any this track
             // model needs to call getUserMedia again, such as when unmuting.
             // resolutions so we do not store it, to avoid wrong reporting of
             // local track resolution.
             this.resolution = browser.isFirefox() ? null : resolution;
+            this.maxEnabledResolution = this.resolution;
         }
 
         this.deviceId = deviceId;

modules/RTC/TraceablePeerConnection.js

                     }
                 }
 
-                return videoSender.setParameters(parameters);
+                return videoSender.setParameters(parameters).then(() => {
+                    localVideoTrack.maxEnabledResolution = newHeight;
+                    this.eventEmitter.emit(RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED, localVideoTrack);
+                });
             });
     }
 

modules/connectivity/ConnectionQuality.js

 import * as ConnectionQualityEvents
     from '../../service/connectivity/ConnectionQualityEvents';
 import * as ConferenceEvents from '../../JitsiConferenceEvents';
+import * as RTCEvents from '../../service/RTC/RTCEvents';
+
 import { getLogger } from 'jitsi-meet-logger';
 
 const XMPPEvents = require('../../service/xmpp/XMPPEvents');
                     this._maybeUpdateUnmuteTime();
                 }
             });
+        conference.rtc.on(
+            RTCEvents.LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED,
+            track => {
+                this._localStats.maxEnabledResolution = track.maxEnabledResolution;
+            });
 
         conference.on(
             ConferenceEvents.SERVER_REGION_CHANGED,
             connectionQuality: this._localStats.connectionQuality,
             jvbRTT: this._localStats.jvbRTT,
             serverRegion: this._localStats.serverRegion,
+            maxEnabledResolution: this._localStats.maxEnabledResolution,
             avgAudioLevels: this._localStats.localAvgAudioLevels
         };
 
         const videoType
             = localVideoTrack ? localVideoTrack.videoType : undefined;
         const isMuted = localVideoTrack ? localVideoTrack.isMuted() : true;
-        const resolution = localVideoTrack ? localVideoTrack.resolution : null;
+        const resolution = localVideoTrack
+            ? Math.min(localVideoTrack.resolution, localVideoTrack.maxEnabledResolution) : null;
 
         if (!isMuted) {
             this._maybeUpdateUnmuteTime();
             connectionQuality: data.connectionQuality,
             jvbRTT: data.jvbRTT,
             serverRegion: data.serverRegion,
+            maxEnabledResolution: data.maxEnabledResolution,
             avgAudioLevels: data.avgAudioLevels
         };
 

service/RTC/RTCEvents.js

      */
     LOCAL_TRACK_SSRC_UPDATED: 'rtc.local_track_ssrc_updated',
 
+    /**
+     * The max enabled resolution of a local video track was changed.
+     */
+    LOCAL_TRACK_MAX_ENABLED_RESOLUTION_CHANGED: 'rtc.local_track_max_enabled_resolution_changed',
+
     TRACK_ATTACHED: 'rtc.track_attached',
 
     /**