feat: add PARTICIPANT_CONN_STATUS_CHANGED conference event

The event is triggered when the notification about the user's connection
status change arrives from the JVB.

JitsiConference.js

 var JitsiConferenceEventManager = require("./JitsiConferenceEventManager");
 var VideoType = require('./service/RTC/VideoType');
 var Transcriber = require("./modules/transcription/transcriber");
+var ParticipantConnectionStatus
+    = require("./modules/connectivity/ParticipantConnectionStatus");
 
 /**
  * Creates a JitsiConference object with the given name and properties.
         this.eventManager.setupRTCListeners();
     }
 
+    this.participantConnectionStatus
+        = new ParticipantConnectionStatus(this.rtc, this);
+
     if(!this.statistics) {
         this.statistics = new Statistics(this.xmpp, {
             callStatsID: this.options.config.callStatsID,

JitsiConferenceEvents.js

  * New text message was received.
  */
 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).
+ * The current status value can be obtained by calling
+ * JitsiParticipant.isConnectionActive().
+ */
+export const PARTICIPANT_CONN_STATUS_CHANGED
+    = "conference.participant_conn_status_changed";
 /**
  * Indicates that a the value of a specific property of a specific participant
  * has changed.

JitsiParticipant.js

             video: undefined
         };
         this._hidden = hidden;
+        this._isConnectionActive = true;
         this._properties = {};
     }
 
         return this._properties[name];
     }
 
+    /**
+     * 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.
+     * @private
+     */
+    _setIsConnectionActive(isActive) {
+        this._isConnectionActive = isActive;
+    }
+
+    /**
+     * Checks participant's connectivity status.
+     *
+     * @returns {boolean} true if the connection is currently ok or false when
+     * the user is having connectivity issues.
+     */
+    isConnectionActive() {
+        return this._isConnectionActive;
+    }
+
     /**
      * Sets the value of a property of this participant, and fires an event if
      * the value has changed.

modules/RTC/DataChannels.js

                     RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
                     obj.msgPayload);
             }
+            else if ("EndpointConnectivityStatusChangeEvent" === colibriClass) {
+                var endpoint = obj.endpoint;
+                var isActive = obj.active === "true";
+                logger.info("Endpoint connection status changed: " + endpoint
+                           + " active ? " + isActive);
+                self.eventEmitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
+                    endpoint, isActive);
+            }
             else {
                 logger.debug("Data channel JSON-formatted message: ", obj);
                 // The received message appears to be appropriately formatted

modules/connectivity/ParticipantConnectionStatus.js

+/* global __filename, module, require */
+var logger = require("jitsi-meet-logger").getLogger(__filename);
+var RTCEvents = require("../../service/RTC/RTCEvents");
+import * as JitsiConferenceEvents from "../../JitsiConferenceEvents";
+
+/**
+ * Class is responsible for emitting
+ * JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED events.
+ *
+ * @constructor
+ * @param rtc {RTC} the RTC service instance
+ * @param conference {JitsiConference} parent conference instance
+ */
+function ParticipantConnectionStatus(rtc, conference) {
+    this.rtc = rtc;
+    this.conference = conference;
+    rtc.addListener(
+        RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
+        this.onEndpointConnStatusChanged.bind(this));
+}
+
+/**
+ * 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 status {boolean} true if the connection is OK or false otherwise
+ */
+ParticipantConnectionStatus.prototype.onEndpointConnStatusChanged
+= function(endpointId, status) {
+    logger.debug(
+        'Detector RTCEvents.ENDPOINT_CONN_STATUS_CHANGED(' + Date.now() +'): '
+            + endpointId +": " + status);
+    // Filter out events for the local JID for now
+    if (endpointId !== this.conference.myUserId()) {
+        this._changeConnectionStatus(endpointId, status);
+    }
+};
+
+ParticipantConnectionStatus.prototype._changeConnectionStatus
+= function (endpointId, newStatus) {
+    var participant = this.conference.getParticipantById(endpointId);
+    if (!participant) {
+        // This will happen when participant exits the conference with broken
+        // ICE connection and we join after that. The bridge keeps sending
+        // that notification until the conference does not expire.
+        logger.warn(
+            'Missed participant connection status update - ' +
+                'no participant for endpoint: ' + endpointId);
+        return;
+    }
+    if (participant.isConnectionActive() !== newStatus) {
+        participant._setIsConnectionActive(newStatus);
+        logger.debug(
+            'Emit endpoint conn status(' + Date.now() + '): ',
+            endpointId, newStatus);
+        this.conference.eventEmitter.emit(
+            JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
+            endpointId, newStatus);
+    }
+};
+
+module.exports = ParticipantConnectionStatus;

service/RTC/RTCEvents.js

 var RTCEvents = {
     RTC_READY: "rtc.ready",
     DATA_CHANNEL_OPEN: "rtc.data_channel_open",
+    ENDPOINT_CONN_STATUS_CHANGED: "rtc.endpoint_conn_status_changed",
     LASTN_CHANGED: "rtc.lastn_changed",
     DOMINANTSPEAKER_CHANGED: "rtc.dominantspeaker_changed",
     LASTN_ENDPOINT_CHANGED: "rtc.lastn_endpoint_changed",