Adds peer connection statuses (active/inactive/interrupted/restoring). (#430)

* Adds peer connection statuses (active/inactive/interrupted/restoring).

The peer connection used to be check with is connection active. Adding new states like active, inactive, when the connection was intentionally stopped by the bridge, interrupted due to network problem and restoring, which is the state of a peer which was inactive as being out of lastN and is now entering lastM and eventually will become active.

* Adds timers to track restoring status.

If restoring too long we set the connection status to interrupted. We save timestamps for all participants entering lastN and set the status for the connection to restoring for 5 seconds, or till it goes into active or exits lastN.

* Adds initial connectionStatus of newly created participant - active.

* Fixes some jsdocs.

* Uses symbols for strings and use of map, fixing comments on PR.

* Removes symbols.

JitsiConference.js

@@ -15,7 +15,7 @@ import JitsiTrackError from './JitsiTrackError';
 import * as JitsiTrackErrors from './JitsiTrackErrors';
 import * as JitsiTrackEvents from './JitsiTrackEvents';
 import * as MediaType from './service/RTC/MediaType';
-import ParticipantConnectionStatus
+import ParticipantConnectionStatusHandler
     from './modules/connectivity/ParticipantConnectionStatus';
 import RTC from './modules/RTC/RTC';
 import RTCBrowserType from './modules/RTC/RTCBrowserType';
@@ -206,7 +206,7 @@ JitsiConference.prototype._init = function(options = {}) {
     }
 
     this.participantConnectionStatus
-        = new ParticipantConnectionStatus(
+        = new ParticipantConnectionStatusHandler(
                 this.rtc, this,
                 options.config.peerDisconnectedThroughRtcTimeout);
     this.participantConnectionStatus.init();

JitsiConferenceEvents.js

@@ -110,11 +110,17 @@ export const MESSAGE_RECEIVED = 'conference.messageReceived';
 
 /**
  * Event fired when JVB sends notification about interrupted/restored user's
- * ICE connection status. First argument is the ID of the participant and
- * the seconds is a boolean indicating if the connection is currently
- * active(true = active, false = interrupted).
+ * 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.isConnectionActive().
+ * JitsiParticipant.getConnectionStatus().
  */
 export const PARTICIPANT_CONN_STATUS_CHANGED
     = 'conference.participant_conn_status_changed';

JitsiMeetJS.js

@@ -18,6 +18,8 @@ import * as JitsiTrackEvents from './JitsiTrackEvents';
 import Logger from 'jitsi-meet-logger';
 import * as MediaType from './service/RTC/MediaType';
 import Resolutions from './service/RTC/Resolutions';
+import { ParticipantConnectionStatus }
+    from './modules/connectivity/ParticipantConnectionStatus';
 import RTC from './modules/RTC/RTC';
 import RTCBrowserType from './modules/RTC/RTCBrowserType';
 import RTCUIHelper from './modules/RTC/RTCUIHelper';
@@ -90,6 +92,7 @@ const LibJitsiMeet = {
 
     JitsiConnection,
     constants: {
+        participantConnectionStatus: ParticipantConnectionStatus,
         sipVideoGW: VideoSIPGWConstants
     },
     events: {

JitsiParticipant.js

@@ -1,5 +1,7 @@
 /* global Strophe */
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
+import { ParticipantConnectionStatus }
+    from './modules/connectivity/ParticipantConnectionStatus';
 import * as MediaType from './service/RTC/MediaType';
 
 /**
@@ -33,7 +35,7 @@ export default class JitsiParticipant {
             video: undefined
         };
         this._hidden = hidden;
-        this._isConnectionActive = true;
+        this._connectionStatus = ParticipantConnectionStatus.ACTIVE;
         this._properties = {};
     }
 
@@ -72,22 +74,23 @@ export default class JitsiParticipant {
 
     /**
      * Updates participant's connection status.
-     * @param {boolean} isActive true if the user's connection is fine or false
-     * when the user is having connectivity issues.
+     * @param {string} state the current participant connection state.
+     * {@link ParticipantConnectionStatus}.
      * @private
      */
-    _setIsConnectionActive(isActive) {
-        this._isConnectionActive = isActive;
+    _setConnectionStatus(status) {
+        this._connectionStatus = status;
     }
 
     /**
-     * Checks participant's connectivity status.
+     * Return participant's connectivity status.
      *
-     * @returns {boolean} true if the connection is currently ok or false when
-     * the user is having connectivity issues.
+     * @returns {string} the connection status
+     * <tt>ParticipantConnectionStatus</tt> of the user.
+     * {@link ParticipantConnectionStatus}.
      */
-    isConnectionActive() {
-        return this._isConnectionActive;
+    getConnectionStatus() {
+        return this._connectionStatus;
     }
 
     /**

modules/connectivity/ParticipantConnectionStatus.js

@@ -17,11 +17,56 @@ const logger = getLogger(__filename);
  */
 const DEFAULT_RTC_MUTE_TIMEOUT = 2000;
 
+/**
+ * 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 = 5000;
+
+/**
+ * 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 ParticipantConnectionStatus {
+export default class ParticipantConnectionStatusHandler {
     /**
      * Creates new instance of <tt>ParticipantConnectionStatus</tt>.
      *
@@ -86,6 +131,27 @@ export default class ParticipantConnectionStatus {
          */
         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();
     }
 
     /**
@@ -135,6 +201,11 @@ export default class ParticipantConnectionStatus {
             this._onSignallingMuteChanged
                 = this.onSignallingMuteChanged.bind(this);
         }
+
+        this._onLastNChanged = this._onLastNChanged.bind(this);
+        this.conference.on(
+            JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
+            this._onLastNChanged);
     }
 
     /**
@@ -163,6 +234,10 @@ export default class ParticipantConnectionStatus {
                 this._onRemoteTrackRemoved);
         }
 
+        this.conference.off(
+            JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
+            this._onLastNChanged);
+
         this.conference.off(
             JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
 
@@ -181,8 +256,8 @@ export default class ParticipantConnectionStatus {
      * 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 endpointId {string} the endpoint ID(MUC nickname/resource JID)
-     * @param isActive {boolean} true if the connection is OK or false otherwise
+     * @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) {
 
@@ -199,16 +274,16 @@ export default class ParticipantConnectionStatus {
     }
 
     /**
-     *
-     * @param participant
+     * Changes connection status.
+     * @param {JitsiParticipant} participant
      * @param newStatus
      */
     _changeConnectionStatus(participant, newStatus) {
-        if (participant.isConnectionActive() !== newStatus) {
+        if (participant.getConnectionStatus() !== newStatus) {
 
             const endpointId = participant.getId();
 
-            participant._setIsConnectionActive(newStatus);
+            participant._setConnectionStatus(newStatus);
 
             logger.debug(
                 `Emit endpoint conn status(${Date.now()}) ${endpointId}: ${
@@ -236,7 +311,7 @@ export default class ParticipantConnectionStatus {
      * Reset the postponed "connection interrupted" event which was previously
      * scheduled as a timeout on RTC 'onmute' event.
      *
-     * @param participantId the participant for which the "connection
+     * @param {string} participantId the participant for which the "connection
      * interrupted" timeout was scheduled
      */
     clearTimeout(participantId) {
@@ -248,8 +323,8 @@ export default class ParticipantConnectionStatus {
 
     /**
      * Clears the timestamp of the RTC muted event for participant's video track
-     * @param participantId the id of the conference participant which is
-     * the same as the Colibri endpoint ID of the video channel allocated for
+     * @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) {
@@ -380,18 +455,117 @@ export default class ParticipantConnectionStatus {
             isConnActiveByJvb = true;
         }
 
-        const isConnectionActive
-            = isConnActiveByJvb
-                && (isVideoMuted || (isInLastN && !isVideoTrackFrozen));
+        let newState = ParticipantConnectionStatus.INACTIVE;
+
+        if (isConnActiveByJvb) {
+            if (isInLastN) {
+                if (isVideoTrackFrozen) {
+                    newState = this._isRestoringTimedout(id)
+                        ? ParticipantConnectionStatus.INTERRUPTED
+                            : ParticipantConnectionStatus.RESTORING;
+                } else {
+                    newState = ParticipantConnectionStatus.ACTIVE;
+                }
+            }
+        } else {
+            // when there is a connection problem signaled from jvb
+            // it means no media was flowing for at least 15secs, so everything
+            // should be interrupted, when in p2p mode we will never end up here
+            newState = ParticipantConnectionStatus.INTERRUPTED;
+        }
+
+        // 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, is video muted: ${isVideoMuted
+            `Figure out conn status for ${id}, is video muted: ${isVideoMuted
                  } is active(jvb): ${isConnActiveByJvb
                  } video track frozen: ${isVideoTrackFrozen
                  } is in last N: ${isInLastN
-                 } => ${isConnectionActive}`);
+                 } currentStatus => newStatus: 
+                    ${participant.getConnectionStatus()} => ${newState}`);
+
+        this._changeConnectionStatus(participant, newState);
+    }
+
+    /**
+     * On change in Last N set check all leaving and entering participants to
+     * change their corresponding statuses.
+     *
+     * @param {Array<string>} leavingLastN array of ids leaving lastN.
+     * @param {Array<string>} enteringLastN array of ids entering lastN.
+     * @private
+     */
+    _onLastNChanged(leavingLastN = [], enteringLastN = []) {
+        for (const id of leavingLastN) {
+            this.enteredLastNTimestamp.delete(id);
+            this._clearRestoringTimer(id);
+            this.figureOutConnectionStatus(id);
+        }
+        for (const id of enteringLastN) {
+            // store the timestamp this id is entering lastN
+            this.enteredLastNTimestamp.set(id, Date.now());
+
+            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));
+        }
 
-        this._changeConnectionStatus(participant, isConnectionActive);
+        return false;
     }
 
     /**