ref(ParticipantConnectionStatus): use ES6 class syntax

JitsiConference.js

 var JitsiConferenceEventManager = require("./JitsiConferenceEventManager");
 var VideoType = require('./service/RTC/VideoType');
 var Transcriber = require("./modules/transcription/transcriber");
-var ParticipantConnectionStatus
-    = require("./modules/connectivity/ParticipantConnectionStatus");
+import ParticipantConnectionStatus
+    from "./modules/connectivity/ParticipantConnectionStatus";
 import TalkMutedDetection from "./modules/TalkMutedDetection";
 
 /**

modules/connectivity/ParticipantConnectionStatus.js

 /**
  * Class is responsible for emitting
  * JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED events.
+ */
+export default class ParticipantConnectionStatus {
+
+/**
+ * Creates new instance of <tt>ParticipantConnectionStatus</tt>.
  *
  * @constructor
  * @param {RTC} rtc the RTC service instance
  * @param {number} rtcMuteTimeout (optional) custom value for
  * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
  */
-function ParticipantConnectionStatus(rtc, conference, rtcMuteTimeout) {
+constructor(rtc, conference, rtcMuteTimeout) {
     this.rtc = rtc;
     this.conference = conference;
     /**
  * Initializes <tt>ParticipantConnectionStatus</tt> and bind required event
  * listeners.
  */
-ParticipantConnectionStatus.prototype.init = function() {
+init() {
 
     this._onEndpointConnStatusChanged
         = this.onEndpointConnStatusChanged.bind(this);
         // signalling mute/unmute events.
         this._onSignallingMuteChanged = this.onSignallingMuteChanged.bind(this);
     }
-};
+}
 
 /**
  * Removes all event listeners and disposes of all resources held by this
  * instance.
  */
-ParticipantConnectionStatus.prototype.dispose = function () {
+dispose() {
 
     this.rtc.removeListener(
         RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
     Object.keys(this.trackTimers).forEach(function (participantId) {
         this.clearTimeout(participantId);
     }.bind(this));
-};
+}
 
 /**
  * Handles RTCEvents.ENDPOINT_CONN_STATUS_CHANGED triggered when we receive
  * @param endpointId {string} the endpoint ID(MUC nickname/resource JID)
  * @param isActive {boolean} true if the connection is OK or false otherwise
  */
-ParticipantConnectionStatus.prototype.onEndpointConnStatusChanged
-= function(endpointId, isActive) {
+onEndpointConnStatusChanged(endpointId, isActive) {
 
     logger.debug(
         'Detector RTCEvents.ENDPOINT_CONN_STATUS_CHANGED('
             this._changeConnectionStatus(endpointId, isActive);
         }
     }
-};
+}
 
-ParticipantConnectionStatus.prototype._changeConnectionStatus
-= function (endpointId, newStatus) {
+_changeConnectionStatus(endpointId, newStatus) {
     var participant = this.conference.getParticipantById(endpointId);
     if (!participant) {
         // This will happen when participant exits the conference with broken
             JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
             endpointId, newStatus);
     }
-};
+}
 
 /**
  * Reset the postponed "connection interrupted" event which was previously
  * @param participantId the participant for which the "connection interrupted"
  * timeout was scheduled
  */
-ParticipantConnectionStatus.prototype.clearTimeout = function (participantId) {
+clearTimeout(participantId) {
     if (this.trackTimers[participantId]) {
         window.clearTimeout(this.trackTimers[participantId]);
         this.trackTimers[participantId] = null;
     }
-};
+}
 
 /**
  * Bind signalling mute event listeners for video {JitsiRemoteTrack} when
  * @param {JitsiTrack} remoteTrack the {JitsiTrack} which is being added to
  * the conference.
  */
-ParticipantConnectionStatus.prototype.onRemoteTrackAdded
-= function(remoteTrack) {
+onRemoteTrackAdded(remoteTrack) {
     if (!remoteTrack.isLocal() && remoteTrack.getType() === MediaType.VIDEO) {
 
         logger.debug(
             JitsiTrackEvents.TRACK_MUTE_CHANGED,
             this._onSignallingMuteChanged);
     }
-};
+}
 
 /**
  * Removes all event listeners bound to the remote video track and clears any
  * @param {JitsiRemoteTrack} remoteTrack the remote track which is being removed
  * from the conference.
  */
-ParticipantConnectionStatus.prototype.onRemoteTrackRemoved
-= function(remoteTrack) {
+onRemoteTrackRemoved(remoteTrack) {
     if (!remoteTrack.isLocal() && remoteTrack.getType() === MediaType.VIDEO) {
         logger.debug(
             'Detector on remote track removed: ',
             this._onSignallingMuteChanged);
         this.clearTimeout(remoteTrack.getParticipantId());
     }
-};
+}
 
 /**
  * Handles RTC 'onmute' event for the video track.
  * @param {JitsiRemoteTrack} track the video track for which 'onmute' event will
  * be processed.
  */
-ParticipantConnectionStatus.prototype.onTrackRtcMuted = function(track) {
+onTrackRtcMuted(track) {
     var participantId = track.getParticipantId();
     var participant = this.conference.getParticipantById(participantId);
     logger.debug('Detector track RTC muted: ', participantId);
             this.clearTimeout(participantId);
         }.bind(this), this.rtcMuteTimeout);
     }
-};
+}
 
 /**
  * Handles RTC 'onunmute' event for the video track.
  * @param {JitsiRemoteTrack} track the video track for which 'onunmute' event
  * will be processed.
  */
-ParticipantConnectionStatus.prototype.onTrackRtcUnmuted = function(track) {
+onTrackRtcUnmuted(track) {
     logger.debug('Detector track RTC unmuted: ', track);
     var participantId = track.getParticipantId();
     if (!track.isMuted() &&
         this._changeConnectionStatus(participantId, true);
     }
     this.clearTimeout(participantId);
-};
+}
 
 /**
  * Here the signalling "mute"/"unmute" events are processed.
  * @param {JitsiRemoteTrack} track the remote video track for which
  * the signalling mute/unmute event will be processed.
  */
-ParticipantConnectionStatus.prototype.onSignallingMuteChanged
-= function (track) {
+onSignallingMuteChanged (track) {
     logger.debug(
         'Detector on track signalling mute changed: ', track, track.isMuted());
     var isMuted = track.isMuted();
             'Signalling got in sync - cancelling task for: ' + participantId);
         this.clearTimeout(participantId);
     }
-};
+}
 
-module.exports = ParticipantConnectionStatus;
+}