Last n improvements (#493)

* doc(JitsiConference): deprecate 'isInLastN'

The 'isInLastN' method should not be used for the UI purposes, but
ParticipantConnectionStatus value should be used instead.

* fix(ParticipantConn..Status): speed up INACTIVE transition

Before this change when user's video stops playing, after user is
removed from last N we were waiting 2 seconds, before going to INACTIVE
state. This commit reduces the time to 500ms for such case.

* fix(ParticipantConn...): reduce logging

Reduce logging verbosity.

* fix(ParticipantConn...): handle LastN == 0

When LastN is set to 0 we should not rely on video playback and last N
set for figuring out participant connection status.

* fix(JitsiConference): undefined participants

Fixes a crash when this.participants field is accessed from _init.

JitsiConference.js

     this.eventEmitter = new EventEmitter();
     this.options = options;
     this.eventManager = new JitsiConferenceEventManager(this);
+    this.participants = {};
     this._init(options);
     this.componentsVersions = new ComponentsVersions(this);
-    this.participants = {};
 
     /**
      * Jingle session instance for the JVB connection.
 
     this.participantConnectionStatus
         = new ParticipantConnectionStatusHandler(
-                this.rtc, this,
-                options.config.peerDisconnectedThroughRtcTimeout);
+            this.rtc,
+            this,
+            {   // Both 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.
+                rtcMuteTimeout:
+                    this.options.config._peerConnStatusRtcMuteTimeout,
+                outOfLastNTimeout:
+                    this.options.config._peerConnStatusOutOfLastNTimeout
+            });
     this.participantConnectionStatus.init();
 
     if (!this.statistics) {
  * 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);

modules/RTC/RTC.js

          * @private
          * @type {number}
          */
-        this._lastN = null;
+        this._lastN = -1;
 
         /**
          * Defines the last N endpoints list. It can be null or an array once
 
                 // If setLastN was invoked before the data channels completed
                 // opening, apply the specified value now that the data channels
-                // are open.
-                if (this._lastN !== null) {
-                    this.setLastN(this._lastN);
-                    this._lastN = null;
+                // are open. NOTE that -1 is the default value assumed by both
+                // RTC module and the JVB.
+                if (this._lastN !== -1) {
+                    this.dataChannels.sendSetLastNMessage(this._lastN);
                 }
             };
             this.addListener(RTCEvents.DATA_CHANNEL_OPEN,
         track.conference = this.conference;
     }
 
+    /**
+     * Returns the current value for "lastN" - the amount of videos are going
+     * to be delivered. When set to -1 for unlimited or all available videos.
+     * @return {number}
+     */
+    getLastN() {
+        return this._lastN;
+    }
+
     /**
      * Get local video track.
      * @returns {JitsiLocalTrack|undefined}
      * @param value {number} the new value for lastN.
      */
     setLastN(value) {
-        if (this.dataChannels && this.dataChannelsOpen) {
-            this.dataChannels.sendSetLastNMessage(value);
-        } else {
-            // No data channel has been initialized or has completed opening
-            // yet. Remember the specified value and apply it as soon as a data
-            // channel opens.
+        if (this._lastN !== value) {
             this._lastN = value;
+            if (this.dataChannels && this.dataChannelsOpen) {
+                this.dataChannels.sendSetLastNMessage(value);
+            }
+            this.eventEmitter.emit(RTCEvents.LASTN_VALUE_CHANGED, value);
         }
     }
 

modules/connectivity/ParticipantConnectionStatus.js

 
 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 2000 milliseconds for
  * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
      * @constructor
      * @param {RTC} rtc the RTC service instance
      * @param {JitsiConference} conference parent conference instance
-     * @param {number} rtcMuteTimeout (optional) custom value for
+     * @param {Object} options
+     * @param {number} [options.rtcMuteTimeout=2000] custom value for
      * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
+     * @param {number} [options.outOfLastNTimeout=500] custom value for
+     * {@link ParticipantConnectionStatus.outOfLastNTimeout}.
      */
-    constructor(rtc, conference, rtcMuteTimeout) {
+    constructor(rtc, conference, options) {
         this.rtc = rtc;
         this.conference = conference;
 
          */
         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're going to wait after the RTC video track muted event
          * for the corresponding signalling mute event, before the connection
          * @type {number} amount of time in milliseconds
          */
         this.rtcMuteTimeout
-            = typeof rtcMuteTimeout === 'number'
-                ? rtcMuteTimeout : DEFAULT_RTC_MUTE_TIMEOUT;
+            = typeof options.rtcMuteTimeout === 'number'
+                ? options.rtcMuteTimeout : DEFAULT_RTC_MUTE_TIMEOUT;
 
         /**
          * This map holds a timestamp indicating  when participant's video track
         this.restoringTimers = 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.outOfLastNTimeout;
+    }
+
     /**
      * Initializes <tt>ParticipantConnectionStatus</tt> and bind required event
      * listeners.
         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);
     }
 
     /**
             JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
             this._onLastNChanged);
 
+        this.rtc.removeListener(
+            RTCEvents.LASTN_VALUE_CHANGED, this._onLastNValueChanged);
+
         this.conference.off(
             JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
 
             return false;
         }
 
+        const id = participant.getId();
         const hasAnyVideoRTCMuted = participant.hasAnyVideoTrackWebRTCMuted();
-        const rtcMutedTimestamp
-            = this.rtcMutedTimestamp[participant.getId()];
+        const rtcMutedTimestamp = this.rtcMutedTimestamp[id];
+        const timeout = this._getVideoFrozenTimeout(id);
 
         return hasAnyVideoRTCMuted
             && typeof rtcMutedTimestamp === 'number'
-            && (Date.now() - rtcMutedTimestamp) >= this.rtcMuteTimeout;
+            && (Date.now() - rtcMutedTimestamp) >= timeout;
     }
 
     /**
 
         const inP2PMode = this.conference.isP2PActive();
         const isRestoringTimedOut = this._isRestoringTimedout(id);
-        const isVideoMuted = participant.isVideoMuted();
+        const audioOnlyMode = this.rtc.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];
      * @private
      */
     _onLastNChanged(leavingLastN = [], enteringLastN = []) {
+        const now = Date.now();
+
+        logger.debug(
+            'leaving/entering lastN', leavingLastN, enteringLastN, now);
+
         for (const id of leavingLastN) {
             this.enteredLastNTimestamp.delete(id);
             this._clearRestoringTimer(id);
         }
         for (const id of enteringLastN) {
             // store the timestamp this id is entering lastN
-            this.enteredLastNTimestamp.set(id, Date.now());
-
+            this.enteredLastNTimestamp.set(id, now);
             this.figureOutConnectionStatus(id);
         }
     }
         const participantId = track.getParticipantId();
         const participant = this.conference.getParticipantById(participantId);
 
-        logger.debug(`Detector track RTC muted: ${participantId}`);
+        logger.debug(`Detector track RTC muted: ${participantId}`, Date.now());
         if (!participant) {
             logger.error(`No participant for id: ${participantId}`);
 
             // 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(`RTC mute timeout for: ${participantId}`);
+                logger.debug(
+                    `Set RTC mute timeout for: ${participantId}\
+                     of ${timeout} ms`);
                 this.clearTimeout(participantId);
                 this.figureOutConnectionStatus(participantId);
-            }, this.rtcMuteTimeout);
+            }, timeout);
         }
     }
 
     onTrackRtcUnmuted(track) {
         const participantId = track.getParticipantId();
 
-        logger.debug(`Detector track RTC unmuted: ${participantId}`);
+        logger.debug(
+            `Detector track RTC unmuted: ${participantId}`, Date.now());
 
         this.clearTimeout(participantId);
         this.clearRtcMutedTimestamp(participantId);

service/RTC/RTCEvents.js

     ENDPOINT_CONN_STATUS_CHANGED: 'rtc.endpoint_conn_status_changed',
     DOMINANT_SPEAKER_CHANGED: 'rtc.dominant_speaker_changed',
     LASTN_ENDPOINT_CHANGED: 'rtc.lastn_endpoint_changed',
+
+    /**
+     * Event emitted when {@link RTC.setLastN} method is called to update with
+     * the new value set.
+     * The first argument is the value passed to {@link RTC.setLastN}.
+     */
+    LASTN_VALUE_CHANGED: 'rtc.lastn_value_changed',
     AVAILABLE_DEVICES_CHANGED: 'rtc.available_devices_changed',
     TRACK_ATTACHED: 'rtc.track_attached',