Merge branch 'master' of https://github.com/jitsi/lib-jitsi-meet into callstats-confid

Conflicts:
	JitsiConference.js
	modules/statistics/CallStats.js

.eslintignore

+# The build artifacts of the lib-jiti-meet project.
+lib-jitsi-meet.js
+lib-jitsi-meet.js.map
+lib-jitsi-meet.min.js
+lib-jitsi-meet.min.map
+
+# Third-party source code which we (1) do not want to modify or (2) try to
+# modify as little as possible.
+libs/*
+modules/RTC/adapter.screenshare.js
+
+# ESLint will by default ignore its own configuration file. However, there does
+# not seem to be a reason why we will want to risk being inconsistent with our
+# remaining JavaScript source code.
+!.eslintrc.js

.eslintrc.js

+module.exports = {
+    'env': {
+        'browser': true,
+        'commonjs': true,
+        'es6': true
+    },
+    'extends': 'eslint:recommended',
+    'globals': {
+        // The globals that (1) are accessed but not defined within many of our
+        // files, (2) are certainly defined, and (3) we would like to use
+        // without explicitly specifying them (using a comment) inside of our
+        // files.
+        '__filename': false
+    },
+    'parserOptions': {
+        'sourceType': 'module'
+    },
+    'rules': {
+        'new-cap': [
+            'error',
+            {
+                'capIsNew': false // Behave like JSHint's newcap.
+            }
+        ],
+        // While it is considered a best practice to avoid using methods on
+        // console in JavaScript that is designed to be executed in the browser
+        // and ESLint includes the rule among its set of recommended rules, (1)
+        // the general practice is to strip such calls before pushing to
+        // production and (2) we prefer to utilize console in lib-jitsi-meet
+        // (and jitsi-meet).
+        'no-console': 'off',
+        'semi': 'error'
+    }
+};

.gitignore

 deploy-local.sh
 .remote-sync.json
 lib-jitsi-meet.*
+npm-*.log
+.sync-config.cson

.jshintrc

 {
     // Refer to http://jshint.com/docs/options/ for an exhaustive list of options
     "asi": false, // true: Tolerate Automatic Semicolon Insertion (no semicolons)
-    "expr": true, // true: Tolerate `ExpressionStatement` as Programs
-    "loopfunc": true, // true: Tolerate functions being defined in loops
+    "browser": true, // Web Browser (window, document, etc)
     "curly": false, // true: Require {} for every new block or scope
+    "esversion": 6,
     "evil": true, // true: Tolerate use of `eval` and `new Function()`
-    "white": true,
-    "undef": true, // true: Require all non-global variables to be declared (prevents global leaks)
-    "browser": true, // Web Browser (window, document, etc)
-    "node": true, // Node.js
-    "trailing": true,
+    "expr": true, // true: Tolerate `ExpressionStatement` as Programs
     "indent": 4, // {int} Number of spaces to use for indentation
-    "latedef": true, // true: Require variables/functions to be defined before being used
-    "newcap": true, // true: Require capitalization of all constructor functions e.g. `new F()`
-    "maxlen": 80, // {int} Max number of characters per line
     "latedef": false, //This option prohibits the use of a variable before it was defined
-    "laxbreak": true //Ignore line breaks around "=", "==", "&&", etc.
+    "laxbreak": true, //Ignore line breaks around "=", "==", "&&", etc.
+    "loopfunc": true, // true: Tolerate functions being defined in loops
+    "maxlen": 80, // {int} Max number of characters per line
+    "newcap": true, // true: Require capitalization of all constructor functions e.g. `new F()`
+    "node": true, // Node.js
+    "trailing": true,
+    "undef": true, // true: Require all non-global variables to be declared (prevents global leaks)
+    "white": true
 }

JitsiConferenceErrors.js

 /**
- * Enumeration with the errors for the conference.
- * @type {{string: string}}
- */
-var JitsiConferenceErrors = {
-    /**
-     * Indicates that a password is required in order to join the conference.
-     */
-    PASSWORD_REQUIRED: "conference.passwordRequired",
-    /**
-     * Indicates that client must be authenticated to create the conference.
-     */
-    AUTHENTICATION_REQUIRED: "conference.authenticationRequired",
-    /**
-     * Indicates that password cannot be set for this conference.
-     */
-    PASSWORD_NOT_SUPPORTED: "conference.passwordNotSupported",
-    /**
-     * Indicates that a connection error occurred when trying to join a
-     * conference.
-     */
-    CONNECTION_ERROR: "conference.connectionError",
-    /**
-     * Indicates that the conference setup failed.
-     */
-    SETUP_FAILED: "conference.setup_failed",
-    /**
-     * Indicates that there is no available videobridge.
-     */
-    VIDEOBRIDGE_NOT_AVAILABLE: "conference.videobridgeNotAvailable",
-    /**
-     * Indicates that reservation system returned error.
-     */
-    RESERVATION_ERROR: "conference.reservationError",
-    /**
-     * Indicates that graceful shutdown happened.
-     */
-    GRACEFUL_SHUTDOWN: "conference.gracefulShutdown",
-    /**
-     * Indicates that jingle fatal error happened.
-     */
-    JINGLE_FATAL_ERROR: "conference.jingleFatalError",
-    /**
-     * Indicates that conference has been destroyed.
-     */
-    CONFERENCE_DESTROYED: "conference.destroyed",
-    /**
-     * Indicates that chat error occurred.
-     */
-    CHAT_ERROR: "conference.chatError",
-    /**
-     * Indicates that focus error happened.
-     */
-    FOCUS_DISCONNECTED: "conference.focusDisconnected",
-    /**
-     * Indicates that focus left the conference.
-     */
-    FOCUS_LEFT: "conference.focusLeft",
-    /**
-     * Indicates that max users limit has been reached.
-     */
-    CONFERENCE_MAX_USERS: "conference.max_users"
-    /**
-     * Many more errors TBD here.
-     */
-};
+ * The errors for the conference.
+ */
 
-module.exports = JitsiConferenceErrors;
+/**
+ * Indicates that client must be authenticated to create the conference.
+ */
+export const AUTHENTICATION_REQUIRED = "conference.authenticationRequired";
+/**
+ * Indicates that chat error occurred.
+ */
+export const CHAT_ERROR = "conference.chatError";
+/**
+ * Indicates that conference has been destroyed.
+ */
+export const CONFERENCE_DESTROYED = "conference.destroyed";
+/**
+ * Indicates that max users limit has been reached.
+ */
+export const CONFERENCE_MAX_USERS = "conference.max_users";
+/**
+ * Indicates that a connection error occurred when trying to join a conference.
+ */
+export const CONNECTION_ERROR = "conference.connectionError";
+/**
+ * Indicates that a connection error is due to not allowed,
+ * occurred when trying to join a conference.
+ */
+export const NOT_ALLOWED_ERROR = "conference.connectionError.notAllowed";
+/**
+ * Indicates that focus error happened.
+ */
+export const FOCUS_DISCONNECTED = "conference.focusDisconnected";
+/**
+ * Indicates that focus left the conference.
+ */
+export const FOCUS_LEFT = "conference.focusLeft";
+/**
+ * Indicates that graceful shutdown happened.
+ */
+export const GRACEFUL_SHUTDOWN = "conference.gracefulShutdown";
+/**
+ * Indicates that the versions of the server side components are incompatible
+ * with the client side.
+ */
+export const INCOMPATIBLE_SERVER_VERSIONS
+    = "conference.incompatible_server_versions";
+/**
+ * Indicates that jingle fatal error happened.
+ */
+export const JINGLE_FATAL_ERROR = "conference.jingleFatalError";
+/**
+ * Indicates that password cannot be set for this conference.
+ */
+export const PASSWORD_NOT_SUPPORTED = "conference.passwordNotSupported";
+/**
+ * Indicates that a password is required in order to join the conference.
+ */
+export const PASSWORD_REQUIRED = "conference.passwordRequired";
+/**
+ * Indicates that reservation system returned error.
+ */
+export const RESERVATION_ERROR = "conference.reservationError";
+/**
+ * Indicates that the conference setup failed.
+ */
+export const SETUP_FAILED = "conference.setup_failed";
+/**
+ * Indicates that there is no available videobridge.
+ */
+export const VIDEOBRIDGE_NOT_AVAILABLE = "conference.videobridgeNotAvailable";

JitsiConferenceEventManager.js

+/* global Strophe */
+var logger = require("jitsi-meet-logger").getLogger(__filename);
+var EventEmitterForwarder = require("./modules/util/EventEmitterForwarder");
+var XMPPEvents = require("./service/xmpp/XMPPEvents");
+var RTCEvents = require("./service/RTC/RTCEvents");
+import * as JitsiConferenceErrors from "./JitsiConferenceErrors";
+import * as JitsiConferenceEvents from "./JitsiConferenceEvents";
+var AuthenticationEvents =
+    require("./service/authentication/AuthenticationEvents");
+var Statistics = require("./modules/statistics/statistics");
+var MediaType = require("./service/RTC/MediaType");
+
+/**
+ * Setups all event listeners related to conference
+ * @param conference {JitsiConference} the conference
+ */
+function JitsiConferenceEventManager(conference) {
+    this.conference = conference;
+
+    //Listeners related to the conference only
+    conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
+        function (track) {
+            if(!track.isLocal() || !conference.statistics)
+                return;
+            conference.statistics.sendMuteEvent(track.isMuted(),
+                track.getType());
+        });
+}
+
+/**
+ * Setups event listeners related to conference.chatRoom
+ */
+JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
+    var conference = this.conference;
+    var chatRoom = conference.room;
+    this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
+        this.conference.eventEmitter);
+
+    chatRoom.addListener(XMPPEvents.ICE_RESTARTING, function () {
+        // All data channels have to be closed, before ICE restart
+        // otherwise Chrome will not trigger "opened" event for the channel
+        // established with the new bridge
+        conference.rtc.closeAllDataChannels();
+    });
+
+    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
+        function (data) {
+            var track = conference.rtc.createRemoteTrack(data);
+            if (track) {
+                conference.onTrackAdded(track);
+            }
+        }
+    );
+    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_REMOVED,
+        function (streamId, trackId) {
+            conference.getParticipants().forEach(function(participant) {
+                var tracks = participant.getTracks();
+                for(var i = 0; i < tracks.length; i++) {
+                    if(tracks[i]
+                        && tracks[i].getStreamId() == streamId
+                        && tracks[i].getTrackId() == trackId) {
+                        var track = participant._tracks.splice(i, 1)[0];
+
+                        conference.rtc.removeRemoteTrack(
+                            participant.getId(), track.getType());
+
+                        conference.eventEmitter.emit(
+                            JitsiConferenceEvents.TRACK_REMOVED, track);
+
+                        if(conference.transcriber){
+                            conference.transcriber.removeTrack(track);
+                        }
+
+                        return;
+                    }
+                }
+            });
+        }
+    );
+
+    chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
+        function (value) {
+            // set isMutedByFocus when setAudioMute Promise ends
+            conference.rtc.setAudioMute(value).then(
+                function() {
+                    conference.isMutedByFocus = true;
+                },
+                function() {
+                    logger.warn(
+                        "Error while audio muting due to focus request");
+                });
+        }
+    );
+
+    this.chatRoomForwarder.forward(XMPPEvents.SUBJECT_CHANGED,
+        JitsiConferenceEvents.SUBJECT_CHANGED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_JOINED,
+        JitsiConferenceEvents.CONFERENCE_JOINED);
+    // send some analytics events
+    chatRoom.addListener(XMPPEvents.MUC_JOINED,
+        () => {
+            let key, value;
+
+            this.conference.connectionIsInterrupted = false;
+
+            for (key in chatRoom.connectionTimes){
+                value = chatRoom.connectionTimes[key];
+                Statistics.analytics.sendEvent('conference.' + key,
+                    {value: value});
+            }
+            for (key in chatRoom.xmpp.connectionTimes){
+                value = chatRoom.xmpp.connectionTimes[key];
+                Statistics.analytics.sendEvent('xmpp.' + key,
+                    {value: value});
+            }
+    });
+
+    this.chatRoomForwarder.forward(XMPPEvents.ROOM_JOIN_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.CONNECTION_ERROR);
+
+    this.chatRoomForwarder.forward(XMPPEvents.ROOM_CONNECT_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.CONNECTION_ERROR);
+    this.chatRoomForwarder.forward(XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.NOT_ALLOWED_ERROR);
+
+    this.chatRoomForwarder.forward(XMPPEvents.ROOM_MAX_USERS_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.CONFERENCE_MAX_USERS);
+
+    this.chatRoomForwarder.forward(XMPPEvents.PASSWORD_REQUIRED,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.PASSWORD_REQUIRED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.AUTHENTICATION_REQUIRED,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.AUTHENTICATION_REQUIRED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.BRIDGE_DOWN,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
+    chatRoom.addListener(XMPPEvents.BRIDGE_DOWN,
+        function (){
+            Statistics.analytics.sendEvent('conference.bridgeDown');
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.RESERVATION_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.RESERVATION_ERROR);
+
+    this.chatRoomForwarder.forward(XMPPEvents.GRACEFUL_SHUTDOWN,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
+
+    chatRoom.addListener(XMPPEvents.JINGLE_FATAL_ERROR,
+        function (session, error) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.CONFERENCE_FAILED,
+                JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
+        });
+
+    chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
+        function () {
+            chatRoom.eventEmitter.emit(
+                XMPPEvents.CONFERENCE_SETUP_FAILED,
+                new Error("ICE fail"));
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_DESTROYED,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.CONFERENCE_DESTROYED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.CHAT_ERROR_RECEIVED,
+        JitsiConferenceEvents.CONFERENCE_ERROR,
+        JitsiConferenceErrors.CHAT_ERROR);
+
+    this.chatRoomForwarder.forward(XMPPEvents.FOCUS_DISCONNECTED,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.FOCUS_DISCONNECTED);
+
+    chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
+        function () {
+            Statistics.analytics.sendEvent('conference.focusLeft');
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.CONFERENCE_FAILED,
+                JitsiConferenceErrors.FOCUS_LEFT);
+        });
+
+    var eventLogHandler = function (reason) {
+        Statistics.sendEventToAll("conference.error." + reason);
+    };
+    chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT,
+        eventLogHandler.bind(null, "sessionAcceptTimeout"));
+
+    this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
+        JitsiConferenceEvents.CONNECTION_INTERRUPTED);
+    chatRoom.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
+        () => {
+            Statistics.sendEventToAll('connection.interrupted');
+            this.conference.connectionIsInterrupted = true;
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
+        JitsiConferenceEvents.RECORDER_STATE_CHANGED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.PHONE_NUMBER_CHANGED,
+        JitsiConferenceEvents.PHONE_NUMBER_CHANGED);
+
+    this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_RESTORED,
+        JitsiConferenceEvents.CONNECTION_RESTORED);
+    chatRoom.addListener(XMPPEvents.CONNECTION_RESTORED,
+        () => {
+            Statistics.sendEventToAll('connection.restored');
+            this.conference.connectionIsInterrupted = false;
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.CONFERENCE_SETUP_FAILED,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.SETUP_FAILED);
+
+    chatRoom.setParticipantPropertyListener(function (node, from) {
+        var participant = conference.getParticipantById(from);
+        if (!participant) {
+            return;
+        }
+
+        participant.setProperty(
+            node.tagName.substring("jitsi_participant_".length),
+            node.value);
+    });
+
+    this.chatRoomForwarder.forward(XMPPEvents.KICKED,
+        JitsiConferenceEvents.KICKED);
+    chatRoom.addListener(XMPPEvents.KICKED,
+        function () {
+            conference.room = null;
+            conference.leave.bind(conference);
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_LOCK_CHANGED,
+        JitsiConferenceEvents.LOCK_STATE_CHANGED);
+
+    chatRoom.addListener(XMPPEvents.MUC_MEMBER_JOINED,
+        conference.onMemberJoined.bind(conference));
+    chatRoom.addListener(XMPPEvents.MUC_MEMBER_LEFT,
+        conference.onMemberLeft.bind(conference));
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_LEFT,
+        JitsiConferenceEvents.CONFERENCE_LEFT);
+
+    chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
+        conference.onDisplayNameChanged.bind(conference));
+
+    chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
+        conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED,
+            conference.myUserId(), role);
+
+        // log all events for the recorder operated by the moderator
+        if (conference.statistics && conference.isModerator()) {
+            conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
+                function (status, error) {
+                    var logObject = {
+                        id: "recorder_status",
+                        status: status
+                    };
+                    if (error) {
+                        logObject.error = error;
+                    }
+                    Statistics.sendLog(JSON.stringify(logObject));
+                });
+        }
+    });
+
+    chatRoom.addListener(XMPPEvents.MUC_ROLE_CHANGED,
+        conference.onUserRoleChanged.bind(conference));
+
+    chatRoom.addListener(AuthenticationEvents.IDENTITY_UPDATED,
+        function (authEnabled, authIdentity) {
+            conference.authEnabled = authEnabled;
+            conference.authIdentity = authIdentity;
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.AUTH_STATUS_CHANGED, authEnabled,
+                authIdentity);
+        });
+
+    chatRoom.addListener(XMPPEvents.MESSAGE_RECEIVED,
+        function (jid, displayName, txt, myJid, ts) {
+            var id = Strophe.getResourceFromJid(jid);
+            conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED,
+                id, txt, ts);
+        });
+
+    chatRoom.addListener(XMPPEvents.PRESENCE_STATUS,
+        function (jid, status) {
+            var id = Strophe.getResourceFromJid(jid);
+            var participant = conference.getParticipantById(id);
+            if (!participant || participant._status === status) {
+                return;
+            }
+            participant._status = status;
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.USER_STATUS_CHANGED, id, status);
+        });
+
+    conference.room.addListener(XMPPEvents.LOCAL_UFRAG_CHANGED,
+        function (ufrag) {
+            Statistics.sendLog(
+                JSON.stringify({id: "local_ufrag", value: ufrag}));
+        });
+    conference.room.addListener(XMPPEvents.REMOTE_UFRAG_CHANGED,
+        function (ufrag) {
+            Statistics.sendLog(
+                JSON.stringify({id: "remote_ufrag", value: ufrag}));
+        });
+
+    chatRoom.addPresenceListener("startmuted", function (data, from) {
+        var isModerator = false;
+        if (conference.myUserId() === from && conference.isModerator()) {
+            isModerator = true;
+        } else {
+            var participant = conference.getParticipantById(from);
+            if (participant && participant.isModerator()) {
+                isModerator = true;
+            }
+        }
+
+        if (!isModerator) {
+            return;
+        }
+
+        var startAudioMuted = data.attributes.audio === 'true';
+        var startVideoMuted = data.attributes.video === 'true';
+
+        var updated = false;
+
+        if (startAudioMuted !== conference.startMutedPolicy.audio) {
+            conference.startMutedPolicy.audio = startAudioMuted;
+            updated = true;
+        }
+
+        if (startVideoMuted !== conference.startMutedPolicy.video) {
+            conference.startMutedPolicy.video = startVideoMuted;
+            updated = true;
+        }
+
+        if (updated) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.START_MUTED_POLICY_CHANGED,
+                conference.startMutedPolicy
+            );
+        }
+    });
+
+    chatRoom.addPresenceListener("videomuted", function (values, from) {
+        conference.rtc.handleRemoteTrackMute(MediaType.VIDEO,
+            values.value == "true", from);
+    });
+
+    chatRoom.addPresenceListener("audiomuted", function (values, from) {
+        conference.rtc.handleRemoteTrackMute(MediaType.AUDIO,
+            values.value == "true", from);
+    });
+
+    chatRoom.addPresenceListener("videoType", function(data, from) {
+        conference.rtc.handleRemoteTrackVideoTypeChanged(data.value, from);
+    });
+
+    chatRoom.addPresenceListener("devices", function (data, from) {
+        var isAudioAvailable = false;
+        var isVideoAvailable = false;
+        data.children.forEach(function (config) {
+            if (config.tagName === 'audio') {
+                isAudioAvailable = config.value === 'true';
+            }
+            if (config.tagName === 'video') {
+                isVideoAvailable = config.value === 'true';
+            }
+        });
+
+        var availableDevices;
+        if (conference.myUserId() === from) {
+            availableDevices = conference.availableDevices;
+        } else {
+            var participant = conference.getParticipantById(from);
+            if (!participant) {
+                return;
+            }
+
+            availableDevices = participant._availableDevices;
+        }
+
+        var updated = false;
+
+        if (availableDevices.audio !== isAudioAvailable) {
+            updated = true;
+            availableDevices.audio = isAudioAvailable;
+        }
+
+        if (availableDevices.video !== isVideoAvailable) {
+            updated = true;
+            availableDevices.video = isVideoAvailable;
+        }
+
+        if (updated) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.AVAILABLE_DEVICES_CHANGED,
+                from, availableDevices);
+        }
+    });
+
+    if(conference.statistics) {
+        chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
+            function (pc) {
+                conference.statistics.sendIceConnectionFailedEvent(pc);
+            });
+
+        chatRoom.addListener(XMPPEvents.CREATE_OFFER_FAILED,
+            function (e, pc) {
+                conference.statistics.sendCreateOfferFailed(e, pc);
+            });
+
+        chatRoom.addListener(XMPPEvents.CREATE_ANSWER_FAILED,
+            function (e, pc) {
+                conference.statistics.sendCreateAnswerFailed(e, pc);
+            });
+
+        chatRoom.addListener(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
+            function (e, pc) {
+                conference.statistics.sendSetLocalDescFailed(e, pc);
+            });
+
+        chatRoom.addListener(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
+            function (e, pc) {
+                conference.statistics.sendSetRemoteDescFailed(e, pc);
+            });
+
+        chatRoom.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
+            function (e, pc) {
+                conference.statistics.sendAddIceCandidateFailed(e, pc);
+            });
+    }
+};
+
+/**
+ * Setups event listeners related to conference.rtc
+ */
+JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
+    var conference = this.conference;
+
+    this.rtcForwarder = new EventEmitterForwarder(conference.rtc,
+        this.conference.eventEmitter);
+
+    conference.rtc.addListener(RTCEvents.DOMINANT_SPEAKER_CHANGED,
+        function (id) {
+            if(conference.lastDominantSpeaker !== id && conference.room) {
+                conference.lastDominantSpeaker = id;
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED, id);
+            }
+            if (conference.statistics && conference.myUserId() === id) {
+                // We are the new dominant speaker.
+                conference.statistics.sendDominantSpeakerEvent();
+            }
+        });
+
+    conference.rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, function () {
+        var now = window.performance.now();
+        logger.log("(TIME) data channel opened ", now);
+        conference.room.connectionTimes["data.channel.opened"] = now;
+        Statistics.analytics.sendEvent('conference.dataChannel.open',
+            {value: now});
+    });
+
+    this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,
+        JitsiConferenceEvents.IN_LAST_N_CHANGED);
+
+    this.rtcForwarder.forward(RTCEvents.LASTN_ENDPOINT_CHANGED,
+        JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED);
+
+    conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
+        function (devices) {
+            conference.room.updateDeviceAvailability(devices);
+        });
+
+    conference.rtc.addListener(RTCEvents.ENDPOINT_MESSAGE_RECEIVED,
+        function (from, payload) {
+            const participant = conference.getParticipantById(from);
+            if (participant) {
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
+                    participant, payload);
+            } else {
+                logger.warn(
+                    "Ignored ENDPOINT_MESSAGE_RECEIVED " +
+                    "for not existing participant: " + from, payload);
+            }
+        });
+};
+
+/**
+ * Setups event listeners related to conference.xmpp
+ */
+JitsiConferenceEventManager.prototype.setupXMPPListeners = function () {
+    var conference = this.conference;
+    conference.xmpp.addListener(
+        XMPPEvents.CALL_INCOMING, conference.onIncomingCall.bind(conference));
+    conference.xmpp.addListener(
+        XMPPEvents.CALL_ENDED, conference.onCallEnded.bind(conference));
+
+    conference.xmpp.addListener(XMPPEvents.START_MUTED_FROM_FOCUS,
+        function (audioMuted, videoMuted) {
+            conference.startAudioMuted = audioMuted;
+            conference.startVideoMuted = videoMuted;
+
+            // mute existing local tracks because this is initial mute from
+            // Jicofo
+            conference.getLocalTracks().forEach(function (track) {
+                switch (track.getType()) {
+                    case MediaType.AUDIO:
+                        conference.startAudioMuted && track.mute();
+                        break;
+                    case MediaType.VIDEO:
+                        conference.startVideoMuted && track.mute();
+                        break;
+                }
+            });
+
+            conference.eventEmitter.emit(JitsiConferenceEvents.STARTED_MUTED);
+        });
+};
+
+/**
+ * Setups event listeners related to conference.statistics
+ */
+JitsiConferenceEventManager.prototype.setupStatisticsListeners = function () {
+    var conference = this.conference;
+    if(!conference.statistics)
+        return;
+
+    conference.statistics.addAudioLevelListener(function (ssrc, level) {
+        var resource = conference.rtc.getResourceBySSRC(ssrc);
+        if (!resource)
+            return;
+
+        conference.rtc.setAudioLevel(resource, level);
+    });
+    conference.statistics.addConnectionStatsListener(function (stats) {
+        var ssrc2resolution = stats.resolution;
+
+        var id2resolution = {};
+
+        // preprocess resolutions: group by user id, skip incorrect
+        // resolutions etc.
+        Object.keys(ssrc2resolution).forEach(function (ssrc) {
+            var resolution = ssrc2resolution[ssrc];
+
+            if (!resolution.width || !resolution.height ||
+                resolution.width == -1 || resolution.height == -1) {
+                return;
+            }
+
+            var id = conference.rtc.getResourceBySSRC(ssrc);
+            if (!id) {
+                return;
+            }
+
+            // ssrc to resolution map for user id
+            var idResolutions = id2resolution[id] || {};
+            idResolutions[ssrc] = resolution;
+
+            id2resolution[id] = idResolutions;
+        });
+
+        stats.resolution = id2resolution;
+
+        conference.eventEmitter.emit(
+            JitsiConferenceEvents.CONNECTION_STATS, stats);
+    });
+
+    conference.statistics.addByteSentStatsListener(function (stats) {
+        conference.getLocalTracks().forEach(function (track) {
+            var ssrc = track.getSSRC();
+            if(!track.isAudioTrack() || !ssrc || !stats.hasOwnProperty(ssrc))
+                return;
+
+            track._setByteSent(stats[ssrc]);
+        });
+    });
+};
+
+module.exports = JitsiConferenceEventManager;

JitsiConferenceEvents.js

 /**
- * Enumeration with the events for the conference.
- * @type {{string: string}}
- */
-var JitsiConferenceEvents = {
-    /**
-     * A new media track was added to the conference. The event provides the
-     * following parameters to its listeners:
-     *
-     * @param {JitsiTrack} track the added JitsiTrack
-     */
-    TRACK_ADDED: "conference.trackAdded",
-    /**
-     * The media track was removed from the conference. The event provides the
-     * following parameters to its listeners:
-     *
-     * @param {JitsiTrack} track the removed JitsiTrack
-     */
-    TRACK_REMOVED: "conference.trackRemoved",
-    /**
-     * The dominant speaker was changed.
-     */
-    DOMINANT_SPEAKER_CHANGED: "conference.dominantSpeaker",
-    /**
-     * A new user joinned the conference.
-     */
-    USER_JOINED: "conference.userJoined",
-    /**
-     * A user has left the conference.
-     */
-    USER_LEFT: "conference.userLeft",
-    /**
-     * User role changed.
-     */
-    USER_ROLE_CHANGED: "conference.roleChanged",
-    /**
-     * User status changed.
-     */
-    USER_STATUS_CHANGED: "conference.statusChanged",
-    /**
-     * New text message was received.
-     */
-    MESSAGE_RECEIVED: "conference.messageReceived",
-    /**
-     * A user has changed it display name
-     */
-    DISPLAY_NAME_CHANGED: "conference.displayNameChanged",
-    /**
-     * Indicates that subject of the conference has changed.
-     */
-    SUBJECT_CHANGED: "conference.subjectChanged",
-    /**
-     * A participant avatar has changed.
-     */
-    AVATAR_CHANGED: "conference.avatarChanged",
-    /**
-     * New local connection statistics are received.
-     */
-    CONNECTION_STATS: "conference.connectionStats",
-    /**
-     * The Last N set is changed.
-     */
-    LAST_N_ENDPOINTS_CHANGED: "conference.lastNEndpointsChanged",
-    /**
-     * You are included / excluded in somebody's last N set
-     */
-    IN_LAST_N_CHANGED: "conference.inLastNChanged",
-    /**
-     * A media track ( attached to the conference) mute status was changed.
-     */
-    TRACK_MUTE_CHANGED: "conference.trackMuteChanged",
-    /**
-     * Audio levels of a media track ( attached to the conference) was changed.
-     */
-    TRACK_AUDIO_LEVEL_CHANGED: "conference.audioLevelsChanged",
-    /**
-     * Indicates that the connection to the conference has been interrupted
-     * for some reason.
-     */
-    CONNECTION_INTERRUPTED: "conference.connectionInterrupted",
-    /**
-     * Indicates that the connection to the conference has been restored.
-     */
-    CONNECTION_RESTORED: "conference.connectionRestored",
-    /**
-     * Indicates that conference failed.
-     */
-    CONFERENCE_FAILED: "conference.failed",
-    /**
-     * Indicates that an error occured.
-     */
-    CONFERENCE_ERROR: "conference.error",
-    /**
-     * Indicates that conference has been joined. The event does NOT provide any
-     * parameters to its listeners.
-     */
-    CONFERENCE_JOINED: "conference.joined",
-    /**
-     * Indicates that conference has been left.
-     */
-    CONFERENCE_LEFT: "conference.left",
-    /**
-     * You are kicked from the conference.
-     */
-    KICKED: "conferenece.kicked",
-    /**
-     * Indicates that start muted settings changed.
-     */
-    START_MUTED_POLICY_CHANGED: "conference.start_muted_policy_changed",
-    /**
-     * Indicates that the local user has started muted.
-     */
-    STARTED_MUTED: "conference.started_muted",
-    /**
-     * Indicates that DTMF support changed.
-     */
-    DTMF_SUPPORT_CHANGED: "conference.dtmfSupportChanged",
-    /**
-     * Indicates that recording state changed.
-     */
-    RECORDER_STATE_CHANGED: "conference.recorderStateChanged",
-    /**
-     * Indicates that phone number changed.
-     */
-    PHONE_NUMBER_CHANGED: "conference.phoneNumberChanged",
-    /**
-     * Indicates that available devices changed.
-     */
-    AVAILABLE_DEVICES_CHANGED: "conference.availableDevicesChanged",
-    /**
-     * Indicates that authentication status changed.
-     */
-    AUTH_STATUS_CHANGED: "conference.auth_status_changed",
-    /**
-     * Indicates that a the value of a specific property of a specific
-     * participant has changed.
-     */
-    PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed"
-};
+ * The events for the conference.
+ */
 
-module.exports = JitsiConferenceEvents;
+/**
+ * Indicates that authentication status changed.
+ */
+export const AUTH_STATUS_CHANGED = "conference.auth_status_changed";
+/**
+ * Indicates that available devices changed.
+ */
+export const AVAILABLE_DEVICES_CHANGED = "conference.availableDevicesChanged";
+/**
+ * A participant avatar has changed.
+ */
+export const AVATAR_CHANGED = "conference.avatarChanged";
+/**
+ * Indicates that an error occured.
+ */
+export const CONFERENCE_ERROR = "conference.error";
+/**
+ * Indicates that conference failed.
+ */
+export const CONFERENCE_FAILED = "conference.failed";
+/**
+ * Indicates that conference has been joined. The event does NOT provide any
+ * parameters to its listeners.
+ */
+export const CONFERENCE_JOINED = "conference.joined";
+/**
+ * Indicates that conference has been left.
+ */
+export const CONFERENCE_LEFT = "conference.left";
+/**
+ * Indicates that the connection to the conference has been interrupted for some
+ * reason.
+ */
+export const CONNECTION_INTERRUPTED = "conference.connectionInterrupted";
+/**
+ * Indicates that the connection to the conference has been restored.
+ */
+export const CONNECTION_RESTORED = "conference.connectionRestored";
+/**
+ * New local connection statistics are received.
+ * @deprecated Use ConnectionQualityEvents.LOCAL_STATS_UPDATED instead.
+ */
+export const CONNECTION_STATS = "conference.connectionStats";
+/**
+ * A user has changed it display name
+ */
+export const DISPLAY_NAME_CHANGED = "conference.displayNameChanged";
+/**
+ * The dominant speaker was changed.
+ */
+export const DOMINANT_SPEAKER_CHANGED = "conference.dominantSpeaker";
+/**
+ * Indicates that DTMF support changed.
+ */
+export const DTMF_SUPPORT_CHANGED = "conference.dtmfSupportChanged";
+/**
+ * Indicates that a message from another participant is received on data
+ * channel.
+ */
+export const ENDPOINT_MESSAGE_RECEIVED = "conference.endpoint_message_received";
+/**
+ * You are included / excluded in somebody's last N set
+ */
+export const IN_LAST_N_CHANGED = "conference.inLastNChanged";
+/**
+ * You are kicked from the conference.
+ */
+export const KICKED = "conferenece.kicked";
+/**
+ * The Last N set is changed.
+ */
+export const LAST_N_ENDPOINTS_CHANGED = "conference.lastNEndpointsChanged";
+/**
+ * Indicates that the room has been locked or unlocked.
+ */
+export const LOCK_STATE_CHANGED = "conference.lock_state_changed";
+/**
+ * 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.
+ */
+export const PARTICIPANT_PROPERTY_CHANGED
+    = "conference.participant_property_changed";
+/**
+ * Indicates that phone number changed.
+ */
+export const PHONE_NUMBER_CHANGED = "conference.phoneNumberChanged";
+/**
+ * Indicates that recording state changed.
+ */
+export const RECORDER_STATE_CHANGED = "conference.recorderStateChanged";
+/**
+ * Indicates that start muted settings changed.
+ */
+export const START_MUTED_POLICY_CHANGED
+    = "conference.start_muted_policy_changed";
+/**
+ * Indicates that the local user has started muted.
+ */
+export const STARTED_MUTED = "conference.started_muted";
+/**
+ * Indicates that subject of the conference has changed.
+ */
+export const SUBJECT_CHANGED = "conference.subjectChanged";
+/**
+ * Event indicates that local user is talking while he muted himself
+ */
+export const TALK_WHILE_MUTED = "conference.talk_while_muted";
+/**
+ * A new media track was added to the conference. The event provides the
+ * following parameters to its listeners:
+ *
+ * @param {JitsiTrack} track the added JitsiTrack
+ */
+export const TRACK_ADDED = "conference.trackAdded";
+/**
+ * Audio levels of a media track ( attached to the conference) was changed.
+ */
+export const TRACK_AUDIO_LEVEL_CHANGED = "conference.audioLevelsChanged";
+/**
+ * A media track ( attached to the conference) mute status was changed.
+ */
+export const TRACK_MUTE_CHANGED = "conference.trackMuteChanged";
+/**
+ * The media track was removed from the conference. The event provides the
+ * following parameters to its listeners:
+ *
+ * @param {JitsiTrack} track the removed JitsiTrack
+ */
+export const TRACK_REMOVED = "conference.trackRemoved";
+/**
+ * A new user joinned the conference.
+ */
+export const USER_JOINED = "conference.userJoined";
+/**
+ * A user has left the conference.
+ */
+export const USER_LEFT = "conference.userLeft";
+/**
+ * User role changed.
+ */
+export const USER_ROLE_CHANGED = "conference.roleChanged";
+/**
+ * User status changed.
+ */
+export const USER_STATUS_CHANGED = "conference.statusChanged";

JitsiConnection.js

 var JitsiConference = require("./JitsiConference");
-var XMPP = require("./modules/xmpp/xmpp");
+import * as JitsiConnectionEvents from "./JitsiConnectionEvents";
+import XMPP from "./modules/xmpp/xmpp";
+var Statistics = require("./modules/statistics/statistics");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
     this.options = options;
     this.xmpp = new XMPP(options, token);
     this.conferences = {};
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
+        function (errType, msg) {
+            // sends analytics and callstats event
+            Statistics.sendEventToAll('connection.failed.' + errType,
+                {label: msg});
+        }.bind(this));
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+        function (msg) {
+            // we can see disconnects from normal tab closing of the browser
+            // and then there are no msgs, but we want to log only disconnects
+            // when there is real error
+            if(msg)
+                Statistics.analytics.sendEvent(
+                    'connection.disconnected.' + msg);
+            Statistics.sendLog(
+                JSON.stringify({id: "connection.disconnected", msg: msg}));
+        });
 }
 
 /**
         options = {};
 
     this.xmpp.connect(options.id, options.password);
-}
+};
 
 /**
  * Attach to existing connection. Can be used for optimizations. For example:
  */
 JitsiConnection.prototype.attach = function (options) {
     this.xmpp.attach(options);
-}
+};
 
 /**
  * Disconnect the client from the server.
     var x = this.xmpp;
 
     x.disconnect.apply(x, arguments);
-}
+};
 
 /**
  * This method allows renewal of the tokens if they are expiring.
  */
 JitsiConnection.prototype.setToken = function (token) {
     this.token = token;
-}
+};
 
 /**
  * Creates and joins new conference.
         = new JitsiConference({name: name, config: options, connection: this});
     this.conferences[name] = conference;
     return conference;
-}
+};
 
 /**
  * Subscribes the passed listener to the event.
  */
 JitsiConnection.prototype.addEventListener = function (event, listener) {
     this.xmpp.addListener(event, listener);
-}
+};
 
 /**
  * Unsubscribes the passed handler.
  */
 JitsiConnection.prototype.removeEventListener = function (event, listener) {
     this.xmpp.removeListener(event, listener);
-}
+};
 
 /**
  * Returns measured connectionTimes.

JitsiConnectionErrors.js

 /**
- * Enumeration with the errors for the connection.
- * @type {{string: string}}
+ * The errors for the connection.
  */
-var JitsiConnectionErrors = {
-    /**
-     * Indicates that a password is required in order to join the conference.
-     */
-    PASSWORD_REQUIRED: "connection.passwordRequired",
-    /**
-     * Indicates that a connection error occurred when trying to join a
-     * conference.
-     */
-    CONNECTION_ERROR: "connection.connectionError",
-    /**
-     * Not specified errors.
-     */
-    OTHER_ERROR: "connection.otherError"
-};
 
-module.exports = JitsiConnectionErrors;
+/**
+ * Indicates that a connection error occurred when trying to join a conference.
+ */
+export const CONNECTION_ERROR = "connection.connectionError";
+/**
+ * Not specified errors.
+ */
+export const OTHER_ERROR = "connection.otherError";
+/**
+ * Indicates that a password is required in order to join the conference.
+ */
+export const PASSWORD_REQUIRED = "connection.passwordRequired";

JitsiConnectionEvents.js

 /**
- * Enumeration with the events for the connection.
- * @type {{string: string}}
+ * The events for the connection.
  */
-var JitsiConnnectionEvents = {
-    /**
-     * Indicates that the connection has been failed for some reason. The event
-     * proivdes the following parameters to its listeners:
-     *
-     * @param err {string} the error (message) associated with the failure
-     */
-    CONNECTION_FAILED: "connection.connectionFailed",
-    /**
-     * Indicates that the connection has been established. The event provides
-     * the following parameters to its listeners:
-     *
-     * @param id {string} the ID of the local endpoint/participant/peer (within
-     * the context of the established connection)
-     */
-    CONNECTION_ESTABLISHED: "connection.connectionEstablished",
-    /**
-     * Indicates that the connection has been disconnected. The event provides
-     * the following parameters to its listeners:
-     *
-     * @param msg {string} a message associated with the disconnect such as the
-     * last (known) error message
-     */
-    CONNECTION_DISCONNECTED: "connection.connectionDisconnected",
-    /**
-     * Indicates that the perfomed action cannot be executed because the
-     * connection is not in the correct state(connected, disconnected, etc.)
-     */
-    WRONG_STATE: "connection.wrongState"
-};
 
-module.exports = JitsiConnnectionEvents;
+/**
+ * Indicates that the connection has been disconnected. The event provides
+ * the following parameters to its listeners:
+ *
+ * @param msg {string} a message associated with the disconnect such as the
+ * last (known) error message
+ */
+export const CONNECTION_DISCONNECTED = "connection.connectionDisconnected";
+/**
+ * Indicates that the connection has been established. The event provides
+ * the following parameters to its listeners:
+ *
+ * @param id {string} the ID of the local endpoint/participant/peer (within
+ * the context of the established connection)
+ */
+export const CONNECTION_ESTABLISHED = "connection.connectionEstablished";
+/**
+ * Indicates that the connection has been failed for some reason. The event
+ * provides the following parameters to its listeners:
+ *
+ * @param err {string} the error (message) associated with the failure
+ */
+export const CONNECTION_FAILED = "connection.connectionFailed";
+/**
+ * Indicates that the performed action cannot be executed because the
+ * connection is not in the correct state(connected, disconnected, etc.)
+ */
+export const WRONG_STATE = "connection.wrongState";

JitsiMediaDevices.js

 var RTCEvents = require('./service/RTC/RTCEvents');
 var RTC = require("./modules/RTC/RTC");
 var MediaType = require('./service/RTC/MediaType');
-var JitsiMediaDevicesEvents = require('./JitsiMediaDevicesEvents');
+import * as JitsiMediaDevicesEvents from "./JitsiMediaDevicesEvents";
 var Statistics = require("./modules/statistics/statistics");
 
 var eventEmitter = new EventEmitter();
     },
     /**
      * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
      */
     isDeviceListAvailable: function () {
         return RTC.isDeviceListAvailable();
      * Emits an event.
      * @param {string} event - event name
      */
-    emitEvent: function (event) {
+    emitEvent: function (event) { // eslint-disable-line no-unused-vars
         eventEmitter.emit.apply(eventEmitter, arguments);
     }
 };
 
-module.exports = JitsiMediaDevices;
+module.exports = JitsiMediaDevices;

JitsiMediaDevicesEvents.js

 /**
- * Enumeration with the events for the media devices.
- * @type {{string: string}}
+ * The events for the media devices.
  */
-var JitsiMediaDevicesEvents = {
-    /**
-     * Indicates that the list of available media devices has been changed. The
-     * event provides the following parameters to its listeners:
-     *
-     * @param {MediaDeviceInfo[]} devices - array of MediaDeviceInfo or
-     *  MediaDeviceInfo-like objects that are currently connected.
-     *  @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
-     */
-    DEVICE_LIST_CHANGED: "mediaDevices.devicechange",
-    /**
-     * Indicates that the environment is currently showing permission prompt to
-     * access camera and/or microphone. The event provides the following
-     * parameters to its listeners:
-     *
-     * @param {'chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'
-     *      |'react-native'|'android'} environmentType - type of browser or
-     *      other execution environment.
-     */
-    PERMISSION_PROMPT_IS_SHOWN: "mediaDevices.permissionPromptIsShown"
-};
 
-module.exports = JitsiMediaDevicesEvents;
+/**
+ * Indicates that the list of available media devices has been changed. The
+ * event provides the following parameters to its listeners:
+ *
+ * @param {MediaDeviceInfo[]} devices - array of MediaDeviceInfo or
+ *  MediaDeviceInfo-like objects that are currently connected.
+ *  @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
+ */
+export const DEVICE_LIST_CHANGED = "mediaDevices.devicechange";
+/**
+ * Indicates that the environment is currently showing permission prompt to
+ * access camera and/or microphone. The event provides the following
+ * parameters to its listeners:
+ *
+ * @param {'chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'
+ *  |'react-native'|'android'} environmentType - type of browser or
+ *  other execution environment.
+ */
+export const PERMISSION_PROMPT_IS_SHOWN
+    = "mediaDevices.permissionPromptIsShown";

JitsiMeetJS.js

 var AuthUtil = require("./modules/util/AuthUtil");
 var JitsiConnection = require("./JitsiConnection");
 var JitsiMediaDevices = require("./JitsiMediaDevices");
-var JitsiConferenceEvents = require("./JitsiConferenceEvents");
-var JitsiConnectionEvents = require("./JitsiConnectionEvents");
-var JitsiMediaDevicesEvents = require('./JitsiMediaDevicesEvents');
-var JitsiConnectionErrors = require("./JitsiConnectionErrors");
-var JitsiConferenceErrors = require("./JitsiConferenceErrors");
-var JitsiTrackEvents = require("./JitsiTrackEvents");
-var JitsiTrackErrors = require("./JitsiTrackErrors");
-var JitsiTrackError = require("./JitsiTrackError");
+import * as JitsiConferenceErrors from "./JitsiConferenceErrors";
+import * as JitsiConferenceEvents from "./JitsiConferenceEvents";
+import * as JitsiConnectionErrors from "./JitsiConnectionErrors";
+import * as JitsiConnectionEvents from "./JitsiConnectionEvents";
+import * as JitsiMediaDevicesEvents from "./JitsiMediaDevicesEvents";
+import * as ConnectionQualityEvents from "./service/connectivity/ConnectionQualityEvents";
+import JitsiTrackError from "./JitsiTrackError";
+import * as JitsiTrackErrors from "./JitsiTrackErrors";
+import * as JitsiTrackEvents from "./JitsiTrackEvents";
 var JitsiRecorderErrors = require("./JitsiRecorderErrors");
 var Logger = require("jitsi-meet-logger");
 var MediaType = require("./service/RTC/MediaType");
     var order = Resolutions[resolution].order;
     var res = null;
     var resName = null;
-    for(var i in Resolutions) {
+    for(let i in Resolutions) {
         var tmp = Resolutions[i];
         if (!res || (res.order < tmp.order && tmp.order < order)) {
             resName = i;
     return resName;
 }
 
+/**
+ * Checks the available devices in options and concatenate the data to the
+ * name, which will be used as analytics event name. Adds resolution for the
+ * devices.
+ * @param name name of event
+ * @param options gum options
+ * @returns {*}
+ */
+function addDeviceTypeToAnalyticsEvent(name, options) {
+    if (options.devices.indexOf("audio") !== -1) {
+        name += ".audio";
+    }
+    if (options.devices.indexOf("desktop") !== -1) {
+        name += ".desktop";
+    }
+    if (options.devices.indexOf("video") !== -1) {
+        // we have video add resolution
+        name += ".video." + options.resolution;
+    }
+
+    return name;
+}
+
 /**
  * Namespace for the interface of Jitsi Meet Library.
  */
         conference: JitsiConferenceEvents,
         connection: JitsiConnectionEvents,
         track: JitsiTrackEvents,
-        mediaDevices: JitsiMediaDevicesEvents
+        mediaDevices: JitsiMediaDevicesEvents,
+        connectionQuality: ConnectionQualityEvents
     },
     errors: {
         conference: JitsiConferenceErrors,
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
+    analytics: null,
     init: function (options) {
-        Statistics.audioLevelsEnabled = !options.disableAudioLevels;
-
-        if(typeof options.audioLevelsInterval === 'number') {
-            Statistics.audioLevelsInterval = options.audioLevelsInterval;
-        }
+        let logObject, attr;
+        Statistics.init(options);
+        this.analytics = Statistics.analytics;
 
         if (options.enableWindowOnErrorHandler) {
             GlobalOnErrorHandler.addHandler(
                 this.getGlobalOnErrorHandler.bind(this));
         }
 
-        // Lets send some general stats useful for debugging problems
+        // Log deployment-specific information, if available.
         if (window.jitsiRegionInfo
             && Object.keys(window.jitsiRegionInfo).length > 0) {
-            // remove quotes to make it prettier
-            Statistics.sendLog(
-                JSON.stringify(window.jitsiRegionInfo).replace(/\"/g, ""));
+            logObject = {};
+            for (attr in window.jitsiRegionInfo) {
+                if (window.jitsiRegionInfo.hasOwnProperty(attr)) {
+                    logObject[attr] = window.jitsiRegionInfo[attr];
+                }
+            }
+
+            logObject.id = "deployment_info";
+            Statistics.sendLog(JSON.stringify(logObject));
         }
 
-        if(this.version)
-            Statistics.sendLog("LibJitsiMeet:" + this.version);
+        if(this.version) {
+            logObject = {
+                id: "component_version",
+                component: "lib-jitsi-meet",
+                version: this.version
+            };
+            Statistics.sendLog(JSON.stringify(logObject));
+        }
 
         return RTC.init(options || {});
     },
      * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
+     * @param {object} options.desktopSharingExtensionExternalInstallation -
+     * enables external installation process for desktop sharing extension if
+     * the inline installation is not posible. The following properties should
+     * be provided:
+     * @param {intiger} interval - the interval (in ms) for
+     * checking whether the desktop sharing extension is installed or not
+     * @param {Function} checkAgain - returns boolean. While checkAgain()==true
+     * createLocalTracks will wait and check on every "interval" ms for the
+     * extension. If the desktop extension is not install and checkAgain()==true
+     * createLocalTracks will finish with rejected Promise.
+     * @param {Function} listener - The listener will be called to notify the
+     * user of lib-jitsi-meet that createLocalTracks is starting external
+     * extension installation process.
+     * NOTE: If the inline installation process is not possible and external
+     * installation is enabled the listener property will be called to notify
+     * the start of external installation process. After that createLocalTracks
+     * will start to check for the extension on every interval ms until the
+     * plugin is installed or until checkAgain return false. If the extension
+     * is found createLocalTracks will try to get the desktop sharing track and
+     * will finish the execution. If checkAgain returns false, createLocalTracks
+     * will finish the execution with rejected Promise.
+     *
      * @param {boolean} (firePermissionPromptIsShownEvent) - if event
      *      JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN should be fired
      * @returns {Promise.<{Array.<JitsiTrack>}, JitsiConferenceError>}
         if (firePermissionPromptIsShownEvent === true) {
             window.setTimeout(function () {
                 if (!promiseFulfilled) {
-                    var browser = RTCBrowserType.getBrowserType()
-                        .split('rtc_browser.')[1];
-
-                    if (RTCBrowserType.isAndroid()) {
-                        browser = 'android';
-                    }
-
                     JitsiMediaDevices.emitEvent(
                         JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                        browser);
+                        RTCBrowserType.getBrowserName());
                 }
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }
 
+        if(!window.connectionTimes)
+            window.connectionTimes = {};
+        window.connectionTimes["obtainPermissions.start"] =
+            window.performance.now();
+
         return RTC.obtainAudioAndVideoPermissions(options || {})
             .then(function(tracks) {
                 promiseFulfilled = true;
 
+                window.connectionTimes["obtainPermissions.end"] =
+                    window.performance.now();
+
+                Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
+                    "getUserMedia.success", options), {value: options});
+
                 if(!RTC.options.disableAudioLevels)
-                    for(var i = 0; i < tracks.length; i++) {
-                        var track = tracks[i];
+                    for(let i = 0; i < tracks.length; i++) {
+                        const track = tracks[i];
                         var mStream = track.getOriginalStream();
                         if(track.getType() === MediaType.AUDIO){
                             Statistics.startLocalStats(mStream,
                         }
                     }
 
+                // set real device ids
+                var currentlyAvailableMediaDevices
+                    = RTC.getCurrentlyAvailableMediaDevices();
+                if (currentlyAvailableMediaDevices) {
+                    for(let i = 0; i < tracks.length; i++) {
+                        const track = tracks[i];
+                        track._setRealDeviceIdFromDeviceList(
+                            currentlyAvailableMediaDevices);
+                    }
+                }
+
                 return tracks;
             }).catch(function (error) {
                 promiseFulfilled = true;
                         logger.debug("Retry createLocalTracks with resolution",
                             newResolution);
 
+                        Statistics.analytics.sendEvent(
+                            "getUserMedia.fail.resolution." + oldResolution);
+
                         return LibJitsiMeet.createLocalTracks(options);
                     }
                 }
                     // User cancelled action is not really an error, so only
                     // log it as an event to avoid having conference classified
                     // as partially failed
-                    Statistics.sendLog(error.message);
+                    const logObject = {
+                        id: "chrome_extension_user_canceled",
+                        message: error.message
+                    };
+                    Statistics.sendLog(JSON.stringify(logObject));
+                    Statistics.analytics.sendEvent(
+                        "getUserMedia.userCancel.extensionInstall");
+                } else if (JitsiTrackErrors.NOT_FOUND === error.name) {
+                    // logs not found devices with just application log to cs
+                    const logObject = {
+                        id: "usermedia_missing_device",
+                        status: error.gum.devices
+                    };
+                    Statistics.sendLog(JSON.stringify(logObject));
+                    Statistics.analytics.sendEvent(
+                        "getUserMedia.deviceNotFound."
+                            + error.gum.devices.join('.'));
                 } else {
                     // Report gUM failed to the stats
                     Statistics.sendGetUserMediaFailed(error);
+                    Statistics.analytics.sendEvent(
+                        addDeviceTypeToAnalyticsEvent(
+                            "getUserMedia.failed", options) + '.' + error.name,
+                        {value: options});
                 }
 
+                window.connectionTimes["obtainPermissions.end"] =
+                    window.performance.now();
+
                 return Promise.reject(error);
             }.bind(this));
     },
     /**
      * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
      * @deprecated use JitsiMeetJS.mediaDevices.isDeviceListAvailable instead
      */
     isDeviceListAvailable: function () {
     }
 };
 
-//Setups the promise object.
-window.Promise = window.Promise || require("es6-promise").Promise;
-
 module.exports = LibJitsiMeet;

JitsiParticipant.js

 /* global Strophe */
-var JitsiConferenceEvents = require('./JitsiConferenceEvents');
+import * as JitsiConferenceEvents from "./JitsiConferenceEvents";
+import * as MediaType from "./service/RTC/MediaType";
 
 /**
- * Represents a participant in (a member of) a conference.
- * @param jid the conference XMPP jid
- * @param conference
- * @param displayName
- * @param isHidden indicates if this participant is a hidden participant
+ * Represents a participant in (i.e. a member of) a conference.
  */
-function JitsiParticipant(jid, conference, displayName, isHidden){
-    this._jid = jid;
-    this._id = Strophe.getResourceFromJid(jid);
-    this._conference = conference;
-    this._displayName = displayName;
-    this._supportsDTMF = false;
-    this._tracks = [];
-    this._role = 'none';
-    this._status = null;
-    this._availableDevices = {
-        audio: undefined,
-        video: undefined
-    };
-    this._isHidden = isHidden;
-    this._properties = {};
-}
-
-/**
- * @returns {JitsiConference} The conference that this participant belongs to.
- */
-JitsiParticipant.prototype.getConference = function() {
-    return this._conference;
-};
-
-/**
- * Gets the value of a property of this participant.
- */
-JitsiParticipant.prototype.getProperty = function(name) {
-    return this._properties[name];
-};
-
-/**
- * Sets the value of a property of this participant, and fires an event if the
- * value has changed.
- * @name the name of the property.
- * @value the value to set.
- */
-JitsiParticipant.prototype.setProperty = function(name, value) {
-    var oldValue = this._properties[name];
-    this._properties[name] = value;
-
-    if (value !== oldValue) {
-        this._conference.eventEmitter.emit(
-            JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED,
-            this,
-            name,
-            oldValue,
-            value);
+export default class JitsiParticipant {
+    /**
+     * Initializes a new JitsiParticipant instance.
+     *
+     * @constructor
+     * @param jid the conference XMPP jid
+     * @param conference
+     * @param displayName
+     * @param {Boolean} hidden - True if the new JitsiParticipant instance is to
+     * represent a hidden participant; otherwise, false.
+     */
+    constructor(jid, conference, displayName, hidden) {
+        this._jid = jid;
+        this._id = Strophe.getResourceFromJid(jid);
+        this._conference = conference;
+        this._displayName = displayName;
+        this._supportsDTMF = false;
+        this._tracks = [];
+        this._role = 'none';
+        this._status = null;
+        this._availableDevices = {
+            audio: undefined,
+            video: undefined
+        };
+        this._hidden = hidden;
+        this._isConnectionActive = true;
+        this._properties = {};
     }
-};
-
-/**
- * @returns {Array.<JitsiTrack>} The list of media tracks for this participant.
- */
-JitsiParticipant.prototype.getTracks = function() {
-    return this._tracks.slice();
-};
 
-/**
- * @returns {String} The ID of this participant.
- */
-JitsiParticipant.prototype.getId = function() {
-    return this._id;
-};
-
-/**
- * @returns {String} The JID of this participant.
- */
-JitsiParticipant.prototype.getJid = function() {
-    return this._jid;
-};
+    /**
+     * @returns {JitsiConference} The conference that this participant belongs
+     * to.
+     */
+    getConference() {
+        return this._conference;
+    }
 
-/**
- * @returns {String} The human-readable display name of this participant.
- */
-JitsiParticipant.prototype.getDisplayName = function() {
-    return this._displayName;
-};
+    /**
+     * Gets the value of a property of this participant.
+     */
+    getProperty(name) {
+        return this._properties[name];
+    }
 
-/**
- * @returns {String} The status of the participant.
- */
-JitsiParticipant.prototype.getStatus = function () {
-    return this._status;
-};
+    /**
+     * Checks whether this <tt>JitsiParticipant</tt> has any video tracks which
+     * are muted according to their underlying WebRTC <tt>MediaStreamTrack</tt>
+     * muted status.
+     * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains any
+     * video <tt>JitsiTrack</tt>s which are muted as defined in
+     * {@link JitsiTrack.isWebRTCTrackMuted}.
+     */
+    hasAnyVideoTrackWebRTCMuted() {
+        return this.getTracks().some(function(jitsiTrack) {
+            return jitsiTrack.getType() === MediaType.VIDEO
+                && jitsiTrack.isWebRTCTrackMuted();
+        });
+    }
 
-/**
- * @returns {Boolean} Whether this participant is a moderator or not.
- */
-JitsiParticipant.prototype.isModerator = function() {
-    return this._role === 'moderator';
-};
+    /**
+     * 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;
+    }
 
-/**
- * @returns {Boolean} Whether this participant is a hidden participant. Some
- * special system participants may want to join hidden (like for example the
- * recorder).
- */
-JitsiParticipant.prototype.isHidden = function() {
-    return this._isHidden;
-};
+    /**
+     * 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;
+    }
 
-// Gets a link to an etherpad instance advertised by the participant?
-//JitsiParticipant.prototype.getEtherpad = function() {
-//
-//}
+    /**
+     * Sets the value of a property of this participant, and fires an event if
+     * the value has changed.
+     * @name the name of the property.
+     * @value the value to set.
+     */
+    setProperty(name, value) {
+        var oldValue = this._properties[name];
+
+        if (value !== oldValue) {
+            this._properties[name] = value;
+            this._conference.eventEmitter.emit(
+                JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED,
+                this,
+                name,
+                oldValue,
+                value);
+        }
+    }
 
+    /**
+     * @returns {Array.<JitsiTrack>} The list of media tracks for this
+     * participant.
+     */
+    getTracks() {
+        return this._tracks.slice();
+    }
 
-/*
- * @returns {Boolean} Whether this participant has muted their audio.
- */
-JitsiParticipant.prototype.isAudioMuted = function() {
-    return this.getTracks().reduce(function (track, isAudioMuted) {
-        return isAudioMuted && (track.isVideoTrack() || track.isMuted());
-    }, true);
-};
-
-/*
- * @returns {Boolean} Whether this participant has muted their video.
- */
-JitsiParticipant.prototype.isVideoMuted = function() {
-    return this.getTracks().reduce(function (track, isVideoMuted) {
-        return isVideoMuted && (track.isAudioTrack() || track.isMuted());
-    }, true);
-};
-
-/*
- * @returns {???} The latest statistics reported by this participant
- * (i.e. info used to populate the GSM bars)
- * TODO: do we expose this or handle it internally?
- */
-JitsiParticipant.prototype.getLatestStats = function() {
+    /**
+     * @returns {String} The ID of this participant.
+     */
+    getId() {
+        return this._id;
+    }
 
-};
+    /**
+     * @returns {String} The JID of this participant.
+     */
+    getJid() {
+        return this._jid;
+    }
 
-/**
- * @returns {String} The role of this participant.
- */
-JitsiParticipant.prototype.getRole = function() {
-    return this._role;
-};
+    /**
+     * @returns {String} The human-readable display name of this participant.
+     */
+    getDisplayName() {
+        return this._displayName;
+    }
 
-/*
- * @returns {Boolean} Whether this participant is
- * the conference focus (i.e. jicofo).
- */
-JitsiParticipant.prototype.isFocus = function() {
+    /**
+     * @returns {String} The status of the participant.
+     */
+    getStatus () {
+        return this._status;
+    }
 
-};
+    /**
+     * @returns {Boolean} Whether this participant is a moderator or not.
+     */
+    isModerator() {
+        return this._role === 'moderator';
+    }
 
-/*
- * @returns {Boolean} Whether this participant is
- * a conference recorder (i.e. jirecon).
- */
-JitsiParticipant.prototype.isRecorder = function() {
+    /**
+     * @returns {Boolean} Whether this participant is a hidden participant. Some
+     * special system participants may want to join hidden (like for example the
+     * recorder).
+     */
+    isHidden() {
+        return this._hidden;
+    }
 
-};
+    // Gets a link to an etherpad instance advertised by the participant?
+    //getEtherpad() {
+    //}
 
-/*
- * @returns {Boolean} Whether this participant is a SIP gateway (i.e. jigasi).
- */
-JitsiParticipant.prototype.isSipGateway = function() {
+    /**
+     * @returns {Boolean} Whether this participant has muted their audio.
+     */
+    isAudioMuted() {
+        return this._isMediaTypeMuted(MediaType.AUDIO);
+    }
 
-};
+    /**
+     * Determines whether all JitsiTracks which are of a specific MediaType and
+     * which belong to this JitsiParticipant are muted.
+     *
+     * @param {MediaType} mediaType - The MediaType of the JitsiTracks to be
+     * checked.
+     * @private
+     * @returns {Boolean} True if all JitsiTracks which are of the specified
+     * mediaType and which belong to this JitsiParticipant are muted; otherwise,
+     * false.
+     */
+    _isMediaTypeMuted(mediaType) {
+        return this.getTracks().reduce(
+            (muted, track) =>
+                muted && (track.getType() !== mediaType || track.isMuted()),
+            true);
+    }
 
-/**
- * @returns {Boolean} Whether this participant
- * is currently sharing their screen.
- */
-JitsiParticipant.prototype.isScreenSharing = function() {
+    /**
+     * @returns {Boolean} Whether this participant has muted their video.
+     */
+    isVideoMuted() {
+        return this._isMediaTypeMuted(MediaType.VIDEO);
+    }
 
-};
+    /**
+     * @returns {???} The latest statistics reported by this participant (i.e.
+     * info used to populate the GSM bars)
+     * TODO: do we expose this or handle it internally?
+     */
+    getLatestStats() {
+    }
 
-/**
- * @returns {String} The user agent of this participant
- * (i.e. browser userAgent string).
- */
-JitsiParticipant.prototype.getUserAgent = function() {
+    /**
+     * @returns {String} The role of this participant.
+     */
+    getRole() {
+        return this._role;
+    }
 
-};
+    /**
+     * @returns {Boolean} Whether this participant is the conference focus (i.e.
+     * jicofo).
+     */
+    isFocus() {
+    }
 
-/**
- * Kicks the participant from the conference (requires certain privileges).
- */
-JitsiParticipant.prototype.kick = function() {
+    /**
+     * @returns {Boolean} Whether this participant is a conference recorder
+     * (i.e. jirecon).
+     */
+    isRecorder() {
+    }
 
-};
+    /**
+     * @returns {Boolean} Whether this participant is a SIP gateway (i.e.
+     * jigasi).
+     */
+    isSipGateway() {
+    }
 
-/**
- * Asks this participant to mute themselves.
- */
-JitsiParticipant.prototype.askToMute = function() {
+    /**
+     * @returns {Boolean} Whether this participant is currently sharing their
+     * screen.
+     */
+    isScreenSharing() {
+    }
 
-};
+    /**
+     * @returns {String} The user agent of this participant (i.e. browser
+     * userAgent string).
+     */
+    getUserAgent() {
+    }
 
-JitsiParticipant.prototype.supportsDTMF = function () {
-    return this._supportsDTMF;
-};
+    /**
+     * Kicks the participant from the conference (requires certain privileges).
+     */
+    kick() {
+    }
 
+    /**
+     * Asks this participant to mute themselves.
+     */
+    askToMute() {
+    }
 
-module.exports = JitsiParticipant;
+    supportsDTMF() {
+        return this._supportsDTMF;
+    }
+}

JitsiTrackError.js

-var JitsiTrackErrors = require("./JitsiTrackErrors");
+import * as JitsiTrackErrors from "./JitsiTrackErrors";
 
-var TRACK_ERROR_TO_MESSAGE_MAP = {};
+const TRACK_ERROR_TO_MESSAGE_MAP = {};
 
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.UNSUPPORTED_RESOLUTION]
     = "Video resolution is not supported: ";
     = "Constraint could not be satisfied: ";
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_IS_DISPOSED]
     = "Track has been already disposed";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_NO_STREAM_FOUND]
+    = "Track does not have an associated Media Stream";
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS]
     = "Track mute/unmute process is currently in progress";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.NO_DATA_FROM_SOURCE]
+    = "The track has stopped receiving data from it's source";
 
 /**
- * Object representing error that happened to a JitsiTrack. Can represent
- * various types of errors. For error descriptions (@see JitsiTrackErrors).
- * @constructor
+ * Represents an error that occurred to a JitsiTrack. Can represent various
+ * types of errors. For error descriptions (@see JitsiTrackErrors).
+ *
  * @extends Error
- * @param {Object|string} error - error object or error name
- * @param {Object|string} (options) - getUserMedia constraints object or error
- *      message
- * @param {('audio'|'video'|'desktop'|'screen'|'audiooutput')[]} (devices) -
- *      list of getUserMedia requested devices
  */
-function JitsiTrackError(error, options, devices) {
-    if (typeof error === "object" && typeof error.name !== "undefined") {
-        /**
-         * Additional information about original getUserMedia error
-         * and constraints.
-         * @type {{
-         *          error: Object,
-         *          constraints: Object,
-         *          devices: Array.<'audio'|'video'|'desktop'|'screen'>
-         *      }}
-         */
-        this.gum = {
-            error: error,
-            constraints: options,
-            devices: devices && Array.isArray(devices)
-                ? devices.slice(0)
-                : undefined
-        };
+export default class JitsiTrackError extends Error {
+    /**
+     * Initializes a new JitsiTrackError instance.
+     *
+     * @constructor
+     * @param {Object|string} error - error object or error name
+     * @param {Object|string} (options) - getUserMedia constraints object or
+     * error message
+     * @param {('audio'|'video'|'desktop'|'screen'|'audiooutput')[]} (devices) -
+     * list of getUserMedia requested devices
+     */
+    constructor(error, options, devices) {
+        super();
 
-        switch (error.name) {
+        if (typeof error === "object" && typeof error.name !== "undefined") {
+            /**
+             * Additional information about original getUserMedia error
+             * and constraints.
+             * @type {{
+             *     error: Object,
+             *     constraints: Object,
+             *     devices: Array.<'audio'|'video'|'desktop'|'screen'>
+             * }}
+             */
+            this.gum = {
+                error,
+                constraints: options,
+                devices: devices && Array.isArray(devices)
+                    ? devices.slice(0)
+                    : undefined
+            };
+
+            switch (error.name) {
             case "PermissionDeniedError":
             case "SecurityError":
                 this.name = JitsiTrackErrors.PERMISSION_DENIED;
-                this.message = TRACK_ERROR_TO_MESSAGE_MAP[
-                        JitsiTrackErrors.PERMISSION_DENIED]
+                this.message
+                    = TRACK_ERROR_TO_MESSAGE_MAP[this.name]
                         + (this.gum.devices || []).join(", ");
                 break;
+            case "DevicesNotFoundError":
             case "NotFoundError":
                 this.name = JitsiTrackErrors.NOT_FOUND;
-                this.message = TRACK_ERROR_TO_MESSAGE_MAP[
-                        JitsiTrackErrors.NOT_FOUND]
+                this.message
+                    = TRACK_ERROR_TO_MESSAGE_MAP[this.name]
                         + (this.gum.devices || []).join(", ");
                 break;
             case "ConstraintNotSatisfiedError":
             case "OverconstrainedError":
                 var constraintName = error.constraintName;
 
-                if (options && options.video
-                    && (devices || []).indexOf('video') > -1
-                    &&
-                    (constraintName === "minWidth" ||
-                        constraintName === "maxWidth" ||
-                        constraintName === "minHeight" ||
-                        constraintName === "maxHeight" ||
-                        constraintName === "width" ||
-                        constraintName === "height")) {
+                if (options
+                        && options.video
+                        && (!devices || devices.indexOf('video') > -1)
+                        && (constraintName === "minWidth"
+                            || constraintName === "maxWidth"
+                            || constraintName === "minHeight"
+                            || constraintName === "maxHeight"
+                            || constraintName === "width"
+                            || constraintName === "height")) {
                     this.name = JitsiTrackErrors.UNSUPPORTED_RESOLUTION;
-                    this.message = TRACK_ERROR_TO_MESSAGE_MAP[
-                            JitsiTrackErrors.UNSUPPORTED_RESOLUTION] +
-                        getResolutionFromFailedConstraint(constraintName,
-                            options);
+                    this.message
+                        = TRACK_ERROR_TO_MESSAGE_MAP[this.name]
+                            + getResolutionFromFailedConstraint(
+                                    constraintName,
+                                    options);
                 } else {
                     this.name = JitsiTrackErrors.CONSTRAINT_FAILED;
-                    this.message = TRACK_ERROR_TO_MESSAGE_MAP[
-                            JitsiTrackErrors.CONSTRAINT_FAILED] +
-                        error.constraintName;
+                    this.message
+                        = TRACK_ERROR_TO_MESSAGE_MAP[this.name]
+                            + error.constraintName;
                 }
                 break;
             default:
                 this.name = JitsiTrackErrors.GENERAL;
-                this.message = error.message ||
-                    TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.GENERAL];
+                this.message
+                    = error.message || TRACK_ERROR_TO_MESSAGE_MAP[this.name];
                 break;
-        }
-    } else if (typeof error === "string") {
-        if (TRACK_ERROR_TO_MESSAGE_MAP[error]) {
-            this.name = error;
-            this.message = options || TRACK_ERROR_TO_MESSAGE_MAP[error];
+            }
+        } else if (typeof error === "string") {
+            if (TRACK_ERROR_TO_MESSAGE_MAP[error]) {
+                this.name = error;
+                this.message = options || TRACK_ERROR_TO_MESSAGE_MAP[error];
+            } else {
+                // this is some generic error that do not fit any of our
+                // pre-defined errors, so don't give it any specific name, just
+                // store message
+                this.message = error;
+            }
         } else {
-            // this is some generic error that do not fit any of our pre-defined
-            // errors, so don't give it any specific name, just store message
-            this.message = error;
+            throw new Error("Invalid arguments");
         }
-    } else {
-        throw new Error("Invalid arguments");
-    }
 
-    this.stack = error.stack || (new Error()).stack;
+        this.stack = error.stack || (new Error()).stack;
+    }
 }
 
-JitsiTrackError.prototype = Object.create(Error.prototype);
-JitsiTrackError.prototype.constructor = JitsiTrackError;
-
 /**
  * Gets failed resolution constraint from corresponding object.
  * @param {string} failedConstraintName
  */
 function getResolutionFromFailedConstraint(failedConstraintName, constraints) {
     if (constraints && constraints.video && constraints.video.mandatory) {
-        if (failedConstraintName === "width") {
+        switch (failedConstraintName) {
+        case "width":
             return constraints.video.mandatory.minWidth;
-        } else if (failedConstraintName === "height") {
+        case "height":
             return constraints.video.mandatory.minHeight;
-        } else {
+        default:
             return constraints.video.mandatory[failedConstraintName] || "";
         }
     }
 
     return "";
 }
-
-module.exports = JitsiTrackError;

JitsiTrackErrors.js

 /**
- * Enumeration with the errors for the JitsiTrack objects.
- * @type {{string: string}}
- */
-module.exports = {
-    /**
-     * An error which indicates that requested video resolution is not supported
-     * by a webcam.
-     */
-    UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution",
-    /**
-     * An error which indicates that the jidesha extension for Firefox is
-     * needed to proceed with screen sharing, and that it is not installed.
-     */
-    FIREFOX_EXTENSION_NEEDED: "gum.firefox_extension_needed",
-    /**
-     * An error which indicates that the jidesha extension for Chrome is
-     * failed to install.
-     */
-    CHROME_EXTENSION_INSTALLATION_ERROR:
-        "gum.chrome_extension_installation_error",
-    /**
-     * An error which indicates that user canceled screen sharing window
-     * selection dialog in jidesha extension for Chrome.
-     */
-    CHROME_EXTENSION_USER_CANCELED:
-        "gum.chrome_extension_user_canceled",
-    /**
-     * Generic error for jidesha extension for Chrome.
-     */
-    CHROME_EXTENSION_GENERIC_ERROR:
-        "gum.chrome_extension_generic_error",
-    /**
-     * Generic getUserMedia error.
-     */
-    GENERAL: "gum.general",
-    /**
-     * An error which indicates that user denied permission to share requested
-     * device.
-     */
-    PERMISSION_DENIED: "gum.permission_denied",
-    /**
-     * An error which indicates that requested device was not found.
-     */
-    NOT_FOUND: "gum.not_found",
-    /**
-     * An error which indicates that some of requested constraints in
-     * getUserMedia call were not satisfied.
-     */
-    CONSTRAINT_FAILED: "gum.constraint_failed",
-    /**
-     * An error which indicates that track has been already disposed and cannot
-     * be longer used.
-     */
-    TRACK_IS_DISPOSED: "track.track_is_disposed",
-    /**
-     * An error which indicates that track is currently in progress of muting or
-     * unmuting itself.
-     */
-    TRACK_MUTE_UNMUTE_IN_PROGRESS: "track.mute_unmute_inprogress"
-};
+ * The errors for the JitsiTrack objects.
+ */
+
+/**
+ * Generic error for jidesha extension for Chrome.
+ */
+export const CHROME_EXTENSION_GENERIC_ERROR
+    = "gum.chrome_extension_generic_error";
+/**
+ * An error which indicates that the jidesha extension for Chrome is
+ * failed to install.
+ */
+export const CHROME_EXTENSION_INSTALLATION_ERROR
+    = "gum.chrome_extension_installation_error";
+/**
+ * An error which indicates that user canceled screen sharing window
+ * selection dialog in jidesha extension for Chrome.
+ */
+export const CHROME_EXTENSION_USER_CANCELED
+    ="gum.chrome_extension_user_canceled";
+/**
+ * An error which indicates that some of requested constraints in
+ * getUserMedia call were not satisfied.
+ */
+export const CONSTRAINT_FAILED = "gum.constraint_failed";
+/**
+ * An error which indicates that the jidesha extension for Firefox is
+ * needed to proceed with screen sharing, and that it is not installed.
+ */
+export const FIREFOX_EXTENSION_NEEDED = "gum.firefox_extension_needed";
+/**
+ * Generic getUserMedia error.
+ */
+export const GENERAL = "gum.general";
+/**
+ * An error which indicates that requested device was not found.
+ */
+export const NOT_FOUND = "gum.not_found";
+/**
+ * An error which indicates that user denied permission to share requested
+ * device.
+ */
+export const PERMISSION_DENIED = "gum.permission_denied";
+/**
+ * An error which indicates that track has been already disposed and cannot
+ * be longer used.
+ */
+export const TRACK_IS_DISPOSED = "track.track_is_disposed";
+/**
+ * An error which indicates that track is currently in progress of muting or
+ * unmuting itself.
+ */
+export const TRACK_MUTE_UNMUTE_IN_PROGRESS = "track.mute_unmute_inprogress";
+/**
+ * An error which indicates that track has no MediaStream associated.
+ */
+export const TRACK_NO_STREAM_FOUND = "track.no_stream_found";
+/**
+ * An error which indicates that requested video resolution is not supported
+ * by a webcam.
+ */
+export const UNSUPPORTED_RESOLUTION = "gum.unsupported_resolution";
+/**
+ * Indicates that the track is no receiving any data without reason(the
+ * stream was stopped, etc)
+ */
+export const NO_DATA_FROM_SOURCE = "track.no_data_from_source";

JitsiTrackEvents.js

-var JitsiTrackEvents = {
-    /**
-     * A media track mute status was changed.
-     */
-    TRACK_MUTE_CHANGED: "track.trackMuteChanged",
-    /**
-     * Audio levels of a this track was changed.
-     */
-    TRACK_AUDIO_LEVEL_CHANGED: "track.audioLevelsChanged",
-    /**
-     * The media track was removed to the conference.
-     */
-    LOCAL_TRACK_STOPPED: "track.stopped",
-    /**
-     * The video type("camera" or "desktop") of the track was changed.
-     */
-    TRACK_VIDEOTYPE_CHANGED: "track.videoTypeChanged",
-    /**
-     * The audio output of the track was changed.
-     */
-    TRACK_AUDIO_OUTPUT_CHANGED: "track.audioOutputChanged"
-};
+/**
+ * The media track was removed to the conference.
+ */
+export const LOCAL_TRACK_STOPPED = "track.stopped";
+/**
+ * Audio levels of a this track was changed.
+ */
+export const TRACK_AUDIO_LEVEL_CHANGED = "track.audioLevelsChanged";
 
-module.exports = JitsiTrackEvents;
+/**
+ * The audio output of the track was changed.
+ */
+export const TRACK_AUDIO_OUTPUT_CHANGED = "track.audioOutputChanged";
+/**
+ * A media track mute status was changed.
+ */
+export const TRACK_MUTE_CHANGED = "track.trackMuteChanged";
+/**
+ * The video type("camera" or "desktop") of the track was changed.
+ */
+export const TRACK_VIDEOTYPE_CHANGED = "track.videoTypeChanged";
+/**
+ * Indicates that the track is no receiving any data without reason(the
+ * stream was stopped, etc)
+ */
+export const NO_DATA_FROM_SOURCE = "track.no_data_from_source";

connection_optimization/external_connect.js

  * callback is going to receive one parameter which is going to be JS error
  * object with a reason for failure in it.
  */
-function createConnectionExternally(webserviceUrl, success_callback,
-    error_callback) {
+function createConnectionExternally( // eslint-disable-line no-unused-vars
+        webserviceUrl,
+        success_callback,
+        error_callback) {
     if (!window.XMLHttpRequest) {
         error_callback(new Error("XMLHttpRequest is not supported!"));
         return;
                 try {
                     var data = JSON.parse(xhttp.responseText);
 
+                    var proxyRegion = xhttp.getResponseHeader('X-Proxy-Region');
+                    var jitsiRegion = xhttp.getResponseHeader('X-Jitsi-Region');
                     window.jitsiRegionInfo = {
-                        "ProxyRegion" :
-                            xhttp.getResponseHeader('X-Proxy-Region'),
-                        "Region" :
-                            xhttp.getResponseHeader('X-Jitsi-Region'),
-                        "Shard" :
-                            xhttp.getResponseHeader('X-Jitsi-Shard')
+                        "ProxyRegion" : proxyRegion,
+                        "Region" : jitsiRegion,
+                        "Shard" : xhttp.getResponseHeader('X-Jitsi-Shard'),
+                        "CrossRegion": proxyRegion !== jitsiRegion ? 1 : 0
                     };
 
                     success_callback(data);
         }
     };
 
+    xhttp.open("GET", webserviceUrl, true);
+
+    // Fixes external connect for IE
+    // The timeout property may be set only after calling the open() method
+    // and before calling the send() method.
     xhttp.timeout = 3000;
 
-    xhttp.open("GET", webserviceUrl, true);
     window.connectionTimes = {};
     var now = window.connectionTimes["external_connect.sending"] =
         window.performance.now();

doc/API.md

     9. disableAudioLevels - boolean property. Enables/disables audio levels.
     10. disableSimulcast - boolean property. Enables/disables simulcast.
     11. enableWindowOnErrorHandler - boolean property (default false). Enables/disables attaching global onerror handler (window.onerror).
+    12. disableThirdPartyRequests - if true - callstats will be disabled and the callstats API won't be included.
+    13. analyticsScriptUrl - (optional) custom url to search for the analytics lib, if missing js file will be expected to be next to the library file (the location it is sourced from)
+    14. callStatsCustomScriptUrl - (optional) custom url to access callstats client script 
+    15. callStatsConfIDNamespace - (optional) a namespace to prepend the callstats conference ID with. Defaults to the window.location.hostname
 
 * ```JitsiMeetJS.JitsiConnection``` - the ```JitsiConnection``` constructor. You can use that to create new server connection.
 
         - AVAILABLE_DEVICES_CHANGED - notifies that available participant devices changed (camera or microphone was added or removed) (parameters - id(string), devices(JS object with 2 properties - audio(boolean), video(boolean)))
         - CONNECTION_STATS - New local connection statistics are received. (parameters - stats(object))
         - AUTH_STATUS_CHANGED - notifies that authentication is enabled or disabled, or local user authenticated (logged in). (parameters - isAuthEnabled(boolean), authIdentity(string))
+        - ENDPOINT_MESSAGE_RECEIVED - notifies that a new message
+        from another participant is received on a data channel.
 
     2. connection
         - CONNECTION_FAILED - indicates that the server connection failed.
         - NOT_FOUND - getUserMedia-related error, indicates that requested device was not found.
         - CONSTRAINT_FAILED - getUserMedia-related error, indicates that some of requested constraints in getUserMedia call were not satisfied.
         - TRACK_IS_DISPOSED - an error which indicates that track has been already disposed and cannot be longer used.
+        - TRACK_NO_STREAM_FOUND - an error which indicates that track has no MediaStream associated.
         - TRACK_MUTE_UNMUTE_IN_PROGRESS - an error which indicates that track is currently in progress of muting or unmuting itself.
         - CHROME_EXTENSION_GENERIC_ERROR - generic error for jidesha extension for Chrome.
         - CHROME_EXTENSION_USER_CANCELED - an error which indicates that user canceled screen sharing window selection dialog in jidesha extension for Chrome.
         - CHROME_EXTENSION_INSTALLATION_ERROR - an error which indicates that the jidesha extension for Chrome is failed to install.
         - FIREFOX_EXTENSION_NEEDED - An error which indicates that the jidesha extension for Firefox is needed to proceed with screen sharing, and that it is not installed.
-        
+
 * ```JitsiMeetJS.errorTypes``` - constructors for Error instances that can be produced by library. Are useful for checks like ```error instanceof JitsiMeetJS.errorTypes.JitsiTrackError```. Following Errors are available:
     1. ```JitsiTrackError``` - Error that happened to a JitsiTrack.
-        
+
 * ```JitsiMeetJS.logLevels``` - object with the log levels:
     1. TRACE
     2. DEBUG
             - muc
             - anonymousdomain
         3. useStunTurn -
+        4. enableLipSync - (optional) boolean property which enables the lipsync feature. Currently works only in Chrome and is enabled by default.
 
 2. connect(options) - establish server connection
     - options - JS Object with ```id``` and ```password``` properties.
         3. jirecon
         4. callStatsID - callstats credentials
         5. callStatsSecret - callstats credentials
-        6. disableThirdPartyRequests - if true - callstats will be disabled and
-        the callstats API won't be included.
+        6. enableTalkWhileMuted - boolean property. Enables/disables talk while muted detection, by default the value is false/disabled.
         **NOTE: if 4 and 5 are set the library is going to send events to callstats. Otherwise the callstats integration will be disabled.**
 
 5. addEventListener(event, listener) - Subscribes the passed listener to the event.
 
     Note: available only for moderator
 
+31. sendEndpointMessage(to, payload) - Sends message via the data channels.
+    - to - the id of the endpoint that should receive the message. If "" the message will be sent to all participants.
+    - payload - JSON object - the payload of the message.
+
+Throws NetworkError or InvalidStateError or Error if the operation fails.
+
+32. broadcastEndpointMessage(payload) - Sends broadcast message via the datachannels.
+    - payload - JSON object - the payload of the message.
+
+Throws NetworkError or InvalidStateError or Error if the operation fails.
+
+33. selectParticipant(participantId) - Elects the participant with the given id to be the selected participant in order to receive higher video quality (if simulcast is enabled).
+    - participantId - the identifier of the participant
+
+Throws NetworkError or InvalidStateError or Error if the operation fails.
+
+34. pinParticipant(participantId) - Elects the participant with the given id to be the pinned participant in order to always receive video for this participant (even when last n is enabled).
+    - participantId - the identifier of the participant
+
+Throws NetworkError or InvalidStateError or Error if the operation fails.
+
 JitsiTrack
 ======
 The object represents single track - video or audio. They can be remote tracks ( from the other participants in the call) or local tracks (from the devices of the local participant).
 
 JitsiTrackError
 ======
-The object represents error that happened to a JitsiTrack. Is inherited from JavaScript base ```Error``` object, 
+The object represents error that happened to a JitsiTrack. Is inherited from JavaScript base ```Error``` object,
 so ```"name"```, ```"message"``` and ```"stack"``` properties are available. For GUM-related errors,
 exposes additional ```"gum"``` property, which is an object with following properties:
  - error - original GUM error

doc/example/example.js

+/* global $, JitsiMeetJS */
+
 var options = {
     hosts: {
         domain: 'jitsi-meet.example.com',
     },
     bosh: '//jitsi-meet.example.com/http-bind', // FIXME: use xep-0156 for that
     clientNode: 'http://jitsi.org/jitsimeet', // The name of client node advertised in XEP-0115 'c' stanza
-}
+};
 
 var confOptions = {
     openSctp: true
-}
-
+};
 
 var isJoined = false;
 
         return;
     var tracks = remoteTracks[id];
     for(var i = 0; i< tracks.length; i++)
-        tracks[i].detach($("#" + id + tracks[i].getType()))
+        tracks[i].detach($("#" + id + tracks[i].getType()));
 }
 
 /**
             room.getPhonePin());
     });
     room.join();
-};
+}
 
 /**
  * This function is called when the connection fail.
  */
-function onConnectionFailed(){console.error("Connection Failed!")};
+function onConnectionFailed() {
+    console.error("Connection Failed!");
+}
 
 /**
  * This function is called when the connection fail.
     room.leave();
     connection.disconnect();
 }
+
 var isVideo = true;
-function switchVideo() {
+function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if(localTracks[1]) {
         localTracks[1].dispose();
         });
 }
 
-function changeAudioOutput(selected) {
+function changeAudioOutput(selected) { // eslint-disable-line no-unused-vars
     JitsiMeetJS.mediaDevices.setAudioOutputDevice(selected.value);
 }
 
 $(window).bind('beforeunload', unload);
 $(window).bind('unload', unload);
 
-
-
 // JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
 var initOptions = {
     disableAudioLevels: true,
     desktopSharingFirefoxMaxVersionExtRequired: -1,
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
-}
+};
 JitsiMeetJS.init(initOptions).then(function(){
     connection = new JitsiMeetJS.JitsiConnection(null, null, options);
 
     console.log(error);
 });
 
-
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(function(devices) {
         var audioOutputDevices = devices.filter(function(d) { return d.kind === 'audiooutput'; });
 
             $('#audioOutputSelectWrapper').show();
         }
-    })
+    });
 }
 
 var connection = null;

modules/RTC/DataChannels.js

-/* global config, APP, Strophe */
-
 // cache datachannels to avoid garbage collection
 // https://code.google.com/p/chromium/issues/detail?id=405545
 
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
-
 /**
  * Binds "ondatachannel" event listener to given PeerConnection instance.
  * @param peerConnection WebRTC peer connection instance.
      var msgData = event.data;
      logger.info("Got My Data Channel Message:", msgData, dataChannel);
      };*/
-};
-
+}
 
 /**
  * Callback triggered by PeerConnection when new data channel is opened
 DataChannels.prototype.onDataChannel = function (event) {
     var dataChannel = event.channel;
     var self = this;
-    var selectedEndpoint = null;
 
     dataChannel.onopen = function () {
         logger.info("Data channel opened by the Videobridge!", dataChannel);
         //dataChannel.send(new ArrayBuffer(12));
 
         self.eventEmitter.emit(RTCEvents.DATA_CHANNEL_OPEN);
-
-        // when the data channel becomes available, tell the bridge about video
-        // selections so that it can do adaptive simulcast,
-        // we want the notification to trigger even if userJid is undefined,
-        // or null.
-        // XXX why do we not do the same for pinned endpoints?
-        self.sendSelectedEndpointMessage(self.selectedEndpoint);
     };
 
     dataChannel.onerror = function (error) {
-        var e = new Error("Data Channel Error:" + error);
-        GlobalOnErrorHandler.callErrorHandler(e);
+        // FIXME: this one seems to be generated a bit too often right now
+        // so we are temporarily commenting it before we have more clarity
+        // on which of the errors we absolutely need to report
+        //GlobalOnErrorHandler.callErrorHandler(
+        //        new Error("Data Channel Error:" + error));
         logger.error("Data Channel Error:", error, dataChannel);
     };
 
                 logger.info(
                     "Data channel new dominant speaker event: ",
                     dominantSpeakerEndpoint);
-                self.eventEmitter.emit(RTCEvents.DOMINANTSPEAKER_CHANGED, dominantSpeakerEndpoint);
+                self.eventEmitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED,
+                  dominantSpeakerEndpoint);
             }
             else if ("InLastNChangeEvent" === colibriClass) {
                 var oldValue = obj.oldValue;
                     lastNEndpoints, endpointsEnteringLastN, obj);
                 self.eventEmitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED,
                     lastNEndpoints, endpointsEnteringLastN, obj);
+            } else if("EndpointMessage" === colibriClass) {
+                self.eventEmitter.emit(
+                    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);
 
 /**
  * Sends a "selected endpoint changed" message via the data channel.
+ * @param endpointId {string} the id of the selected endpoint
+ * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
+ * or Error with "No opened data channels found!" message.
  */
 DataChannels.prototype.sendSelectedEndpointMessage = function (endpointId) {
-    this.selectedEndpoint = endpointId;
     this._onXXXEndpointChanged("selected", endpointId);
 };
 
 /**
  * Sends a "pinned endpoint changed" message via the data channel.
+ * @param endpointId {string} the id of the pinned endpoint
+ * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
+ * or Error with "No opened data channels found!" message.
  */
 DataChannels.prototype.sendPinnedEndpointMessage = function (endpointId) {
-    this._onXXXEndpointChanged("pinnned", endpointId);
+    this._onXXXEndpointChanged("pinned", endpointId);
 };
 
 /**
  * Notifies Videobridge about a change in the value of a specific
- * endpoint-related property such as selected endpoint and pinnned endpoint.
+ * endpoint-related property such as selected endpoint and pinned endpoint.
  *
  * @param xxx the name of the endpoint-related property whose value changed
  * @param userResource the new value of the endpoint-related property after the
  * change
+ * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
+ * or Error with "No opened data channels found!" message.
  */
 DataChannels.prototype._onXXXEndpointChanged = function (xxx, userResource) {
     // Derive the correct words from xxx such as selected and Selected, pinned
     var tail = xxx.substring(1);
     var lower = head.toLowerCase() + tail;
     var upper = head.toUpperCase() + tail;
+    logger.log(
+            'sending ' + lower
+                + ' endpoint changed notification to the bridge: ',
+            userResource);
 
-    // Notify Videobridge about the specified endpoint change.
-    logger.log(lower + ' endpoint changed: ', userResource);
-    this._some(function (dataChannel) {
-        if (dataChannel.readyState == 'open') {
-            logger.log(
-                    'sending ' + lower
-                        + ' endpoint changed notification to the bridge: ',
-                    userResource);
+    var jsonObject = {};
 
-            var jsonObject = {};
+    jsonObject.colibriClass = (upper + 'EndpointChangedEvent');
+    jsonObject[lower + "Endpoint"]
+        = (userResource ? userResource : null);
 
-            jsonObject.colibriClass = (upper + 'EndpointChangedEvent');
-            jsonObject[lower + "Endpoint"]
-                = (userResource ? userResource : null);
-            try {
-                dataChannel.send(JSON.stringify(jsonObject));
-            } catch (e) {
-                // FIXME: Maybe we should check if the conference is left
-                // before calling _onXXXEndpointChanged method.
-                // FIXME: We should check if we are disposing correctly the
-                // data channels.
-                logger.warn(e);
-            }
+    this.send(jsonObject);
 
-            return true;
-        }
-    });
+    // Notify Videobridge about the specified endpoint change.
+    logger.log(lower + ' endpoint changed: ', userResource);
 };
 
 DataChannels.prototype._some = function (callback, thisArg) {
     }
 };
 
+/**
+ * Sends passed object via the first found open datachannel
+ * @param jsonObject {object} the object that will be sent
+ * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
+ * or Error with "No opened data channels found!" message.
+ */
+DataChannels.prototype.send = function (jsonObject) {
+    if(!this._some(function (dataChannel) {
+        if (dataChannel.readyState == 'open') {
+                dataChannel.send(JSON.stringify(jsonObject));
+            return true;
+        }
+    })) {
+        throw new Error("No opened data channels found!");
+    }
+};
+
+/**
+ * Sends message via the datachannels.
+ * @param to {string} the id of the endpoint that should receive the message.
+ * If "" the message will be sent to all participants.
+ * @param payload {object} the payload of the message.
+ * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
+ * or Error with "No opened data channels found!" message.
+ */
+DataChannels.prototype.sendDataChannelMessage = function (to, payload) {
+    this.send({
+        colibriClass: "EndpointMessage",
+        to: to,
+        msgPayload: payload
+    });
+};
+
 module.exports = DataChannels;

modules/RTC/JitsiLocalTrack.js

 /* global __filename, Promise */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+var CameraFacingMode = require('../../service/RTC/CameraFacingMode');
 var JitsiTrack = require("./JitsiTrack");
+import JitsiTrackError from "../../JitsiTrackError";
+import * as JitsiTrackErrors from "../../JitsiTrackErrors";
+import * as JitsiTrackEvents from "../../JitsiTrackEvents";
+var logger = require("jitsi-meet-logger").getLogger(__filename);
+var MediaType = require('../../service/RTC/MediaType');
 var RTCBrowserType = require("./RTCBrowserType");
-var JitsiTrackEvents = require('../../JitsiTrackEvents');
-var JitsiTrackErrors = require("../../JitsiTrackErrors");
-var JitsiTrackError = require("../../JitsiTrackError");
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
+var Statistics = require("../statistics/statistics");
 var VideoType = require('../../service/RTC/VideoType');
 
 /**
  * @param videoType the VideoType of the JitsiRemoteTrack
  * @param resolution the video resoultion if it's a video track
  * @param deviceId the ID of the local device for this track
+ * @param facingMode the camera facing mode used in getUserMedia call
  * @constructor
  */
 function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
-                         deviceId) {
+                         deviceId, facingMode) {
     var self = this;
 
     JitsiTrack.call(this,
         mediaType, videoType, null /* ssrc */);
     this.dontFireRemoveEvent = false;
     this.resolution = resolution;
+
+    // FIXME: currently firefox is ignoring our constraints about resolutions
+    // so we do not store it, to avoid wrong reporting of local track resolution
+    if (RTCBrowserType.isFirefox())
+        this.resolution = null;
+
     this.deviceId = deviceId;
     this.startMuted = false;
-    this.disposed = false;
-    //FIXME: This dependacy is not necessary.
-    this.conference = null;
     this.initialMSID = this.getMSID();
     this.inMuteOrUnmuteProgress = false;
 
+    /**
+     * The facing mode of the camera from which this JitsiLocalTrack instance
+     * was obtained.
+     */
+    this._facingMode = facingMode;
+
     // Currently there is no way to know the MediaStreamTrack ended due to to
     // device disconnect in Firefox through e.g. "readyState" property. Instead
     // we will compare current track's label with device labels from
     // enumerateDevices() list.
     this._trackEnded = false;
 
+    /**
+     * The value of bytes sent received from the statistics module.
+     */
+    this._bytesSent = null;
+
+    /**
+     * Used only for detection of audio problems. We want to check only once
+     * whether the track is sending bytes ot not. This flag is set to false
+     * after the check.
+     */
+    this._testByteSent = true;
+
     // Currently there is no way to determine with what device track was
     // created (until getConstraints() support), however we can associate tracks
     // with real devices obtained from enumerateDevices() call as soon as it's
     // called.
     this._realDeviceId = this.deviceId === '' ? undefined : this.deviceId;
 
+    /**
+     * Indicates that we have called RTCUtils.stopMediaStream for the
+     * MediaStream related to this JitsiTrack object.
+     */
+    this.stopStreamInProgress = false;
+
+    /**
+     * On mute event we are waiting for 3s to check if the stream is going to
+     * be still muted before firing the event for camera issue detected
+     * (NO_DATA_FROM_SOURCE).
+     */
+    this._noDataFromSourceTimeout = null;
+
     this._onDeviceListChanged = function (devices) {
         self._setRealDeviceIdFromDeviceList(devices);
 
 
     RTCUtils.addListener(RTCEvents.DEVICE_LIST_CHANGED,
         this._onDeviceListChanged);
+
+    this._initNoDataFromSourceHandlers();
 }
 
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
     return  this.getTrack().readyState === 'ended' || this._trackEnded;
 };
 
+/**
+ * Sets handlers to the MediaStreamTrack object that will detect camera issues.
+ */
+JitsiLocalTrack.prototype._initNoDataFromSourceHandlers = function () {
+    if(this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
+        let _onNoDataFromSourceError
+            = this._onNoDataFromSourceError.bind(this);
+        this._setHandler("track_mute", () => {
+            if(this._checkForCameraIssues()) {
+                let now = window.performance.now();
+                this._noDataFromSourceTimeout
+                    = setTimeout(_onNoDataFromSourceError, 3000);
+                this._setHandler("track_unmute", () => {
+                    this._clearNoDataFromSourceMuteResources();
+                    Statistics.sendEventToAll(
+                        this.getType() + ".track_unmute",
+                        {value: window.performance.now() - now});
+                });
+            }
+        });
+        this._setHandler("track_ended", _onNoDataFromSourceError);
+    }
+};
+
+/**
+ * Clears all timeouts and handlers set on MediaStreamTrack mute event.
+ * FIXME: Change the name of the method with better one.
+ */
+JitsiLocalTrack.prototype._clearNoDataFromSourceMuteResources = function () {
+    if(this._noDataFromSourceTimeout) {
+        clearTimeout(this._noDataFromSourceTimeout);
+        this._noDataFromSourceTimeout = null;
+    }
+    this._setHandler("track_unmute", undefined);
+};
+
+/**
+ * Called when potential camera issue is detected. Clears the handlers and
+ * timeouts set on MediaStreamTrack muted event. Verifies that the camera
+ * issue persists and fires NO_DATA_FROM_SOURCE event.
+ */
+JitsiLocalTrack.prototype._onNoDataFromSourceError = function () {
+    this._clearNoDataFromSourceMuteResources();
+    if(this._checkForCameraIssues())
+        this._fireNoDataFromSourceEvent();
+};
+
+/**
+ * Fires JitsiTrackEvents.NO_DATA_FROM_SOURCE and logs it to analytics and
+ * callstats.
+ */
+JitsiLocalTrack.prototype._fireNoDataFromSourceEvent = function () {
+    this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
+    let eventName = this.getType() + ".no_data_from_source";
+    Statistics.analytics.sendEvent(eventName);
+    let log = {name: eventName};
+    if (this.isAudioTrack()) {
+        log.isReceivingData = this._isReceivingData();
+    }
+    Statistics.sendLog(JSON.stringify(log));
+};
+
 /**
  * Sets real device ID by comparing track information with device information.
  * This is temporary solution until getConstraints() method will be implemented
 
 /**
  * Creates Promise for mute/unmute operation.
- * @param track the track that will be muted/unmuted
- * @param mute whether to mute or unmute the track
+ *
+ * @param {JitsiLocalTrack} track - The track that will be muted/unmuted.
+ * @param {boolean} mute - Whether to mute or unmute the track.
+ * @returns {Promise}
  */
-function createMuteUnmutePromise(track, mute)
-{
-    return new Promise(function (resolve, reject) {
-
-        if(this.inMuteOrUnmuteProgress) {
-            reject(new JitsiTrackError(
-                JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
-            return;
-        }
-        this.inMuteOrUnmuteProgress = true;
-
-        this._setMute(mute,
-            function(){
-                this.inMuteOrUnmuteProgress = false;
-                resolve();
-            }.bind(this),
-            function(status){
-                this.inMuteOrUnmuteProgress = false;
-                reject(status);
-            }.bind(this));
-    }.bind(track));
+function createMuteUnmutePromise(track, mute) {
+    if (track.inMuteOrUnmuteProgress) {
+        return Promise.reject(
+            new JitsiTrackError(JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS)
+        );
+    }
+
+    track.inMuteOrUnmuteProgress = true;
+
+    return track._setMute(mute)
+        .then(function() {
+            track.inMuteOrUnmuteProgress = false;
+        })
+        .catch(function(status) {
+            track.inMuteOrUnmuteProgress = false;
+            throw status;
+        });
 }
 
 /**
  * Mutes / unmutes the track.
- * @param mute {boolean} if true the track will be muted. Otherwise the track
+ *
+ * @param {boolean} mute - If true the track will be muted. Otherwise the track
  * will be unmuted.
+ * @private
+ * @returns {Promise}
  */
-JitsiLocalTrack.prototype._setMute = function (mute, resolve, reject) {
+JitsiLocalTrack.prototype._setMute = function (mute) {
     if (this.isMuted() === mute) {
-        resolve();
-        return;
+        return Promise.resolve();
     }
-    if(!this.rtc) {
-        this.startMuted = mute;
-        resolve();
-        return;
-    }
-    var isAudio = this.isAudioTrack();
-    this.dontFireRemoveEvent = false;
 
-    var setStreamToNull = false;
-    // the callback that will notify that operation had finished
-    var callbackFunction = function() {
+    var promise = Promise.resolve();
+    var self = this;
 
-        if(setStreamToNull)
-            this.stream = null;
-        this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
+    // Local track can be used out of conference, so we need to handle that
+    // case and mark that track should start muted or not when added to
+    // conference.
+    if(!this.conference || !this.conference.room) {
+        this.startMuted = mute;
+    }
 
-        resolve();
-    }.bind(this);
+    this.dontFireRemoveEvent = false;
 
-    if ((window.location.protocol != "https:") ||
-        (isAudio) || this.videoType === VideoType.DESKTOP ||
-        // FIXME FF does not support 'removeStream' method used to mute
+    // FIXME FF does not support 'removeStream' method used to mute
+    if (window.location.protocol !== "https:" ||
+        this.isAudioTrack() ||
+        this.videoType === VideoType.DESKTOP ||
         RTCBrowserType.isFirefox()) {
-
-        if (this.track)
+        if(this.track)
             this.track.enabled = !mute;
-        if(isAudio)
-            this.rtc.room.setAudioMute(mute, callbackFunction);
-        else
-            this.rtc.room.setVideoMute(mute, callbackFunction);
     } else {
-        if (mute) {
+        if(mute) {
             this.dontFireRemoveEvent = true;
-            this.rtc.room.removeStream(this.stream, function () {
-                    RTCUtils.stopMediaStream(this.stream);
-                    setStreamToNull = true;
-                    if(isAudio)
-                        this.rtc.room.setAudioMute(mute, callbackFunction);
-                    else
-                        this.rtc.room.setVideoMute(mute, callbackFunction);
-                    //FIXME: Maybe here we should set the SRC for the containers to something
-                }.bind(this),
-                function (error) {
-                    reject(error);
-                }, {mtype: this.type, type: "mute", ssrc: this.ssrc});
-
+            promise = new Promise( (resolve, reject) => {
+                this._removeStreamFromConferenceAsMute(() => {
+                    //FIXME: Maybe here we should set the SRC for the containers
+                    // to something
+                    this._stopMediaStream();
+                    this._setStream(null);
+                    resolve();
+                }, (err) => {
+                    reject(err);
+                });
+            });
         } else {
-            var self = this;
-            // FIXME why are we doing all this audio type checks and
-            // convoluted scenarios if we're going this way only
-            // for VIDEO media and CAMERA type of video ?
+            // This path is only for camera.
             var streamOptions = {
-                devices: (isAudio ? ["audio"] : ["video"]),
-                resolution: self.resolution
+                cameraDeviceId: this.getDeviceId(),
+                devices: [ MediaType.VIDEO ],
+                facingMode: this.getCameraFacingMode()
             };
-            if (isAudio) {
-                streamOptions['micDeviceId'] = self.getDeviceId();
-            } else if(self.videoType === VideoType.CAMERA) {
-                streamOptions['cameraDeviceId'] = self.getDeviceId();
-            }
-            RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
+            if (this.resolution)
+                streamOptions.resolution = this.resolution;
+
+            promise = RTCUtils.obtainAudioAndVideoPermissions(streamOptions)
                 .then(function (streamsInfo) {
-                    var streamInfo = null;
-                    for(var i = 0; i < streamsInfo.length; i++) {
-                        if(streamsInfo[i].mediaType === self.getType()) {
-                            streamInfo = streamsInfo[i];
-                            self.stream = streamInfo.stream;
-                            self.track = streamInfo.track;
-                            // This is not good when video type changes after
-                            // unmute, but let's not crash here
-                            if (self.videoType != streamInfo.videoType) {
-                                logger.warn(
-                                    "Video type has changed after unmute!",
-                                    self.videoType, streamInfo.videoType);
-                                self.videoType = streamInfo.videoType;
-                            }
-                            break;
-                        }
-                    }
+                    var mediaType = self.getType();
+                    var streamInfo = streamsInfo.find(function(info) {
+                        return info.mediaType === mediaType;
+                    });
 
                     if(!streamInfo) {
-                        reject(new Error('track.no_stream_found'));
-                        return;
+                        throw new JitsiTrackError(
+                            JitsiTrackErrors.TRACK_NO_STREAM_FOUND);
+                    }else {
+                        self._setStream(streamInfo.stream);
+                        self.track = streamInfo.track;
+                        // This is not good when video type changes after
+                        // unmute, but let's not crash here
+                        if (self.videoType !== streamInfo.videoType) {
+                            logger.warn(
+                                "Video type has changed after unmute!",
+                                self.videoType, streamInfo.videoType);
+                            self.videoType = streamInfo.videoType;
+                        }
                     }
 
-                    for(var i = 0; i < self.containers.length; i++)
-                    {
-                        self.containers[i]
-                            = RTCUtils.attachMediaStream(
-                                    self.containers[i], self.stream);
-                    }
+                    self.containers = self.containers.map(function(cont) {
+                        return RTCUtils.attachMediaStream(cont, self.stream);
+                    });
 
-                    self.rtc.room.addStream(self.stream,
-                        function () {
-                            if(isAudio)
-                                self.rtc.room.setAudioMute(
-                                    mute, callbackFunction);
-                            else
-                                self.rtc.room.setVideoMute(
-                                    mute, callbackFunction);
-                        }, function (error) {
-                            reject(error);
-                        }, {
-                            mtype: self.type,
-                            type: "unmute",
-                            ssrc: self.ssrc,
-                            msid: self.getMSID()});
-                }).catch(function (error) {
-                    reject(error);
+                   return self._addStreamToConferenceAsUnmute();
                 });
         }
     }
+
+    return promise
+        .then(function() {
+            return self._sendMuteStatus(mute);
+        })
+        .then(function() {
+            self.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
+        });
+};
+
+/**
+ * Adds stream to conference and marks it as "unmute" operation.
+ *
+ * @private
+ * @returns {Promise}
+ */
+JitsiLocalTrack.prototype._addStreamToConferenceAsUnmute = function () {
+    if (!this.conference || !this.conference.room) {
+        return Promise.resolve();
+    }
+
+    var self = this;
+
+    return new Promise(function(resolve, reject) {
+        self.conference.room.addStream(
+            self.stream,
+            resolve,
+            reject,
+            {
+                mtype: self.type,
+                type: "unmute",
+                ssrc: self.ssrc,
+                msid: self.getMSID()
+            });
+    });
+};
+
+/**
+ * Removes stream from conference and marks it as "mute" operation.
+ * @param {Function} successCallback will be called on success
+ * @param {Function} errorCallback will be called on error
+ * @private
+ */
+JitsiLocalTrack.prototype._removeStreamFromConferenceAsMute =
+function (successCallback, errorCallback) {
+    if (!this.conference || !this.conference.room) {
+        successCallback();
+        return;
+    }
+
+    this.conference.room.removeStream(
+        this.stream,
+        successCallback,
+        errorCallback,
+        {
+            mtype: this.type,
+            type: "mute",
+            ssrc: this.ssrc
+        });
+};
+
+/**
+ * Sends mute status for a track to conference if any.
+ *
+ * @param {boolean} mute - If track is muted.
+ * @private
+ * @returns {Promise}
+ */
+JitsiLocalTrack.prototype._sendMuteStatus = function(mute) {
+    if (!this.conference || !this.conference.room) {
+        return Promise.resolve();
+    }
+
+    var self = this;
+
+    return new Promise(function(resolve) {
+        self.conference.room[
+            self.isAudioTrack()
+                ? 'setAudioMute'
+                : 'setVideoMute'](mute, resolve);
+    });
 };
 
 /**
+ * @inheritdoc
+ *
  * Stops sending the media track. And removes it from the HTML.
  * NOTE: Works for local tracks only.
+ *
+ * @extends JitsiTrack#dispose
  * @returns {Promise}
  */
 JitsiLocalTrack.prototype.dispose = function () {
+    var self = this;
     var promise = Promise.resolve();
 
     if (this.conference){
     }
 
     if (this.stream) {
-        RTCUtils.stopMediaStream(this.stream);
+        this._stopMediaStream();
         this.detach();
     }
 
-    this.disposed = true;
-
     RTCUtils.removeListener(RTCEvents.DEVICE_LIST_CHANGED,
         this._onDeviceListChanged);
 
             this._onAudioOutputDeviceChanged);
     }
 
-    return promise;
+    return promise
+        .then(function() {
+            return JitsiTrack.prototype.dispose.call(self); // super.dispose();
+        });
 };
 
 /**
     }
 };
 
-/**
- * Private method. Updates rtc property of the track.
- * @param rtc the rtc instance.
- */
-JitsiLocalTrack.prototype._setRTC = function (rtc) {
-    this.rtc = rtc;
-    // We want to keep up with postponed events which should have been fired
-    // on "attach" call, but for local track we not always have the conference
-    // before attaching. However this may result in duplicated events if they
-    // have been triggered on "attach" already.
-    for(var i = 0; i < this.containers.length; i++)
-    {
-        this._maybeFireTrackAttached(this.containers[i]);
-    }
-};
-
 /**
  * Updates the SSRC associated with the MediaStream in JitsiLocalTrack object.
  * @ssrc the new ssrc
 };
 
 
-//FIXME: This dependacy is not necessary. This is quick fix.
 /**
  * Sets the JitsiConference object associated with the track. This is temp
  * solution.
  */
 JitsiLocalTrack.prototype._setConference = function(conference) {
     this.conference = conference;
+
+    // We want to keep up with postponed events which should have been fired
+    // on "attach" call, but for local track we not always have the conference
+    // before attaching. However this may result in duplicated events if they
+    // have been triggered on "attach" already.
+    for(var i = 0; i < this.containers.length; i++)
+    {
+        this._maybeFireTrackAttached(this.containers[i]);
+    }
 };
 
 /**
     return this._realDeviceId || this.deviceId;
 };
 
+/**
+ * Sets the value of bytes sent statistic.
+ * @param bytesSent {intiger} the new value
+ * NOTE: used only for audio tracks to detect audio issues.
+ */
+JitsiLocalTrack.prototype._setByteSent = function (bytesSent) {
+    this._bytesSent = bytesSent;
+    // FIXME it's a shame that PeerConnection and ICE status does not belong
+    // to the RTC module and it has to be accessed through
+    // the conference(and through the XMPP chat room ???) instead
+    let iceConnectionState
+        = this.conference ? this.conference.getConnectionState() : null;
+    if(this._testByteSent && "connected" === iceConnectionState) {
+        setTimeout(function () {
+            if(this._bytesSent <= 0){
+                //we are not receiving anything from the microphone
+                this._fireNoDataFromSourceEvent();
+            }
+        }.bind(this), 3000);
+        this._testByteSent = false;
+    }
+};
+
+/**
+ * Returns facing mode for video track from camera. For other cases (e.g. audio
+ * track or 'desktop' video track) returns undefined.
+ *
+ * @returns {CameraFacingMode|undefined}
+ */
+JitsiLocalTrack.prototype.getCameraFacingMode = function () {
+    if (this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
+        // MediaStreamTrack#getSettings() is not implemented in many browsers,
+        // so we need feature checking here. Progress on the respective
+        // browser's implementation can be tracked at
+        // https://bugs.chromium.org/p/webrtc/issues/detail?id=2481 for Chromium
+        // and https://bugzilla.mozilla.org/show_bug.cgi?id=1213517 for Firefox.
+        // Even if a browser implements getSettings() already, it might still
+        // not return anything for 'facingMode'.
+        var trackSettings;
+
+        try {
+            trackSettings = this.track.getSettings();
+        } catch (e) {
+            // XXX React-native-webrtc, for example, defines
+            // MediaStreamTrack#getSettings() but the implementation throws a
+            // "Not implemented" Error.
+        }
+        if (trackSettings && 'facingMode' in trackSettings) {
+            return trackSettings.facingMode;
+        }
+
+        if (typeof this._facingMode !== 'undefined') {
+            return this._facingMode;
+        }
+
+        // In most cases we are showing a webcam. So if we've gotten here, it
+        // should be relatively safe to assume that we are probably showing
+        // the user-facing camera.
+        return CameraFacingMode.USER;
+    }
+
+    return undefined;
+};
+
+/**
+ * Stops the associated MediaStream.
+ */
+JitsiLocalTrack.prototype._stopMediaStream = function () {
+    this.stopStreamInProgress = true;
+    RTCUtils.stopMediaStream(this.stream);
+    this.stopStreamInProgress = false;
+};
+
+/**
+ * Detects camera issues on ended and mute events from MediaStreamTrack.
+ * @returns {boolean} true if an issue is detected and false otherwise
+ */
+JitsiLocalTrack.prototype._checkForCameraIssues = function () {
+    if(!this.isVideoTrack() || this.stopStreamInProgress ||
+        this.videoType === VideoType.DESKTOP)
+        return false;
+
+    return !this._isReceivingData();
+};
+
+/**
+ * Checks whether the attached MediaStream is reveiving data from source or
+ * not. If the stream property is null(because of mute or another reason) this
+ * method will return false.
+ * NOTE: This method doesn't indicate problem with the streams directly.
+ * For example in case of video mute the method will return false or if the
+ * user has disposed the track.
+ * @returns {boolean} true if the stream is receiving data and false otherwise.
+ */
+JitsiLocalTrack.prototype._isReceivingData = function () {
+    if(!this.stream)
+        return false;
+    // In older version of the spec there is no muted property and
+    // readyState can have value muted. In the latest versions
+    // readyState can have values "live" and "ended" and there is
+    // muted boolean property. If the stream is muted that means that
+    // we aren't receiving any data from the source. We want to notify
+    // the users for error if the stream is muted or ended on it's
+    // creation.
+    return this.stream.getTracks().some(track =>
+        ((!("readyState" in track) || track.readyState === "live")
+            && (!("muted" in track) || track.muted !== true)));
+};
+
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiRemoteTrack.js

+/* global Strophe */
+
 var JitsiTrack = require("./JitsiTrack");
-var JitsiTrackEvents = require("../../JitsiTrackEvents");
+import * as JitsiTrackEvents from "../../JitsiTrackEvents";
+var logger = require("jitsi-meet-logger").getLogger(__filename);
+var RTCBrowserType = require("./RTCBrowserType");
+var RTCEvents = require("../../service/RTC/RTCEvents");
+var Statistics = require("../statistics/statistics");
+
+var ttfmTrackerAudioAttached = false;
+var ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
- * @param RTC the rtc instance.
+ * @param rtc {RTC} the RTC service instance.
  * @param ownerJid the MUC JID of the track owner
  * @param stream WebRTC MediaStream, parent of the track
  * @param track underlying WebRTC MediaStreamTrack for new JitsiRemoteTrack
  * @param muted intial muted state of the JitsiRemoteTrack
  * @constructor
  */
-function JitsiRemoteTrack(RTC, ownerJid, stream, track, mediaType, videoType,
+function JitsiRemoteTrack(rtc, conference, ownerJid, stream, track, mediaType, videoType,
                           ssrc, muted) {
     JitsiTrack.call(
-        this, RTC, stream, track, function () {}, mediaType, videoType, ssrc);
-    this.rtc = RTC;
+        this, conference, stream, track, function () {}, mediaType, videoType, ssrc);
+    this.rtc = rtc;
     this.peerjid = ownerJid;
     this.muted = muted;
+    // we want to mark whether the track has been ever muted
+    // to detect ttfm events for startmuted conferences, as it can significantly
+    // increase ttfm values
+    this.hasBeenMuted = muted;
+    // Bind 'onmute' and 'onunmute' event handlers
+    if (this.rtc && this.track)
+        this._bindMuteHandlers();
 }
 
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
 JitsiRemoteTrack.prototype.constructor = JitsiRemoteTrack;
 
+JitsiRemoteTrack.prototype._bindMuteHandlers = function() {
+    // Bind 'onmute'
+    // FIXME it would be better to use recently added '_setHandler' method, but
+    // 1. It does not allow to set more than one handler to the event
+    // 2. It does mix MediaStream('inactive') with MediaStreamTrack events
+    // 3. Allowing to bind more than one event handler requires too much
+    //    refactoring around camera issues detection.
+    this.track.addEventListener('mute', function () {
+
+        logger.debug(
+            '"onmute" event(' + Date.now() + '): ',
+            this.getParticipantId(), this.getType(), this.getSSRC());
+
+        this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_MUTE, this);
+    }.bind(this));
+
+    // Bind 'onunmute'
+    this.track.addEventListener('unmute', function () {
+
+        logger.debug(
+            '"onunmute" event(' + Date.now() + '): ',
+            this.getParticipantId(), this.getType(), this.getSSRC());
+
+        this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_UNMUTE, this);
+    }.bind(this));
+};
+
 /**
  * Sets current muted status and fires an events for the change.
  * @param value the muted status.
     if(this.muted === value)
         return;
 
+    if(value)
+        this.hasBeenMuted = true;
+
     // we can have a fake video stream
     if(this.stream)
         this.stream.muted = value;
 
     this.muted = value;
-    this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
+    this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
 };
 
 /**
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
 
-delete JitsiRemoteTrack.prototype.dispose;
+JitsiRemoteTrack.prototype._playCallback = function () {
+    var type = (this.isVideoTrack() ? 'video' : 'audio');
+
+    var now = window.performance.now();
+    console.log("(TIME) Render " + type + ":\t", now);
+    this.conference.getConnectionTimes()[type + ".render"] = now;
+
+    var ttfm = now
+        - (this.conference.getConnectionTimes()["session.initiate"]
+        - this.conference.getConnectionTimes()["muc.joined"])
+        - (window.connectionTimes["obtainPermissions.end"]
+        - window.connectionTimes["obtainPermissions.start"]);
+    this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
+    console.log("(TIME) TTFM " + type + ":\t", ttfm);
+    var eventName = type +'.ttfm';
+    if(this.hasBeenMuted)
+        eventName += '.muted';
+    Statistics.analytics.sendEvent(eventName, {value: ttfm});
+};
+
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
+    if((ttfmTrackerAudioAttached && this.isAudioTrack())
+        || (ttfmTrackerVideoAttached && this.isVideoTrack()))
+        return;
+
+    if (this.isAudioTrack())
+        ttfmTrackerAudioAttached = true;
+    if (this.isVideoTrack())
+        ttfmTrackerVideoAttached = true;
+
+    if (RTCBrowserType.isTemasysPluginUsed()) {
+        // XXX Don't require Temasys unless it's to be used because it doesn't
+        // run on React Native, for example.
+        const AdapterJS = require("./adapter.screenshare");
+
+        // FIXME: this is not working for IE11
+        AdapterJS.addEvent(container, 'play', this._playCallback.bind(this));
+    }
+    else {
+        container.addEventListener("canplay", this._playCallback.bind(this));
+    }
+};
 
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

 /* global __filename, module */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
-var JitsiTrackEvents = require("../../JitsiTrackEvents");
+import * as JitsiTrackEvents from "../../JitsiTrackEvents";
 var EventEmitter = require("events");
 var MediaType = require("../../service/RTC/MediaType");
 
+/**
+ * Maps our handler types to MediaStreamTrack properties.
+ */
+var trackHandler2Prop = {
+    "track_mute": "onmute",//Not supported on FF
+    "track_unmute": "onunmute",
+    "track_ended": "onended"
+};
+
 /**
  * This implements 'onended' callback normally fired by WebRTC after the stream
  * is stopped. There is no such behaviour yet in FF, so we have to add it.
  * @param videoType the VideoType for this track if any
  * @param ssrc the SSRC of this track if known
  */
-function JitsiTrack(rtc, stream, track, streamInactiveHandler, trackMediaType,
+function JitsiTrack(conference, stream, track, streamInactiveHandler, trackMediaType,
                     videoType, ssrc)
 {
     /**
      * @type {Array}
      */
     this.containers = [];
-    this.rtc = rtc;
+    this.conference = conference;
     this.stream = stream;
     this.ssrc = ssrc;
     this.eventEmitter = new EventEmitter();
     this.type = trackMediaType;
     this.track = track;
     this.videoType = videoType;
+    this.handlers = {};
+
+    /**
+     * Indicates whether this JitsiTrack has been disposed. If true, this
+     * JitsiTrack is to be considered unusable and operations involving it are
+     * to fail (e.g. {@link JitsiConference#addTrack(JitsiTrack)},
+     * {@link JitsiConference#removeTrack(JitsiTrack)}).
+     * @type {boolean}
+     */
+    this.disposed = false;
+    this._setHandler("inactive", streamInactiveHandler);
+}
+
+/**
+ * Sets handler to the WebRTC MediaStream or MediaStreamTrack object depending
+ * on the passed type.
+ * @param {string} type the type of the handler that is going to be set
+ * @param {Function} handler the handler.
+ */
+JitsiTrack.prototype._setHandler = function (type, handler) {
+    this.handlers[type] = handler;
+    if(!this.stream)
+        return;
 
-    if(stream) {
+    if(type === "inactive") {
         if (RTCBrowserType.isFirefox()) {
             implementOnEndedHandling(this);
         }
-        addMediaStreamInactiveHandler(stream, streamInactiveHandler);
+        addMediaStreamInactiveHandler(this.stream, handler);
+    } else if(trackHandler2Prop.hasOwnProperty(type)) {
+        this.stream.getVideoTracks().forEach(function (track) {
+            track[trackHandler2Prop[type]] = handler;
+        }, this);
     }
-}
+};
+
+/**
+ * Sets the stream property of JitsiTrack object and sets all stored handlers
+ * to it.
+ * @param {MediaStream} stream the new stream.
+ */
+JitsiTrack.prototype._setStream = function (stream) {
+    this.stream = stream;
+    Object.keys(this.handlers).forEach(function (type) {
+        typeof(this.handlers[type]) === "function" &&
+            this._setHandler(type, this.handlers[type]);
+    }, this);
+};
 
 /**
  * Returns the type (audio or video) of this track.
     return this.getType() === MediaType.AUDIO;
 };
 
+/**
+ * Checks whether the underlying WebRTC <tt>MediaStreamTrack</tt> is muted
+ * according to it's 'muted' field status.
+ * @return {boolean} <tt>true</tt> if the underlying <tt>MediaStreamTrack</tt>
+ * is muted or <tt>false</tt> otherwise.
+ */
+JitsiTrack.prototype.isWebRTCTrackMuted = function () {
+    return this.track && this.track.muted;
+};
+
 /**
  * Check if this is videotrack.
  */
     return this.getType() === MediaType.VIDEO;
 };
 
+/**
+ * Checks whether this is a local track.
+ * @abstract
+ * @return {boolean} 'true' if it's a local track or 'false' otherwise.
+ */
+JitsiTrack.prototype.isLocal = function () {
+    throw new Error("Not implemented by subclass");
+};
+
 /**
  * Returns the WebRTC MediaStream instance.
  */
  * @private
  */
 JitsiTrack.prototype._maybeFireTrackAttached = function (container) {
-    if (this.rtc && container) {
-        this.rtc.eventEmitter.emit(RTCEvents.TRACK_ATTACHED, this, container);
+    if (this.conference && container) {
+        this.conference._onTrackAttach(this, container);
     }
 };
 
 
     this._maybeFireTrackAttached(container);
 
+    this._attachTTFMTracker(container);
+
     return container;
 };
 
 };
 
 /**
- * Dispose sending the media track. And removes it from the HTML.
- * NOTE: Works for local tracks only.
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+// eslint-disable-next-line no-unused-vars
+JitsiTrack.prototype._attachTTFMTracker = function (container) {
+};
+
+/**
+ * Removes attached event listeners.
+ *
+ * @returns {Promise}
  */
 JitsiTrack.prototype.dispose = function () {
+    this.eventEmitter.removeAllListeners();
+
+    this.disposed = true;
+
+    return Promise.resolve();
 };
 
 /**

modules/RTC/RTC.js

-/* global __filename, APP, module */
+/* global Strophe */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var EventEmitter = require("events");
-var RTCBrowserType = require("./RTCBrowserType");
 var RTCEvents = require("../../service/RTC/RTCEvents.js");
 var RTCUtils = require("./RTCUtils.js");
-var JitsiTrack = require("./JitsiTrack");
 var JitsiLocalTrack = require("./JitsiLocalTrack.js");
+import JitsiTrackError from "../../JitsiTrackError";
+import * as JitsiTrackErrors from "../../JitsiTrackErrors";
 var DataChannels = require("./DataChannels");
 var JitsiRemoteTrack = require("./JitsiRemoteTrack.js");
 var MediaType = require("../../service/RTC/MediaType");
     var deviceId = null;
     tracksInfo.forEach(function(trackInfo){
         if (trackInfo.mediaType === MediaType.AUDIO) {
-          deviceId = options.micDeviceId;
+            deviceId = options.micDeviceId;
         } else if (trackInfo.videoType === VideoType.CAMERA){
-          deviceId = options.cameraDeviceId;
+            deviceId = options.cameraDeviceId;
         }
         var localTrack
             = new JitsiLocalTrack(
                 trackInfo.stream,
                 trackInfo.track,
                 trackInfo.mediaType,
-                trackInfo.videoType, trackInfo.resolution, deviceId);
+                trackInfo.videoType,
+                trackInfo.resolution,
+                deviceId,
+                options.facingMode);
         newTracks.push(localTrack);
     });
     return newTracks;
 }
 
-function RTC(room, options) {
-    this.room = room;
+function RTC(conference, options) {
+    this.conference = conference;
     this.localTracks = [];
     //FIXME: We should support multiple streams per jid.
     this.remoteTracks = {};
     this.eventEmitter = new EventEmitter();
     var self = this;
     this.options = options || {};
-    room.addPresenceListener("videomuted", function (values, from) {
-        var videoTrack = self.getRemoteVideoTrack(from);
-        if (videoTrack) {
-            videoTrack.setMute(values.value == "true");
-        }
-    });
-    room.addPresenceListener("audiomuted", function (values, from) {
-        var audioTrack = self.getRemoteAudioTrack(from);
-        if (audioTrack) {
-            audioTrack.setMute(values.value == "true");
-        }
-    });
-    room.addPresenceListener("videoType", function(data, from) {
-        var videoTrack = self.getRemoteVideoTrack(from);
-        if (videoTrack) {
-            videoTrack._setVideoType(data.value);
-        }
-    });
+    // A flag whether we had received that the data channel had opened
+    // we can get this flag out of sync if for some reason data channel got
+    // closed from server, a desired behaviour so we can see errors when this
+    // happen
+    this.dataChannelsOpen = false;
 
     // Switch audio output device on all remote audio tracks. Local audio tracks
     // handle this event by themselves.
 RTC.obtainAudioAndVideoPermissions = function (options) {
     return RTCUtils.obtainAudioAndVideoPermissions(options).then(
         function (tracksInfo) {
-            return createLocalTracks(tracksInfo, options);
+            var tracks = createLocalTracks(tracksInfo, options);
+            return !tracks.some(track => !track._isReceivingData())? tracks :
+                Promise.reject(new JitsiTrackError(
+                    JitsiTrackErrors.NO_DATA_FROM_SOURCE));
     });
 };
 
 RTC.prototype.onIncommingCall = function(event) {
-    if(this.options.config.openSctp)
+    if(this.options.config.openSctp) {
         this.dataChannels = new DataChannels(event.peerconnection,
             this.eventEmitter);
-    // Add local Tracks to the ChatRoom
-    this.localTracks.forEach(function(localTrack) {
-        var ssrcInfo = null;
-        if(localTrack.isVideoTrack() && localTrack.isMuted()) {
-            /**
-             * Handles issues when the stream is added before the peerconnection
-             * is created. The peerconnection is created when second participant
-             * enters the call. In that use case the track doesn't have
-             * information about it's ssrcs and no jingle packets are sent. That
-             * can cause inconsistent behavior later.
-             *
-             * For example:
-             * If we mute the stream and than second participant enter it's
-             * remote SDP won't include that track. On unmute we are not sending
-             * any jingle packets which will brake the unmute.
-             *
-             * In order to solve issues like the above one here we have to
-             * generate the ssrc information for the track .
-             */
-            localTrack._setSSRC(
-                this.room.generateNewStreamSSRCInfo());
-            ssrcInfo = {
-                mtype: localTrack.getType(),
-                type: "addMuted",
-                ssrc: localTrack.ssrc,
-                msid: localTrack.initialMSID
-            };
-        }
-        try {
-            this.room.addStream(
-                localTrack.getOriginalStream(), function () {}, function () {},
-                ssrcInfo, true);
-        } catch(e) {
-            GlobalOnErrorHandler.callErrorHandler(e);
-            logger.error(e);
-        }
-    }.bind(this));
+        this._dataChannelOpenListener = () => {
+            // mark that dataChannel is opened
+            this.dataChannelsOpen = true;
+            // when the data channel becomes available, tell the bridge
+            // about video selections so that it can do adaptive simulcast,
+            // we want the notification to trigger even if userJid
+            // is undefined, or null.
+            // XXX why do we not do the same for pinned endpoints?
+            try {
+                this.dataChannels.sendSelectedEndpointMessage(
+                    this.selectedEndpoint);
+            } catch (error) {
+                GlobalOnErrorHandler.callErrorHandler(error);
+                logger.error("Cannot sendSelectedEndpointMessage ",
+                    this.selectedEndpoint, ". Error: ", error);
+            }
+
+            this.removeListener(RTCEvents.DATA_CHANNEL_OPEN,
+                this._dataChannelOpenListener);
+            this._dataChannelOpenListener = null;
+        };
+        this.addListener(RTCEvents.DATA_CHANNEL_OPEN,
+            this._dataChannelOpenListener);
+    }
+};
+
+/**
+ * Should be called when current media session ends and after the PeerConnection
+ * has been closed using PeerConnection.close() method.
+ */
+RTC.prototype.onCallEnded = function() {
+    if (this.dataChannels) {
+        // DataChannels are not explicitly closed as the PeerConnection
+        // is closed on call ended which triggers data channel onclose events.
+        // The reference is cleared to disable any logic related to the data
+        // channels.
+        this.dataChannels = null;
+        this.dataChannelsOpen = false;
+    }
 };
 
+/**
+ * Elects the participant with the given id to be the selected participant in
+ * order to always receive video for this participant (even when last n is
+ * enabled).
+ * If there is no data channel we store it and send it through the channel once
+ * it is created.
+ * @param id {string} the user id.
+ * @throws NetworkError or InvalidStateError or Error if the operation fails.
+*/
 RTC.prototype.selectEndpoint = function (id) {
-    if(this.dataChannels)
+    // cache the value if channel is missing, till we open it
+    this.selectedEndpoint = id;
+    if(this.dataChannels && this.dataChannelsOpen)
         this.dataChannels.sendSelectedEndpointMessage(id);
 };
 
+/**
+ * Elects the participant with the given id to be the pinned participant in
+ * order to always receive video for this participant (even when last n is
+ * enabled).
+ * @param id {string} the user id
+ * @throws NetworkError or InvalidStateError or Error if the operation fails.
+ */
 RTC.prototype.pinEndpoint = function (id) {
-    if(this.dataChannels)
+    if(this.dataChannels) {
         this.dataChannels.sendPinnedEndpointMessage(id);
+    } else {
+        // FIXME: cache value while there is no data channel created
+        // and send the cached state once channel is created
+        throw new Error("Data channels support is disabled!");
+    }
 };
 
 RTC.prototype.addListener = function (type, listener) {
 };
 
 RTC.removeListener = function (eventType, listener) {
-    RTCUtils.removeListener(eventType, listener)
+    RTCUtils.removeListener(eventType, listener);
 };
 
 RTC.isRTCReady = function () {
         throw new Error('track must not be null nor undefined');
 
     this.localTracks.push(track);
-    track._setRTC(this);
+
+    track.conference = this.conference;
 
     if (track.isAudioTrack()) {
         this.localAudio = track;
 };
 
 /**
- * Gets JitsiRemoteTrack for AUDIO MediaType associated with given MUC nickname
- * (resource part of the JID).
+ * Gets JitsiRemoteTrack for the passed MediaType associated with given MUC
+ * nickname (resource part of the JID).
+ * @param type audio or video.
  * @param resource the resource part of the MUC JID
  * @returns {JitsiRemoteTrack|null}
  */
-RTC.prototype.getRemoteAudioTrack = function (resource) {
+RTC.prototype.getRemoteTrackByType = function (type, resource) {
     if (this.remoteTracks[resource])
-        return this.remoteTracks[resource][MediaType.AUDIO];
+        return this.remoteTracks[resource][type];
     else
         return null;
 };
 
+/**
+ * Gets JitsiRemoteTrack for AUDIO MediaType associated with given MUC nickname
+ * (resource part of the JID).
+ * @param resource the resource part of the MUC JID
+ * @returns {JitsiRemoteTrack|null}
+ */
+RTC.prototype.getRemoteAudioTrack = function (resource) {
+    return this.getRemoteTrackByType(MediaType.AUDIO, resource);
+};
+
 /**
  * Gets JitsiRemoteTrack for VIDEO MediaType associated with given MUC nickname
  * (resource part of the JID).
  * @returns {JitsiRemoteTrack|null}
  */
 RTC.prototype.getRemoteVideoTrack = function (resource) {
-    if (this.remoteTracks[resource])
-        return this.remoteTracks[resource][MediaType.VIDEO];
-    else
-        return null;
+    return this.getRemoteTrackByType(MediaType.VIDEO, resource);
 };
 
 /**
 RTC.prototype.createRemoteTrack = function (event) {
     var ownerJid = event.owner;
     var remoteTrack = new JitsiRemoteTrack(
-        this,  ownerJid, event.stream,    event.track,
+        this, this.conference, ownerJid, event.stream, event.track,
         event.mediaType, event.videoType, event.ssrc, event.muted);
     var resource = Strophe.getResourceFromJid(ownerJid);
     var remoteTracks
 
 /**
  * Removes all JitsiRemoteTracks associated with given MUC nickname (resource
- * part of the JID).
- * @param resource the resource part of the MUC JID
- * @returns {JitsiRemoteTrack|null}
+ * part of the JID). Returns array of removed tracks.
+ *
+ * @param {string} resource - The resource part of the MUC JID.
+ * @returns {JitsiRemoteTrack[]}
  */
 RTC.prototype.removeRemoteTracks = function (resource) {
-    var remoteTracks = this.remoteTracks[resource];
+    var removedTracks = [];
+    var removedAudioTrack = this.removeRemoteTrack(resource, MediaType.AUDIO);
+    var removedVideoTrack = this.removeRemoteTrack(resource, MediaType.VIDEO);
+
+    removedAudioTrack && removedTracks.push(removedAudioTrack);
+    removedVideoTrack && removedTracks.push(removedVideoTrack);
 
-    if(remoteTracks) {
-        remoteTracks['audio'] && remoteTracks['audio'].dispose();
-        remoteTracks['video'] && remoteTracks['video'].dispose();
-        delete this.remoteTracks[resource];
+    delete this.remoteTracks[resource];
+
+    return removedTracks;
+};
+
+/**
+ * Removes specified track type associated with given MUC nickname
+ * (resource part of the JID). Returns removed track if any.
+ *
+ * @param {string} resource - The resource part of the MUC JID.
+ * @param {string} mediaType - Type of track to remove.
+ * @returns {JitsiRemoteTrack|undefined}
+ */
+RTC.prototype.removeRemoteTrack = function (resource, mediaType) {
+    var remoteTracksForResource = this.remoteTracks[resource];
+
+    if (remoteTracksForResource && remoteTracksForResource[mediaType]) {
+        var track = remoteTracksForResource[mediaType];
+        track.dispose();
+        delete remoteTracksForResource[mediaType];
+        return track;
     }
 };
 
  * Closes all currently opened data channels.
  */
 RTC.prototype.closeAllDataChannels = function () {
-    this.dataChannels.closeAllChannels();
+    if(this.dataChannels) {
+        this.dataChannels.closeAllChannels();
+        this.dataChannelsOpen = false;
+    }
 };
 
 RTC.prototype.dispose = function() {
 RTC.prototype.getResourceBySSRC = function (ssrc) {
     if((this.localVideo && ssrc == this.localVideo.getSSRC())
         || (this.localAudio && ssrc == this.localAudio.getSSRC())) {
-        return Strophe.getResourceFromJid(this.room.myroomjid);
+        return this.conference.myUserId();
     }
 
     var track = this.getRemoteTrackBySSRC(ssrc);
     return null;
 };
 
+/**
+ * Handles remote track mute / unmute events.
+ * @param type {string} "audio" or "video"
+ * @param isMuted {boolean} the new mute state
+ * @param from {string} user id
+ */
+RTC.prototype.handleRemoteTrackMute = function (type, isMuted, from) {
+    var track = this.getRemoteTrackByType(type, from);
+    if (track) {
+        track.setMute(isMuted);
+    }
+};
+
+/**
+ * Handles remote track video type events
+ * @param value {string} the new video type
+ * @param from {string} user id
+ */
+RTC.prototype.handleRemoteTrackVideoTypeChanged = function (value, from) {
+    var videoTrack = this.getRemoteVideoTrack(from);
+    if (videoTrack) {
+        videoTrack._setVideoType(value);
+    }
+};
+
+/**
+ * Sends message via the datachannels.
+ * @param to {string} the id of the endpoint that should receive the message.
+ * If "" the message will be sent to all participants.
+ * @param payload {object} the payload of the message.
+ * @throws NetworkError or InvalidStateError or Error if the operation fails
+ * or there is no data channel created
+ */
+RTC.prototype.sendDataChannelMessage = function (to, payload) {
+    if(this.dataChannels) {
+        this.dataChannels.sendDataChannelMessage(to, payload);
+    } else {
+        throw new Error("Data channels support is disabled!");
+    }
+};
+
 module.exports = RTC;

modules/RTC/RTCBrowserType.js

         return currentBrowser;
     },
 
+    /**
+     * Gets current browser name, split from the type.
+     * @returns {string}
+     */
+    getBrowserName: function () {
+        var browser = currentBrowser.split('rtc_browser.')[1];
+        if (RTCBrowserType.isAndroid()) {
+            browser = 'android';
+        }
+        return browser;
+    },
+
     /**
      * Checks if current browser is Chrome.
      * @returns {boolean}
         return RTCBrowserType.isIExplorer() || RTCBrowserType.isSafari();
     },
 
+    /**
+     * Checks if the current browser triggers 'onmute'/'onunmute' events when
+     * user's connection is interrupted and the video stops playback.
+     * @returns {*|boolean} 'true' if the event is supported or 'false'
+     * otherwise.
+     */
+    isVideoMuteOnConnInterruptedSupported: function () {
+        return RTCBrowserType.isChrome();
+    },
+
     /**
      * Returns Firefox version.
      * @returns {number|null}
      */
     isAndroid: function() {
         return isAndroid;
+    },
+
+    /**
+     * Whether jitsi-meet supports simulcast on the current browser.
+     * @returns {boolean}
+     */
+    supportsSimulcast: function() {
+        return RTCBrowserType.isChrome();
     }
 
     // Add version getters for other browsers when needed
     var match
         = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
     var version;
-    if (match) {
+    // If we're remote debugging a React Native app, it may be treated as
+    // Chrome. Check navigator.product as well and always return some version
+    // even if we can't get the real one.
+    if (match || navigator.product === 'ReactNative') {
         currentBrowser = RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
-        if (match.length > 2) {
+        var name;
+        if (match && match.length > 2) {
+            name = match[1];
             version = match[2];
         }
-        console.info(
-            "This appears to be " + /* name */ match[1] + ", ver: " + version);
+        if (!name) {
+            name = 'react-native';
+        }
+        if (!version) {
+            version = 'unknown';
+        }
+        console.info('This appears to be ' + name + ', ver: ' + version);
+    } else {
+        // We're not running in a React Native environment.
+        version = null;
     }
     return version;
 }

modules/RTC/RTCUIHelper.js

-/* global $, __filename */
+/* global $ */
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var RTC = require('./RTC');
 
 var RTCUIHelper = {
 
      */
     setAutoPlay: function (streamElement, autoPlay) {
         if (!RTCBrowserType.isIExplorer()) {
-            streamElement.autoplay = true;
+            streamElement.autoplay = autoPlay;
         }
     }
 };

modules/RTC/RTCUtils.js

-/* global config, require, attachMediaStream, getUserMedia,
-   RTCPeerConnection, RTCSessionDescription, RTCIceCandidate, MediaStreamTrack,
-   mozRTCPeerConnection, mozRTCSessionDescription, mozRTCIceCandidate,
-   webkitRTCPeerConnection, webkitMediaStream, webkitURL
+/* global $,
+          attachMediaStream,
+          MediaStreamTrack,
+          RTCIceCandidate,
+          RTCPeerConnection,
+          RTCSessionDescription,
+          mozRTCIceCandidate,
+          mozRTCPeerConnection,
+          mozRTCSessionDescription,
+          webkitMediaStream,
+          webkitRTCPeerConnection,
+          webkitURL
 */
-/* jshint -W101 */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
 var Resolutions = require("../../service/RTC/Resolutions");
 var RTCEvents = require("../../service/RTC/RTCEvents");
-var AdapterJS = require("./adapter.screenshare");
 var SDPUtil = require("../xmpp/SDPUtil");
 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
-var JitsiTrackErrors = require("../../JitsiTrackErrors");
-var JitsiTrackError = require("../../JitsiTrackError");
+import JitsiTrackError from "../../JitsiTrackError";
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
+var CameraFacingMode = require("../../service/RTC/CameraFacingMode");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
+// XXX Don't require Temasys unless it's to be used because it doesn't run on
+// React Native, for example.
+const AdapterJS
+    = RTCBrowserType.isTemasysPluginUsed()
+        ? require("./adapter.screenshare")
+        : undefined;
+
 var eventEmitter = new EventEmitter();
 
 var AVAILABLE_DEVICES_POLL_INTERVAL_TIME = 3000; // ms
 // Currently audio output device change is supported only in Chrome and
 // default output always has 'default' device ID
 var audioOutputDeviceId = 'default'; // default device
+// whether user has explicitly set a device to use
+var audioOutputChanged = false;
 // Disables Acoustic Echo Cancellation
 var disableAEC = false;
 // Disables Noise Suppression
 
 var currentlyAvailableMediaDevices;
 
-var rawEnumerateDevicesWithCallback = navigator.mediaDevices
-    && navigator.mediaDevices.enumerateDevices
+var rawEnumerateDevicesWithCallback = undefined;
+/**
+ * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
+ * ready. Otherwise it is too early to assume that the devices listing is not
+ * supported.
+ */
+function initRawEnumerateDevicesWithCallback() {
+    rawEnumerateDevicesWithCallback = navigator.mediaDevices
+        && navigator.mediaDevices.enumerateDevices
         ? function(callback) {
-            navigator.mediaDevices.enumerateDevices().then(callback, function () {
-                callback([]);
+            navigator.mediaDevices.enumerateDevices().then(
+                callback, function () {
+                    callback([]);
             });
         }
+        // Safari:
+        // "ReferenceError: Can't find variable: MediaStreamTrack"
+        // when Temasys plugin is not installed yet, have to delay this call
+        // until WebRTC is ready.
         : (MediaStreamTrack && MediaStreamTrack.getSources)
-            ? function (callback) {
-                MediaStreamTrack.getSources(function (sources) {
-                    callback(sources.map(convertMediaStreamTrackSource));
-                });
-            }
-            : undefined;
+        ? function (callback) {
+            MediaStreamTrack.getSources(function (sources) {
+                callback(sources.map(convertMediaStreamTrackSource));
+            });
+        }
+        : undefined;
+}
 
 // TODO: currently no browser supports 'devicechange' event even in nightly
 // builds so no feature/browser detection is used at all. However in future this
  * @param {string} options.desktopStream
  * @param {string} options.cameraDeviceId
  * @param {string} options.micDeviceId
- * @param {'user'|'environment'} options.facingMode
+ * @param {CameraFacingMode} options.facingMode
  * @param {bool} firefox_fake_device
  */
 function getConstraints(um, options) {
             // TODO: Maybe use "exact" syntax if options.facingMode is defined,
             // but this probably needs to be decided when updating other
             // constraints, as we currently don't use "exact" syntax anywhere.
+            var facingMode = options.facingMode || CameraFacingMode.USER;
+
             if (isNewStyleConstraintsSupported) {
-                constraints.video.facingMode = options.facingMode || 'user';
+                constraints.video.facingMode = facingMode;
             }
-
             constraints.video.optional.push({
-                facingMode: options.facingMode || 'user'
+                facingMode: facingMode
             });
         }
 
     return constraints;
 }
 
-function setAvailableDevices(um, available) {
+/**
+ * Sets the availbale devices based on the options we requested and the
+ * streams we received.
+ * @param um the options we requested to getUserMedia.
+ * @param stream the stream we received from calling getUserMedia.
+ */
+function setAvailableDevices(um, stream) {
+    var audioTracksReceived = stream && !!stream.getAudioTracks().length;
+    var videoTracksReceived = stream && !!stream.getVideoTracks().length;
+
     if (um.indexOf("video") != -1) {
-        devices.video = available;
+        devices.video = videoTracksReceived;
     }
     if (um.indexOf("audio") != -1) {
-        devices.audio = available;
+        devices.audio = audioTracksReceived;
     }
 
     eventEmitter.emit(RTCEvents.AVAILABLE_DEVICES_CHANGED, devices);
  * @param {MediaDeviceInfo[]} devices - list of media devices.
  * @emits RTCEvents.DEVICE_LIST_CHANGED
  */
-function onMediaDevicesListChanged(devices) {
-    currentlyAvailableMediaDevices = devices.slice(0);
+function onMediaDevicesListChanged(devicesReceived) {
+    currentlyAvailableMediaDevices = devicesReceived.slice(0);
     logger.info('list of media devices has changed:', currentlyAvailableMediaDevices);
 
     var videoInputDevices = currentlyAvailableMediaDevices.filter(function (d) {
 
     if (videoInputDevices.length &&
         videoInputDevices.length === videoInputDevicesWithEmptyLabels.length) {
-        setAvailableDevices(['video'], false);
+        devices.video = false;
     }
 
     if (audioInputDevices.length &&
         audioInputDevices.length === audioInputDevicesWithEmptyLabels.length) {
-        setAvailableDevices(['audio'], false);
+        devices.audio = false;
     }
 
-    eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, devices);
+    eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, devicesReceived);
 }
 
 // In case of IE we continue from 'onReady' callback
     eventEmitter.emit(RTCEvents.RTC_READY, true);
     screenObtainer.init(options, GUM);
 
+    // Initialize rawEnumerateDevicesWithCallback
+    initRawEnumerateDevicesWithCallback();
+
     if (RTCUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
         rawEnumerateDevicesWithCallback(function (devices) {
             currentlyAvailableMediaDevices = devices.splice(0);
         if (audioVideo) {
             var audioTracks = audioVideo.getAudioTracks();
             if (audioTracks.length) {
+                // eslint-disable-next-line new-cap
                 audioStream = new webkitMediaStream();
                 for (var i = 0; i < audioTracks.length; i++) {
                     audioStream.addTrack(audioTracks[i]);
 
             var videoTracks = audioVideo.getVideoTracks();
             if (videoTracks.length) {
+                // eslint-disable-next-line new-cap
                 videoStream = new webkitMediaStream();
                 for (var j = 0; j < videoTracks.length; j++) {
                     videoStream.addTrack(videoTracks[j]);
         if (stream
                 && RTCUtils.isDeviceChangeAvailable('output')
                 && stream.getAudioTracks
-                && stream.getAudioTracks().length) {
+                && stream.getAudioTracks().length
+                // we skip setting audio output if there was no explicit change
+                && audioOutputChanged) {
             element.setSinkId(RTCUtils.getAudioOutputDevice())
                 .catch(function (ex) {
                     var err = new JitsiTrackError(ex, null, ['audiooutput']);
         }
 
         return res;
-    }
+    };
 }
 
 /**
                     }
                     return SDPUtil.filter_special_chars(id);
                 };
-                RTCSessionDescription = mozRTCSessionDescription;
-                RTCIceCandidate = mozRTCIceCandidate;
+                RTCSessionDescription = mozRTCSessionDescription; // eslint-disable-line
+                RTCIceCandidate = mozRTCIceCandidate;             // eslint-disable-line
             } else if (RTCBrowserType.isChrome() ||
                     RTCBrowserType.isOpera() ||
                     RTCBrowserType.isNWJS() ||
                 //AdapterJS.WebRTCPlugin.setLogLevel(
                 //    AdapterJS.WebRTCPlugin.PLUGIN_LOG_LEVELS.VERBOSE);
                 var self = this;
-                AdapterJS.webRTCReady(function (isPlugin) {
+                AdapterJS.webRTCReady(function () {
 
                     self.peerconnection = RTCPeerConnection;
                     self.getUserMedia = window.getUserMedia;
                         return SDPUtil.filter_special_chars(stream.label);
                     };
 
-                    onReady(options, self.getUserMediaWithConstraints);
+                    onReady(options,
+                        self.getUserMediaWithConstraints.bind(self));
                     resolve();
                 });
             } else {
                 var errmsg = 'Browser does not appear to be WebRTC-capable';
-                try {
-                    logger.error(errmsg);
-                } catch (e) {
-                }
+                logger.error(errmsg);
                 reject(new Error(errmsg));
                 return;
             }
 
             // Call onReady() if Temasys plugin is not used
             if (!RTCBrowserType.isTemasysPluginUsed()) {
-                onReady(options, this.getUserMediaWithConstraints);
+                onReady(options, this.getUserMediaWithConstraints.bind(this));
                 resolve();
             }
         }.bind(this));
     **/
     getUserMediaWithConstraints: function ( um, success_callback, failure_callback, options) {
         options = options || {};
-        var resolution = options.resolution;
         var constraints = getConstraints(um, options);
 
         logger.info("Get media constraints", constraints);
             this.getUserMedia(constraints,
                 function (stream) {
                     logger.log('onUserMediaSuccess');
-                    setAvailableDevices(um, true);
+                    setAvailableDevices(um, stream);
                     success_callback(stream);
                 },
                 function (error) {
-                    setAvailableDevices(um, false);
+                    setAvailableDevices(um, undefined);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
 
         var self = this;
 
         options = options || {};
+        var dsOptions = options.desktopSharingExtensionExternalInstallation;
         return new Promise(function (resolve, reject) {
             var successCallback = function (stream) {
                 resolve(handleLocalStream(stream, options.resolution));
 
                 if(screenObtainer.isSupported()){
                     deviceGUM["desktop"] = screenObtainer.obtainStream.bind(
-                        screenObtainer);
+                        screenObtainer,
+                        dsOptions);
                 }
                 // With FF/IE we can't split the stream into audio and video because FF
                 // doesn't support media stream constructors. So, we need to get the
                                     devices.push("video");
                                 }
 
-                                reject(new JitsiTrackError(
-                                    { name: "UnknownError" },
-                                    getConstraints(options.devices, options),
-                                    devices)
-                                );
+                                // we are missing one of the media we requested
+                                // in order to get the actual error that caused
+                                // this missing media we will call one more time
+                                // getUserMedia so we can obtain the actual
+                                // error (Example usecases are requesting
+                                // audio and video and video device is missing
+                                // or device is denied to be used and chrome is
+                                // set to not ask for permissions)
+                                self.getUserMediaWithConstraints(
+                                    devices,
+                                    function () {
+                                        // we already failed to obtain this
+                                        // media, so we are not supposed in any
+                                        // way to receive success for this call
+                                        // any way we will throw an error to be
+                                        // sure the promise will finish
+                                        reject(new JitsiTrackError(
+                                            { name: "UnknownError" },
+                                            getConstraints(
+                                                options.devices, options),
+                                            devices)
+                                        );
+                                    },
+                                    function (error) {
+                                        // rejects with real error for not
+                                        // obtaining the media
+                                        reject(error);
+                                    },options);
+
                                 return;
                             }
                             if(hasDesktop) {
                                 screenObtainer.obtainStream(
+                                    dsOptions,
                                     function (desktopStream) {
                                         successCallback({audioVideo: stream,
                                             desktopStream: desktopStream});
                         options);
                 } else if (hasDesktop) {
                     screenObtainer.obtainStream(
+                        dsOptions,
                         function (stream) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
     isRTCReady: function () {
         return rtcReady;
     },
-    /**
-     * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
-     */
-    isDeviceListAvailable: function () {
+    _isDeviceListAvailable: function () {
+        if (!rtcReady)
+            throw new Error("WebRTC not ready yet");
         var isEnumerateDevicesAvailable
             = navigator.mediaDevices && navigator.mediaDevices.enumerateDevices;
         if (isEnumerateDevicesAvailable) {
             return true;
         }
-        return (MediaStreamTrack && MediaStreamTrack.getSources)? true : false;
+        return (typeof MediaStreamTrack !== "undefined" &&
+            MediaStreamTrack.getSources)? true : false;
+    },
+    /**
+     * Returns a promise which can be used to make sure that the WebRTC stack
+     * has been initialized.
+     *
+     * @returns {Promise} which is resolved only if the WebRTC stack is ready.
+     * Note that currently we do not detect stack initialization failure and
+     * the promise is never rejected(unless unexpected error occurs).
+     */
+    onRTCReady: function() {
+        if (rtcReady) {
+            return Promise.resolve();
+        } else {
+            return new Promise(function (resolve) {
+                var listener = function () {
+                    eventEmitter.removeListener(RTCEvents.RTC_READY, listener);
+                    resolve();
+                };
+                eventEmitter.addListener(RTCEvents.RTC_READY, listener);
+                // We have no failed event, so... it either resolves or nothing
+                // happens
+            });
+        }
+    },
+    /**
+     * Checks if its possible to enumerate available cameras/microphones.
+     *
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
+     */
+    isDeviceListAvailable: function () {
+        return this.onRTCReady().then(function() {
+            return this._isDeviceListAvailable();
+        }.bind(this));
     },
     /**
      * Returns true if changing the input (camera / microphone) or output
             mediaStream.stop();
         }
 
+        // The MediaStream implementation of the react-native-webrtc project has
+        // an explicit release method that is to be invoked in order to release
+        // used resources such as memory.
+        if (mediaStream.release) {
+            mediaStream.release();
+        }
+
         // if we have done createObjectURL, lets clean it
         var url = mediaStream.jitsiObjectURL;
         if (url) {
         return featureDetectionAudioEl.setSinkId(deviceId)
             .then(function() {
                 audioOutputDeviceId = deviceId;
+                audioOutputChanged = true;
 
                 logger.log('Audio output device set to ' + deviceId);
 

modules/RTC/ScreenObtainer.js

 /* global chrome, $, alert */
-/* jshint -W003 */
+
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var AdapterJS = require("./adapter.screenshare");
-var JitsiTrackErrors = require("../../JitsiTrackErrors");
-var JitsiTrackError = require("../../JitsiTrackError");
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+import JitsiTrackError from "../../JitsiTrackError";
+import * as JitsiTrackErrors from "../../JitsiTrackErrors";
 
 /**
  * Indicates whether the Chrome desktop sharing extension is installed.
 
 var GUM = null;
 
+/**
+ * The error returned by chrome when trying to start inline installation from
+ * popup.
+ */
+const CHROME_EXTENSION_POPUP_ERROR
+    = "Inline installs can not be initiated from pop-up windows.";
+
+/**
+ * The error message returned by chrome when the extension is installed.
+ */
+const CHROME_NO_EXTENSION_ERROR_MSG // eslint-disable-line no-unused-vars
+    = "Could not establish connection. Receiving end does not exist.";
+
 /**
  * Handles obtaining a stream from a screen capture on different browsers.
  */
 var ScreenObtainer = {
     obtainStream: null,
+
     /**
      * Initializes the function used to obtain a screen capture
      * (this.obtainStream).
      * or disable screen capture (if the value is other).
      * Note that for the "screen" media source to work the
      * 'chrome://flags/#enable-usermedia-screen-capture' flag must be set.
+     * @param options {object}
+     * @param gum {Function} GUM method
      */
-    init: function(options, gum) {
+    init(options, gum) {
         var obtainDesktopStream = null;
         this.options = options = options || {};
         GUM = gum;
             (options.desktopSharingChromeMethod || options.desktopSharing);
 
         if (RTCBrowserType.isNWJS()) {
-            obtainDesktopStream = function (onSuccess, onFailure) {
+            obtainDesktopStream = (options, onSuccess, onFailure) => {
                 window.JitsiMeetNW.obtainDesktopStream (
-                    onSuccess, function (error, constraints) {
-                        onFailure && onFailure(new JitsiTrackError(
-                            error, constraints, ["desktop"]));
+                    onSuccess,
+                    (error, constraints) => {
+                        var jitsiError;
+                        // FIXME:
+                        // This is very very durty fix for recognising that the
+                        // user have clicked the cancel button from the Desktop
+                        // sharing pick window. The proper solution would be to
+                        // detect this in the NWJS application by checking the
+                        // streamId === "". Even better solution would be to
+                        // stop calling GUM from the NWJS app and just pass the
+                        // streamId to lib-jitsi-meet. This way the desktop
+                        // sharing implementation for NWJS and chrome extension
+                        // will be the same and lib-jitsi-meet will be able to
+                        // control the constraints, check the streamId, etc.
+                        //
+                        // I cannot find documentation about "InvalidStateError"
+                        // but this is what we are receiving from GUM when the
+                        // streamId for the desktop sharing is "".
+                        if (error && error.name == "InvalidStateError") {
+                            jitsiError = new JitsiTrackError(
+                                JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED
+                            );
+                        } else {
+                            jitsiError = new JitsiTrackError(
+                                error, constraints, ["desktop"]);
+                        }
+                        (typeof(onFailure) === "function") &&
+                            onFailure(jitsiError);
                     });
             };
         } else if (RTCBrowserType.isTemasysPluginUsed()) {
+            // XXX Don't require Temasys unless it's to be used because it
+            // doesn't run on React Native, for example.
+            const AdapterJS = require("./adapter.screenshare");
+
             if (!AdapterJS.WebRTCPlugin.plugin.HasScreensharingFeature) {
                 logger.info("Screensharing not supported by this plugin " +
                     "version");
             } else {
                 obtainDesktopStream = this.obtainScreenOnFirefox;
             }
-
         }
 
         if (!obtainDesktopStream) {
      * environment.
      * @returns {boolean}
      */
-    isSupported: function() {
+    isSupported() {
         return !!this.obtainStream;
     },
+
     /**
      * Obtains a screen capture stream on Firefox.
      * @param callback
      * @param errorCallback
      */
-    obtainScreenOnFirefox:
-           function (callback, errorCallback) {
-        var self = this;
+    obtainScreenOnFirefox(options, callback, errorCallback) {
         var extensionRequired = false;
         if (this.options.desktopSharingFirefoxMaxVersionExtRequired === -1 ||
             (this.options.desktopSharingFirefoxMaxVersionExtRequired >= 0 &&
         }
 
         if (!extensionRequired || firefoxExtInstalled === true) {
-            obtainWebRTCScreen(callback, errorCallback);
+            obtainWebRTCScreen(options, callback, errorCallback);
             return;
         }
 
         // extension if it hasn't.
         if (firefoxExtInstalled === null) {
             window.setTimeout(
-                function() {
+                () => {
                     if (firefoxExtInstalled === null)
                         firefoxExtInstalled = false;
-                    self.obtainScreenOnFirefox(callback, errorCallback);
+                    this.obtainScreenOnFirefox(callback, errorCallback);
                 },
-                300
-            );
+                300);
             logger.log("Waiting for detection of jidesha on firefox to " +
                 "finish.");
             return;
         errorCallback(
             new JitsiTrackError(JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED));
     },
+
     /**
      * Asks Chrome extension to call chooseDesktopMedia and gets chrome
      * 'desktop' stream for returned stream token.
      */
-    obtainScreenFromExtension: function (streamCallback, failCallback) {
-        var self = this;
+    obtainScreenFromExtension(options, streamCallback, failCallback) {
         if (chromeExtInstalled) {
             doGetStreamFromExtension(this.options, streamCallback,
                 failCallback);
             try {
                 chrome.webstore.install(
                     getWebStoreInstallUrl(this.options),
-                    function (arg) {
+                    arg => {
                         logger.log("Extension installed successfully", arg);
                         chromeExtInstalled = true;
-                        // We need to give a moment for the endpoint to become
-                        // available
-                        window.setTimeout(function () {
-                            doGetStreamFromExtension(self.options,
-                                streamCallback, failCallback);
-                        }, 500);
+                        // We need to give a moment to the endpoint to become
+                        // available.
+                        waitForExtensionAfterInstall(this.options, 200, 10)
+                            .then(() => {
+                                doGetStreamFromExtension(this.options,
+                                    streamCallback, failCallback);
+                            }).catch(() => {
+                                this.handleExtensionInstallationError(options,
+                                    streamCallback, failCallback);
+                            });
                     },
-                    handleExtensionInstallationError
+                    this.handleExtensionInstallationError.bind(this,
+                        options, streamCallback, failCallback)
                 );
             } catch(e) {
-                handleExtensionInstallationError(e);
+                this.handleExtensionInstallationError(options, streamCallback,
+                    failCallback, e);
             }
         }
+    },
+
+    handleExtensionInstallationError(options, streamCallback, failCallback, e) {
+        const webStoreInstallUrl = getWebStoreInstallUrl(this.options);
+
+        if (CHROME_EXTENSION_POPUP_ERROR === e
+                && options.interval > 0
+                && typeof(options.checkAgain) === "function"
+                && typeof(options.listener) === "function") {
+            options.listener("waitingForExtension", webStoreInstallUrl);
+            this.checkForChromeExtensionOnInterval(options, streamCallback,
+                failCallback, e);
+            return;
+        }
 
-        function handleExtensionInstallationError(e) {
-            var msg = "Failed to install the extension from "
-                + getWebStoreInstallUrl(self.options);
+        const msg
+            = "Failed to install the extension from " + webStoreInstallUrl;
 
-            logger.log(msg, e);
+        logger.log(msg, e);
+        failCallback(new JitsiTrackError(
+            JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
+            msg));
+    },
 
+    checkForChromeExtensionOnInterval(options, streamCallback, failCallback) {
+        if (options.checkAgain() === false) {
             failCallback(new JitsiTrackError(
-                JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
-                msg
-            ));
+                JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR));
+            return;
         }
+        waitForExtensionAfterInstall(this.options, options.interval, 1)
+            .then(() => {
+                chromeExtInstalled = true;
+                options.listener("extensionFound");
+                this.obtainScreenFromExtension(options,
+                    streamCallback, failCallback);
+            }).catch(() => {
+                this.checkForChromeExtensionOnInterval(options,
+                    streamCallback, failCallback);
+            });
     }
 };
 
-
-
 /**
  * Obtains a desktop stream using getUserMedia.
  * For this to work on Chrome, the
  * 'media.getusermedia.screensharing.allowed_domains' preference in
  * 'about:config'.
  */
-function obtainWebRTCScreen(streamCallback, failCallback) {
-    GUM(
-        ['screen'],
-        streamCallback,
-        failCallback
-    );
+function obtainWebRTCScreen(options, streamCallback, failCallback) {
+    GUM(['screen'], streamCallback, failCallback);
 }
 
 /**
         //TODO: remove chromeExtensionId (deprecated)
         (options.desktopSharingChromeExtId || options.chromeExtensionId),
         { getVersion: true },
-        function (response) {
+        response => {
             if (!response || !response.version) {
                 // Communication failure - assume that no endpoint exists
                 logger.warn(
             sources: (options.desktopSharingChromeSources ||
                 options.desktopSharingSources)
         },
-        function (response) {
+        response => {
             if (!response) {
                 // possibly re-wraping error message to make code consistent
                 var lastError = chrome.runtime.lastError;
             if (response.streamId) {
                 GUM(
                     ['desktop'],
-                    function (stream) {
-                        streamCallback(stream);
-                    },
+                    stream => streamCallback(stream),
                     failCallback,
-                    {desktopStream: response.streamId});
+                    { desktopStream: response.streamId });
             } else {
                 // As noted in Chrome Desktop Capture API:
                 // If user didn't select any source (i.e. canceled the prompt)
     // Initialize Chrome extension inline installs
     initInlineInstalls(options);
     // Check if extension is installed
-    checkChromeExtInstalled(function (installed, updateRequired) {
+    checkChromeExtInstalled((installed, updateRequired) => {
         chromeExtInstalled = installed;
         chromeExtUpdateRequired = updateRequired;
         logger.info(
     }, options);
 }
 
+/**
+ * Checks "retries" times on every "waitInterval"ms whether the ext is alive.
+ * @param {Object} options the options passed to ScreanObtainer.obtainStream
+ * @param {int} waitInterval the number of ms between retries
+ * @param {int} retries the number of retries
+ * @returns {Promise} returns promise that will be resolved when the extension
+ * is alive and rejected if the extension is not alive even after "retries"
+ * checks
+ */
+function waitForExtensionAfterInstall(options, waitInterval, retries) {
+    if(retries === 0) {
+        return Promise.reject();
+    }
+    return new Promise((resolve, reject) => {
+        let currentRetries = retries;
+        let interval = window.setInterval(() => {
+            checkChromeExtInstalled( (installed) => {
+                if(installed) {
+                    window.clearInterval(interval);
+                    resolve();
+                } else {
+                    currentRetries--;
+                    if(currentRetries === 0) {
+                        reject();
+                        window.clearInterval(interval);
+                    }
+                }
+            }, options);
+        }, waitInterval);
+    });
+}
+
 /**
  * Starts the detection of an installed jidesha extension for firefox.
  * @param options supports "desktopSharingFirefoxDisabled",
     }
 
     var img = document.createElement('img');
-    img.onload = function(){
+    img.onload = () => {
         logger.log("Detected firefox screen sharing extension.");
         firefoxExtInstalled = true;
     };
-    img.onerror = function(){
+    img.onerror = () => {
         logger.log("Detected lack of firefox screen sharing extension.");
         firefoxExtInstalled = false;
     };

modules/TalkMutedDetection.js

+import * as JitsiConferenceEvents from "../JitsiConferenceEvents";
+
+export default class TalkMutedDetection {
+    /**
+     * Creates TalkMutedDetection
+     * @param conference the JitsiConference instance that created us.
+     * @param callback the callback to call when detected that the local user is
+     * talking while her microphone is muted.
+     * @constructor
+     */
+    constructor(conference, callback) {
+        /**
+         * The callback to call when detected that the local user is talking
+         * while her microphone is muted.
+         *
+         * @private
+         */
+        this._callback = callback;
+
+        /**
+         * The indicator which determines whether <tt>callback</tt> has been
+         * invoked for the current local audio track of <tt>conference</tt> so
+         * that it is invoked once only.
+         *
+         * @private
+         */
+        this._eventFired = false;
+
+        // XXX I went back and forth on the subject of where to put the access
+        // to statistics. On the one had, (1) statistics is likely intended to
+        // be private to conference and (2) there is a desire to keep the
+        // dependencies of modules to the minimum (i.e. not have
+        // TalkMutedDetection depend on statistics). On the other hand, (1)
+        // statistics is technically not private because
+        // JitsiConferenceEventManager accesses it and (2) TalkMutedDetection
+        // works exactly because it knows that there are no audio levels for
+        // JitsiLocalTrack but there are audio levels for the local participant
+        // through statistics.
+        conference.statistics.addAudioLevelListener(
+            this._audioLevel.bind(this));
+
+        conference.on(
+            JitsiConferenceEvents.TRACK_MUTE_CHANGED,
+            this._trackMuteChanged.bind(this));
+        conference.on(
+            JitsiConferenceEvents.TRACK_ADDED,
+            this._trackAdded.bind(this));
+    }
+
+    /**
+     * Receives audio level events for all send and receive streams.
+     *
+     * @param ssrc - The synchronization source identifier (SSRC) of the
+     * endpoint/participant/stream being reported.
+     * @param {number} audioLevel - The audio level of <tt>ssrc</tt>.
+     * @param {boolean} isLocal - <tt>true</tt> if <tt>ssrc</tt> represents a
+     * local/send stream or <tt>false</tt> for a remote/receive stream.
+     */
+    _audioLevel(ssrc, audioLevel, isLocal) {
+        // We are interested in the local audio stream only and if event is not
+        // sent yet.
+        if (!isLocal || !this.audioTrack || this._eventFired)
+            return;
+
+        if (this.audioTrack.isMuted() && audioLevel > 0.6) {
+            this._eventFired = true;
+            this._callback();
+        }
+    }
+
+    /**
+     * Determines whether a specific {@link JitsiTrack} represents a local audio
+     * track.
+     *
+     * @param {JitsiTrack} track - The <tt>JitsiTrack</tt> to be checked whether
+     * it represents a local audio track.
+     * @private
+     * @return {boolean} - <tt>true</tt> if the specified <tt>track</tt>
+     * represents a local audio track; otherwise, <tt>false</tt>.
+     */
+    _isLocalAudioTrack(track) {
+        return track.isAudioTrack() && track.isLocal();
+    }
+
+    /**
+     * Notifies this <tt>TalkMutedDetection</tt> that a {@link JitsiTrack} was
+     * added to the associated {@link JitsiConference}. Looks for the local
+     * audio track only.
+     *
+     * @param {JitsiTrack} track - The added <tt>JitsiTrack</tt>.
+     * @private
+     */
+    _trackAdded(track) {
+        if (this._isLocalAudioTrack(track))
+            this.audioTrack = track;
+    }
+
+    /**
+     * Notifies this <tt>TalkMutedDetection</tt> that the mute state of a
+     * {@link JitsiTrack} has changed. Looks for the local audio track only.
+     *
+     * @param {JitsiTrack} track - The <tt>JitsiTrack</tt> whose mute state has
+     * changed.
+     * @private
+     */
+    _trackMuteChanged(track) {
+        if (this._isLocalAudioTrack(track) && track.isMuted())
+            this._eventFired = false;
+    }
+}

modules/connectivity/ConnectionQuality.js

+import * as ConnectionQualityEvents
+    from "../../service/connectivity/ConnectionQualityEvents";
+import * as ConferenceEvents from "../../JitsiConferenceEvents";
+import {getLogger} from "jitsi-meet-logger";
+import RTCBrowserType from "../RTC/RTCBrowserType";
+
+var XMPPEvents = require('../../service/xmpp/XMPPEvents');
+var MediaType = require('../../service/RTC/MediaType');
+var VideoType = require('../../service/RTC/VideoType');
+var Resolutions = require("../../service/RTC/Resolutions");
+
+const logger = getLogger(__filename);
+
+/**
+ * The value to use for the "type" field for messages sent by ConnectionQuality
+ * over the data channel.
+ */
+const STATS_MESSAGE_TYPE = "stats";
+
+/**
+ * See media/engine/simulcast.ss from webrtc.org
+ */
+const kSimulcastFormats = [
+    { width: 1920, height: 1080, layers:3, max: 5000, target: 4000, min: 800 },
+    { width: 1280, height: 720,  layers:3, max: 2500, target: 2500, min: 600 },
+    { width: 960,  height: 540,  layers:3, max: 900,  target: 900, min: 450 },
+    { width: 640,  height: 360,  layers:2, max: 700,  target: 500, min: 150 },
+    { width: 480,  height: 270,  layers:2, max: 450,  target: 350, min: 150 },
+    { width: 320,  height: 180,  layers:1, max: 200,  target: 150, min: 30 }
+];
+
+/**
+ * The initial bitrate for video in kbps.
+ */
+var startBitrate = 800;
+
+/**
+ * Gets the expected bitrate (in kbps) in perfect network conditions.
+ * @param simulcast {boolean} whether simulcast is enabled or not.
+ * @param resolution {Resolution} the resolution.
+ * @param millisSinceStart {number} the number of milliseconds since sending
+ * video started.
+ */
+function getTarget(simulcast, resolution, millisSinceStart) {
+    // Completely ignore the bitrate in the first 5 seconds, as the first
+    // event seems to fire very early and the value is suspicious and causes
+    // false positives.
+    if (millisSinceStart < 5000) {
+        return 1;
+    }
+
+    let target = 0;
+    let height = Math.min(resolution.height, resolution.width);
+
+    if (simulcast) {
+        // Find the first format with height no bigger than ours.
+        let simulcastFormat = kSimulcastFormats.find(f => f.height <= height);
+        if (simulcastFormat) {
+            // Sum the target fields from all simulcast layers for the given
+            // resolution (e.g. 720p + 360p + 180p).
+            for (height = simulcastFormat.height; height >= 180; height /=2) {
+                simulcastFormat
+                    = kSimulcastFormats.find(f => f.height == height);
+                if (simulcastFormat) {
+                    target += simulcastFormat.target;
+                } else {
+                    break;
+                }
+            }
+        }
+    } else {
+        // See GetMaxDefaultVideoBitrateKbps in
+        // media/engine/webrtcvideoengine2.cc from webrtc.org
+        let pixels = resolution.width * resolution.height;
+        if (pixels <= 320 * 240) {
+            target = 600;
+        } else if (pixels <= 640 * 480) {
+            target =  1700;
+        } else if (pixels <= 960 * 540) {
+            target = 2000;
+        } else {
+            target = 2500;
+        }
+    }
+
+    // Allow for an additional 1 second for ramp up -- delay any initial drop
+    // of connection quality by 1 second.
+    return Math.min(target, rampUp(Math.max(0, millisSinceStart - 1000)));
+}
+
+/**
+ * Gets the bitrate to which GCC would have ramped up in perfect network
+ * conditions after millisSinceStart milliseconds.
+ * @param millisSinceStart {number} the number of milliseconds since sending
+ * video was enabled.
+ */
+function rampUp(millisSinceStart) {
+    if (millisSinceStart > 60000) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    // According to GCC the send side bandwidth estimation grows with at most
+    // 8% per second.
+    // https://tools.ietf.org/html/draft-ietf-rmcat-gcc-02#section-5.5
+    return startBitrate * Math.pow(1.08, millisSinceStart / 1000);
+}
+
+/**
+ * A class which monitors the local statistics coming from the RTC modules, and
+ * calculates a "connection quality" value, in percent, for the media
+ * connection. A value of 100% indicates a very good network connection, and a
+ * value of 0% indicates a poor connection.
+ */
+export default class ConnectionQuality {
+    constructor(conference, eventEmitter, options) {
+        this.eventEmitter = eventEmitter;
+
+        /**
+         * The owning JitsiConference.
+         */
+        this._conference = conference;
+
+        /**
+         * Whether simulcast is supported. Note that even if supported, it is
+         * currently not used for screensharing, which is why we have an
+         * additional check.
+         */
+        this._simulcast
+            = !options.disableSimulcast && RTCBrowserType.supportsSimulcast();
+
+        /**
+         * Holds statistics about the local connection quality.
+         */
+        this._localStats = {connectionQuality: 100};
+
+        /**
+         * The time this._localStats.connectionQuality was last updated.
+         */
+        this._lastConnectionQualityUpdate = -1;
+
+        /**
+         * Maps a participant ID to an object holding connection quality
+         * statistics received from this participant.
+         */
+        this._remoteStats = {};
+
+        /**
+         * The time that the ICE state last changed to CONNECTED. We use this
+         * to calculate how much time we as a sender have had to ramp-up.
+         */
+        this._timeIceConnected = -1;
+
+        /**
+         * The time that local video was unmuted. We use this to calculate how
+         * much time we as a sender have had to ramp-up.
+         */
+        this._timeVideoUnmuted = -1;
+
+
+        // We assume a global startBitrate value for the sake of simplicity.
+        if (options.startBitrate && options.startBitrate > 0) {
+            startBitrate = options.startBitrate;
+        }
+
+        // TODO: consider ignoring these events and letting the user of
+        // lib-jitsi-meet handle these separately.
+        conference.on(
+            ConferenceEvents.CONNECTION_INTERRUPTED,
+            () => {
+                this._updateLocalConnectionQuality(0);
+                this.eventEmitter.emit(
+                    ConnectionQualityEvents.LOCAL_STATS_UPDATED,
+                    this._localStats);
+                this._broadcastLocalStats();
+            });
+
+        conference.room.addListener(
+            XMPPEvents.ICE_CONNECTION_STATE_CHANGED,
+            (newState) => {
+                if (newState === 'connected') {
+                    this._timeIceConnected = window.performance.now();
+                }
+            });
+
+        // Listen to DataChannel message from other participants in the
+        // conference, and update the _remoteStats field accordingly.
+        conference.on(
+            ConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
+            (participant, payload) => {
+                if (payload.type === STATS_MESSAGE_TYPE) {
+                    this._updateRemoteStats(
+                        participant.getId(), payload.values);
+                }
+        });
+
+        // Listen to local statistics events originating from the RTC module
+        // and update the _localStats field.
+        // Oh, and by the way, the resolutions of all remote participants are
+        // also piggy-backed in these "local" statistics. It's obvious, really,
+        // if one carefully reads the *code* (but not the docs) in
+        // UI/VideoLayout/VideoLayout.js#updateLocalConnectionStats in
+        // jitsi-meet
+        // TODO: We should keep track of the remote resolution in _remoteStats,
+        // and notify about changes via separate events.
+        conference.on(
+            ConferenceEvents.CONNECTION_STATS,
+            this._updateLocalStats.bind(this));
+
+        // Save the last time we were unmuted.
+        conference.on(
+            ConferenceEvents.TRACK_MUTE_CHANGED,
+            (track) => {
+                if (track.isVideoTrack()) {
+                    if (track.isMuted()) {
+                        this._timeVideoUnmuted = -1;
+                    } else {
+                        this._maybeUpdateUnmuteTime();
+                    }
+                }
+            });
+        conference.on(
+            ConferenceEvents.TRACK_ADDED,
+            (track) => {
+                if (track.isVideoTrack() && !track.isMuted())
+                {
+                    this._maybeUpdateUnmuteTime();
+                }
+            });
+    }
+
+    /**
+     * Sets _timeVideoUnmuted if it was previously unset. If it was already set,
+     * doesn't change it.
+     */
+    _maybeUpdateUnmuteTime() {
+        if (this._timeVideoUnmuted < 0) {
+            this._timeVideoUnmuted = window.performance.now();
+        }
+    }
+
+    /**
+     * Calculates a new "connection quality" value.
+     * @param videoType {VideoType} the type of the video source (camera or
+     * a screen capture).
+     * @param isMuted {boolean} whether the local video is muted.
+     * @param resolutionName {Resolution} the input resolution used by the
+     * camera.
+     * @returns {*} the newly calculated connection quality.
+     */
+    _calculateConnectionQuality(videoType, isMuted, resolutionName) {
+
+        // resolutionName is an index into Resolutions (where "720" is
+        // "1280x720" and "960" is "960x720" ...).
+        let resolution = Resolutions[resolutionName];
+
+        let quality = 100;
+        let packetLoss;
+        // TODO: take into account packet loss for received streams
+        if (this._localStats.packetLoss) {
+            packetLoss = this._localStats.packetLoss.upload;
+
+            // Ugly Hack Alert (UHA):
+            // The packet loss for the upload direction is calculated based on
+            // incoming RTCP Receiver Reports. Since we don't have RTCP
+            // termination for audio, these reports come from the actual
+            // receivers in the conference and therefore the reported packet
+            // loss includes loss from the bridge to the receiver.
+            // When we are sending video this effect is small, because the
+            // number of video packets is much larger than the number of audio
+            // packets (and our calculation is based on the total number of
+            // received and lost packets).
+            // When video is muted, however, the effect might be significant,
+            // but we don't know what it is. We do know that it is positive, so
+            // as a temporary solution, until RTCP termination is implemented
+            // for the audio streams, we relax the packet loss checks here.
+            if (isMuted) {
+                packetLoss *= 0.5;
+            }
+        }
+
+        if (isMuted || !resolution || videoType === VideoType.DESKTOP
+            || this._timeIceConnected < 0
+            || this._timeVideoUnmuted < 0) {
+
+            // Calculate a value based on packet loss only.
+            if (packetLoss === undefined) {
+                logger.error("Cannot calculate connection quality, unknown "
+                    + "packet loss.");
+                quality = 100;
+            } else if (packetLoss <= 2) {
+                quality = 100; // Full 5 bars.
+            } else if (packetLoss <= 4) {
+                quality = 70; // 4 bars
+            } else if (packetLoss <= 6) {
+                quality = 50; // 3 bars
+            } else if (packetLoss <= 8) {
+                quality = 30; // 2 bars
+            } else if (packetLoss <= 12) {
+                quality = 10; // 1 bars
+            } else {
+                quality = 0; // Still 1 bar, but slower climb-up.
+            }
+        } else {
+            // Calculate a value based on the sending bitrate.
+
+            // time since sending of video was enabled.
+            let millisSinceStart = window.performance.now()
+                    - Math.max(this._timeVideoUnmuted, this._timeIceConnected);
+
+            // expected sending bitrate in perfect conditions
+            let target
+                = getTarget(this._simulcast, resolution, millisSinceStart);
+            target = 0.9 * target;
+
+            quality = 100 * this._localStats.bitrate.upload / target;
+
+            // Whatever the bitrate, drop early if there is significant loss
+            if (packetLoss && packetLoss >= 10) {
+                quality = Math.min(quality, 30);
+            }
+        }
+
+        // Make sure that the quality doesn't climb quickly
+        if (this._lastConnectionQualityUpdate > 0)
+        {
+            let maxIncreasePerSecond = 2;
+            let prevConnectionQuality = this._localStats.connectionQuality;
+            let diffSeconds
+                = (window.performance.now()
+                    - this._lastConnectionQualityUpdate) / 1000;
+            quality = Math.min(
+                quality,
+                prevConnectionQuality + diffSeconds * maxIncreasePerSecond);
+        }
+
+        return Math.min(100, quality);
+    }
+
+    /**
+     * Updates the localConnectionQuality value
+     * @param values {number} the new value. Should be in [0, 100].
+     */
+    _updateLocalConnectionQuality(value) {
+        this._localStats.connectionQuality = value;
+        this._lastConnectionQualityUpdate = window.performance.now();
+    }
+
+    /**
+     * Broadcasts the local statistics to all other participants in the
+     * conference.
+     */
+    _broadcastLocalStats() {
+        // Send only the data that remote participants care about.
+        let data = {
+            bitrate: this._localStats.bitrate,
+            packetLoss: this._localStats.packetLoss,
+            connectionQuality: this._localStats.connectionQuality
+        };
+
+        // TODO: It looks like the remote participants don't really "care"
+        // about the resolution, and they look at their local rendered
+        // resolution instead. Consider removing this.
+        let localVideoTrack
+            = this._conference.getLocalTracks(MediaType.VIDEO)
+                .find(track => track.isVideoTrack());
+        if (localVideoTrack && localVideoTrack.resolution) {
+            data.resolution = localVideoTrack.resolution;
+        }
+
+        try {
+            this._conference.broadcastEndpointMessage({
+                type: STATS_MESSAGE_TYPE,
+                values: data });
+        } catch (e) {
+            // We often hit this in the beginning of a call, before the data
+            // channel is ready. It is not a big problem, because we will
+            // send the statistics again after a few seconds, and the error is
+            // already logged elsewhere. So just ignore it.
+
+            //let errorMsg = "Failed to broadcast local stats";
+            //logger.error(errorMsg, e);
+            //GlobalOnErrorHandler.callErrorHandler(
+            //    new Error(errorMsg + ": " + e));
+        }
+    }
+
+    /**
+     * Updates the local statistics
+     * @param data new statistics
+     */
+    _updateLocalStats(data) {
+        let key;
+        let updateLocalConnectionQuality
+            = !this._conference.isConnectionInterrupted();
+        let localVideoTrack =
+                this._conference.getLocalTracks(MediaType.VIDEO)
+                    .find(track => track.isVideoTrack());
+        let videoType = localVideoTrack ? localVideoTrack.videoType : undefined;
+        let isMuted = localVideoTrack ? localVideoTrack.isMuted() : true;
+        let resolution = localVideoTrack ? localVideoTrack.resolution : null;
+
+        if (!isMuted) {
+            this._maybeUpdateUnmuteTime();
+        }
+
+        // Copy the fields already in 'data'.
+        for (key in data) {
+            if (data.hasOwnProperty(key)) {
+                this._localStats[key] = data[key];
+            }
+        }
+
+        // And re-calculate the connectionQuality field.
+        if (updateLocalConnectionQuality) {
+            this._updateLocalConnectionQuality(
+                this._calculateConnectionQuality(
+                    videoType,
+                    isMuted,
+                    resolution));
+        }
+
+        this.eventEmitter.emit(
+            ConnectionQualityEvents.LOCAL_STATS_UPDATED,
+            this._localStats);
+        this._broadcastLocalStats();
+    }
+
+    /**
+     * Updates remote statistics
+     * @param id the id of the remote participant
+     * @param data the statistics received
+     */
+    _updateRemoteStats(id, data) {
+            // Use only the fields we need
+            this._remoteStats[id] = {
+                bitrate: data.bitrate,
+                packetLoss: data.packetLoss,
+                connectionQuality: data.connectionQuality
+            };
+
+            this.eventEmitter.emit(
+                ConnectionQualityEvents.REMOTE_STATS_UPDATED,
+                id,
+                this._remoteStats[id]);
+    }
+
+    /**
+     * Returns the local statistics.
+     * Exported only for use in jitsi-meet-torture.
+     */
+    getStats() {
+        return this._localStats;
+    }
+}

modules/connectivity/ParticipantConnectionStatus.js

+/* global __filename, module, require */
+var logger = require('jitsi-meet-logger').getLogger(__filename);
+var MediaType = require('../../service/RTC/MediaType');
+var RTCBrowserType = require('../RTC/RTCBrowserType');
+var RTCEvents = require('../../service/RTC/RTCEvents');
+
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import * as JitsiTrackEvents from '../../JitsiTrackEvents';
+import Statistics from '../statistics/statistics';
+
+/**
+ * Default value of 2000 milliseconds for
+ * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
+ *
+ * @type {number}
+ */
+const DEFAULT_RTC_MUTE_TIMEOUT = 2000;
+
+/**
+ * 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 {JitsiConference} conference parent conference instance
+     * @param {number} rtcMuteTimeout (optional) custom value for
+     * {@link ParticipantConnectionStatus.rtcMuteTimeout}.
+     */
+    constructor(rtc, conference, rtcMuteTimeout) {
+        this.rtc = rtc;
+        this.conference = conference;
+        /**
+         * A map of the "endpoint ID"(which corresponds to the resource part
+         * of MUC JID(nickname)) to the timeout callback IDs scheduled using
+         * window.setTimeout.
+         * @type {Object.<string, number>}
+         */
+        this.trackTimers = {};
+        /**
+         * This map holds the endpoint connection status received from the JVB
+         * (as it might be different than the one stored in JitsiParticipant).
+         * Required for getting back in sync when remote video track is removed.
+         * @type {Object.<string, boolean>}
+         */
+        this.rtcConnStatusCache = { };
+        /**
+         * How long we're going to wait after the RTC video track muted event
+         * for the corresponding signalling mute event, before the connection
+         * interrupted is fired. The default value is
+         * {@link DEFAULT_RTC_MUTE_TIMEOUT}.
+         *
+         * @type {number} amount of time in milliseconds
+         */
+        this.rtcMuteTimeout
+            = typeof rtcMuteTimeout === 'number'
+                ? rtcMuteTimeout : DEFAULT_RTC_MUTE_TIMEOUT;
+        logger.info("RtcMuteTimeout set to: " + this.rtcMuteTimeout);
+    }
+
+    /**
+     * Initializes <tt>ParticipantConnectionStatus</tt> and bind required event
+     * listeners.
+     */
+    init() {
+
+        this._onEndpointConnStatusChanged
+            = this.onEndpointConnStatusChanged.bind(this);
+
+        this.rtc.addListener(
+            RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
+            this._onEndpointConnStatusChanged);
+
+        // On some browsers MediaStreamTrack trigger "onmute"/"onunmute"
+        // events for video type tracks when they stop receiving data which is
+        // often a sign that remote user is having connectivity issues
+        if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+
+            this._onTrackRtcMuted = this.onTrackRtcMuted.bind(this);
+            this.rtc.addListener(
+                RTCEvents.REMOTE_TRACK_MUTE, this._onTrackRtcMuted);
+
+            this._onTrackRtcUnmuted = this.onTrackRtcUnmuted.bind(this);
+            this.rtc.addListener(
+                RTCEvents.REMOTE_TRACK_UNMUTE, this._onTrackRtcUnmuted);
+
+            // Track added/removed listeners are used to bind "mute"/"unmute"
+            // event handlers
+            this._onRemoteTrackAdded = this.onRemoteTrackAdded.bind(this);
+            this.conference.on(
+                JitsiConferenceEvents.TRACK_ADDED,
+                this._onRemoteTrackAdded);
+
+            this._onRemoteTrackRemoved = this.onRemoteTrackRemoved.bind(this);
+            this.conference.on(
+                JitsiConferenceEvents.TRACK_REMOVED,
+                this._onRemoteTrackRemoved);
+
+            // Listened which will be bound to JitsiRemoteTrack to listen for
+            // signalling mute/unmute events.
+            this._onSignallingMuteChanged
+                = this.onSignallingMuteChanged.bind(this);
+        }
+    }
+
+    /**
+     * Removes all event listeners and disposes of all resources held by this
+     * instance.
+     */
+    dispose() {
+
+        this.rtc.removeListener(
+            RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
+            this._onEndpointConnStatusChanged);
+
+        if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+            this.rtc.removeListener(
+                RTCEvents.REMOTE_TRACK_MUTE,
+                this._onTrackRtcMuted);
+            this.rtc.removeListener(
+                RTCEvents.REMOTE_TRACK_UNMUTE,
+                this._onTrackRtcUnmuted);
+
+            this.conference.off(
+                JitsiConferenceEvents.TRACK_ADDED,
+                this._onRemoteTrackAdded);
+            this.conference.off(
+                JitsiConferenceEvents.TRACK_REMOVED,
+                this._onRemoteTrackRemoved);
+        }
+
+        Object.keys(this.trackTimers).forEach(function (participantId) {
+            this.clearTimeout(participantId);
+        }.bind(this));
+
+        // Clear RTC connection status cache
+        this.rtcConnStatusCache = {};
+    }
+
+    /**
+     * 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
+     */
+    onEndpointConnStatusChanged(endpointId, isActive) {
+
+        logger.debug(
+            'Detector RTCEvents.ENDPOINT_CONN_STATUS_CHANGED('
+                + Date.now() +'): ' + endpointId + ': ' + isActive);
+
+        // Filter out events for the local JID for now
+        if (endpointId !== this.conference.myUserId()) {
+
+            // Cache the status received received over the data channels, as
+            // it will be needed to verify for out of sync when the remote video
+            // track is being removed.
+            this.rtcConnStatusCache[endpointId] = isActive;
+
+            var participant = this.conference.getParticipantById(endpointId);
+            // Delay the 'active' event until the video track gets
+            // the RTC unmuted event
+            if (isActive
+                    && RTCBrowserType.isVideoMuteOnConnInterruptedSupported()
+                    && participant
+                    && participant.hasAnyVideoTrackWebRTCMuted()
+                    && !participant.isVideoMuted()) {
+                logger.debug(
+                    'Ignoring RTCEvents.ENDPOINT_CONN_STATUS_CHANGED -'
+                        + ' will wait for unmute event');
+            } else {
+                this._changeConnectionStatus(endpointId, isActive);
+            }
+        }
+    }
+
+    _changeConnectionStatus(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);
+
+            // Log the event on CallStats
+            Statistics.sendLog(
+                JSON.stringify({
+                    id: 'peer.conn.status',
+                    participant: endpointId,
+                    status: newStatus
+                }));
+
+            // and analytics
+            Statistics.analytics.sendEvent('peer.conn.status',
+                {label: newStatus});
+
+            this.conference.eventEmitter.emit(
+                JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
+                endpointId, newStatus);
+        }
+    }
+
+    /**
+     * 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
+     * interrupted" timeout was scheduled
+     */
+    clearTimeout(participantId) {
+        if (this.trackTimers[participantId]) {
+            window.clearTimeout(this.trackTimers[participantId]);
+            this.trackTimers[participantId] = null;
+        }
+    }
+
+    /**
+     * Bind signalling mute event listeners for video {JitsiRemoteTrack} when
+     * a new one is added to the conference.
+     *
+     * @param {JitsiTrack} remoteTrack the {JitsiTrack} which is being added to
+     * the conference.
+     */
+    onRemoteTrackAdded(remoteTrack) {
+        if (!remoteTrack.isLocal()
+                && remoteTrack.getType() === MediaType.VIDEO) {
+
+            logger.debug(
+                'Detector on remote track added for: '
+                    + remoteTrack.getParticipantId());
+
+            remoteTrack.on(
+                JitsiTrackEvents.TRACK_MUTE_CHANGED,
+                this._onSignallingMuteChanged);
+        }
+    }
+
+    /**
+     * Removes all event listeners bound to the remote video track and clears
+     * any related timeouts.
+     *
+     * @param {JitsiRemoteTrack} remoteTrack the remote track which is being
+     * removed from the conference.
+     */
+    onRemoteTrackRemoved(remoteTrack) {
+        if (!remoteTrack.isLocal()
+                && remoteTrack.getType() === MediaType.VIDEO) {
+
+            const endpointId = remoteTrack.getParticipantId();
+
+            logger.debug(
+                'Detector on remote track removed: ' + endpointId);
+
+            remoteTrack.off(
+                JitsiTrackEvents.TRACK_MUTE_CHANGED,
+                this._onSignallingMuteChanged);
+
+            this.clearTimeout(endpointId);
+
+            // Only if we're using video muted events - check if the JVB status
+            // should be restored from cache.
+            if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported())
+            {
+                this.maybeRestoreCachedStatus(endpointId);
+            }
+        }
+    }
+
+    /**
+     * When RTC video track muted events are taken into account,
+     * at the point when the track is being removed we have to update
+     * to the current connectivity status according to the JVB. That's
+     * because if the current track is muted then the new one which
+     * replaces it is always added as unmuted and there may be no
+     * 'muted'/'unmuted' event sequence if the connection restores in
+     * the meantime.
+     *
+     * XXX See onEndpointConnStatusChanged method where the update is
+     * postponed and which is the cause for this workaround. If we
+     * decide to not wait for video unmuted event and accept the JVB
+     * status immediately then it's fine to remove the code below.
+     */
+    maybeRestoreCachedStatus(endpointId) {
+        var participant = this.conference.getParticipantById(endpointId);
+        if (!participant) {
+            // Probably the participant is no longer in the conference
+            // (at the time of writing this code, participant is
+            // detached from the conference and TRACK_REMOVED events are
+            // fired),
+            // so we don't care, but let's print the warning for
+            // debugging purpose
+            logger.warn(
+                'maybeRestoreCachedStatus - ' +
+                'no participant for endpoint: ' + endpointId);
+            return;
+        }
+
+        const isConnectionActive = participant.isConnectionActive();
+        const hasAnyVideoRTCMuted = participant.hasAnyVideoTrackWebRTCMuted();
+        let isConnActiveByJvb = this.rtcConnStatusCache[endpointId];
+
+        // If no status was received from the JVB it means that it's active
+        // (the bridge does not send notification unless there is a problem).
+        if (typeof isConnActiveByJvb !== 'boolean') {
+            logger.debug("Assuming connection active by JVB - no notification");
+            isConnActiveByJvb = true;
+        }
+
+        logger.debug(
+            "Remote track removed, is active: " + isConnectionActive
+            + " is active(jvb):" + isConnActiveByJvb
+            + " video RTC muted:" + hasAnyVideoRTCMuted);
+
+        if (!isConnectionActive && isConnActiveByJvb && !hasAnyVideoRTCMuted) {
+            // FIXME adjust the log level or remove the message completely once
+            // the feature gets mature enough.
+            logger.info(
+                "Remote track removed for disconnected" +
+                " participant, when the status according to" +
+                " the JVB is connected. Adjusting to the JVB value.");
+            this._changeConnectionStatus(endpointId, isConnActiveByJvb);
+        }
+    }
+
+    /**
+     * Handles RTC 'onmute' event for the video track.
+     *
+     * @param {JitsiRemoteTrack} track the video track for which 'onmute' event
+     * will be processed.
+     */
+    onTrackRtcMuted(track) {
+        var participantId = track.getParticipantId();
+        var participant = this.conference.getParticipantById(participantId);
+        logger.debug('Detector track RTC muted: ' + participantId);
+        if (!participant) {
+            logger.error('No participant for id: ' + participantId);
+            return;
+        }
+        if (!participant.isVideoMuted()) {
+            // If the user is not muted according to the signalling we'll give
+            // it some time, before the connection interrupted event is
+            // triggered.
+            this.trackTimers[participantId] = window.setTimeout(function () {
+                if (!track.isMuted() && participant.isConnectionActive()) {
+                    logger.info(
+                        'Connection interrupted through the RTC mute: '
+                            + participantId, Date.now());
+                    this._changeConnectionStatus(participantId, false);
+                }
+                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.
+     */
+    onTrackRtcUnmuted(track) {
+        logger.debug('Detector track RTC unmuted: ', track);
+        var participantId = track.getParticipantId();
+        if (!track.isMuted() &&
+            !this.conference.getParticipantById(participantId)
+                .isConnectionActive()) {
+            logger.info(
+                'Detector connection restored through the RTC unmute: '
+                    + participantId, Date.now());
+            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.
+     */
+    onSignallingMuteChanged (track) {
+        logger.debug(
+            'Detector on track signalling mute changed: ',
+            track, track.isMuted());
+        var isMuted = track.isMuted();
+        var participantId = track.getParticipantId();
+        var participant = this.conference.getParticipantById(participantId);
+        if (!participant) {
+            logger.error('No participant for id: ' + participantId);
+            return;
+        }
+        var isConnectionActive = participant.isConnectionActive();
+        if (isMuted && isConnectionActive && this.trackTimers[participantId]) {
+            logger.debug(
+                'Signalling got in sync - cancelling task for: '
+                    + participantId);
+            this.clearTimeout(participantId);
+        }
+    }
+
+}

modules/statistics/AnalyticsAdapter.js

+var RTCBrowserType = require("../RTC/RTCBrowserType");
+
+function NoopAnalytics() {}
+NoopAnalytics.prototype.sendEvent = function () {};
+
+function AnalyticsAdapter() {
+    this.browserName = RTCBrowserType.getBrowserName();
+    /**
+     * Map of properties that will be added to every event
+     */
+    this.permanentProperties = {};
+}
+
+// some events may happen before init or implementation script download
+// in this case we accumulate them in this array and send them on init
+AnalyticsAdapter.eventsQueue = [];
+
+/**
+ * Sends analytics event.
+ * @param {String} action the name of the event
+ * @param {Object} data can be any JSON object
+ */
+AnalyticsAdapter.prototype.sendEvent = function (action, data = {}) {
+    if(this._checkAnalyticsAndMaybeCacheEvent(action, data)) {
+        data.browserName = this.browserName;
+        try {
+            this.analytics.sendEvent(action,
+                Object.assign({}, this.permanentProperties, data));
+        } catch (ignored) { // eslint-disable-line no-empty
+        }
+    }
+};
+
+/**
+ * Since we asynchronously load the integration of the analytics API and the
+ * analytics API may asynchronously load its implementation (e.g. Google
+ * Analytics), we cannot make the decision with respect to which analytics
+ * implementation we will use here and we have to postpone it i.e. we will make
+ * a lazy decision, will wait for loaded or dispose methods to be called.
+ * in the meantime we accumulate any events received. We should call this
+ * method before trying to send the event.
+ * @param action
+ * @param data
+ */
+AnalyticsAdapter.prototype._checkAnalyticsAndMaybeCacheEvent
+= function (action, data) {
+    if (this.analytics === null || typeof this.analytics === 'undefined') {
+        // missing this.analytics but have window implementation, let's use it
+        if (window.Analytics) {
+            this.loaded();
+        }
+        else {
+            AnalyticsAdapter.eventsQueue.push({
+                action: action,
+                data: data
+            });
+            // stored, lets break here
+            return false;
+        }
+    }
+    return true;
+};
+
+
+/**
+ * Dispose analytics. Clears any available queue element and sets
+ * NoopAnalytics to be used.
+ */
+AnalyticsAdapter.prototype.dispose = function () {
+    this.analytics = new NoopAnalytics();
+    AnalyticsAdapter.eventsQueue.length = 0;
+};
+
+/**
+ * Adds map of properties that will be added to every event.
+ * @param {Object} properties the map of properties
+ */
+AnalyticsAdapter.prototype.addPermanentProperties = function (properties) {
+    this.permanentProperties
+        = Object.assign(this.permanentProperties, properties);
+};
+
+/**
+ * Loaded analytics script. Sens queued events.
+ */
+AnalyticsAdapter.prototype.loaded = function () {
+    var AnalyticsImpl = window.Analytics || NoopAnalytics;
+
+    this.analytics = new AnalyticsImpl();
+
+    // new analytics lets send all events if any
+    if (AnalyticsAdapter.eventsQueue.length) {
+        AnalyticsAdapter.eventsQueue.forEach(function (event) {
+            this.sendEvent(event.action, event.data);
+        }.bind(this));
+        AnalyticsAdapter.eventsQueue.length = 0;
+    }
+};
+
+module.exports = new AnalyticsAdapter();

modules/statistics/CallStats.js

 
 var callStats = null;
 
+/**
+ * The user id to report to callstats as destination.
+ * @type {string}
+ */
+const DEFAULT_REMOTE_USER = "jitsi";
+
 function initCallback (err, msg) {
     logger.log("CallStats Status: err=" + err + " msg=" + msg);
 
+    CallStats.initializeInProgress = false;
+
     // there is no lib, nothing to report to
-    if (err !== 'success')
+    if (err !== 'success') {
+        CallStats.initializeFailed = true;
         return;
-
-    CallStats.initialized = true;
+    }
 
     var ret = callStats.addNewFabric(this.peerconnection,
-        Strophe.getResourceFromJid(this.session.peerjid),
+        DEFAULT_REMOTE_USER,
         callStats.fabricUsage.multiplex,
         this.confID,
         this.pcCallback.bind(this));
 
     var fabricInitialized = (ret.status === 'success');
 
-    if(!fabricInitialized)
-        console.log("callstats fabric not initilized", ret.message);
+    if(!fabricInitialized) {
+        CallStats.initializeFailed = true;
+        logger.log("callstats fabric not initilized", ret.message);
+        return;
+    }
+
+    CallStats.initializeFailed = false;
+    CallStats.initialized = true;
+    CallStats.feedbackEnabled = true;
 
     // notify callstats about failures if there were any
     if (CallStats.reportsQueue.length) {
  */
 var CallStats = _try_catch(function(jingleSession, Settings, options) {
     try{
-        //check weather that should work with more than 1 peerconnection
-        if(!callStats) {
-            callStats = new callstats($, io, jsSHA);
-        } else {
-            return;
-        }
+        CallStats.feedbackEnabled = false;
+        callStats = new callstats($, io, jsSHA); // eslint-disable-line new-cap
 
-        this.session = jingleSession;
         this.peerconnection = jingleSession.peerconnection.peerconnection;
 
-        this.userID = Settings.getCallStatsUserName();
-
+        this.userID = {
+            aliasName: Strophe.getResourceFromJid(jingleSession.room.myroomjid),
+            userName: Settings.getCallStatsUserName()
+        };
+        
         // The confID is case sensitive!!!
         this.confID = options.callStatsConfIDNamespace + "/" + options.roomName;
 
+        this.callStatsID = options.callStatsID;
+        this.callStatsSecret = options.callStatsSecret;
+
+        CallStats.initializeInProgress = true;
         //userID is generated or given by the origin server
-        callStats.initialize(options.callStatsID,
-            options.callStatsSecret,
+        callStats.initialize(this.callStatsID,
+            this.callStatsSecret,
             this.userID,
             initCallback.bind(this));
 
     } catch (e) {
-        // The callstats.io API failed to initialize (e.g. because its
-        // download failed to succeed in general or on time). Further
-        // attempts to utilize it cannot possibly succeed.
+        // The callstats.io API failed to initialize (e.g. because its download
+        // did not succeed in general or on time). Further attempts to utilize
+        // it cannot possibly succeed.
         GlobalOnErrorHandler.callErrorHandler(e);
         callStats = null;
         logger.error(e);
  */
 CallStats.initialized = false;
 
+/**
+ * Whether we are in progress of initializing.
+ * @type {boolean}
+ */
+CallStats.initializeInProgress = false;
+
+/**
+ * Whether we tried to initialize and it failed.
+ * @type {boolean}
+ */
+CallStats.initializeFailed = false;
+
+/**
+ * Shows weather sending feedback is enabled or not
+ * @type {boolean}
+ */
+CallStats.feedbackEnabled = false;
+
+/**
+ * Checks whether we need to re-initialize callstats and starts the process.
+ * @private
+ */
+CallStats._checkInitialize = function () {
+    if (CallStats.initialized || !CallStats.initializeFailed
+        || !callStats || CallStats.initializeInProgress)
+        return;
+
+    // callstats object created, not initialized and it had previously failed,
+    // and there is no init in progress, so lets try initialize it again
+    CallStats.initializeInProgress = true;
+    callStats.initialize(
+        callStats.callStatsID,
+        callStats.callStatsSecret,
+        callStats.userID,
+        initCallback.bind(callStats));
+};
+
 /**
  * Type of pending reports, can be event or an error.
  * @type {{ERROR: string, EVENT: string}}
 };
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
-    if (!callStats) {
-        return;
-    }
-    logger.log("Monitoring status: "+ err + " msg: " + msg);
+    if (callStats && err !== 'success')
+        logger.error("Monitoring status: "+ err + " msg: " + msg);
 });
 
 /**
     if(!callStats) {
         return;
     }
+
     // 'focus' is default remote user ID for now
-    var callStatsId = 'focus';
-    if (isLocal) {
-        callStatsId = this.userID;
-    }
+    const callStatsId = isLocal ? this.userID : 'focus';
 
     _try_catch(function() {
         logger.debug(
             this.confID,
             ssrc,
             usageLabel,
-            containerId
-        );
+            containerId);
         if(CallStats.initialized) {
             callStats.associateMstWithUserID(
                 this.peerconnection,
                 this.confID,
                 ssrc,
                 usageLabel,
-                containerId
-            );
+                containerId);
         }
         else {
             CallStats.reportsQueue.push({
                 type: reportType.MST_WITH_USERID,
                 data: {
-                    callStatsId: callStatsId,
-                    ssrc: ssrc,
-                    usageLabel: usageLabel,
-                    containerId: containerId
+                    callStatsId,
+                    containerId,
+                    ssrc,
+                    usageLabel
                 }
             });
+            CallStats._checkInitialize();
         }
     }).bind(this)();
 };
  * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendMuteEvent = _try_catch(function (mute, type, cs) {
+    let event;
 
-    var event = null;
     if (type === "video") {
-        event = (mute? fabricEvent.videoPause : fabricEvent.videoResume);
-    }
-    else {
-        event = (mute? fabricEvent.audioMute : fabricEvent.audioUnmute);
+        event = mute ? fabricEvent.videoPause : fabricEvent.videoResume;
+    } else {
+        event = mute ? fabricEvent.audioMute : fabricEvent.audioUnmute;
     }
 
     CallStats._reportEvent.call(cs, event);
  * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendScreenSharingEvent = _try_catch(function (start, cs) {
-
-    CallStats._reportEvent.call(cs,
-        start? fabricEvent.screenShareStart : fabricEvent.screenShareStop);
+    CallStats._reportEvent.call(
+        cs,
+        start ? fabricEvent.screenShareStart : fabricEvent.screenShareStop);
 });
 
 /**
  * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendDominantSpeakerEvent = _try_catch(function (cs) {
-
-    CallStats._reportEvent.call(cs,
-        fabricEvent.dominantSpeaker);
+    CallStats._reportEvent.call(cs, fabricEvent.dominantSpeaker);
 });
 
 /**
  * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendActiveDeviceListEvent = _try_catch(function (devicesData, cs) {
-
     CallStats._reportEvent.call(cs, fabricEvent.activeDeviceList, devicesData);
 });
 
                 type: reportType.EVENT,
                 data: {event: event, eventData: eventData}
             });
+        CallStats._checkInitialize();
     }
 };
 
         callStats.fabricEvent.fabricTerminated, this.confID);
 });
 
-/**
- * Notifies CallStats that audio problems are detected.
- *
- * @param {Error} e error to send
- * @param {CallStats} cs callstats instance related to the error (optional)
- */
-CallStats.prototype.sendDetectedAudioProblem = _try_catch(function (e) {
-    CallStats._reportError.call(this, wrtcFuncNames.signalingError, e,
-        this.peerconnection);
-});
-
-
 /**
  * Notifies CallStats for ice connection failed
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 CallStats.prototype.sendFeedback = _try_catch(
 function(overallFeedback, detailedFeedback) {
-    if(!CallStats.initialized) {
+    if(!CallStats.feedbackEnabled) {
         return;
     }
-    var feedbackString =    '{"userID":"' + this.userID + '"' +
-                            ', "overall":' + overallFeedback +
-                            ', "comment": "' + detailedFeedback + '"}';
 
-    var feedbackJSON = JSON.parse(feedbackString);
-
-    callStats.sendUserFeedback(this.confID, feedbackJSON);
+    callStats.sendUserFeedback(this.confID, {
+        userID: this.userID,
+        overall: overallFeedback,
+        comment: detailedFeedback
+    });
 });
 
 /**
             type: reportType.ERROR,
             data: { type: type, error: e, pc: pc}
         });
+        CallStats._checkInitialize();
     }
     // else just ignore it
 };
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
 CallStats.sendApplicationLog = _try_catch(function (e, cs) {
-    CallStats._reportError
-        .call(cs, wrtcFuncNames.applicationLog, e, null);
+    CallStats._reportError.call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 
+/**
+ * Clears allocated resources.
+ */
+CallStats.dispose = function () {
+    // The next line is commented because we need to be able to send feedback
+    // even after the conference has been destroyed.
+    // callStats = null;
+    CallStats.initialized = false;
+    CallStats.initializeFailed = false;
+    CallStats.initializeInProgress = false;
+};
+
 module.exports = CallStats;

modules/statistics/LocalStatsCollector.js

-/* global config */
 /**
  * Provides statistics for the local stream.
  */

modules/statistics/RTPStatsCollector.js

 /* global require */
-/* jshint -W101 */
 
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType");
-var StatisticsEvents = require("../../service/statistics/Events");
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+import * as StatisticsEvents from "../../service/statistics/Events";
 
 /* Whether we support the browser we are running into for logging statistics */
 var browserSupported = RTCBrowserType.isChrome() ||
-        RTCBrowserType.isOpera() || RTCBrowserType.isFirefox();
+        RTCBrowserType.isOpera() || RTCBrowserType.isFirefox() ||
+        RTCBrowserType.isNWJS();
 
 /**
  * The LibJitsiMeet browser-agnostic names of the browser-specific keys reported
 };
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_OPERA] =
     KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_NWJS] =
+    KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_IEXPLORER] =
     KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_SAFARI] =
     return Math.round((lostPackets/totalPackets)*100);
 }
 
-function formatAudioLevel(audioLevel) {
-    return Math.min(Math.max(audioLevel, 0), 1);
-}
-
 /**
  * Checks whether a certain record should be included in the logged statistics.
  */
 }
 
 /**
- * Peer statistics data holder.
+ * Holds "statistics" for a single SSRC.
  * @constructor
  */
-function PeerStats() {
-    this.ssrc2Loss = {};
-    this.ssrc2AudioLevel = {};
-    this.ssrc2bitrate = {
+function SsrcStats() {
+    this.loss = {};
+    this.bitrate = {
         download: 0,
         upload: 0
     };
-    this.ssrc2resolution = {};
+    this.resolution = {};
 }
 
 /**
- * Sets packets loss rate for given <tt>ssrc</tt> that belong to the peer
- * represented by this instance.
- * @param lossRate new packet loss rate value to be set.
+ * Sets the "loss" object.
+ * @param loss the value to set.
  */
-PeerStats.prototype.setSsrcLoss = function (lossRate) {
-    this.ssrc2Loss = lossRate || {};
+SsrcStats.prototype.setLoss = function (loss) {
+    this.loss = loss || {};
 };
 
 /**
- * Sets resolution that belong to the ssrc
- * represented by this instance.
+ * Sets resolution that belong to the ssrc represented by this instance.
  * @param resolution new resolution value to be set.
  */
-PeerStats.prototype.setSsrcResolution = function (resolution) {
-    this.ssrc2resolution = resolution || {};
+SsrcStats.prototype.setResolution = function (resolution) {
+    this.resolution = resolution || {};
 };
 
 /**
- * Sets the bit rate for given <tt>ssrc</tt> that belong to the peer
- * represented by this instance.
- * @param bitrate new bitrate value to be set.
+ * Adds the "download" and "upload" fields from the "bitrate" parameter to
+ * the respective fields of the "bitrate" field of this object.
+ * @param bitrate an object holding the values to add.
  */
-PeerStats.prototype.setSsrcBitrate = function (bitrate) {
-    this.ssrc2bitrate.download += bitrate.download;
-    this.ssrc2bitrate.upload += bitrate.upload;
+SsrcStats.prototype.addBitrate = function (bitrate) {
+    this.bitrate.download += bitrate.download;
+    this.bitrate.upload += bitrate.upload;
 };
 
 /**
  * Resets the bit rate for given <tt>ssrc</tt> that belong to the peer
  * represented by this instance.
  */
-PeerStats.prototype.resetSsrcBitrate = function () {
-    this.ssrc2bitrate.download = 0;
-    this.ssrc2bitrate.upload = 0;
-};
-
-/**
- * Sets new audio level(input or output) for given <tt>ssrc</tt> that identifies
- * the stream which belongs to the peer represented by this instance.
- * @param audioLevel the new audio level value to be set. Value is truncated to
- *        fit the range from 0 to 1.
- */
-PeerStats.prototype.setSsrcAudioLevel = function (audioLevel) {
-    // Range limit 0 - 1
-    this.ssrc2AudioLevel = formatAudioLevel(audioLevel);
+SsrcStats.prototype.resetBitrate = function () {
+    this.bitrate.download = 0;
+    this.bitrate.upload = 0;
 };
 
 function ConferenceStats() {
 /**
  * <tt>StatsCollector</tt> registers for stats updates of given
  * <tt>peerconnection</tt> in given <tt>interval</tt>. On each update particular
- * stats are extracted and put in {@link PeerStats} objects. Once the processing
+ * stats are extracted and put in {@link SsrcStats} objects. Once the processing
  * is done <tt>audioLevelsUpdateCallback</tt> is called with <tt>this</tt>
  * instance as an event source.
  *
  * @param audioLevelsInterval
  * @param statsInterval stats refresh interval given in ms.
  * @param eventEmitter
- * @param config {object} supports the following properties: disableAudioLevels,
- * disableStats, logStats
  * @constructor
  */
 function StatsCollector(
         peerconnection,
         audioLevelsInterval,
         statsInterval,
-        eventEmitter,
-        config) {
+        eventEmitter) {
     // StatsCollector depends entirely on the format of the reports returned by
     // RTCPeerConnection#getStats. Given that the value of
     // RTCBrowserType#getBrowserType() is very unlikely to change at runtime, it
     this.baselineAudioLevelsReport = null;
     this.currentAudioLevelsReport = null;
     this.currentStatsReport = null;
-    this.baselineStatsReport = null;
+    this.previousStatsReport = null;
     this.audioLevelsIntervalId = null;
     this.eventEmitter = eventEmitter;
-    this.config = config || {};
     this.conferenceStats = new ConferenceStats();
 
     /**
 
     this.statsIntervalId = null;
     this.statsIntervalMilis = statsInterval;
-    // Map of ssrcs to PeerStats
+    // Map of ssrcs to SsrcStats
     this.ssrc2stats = {};
 }
 
 /**
  * Starts stats updates.
  */
-StatsCollector.prototype.start = function () {
+StatsCollector.prototype.start = function (startAudioLevelStats) {
     var self = this;
-    this.audioLevelsIntervalId = setInterval(
-        function () {
-            // Interval updates
-            self.peerconnection.getStats(
-                function (report) {
-                    var results = null;
-                    if (!report || !report.result ||
-                        typeof report.result != 'function') {
-                        results = report;
-                    }
-                    else {
-                        results = report.result();
-                    }
-                    self.currentAudioLevelsReport = results;
-                    self.processAudioLevelReport();
-                    self.baselineAudioLevelsReport =
-                        self.currentAudioLevelsReport;
-                },
-                self.errorCallback
-            );
-        },
-        self.audioLevelsIntervalMilis
-    );
+    if(startAudioLevelStats) {
+        this.audioLevelsIntervalId = setInterval(
+            function () {
+                // Interval updates
+                self.peerconnection.getStats(
+                    function (report) {
+                        var results = null;
+                        if (!report || !report.result ||
+                            typeof report.result != 'function') {
+                            results = report;
+                        }
+                        else {
+                            results = report.result();
+                        }
+                        self.currentAudioLevelsReport = results;
+                        self.processAudioLevelReport();
+                        self.baselineAudioLevelsReport =
+                            self.currentAudioLevelsReport;
+                    },
+                    self.errorCallback
+                );
+            },
+            self.audioLevelsIntervalMilis
+        );
+    }
 
-    if (!this.config.disableStats && browserSupported) {
+    if (browserSupported) {
         this.statsIntervalId = setInterval(
             function () {
                 // Interval updates
                             logger.error("Unsupported key:" + e, e);
                         }
 
-                        self.baselineStatsReport = self.currentStatsReport;
+                        self.previousStatsReport = self.currentStatsReport;
                     },
                     self.errorCallback
                 );
         );
     }
 
-    if (this.config.logStats
-            && browserSupported
+    if (browserSupported
             // logging statistics does not support firefox
             && this._browserType !== RTCBrowserType.RTC_BROWSER_FIREFOX) {
         this.gatherStatsIntervalId = setInterval(
     switch (this._browserType) {
     case RTCBrowserType.RTC_BROWSER_CHROME:
     case RTCBrowserType.RTC_BROWSER_OPERA:
+    case RTCBrowserType.RTC_BROWSER_NWJS:
         // TODO What about other types of browser which are based on Chrome such
         // as NW.js? Every time we want to support a new type browser we have to
         // go and add more conditions (here and in multiple other places).
         // example, if item has a stat property of type function, then it's very
         // likely that whoever defined it wanted you to call it in order to
         // retrieve the value associated with a specific key.
-        itemStatByKey = function (item, key) { return item.stat(key) };
+        itemStatByKey = function (item, key) { return item.stat(key); };
         break;
     case RTCBrowserType.RTC_BROWSER_REACT_NATIVE:
         // The implementation provided by react-native-webrtc follows the
         };
         break;
     default:
-        itemStatByKey = function (item, key) { return item[key] };
+        itemStatByKey = function (item, key) { return item[key]; };
     }
 
     // Compose the 2 functions defined above to get a function which retrieves
     // the value from a specific report returned by RTCPeerConnection#getStats
     // associated with a specific LibJitsiMeet browser-agnostic name.
     return function (item, name) {
-        return itemStatByKey(item, keyFromName(name))
+        return itemStatByKey(item, keyFromName(name));
     };
 };
 
  * Stats processing logic.
  */
 StatsCollector.prototype.processStatsReport = function () {
-    if (!this.baselineStatsReport) {
+    if (!this.previousStatsReport) {
         return;
     }
 
     var getStatValue = this._getStatValue;
+    function getNonNegativeStat(report, name) {
+        var value = getStatValue(report, name);
+        if (typeof value !== 'number') {
+            value = Number(value);
+        }
+
+        if (isNaN(value)) {
+            return 0;
+        }
+
+        return Math.max(0, value);
+    }
+    var byteSentStats = {};
 
     for (var idx in this.currentStatsReport) {
         var now = this.currentStatsReport[idx];
             var conferenceStatsTransport = this.conferenceStats.transport;
             if(!conferenceStatsTransport.some(function (t) { return (
                         t.ip == ip && t.type == type && t.localip == localip
-                    )})) {
+                    );})) {
                 conferenceStatsTransport.push(
                     {ip: ip, type: type, localip: localip});
             }
             continue;
         }
 
-        var before = this.baselineStatsReport[idx];
+        var before = this.previousStatsReport[idx];
         var ssrc = getStatValue(now, 'ssrc');
-        if (!before) {
-            logger.warn(ssrc + ' not enough data');
+        if (!before || !ssrc) {
             continue;
         }
 
-        if(!ssrc)
-            continue;
-
         var ssrcStats
-          = this.ssrc2stats[ssrc] || (this.ssrc2stats[ssrc] = new PeerStats());
+          = this.ssrc2stats[ssrc] || (this.ssrc2stats[ssrc] = new SsrcStats());
 
         var isDownloadStream = true;
         var key = 'packetsReceived';
         if (!packetsNow || packetsNow < 0)
             packetsNow = 0;
 
-        var packetsBefore = getStatValue(before, key);
-        if (!packetsBefore || packetsBefore < 0)
-            packetsBefore = 0;
-        var packetRate = packetsNow - packetsBefore;
-        if (!packetRate || packetRate < 0)
-            packetRate = 0;
-        var currentLoss = getStatValue(now, 'packetsLost');
-        if (!currentLoss || currentLoss < 0)
-            currentLoss = 0;
-        var previousLoss = getStatValue(before, 'packetsLost');
-        if (!previousLoss || previousLoss < 0)
-            previousLoss = 0;
-        var lossRate = currentLoss - previousLoss;
-        if (!lossRate || lossRate < 0)
-            lossRate = 0;
-        var packetsTotal = (packetRate + lossRate);
-
-        ssrcStats.setSsrcLoss({
-            packetsTotal: packetsTotal,
-            packetsLost: lossRate,
-            isDownloadStream: isDownloadStream
-        });
+        var packetsBefore = getNonNegativeStat(before, key);
+        var packetsDiff = Math.max(0, packetsNow - packetsBefore);
 
-        var bytesReceived = 0, bytesSent = 0;
-        var nowBytesTransmitted = getStatValue(now, "bytesReceived");
-        if(nowBytesTransmitted) {
-            bytesReceived
-                = nowBytesTransmitted - getStatValue(before, "bytesReceived");
-        }
-        nowBytesTransmitted = getStatValue(now, "bytesSent");
-        if (nowBytesTransmitted) {
-            bytesSent = nowBytesTransmitted - getStatValue(before, "bytesSent");
-        }
+        var packetsLostNow = getNonNegativeStat(now, 'packetsLost');
+        var packetsLostBefore = getNonNegativeStat(before, 'packetsLost');
+        var packetsLostDiff = Math.max(0, packetsLostNow - packetsLostBefore);
 
-        var time = Math.round((now.timestamp - before.timestamp) / 1000);
-        if (bytesReceived <= 0 || time <= 0) {
-            bytesReceived = 0;
-        } else {
-            bytesReceived = Math.round(((bytesReceived * 8) / time) / 1000);
-        }
+        ssrcStats.setLoss({
+            packetsTotal: packetsDiff + packetsLostDiff,
+            packetsLost: packetsLostDiff,
+            isDownloadStream: isDownloadStream
+        });
 
-        if (bytesSent <= 0 || time <= 0) {
-            bytesSent = 0;
-        } else {
-            bytesSent = Math.round(((bytesSent * 8) / time) / 1000);
+        var bytesReceivedNow = getNonNegativeStat(now, 'bytesReceived');
+        var bytesReceivedBefore = getNonNegativeStat(before, 'bytesReceived');
+        var bytesReceived = Math.max(0, bytesReceivedNow - bytesReceivedBefore);
+
+        var bytesSent = 0;
+
+        // TODO: clean this mess up!
+        var nowBytesTransmitted = getStatValue(now, "bytesSent");
+        if(typeof(nowBytesTransmitted) === "number" ||
+            typeof(nowBytesTransmitted) === "string") {
+            nowBytesTransmitted = Number(nowBytesTransmitted);
+            if(!isNaN(nowBytesTransmitted)){
+                byteSentStats[ssrc] = nowBytesTransmitted;
+                if (nowBytesTransmitted > 0) {
+                    bytesSent = nowBytesTransmitted -
+                        getStatValue(before, "bytesSent");
+                }
+            }
         }
-
-        //detect audio issues (receiving data but audioLevel == 0)
-        if(bytesReceived > 10 && ssrcStats.ssrc2AudioLevel === 0) {
-            this.eventEmitter.emit(StatisticsEvents.AUDIO_NOT_WORKING, ssrc);
+        bytesSent = Math.max(0, bytesSent);
+
+        var timeMs = now.timestamp - before.timestamp;
+        var bitrateReceivedKbps = 0, bitrateSentKbps = 0;
+        if (timeMs > 0) {
+            // TODO is there any reason to round here?
+            bitrateReceivedKbps = Math.round((bytesReceived * 8) / timeMs);
+            bitrateSentKbps = Math.round((bytesSent * 8) / timeMs);
         }
 
-        ssrcStats.setSsrcBitrate({
-            "download": bytesReceived,
-            "upload": bytesSent
+        ssrcStats.addBitrate({
+            "download": bitrateReceivedKbps,
+            "upload": bitrateSentKbps
         });
 
         var resolution = {height: null, width: null};
         catch(e){/*not supported*/}
 
         if (resolution.height && resolution.width) {
-            ssrcStats.setSsrcResolution(resolution);
+            ssrcStats.setResolution(resolution);
         } else {
-            ssrcStats.setSsrcResolution(null);
+            ssrcStats.setResolution(null);
         }
     }
 
     Object.keys(this.ssrc2stats).forEach(
         function (ssrc) {
             var ssrcStats = this.ssrc2stats[ssrc];
-
-            // process package loss stats
-            var ssrc2Loss = ssrcStats.ssrc2Loss;
-            var type = ssrc2Loss.isDownloadStream ? "download" : "upload";
-            totalPackets[type] += ssrc2Loss.packetsTotal;
-            lostPackets[type] += ssrc2Loss.packetsLost;
+            // process packet loss stats
+            var loss = ssrcStats.loss;
+            var type = loss.isDownloadStream ? "download" : "upload";
+            totalPackets[type] += loss.packetsTotal;
+            lostPackets[type] += loss.packetsLost;
 
             // process bitrate stats
-            var ssrc2bitrate = ssrcStats.ssrc2bitrate;
-            bitrateDownload += ssrc2bitrate.download;
-            bitrateUpload += ssrc2bitrate.upload;
+            bitrateDownload += ssrcStats.bitrate.download;
+            bitrateUpload += ssrcStats.bitrate.upload;
 
-            ssrcStats.resetSsrcBitrate();
+            ssrcStats.resetBitrate();
 
             // collect resolutions
-            resolutions[ssrc] = ssrcStats.ssrc2resolution;
+            resolutions[ssrc] = ssrcStats.resolution;
         },
         this
     );
 
+    this.eventEmitter.emit(StatisticsEvents.BYTE_SENT_STATS, byteSentStats);
+
     this.conferenceStats.bitrate
       = {"upload": bitrateUpload, "download": bitrateDownload};
 
             calculatePacketLoss(lostPackets.upload, totalPackets.upload)
     };
     this.eventEmitter.emit(StatisticsEvents.CONNECTION_STATS, {
+            "bandwidth": this.conferenceStats.bandwidth,
             "bitrate": this.conferenceStats.bitrate,
             "packetLoss": this.conferenceStats.packetLoss,
-            "bandwidth": this.conferenceStats.bandwidth,
             "resolution": resolutions,
             "transport": this.conferenceStats.transport
         });
     for (var idx in this.currentAudioLevelsReport) {
         var now = this.currentAudioLevelsReport[idx];
 
-        //if we don't have "packetsReceived" this is local stream
-        if (now.type != 'ssrc' || !getStatValue(now, 'packetsReceived')) {
+        if (now.type != 'ssrc')
             continue;
-        }
 
         var before = this.baselineAudioLevelsReport[idx];
         var ssrc = getStatValue(now, 'ssrc');
             continue;
         }
 
-        var ssrcStats
-            = this.ssrc2stats[ssrc]
-                || (this.ssrc2stats[ssrc] = new PeerStats());
-
         // Audio level
         try {
             var audioLevel
         }
 
         if (audioLevel) {
-            // TODO: can't find specs about what this value really is,
-            // but it seems to vary between 0 and around 32k.
+            const isLocal = !getStatValue(now, 'packetsReceived');
+
+            // TODO: Can't find specs about what this value really is, but it
+            // seems to vary between 0 and around 32k.
             audioLevel = audioLevel / 32767;
-            ssrcStats.setSsrcAudioLevel(audioLevel);
             this.eventEmitter.emit(
-                StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel);
+                StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel, isLocal);
         }
     }
 };

modules/statistics/statistics.js

 /* global require */
-var LocalStats = require("./LocalStatsCollector.js");
+var AnalyticsAdapter = require("./AnalyticsAdapter");
+var CallStats = require("./CallStats");
+var EventEmitter = require("events");
+import JitsiTrackError from "../../JitsiTrackError";
 var logger = require("jitsi-meet-logger").getLogger(__filename);
+var LocalStats = require("./LocalStatsCollector.js");
 var RTPStats = require("./RTPStatsCollector.js");
-var EventEmitter = require("events");
-var StatisticsEvents = require("../../service/statistics/Events");
-var CallStats = require("./CallStats");
 var ScriptUtil = require('../util/ScriptUtil');
-var JitsiTrackError = require("../../JitsiTrackError");
+import * as StatisticsEvents from "../../service/statistics/Events";
+
+/**
+ * True if callstats API is loaded
+ */
+ var isCallstatsLoaded = false;
 
 // Since callstats.io is a third party, we cannot guarantee the quality of their
 // service. More specifically, their server may take noticeably long time to
 // allow it to prevent people from joining a conference) to (1) start
 // downloading their API as soon as possible and (2) do the downloading
 // asynchronously.
-function loadCallStatsAPI() {
-    ScriptUtil.loadScript(
-            'https://api.callstats.io/static/callstats.min.js',
-            /* async */ true,
-            /* prepend */ true);
+function loadCallStatsAPI(customScriptUrl) {
+    if(!isCallstatsLoaded) {
+        ScriptUtil.loadScript(
+                customScriptUrl ? customScriptUrl :
+                    'https://api.callstats.io/static/callstats-ws.min.js',
+                /* async */ true,
+                /* prepend */ true);
+        isCallstatsLoaded = true;
+    }
     // FIXME At the time of this writing, we hope that the callstats.io API will
     // have loaded by the time we needed it (i.e. CallStats.init is invoked).
 }
 
+// Load the integration of a third-party analytics API such as Google Analytics.
+// Since we cannot guarantee the quality of the third-party service (e.g. their
+// server may take noticeably long time to respond), it is in our best interest
+// (in the sense that the intergration of the analytics API is important to us
+// but not enough to allow it to prevent people from joining a conference) to
+// download the API asynchronously. Additionally, Google Analytics will download
+// its implementation asynchronously anyway so it makes sense to append the
+// loading on our side rather than prepend it.
+function loadAnalytics(customScriptUrl) {
+    // if we have a custom script url passed as parameter we don't want to
+    // search it relatively near the library
+    ScriptUtil.loadScript(
+        customScriptUrl ? customScriptUrl : 'analytics.js',
+        /* async */ true,
+        /* prepend */ false,
+        /* relativeURL */ customScriptUrl ? false : true,
+        /* loadCallback */ function () {
+            Statistics.analytics.loaded();
+        },
+        /* errorCallback */ function () {
+            Statistics.analytics.dispose();
+        });
+}
+
 /**
  * Log stats via the focus once every this many milliseconds.
  */
     return err;
 }
 
+/**
+ * Init statistic options
+ * @param options
+ */
+Statistics.init = function (options) {
+    Statistics.audioLevelsEnabled = !options.disableAudioLevels;
+
+    if(typeof options.audioLevelsInterval === 'number') {
+        Statistics.audioLevelsInterval = options.audioLevelsInterval;
+    }
+
+    Statistics.disableThirdPartyRequests = options.disableThirdPartyRequests;
+
+    if (Statistics.disableThirdPartyRequests !== true)
+        loadAnalytics(options.analyticsScriptUrl);
+    else // if not enable make sure we dispose any event that goes in the queue
+        Statistics.analytics.dispose();
+};
+
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
             // Even though AppID and AppSecret may be specified, the integration
             // of callstats.io may be disabled because of globally-disallowed
             // requests to any third parties.
-            && (this.options.disableThirdPartyRequests !== true);
+            && (Statistics.disableThirdPartyRequests !== true);
     if(this.callStatsIntegrationEnabled)
-        loadCallStatsAPI();
+        loadCallStatsAPI(this.options.callStatsCustomScriptUrl);
     this.callStats = null;
+    // Flag indicates whether or not the CallStats have been started for this
+    // Statistics instance
+    this.callStatsStarted = false;
 
     /**
      * Send the stats already saved in rtpStats to be logged via the focus.
 }
 Statistics.audioLevelsEnabled = false;
 Statistics.audioLevelsInterval = 200;
+Statistics.disableThirdPartyRequests = false;
+Statistics.analytics = AnalyticsAdapter;
 
 /**
  * Array of callstats instances. Used to call Statistics static methods and
 Statistics.callsStatsInstances = [];
 
 Statistics.prototype.startRemoteStats = function (peerconnection) {
-    if(!Statistics.audioLevelsEnabled)
-        return;
-
     this.stopRemoteStats();
 
     try {
         this.rtpStats
             = new RTPStats(peerconnection,
                     Statistics.audioLevelsInterval, 2000, this.eventEmitter);
-        this.rtpStats.start();
+        this.rtpStats.start(Statistics.audioLevelsEnabled);
     } catch (e) {
         this.rtpStats = null;
         logger.error('Failed to start collecting remote statistics: ' + e);
     this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
 };
 
-/**
- * Adds listener for detected audio problems.
- * @param listener the listener.
- */
-Statistics.prototype.addAudioProblemListener = function (listener) {
-    this.eventEmitter.on(StatisticsEvents.AUDIO_NOT_WORKING, listener);
-};
-
 Statistics.prototype.removeConnectionStatsListener = function (listener) {
     this.eventEmitter.removeListener(StatisticsEvents.CONNECTION_STATS, listener);
 };
 
-Statistics.prototype.dispose = function () {
-    if(Statistics.audioLevelsEnabled) {
-        Statistics.stopAllLocalStats();
-        this.stopRemoteStats();
-        if(this.eventEmitter)
-            this.eventEmitter.removeAllListeners();
-    }
+Statistics.prototype.addByteSentStatsListener = function (listener) {
+    this.eventEmitter.on(StatisticsEvents.BYTE_SENT_STATS, listener);
 };
 
-Statistics.stopAllLocalStats = function () {
-    if(!Statistics.audioLevelsEnabled)
-        return;
+Statistics.prototype.removeByteSentStatsListener = function (listener) {
+    this.eventEmitter.removeListener(StatisticsEvents.BYTE_SENT_STATS,
+        listener);
+};
 
-    for(var i = 0; i < this.localStats.length; i++)
-        this.localStats[i].stop();
-    this.localStats = [];
+Statistics.prototype.dispose = function () {
+    this.stopCallStats();
+    this.stopRemoteStats();
+    if(this.eventEmitter)
+        this.eventEmitter.removeAllListeners();
 };
 
 Statistics.stopLocalStats = function (stream) {
 };
 
 Statistics.prototype.stopRemoteStats = function () {
-    if (!Statistics.audioLevelsEnabled || !this.rtpStats) {
+    if (!this.rtpStats) {
         return;
     }
 
  * /modules/settings/Settings.js
  */
 Statistics.prototype.startCallStats = function (session, settings) {
-    if(this.callStatsIntegrationEnabled && !this.callstats) {
+    if(this.callStatsIntegrationEnabled && !this.callStatsStarted) {
+        // Here we overwrite the previous instance, but it must be bound to
+        // the new PeerConnection
         this.callstats = new CallStats(session, settings, this.options);
         Statistics.callsStatsInstances.push(this.callstats);
+        this.callStatsStarted = true;
+    }
+};
+
+/**
+ * Removes the callstats.io instances.
+ */
+Statistics.prototype.stopCallStats = function () {
+    if(this.callStatsStarted) {
+        var index = Statistics.callsStatsInstances.indexOf(this.callstats);
+        if(index > -1)
+            Statistics.callsStatsInstances.splice(index, 1);
+        // The next line is commented because we need to be able to send
+        // feedback even after the conference has been destroyed.
+        // this.callstats = null;
+        CallStats.dispose();
+        this.callStatsStarted = false;
     }
 };
 
 };
 
 /**
- * Notifies CallStats for ice connection failed
+ * Notifies CallStats and analytics(if present) for ice connection failed
  * @param {RTCPeerConnection} pc connection on which failure occured.
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function (pc) {
     if(this.callstats)
         this.callstats.sendIceConnectionFailedEvent(pc, this.callstats);
+    Statistics.analytics.sendEvent('connection.ice_failed');
 };
 
 /**
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
 };
 
-/**
- * Notifies CallStats that audio problems are detected.
- *
- * @param {Error} e error to send
- */
-Statistics.prototype.sendDetectedAudioProblem = function (e) {
-    if(this.callstats)
-        this.callstats.sendDetectedAudioProblem(e);
-};
-
 /**
  * Adds to CallStats an application log.
  *
 Statistics.prototype.sendFeedback = function(overall, detailed) {
     if(this.callstats)
         this.callstats.sendFeedback(overall, detailed);
+    Statistics.analytics.sendEvent("feedback.rating",
+        {value: overall, detailed: detailed});
 };
 
 Statistics.LOCAL_JID = require("../../service/statistics/constants").LOCAL_JID;
     }
 };
 
+/**
+ * Sends event to analytics and callstats.
+ * @param {string} eventName the event name.
+ * @param {Object} data the data to be sent.
+ */
+Statistics.sendEventToAll = function (eventName, data) {
+    this.analytics.sendEvent(eventName, data);
+    Statistics.sendLog(JSON.stringify({name: eventName, data}));
+};
+
 module.exports = Statistics;

modules/transcription/audioRecorder.js

+/* global MediaRecorder, MediaStream, webkitMediaStream */
+
+var RecordingResult = require("./recordingResult");
+
+/**
+ * Possible audio formats MIME types
+ */
+var AUDIO_WEBM = "audio/webm";    // Supported in chrome
+var AUDIO_OGG  = "audio/ogg";     // Supported in firefox
+
+/**
+ * A TrackRecorder object holds all the information needed for recording a
+ * single JitsiTrack (either remote or local)
+ * @param track The JitsiTrack the object is going to hold
+ */
+var TrackRecorder = function(track){
+    // The JitsiTrack holding the stream
+    this.track = track;
+    // The MediaRecorder recording the stream
+    this.recorder = null;
+    // The array of data chunks recorded from the stream
+    // acts as a buffer until the data is stored on disk
+    this.data = null;
+    //the name of the person of the JitsiTrack. This can be undefined and/or
+    //not unique
+    this.name = null;
+    //the time of the start of the recording
+    this.startTime = null;
+};
+
+/**
+ * Starts the recording of a JitsiTrack in a TrackRecorder object.
+ * This will also define the timestamp and try to update the name
+ * @param trackRecorder the TrackRecorder to start
+ */
+function startRecorder(trackRecorder) {
+    if(trackRecorder.recorder === undefined) {
+        throw new Error("Passed an object to startRecorder which is not a " +
+            "TrackRecorder object");
+    }
+    trackRecorder.recorder.start();
+    trackRecorder.startTime = new Date();
+}
+
+/**
+ * Stops the recording of a JitsiTrack in a TrackRecorder object.
+ * This will also try to update the name
+ * @param trackRecorder the TrackRecorder to stop
+ */
+function stopRecorder(trackRecorder){
+    if(trackRecorder.recorder === undefined) {
+        throw new Error("Passed an object to stopRecorder which is not a " +
+            "TrackRecorder object");
+    }
+    trackRecorder.recorder.stop();
+}
+
+/**
+ * Creates a TrackRecorder object. Also creates the MediaRecorder and
+ * data array for the trackRecorder.
+ * @param track the JitsiTrack holding the audio MediaStream(s)
+ */
+function instantiateTrackRecorder(track) {
+    var trackRecorder = new TrackRecorder(track);
+    // Create a new stream which only holds the audio track
+    var originalStream = trackRecorder.track.getOriginalStream();
+    var stream = createEmptyStream();
+    originalStream.getAudioTracks().forEach(function(track){
+        stream.addTrack(track);
+    });
+    // Create the MediaRecorder
+    trackRecorder.recorder = new MediaRecorder(stream,
+        {mimeType: audioRecorder.fileType});
+    //array for holding the recorder data. Resets it when
+    //audio already has been recorder once
+    trackRecorder.data = [];
+    // function handling a dataEvent, e.g the stream gets new data
+    trackRecorder.recorder.ondataavailable = function (dataEvent) {
+        if(dataEvent.data.size > 0) {
+            trackRecorder.data.push(dataEvent.data);
+        }
+    };
+
+    return trackRecorder;
+}
+
+/**
+ * Determines which kind of audio recording the browser supports
+ * chrome supports "audio/webm" and firefox supports "audio/ogg"
+ */
+function determineCorrectFileType() {
+    if(MediaRecorder.isTypeSupported(AUDIO_WEBM)) {
+        return AUDIO_WEBM;
+    }
+    else if(MediaRecorder.isTypeSupported(AUDIO_OGG)) {
+        return AUDIO_OGG;
+    }
+    else {
+        throw new Error("unable to create a MediaRecorder with the" +
+            "right mimetype!");
+    }
+}
+
+/**
+ * main exported object of the file, holding all
+ * relevant functions and variables for the outside world
+ * @param jitsiConference the jitsiConference which this object
+ * is going to record
+ */
+var audioRecorder = function(jitsiConference){
+    // array of TrackRecorders, where each trackRecorder
+    // holds the JitsiTrack, MediaRecorder and recorder data
+    this.recorders = [];
+
+    //get which file type is supported by the current browser
+    this.fileType = determineCorrectFileType();
+
+    //boolean flag for active recording
+    this.isRecording = false;
+
+    //the jitsiconference the object is recording
+    this.jitsiConference = jitsiConference;
+};
+
+/**
+ * Add the the exported module so that it can be accessed by other files
+ */
+audioRecorder.determineCorrectFileType = determineCorrectFileType;
+
+/**
+ * Adds a new TrackRecorder object to the array.
+ *
+ * @param track the track potentially holding an audio stream
+ */
+audioRecorder.prototype.addTrack = function (track) {
+    if(track.isAudioTrack()) {
+        //create the track recorder
+        var trackRecorder = instantiateTrackRecorder(track);
+        //push it to the local array of all recorders
+        this.recorders.push(trackRecorder);
+        //update the name of the trackRecorders
+        this.updateNames();
+        //if we're already recording, immediately start recording this new track
+        if(this.isRecording){
+            startRecorder(trackRecorder);
+        }
+    }
+};
+
+/**
+ * Notifies the module that a specific track has stopped, e.g participant left
+ * the conference.
+ * if the recording has not started yet, the TrackRecorder will be removed from
+ * the array. If the recording has started, the recorder will stop recording
+ * but not removed from the array so that the recorded stream can still be
+ * accessed
+ *
+ * @param {JitsiTrack} track the JitsiTrack to remove from the recording session
+ */
+audioRecorder.prototype.removeTrack = function(track){
+    if(track.isVideoTrack()){
+        return;
+    }
+    
+    var array = this.recorders;
+    var i;
+    for(i = 0; i < array.length; i++) {
+        if(array[i].track.getParticipantId() === track.getParticipantId()){
+            var recorderToRemove = array[i];
+            if(this.isRecording){
+                stopRecorder(recorderToRemove);
+            }
+            else {
+                //remove the TrackRecorder from the array
+                array.splice(i, 1);
+            }
+        }
+    }
+
+    //make sure the names are up to date
+    this.updateNames();
+};
+
+/**
+ * Tries to update the name value of all TrackRecorder in the array.
+ * If it hasn't changed,it will keep the exiting name. If it changes to a
+ * undefined value, the old value will also be kept.
+ */
+audioRecorder.prototype.updateNames = function(){
+    var conference = this.jitsiConference;
+    this.recorders.forEach(function(trackRecorder){
+        if(trackRecorder.track.isLocal()){
+            trackRecorder.name = "the transcriber";
+        }
+        else {
+            var id = trackRecorder.track.getParticipantId();
+            var participant = conference.getParticipantById(id);
+            var newName = participant.getDisplayName();
+            if(newName !== 'undefined') {
+                trackRecorder.name = newName;
+            }
+        }
+    });
+};
+
+/**
+ * Starts the audio recording of every local and remote track
+ */
+audioRecorder.prototype.start = function () {
+    if(this.isRecording) {
+        throw new Error("audiorecorder is already recording");
+    }
+    // set boolean isRecording flag to true so if new participants join the
+    // conference, that track can instantly start recording as well
+    this.isRecording = true;
+    //start all the mediaRecorders
+    this.recorders.forEach(function(trackRecorder){
+        startRecorder(trackRecorder);
+    });
+    //log that recording has started
+    console.log("Started the recording of the audio. There are currently " +
+        this.recorders.length + " recorders active.");
+};
+
+/**
+ * Stops the audio recording of every local and remote track
+ */
+audioRecorder.prototype.stop = function() {
+    //set the boolean flag to false
+    this.isRecording = false;
+    //stop all recorders
+    this.recorders.forEach(function(trackRecorder){
+       stopRecorder(trackRecorder);
+    });
+    console.log("stopped recording");
+};
+
+/**
+ * link hacking to download all recorded audio streams
+ */
+audioRecorder.prototype.download = function () {
+    var t = this;
+    this.recorders.forEach(function (trackRecorder) {
+        var blob = new Blob(trackRecorder.data, {type: t.fileType});
+        var url = URL.createObjectURL(blob);
+        var a = document.createElement('a');
+        document.body.appendChild(a);
+        a.style = "display: none";
+        a.href = url;
+        a.download = 'test.' + t.fileType.split("/")[1];
+        a.click();
+        window.URL.revokeObjectURL(url);
+    });
+};
+
+/**
+ * returns the audio files of all recorders as an array of objects,
+ * which include the name of the owner of the track and the starting time stamp
+ * @returns {Array} an array of RecordingResult objects
+ */
+audioRecorder.prototype.getRecordingResults = function () {
+    if(this.isRecording) {
+        throw new Error("cannot get blobs because the AudioRecorder is still" +
+            "recording!");
+    }
+    //make sure the names are up to date before sending them off
+    this.updateNames();
+
+    var array = [];
+    var t = this;
+    this.recorders.forEach(function (recorder) {
+        array.push(
+            new RecordingResult(
+            new Blob(recorder.data, {type: t.fileType}),
+            recorder.name,
+            recorder.startTime)
+        );
+    });
+    return array;
+};
+
+/**
+ * Gets the mime type of the recorder audio
+ * @returns {String} the mime type of the recorder audio
+ */
+audioRecorder.prototype.getFileType = function () {
+    return this.fileType;
+};
+
+/**
+ * Creates a empty MediaStream object which can be used
+ * to add MediaStreamTracks to
+ * @returns MediaStream
+ */
+function createEmptyStream() {
+    // Firefox supports the MediaStream object, Chrome webkitMediaStream
+    if(typeof(MediaStream) !== 'undefined') {
+        return new MediaStream();
+    }
+    else if(typeof(webkitMediaStream) !== 'undefined') {
+        return new webkitMediaStream(); // eslint-disable-line new-cap
+    }
+    else {
+        throw new Error("cannot create a clean mediaStream");
+    }
+}
+
+/**
+ * export the main object audioRecorder
+ */
+module.exports = audioRecorder;

modules/transcription/recordingResult.js

+/**
+ * This object stores variables needed around the recording of an audio stream
+ * and passing this recording along with additional information along to
+ * different processes
+ * @param blob the recording audio stream as a single blob
+ * @param name the name of the person of the audio stream
+ * @param startTime the time in UTC when recording of the audiostream started
+ * @param wordArray the recorder audio stream transcribed as an array of Word
+ *                  objects
+ */
+var RecordingResult = function(blob, name, startTime, wordArray){
+    this.blob = blob;
+    this.name = name;
+    this.startTime = startTime;
+    this.wordArray = wordArray;
+};
+
+module.exports = RecordingResult;

modules/transcription/transcriber.js

+var AudioRecorder = require( './audioRecorder');
+var SphinxService = require(
+    './transcriptionServices/SphinxTranscriptionService');
+
+var BEFORE_STATE = "before";
+var RECORDING_STATE = "recording";
+var TRANSCRIBING_STATE = "transcribing";
+var FINISHED_STATE = "finished";
+
+//the amount of characters each line in the transcription will have
+var MAXIMUM_SENTENCE_LENGTH = 80;
+
+/**
+ * This is the main object for handing the Transcription. It interacts with
+ * the audioRecorder to record every person in a conference and sends the
+ * recorder audio to a transcriptionService. The returned speech-to-text result
+ * will be merged to create a transcript
+ * @param {AudioRecorder} audioRecorder An audioRecorder recording a conference
+ */
+var transcriber = function() {
+    //the object which can record all audio in the conference
+    this.audioRecorder = new AudioRecorder();
+    //this object can send the recorder audio to a speech-to-text service
+    this.transcriptionService =  new SphinxService();
+    //holds a counter to keep track if merging can start
+    this.counter = null;
+    //holds the date when transcription started which makes it possible
+    //to calculate the offset between recordings
+    this.startTime = null;
+    //will hold the transcription once it is completed
+    this.transcription = null;
+    //this will be a method which will be called once the transcription is done
+    //with the transcription as parameter
+    this.callback =  null;
+    //stores all the retrieved speech-to-text results to merge together
+    //this value will store an Array<Word> object
+    this.results = [];
+    // Stores the current state of the transcription process
+    this.state = BEFORE_STATE;
+    //Used in the updateTranscription method to add a new line when the
+    //sentence becomes to long
+    this.lineLength = 0;
+};
+
+/**
+ * Method to start the transcription process. It will tell the audioRecorder
+ * to start storing all audio streams and record the start time for merging
+ * purposes
+ */
+transcriber.prototype.start = function start() {
+    if(this.state !== BEFORE_STATE){
+        throw new Error("The transcription can only start when it's in the" +
+            "\"" + BEFORE_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    this.state = RECORDING_STATE;
+    this.audioRecorder.start();
+    this.startTime = new Date();
+};
+
+/**
+ * Method to stop the transcription process. It will tell the audioRecorder to
+ * stop, and get all the recorded audio to send it to the transcription service
+
+ * @param callback a callback which will receive the transcription
+ */
+transcriber.prototype.stop = function stop(callback) {
+    if(this.state !== RECORDING_STATE){
+        throw new Error("The transcription can only stop when it's in the" +
+            "\"" + RECORDING_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    //stop the recording
+    console.log("stopping recording and sending audio files");
+    this.audioRecorder.stop();
+    //and send all recorded audio the the transcription service
+    var t = this;
+
+    var callBack = blobCallBack.bind(this);
+    this.audioRecorder.getRecordingResults().forEach(function(recordingResult){
+        t.transcriptionService.send(recordingResult, callBack);
+        t.counter++;
+    });
+    //set the state to "transcribing" so that maybeMerge() functions correctly
+    this.state = TRANSCRIBING_STATE;
+    //and store the callback for later
+    this.callback = callback;
+};
+
+/**
+ * This method gets the answer from the transcription service, calculates the
+ * offset and adds is to every Word object. It will also start the merging
+ * when every send request has been received
+ *
+ * note: Make sure to bind this as a Transcription object
+ *
+ * @param {RecordingResult} answer a RecordingResult object with a defined
+ * WordArray
+ */
+var blobCallBack = function(answer){
+    console.log("retrieved an answer from the transcription service. The" +
+        " answer has an array of length: " + answer.wordArray.length);
+    //first add the offset between the start of the transcription and
+    //the start of the recording to all start and end times
+    if(answer.wordArray.length > 0) {
+        var offset = answer.startTime.getUTCMilliseconds() -
+            this.startTime.getUTCMilliseconds();
+        //transcriber time will always be earlier
+        if (offset < 0) {
+            offset = 0; //presume 0 if it somehow not earlier
+        }
+
+        var array = "[";
+        answer.wordArray.forEach(function(wordObject) {
+            wordObject.begin += offset;
+            wordObject.end += offset;
+            array += wordObject.word+",";
+        });
+        array += "]";
+        console.log(array);
+        //give a name value to the Array object so that the merging can access
+        //the name value without having to use the whole recordingResult object
+        //in the algorithm
+        answer.wordArray.name = answer.name;
+    }
+    //then store the array and decrease the counter
+    this.results.push(answer.wordArray);
+    this.counter--;
+    console.log("current counter: " + this.counter);
+    //and check if all results have been received.
+    this.maybeMerge();
+};
+
+/**
+ * this method will check if the counter is zero. If it is, it will call
+ * the merging method
+ */
+transcriber.prototype.maybeMerge = function(){
+    if(this.state === TRANSCRIBING_STATE && this.counter === 0){
+        //make sure to include the events in the result arrays before
+        //merging starts
+        this.merge();
+    }
+};
+
+/**
+ * This method will merge all speech-to-text arrays together in one
+ * readable transcription string
+ */
+transcriber.prototype.merge = function() {
+    console.log("starting merge process!\n The length of the array: " +
+        this.results.length);
+    this.transcription = "";
+    //the merging algorithm will look over all Word objects who are at pos 0 in
+    //every array. It will then select the one closest in time to the
+    //previously placed word, while removing the selected word from its array
+    //note: words can be skipped the skipped word's begin and end time somehow
+    //end up between the closest word start and end time
+    var arrays = this.results;
+    //arrays of Word objects
+    var potentialWords = []; //array of the first Word objects
+    //check if any arrays are already empty and remove them
+    hasPopulatedArrays(arrays);
+
+    //populate all the potential Words for a first time
+    arrays.forEach(function (array){
+        pushWordToSortedArray(potentialWords, array);
+    });
+
+    //keep adding words to transcription until all arrays are exhausted
+    var lowestWordArray;
+    var wordToAdd;
+    var foundSmaller;
+    while(hasPopulatedArrays(arrays)){
+        //first select the lowest array;
+        lowestWordArray = arrays[0];
+        arrays.forEach(function(wordArray){
+           if(wordArray[0].begin < lowestWordArray[0].begin){
+               lowestWordArray = wordArray;
+           }
+        });
+        //put the word in the transcription
+        wordToAdd = lowestWordArray.shift();
+        this.updateTranscription(wordToAdd,lowestWordArray.name);
+
+        //keep going until a word in another array has a smaller time
+        //or the array is empty
+        while(!foundSmaller && lowestWordArray.length > 0){
+            arrays.forEach(function(wordArray){
+                if(wordArray[0].begin < lowestWordArray[0].begin){
+                    foundSmaller = true;
+                }
+            });
+            //add next word if no smaller time has been found
+            if(!foundSmaller){
+                wordToAdd = lowestWordArray.shift();
+                this.updateTranscription(wordToAdd, null);
+            }
+        }
+
+    }
+
+    //set the state to finished and do the necessary left-over tasks
+    this.state = FINISHED_STATE;
+    if(this.callback){
+        this.callback(this.transcription);
+    }
+};
+
+/**
+ * Appends a word object to the transcription. It will make a new line with a
+ * name if a name is specified
+ * @param {Word} word the Word object holding the word to append
+ * @param {String|null} name the name of a new speaker. Null if not applicable
+ */
+transcriber.prototype.updateTranscription = function(word, name){
+    if(name !== undefined && name !== null){
+        this.transcription += "\n" + name + ":";
+        this.lineLength = name.length + 1; //+1 for the semi-colon
+    }
+    if(this.lineLength + word.word.length > MAXIMUM_SENTENCE_LENGTH){
+        this.transcription += "\n    ";
+        this.lineLength = 4; //because of the 4 spaces after the new line
+    }
+    this.transcription += " " + word.word;
+    this.lineLength += word.word.length + 1; //+1 for the space
+};
+
+/**
+ * Check if the given 2 dimensional array has any non-zero Word-arrays in them.
+ * All zero-element arrays inside will be removed
+ * If any non-zero-element arrays are found, the method will return true.
+ * otherwise it will return false
+ * @param {Array<Array>} twoDimensionalArray the array to check
+ * @returns {boolean} true if any non-zero arrays inside, otherwise false
+ */
+var hasPopulatedArrays = function(twoDimensionalArray){
+    var i;
+    for(i = 0; i < twoDimensionalArray.length; i++){
+        if(twoDimensionalArray[i].length === 0){
+            twoDimensionalArray.splice(i, 1);
+        }
+    }
+    return twoDimensionalArray.length > 0;
+};
+
+/**
+ * Push a word to the right location in a sorted array. The array is sorted
+ * from lowest to highest start time. Every word is stored in an object which
+ * includes the name of the person saying the word.
+ *
+ * @param {Array<Word>} array the sorted array to push to
+ * @param {Word} word the word to push into the array
+ */
+var pushWordToSortedArray = function(array, word){
+    if(array.length === 0) {
+        array.push(word);
+    }
+    else{
+        if(array[array.length - 1].begin <= word.begin){
+            array.push(word);
+            return;
+        }
+        var i;
+        for(i = 0; i < array.length; i++){
+            if(word.begin < array[i].begin){
+                array.splice(i, 0, word);
+                return;
+            }
+        }
+        array.push(word); //fail safe
+    }
+};
+
+/**
+ * Gives the transcriber a JitsiTrack holding an audioStream to transcribe.
+ * The JitsiTrack is given to the audioRecorder. If it doesn't hold an
+ * audiostream, it will not be added by the audioRecorder
+ * @param {JitsiTrack} track the track to give to the audioRecorder
+ */
+transcriber.prototype.addTrack = function(track){
+    this.audioRecorder.addTrack(track);
+};
+
+/**
+ * Remove the given track from the auioRecorder
+ * @param track
+ */
+transcriber.prototype.removeTrack = function(track){
+    this.audioRecorder.removeTrack(track);
+};
+
+/**
+ * Will return the created transcription if it's avialable or throw an error
+ * when it's not done yet
+ * @returns {String} the transcription as a String
+ */
+transcriber.prototype.getTranscription = function(){
+    if(this.state !== FINISHED_STATE){
+        throw new Error("The transcription can only be retrieved when it's in" +
+            " the\"" + FINISHED_STATE + "\" state. It's currently in the " +
+            "\"" + this.state + "\" state");
+    }
+    return this.transcription;
+};
+
+/**
+ * Returns the current state of the transcription process
+ */
+transcriber.prototype.getState = function(){
+    return this.state;
+};
+
+/**
+ * Resets the state to the "before" state, such that it's again possible to
+ * call the start method
+ */
+transcriber.prototype.reset = function() {
+    this.state = BEFORE_STATE;
+    this.counter = null;
+    this.transcription = null;
+    this.startTime = null;
+    this.callback = null;
+    this.results = [];
+    this.lineLength = 0;
+};
+
+module.exports = transcriber;

modules/transcription/transcriberHolder.js

+/**
+ * This objets holds all created transcriberHolders so that they can be
+ * accessed through the JitsiMeetJS object.
+ *
+ * This is probably temporary until there is a better way to expose the
+ * Transcriber in a conference
+ */
+var transcriberHolder = {
+    transcribers : [],
+
+    add : function(transcriber){
+        transcriberHolder.transcribers.push(transcriber);
+    }
+};
+
+module.exports = transcriberHolder;

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

+/**
+ * Abstract class representing an interface to implement a speech-to-text
+ * service on.
+ */
+var TranscriptionService = function() {
+    throw new Error("TranscriptionService is abstract and cannot be" +
+        "created");
+};
+
+/**
+ * This method can be used to send the recorder audio stream and
+ * retrieve the answer from the transcription service from the callback
+ *
+ * @param {RecordingResult} recordingResult a recordingResult object which
+ * includes the recorded audio stream as a blob
+ * @param {Function} callback  which will retrieve the a RecordingResult with
+ *        the answer as a WordArray
+ */
+TranscriptionService.prototype.send = function send(recordingResult, callback){
+    var t = this;
+    this.sendRequest(recordingResult.blob, function(response){
+        if(!t.verify(response)){
+               console.log("the retrieved response from the server" +
+                   " is not valid!");
+            recordingResult.wordArray = [];
+            callback(recordingResult);
+        }
+        else{
+            recordingResult.wordArray = t.formatResponse(response);
+            callback(recordingResult);
+        }
+    });
+};
+
+/**
+ * Abstract method which will rend the recorder audio stream to the implemented
+ * transcription service and will retrieve an answer, which will be
+ * called on the given callback method
+ *
+ * @param {Blob} audioBlob the recorded audio stream as a single Blob
+ * @param {function} callback function which will retrieve the answer
+ *                            from the service
+ */
+// eslint-disable-next-line no-unused-vars
+TranscriptionService.prototype.sendRequest = function(audioBlob, callback) {
+    throw new Error("TranscriptionService.sendRequest is abstract");
+};
+
+/**
+ * Abstract method which will parse the output from the implemented
+ * transcription service to the expected format
+ *
+ * The transcriber class expect an array of word objects, where each word
+ * object is one transcribed word by the service.
+ *
+ * The expected output of this method is an array of word objects, in
+ * the correct order. That is, the first object in the array is the first word
+ * being said, and the last word in the array is the last word being said
+ *
+ * @param response the answer from the speech-to-text server which needs to be
+ *                 formatted
+ * @return {Array<Word>} an array of Word objects
+ */
+// eslint-disable-next-line no-unused-vars
+TranscriptionService.prototype.formatResponse = function(response){
+    throw new Error("TranscriptionService.format is abstract");
+};
+
+/**
+ * Abstract method which will verify that the response from the server is valid
+ *
+ * @param response the response from the server
+ * @return {boolean} true if response is valid, false otherwise
+ */
+// eslint-disable-next-line no-unused-vars
+TranscriptionService.prototype.verify = function(response){
+      throw new Error("TranscriptionService.verify is abstract");
+};
+
+module.exports = TranscriptionService;

modules/transcription/transcriptionServices/SphinxTranscriptionService.js

+/* global config */
+
+var TranscriptionService = require("./AbstractTranscriptionService");
+var Word = require( "../word");
+var audioRecorder = require("./../audioRecorder");
+
+/**
+ * Implements a TranscriptionService for a Sphinx4 http server
+ */
+var SphinxService = function() {
+    //set the correct url
+    this.url = getURL();
+};
+
+/**
+ * Subclass of AbstractTranscriptionService
+ */
+SphinxService.prototype = Object.create(TranscriptionService.prototype);
+
+/**
+ * Set the right constructor
+ */
+SphinxService.constructor = SphinxService;
+
+/**
+ * Overrides the sendRequest method from AbstractTranscriptionService
+ * it will send the audio stream the a Sphinx4 server to get the transcription
+ *
+ * @param audioFileBlob the recorder audio stream an a single Blob
+ * @param callback the callback function retrieving the server response
+ */
+SphinxService.prototype.sendRequest = function(audioFileBlob, callback) {
+    console.log("sending an audio file  to " + this.url);
+    console.log("the audio file being sent: " + audioFileBlob);
+    var request = new XMLHttpRequest();
+    request.onreadystatechange = function() {
+        if(request.readyState === XMLHttpRequest.DONE && request.status === 200)
+        {
+            callback(request.responseText);
+        }
+        else if (request.readyState === XMLHttpRequest.DONE) {
+            throw new Error("unable to accept response from sphinx server." +
+                "status: " + request.status);
+        }
+        //if not ready no point to throw an error
+    };
+    request.open("POST", this.url);
+    request.setRequestHeader("Content-Type",
+        audioRecorder.determineCorrectFileType());
+    request.send(audioFileBlob);
+    console.log("send " + audioFileBlob);
+};
+
+/**
+ * Overrides the formatResponse method from AbstractTranscriptionService
+ * It will parse the answer from the server in the expected format
+ *
+ * @param response the JSON body retrieved from the Sphinx4 server
+ */
+SphinxService.prototype.formatResponse = function(response) {
+    var result = JSON.parse(response).objects;
+    //make sure to delete the session id object, which is always
+    //the first value in the JSON array
+    result.shift();
+    var array = [];
+    result.forEach(function(word){
+        if(!word.filler) {
+            array.push(new Word(word.word, word.start, word.end));
+        }
+    });
+    return array;
+};
+
+/**
+ * checks wether the reply is empty, or doesn't contain a correct JSON object
+ * @param response the server response
+ * @return {boolean} whether the response is valid
+ */
+SphinxService.prototype.verify = function(response){
+    console.log("response from server:" + response.toString());
+    //test if server responded with a string object
+    if(typeof(response) !== "string"){
+        return false;
+    }
+    //test if the string can be parsed into valid JSON
+    var json;
+    try{
+        json = JSON.parse(response);
+    }
+    catch (error){
+        console.log(error);
+        return false;
+    }
+    //check if the JSON has a "objects" value
+    if(json.objects === undefined){
+        return false;
+    }
+    //get the "objects" value and check for a session ID
+    var array = json.objects;
+    if(!(array[0] && array[0]["session-id"])){
+        return false;
+    }
+    //everything seems to be in order
+    return true;
+};
+
+/**
+ * Gets the URL to the Sphinx4 server from the config file. If it's not there,
+ * it will throw an error
+ *
+ * @returns {string} the URL to the sphinx4 server
+ */
+function getURL() {
+    var message = "config does not contain an url to a " +
+    "Sphinx4 https server";
+    if(config.sphinxURL === undefined){
+        console.log(message);
+    }
+    else {
+        var toReturn = config.sphinxURL;
+        if(toReturn.includes !== undefined && toReturn.includes("https://")){
+            return toReturn;
+        }
+        else{
+            console.log(message);
+        }
+    }
+}
+
+module.exports = SphinxService;

modules/transcription/word.js

+/**
+ * An object representing a transcribed word, with some additional information
+ * @param word the word 
+ * @param begin the time the word was started being uttered
+ * @param end the time the word stopped being uttered
+ */
+var Word = function (word, begin, end) {
+    this.word = word;
+    this.begin = begin;
+    this.end = end;
+};
+
+/**
+ * Get the string representation of the word
+ * @returns {*} the word as a string
+ */
+Word.prototype.getWord = function() {
+    return this.word;  
+};
+
+/**
+ * Get the time the word started being uttered
+ * @returns {*} the start time as an integer
+ */
+Word.prototype.getBeginTime = function () {
+    return this.begin;
+};
+
+/**
+ * Get the time the word stopped being uttered
+ * @returns {*} the end time as an integer
+ */
+Word.prototype.getEndTime = function () {
+    return this.end;
+};
+
+module.exports = Word;

modules/util/EventEmitterForwarder.js

+/**
+ * Implements utility to forward events from one eventEmitter to another.
+ * @param src {object} instance of EventEmitter or another class that implements
+ * addListener method which will register listener to EventEmitter instance.
+ * @param dest {object} instance of EventEmitter or another class that
+ * implements emit method which will emit an event.
+ */
+function EventEmitterForwarder (src, dest) {
+    if (!src || !dest || typeof(src.addListener) !== "function" ||
+        typeof(dest.emit) !== "function")
+        throw new Error("Invalid arguments passed to EventEmitterForwarder");
+    this.src = src;
+    this.dest = dest;
+}
+
+/**
+ * Adds event to be forwarded from src to dest.
+ * @param srcEvent {string} the event that EventEmitterForwarder is listening
+ * for.
+ * @param dstEvent {string} the event that will be fired from dest.
+ * @param arguments all other passed arguments are going to be fired with
+ * dstEvent.
+ */
+EventEmitterForwarder.prototype.forward = function () {
+    // This line is only for fixing jshint errors.
+    var args = arguments;
+    var srcEvent = args[0];
+    //This will be the "this" value for emit function.
+    args[0] = this.dest;
+    //Using bind.apply to pass the arguments as Array-like object ("arguments")
+    this.src.addListener(srcEvent,
+        Function.prototype.bind.apply(this.dest.emit, args));
+};
+
+module.exports = EventEmitterForwarder;

modules/util/ScriptUtil.js

+var currentExecutingScript = require("current-executing-script");
+
+
 /**
  * Implements utility functions which facilitate the dealing with scripts such
  * as the download and execution of a JavaScript file.
      * @param prepend true to schedule the loading of the script as soon as
      * possible or false to schedule the loading of the script at the end of the
      * scripts known at the time
+     * @param relativeURL whether we need load the library from url relative
+     * to the url that lib-jitsi-meet was loaded. Useful when sourcing the
+     * library from different location than the app that is using it
+     * @param loadCallback on load callback function
+     * @param errorCallback callback to be called on error loading the script
      */
-    loadScript: function (src, async, prepend) {
+    loadScript: function (src, async, prepend, relativeURL,
+                          loadCallback, errorCallback) {
         var d = document;
         var tagName = 'script';
         var script = d.createElement(tagName);
         var referenceNode = d.getElementsByTagName(tagName)[0];
 
         script.async = async;
+
+        if (relativeURL) {
+            // finds the src url of the current loaded script
+            // and use it as base of the src supplied argument
+            var scriptEl = currentExecutingScript();
+            if(scriptEl) {
+                var scriptSrc = scriptEl.src;
+                var baseScriptSrc
+                    = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
+                if (scriptSrc && baseScriptSrc)
+                    src = baseScriptSrc + src;
+            }
+        }
+
+        if (loadCallback)
+            script.onload = loadCallback;
+        if (errorCallback)
+            script.onerror = errorCallback;
+
         script.src = src;
         if (prepend) {
             referenceNode.parentNode.insertBefore(script, referenceNode);
         } else {
             referenceNode.parentNode.appendChild(script);
         }
-    },
+    }
 };
 
 module.exports = ScriptUtil;

modules/version/ComponentsVersions.js

  */
 ComponentsVersions.VIDEOBRIDGE_COMPONENT = "videobridge";
 /**
- * The contant for the name of the XMPP server component.
+ * The constant for the name of the XMPP server component.
  * @type {string}
  */
 ComponentsVersions.XMPP_SERVER_COMPONENT = "xmpp";
 
 /**
  * Creates new instance of <tt>ComponentsVersions</tt> which will be discovering
- * the versions of conferencing system components in given <tt>ChatRoom</tt>.
- * @param chatRoom <tt>ChatRoom</tt> instance which will be used to listen for
- *        focus presence updates.
+ * the versions of conferencing system components in given
+ * <tt>JitsiConference</tt>.
+ * @param conference <tt>JitsiConference</tt> instance which will be used to
+ *        listen for focus presence updates.
  * @constructor
  */
-function ComponentsVersions(chatRoom) {
+function ComponentsVersions(conference) {
 
     this.versions = {};
 
-    this.chatRoom = chatRoom;
-    this.chatRoom.addPresenceListener(
+    this.conference = conference;
+    this.conference.addCommandListener(
         'versions', this.processPresence.bind(this));
 }
 
 ComponentsVersions.prototype.processPresence =
-function(node, mucResource, mucJid) {
+    function(node, mucResource, mucJid) {
 
     if (node.attributes.xmlns !== 'http://jitsi.org/jitmeet') {
         logger.warn("Ignored presence versions node - invalid xmlns", node);
         return;
     }
 
-    if (!this.chatRoom.isFocus(mucJid)) {
+    if (!this.conference._isFocus(mucJid)) {
         logger.warn(
             "Received versions not from the focus user: " + node, mucJid);
         return;
     }
 
-    var log = "";
+    var log = [];
     node.children.forEach(function(item){
 
         var componentName = item.attributes.name;
             this.versions[componentName] = version;
             logger.info("Got " + componentName + " version: " + version);
 
-            log += (log.length > 0? ", " : "")
-                + componentName + ": " + version;
+            log.push({
+                id: "component_version",
+                component: componentName,
+                version: version});
         }
     }.bind(this));
 
     // logs versions to stats
     if (log.length > 0)
-        Statistics.sendLog(log);
+        Statistics.sendLog(JSON.stringify(log));
 };
 
 /**
 };
 
 module.exports = ComponentsVersions;
-

modules/xmpp/ChatRoom.js

 /* global Strophe, $, $pres, $iq, $msg */
-/* jshint -W101,-W069 */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var MediaType = require("../../service/RTC/MediaType");
 var Moderator = require("./moderator");
 var Recorder = require("./recording");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
-var JIBRI_XMLNS = 'http://jitsi.org/protocol/jibri';
-
 var parser = {
     packet2JSON: function (packet, nodes) {
         var self = this;
-        $(packet).children().each(function (index) {
+        $(packet).children().each(function () {
             var tagName = $(this).prop("tagName");
-            var node = {
+            const node = {
                 tagName: tagName
             };
             node.attributes = {};
         });
     },
     JSON2packet: function (nodes, packet) {
-        for(var i = 0; i < nodes.length; i++) {
-            var node = nodes[i];
+        for(let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
             if(!node || node === null){
                 continue;
             }
  */
 function filterNodeFromPresenceJSON(pres, nodeName){
     var res = [];
-    for(var i = 0; i < pres.length; i++)
+    for(let i = 0; i < pres.length; i++)
         if(pres[i].tagName === nodeName)
             res.push(pres[i]);
 
     this.presMap = {};
     this.presHandlers = {};
     this.joined = false;
-    this.role = 'none';
+    this.role = null;
     this.focusMucJid = null;
-    this.bridgeIsDown = false;
+    this.noBridgeAvailable = false;
     this.options = options || {};
     this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
         settings, {connection: this.xmpp.options, conference: this.options});
     this.initPresenceMap();
     this.session = null;
-    var self = this;
     this.lastPresences = {};
     this.phoneNumber = null;
     this.phonePin = null;
     this.connectionTimes = {};
     this.participantPropertyListener = null;
+
+    this.locked = false;
 }
 
 ChatRoom.prototype.initPresenceMap = function () {
 };
 
 ChatRoom.prototype.join = function (password) {
-    if(password)
-        this.password = password;
+    this.password = password;
     var self = this;
     this.moderator.allocateConferenceFocus(function () {
         self.sendPresence(true);
     }
 
     var pres = $pres({to: to });
-    pres.c('x', {xmlns: this.presMap['xns']});
 
-    if (this.password) {
-        pres.c('password').t(this.password).up();
-    }
+    // xep-0045 defines: "including in the initial presence stanza an empty
+    // <x/> element qualified by the 'http://jabber.org/protocol/muc' namespace"
+    // and subsequent presences should not include that or it can be considered
+    // as joining, and server can send us the message history for the room on
+    // every presence
+    if (fromJoin) {
+        pres.c('x', {xmlns: this.presMap['xns']});
 
-    pres.up();
+        if (this.password) {
+            pres.c('password').t(this.password).up();
+        }
+        pres.up();
+    }
 
     // Send XEP-0115 'c' stanza that contains our capabilities info
     var connection = this.connection;
     }
 };
 
-
+/**
+ * Sends the presence unavailable, signaling the server
+ * we want to leave the room.
+ */
 ChatRoom.prototype.doLeave = function () {
     logger.log("do leave", this.myroomjid);
     var pres = $pres({to: this.myroomjid, type: 'unavailable' });
     this.connection.flush();
 };
 
+ChatRoom.prototype.discoRoomInfo = function () {
+  // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
+
+  var getInfo = $iq({type: 'get', to: this.roomjid})
+    .c('query', {xmlns: Strophe.NS.DISCO_INFO});
+
+  this.connection.sendIQ(getInfo, function (result) {
+    var locked = $(result).find('>query>feature[var="muc_passwordprotected"]')
+        .length === 1;
+    if (locked != this.locked) {
+      this.eventEmitter.emit(XMPPEvents.MUC_LOCK_CHANGED, locked);
+      this.locked = locked;
+    }
+  }.bind(this), function (error) {
+    GlobalOnErrorHandler.callErrorHandler(error);
+    logger.error("Error getting room info: ", error);
+  }.bind(this));
+};
+
 
 ChatRoom.prototype.createNonAnonymousRoom = function () {
     // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
             return;
         }
 
-        var formSubmit = $iq({to: this.roomjid, type: 'set'})
+        var formSubmit = $iq({to: self.roomjid, type: 'set'})
             .c('query', {xmlns: 'http://jabber.org/protocol/muc#owner'});
 
         formSubmit.c('x', {xmlns: 'jabber:x:data', type: 'submit'});
     member.jid = jid;
     member.isFocus
         = jid && jid.indexOf(this.moderator.getFocusUserJid() + "/") === 0;
-
     member.isHiddenDomain
         = jid && jid.indexOf("@") > 0
             && this.options.hiddenDomain
-                === jid.substring(jid.indexOf("@") + 1, jid.indexOf("/"))
+                === jid.substring(jid.indexOf("@") + 1, jid.indexOf("/"));
 
     $(pres).find(">x").remove();
     var nodes = [];
     parser.packet2JSON(pres, nodes);
     this.lastPresences[from] = nodes;
-    var jibri = null;
+    let jibri = null;
     // process nodes to extract data needed for MUC_JOINED and MUC_MEMBER_JOINED
     // events
-    for(var i = 0; i < nodes.length; i++)
+    for(let i = 0; i < nodes.length; i++)
     {
-        var node = nodes[i];
+        const node = nodes[i];
         switch(node.tagName)
         {
             case "nick":
     }
 
     if (from == this.myroomjid) {
-        if (member.affiliation == 'owner' && this.role !== member.role) {
-            this.role = member.role;
+        var newRole = member.affiliation == "owner"? member.role : "none";
+        if (this.role !== newRole) {
+            this.role = newRole;
             this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
         }
         if (!this.joined) {
             var now = this.connectionTimes["muc.joined"] =
                 window.performance.now();
             logger.log("(TIME) MUC joined:\t", now);
+
+            // set correct initial state of locked
+            if (this.password)
+                this.locked = true;
+
             this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
         }
     } else if (this.members[from] === undefined) {
         this.members[from] = member;
         logger.log('entered', from, member);
         if (member.isFocus) {
-            this.focusMucJid = from;
-            if(!this.recording) {
-                this.recording = new Recorder(this.options.recordingType,
-                    this.eventEmitter, this.connection, this.focusMucJid,
-                    this.options.jirecon, this.roomjid);
-                if(this.lastJibri)
-                    this.recording.handleJibriPresence(this.lastJibri);
-            }
-            logger.info("Ignore focus: " + from + ", real JID: " + jid);
-        }
-        else {
+            this._initFocus(from, jid);
+        } else {
             this.eventEmitter.emit(
                 XMPPEvents.MUC_MEMBER_JOINED,
                 from, member.nick, member.role, member.isHiddenDomain);
                 XMPPEvents.MUC_ROLE_CHANGED, from, member.role);
         }
 
+        if (member.isFocus) {
+            // From time to time first few presences of the focus are not
+            // containing it's jid. That way we can mark later the focus member
+            // instead of not marking it at all and not starting the conference.
+            // FIXME: Maybe there is a better way to handle this issue. It seems
+            // there is some period of time in prosody that the configuration
+            // form is received but not applied. And if any participant joins
+            // during that period of time the first presence from the focus
+            // won't conain <item jid="focus..." />.
+            memberOfThis.isFocus = true;
+            this._initFocus(from, jid);
+        }
+
         // store the new display name
         if(member.displayName)
             memberOfThis.displayName = member.displayName;
 
     // after we had fired member or room joined events, lets fire events
     // for the rest info we got in presence
-    for(var i = 0; i < nodes.length; i++)
+    for(let i = 0; i < nodes.length; i++)
     {
-        var node = nodes[i];
+        const node = nodes[i];
         switch(node.tagName)
         {
             case "nick":
                     }
                 }
                 break;
-            case "bridgeIsDown":
-                if (member.isFocus && !this.bridgeIsDown) {
-                    this.bridgeIsDown = true;
+            case "bridgeNotAvailable":
+                if (member.isFocus && !this.noBridgeAvailable) {
+                    this.noBridgeAvailable = true;
                     this.eventEmitter.emit(XMPPEvents.BRIDGE_DOWN);
                 }
                 break;
             case "jibri-recording-status":
-                var jibri = node;
+                jibri = node;
                 break;
             case "call-control":
                 var att = node.attributes;
     }
 };
 
+/**
+ * Initialize some properties when the focus participant is verified.
+ * @param from jid of the focus
+ * @param mucJid the jid of the focus in the muc
+ */
+ChatRoom.prototype._initFocus = function (from, mucJid) {
+    this.focusMucJid = from;
+    if(!this.recording) {
+        this.recording = new Recorder(this.options.recordingType,
+            this.eventEmitter, this.connection, this.focusMucJid,
+            this.options.jirecon, this.roomjid);
+        if(this.lastJibri)
+            this.recording.handleJibriPresence(this.lastJibri);
+    }
+    logger.info("Ignore focus: " + from + ", real JID: " + mucJid);
+};
+
 /**
  * Sets the special listener to be used for "command"s whose name starts with
  * "jitsi_participant_".
             reason = reasonSelect.text();
         }
 
-        this.leave();
+        this._dispose();
 
         this.eventEmitter.emit(XMPPEvents.MUC_DESTROYED, reason);
-        delete this.connection.emuc.rooms[Strophe.getBareJidFromJid(from)];
+        this.connection.emuc.doLeave(this.roomjid);
         return true;
     }
 
     // Status code 110 indicates that this notification is "self-presence".
-    if (!$(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="110"]').length) {
+    var isSelfPresence = $(pres).find(
+            '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="110"]'
+        ).length !== 0;
+    var isKick = $(pres).find(
+            '>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="307"]'
+        ).length !== 0;
+
+    if (!isSelfPresence) {
         delete this.members[from];
         this.onParticipantLeft(from, false);
     }
     // If the status code is 110 this means we're leaving and we would like
     // to remove everyone else from our view, so we trigger the event.
-    else if (Object.keys(this.members).length > 1) {
-        for (var i in this.members) {
-            var member = this.members[i];
+    else if (Object.keys(this.members).length > 0) {
+        for (const i in this.members) {
+            const member = this.members[i];
             delete this.members[i];
             this.onParticipantLeft(i, member.isFocus);
         }
+        this.connection.emuc.doLeave(this.roomjid);
+
+        // we fire muc_left only if this is not a kick,
+        // kick has both statuses 110 and 307.
+        if (!isKick)
+            this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
     }
-    if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="307"]').length) {
-        if (this.myroomjid === from) {
-            this.leave();
-            this.eventEmitter.emit(XMPPEvents.KICKED);
-        }
+
+    if (isKick && this.myroomjid === from) {
+        this._dispose();
+        this.eventEmitter.emit(XMPPEvents.KICKED);
     }
 };
 
         }
     }
 
+    if (from==this.roomjid && $(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="104"]').length) {
+      this.discoRoomInfo();
+    }
+
     if (txt) {
         logger.log('chat', nick, txt);
         this.eventEmitter.emit(XMPPEvents.MESSAGE_RECEIVED,
             // result in reconnection from authorized domain.
             // We're either missing Jicofo/Prosody config for anonymous
             // domains or something is wrong.
-            this.eventEmitter.emit(XMPPEvents.ROOM_JOIN_ERROR, pres);
+            this.eventEmitter.emit(XMPPEvents.ROOM_JOIN_ERROR);
 
         } else {
             logger.warn('onPresError ', pres);
-            this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_ERROR, pres);
+            this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR);
         }
     } else if($(pres).find('>error>service-unavailable').length) {
         logger.warn('Maximum users limit for the room has been reached',
             pres);
-        this.eventEmitter.emit(XMPPEvents.ROOM_MAX_USERS_ERROR, pres);
+        this.eventEmitter.emit(XMPPEvents.ROOM_MAX_USERS_ERROR);
     } else {
         logger.warn('onPresError ', pres);
-        this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_ERROR, pres);
+        this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_ERROR);
     }
 };
 
  * Checks if the user identified by given <tt>mucJid</tt> is the conference
  * focus.
  * @param mucJid the full MUC address of the user to be checked.
- * @returns {boolean} <tt>true</tt> if MUC user is the conference focus.
+ * @returns {boolean|null} <tt>true</tt> if MUC user is the conference focus or
+ * <tt>false</tt> if is not. When given <tt>mucJid</tt> does not exist in
+ * the MUC then <tt>null</tt> is returned.
  */
 ChatRoom.prototype.isFocus = function (mucJid) {
     var member = this.members[mucJid];
     return this.session.generateNewStreamSSRCInfo();
 };
 
-ChatRoom.prototype.setVideoMute = function (mute, callback, options) {
+ChatRoom.prototype.setVideoMute = function (mute, callback) {
     this.sendVideoInfoPresence(mute);
     if(callback)
         callback(mute);
             mutedNode = filterNodeFromPresenceJSON(pres, "audiomuted");
         } else if (mediaType === MediaType.VIDEO) {
             mutedNode = filterNodeFromPresenceJSON(pres, "videomuted");
+            var videoTypeNode = filterNodeFromPresenceJSON(pres, "videoType");
+            if(videoTypeNode
+                && videoTypeNode.length > 0
+                && videoTypeNode[0])
+                data.videoType = videoTypeNode[0]["value"];
         } else {
             logger.warn("Unsupported media type: " + mediaType);
             data.muted = null;
  */
 ChatRoom.prototype.getRecordingState = function () {
     return (this.recording) ? this.recording.getState() : undefined;
-}
+};
 
 /**
  * Returns the url of the recorded video.
  */
 ChatRoom.prototype.getRecordingURL = function () {
     return (this.recording) ? this.recording.getURL() : null;
-}
+};
 
 /**
  * Starts/stops the recording
 
 /**
  * Leaves the room. Closes the jingle session.
+ * @returns {Promise} which is resolved if XMPPEvents.MUC_LEFT is received less
+ * than 5s after sending presence unavailable. Otherwise the promise is
+ * rejected.
  */
 ChatRoom.prototype.leave = function () {
+    this._dispose();
+    return new Promise((resolve, reject) => {
+        let timeout = setTimeout(() => onMucLeft(true), 5000);
+        let eventEmitter = this.eventEmitter;
+        function onMucLeft(doReject = false) {
+            eventEmitter.removeListener(XMPPEvents.MUC_LEFT, onMucLeft);
+            clearTimeout(timeout);
+            if(doReject) {
+                // the timeout expired
+                reject(new Error("The timeout for the confirmation about " +
+                    "leaving the room expired."));
+            } else {
+                resolve();
+            }
+        }
+        eventEmitter.on(XMPPEvents.MUC_LEFT, onMucLeft);
+        this.doLeave();
+    });
+};
+
+/**
+ * Disposes the conference, closes the jingle session.
+ */
+ChatRoom.prototype._dispose = function () {
     if (this.session) {
         this.session.close();
     }
-    this.eventEmitter.emit(XMPPEvents.DISPOSE_CONFERENCE);
-    this.doLeave();
-    this.connection.emuc.doLeave(this.roomjid);
 };
 
 module.exports = ChatRoom;

modules/xmpp/ConnectionPlugin.js

+/**
+ * Base class for strophe connection plugins.
+ */
+export default class ConnectionPlugin {
+    constructor() {
+        this.connection = null;
+    }
+    init (connection) {
+        this.connection = connection;
+    }
+}

modules/xmpp/JingleSession.js

  * have different implementations depending on the underlying interface used
  * (i.e. WebRTC and ORTC) and here we hold the code common to all of them.
  */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+
+import * as JingleSessionState from "./JingleSessionState";
 
 function JingleSession(me, sid, peerjid, connection,
                        media_constraints, ice_config, service, eventEmitter) {
     // The chat room instance associated with the session.
     this.room = null;
 
-    // Jingle session state - uninitialized until 'initialize' is called
+    /**
+     * Jingle session state - uninitialized until {@link initialize} is called
+     * @type {JingleSessionState}
+     */
     this.state = null;
 }
 
         throw new Error(errmsg);
     }
     this.room = room;
-    this.state = 'pending';
+    this.state = JingleSessionState.PENDING;
     this.initiator = isInitiator ? this.me : this.peerjid;
     this.responder = !isInitiator ? this.me : this.peerjid;
     this.doInitialize();
  * Adds the ICE candidates found in the 'contents' array as remote candidates?
  * Note: currently only used on transport-info
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.addIceCandidates = function(contents) {};
 
 /**
- * Checks if this JingleSession is in 'active' state which means that the call
- * is in progress.
- * @returns {boolean} <tt>true</tt> if this JingleSession is in 'active' state
- *          or <tt>false</tt> otherwise.
+ * Returns current state of this <tt>JingleSession</tt> instance.
+ * @returns {JingleSessionState} the current state of this session instance.
  */
-JingleSession.prototype.active = function () {
-    return this.state === 'active';
+JingleSession.prototype.getState = function () {
+    return this.state;
 };
 
 /**
  *
  * @param contents an array of Jingle 'content' elements.
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.addSources = function(contents) {};
 
 /**
  *
  * @param contents an array of Jingle 'content' elements.
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.removeSources = function(contents) {};
 
 /**
  * Terminates this Jingle session by sending session-terminate
  * @param reason XMPP Jingle error condition
  * @param text some meaningful error message
+ * @param success a callback called once the 'session-terminate' packet has been
+ * acknowledged with RESULT.
+ * @param failure a callback called when either timeout occurs or ERROR response
+ * is received.
  */
-JingleSession.prototype.terminate = function(reason, text) {};
+// eslint-disable-next-line no-unused-vars
+JingleSession.prototype.terminate = function(reason, text, success, failure) {};
 
 /**
  * Handles an offer from the remote peer (prepares to accept a session).
  *        object with details(which is meant more to be printed to the logger
  *        than analysed in the code, as the error is unrecoverable anyway)
  */
+// eslint-disable-next-line no-unused-vars
 JingleSession.prototype.acceptOffer = function(jingle, success, failure) {};
 
 module.exports = JingleSession;

modules/xmpp/JingleSessionPC.js

-/* jshint -W117 */
+/* global $, $iq */
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 var JingleSession = require("./JingleSession");
 var TraceablePeerConnection = require("./TraceablePeerConnection");
-var MediaType = require("../../service/RTC/MediaType");
 var SDPDiffer = require("./SDPDiffer");
 var SDPUtil = require("./SDPUtil");
 var SDP = require("./SDP");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+var Statistics = require("../statistics/statistics");
+
+import * as JingleSessionState from "./JingleSessionState";
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
     this.jingleOfferIq = null;
     this.webrtcIceUdpDisable = !!this.service.options.webrtcIceUdpDisable;
     this.webrtcIceTcpDisable = !!this.service.options.webrtcIceTcpDisable;
+    /**
+     * Flag used to enforce ICE failure through the URL parameter for
+     * the automatic testing purpose.
+     * @type {boolean}
+     */
+    this.failICE = !!this.service.options.failICE;
 
     this.modifySourcesQueue = async.queue(this._modifySources.bind(this), 1);
 }
             var protocol = candidate.protocol;
             if (typeof protocol === 'string') {
                 protocol = protocol.toLowerCase();
-                if (protocol == 'tcp') {
+                if (protocol === 'tcp' || protocol ==='ssltcp') {
                     if (self.webrtcIceTcpDisable)
                         return;
                 } else if (protocol == 'udp') {
     this.peerconnection.onremovestream = function (event) {
         self.remoteStreamRemoved(event.stream);
     };
-    this.peerconnection.onsignalingstatechange = function (event) {
+    this.peerconnection.onsignalingstatechange = function () {
         if (!(self && self.peerconnection)) return;
         if (self.peerconnection.signalingState === 'stable') {
             self.wasstable = true;
         }
     };
     /**
-     * The oniceconnectionstatechange event handler contains the code to execute when the iceconnectionstatechange event,
-     * of type Event, is received by this RTCPeerConnection. Such an event is sent when the value of
+     * The oniceconnectionstatechange event handler contains the code to execute
+     * when the iceconnectionstatechange event, of type Event, is received by
+     * this RTCPeerConnection. Such an event is sent when the value of
      * RTCPeerConnection.iceConnectionState changes.
-     *
-     * @param event the event containing information about the change
      */
-    this.peerconnection.oniceconnectionstatechange = function (event) {
+    this.peerconnection.oniceconnectionstatechange = function () {
         if (!(self && self.peerconnection)) return;
         var now = window.performance.now();
         self.room.connectionTimes["ice.state." +
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
+        Statistics.analytics.sendEvent(
+            'ice.' + self.peerconnection.iceConnectionState, {value: now});
+        self.room.eventEmitter.emit(
+            XMPPEvents.ICE_CONNECTION_STATE_CHANGED,
+            self.peerconnection.iceConnectionState);
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 
                 break;
         }
     };
-    this.peerconnection.onnegotiationneeded = function (event) {
+    this.peerconnection.onnegotiationneeded = function () {
         self.room.eventEmitter.emit(XMPPEvents.PEERCONNECTION_READY, self);
     };
 };
                 name: (cands[0].sdpMid? cands[0].sdpMid : mline.media)
             }).c('transport', ice);
             for (var i = 0; i < cands.length; i++) {
-                cand.c('candidate', SDPUtil.candidateToJingle(cands[i].candidate)).up();
+                var candidate = SDPUtil.candidateToJingle(cands[i].candidate);
+                // Mangle ICE candidate if 'failICE' test option is enabled
+                if (this.service.options.failICE) {
+                    candidate.ip = "1.1.1.1";
+                }
+                cand.c('candidate', candidate).up();
             }
             // add fingerprint
             var fingerprint_line = SDPUtil.find_line(this.localSDP.media[mid], 'a=fingerprint:', this.localSDP.session);
 JingleSessionPC.prototype.readSsrcInfo = function (contents) {
     var self = this;
     $(contents).each(function (idx, content) {
-        var name = $(content).attr('name');
-        var mediaType = this.getAttribute('name');
         var ssrcs = $(content).find('description>source[xmlns="urn:xmpp:jingle:apps:rtp:ssma:0"]');
         ssrcs.each(function () {
             var ssrc = this.getAttribute('ssrc');
  */
 JingleSessionPC.prototype.acceptOffer = function(jingleOffer,
                                                  success, failure) {
-    this.state = 'active';
+    this.state = JingleSessionState.ACTIVE;
     this.setOfferCycle(jingleOffer,
         function() {
             // setOfferCycle succeeded, now we have self.localSDP up to date
     if (this.webrtcIceUdpDisable) {
         localSDP.removeUdpCandidates = true;
     }
+    if (this.failICE) {
+        localSDP.failICE = true;
+    }
     localSDP.toJingle(
         accept,
         this.initiator == this.me ? 'initiator' : 'responder',
     // Calling tree() to print something useful
     accept = accept.tree();
     logger.info("Sending session-accept", accept);
-
+    var self = this;
     this.connection.sendIQ(accept,
         success,
-        this.newJingleErrorHandler(accept, failure),
+        this.newJingleErrorHandler(accept, function (error) {
+            failure(error);
+            // 'session-accept' is a critical timeout and we'll have to restart
+            self.room.eventEmitter.emit(XMPPEvents.SESSION_ACCEPT_TIMEOUT);
+        }),
         IQ_TIMEOUT);
     // XXX Videobridge needs WebRTC's answer (ICE ufrag and pwd, DTLS
     // fingerprint and setup) ASAP in order to start the connection
     // establishment.
-    this.connection.flush();
+    //
+    // FIXME Flushing the connection at this point triggers an issue with BOSH
+    // request handling in Prosody on slow connections.
+    //
+    // The problem is that this request will be quite large and it may take time
+    // before it reaches Prosody. In the meantime Strophe may decide to send
+    // the next one. And it was observed that a small request with
+    // 'transport-info' usually follows this one. It does reach Prosody before
+    // the previous one was completely received. 'rid' on the server is
+    // increased and Prosody ignores the request with 'session-accept'. It will
+    // never reach Jicofo and everything in the request table is lost. Removing
+    // the flush does not guarantee it will never happen, but makes it much less
+    // likely('transport-info' is bundled with 'session-accept' and any
+    // immediate requests).
+    //
+    // this.connection.flush();
 };
 
 /**
         IQ_TIMEOUT);
 };
 
-//FIXME: I think this method is not used!
+/**
+ * @inheritDoc
+ */
 JingleSessionPC.prototype.terminate = function (reason,  text,
                                                 success, failure) {
+    this.state = JingleSessionState.ENDED;
+
     var term = $iq({to: this.peerjid,
         type: 'set'})
         .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
     // FIXME: dirty waiting
     if (!this.peerconnection.localDescription)
     {
-        logger.warn("addSource - localDescription not ready yet")
+        logger.warn("addSource - localDescription not ready yet");
         setTimeout(function()
             {
                 self.addSource(elem);
         if (this.webrtcIceUdpDisable) {
             sdp.removeUdpCandidates = true;
         }
+        if (this.failICE) {
+            sdp.failICE = true;
+        }
 
         sdp.fromJingle(this.jingleOfferIq);
         this.readSsrcInfo($(this.jingleOfferIq).find(">content"));
     this.removessrc = [];
 
     sdp.raw = sdp.session + sdp.media.join('');
+
     /**
      * Implements a failure callback which reports an error message and an
      * optional error through (1) logger, (2) GlobalOnErrorHandler, and (3)
      * queueCallback.
      *
-     * @param {string} errmsg the error messsage to report
+     * @param {string} errmsg the error message to report
      * @param {*} error an optional error to report in addition to errmsg
      */
     function reportError(errmsg, err) {
         }
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         queueCallback(err);
-    };
+    }
 
     var ufrag = getUfrag(sdp.raw);
     if (ufrag != self.remoteUfrag) {
             errorCallback(error);
         }
     });
-}
+};
 
 /**
  * Generate ssrc info object for a stream with the following properties:
             errorCallback(error);
         }
     });
-}
+};
 
 /**
  * Figures out added/removed ssrcs and send update IQs.
  */
 JingleSessionPC.prototype.notifyMySSRCUpdate = function (old_sdp, new_sdp) {
 
-    if (!(this.peerconnection.signalingState == 'stable' &&
-        this.peerconnection.iceConnectionState == 'connected')){
-        logger.log("Too early to send updates");
+    if (this.state !== JingleSessionState.ACTIVE){
+        logger.warn(
+            "Skipping SSRC update in \'" + this.state + " \' state.");
         return;
     }
 
             error.source = request.tree();
         }
 
-        error.session = this;
+        // Commented to fix JSON.stringify(error) exception for circular
+        // dependancies when we print that error.
+        // FIXME: Maybe we can include part of the session object
+        // error.session = this;
 
         logger.error("Jingle error", error);
         if (failureCb) {
     var ufragLines = sdp.split('\n').filter(function(line) {
         return line.startsWith("a=ice-ufrag:");});
     if (ufragLines.length > 0) {
-        return ufragLines[0].substr("a=ice-ufrag:".length)
+        return ufragLines[0].substr("a=ice-ufrag:".length);
     }
 }
 

modules/xmpp/JingleSessionState.js

+/**
+ * The pending Jingle session state which means the session as defined in
+ * XEP-0166(before 'session-invite/session-accept' took place).
+ *
+ * @type {string}
+ */
+export const PENDING = 'pending';
+
+/**
+ * The active Jingle session state as defined in XEP-0166
+ * (after 'session-invite'/'session-accept').
+ *
+ * @type {string}
+ */
+export const ACTIVE = 'active';
+
+/**
+ * The ended Jingle session state as defined in XEP-0166
+ * (after 'session-terminate').
+ * @type {string}
+ */
+export const ENDED = 'ended';

modules/xmpp/SDP.js

-/* jshint -W117 */
+/* global $, APP */
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
 var SDPUtil = require("./SDPUtil");
 
 // SDP STUFF
     this.session = session;
 }
 
+/**
+ * A flag will make {@link transportToJingle} and {@link jingle2media} replace
+ * ICE candidates IPs with invalid value of '1.1.1.1' which will cause ICE
+ * failure. The flag is used in the automated testing.
+ * @type {boolean}
+ */
+SDP.prototype.failICE = false;
+
 /**
  * Whether or not to remove TCP ice candidates when translating from/to jingle.
  * @type {boolean}
     });
     this.raw = this.session + this.media.join('');
     return lines;
-}
+};
 // remove lines matching prefix from a media section specified by mediaindex
 // TODO: non-numeric mediaindex could match mid
 SDP.prototype.removeMediaLines = function(mediaindex, prefix) {
     });
     this.raw = this.session + this.media.join('');
     return lines;
-}
+};
 
 // add content's to a jingle element
 SDP.prototype.toJingle = function (elem, thecreator) {
-//    logger.log("SSRC" + ssrcs["audio"] + " - " + ssrcs["video"]);
-    var self = this;
     var i, j, k, mline, ssrc, rtpmap, tmp, lines;
     // new bundle plan
     lines = SDPUtil.find_lines(this.session, 'a=group:');
             var lines = SDPUtil.find_lines(this.media[mediaindex], 'a=candidate:', this.session);
             lines.forEach(function (line) {
                 var candidate = SDPUtil.candidateToJingle(line);
+                if (self.failICE) {
+                    candidate.ip = "1.1.1.1";
+                }
                 var protocol = (candidate &&
                         typeof candidate.protocol === 'string')
                     ? candidate.protocol.toLowerCase() : '';
-                if ((self.removeTcpCandidates && protocol === 'tcp') ||
+                if ((self.removeTcpCandidates
+                        && (protocol === 'tcp' || protocol === 'ssltcp')) ||
                     (self.removeUdpCandidates && protocol === 'udp')) {
                     return;
                 }
         }
     }
     elem.up(); // end of transport
-}
+};
 
 SDP.prototype.rtcpFbToJingle = function (mediaindex, elem, payloadtype) { // XEP-0293
     var lines = SDPUtil.find_lines(this.media[mediaindex], 'a=rtcp-fb:' + payloadtype);
 SDP.prototype.jingle2media = function (content) {
     var media = '',
         desc = content.find('description'),
-        ssrc = desc.attr('ssrc'),
         self = this,
         tmp;
     var sctp = content.find(
         var protocol = this.getAttribute('protocol');
         protocol = (typeof protocol === 'string') ? protocol.toLowerCase(): '';
 
-        if ((self.removeTcpCandidates && protocol === 'tcp') ||
+        if ((self.removeTcpCandidates
+                && (protocol === 'tcp' || protocol === 'ssltcp')) ||
             (self.removeUdpCandidates && protocol === 'udp')) {
             return;
+        } else  if (self.failICE) {
+            this.setAttribute('ip', '1.1.1.1');
         }
 
         media += SDPUtil.candidateFromJingle(this);

modules/xmpp/SDPUtil.js

-var logger = require("jitsi-meet-logger").getLogger(__filename);
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 
 
-SDPUtil = {
+var SDPUtil = {
     filter_special_chars: function (text) {
         // XXX Neither one of the falsy values (e.g. null, undefined, false,
         // "", etc.) "contain" special chars.

modules/xmpp/TraceablePeerConnection.js

-/* global $ */
+/* global mozRTCPeerConnection, webkitRTCPeerConnection */
+
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 var RTC = require('../RTC/RTC');
-var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var transform = require('sdp-transform');
             var ssrcOperation = SSRCs[0];
             switch(ssrcOperation.type) {
                 case "mute":
-                case "addMuted":
+                case "addMuted": {
                 //FIXME: If we want to support multiple streams we have to add
                 // recv-only ssrcs for the
                 // muted streams on every change until the stream is unmuted
                 // in the SDP
                     if(!bLine.ssrcs)
                         bLine.ssrcs = [];
-                    var groups = ssrcOperation.ssrc.groups;
-                    var ssrc = null;
+                    const groups = ssrcOperation.ssrc.groups;
+                    let ssrc = null;
                     if(groups && groups.length) {
                         ssrc = groups[0].primarySSRC;
                     } else if(ssrcOperation.ssrc.ssrcs &&
                     // only 1 video stream that is muted.
                     this.recvOnlySSRCs[bLine.type] = ssrc;
                     break;
-                case "unmute":
+                }
+                case "unmute": {
                     if(!ssrcOperation.ssrc || !ssrcOperation.ssrc.ssrcs ||
                         !ssrcOperation.ssrc.ssrcs.length)
                         break;
                     var ssrcMap = {};
                     var ssrcLastIdx = ssrcOperation.ssrc.ssrcs.length - 1;
                     for(var i = 0; i < bLine.ssrcs.length; i++) {
-                        var ssrc = bLine.ssrcs[i];
+                        const ssrc = bLine.ssrcs[i];
                         if (ssrc.attribute !== 'msid' &&
                             ssrc.value !== ssrcOperation.msid) {
                             continue;
                         if(ssrcLastIdx < 0)
                             break;
                     }
-                    var groups = ssrcOperation.ssrc.groups;
+                    const groups = ssrcOperation.ssrc.groups;
                     if (typeof bLine.ssrcGroups !== 'undefined' &&
                         Array.isArray(bLine.ssrcGroups) && groups &&
                         groups.length) {
                     // Storing the unmuted SSRCs.
                     permSSRCs.push(ssrcOperation);
                     break;
+                }
                 default:
-                break;
+                    break;
             }
             SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
         }
 
         if (!Array.isArray(bLine.ssrcs) || bLine.ssrcs.length === 0)
         {
-            var ssrc = this.recvOnlySSRCs[bLine.type]
+            const ssrc = this.recvOnlySSRCs[bLine.type]
                 = this.recvOnlySSRCs[bLine.type] ||
                     RandomUtil.randomInt(1, 0xffffffff);
             bLine.ssrcs = [{
         // Removing all cached ssrcs for the streams that are removed or
         // muted.
         if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype]) {
-            for(i = 0; i < this.replaceSSRCs[ssrcInfo.mtype].length; i++) {
+            for(var i = 0; i < this.replaceSSRCs[ssrcInfo.mtype].length; i++) {
                 var op = this.replaceSSRCs[ssrcInfo.mtype][i];
                 if(op.type === "unmute" &&
                     op.ssrc.ssrcs.join("_") ===
     this.trace('createAnswer', JSON.stringify(constraints, null, ' '));
     this.peerconnection.createAnswer(
         function (answer) {
-            self.trace('createAnswerOnSuccess::preTransform', dumpSDP(answer));
-            // if we're running on FF, transform to Plan A first.
-            if (RTCBrowserType.usesUnifiedPlan()) {
-                answer = self.interop.toPlanB(answer);
-                self.trace('createAnswerOnSuccess::postTransform (Plan B)',
-                    dumpSDP(answer));
-            }
-
-            if (!self.session.room.options.disableSimulcast
-                && self.simulcast.isSupported()) {
-                answer = self.simulcast.mungeLocalDescription(answer);
-                self.trace('createAnswerOnSuccess::postTransform (simulcast)',
-                    dumpSDP(answer));
-            }
+            try {
+                self.trace(
+                    'createAnswerOnSuccess::preTransform', dumpSDP(answer));
+                // if we're running on FF, transform to Plan A first.
+                if (RTCBrowserType.usesUnifiedPlan()) {
+                    answer = self.interop.toPlanB(answer);
+                    self.trace('createAnswerOnSuccess::postTransform (Plan B)',
+                        dumpSDP(answer));
+                }
 
-            if (!RTCBrowserType.isFirefox())
-            {
-                answer = self.ssrcReplacement(answer);
-                self.trace('createAnswerOnSuccess::mungeLocalVideoSSRC',
-                    dumpSDP(answer));
-            }
+                if (!self.session.room.options.disableSimulcast
+                    && self.simulcast.isSupported()) {
+                    answer = self.simulcast.mungeLocalDescription(answer);
+                    self.trace(
+                        'createAnswerOnSuccess::postTransform (simulcast)',
+                        dumpSDP(answer));
+                }
 
-            self.eventEmitter.emit(XMPPEvents.SENDRECV_STREAMS_CHANGED,
-                extractSSRCMap(answer));
+                if (!RTCBrowserType.isFirefox())
+                {
+                    answer = self.ssrcReplacement(answer);
+                    self.trace('createAnswerOnSuccess::mungeLocalVideoSSRC',
+                        dumpSDP(answer));
+                }
 
-            successCallback(answer);
+                self.eventEmitter.emit(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                    extractSSRCMap(answer));
+
+                successCallback(answer);
+            } catch (e) {
+                // there can be error modifying the answer, for example
+                // for ssrcReplacement there was a track with ssrc that is null
+                // and if we do not catch the error no callback is called
+                // at all
+                self.trace('createAnswerOnError', e);
+                self.trace('createAnswerOnError', dumpSDP(answer));
+                logger.error('createAnswerOnError', e, dumpSDP(answer));
+                failureCallback(e);
+            }
         },
         function(err) {
             self.trace('createAnswerOnFailure', err);
 };
 
 TraceablePeerConnection.prototype.addIceCandidate
+        // eslint-disable-next-line no-unused-vars
         = function (candidate, successCallback, failureCallback) {
     //var self = this;
     this.trace('addIceCandidate', JSON.stringify(candidate, null, ' '));

modules/xmpp/moderator.js

                 value: true
             }).up();
     //}
-    if (this.options.conference.enableLipSync !== undefined) {
-        elem.c(
-            'property', {
-                name: 'enableLipSync',
-                value: this.options.conference.enableLipSync
-            }).up();
-    }
+    elem.c(
+        'property', {
+            name: 'enableLipSync',
+            value: false !== this.options.connection.enableLipSync
+        }).up();
     if (this.options.conference.audioPacketDelay !== undefined) {
         elem.c(
             'property', {
             name: 'simulcastMode',
             value: 'rewriting'
         }).up();
+
+    if (this.options.conference.useRoomAsSharedDocumentName !== undefined) {
+        elem.c(
+            'property', {
+                name: 'useRoomAsSharedDocumentName',
+                value: this.options.conference.useRoomAsSharedDocumentName
+            }).up();
+    }
     elem.up();
     return elem;
 };
                 });
         return;
     }
+    if(this.retries >= this.maxRetries) {
+        self.eventEmitter.emit(
+                XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR);
+        return;
+    }
+    this.retries++;
     var waitMs = self.getNextErrorTimeout();
     var errmsg = "Focus error, retry after "+ waitMs;
     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));

modules/xmpp/recording.js

-/* global $, $iq, config, connection, focusMucJid, messageHandler,
-   Toolbar, Util, Promise */
+/* global $, $iq */
+
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var JitsiRecorderErrors = require("../../JitsiRecorderErrors");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
 
 function Recording(type, eventEmitter, connection, focusMucJid, jirecon,
     roomjid) {
 };
 
 Recording.prototype.setRecordingJirecon =
-    function (state, callback, errCallback, options) {
+    function (state, callback, errCallback) {
 
     if (state == this.state){
         errCallback(new Error("Invalid state!"));

modules/xmpp/strophe.emuc.js

-/* jshint -W117 */
 /* a simple MUC connection plugin
  * can only handle a single MUC room
  */
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var ChatRoom = require("./ChatRoom");
-
-module.exports = function(XMPP) {
-    Strophe.addConnectionPlugin('emuc', {
-        connection: null,
-        rooms: {},//map with the rooms
-        init: function (conn) {
-            this.connection = conn;
-            // add handlers (just once)
-            this.connection.addHandler(this.onPresence.bind(this), null,
-                'presence', null, null, null, null);
-            this.connection.addHandler(this.onPresenceUnavailable.bind(this),
-                null, 'presence', 'unavailable', null);
-            this.connection.addHandler(this.onPresenceError.bind(this), null,
-                'presence', 'error', null);
-            this.connection.addHandler(this.onMessage.bind(this), null,
-                'message', null, null);
-            this.connection.addHandler(this.onMute.bind(this),
-                'http://jitsi.org/jitmeet/audio', 'iq', 'set',null,null);
-        },
-        createRoom: function (jid, password, options, settings) {
-            var roomJid = Strophe.getBareJidFromJid(jid);
-            if (this.rooms[roomJid]) {
-                var errmsg = "You are already in the room!";
-                logger.error(errmsg);
-                throw new Error(errmsg);
-                return;
-            }
-            this.rooms[roomJid] = new ChatRoom(this.connection, jid,
-                password, XMPP, options, settings);
-            return this.rooms[roomJid];
-        },
-        doLeave: function (jid) {
-            delete this.rooms[jid];
-        },
-        onPresence: function (pres) {
-            var from = pres.getAttribute('from');
-
-            // What is this for? A workaround for something?
-            if (pres.getAttribute('type')) {
-                return true;
-            }
-
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
-
-            // Parse status.
-            if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="201"]').length) {
-                room.createNonAnonymousRoom();
-            }
-
-            room.onPresence(pres);
+/* global $, Strophe */
 
-            return true;
-        },
-        onPresenceUnavailable: function (pres) {
-            var from = pres.getAttribute('from');
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
-
-            room.onPresenceUnavailable(pres, from);
-            return true;
-        },
-        onPresenceError: function (pres) {
-            var from = pres.getAttribute('from');
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
-
-            room.onPresenceError(pres, from);
-            return true;
-        },
-        onMessage: function (msg) {
-            // FIXME: this is a hack. but jingle on muc makes nickchanges hard
-            var from = msg.getAttribute('from');
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
-
-            room.onMessage(msg, from);
-            return true;
-        },
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import ChatRoom from "./ChatRoom";
+import ConnectionPlugin from "./ConnectionPlugin";
+
+class MucConnectionPlugin extends ConnectionPlugin {
+    constructor(xmpp) {
+        super();
+        this.xmpp = xmpp;
+        this.rooms = {};
+    }
+
+    init (connection) {
+        super.init(connection);
+        // add handlers (just once)
+        this.connection.addHandler(this.onPresence.bind(this), null,
+            'presence', null, null, null, null);
+        this.connection.addHandler(this.onPresenceUnavailable.bind(this),
+            null, 'presence', 'unavailable', null);
+        this.connection.addHandler(this.onPresenceError.bind(this), null,
+            'presence', 'error', null);
+        this.connection.addHandler(this.onMessage.bind(this), null,
+            'message', null, null);
+        this.connection.addHandler(this.onMute.bind(this),
+            'http://jitsi.org/jitmeet/audio', 'iq', 'set',null,null);
+    }
 
-        setJingleSession: function (from, session) {
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
+    createRoom (jid, password, options, settings) {
+        const roomJid = Strophe.getBareJidFromJid(jid);
+        if (this.rooms[roomJid]) {
+            const errmsg = "You are already in the room!";
+            logger.error(errmsg);
+            throw new Error(errmsg);
+        }
+        this.rooms[roomJid] = new ChatRoom(this.connection, jid,
+            password, this.xmpp, options, settings);
+        return this.rooms[roomJid];
+    }
 
-            room.setJingleSession(session);
-        },
+    doLeave (jid) {
+        delete this.rooms[jid];
+    }
 
-        onMute: function(iq) {
-            var from = iq.getAttribute('from');
-            var room = this.rooms[Strophe.getBareJidFromJid(from)];
-            if(!room)
-                return;
+    onPresence (pres) {
+        const from = pres.getAttribute('from');
 
-            room.onMute(iq);
+        // What is this for? A workaround for something?
+        if (pres.getAttribute('type')) {
             return true;
         }
-    });
-};
+
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        // Parse status.
+        if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]' +
+            '>status[code="201"]').length) {
+            room.createNonAnonymousRoom();
+        }
+
+        room.onPresence(pres);
+
+        return true;
+    }
+
+    onPresenceUnavailable (pres) {
+        const from = pres.getAttribute('from');
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        room.onPresenceUnavailable(pres, from);
+        return true;
+    }
+
+    onPresenceError (pres) {
+        const from = pres.getAttribute('from');
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        room.onPresenceError(pres, from);
+        return true;
+    }
+
+    onMessage (msg) {
+        // FIXME: this is a hack. but jingle on muc makes nickchanges hard
+        const from = msg.getAttribute('from');
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        room.onMessage(msg, from);
+        return true;
+    }
+
+    setJingleSession (from, session) {
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        room.setJingleSession(session);
+    }
+
+    onMute(iq) {
+        const from = iq.getAttribute('from');
+        const room = this.rooms[Strophe.getBareJidFromJid(from)];
+        if(!room)
+            return;
+
+        room.onMute(iq);
+        return true;
+    }
+}
+
+export default function(XMPP) {
+    Strophe.addConnectionPlugin('emuc', new MucConnectionPlugin(XMPP));
+}

modules/xmpp/strophe.jingle.js

-/* jshint -W117 */
+/* global $, $iq, Strophe */
 
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import JingleSession from "./JingleSessionPC";
+import XMPPEvents from "../../service/xmpp/XMPPEvents";
+import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
+import Statistics from "../statistics/statistics";
+import ConnectionPlugin from "./ConnectionPlugin";
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var JingleSession = require("./JingleSessionPC");
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
-var RTCBrowserType = require("../RTC/RTCBrowserType");
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-
-
-module.exports = function(XMPP, eventEmitter) {
-    Strophe.addConnectionPlugin('jingle', {
-        connection: null,
-        sessions: {},
-        ice_config: {iceServers: []},
-        media_constraints: {
+class JingleConnectionPlugin extends ConnectionPlugin {
+    constructor(xmpp, eventEmitter) {
+        super();
+        this.xmpp = xmpp;
+        this.eventEmitter = eventEmitter;
+        this.sessions = {};
+        this.ice_config = {iceServers: []};
+        this.media_constraints = {
             mandatory: {
                 'OfferToReceiveAudio': true,
                 'OfferToReceiveVideo': true
             }
             // MozDontOfferDataChannel: true when this is firefox
-        },
-        init: function (conn) {
-            this.connection = conn;
-            this.connection.addHandler(this.onJingle.bind(this), 'urn:xmpp:jingle:1', 'iq', 'set', null, null);
-        },
-        onJingle: function (iq) {
-            var sid = $(iq).find('jingle').attr('sid');
-            var action = $(iq).find('jingle').attr('action');
-            var fromJid = iq.getAttribute('from');
-            // send ack first
-            var ack = $iq({type: 'result',
-                to: fromJid,
-                id: iq.getAttribute('id')
-            });
-            logger.log('on jingle ' + action + ' from ' + fromJid, iq);
-            var sess = this.sessions[sid];
-            if ('session-initiate' != action) {
-                if (!sess) {
-                    ack.attrs({ type: 'error' });
-                    ack.c('error', {type: 'cancel'})
-                        .c('item-not-found', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up()
-                        .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
-                    logger.warn('invalid session id', iq);
-                    this.connection.send(ack);
-                    return true;
-                }
-                // local jid is not checked
-                if (fromJid != sess.peerjid) {
-                    logger.warn(
-                        'jid mismatch for session id', sid, sess.peerjid, iq);
-                    ack.attrs({ type: 'error' });
-                    ack.c('error', {type: 'cancel'})
-                        .c('item-not-found', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up()
-                        .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
-                    this.connection.send(ack);
-                    return true;
-                }
-            } else if (sess !== undefined) {
-                // existing session with same session id
-                // this might be out-of-order if the sess.peerjid is the same as from
+        };
+    }
+
+    init (connection) {
+        super.init(connection);
+        this.connection.addHandler(this.onJingle.bind(this),
+            'urn:xmpp:jingle:1', 'iq', 'set', null, null);
+    }
+
+    onJingle (iq) {
+        const sid = $(iq).find('jingle').attr('sid');
+        const action = $(iq).find('jingle').attr('action');
+        const fromJid = iq.getAttribute('from');
+        // send ack first
+        const ack = $iq({type: 'result',
+            to: fromJid,
+            id: iq.getAttribute('id')
+        });
+        logger.log('on jingle ' + action + ' from ' + fromJid, iq);
+        let sess = this.sessions[sid];
+        if ('session-initiate' != action) {
+            if (!sess) {
                 ack.attrs({ type: 'error' });
                 ack.c('error', {type: 'cancel'})
-                    .c('service-unavailable', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up();
-                logger.warn('duplicate session id', sid, iq);
+                    .c('item-not-found', {
+                        xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up()
+                    .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
+                logger.warn('invalid session id', iq);
                 this.connection.send(ack);
                 return true;
             }
-            // see http://xmpp.org/extensions/xep-0166.html#concepts-session
-            switch (action) {
-                case 'session-initiate':
-                    var now = window.performance.now();
-                    logger.log("(TIME) received session-initiate:\t", now);
-                    var startMuted = $(iq).find('jingle>startmuted');
-                    if (startMuted && startMuted.length > 0) {
-                        var audioMuted = startMuted.attr("audio");
-                        var videoMuted = startMuted.attr("video");
-                        eventEmitter.emit(XMPPEvents.START_MUTED_FROM_FOCUS,
-                                audioMuted === "true", videoMuted === "true");
-                    }
-                    sess = new JingleSession(
-                            $(iq).attr('to'), $(iq).find('jingle').attr('sid'),
-                            fromJid,
-                            this.connection,
-                            this.media_constraints,
-                            this.ice_config, XMPP);
-
-                    this.sessions[sess.sid] = sess;
-
-                    var jingleOffer = $(iq).find('>jingle');
-                    // FIXME there's no nice way with event to get the reason
-                    // why the call was rejected
-                    eventEmitter.emit(XMPPEvents.CALL_INCOMING, sess, jingleOffer, now);
-                    if (!sess.active())
-                    {
-                        // Call not accepted
-                        ack.attrs({ type: 'error' });
-                        ack.c('error', {type: 'cancel'})
-                           .c('bad-request',
-                            { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' })
-                            .up();
-                        this.terminate(sess.sid);
-                    }
-                    break;
-                case 'session-terminate':
-                    logger.log('terminating...', sess.sid);
-                    var reasonCondition = null;
-                    var reasonText = null;
-                    if ($(iq).find('>jingle>reason').length) {
-                        reasonCondition
-                            = $(iq).find('>jingle>reason>:first')[0].tagName;
-                        reasonText = $(iq).find('>jingle>reason>text').text();
-                    }
-                    this.terminate(sess.sid, reasonCondition, reasonText);
-                    break;
-                case 'transport-replace':
-                    logger.info("(TIME) Start transport replace",
-                                window.performance.now());
-                    sess.replaceTransport($(iq).find('>jingle'),
-                        function () {
-                            logger.info(
-                                "(TIME) Transport replace success!",
-                                window.performance.now());
-                        },
-                        function(error) {
-                            GlobalOnErrorHandler.callErrorHandler(error);
-                            logger.error('Transport replace failed', error);
-                            sess.sendTransportReject();
-                        });
-                    break;
-                case 'addsource': // FIXME: proprietary, un-jingleish
-                case 'source-add': // FIXME: proprietary
-                    sess.addSource($(iq).find('>jingle>content'));
-                    break;
-                case 'removesource': // FIXME: proprietary, un-jingleish
-                case 'source-remove': // FIXME: proprietary
-                    sess.removeSource($(iq).find('>jingle>content'));
-                    break;
-                default:
-                    logger.warn('jingle action not implemented', action);
-                    ack.attrs({ type: 'error' });
-                    ack.c('error', {type: 'cancel'})
-                        .c('bad-request',
-                            { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' })
-                        .up();
-                    break;
+            // local jid is not checked
+            if (fromJid != sess.peerjid) {
+                logger.warn(
+                    'jid mismatch for session id', sid, sess.peerjid, iq);
+                ack.attrs({ type: 'error' });
+                ack.c('error', {type: 'cancel'})
+                    .c('item-not-found', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up()
+                    .c('unknown-session', {xmlns: 'urn:xmpp:jingle:errors:1'});
+                this.connection.send(ack);
+                return true;
             }
+        } else if (sess !== undefined) {
+            // existing session with same session id
+            // this might be out-of-order if the sess.peerjid is the same as from
+            ack.attrs({ type: 'error' });
+            ack.c('error', {type: 'cancel'})
+                .c('service-unavailable', {xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas'}).up();
+            logger.warn('duplicate session id', sid, iq);
             this.connection.send(ack);
             return true;
-        },
-        terminate: function (sid, reasonCondition, reasonText) {
-            if (this.sessions.hasOwnProperty(sid)) {
-                if (this.sessions[sid].state != 'ended') {
-                    this.sessions[sid].onTerminated(reasonCondition, reasonText);
+        }
+        const now = window.performance.now();
+        // see http://xmpp.org/extensions/xep-0166.html#concepts-session
+        switch (action) {
+            case 'session-initiate': {
+                logger.log("(TIME) received session-initiate:\t", now);
+                const startMuted = $(iq).find('jingle>startmuted');
+                if (startMuted && startMuted.length > 0) {
+                    const audioMuted = startMuted.attr("audio");
+                    const videoMuted = startMuted.attr("video");
+                    this.eventEmitter.emit(XMPPEvents.START_MUTED_FROM_FOCUS,
+                            audioMuted === "true", videoMuted === "true");
                 }
-                delete this.sessions[sid];
+                sess = new JingleSession(
+                        $(iq).attr('to'), $(iq).find('jingle').attr('sid'),
+                        fromJid,
+                        this.connection,
+                        this.media_constraints,
+                        this.ice_config, this.xmpp);
+
+                this.sessions[sess.sid] = sess;
+
+                this.eventEmitter.emit(XMPPEvents.CALL_INCOMING,
+                    sess, $(iq).find('>jingle'), now);
+                Statistics.analytics.sendEvent(
+                    'xmpp.session-initiate', {value: now});
+                break;
             }
-        },
-        getStunAndTurnCredentials: function () {
-            // get stun and turn configuration from server via xep-0215
-            // uses time-limited credentials as described in
-            // http://tools.ietf.org/html/draft-uberti-behave-turn-rest-00
-            //
-            // see https://code.google.com/p/prosody-modules/source/browse/mod_turncredentials/mod_turncredentials.lua
-            // for a prosody module which implements this
-            //
-            // currently, this doesn't work with updateIce and therefore credentials with a long
-            // validity have to be fetched before creating the peerconnection
-            // TODO: implement refresh via updateIce as described in
-            //      https://code.google.com/p/webrtc/issues/detail?id=1650
-            var self = this;
-            this.connection.sendIQ(
-                $iq({type: 'get', to: this.connection.domain})
-                    .c('services', {xmlns: 'urn:xmpp:extdisco:1'}).c('service', {host: 'turn.' + this.connection.domain}),
-                function (res) {
-                    var iceservers = [];
-                    $(res).find('>services>service').each(function (idx, el) {
-                        el = $(el);
-                        var dict = {};
-                        var type = el.attr('type');
-                        switch (type) {
-                            case 'stun':
-                                dict.url = 'stun:' + el.attr('host');
-                                if (el.attr('port')) {
-                                    dict.url += ':' + el.attr('port');
-                                }
-                                iceservers.push(dict);
-                                break;
-                            case 'turn':
-                            case 'turns':
-                                dict.url = type + ':';
-                                if (el.attr('username')) { // https://code.google.com/p/webrtc/issues/detail?id=1508
-                                    if (navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./) && parseInt(navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./)[2], 10) < 28) {
-                                        dict.url += el.attr('username') + '@';
-                                    } else {
-                                        dict.username = el.attr('username'); // only works in M28
-                                    }
-                                }
-                                dict.url += el.attr('host');
-                                if (el.attr('port') && el.attr('port') != '3478') {
-                                    dict.url += ':' + el.attr('port');
-                                }
-                                if (el.attr('transport') && el.attr('transport') != 'udp') {
-                                    dict.url += '?transport=' + el.attr('transport');
-                                }
-                                if (el.attr('password')) {
-                                    dict.credential = el.attr('password');
-                                }
-                                iceservers.push(dict);
-                                break;
-                        }
-                    });
-                    self.ice_config.iceServers = iceservers;
-                },
-                function (err) {
-                    logger.warn('getting turn credentials failed', err);
-                    logger.warn('is mod_turncredentials or similar installed?');
+            case 'session-terminate': {
+                logger.log('terminating...', sess.sid);
+                let reasonCondition = null;
+                let reasonText = null;
+                if ($(iq).find('>jingle>reason').length) {
+                    reasonCondition
+                        = $(iq).find('>jingle>reason>:first')[0].tagName;
+                    reasonText = $(iq).find('>jingle>reason>text').text();
                 }
-            );
-            // implement push?
-        },
+                this.terminate(sess.sid, reasonCondition, reasonText);
+                this.eventEmitter.emit(XMPPEvents.CALL_ENDED,
+                    sess, reasonCondition, reasonText);
+                break;
+            }
+            case 'transport-replace':
+                logger.info("(TIME) Start transport replace", now);
+                Statistics.analytics.sendEvent(
+                    'xmpp.transport-replace.start', {value: now});
 
-        /**
-         * Returns the data saved in 'updateLog' in a format to be logged.
-         */
-        getLog: function () {
-            var data = {};
-            var self = this;
-            Object.keys(this.sessions).forEach(function (sid) {
-                var session = self.sessions[sid];
-                if (session.peerconnection && session.peerconnection.updateLog) {
-                    // FIXME: should probably be a .dump call
-                    data["jingle_" + session.sid] = {
-                        updateLog: session.peerconnection.updateLog,
-                        stats: session.peerconnection.stats,
-                        url: window.location.href
-                    };
-                }
-            });
-            return data;
+                sess.replaceTransport($(iq).find('>jingle'), () => {
+                    const successTime = window.performance.now();
+                    logger.info(
+                        "(TIME) Transport replace success!", successTime);
+                    Statistics.analytics.sendEvent(
+                        'xmpp.transport-replace.success',
+                        {value: successTime});
+                }, error => {
+                    GlobalOnErrorHandler.callErrorHandler(error);
+                    logger.error('Transport replace failed', error);
+                    sess.sendTransportReject();
+                });
+                break;
+            case 'addsource': // FIXME: proprietary, un-jingleish
+            case 'source-add': // FIXME: proprietary
+                sess.addSource($(iq).find('>jingle>content'));
+                break;
+            case 'removesource': // FIXME: proprietary, un-jingleish
+            case 'source-remove': // FIXME: proprietary
+                sess.removeSource($(iq).find('>jingle>content'));
+                break;
+            default:
+                logger.warn('jingle action not implemented', action);
+                ack.attrs({ type: 'error' });
+                ack.c('error', {type: 'cancel'})
+                    .c('bad-request',
+                        { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' })
+                    .up();
+                break;
+        }
+        this.connection.send(ack);
+        return true;
+    }
+
+    terminate (sid, reasonCondition, reasonText) {
+        if (this.sessions.hasOwnProperty(sid)) {
+            if (this.sessions[sid].state != 'ended') {
+                this.sessions[sid].onTerminated(reasonCondition, reasonText);
+            }
+            delete this.sessions[sid];
         }
-    });
+    }
+
+    getStunAndTurnCredentials () {
+        // get stun and turn configuration from server via xep-0215
+        // uses time-limited credentials as described in
+        // http://tools.ietf.org/html/draft-uberti-behave-turn-rest-00
+        //
+        // see https://code.google.com/p/prosody-modules/source/browse/mod_turncredentials/mod_turncredentials.lua
+        // for a prosody module which implements this
+        //
+        // currently, this doesn't work with updateIce and therefore credentials with a long
+        // validity have to be fetched before creating the peerconnection
+        // TODO: implement refresh via updateIce as described in
+        //      https://code.google.com/p/webrtc/issues/detail?id=1650
+        this.connection.sendIQ(
+            $iq({type: 'get', to: this.connection.domain})
+                .c('services', {xmlns: 'urn:xmpp:extdisco:1'})
+                .c('service', {host: 'turn.' + this.connection.domain}),
+            res => {
+                let iceservers = [];
+                $(res).find('>services>service').each((idx, el) => {
+                    el = $(el);
+                    let dict = {};
+                    const type = el.attr('type');
+                    switch (type) {
+                        case 'stun':
+                            dict.url = 'stun:' + el.attr('host');
+                            if (el.attr('port')) {
+                                dict.url += ':' + el.attr('port');
+                            }
+                            iceservers.push(dict);
+                            break;
+                        case 'turn':
+                        case 'turns': {
+                            dict.url = type + ':';
+                            const username = el.attr('username');
+                            // https://code.google.com/p/webrtc/issues/detail?id=1508
+                            if (username) {
+                                if (navigator.userAgent.match(
+                                    /Chrom(e|ium)\/([0-9]+)\./)
+                                    && parseInt(
+                                        navigator.userAgent.match(
+                                            /Chrom(e|ium)\/([0-9]+)\./)[2],
+                                            10) < 28) {
+                                    dict.url += username + '@';
+                                } else {
+                                    // only works in M28
+                                    dict.username = username;
+                                }
+                            }
+                            dict.url += el.attr('host');
+                            const port = el.attr('port');
+                            if (port && port != '3478') {
+                                dict.url += ':' + el.attr('port');
+                            }
+                            const transport = el.attr('transport');
+                            if (transport && transport != 'udp') {
+                                dict.url += '?transport=' + transport;
+                            }
+
+                            dict.credential = el.attr('password')
+                                || dict.credential;
+                            iceservers.push(dict);
+                            break;
+                        }
+                    }
+                });
+                this.ice_config.iceServers = iceservers;
+            }, err => {
+                logger.warn('getting turn credentials failed', err);
+                logger.warn('is mod_turncredentials or similar installed?');
+            });
+        // implement push?
+    }
+
+    /**
+     * Returns the data saved in 'updateLog' in a format to be logged.
+     */
+    getLog () {
+        const data = {};
+        Object.keys(this.sessions).forEach(sid => {
+            const session = this.sessions[sid];
+            const pc = session.peerconnection;
+            if (pc && pc.updateLog) {
+                // FIXME: should probably be a .dump call
+                data["jingle_" + sid] = {
+                    updateLog: pc.updateLog,
+                    stats: pc.stats,
+                    url: window.location.href
+                };
+            }
+        });
+        return data;
+    }
+}
+
+
+
+module.exports = function(XMPP, eventEmitter) {
+    Strophe.addConnectionPlugin('jingle',
+        new JingleConnectionPlugin(XMPP, eventEmitter));
 };

modules/xmpp/strophe.logger.js

 /* global Strophe */
-module.exports = function () {
+import ConnectionPlugin from "./ConnectionPlugin";
 
-    Strophe.addConnectionPlugin('logger', {
-        // logs raw stanzas and makes them available for download as JSON
-        connection: null,
-        log: [],
-        init: function (conn) {
-            this.connection = conn;
-            this.connection.rawInput = this.log_incoming.bind(this);
-            this.connection.rawOutput = this.log_outgoing.bind(this);
-        },
-        log_incoming: function (stanza) {
-            this.log.push([new Date().getTime(), 'incoming', stanza]);
-        },
-        log_outgoing: function (stanza) {
-            this.log.push([new Date().getTime(), 'outgoing', stanza]);
-        }
-    });
-};
+/**
+ *  Logs raw stanzas and makes them available for download as JSON
+ */
+class StropheLogger extends ConnectionPlugin {
+    constructor() {
+        super();
+        this.log = [];
+    }
+
+    init (connection) {
+        super.init(connection);
+        this.connection.rawInput = this.log_incoming.bind(this);
+        this.connection.rawOutput = this.log_outgoing.bind(this);
+    }
+
+    log_incoming (stanza) {
+        this.log.push([new Date().getTime(), 'incoming', stanza]);
+    }
+
+    log_outgoing (stanza) {
+        this.log.push([new Date().getTime(), 'outgoing', stanza]);
+    }
+}
+
+export default function () {
+    Strophe.addConnectionPlugin('logger', new StropheLogger());
+}

modules/xmpp/strophe.ping.js

 /* global $, $iq, Strophe */
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import ConnectionPlugin from "./ConnectionPlugin";
+import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
 
 /**
  * Ping every 10 sec
  */
-var PING_INTERVAL = 10000;
+const PING_INTERVAL = 10000;
 
 /**
  * Ping timeout error after 15 sec of waiting.
  */
-var PING_TIMEOUT = 15000;
+const PING_TIMEOUT = 15000;
 
 /**
  * Will close the connection after 3 consecutive ping errors.
  */
-var PING_THRESHOLD = 3;
+const PING_THRESHOLD = 3;
+
+
+
 
 /**
  * XEP-0199 ping plugin.
  *
  * Registers "urn:xmpp:ping" namespace under Strophe.NS.PING.
  */
-module.exports = function (XMPP, eventEmitter) {
-    Strophe.addConnectionPlugin('ping', {
-
-        connection: null,
-
-        failedPings: 0,
+class PingConnectionPlugin extends ConnectionPlugin {
+    constructor() {
+        super();
+        this.failedPings = 0;
+    }
 
-        /**
-         * Initializes the plugin. Method called by Strophe.
-         * @param connection Strophe connection instance.
-         */
-        init: function (connection) {
-            this.connection = connection;
-            Strophe.addNamespace('PING', "urn:xmpp:ping");
-        },
+    /**
+     * Initializes the plugin. Method called by Strophe.
+     * @param connection Strophe connection instance.
+     */
+    init (connection) {
+        super.init(connection);
+        Strophe.addNamespace('PING', "urn:xmpp:ping");
+    }
 
-        /**
-         * Sends "ping" to given <tt>jid</tt>
-         * @param jid the JID to which ping request will be sent.
-         * @param success callback called on success.
-         * @param error callback called on error.
-         * @param timeout ms how long are we going to wait for the response. On
-         *        timeout <tt>error<//t> callback is called with undefined error
-         *        argument.
-         */
-        ping: function (jid, success, error, timeout) {
-            var iq = $iq({type: 'get', to: jid});
-            iq.c('ping', {xmlns: Strophe.NS.PING});
-            this.connection.sendIQ(iq, success, error, timeout);
-        },
+    /**
+     * Sends "ping" to given <tt>jid</tt>
+     * @param jid the JID to which ping request will be sent.
+     * @param success callback called on success.
+     * @param error callback called on error.
+     * @param timeout ms how long are we going to wait for the response. On
+     *        timeout <tt>error<//t> callback is called with undefined error
+     *        argument.
+     */
+    ping (jid, success, error, timeout) {
+        const iq = $iq({type: 'get', to: jid});
+        iq.c('ping', {xmlns: Strophe.NS.PING});
+        this.connection.sendIQ(iq, success, error, timeout);
+    }
 
-        /**
-         * Checks if given <tt>jid</tt> has XEP-0199 ping support.
-         * @param jid the JID to be checked for ping support.
-         * @param callback function with boolean argument which will be
-         * <tt>true</tt> if XEP-0199 ping is supported by given <tt>jid</tt>
-         */
-        hasPingSupport: function (jid, callback) {
-            var disco = this.connection.disco;
-            // XXX The following disco.info was observed to throw a "TypeError:
-            // Cannot read property 'info' of undefined" during porting to React
-            // Native. Since disco is checked in multiple places (e.g.
-            // strophe.jingle.js, strophe.rayo.js), check it here as well.
-            if (disco) {
-                disco.info(
-                    jid,
-                    null,
-                    function (result) {
-                        var ping
-                            = $(result).find('>>feature[var="urn:xmpp:ping"]');
-                        callback(ping.length > 0);
-                    },
-                    function (error) {
-                        var errmsg = "Ping feature discovery error";
-                        GlobalOnErrorHandler.callErrorHandler(new Error(
-                            errmsg + ": " + error));
-                        logger.error(errmsg, error);
-                        callback(false);
-                    }
-                );
-            } else {
-              // FIXME Should callback be invoked here? Maybe with false as an
-              // argument?
-            }
-        },
-
-        /**
-         * Starts to send ping in given interval to specified remote JID.
-         * This plugin supports only one such task and <tt>stopInterval</tt>
-         * must be called before starting a new one.
-         * @param remoteJid remote JID to which ping requests will be sent to.
-         * @param interval task interval in ms.
-         */
-        startInterval: function (remoteJid, interval) {
-            if (this.intervalId) {
-                var errmsg = "Ping task scheduled already";
-                GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-                logger.error(errmsg);
-                return;
-            }
-            if (!interval)
-                interval = PING_INTERVAL;
-            var self = this;
-            this.intervalId = window.setInterval(function () {
-                self.ping(remoteJid,
-                function (result) {
-                    // Ping OK
-                    self.failedPings = 0;
-                },
-                function (error) {
-                    self.failedPings += 1;
-                    var errmsg = "Ping " + (error ? "error" : "timeout");
-                    if (self.failedPings >= PING_THRESHOLD) {
-                        GlobalOnErrorHandler.callErrorHandler(
-                            new Error(errmsg));
-                        logger.error(errmsg, error);
-                        // FIXME it doesn't help to disconnect when 3rd PING
-                        // times out, it only stops Strophe from retrying.
-                        // Not really sure what's the right thing to do in that
-                        // situation, but just closing the connection makes no
-                        // sense.
-                        //self.connection.disconnect();
-                    } else {
-                        logger.warn(errmsg, error);
-                    }
-                }, PING_TIMEOUT);
-            }, interval);
-            logger.info("XMPP pings will be sent every " + interval + " ms");
-        },
+    /**
+     * Checks if given <tt>jid</tt> has XEP-0199 ping support.
+     * @param jid the JID to be checked for ping support.
+     * @param callback function with boolean argument which will be
+     * <tt>true</tt> if XEP-0199 ping is supported by given <tt>jid</tt>
+     */
+    hasPingSupport (jid, callback) {
+        const disco = this.connection.disco;
+        // XXX The following disco.info was observed to throw a "TypeError:
+        // Cannot read property 'info' of undefined" during porting to React
+        // Native. Since disco is checked in multiple places (e.g.
+        // strophe.jingle.js, strophe.rayo.js), check it here as well.
+        if (disco) {
+            disco.info(jid, null, (result)  => {
+                const ping
+                    = $(result).find('>>feature[var="urn:xmpp:ping"]');
+                callback(ping.length > 0);
+            }, (error) => {
+                const errmsg = "Ping feature discovery error";
+                GlobalOnErrorHandler.callErrorHandler(new Error(
+                    errmsg + ": " + error));
+                logger.error(errmsg, error);
+                callback(false);
+            });
+        } else {
+          // FIXME Should callback be invoked here? Maybe with false as an
+          // argument?
+        }
+    }
 
-        /**
-         * Stops current "ping"  interval task.
-         */
-        stopInterval: function () {
-            if (this.intervalId) {
-                window.clearInterval(this.intervalId);
-                this.intervalId = null;
+    /**
+     * Starts to send ping in given interval to specified remote JID.
+     * This plugin supports only one such task and <tt>stopInterval</tt>
+     * must be called before starting a new one.
+     * @param remoteJid remote JID to which ping requests will be sent to.
+     * @param interval task interval in ms.
+     */
+    startInterval (remoteJid, interval = PING_INTERVAL) {
+        if (this.intervalId) {
+            const errmsg = "Ping task scheduled already";
+            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+            logger.error(errmsg);
+            return;
+        }
+        this.intervalId = window.setInterval(() => {
+            this.ping(remoteJid, () => {
                 this.failedPings = 0;
-                logger.info("Ping interval cleared");
-            }
+            }, (error) => {
+                this.failedPings += 1;
+                const errmsg = "Ping " + (error ? "error" : "timeout");
+                if (this.failedPings >= PING_THRESHOLD) {
+                    GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+                    logger.error(errmsg, error);
+                    // FIXME it doesn't help to disconnect when 3rd PING
+                    // times out, it only stops Strophe from retrying.
+                    // Not really sure what's the right thing to do in that
+                    // situation, but just closing the connection makes no
+                    // sense.
+                    //self.connection.disconnect();
+                } else {
+                    logger.warn(errmsg, error);
+                }
+            }, PING_TIMEOUT);
+        }, interval);
+        logger.info("XMPP pings will be sent every " + interval + " ms");
+    }
+
+    /**
+     * Stops current "ping"  interval task.
+     */
+    stopInterval () {
+        if (this.intervalId) {
+            window.clearInterval(this.intervalId);
+            this.intervalId = null;
+            this.failedPings = 0;
+            logger.info("Ping interval cleared");
         }
-    });
-};
+    }
+}
+
+export default function () {
+    Strophe.addConnectionPlugin('ping', new PingConnectionPlugin());
+}

modules/xmpp/strophe.rayo.js

-/* jshint -W117 */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
+/* global $, $iq, Strophe */
 
-module.exports = function() {
-    Strophe.addConnectionPlugin('rayo',
-        {
-            RAYO_XMLNS: 'urn:xmpp:rayo:1',
-            connection: null,
-            init: function (conn) {
-                this.connection = conn;
-                var disco = conn.disco;
-                if (disco) {
-                    disco.addFeature('urn:xmpp:rayo:client:1');
-                }
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import ConnectionPlugin from "./ConnectionPlugin";
 
-                this.connection.addHandler(
-                    this.onRayo.bind(this), this.RAYO_XMLNS, 'iq', 'set',
-                    null, null);
-            },
-            onRayo: function (iq) {
-                logger.info("Rayo IQ", iq);
-            },
-            dial: function (to, from, roomName, roomPass, focusMucJid) {
-                var self = this;
-                return new Promise(function (resolve, reject) {
-                    if(!focusMucJid) {
-                        reject(new Error("Internal error!"));
-                        return;
-                    }
-                    var req = $iq(
-                        {
-                            type: 'set',
-                            to: focusMucJid
-                        }
-                    );
-                    req.c('dial',
-                        {
-                            xmlns: self.RAYO_XMLNS,
-                            to: to,
-                            from: from
-                        });
-                    req.c('header',
-                        {
-                            name: 'JvbRoomName',
-                            value: roomName
-                        }).up();
+const RAYO_XMLNS = 'urn:xmpp:rayo:1';
 
-                    if (roomPass !== null && roomPass.length) {
+class RayoConnectionPlugin extends ConnectionPlugin {
+    init (connection) {
+        super.init(connection);
+        const disco = this.connection.disco;
+        if (disco) {
+            disco.addFeature('urn:xmpp:rayo:client:1');
+        }
+
+        this.connection.addHandler(
+            this.onRayo.bind(this), RAYO_XMLNS, 'iq', 'set', null, null);
+    }
 
-                        req.c('header',
-                            {
-                                name: 'JvbRoomPassword',
-                                value: roomPass
-                            }).up();
-                    }
+    onRayo (iq) {
+        logger.info("Rayo IQ", iq);
+    }
 
-                    self.connection.sendIQ(
-                        req,
-                        function (result) {
-                            logger.info('Dial result ', result);
+    dial (to, from, roomName, roomPass, focusMucJid) {
+        return new Promise((resolve, reject) => {
+            if(!focusMucJid) {
+                reject(new Error("Internal error!"));
+                return;
+            }
+            const req = $iq({
+                type: 'set',
+                to: focusMucJid
+            });
+            req.c('dial', {
+                xmlns: RAYO_XMLNS,
+                to: to,
+                from: from
+            });
+            req.c('header', {
+                name: 'JvbRoomName',
+                value: roomName
+            }).up();
+
+            if (roomPass && roomPass.length) {
+                req.c('header', {
+                    name: 'JvbRoomPassword',
+                    value: roomPass
+                }).up();
+            }
 
-                            var resource = $(result).find('ref').attr('uri');
-                            self.call_resource =
-                                resource.substr('xmpp:'.length);
-                            logger.info(
-                                "Received call resource: " +
-                                self.call_resource);
-                            resolve();
-                        },
-                        function (error) {
-                            logger.info('Dial error ', error);
-                            reject(error);
-                        }
-                    );
-                });
-            },
-            hangup: function () {
-                var self = this;
-                return new Promise(function (resolve, reject) {
-                    if (!self.call_resource) {
-                        reject(new Error("No call in progress"));
-                        logger.warn("No call in progress");
-                        return;
-                    }
+            this.connection.sendIQ(req, (result) => {
+                logger.info('Dial result ', result);
 
-                    var req = $iq(
-                        {
-                            type: 'set',
-                            to: self.call_resource
-                        }
-                    );
-                    req.c('hangup',
-                        {
-                            xmlns: self.RAYO_XMLNS
-                        });
+                let resource = $(result).find('ref').attr('uri');
+                this.call_resource =
+                    resource.substr('xmpp:'.length);
+                logger.info("Received call resource: " + this.call_resource);
+                resolve();
+            }, (error) => {
+                logger.info('Dial error ', error);
+                reject(error);
+            });
+        });
+    }
 
-                    self.connection.sendIQ(
-                        req,
-                        function (result) {
-                            logger.info('Hangup result ', result);
-                            self.call_resource = null;
-                            resolve();
-                        },
-                        function (error) {
-                            logger.info('Hangup error ', error);
-                            self.call_resource = null;
-                            reject(new Error('Hangup error '));
-                        }
-                    );
-                });
+    hangup () {
+        return new Promise((resolve, reject) => {
+            if (!this.call_resource) {
+                reject(new Error("No call in progress"));
+                logger.warn("No call in progress");
+                return;
             }
-        }
-    );
-};
+
+            const req = $iq({
+                type: 'set',
+                to: this.call_resource
+            });
+            req.c('hangup', {
+                xmlns: RAYO_XMLNS
+            });
+
+            this.connection.sendIQ(req, (result) => {
+                logger.info('Hangup result ', result);
+                this.call_resource = null;
+                resolve();
+            }, (error) => {
+                logger.info('Hangup error ', error);
+                this.call_resource = null;
+                reject(new Error('Hangup error '));
+            });
+        });
+    }
+}
+
+export default function() {
+    Strophe.addConnectionPlugin('rayo', new RayoConnectionPlugin());
+}

modules/xmpp/strophe.util.js

 /**
  * Strophe logger implementation. Logs from level WARN and above.
  */
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+import {getLogger} from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
 
-module.exports = function () {
+export default function () {
 
     Strophe.log = function (level, msg) {
         // Our global handler reports uncaught errors to the stats which may
                 return "unknown";
         }
     };
-};
+}

modules/xmpp/xmpp.js

-/* global $, APP, config, Strophe */
-
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var EventEmitter = require("events");
-var Pako = require("pako");
-var RandomUtil = require("../util/RandomUtil");
-var RTCEvents = require("../../service/RTC/RTCEvents");
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
-var JitsiConnectionErrors = require("../../JitsiConnectionErrors");
-var JitsiConnectionEvents = require("../../JitsiConnectionEvents");
-var RTC = require("../RTC/RTC");
-var RTCBrowserType = require("../RTC/RTCBrowserType");
-
-var authenticatedUser = false;
-
-function createConnection(bosh, token) {
-    bosh = bosh || '/http-bind';
-
+/* global $, $msg, Base64, Strophe */
+
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import EventEmitter from "events";
+import Pako from "pako";
+import RandomUtil from "../util/RandomUtil";
+import * as JitsiConnectionErrors from "../../JitsiConnectionErrors";
+import * as JitsiConnectionEvents from "../../JitsiConnectionEvents";
+import RTCBrowserType from "../RTC/RTCBrowserType";
+import initEmuc from "./strophe.emuc";
+import initJingle from "./strophe.jingle";
+import initStropheUtil from "./strophe.util";
+import initPing from "./strophe.ping";
+import initRayo from "./strophe.rayo";
+import initStropheLogger from "./strophe.logger";
+
+function createConnection(token, bosh = '/http-bind') {
     // Append token as URL param
     if (token) {
         bosh += (bosh.indexOf('?') == -1 ? '?' : '&') + 'token=' + token;
     }
 
     return new Strophe.Connection(bosh);
-};
-
-//!!!!!!!!!! FIXME: ...
-function initStrophePlugins(XMPP) {
-    require("./strophe.emuc")(XMPP);
-    require("./strophe.jingle")(XMPP, XMPP.eventEmitter);
-//    require("./strophe.moderate")(XMPP, eventEmitter);
-    require("./strophe.util")();
-    require("./strophe.ping")(XMPP, XMPP.eventEmitter);
-    require("./strophe.rayo")();
-    require("./strophe.logger")();
 }
 
-function XMPP(options, token) {
-    this.eventEmitter = new EventEmitter();
-    this.connection = null;
-    this.disconnectInProgress = false;
-    this.connectionTimes = {};
-    this.forceMuted = false;
-    this.options = options;
-    initStrophePlugins(this);
-
-    this.connection = createConnection(options.bosh, token);
-
-    // Initialize features advertised in disco-info
-    this.initFeaturesList();
-
-    // Setup a disconnect on unload as a way to facilitate API consumers. It
-    // sounds like they would want that. A problem for them though may be if
-    // they wanted to utilize the connected connection in an unload handler of
-    // their own. However, it should be fairly easy for them to do that by
-    // registering their unload handler before us.
-    $(window).on('beforeunload unload', this.disconnect.bind(this));
-}
+export default class XMPP {
+    constructor(options, token) {
+        this.eventEmitter = new EventEmitter();
+        this.connection = null;
+        this.disconnectInProgress = false;
+        this.connectionTimes = {};
+        this.forceMuted = false;
+        this.options = options;
+        this.connectParams = {};
+        this.token = token;
+        this.authenticatedUser = false;
+        this._initStrophePlugins(this);
+
+        this.connection = createConnection(token, options.bosh);
+
+        if(!this.connection.disco || !this.connection.caps)
+            throw new Error(
+                "Missing strophe-plugins (disco and caps plugins are required)!");
+
+        // Initialize features advertised in disco-info
+        this.initFeaturesList();
+
+        // Setup a disconnect on unload as a way to facilitate API consumers. It
+        // sounds like they would want that. A problem for them though may be if
+        // they wanted to utilize the connected connection in an unload handler of
+        // their own. However, it should be fairly easy for them to do that by
+        // registering their unload handler before us.
+        $(window).on('beforeunload unload', this.disconnect.bind(this));
+    }
+
+    /**
+     * Initializes the list of feature advertised through the disco-info mechanism
+     */
+    initFeaturesList () {
+        const disco = this.connection.disco;
+        if (!disco)
+            return;
 
-/**
- * Initializes the list of feature advertised through the disco-info mechanism
- */
-XMPP.prototype.initFeaturesList = function () {
-    var disco = this.connection.disco;
-    if (disco) {
         // http://xmpp.org/extensions/xep-0167.html#support
         // http://xmpp.org/extensions/xep-0176.html#support
         disco.addFeature('urn:xmpp:jingle:1');
         //disco.addFeature('urn:ietf:rfc:5576'); // a=ssrc
 
         // Enable Lipsync ?
-        if (this.options.enableLipSync && RTCBrowserType.isChrome()) {
+        if (RTCBrowserType.isChrome() && false !== this.options.enableLipSync) {
             logger.info("Lip-sync enabled !");
-            this.connection.disco.addFeature('http://jitsi.org/meet/lipsync');
+            disco.addFeature('http://jitsi.org/meet/lipsync');
         }
     }
-};
-
-XMPP.prototype.getConnection = function () { return this.connection; };
-
-/**
- * Receive connection status changes and handles them.
- * @password {string} the password passed in connect method
- * @status the connection status
- * @msg message
- */
-XMPP.prototype.connectionHandler = function (password, status, msg) {
-    var now = window.performance.now();
-    this.connectionTimes[Strophe.getStatusString(status).toLowerCase()] = now;
-    logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
-        (msg ? "[" + msg + "]" : "") + ":\t", now);
-    if (status === Strophe.Status.CONNECTED ||
-        status === Strophe.Status.ATTACHED) {
-        if (this.options.useStunTurn) {
-            this.connection.jingle.getStunAndTurnCredentials();
-        }
 
-        logger.info("My Jabber ID: " + this.connection.jid);
-
-        // Schedule ping ?
-        var pingJid = this.connection.domain;
-        this.connection.ping.hasPingSupport(
-            pingJid,
-            function (hasPing) {
-                if (hasPing)
-                    this.connection.ping.startInterval(pingJid);
-                else
-                    logger.warn("Ping NOT supported by " + pingJid);
-            }.bind(this));
-
-        if (password)
-            authenticatedUser = true;
-        if (this.connection && this.connection.connected &&
-            Strophe.getResourceFromJid(this.connection.jid)) {
-            // .connected is true while connecting?
-//                this.connection.send($pres());
-            this.eventEmitter.emit(
-                    JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                    Strophe.getResourceFromJid(this.connection.jid));
-        }
-    } else if (status === Strophe.Status.CONNFAIL) {
-        if (msg === 'x-strophe-bad-non-anon-jid') {
-            this.anonymousConnectionFailed = true;
-        } else {
-            this.connectionFailed = true;
-        }
-        this.lastErrorMsg = msg;
-    } else if (status === Strophe.Status.DISCONNECTED) {
-        // Stop ping interval
-        this.connection.ping.stopInterval();
-        this.disconnectInProgress = false;
-        if (this.anonymousConnectionFailed) {
-            // prompt user for username and password
+    getConnection () { return this.connection; }
+
+    /**
+     * Receive connection status changes and handles them.
+     * @password {string} the password passed in connect method
+     * @status the connection status
+     * @msg message
+     */
+    connectionHandler (password, status, msg) {
+        const now = window.performance.now();
+        const statusStr = Strophe.getStatusString(status).toLowerCase();
+        this.connectionTimes[statusStr] = now;
+        logger.log("(TIME) Strophe " + statusStr +
+            (msg ? "[" + msg + "]" : "") + ":\t", now);
+        if (status === Strophe.Status.CONNECTED ||
+            status === Strophe.Status.ATTACHED) {
+            if (this.options.useStunTurn) {
+                this.connection.jingle.getStunAndTurnCredentials();
+            }
+
+            logger.info("My Jabber ID: " + this.connection.jid);
+
+            // Schedule ping ?
+            var pingJid = this.connection.domain;
+            this.connection.ping.hasPingSupport(
+                pingJid,
+                function (hasPing) {
+                    if (hasPing)
+                        this.connection.ping.startInterval(pingJid);
+                    else
+                        logger.warn("Ping NOT supported by " + pingJid);
+                }.bind(this));
+
+            if (password)
+                this.authenticatedUser = true;
+            if (this.connection && this.connection.connected &&
+                Strophe.getResourceFromJid(this.connection.jid)) {
+                // .connected is true while connecting?
+    //                this.connection.send($pres());
+                this.eventEmitter.emit(
+                        JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+                        Strophe.getResourceFromJid(this.connection.jid));
+            }
+        } else if (status === Strophe.Status.CONNFAIL) {
+            if (msg === 'x-strophe-bad-non-anon-jid') {
+                this.anonymousConnectionFailed = true;
+            } else {
+                this.connectionFailed = true;
+            }
+            this.lastErrorMsg = msg;
+        } else if (status === Strophe.Status.DISCONNECTED) {
+            // Stop ping interval
+            this.connection.ping.stopInterval();
+            const wasIntentionalDisconnect = this.disconnectInProgress;
+            const errMsg = msg ? msg : this.lastErrorMsg;
+            this.disconnectInProgress = false;
+            if (this.anonymousConnectionFailed) {
+                // prompt user for username and password
+                this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_FAILED,
+                    JitsiConnectionErrors.PASSWORD_REQUIRED);
+            } else if(this.connectionFailed) {
+                this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_FAILED,
+                    JitsiConnectionErrors.OTHER_ERROR, errMsg);
+            } else if (!wasIntentionalDisconnect) {
+                // XXX if Strophe drops the connection while not being asked to,
+                // it means that most likely some serious error has occurred.
+                // One currently known case is when a BOSH request fails for
+                // more than 4 times. The connection is dropped without
+                // supplying a reason(error message/event) through the API.
+                logger.error("XMPP connection dropped!");
+                this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_FAILED,
+                    JitsiConnectionErrors.OTHER_ERROR,
+                    errMsg ? errMsg : 'connection-dropped-error');
+            } else {
+                this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_DISCONNECTED, errMsg);
+            }
+        } else if (status === Strophe.Status.AUTHFAIL) {
+            // wrong password or username, prompt user
             this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
                 JitsiConnectionErrors.PASSWORD_REQUIRED);
-        } else if(this.connectionFailed) {
-            this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                JitsiConnectionErrors.OTHER_ERROR,
-                msg ? msg : this.lastErrorMsg);
-        } else {
-            this.eventEmitter.emit(
-                    JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                    msg ? msg : this.lastErrorMsg);
+
         }
-    } else if (status === Strophe.Status.AUTHFAIL) {
-        // wrong password or username, prompt user
-        this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-            JitsiConnectionErrors.PASSWORD_REQUIRED);
+    }
 
+    _connect (jid, password) {
+        // connection.connect() starts the connection process.
+        //
+        // As the connection process proceeds, the user supplied callback will
+        // be triggered multiple times with status updates. The callback should
+        // take two arguments - the status code and the error condition.
+        //
+        // The status code will be one of the values in the Strophe.Status
+        // constants. The error condition will be one of the conditions defined
+        // in RFC 3920 or the condition ‘strophe-parsererror’.
+        //
+        // The Parameters wait, hold and route are optional and only relevant
+        // for BOSH connections. Please see XEP 124 for a more detailed
+        // explanation of the optional parameters.
+        //
+        // Connection status constants for use by the connection handler
+        // callback.
+        //
+        //  Status.ERROR - An error has occurred (websockets specific)
+        //  Status.CONNECTING - The connection is currently being made
+        //  Status.CONNFAIL - The connection attempt failed
+        //  Status.AUTHENTICATING - The connection is authenticating
+        //  Status.AUTHFAIL - The authentication attempt failed
+        //  Status.CONNECTED - The connection has succeeded
+        //  Status.DISCONNECTED - The connection has been terminated
+        //  Status.DISCONNECTING - The connection is currently being terminated
+        //  Status.ATTACHED - The connection has been attached
+
+        this.anonymousConnectionFailed = false;
+        this.connectionFailed = false;
+        this.lastErrorMsg = undefined;
+        this.connection.connect(jid, password,
+            this.connectionHandler.bind(this, password));
     }
-}
 
-XMPP.prototype._connect = function (jid, password) {
-    // connection.connect() starts the connection process.
-    //
-    // As the connection process proceeds, the user supplied callback will
-    // be triggered multiple times with status updates. The callback should
-    // take two arguments - the status code and the error condition.
-    //
-    // The status code will be one of the values in the Strophe.Status
-    // constants. The error condition will be one of the conditions defined
-    // in RFC 3920 or the condition ‘strophe-parsererror’.
-    //
-    // The Parameters wait, hold and route are optional and only relevant
-    // for BOSH connections. Please see XEP 124 for a more detailed
-    // explanation of the optional parameters.
-    //
-    // Connection status constants for use by the connection handler
-    // callback.
-    //
-    //  Status.ERROR - An error has occurred (websockets specific)
-    //  Status.CONNECTING - The connection is currently being made
-    //  Status.CONNFAIL - The connection attempt failed
-    //  Status.AUTHENTICATING - The connection is authenticating
-    //  Status.AUTHFAIL - The authentication attempt failed
-    //  Status.CONNECTED - The connection has succeeded
-    //  Status.DISCONNECTED - The connection has been terminated
-    //  Status.DISCONNECTING - The connection is currently being terminated
-    //  Status.ATTACHED - The connection has been attached
-
-    this.anonymousConnectionFailed = false;
-    this.connectionFailed = false;
-    this.lastErrorMsg = undefined;
-    this.connection.connect(jid, password,
-        this.connectionHandler.bind(this, password));
-}
+    /**
+     * Attach to existing connection. Can be used for optimizations. For example:
+     * if the connection is created on the server we can attach to it and start
+     * using it.
+     *
+     * @param options {object} connecting options - rid, sid, jid and password.
+     */
+    attach (options) {
+        const now = this.connectionTimes["attaching"] = window.performance.now();
+        logger.log("(TIME) Strophe Attaching\t:" + now);
+        this.connection.attach(options.jid, options.sid,
+            parseInt(options.rid,10)+1,
+            this.connectionHandler.bind(this, options.password));
+    }
 
-/**
- * Attach to existing connection. Can be used for optimizations. For example:
- * if the connection is created on the server we can attach to it and start
- * using it.
- *
- * @param options {object} connecting options - rid, sid, jid and password.
- */
- XMPP.prototype.attach = function (options) {
-    var now = this.connectionTimes["attaching"] = window.performance.now();
-    logger.log("(TIME) Strophe Attaching\t:" + now);
-    this.connection.attach(options.jid, options.sid, parseInt(options.rid,10)+1,
-        this.connectionHandler.bind(this, options.password));
-}
+    connect (jid, password) {
+        this.connectParams = {
+            jid: jid,
+            password: password
+        };
+        if (!jid) {
+            let configDomain
+                = this.options.hosts.anonymousdomain ||
+                    this.options.hosts.domain;
+            // Force authenticated domain if room is appended with '?login=true'
+            // or if we're joining with the token
+            if (this.options.hosts.anonymousdomain
+                    && (window.location.search.indexOf("login=true") !== -1
+                        || this.options.token)) {
+                configDomain = this.options.hosts.domain;
+            }
+            jid = configDomain || window.location.hostname;
+        }
+        return this._connect(jid, password);
+    }
 
-XMPP.prototype.connect = function (jid, password) {
-    if (!jid) {
-        var configDomain
-            = this.options.hosts.anonymousdomain || this.options.hosts.domain;
-        // Force authenticated domain if room is appended with '?login=true'
-        // or if we're joining with the token
-        if (this.options.hosts.anonymousdomain
-                && (window.location.search.indexOf("login=true") !== -1
-                    || this.options.token)) {
-            configDomain = this.options.hosts.domain;
+    createRoom (roomName, options, settings) {
+        // By default MUC nickname is the resource part of the JID
+        let mucNickname = Strophe.getNodeFromJid(this.connection.jid);
+        let roomjid = roomName  + "@" + this.options.hosts.muc + "/";
+        let cfgNickname
+            = (options.useNicks && options.nick) ? options.nick : null;
+
+        if (cfgNickname) {
+            // Use nick if it's defined
+            mucNickname = options.nick;
+        } else if (!this.authenticatedUser) {
+            // node of the anonymous JID is very long - here we trim it a bit
+            mucNickname = mucNickname.substr(0, 8);
         }
-        jid = configDomain || window.location.hostname;
+        // Constant JIDs need some random part to be appended in order to be
+        // able to join the MUC more than once.
+        if (this.authenticatedUser || cfgNickname != null) {
+            mucNickname += "-" + RandomUtil.randomHexString(6);
+        }
+
+        roomjid += mucNickname;
+
+        return this.connection.emuc.createRoom(roomjid, null, options,
+            settings);
     }
-    return this._connect(jid, password);
-};
 
-XMPP.prototype.createRoom = function (roomName, options, settings) {
-    var roomjid = roomName  + '@' + this.options.hosts.muc;
+    addListener (type, listener) {
+        this.eventEmitter.on(type, listener);
+    }
 
-    if (options.useNicks) {
-        if (options.nick) {
-            roomjid += '/' + options.nick;
-        } else {
-            roomjid += '/' + Strophe.getNodeFromJid(this.connection.jid);
-        }
-    } else {
-        var tmpJid = Strophe.getNodeFromJid(this.connection.jid);
+    removeListener (type, listener) {
+        this.eventEmitter.removeListener(type, listener);
+    }
 
-        if (!authenticatedUser)
-            tmpJid = tmpJid.substr(0, 8);
-        else
-            tmpJid += "-" + RandomUtil.randomHexString(6);
+    /**
+     * Sends 'data' as a log message to the focus. Returns true iff a message
+     * was sent.
+     * @param data
+     * @returns {boolean} true iff a message was sent.
+     */
+    sendLogs (data) {
+        if (!this.connection.emuc.focusMucJid)
+            return false;
+
+        const content = Base64.encode(
+            String.fromCharCode.apply(null,
+                Pako.deflateRaw(JSON.stringify(data))));
+        // XEP-0337-ish
+        const message = $msg({
+            to: this.connection.emuc.focusMucJid,
+            type: "normal"
+        });
+        message.c("log", {
+            xmlns: "urn:xmpp:eventlog",
+            id: "PeerConnectionStats"
+        });
+        message.c("message").t(content).up();
+        message.c("tag", {name: "deflated", value: "true"}).up();
+        message.up();
+
+        this.connection.send(message);
+        return true;
+    }
 
-        roomjid += '/' + tmpJid;
+    /**
+     * Returns the logs from strophe.jingle.
+     * @returns {Object}
+     */
+    getJingleLog () {
+        const jingle = this.connection.jingle;
+        return jingle? jingle.getLog() : {};
     }
 
-    return this.connection.emuc.createRoom(roomjid, null, options, settings);
-}
+    /**
+     * Returns the logs from strophe.
+     */
+    getXmppLog () {
+        return (this.connection.logger || {}).log || null;
+    }
 
-XMPP.prototype.addListener = function(type, listener) {
-    this.eventEmitter.on(type, listener);
-};
-
-XMPP.prototype.removeListener = function (type, listener) {
-    this.eventEmitter.removeListener(type, listener);
-};
-
-/**
- * Sends 'data' as a log message to the focus. Returns true iff a message
- * was sent.
- * @param data
- * @returns {boolean} true iff a message was sent.
- */
-XMPP.prototype.sendLogs = function (data) {
-    if (!this.connection.emuc.focusMucJid)
-        return false;
-
-    var deflate = true;
-
-    var content = JSON.stringify(data);
-    if (deflate) {
-        content = String.fromCharCode.apply(null, Pako.deflateRaw(content));
+    dial (to, from, roomName,roomPass) {
+        this.connection.rayo.dial(to, from, roomName,roomPass);
     }
-    content = Base64.encode(content);
-    // XEP-0337-ish
-    var message = $msg({to: this.connection.emuc.focusMucJid, type: 'normal'});
-    message.c('log', {xmlns: 'urn:xmpp:eventlog', id: 'PeerConnectionStats'});
-    message.c('message').t(content).up();
-    if (deflate) {
-        message.c('tag', {name: "deflated", value: "true"}).up();
+
+    setMute (jid, mute) {
+        this.connection.moderate.setMute(jid, mute);
     }
-    message.up();
-
-    this.connection.send(message);
-    return true;
-};
-
-// Gets the logs from strophe.jingle.
-XMPP.prototype.getJingleLog = function () {
-    return this.connection.jingle ? this.connection.jingle.getLog() : {};
-};
-
-// Gets the logs from strophe.
-XMPP.prototype.getXmppLog = function () {
-    return this.connection.logger ? this.connection.logger.log : null;
-};
-
-XMPP.prototype.dial = function (to, from, roomName,roomPass) {
-    this.connection.rayo.dial(to, from, roomName,roomPass);
-};
-
-XMPP.prototype.setMute = function (jid, mute) {
-    this.connection.moderate.setMute(jid, mute);
-};
-
-XMPP.prototype.eject = function (jid) {
-    this.connection.moderate.eject(jid);
-};
-
-XMPP.prototype.getSessions = function () {
-    return this.connection.jingle.sessions;
-};
-
-/**
- * Disconnects this from the XMPP server (if this is connected).
- *
- * @param ev optionally, the event which triggered the necessity to disconnect
- * from the XMPP server (e.g. beforeunload, unload)
- */
-XMPP.prototype.disconnect = function (ev) {
-    if (this.disconnectInProgress
-            || !this.connection
-            || !this.connection.connected) {
-        this.eventEmitter.emit(JitsiConnectionEvents.WRONG_STATE);
-        return;
+
+    eject (jid) {
+        this.connection.moderate.eject(jid);
     }
 
-    this.disconnectInProgress = true;
-
-    // XXX Strophe is asynchronously sending by default. Unfortunately, that
-    // means that there may not be enough time to send an unavailable presence
-    // or disconnect at all. Switching Strophe to synchronous sending is not
-    // much of an option because it may lead to a noticeable delay in navigating
-    // away from the current location. As a compromise, we will try to increase
-    // the chances of sending an unavailable presence and/or disconecting within
-    // the short time span that we have upon unloading by invoking flush() on
-    // the connection. We flush() once before disconnect() in order to attemtp
-    // to have its unavailable presence at the top of the send queue. We flush()
-    // once more after disconnect() in order to attempt to have its unavailable
-    // presence sent as soon as possible.
-    this.connection.flush();
-
-    if (ev !== null && typeof ev !== 'undefined') {
-        var evType = ev.type;
-
-        if (evType == 'beforeunload' || evType == 'unload') {
-            // XXX Whatever we said above, synchronous sending is the best
-            // (known) way to properly disconnect from the XMPP server.
-            // Consequently, it may be fine to have the source code and comment
-            // it in or out depending on whether we want to run with it for some
-            // time.
-            this.connection.options.sync = true;
-        }
+    getSessions () {
+        return this.connection.jingle.sessions;
     }
 
-    this.connection.disconnect();
+    /**
+     * Disconnects this from the XMPP server (if this is connected).
+     *
+     * @param ev optionally, the event which triggered the necessity to disconnect
+     * from the XMPP server (e.g. beforeunload, unload)
+     */
+    disconnect (ev) {
+        if (this.disconnectInProgress
+                || !this.connection
+                || !this.connection.connected) {
+            this.eventEmitter.emit(JitsiConnectionEvents.WRONG_STATE);
+            return;
+        }
 
-    if (this.connection.options.sync !== true) {
+        this.disconnectInProgress = true;
+
+        // XXX Strophe is asynchronously sending by default. Unfortunately, that
+        // means that there may not be enough time to send an unavailable presence
+        // or disconnect at all. Switching Strophe to synchronous sending is not
+        // much of an option because it may lead to a noticeable delay in navigating
+        // away from the current location. As a compromise, we will try to increase
+        // the chances of sending an unavailable presence and/or disconecting within
+        // the short time span that we have upon unloading by invoking flush() on
+        // the connection. We flush() once before disconnect() in order to attemtp
+        // to have its unavailable presence at the top of the send queue. We flush()
+        // once more after disconnect() in order to attempt to have its unavailable
+        // presence sent as soon as possible.
         this.connection.flush();
+
+        if (ev !== null && typeof ev !== 'undefined') {
+            const evType = ev.type;
+
+            if (evType == 'beforeunload' || evType == 'unload') {
+                // XXX Whatever we said above, synchronous sending is the best
+                // (known) way to properly disconnect from the XMPP server.
+                // Consequently, it may be fine to have the source code and comment
+                // it in or out depending on whether we want to run with it for some
+                // time.
+                this.connection.options.sync = true;
+            }
+        }
+
+        this.connection.disconnect();
+
+        if (this.connection.options.sync !== true) {
+            this.connection.flush();
+        }
     }
-};
 
-module.exports = XMPP;
+    _initStrophePlugins() {
+        initEmuc(this);
+        initJingle(this, this.eventEmitter);
+        initStropheUtil();
+        initPing(this, this.eventEmitter);
+        initRayo();
+        initStropheLogger();
+    }
+}

package.json

   "description": "JS library for accessing Jitsi server side deployments",
   "repository": {
     "type": "git",
-    "url": "git://github.com/jitsi/jitsi-meet"
+    "url": "git://github.com/jitsi/lib-jitsi-meet"
   },
   "keywords": [
     "jingle",
     "webrtc",
     "xmpp",
-    "browser"
+    "browser",
+    "jitsi"
   ],
   "author": "",
   "readmeFilename": "README.md",
   "dependencies": {
+    "async": "0.9.0",
+    "current-executing-script": "*",
     "events": "*",
+    "jitsi-meet-logger": "jitsi/jitsi-meet-logger",
+    "jssha": "1.5.0",
     "pako": "*",
+    "retry": "0.6.1",
     "sdp-interop": "0.1.11",
-    "sdp-transform": "1.5.*",
     "sdp-simulcast": "0.1.7",
-    "async": "0.9.0",
-    "retry": "0.6.1",
-    "jssha": "1.5.0",
-    "es6-promise": "*",
-    "jitsi-meet-logger": "jitsi/jitsi-meet-logger",
+    "sdp-transform": "1.5.*",
+    "socket.io-client": "1.4.5",
     "strophe": "^1.2.2",
-    "strophejs-plugins": "^0.0.6",
-    "socket.io-client": "1.3.6"
+    "strophejs-plugins": "^0.0.6"
   },
   "devDependencies": {
-    "browserify": "11.1.x",
+    "babel-core": "*",
+    "babel-loader": "*",
+    "babel-polyfill": "*",
+    "babel-preset-es2015": "*",
+    "eslint": "*",
     "jshint": "^2.8.0",
     "precommit-hook": "^3.0.0",
-    "exorcist": "*",
-    "uglify-js": "2.4.24",
-    "watchify": "^3.7.0"
+    "string-replace-loader": "*",
+    "webpack": "*"
   },
   "scripts": {
-    "install": "npm run browserify && npm run version && npm run uglifyjs",
-
-    "browserify": "browserify -d JitsiMeetJS.js -s JitsiMeetJS | exorcist lib-jitsi-meet.js.map > lib-jitsi-meet.js && [ -s lib-jitsi-meet.js ]",
-    "version": "VERSION=`./get-version.sh` && echo lib-jitsi-meet version is:${VERSION} && sed -i'' -e s/{#COMMIT_HASH#}/${VERSION}/g lib-jitsi-meet.js",
-    "uglifyjs": "uglifyjs -p relative lib-jitsi-meet.js -o lib-jitsi-meet.min.js --source-map lib-jitsi-meet.min.map --in-source-map lib-jitsi-meet.js.map",
-    "watch": "watchify JitsiMeetJS.js -s JitsiMeetJS -o lib-jitsi-meet.js -v",
-    "lint": "jshint .",
+    "install": "webpack -p",
+    "lint": "jshint . && eslint .",
     "validate": "npm ls"
   },
   "pre-commit": [

service/RTC/CameraFacingMode.js

+/* global module */
+/**
+ * The possible camera facing modes. For now support only 'user' and
+ * 'environment' because 'left' and 'right' are not used anywhere in our
+ * projects at the time of this writing. For more information please refer to
+ * https://w3c.github.io/mediacapture-main/getusermedia.html#def-constraint-facingMode
+ *
+ * @enum {string}
+ */
+var CameraFacingMode = {
+    /**
+     * The mode which specifies the environment-facing camera.
+     */
+    ENVIRONMENT: "environment",
+
+    /**
+     * The mode which specifies the user-facing camera.
+     */
+    USER: "user"
+};
+
+module.exports = CameraFacingMode;

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",
+    DOMINANT_SPEAKER_CHANGED: "rtc.dominant_speaker_changed",
     LASTN_ENDPOINT_CHANGED: "rtc.lastn_endpoint_changed",
     AVAILABLE_DEVICES_CHANGED: "rtc.available_devices_changed",
     TRACK_ATTACHED: "rtc.track_attached",
+    REMOTE_TRACK_MUTE: "rtc.remote_track_mute",
+    REMOTE_TRACK_UNMUTE: "rtc.remote_track_unmute",
     AUDIO_OUTPUT_DEVICE_CHANGED: "rtc.audio_output_device_changed",
     DEVICE_LIST_CHANGED: "rtc.device_list_changed",
-    DEVICE_LIST_AVAILABLE: "rtc.device_list_available"
+    DEVICE_LIST_AVAILABLE: "rtc.device_list_available",
+    /**
+     * Indicates that a message from another participant is received on
+     * data channel.
+     */
+    ENDPOINT_MESSAGE_RECEIVED:
+        "rtc.endpoint_message_received"
 };
 
 module.exports = RTCEvents;

service/connectionquality/CQEvents.js

-var CQEvents = {
-    LOCALSTATS_UPDATED: "cq.localstats_updated",
-    REMOTESTATS_UPDATED: "cq.remotestats_updated",
-    STOP: "cq.stop"
-};
-
-module.exports = CQEvents;

service/connectivity/ConnectionQualityEvents.js

+/**
+ * Indicates that the local connection statistics were updated.
+ */
+export const LOCAL_STATS_UPDATED = "cq.local_stats_updated";
+
+/**
+ * Indicates that the connection statistics for a particular remote participant
+ * were updated.
+ */
+export const REMOTE_STATS_UPDATED = "cq.remote_stats_updated";

service/statistics/Events.js

-module.exports = {
-    /**
-     * An event carrying connection statistics.
-     */
-    CONNECTION_STATS: "statistics.connectionstats",
-    /**
-     * FIXME: needs documentation.
-     */
-    AUDIO_LEVEL: "statistics.audioLevel",
-    /**
-     * Notifies about audio problem with remote participant.
-     */
-    AUDIO_NOT_WORKING: "statistics.audio_not_working"
-};
+/**
+ * Notifies about audio level in RTP statistics by SSRC.
+ *
+ * @param ssrc - The synchronization source identifier (SSRC) of the
+ * endpoint/participant whose audio level is being reported.
+ * @param {number} audioLevel - The audio level of <tt>ssrc</tt> according to
+ * RTP statistics.
+ * @param {boolean} isLocal - <tt>true</tt> if <tt>ssrc</tt> identifies the
+ * local endpoint/participant; otherwise, <tt>false</tt>.
+ */
+export const AUDIO_LEVEL = "statistics.audioLevel";
+
+/**
+ * An event carrying all statistics by ssrc.
+ */
+export const BYTE_SENT_STATS = "statistics.byte_sent_stats";
+
+/**
+ * An event carrying connection statistics.
+ *
+ * @param {object} connectionStats - The connection statistics carried by the
+ * event such as <tt>bandwidth</tt>, <tt>bitrate</tt>, <tt>packetLoss</tt>,
+ * <tt>resolution</tt>, and <tt>transport</tt>.
+ */
+export const CONNECTION_STATS = "statistics.connectionstats";

service/xmpp/XMPPEvents.js

     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.
     CALL_INCOMING: "xmpp.callincoming.jingle",
+    // Triggered when Jicofo kills our media session, this can happen while
+    // we're still in the MUC, when it decides to terminate the media session.
+    // For example when the session is idle for too long, because we're the only
+    // person in the conference room.
+    CALL_ENDED: "xmpp.callended.jingle",
     CHAT_ERROR_RECEIVED: "xmpp.chat_error_received",
     CONFERENCE_SETUP_FAILED: "xmpp.conference_setup_failed",
     // Designates an event indicating that the connection to the XMPP server
     // Designates an event indicating that the display name of a participant
     // has changed.
     DISPLAY_NAME_CHANGED: "xmpp.display_name_changed",
-    DISPOSE_CONFERENCE: "xmpp.dispose_conference",
     ETHERPAD: "xmpp.etherpad",
     FOCUS_DISCONNECTED: 'xmpp.focus_disconnected',
     FOCUS_LEFT: "xmpp.focus_left",
     MUC_MEMBER_JOINED: "xmpp.muc_member_joined",
     // Designates an event indicating that a participant left the XMPP MUC.
     MUC_MEMBER_LEFT: "xmpp.muc_member_left",
+    // Designates an event indicating that local participant left the muc
+    MUC_LEFT: "xmpp.muc_left",
     // Designates an event indicating that the MUC role of a participant has
     // changed.
     MUC_ROLE_CHANGED: "xmpp.muc_role_changed",
+    // Designates an event indicating that the MUC has been locked or unlocked.
+    MUC_LOCK_CHANGED: "xmpp.muc_lock_changed",
     // Designates an event indicating that a participant in the XMPP MUC has
     // advertised that they have audio muted (or unmuted).
     PARTICIPANT_AUDIO_MUTED: "xmpp.audio_muted",
     REMOTE_TRACK_REMOVED: "xmpp.remote_track_removed",
     RESERVATION_ERROR: "xmpp.room_reservation_error",
     ROOM_CONNECT_ERROR: 'xmpp.room_connect_error',
+    ROOM_CONNECT_NOT_ALLOWED_ERROR: 'xmpp.room_connect_error.not_allowed',
     ROOM_JOIN_ERROR: 'xmpp.room_join_error',
     /**
      * Indicates that max users limit has been reached.
      * Indicates that the local sendrecv streams in local SDP are changed.
      */
     SENDRECV_STREAMS_CHANGED: "xmpp.sendrecv_streams_changed",
+    /**
+     * Event fired when we do not get our 'session-accept' acknowledged by
+     * Jicofo. It most likely means that there is serious problem with our
+     * connection or XMPP server and we should reload the conference.
+     *
+     * We have seen that to happen in BOSH requests race condition when the BOSH
+     * request table containing the 'session-accept' was discarded by Prosody.
+     * Jicofo does send the RESULT immediately without any condition, so missing
+     * packets means that most likely it has never seen our IQ.
+     */
+    SESSION_ACCEPT_TIMEOUT: "xmpp.session_accept_timeout",
     // TODO: only used in a hack, should probably be removed.
     SET_LOCAL_DESCRIPTION_ERROR: 'xmpp.set_local_description_error',
 
     LOCAL_UFRAG_CHANGED: "xmpp.local_ufrag_changed",
     // Designates an event indicating that the local ICE username fragment of
     // the jingle session has changed.
-    REMOTE_UFRAG_CHANGED: "xmpp.remote_ufrag_changed"
+    REMOTE_UFRAG_CHANGED: "xmpp.remote_ufrag_changed",
+    // Designates an event indicating that the local ICE connection state has
+    // changed.
+    ICE_CONNECTION_STATE_CHANGED: "xmpp.ice_connection_state_changed"
 };
 module.exports = XMPPEvents;

webpack.config.js

+/* global __dirname */
+
+var child_process = require('child_process'); // eslint-disable-line camelcase
+var process = require('process');
+
+var minimize
+    = process.argv.indexOf('-p') !== -1
+        || process.argv.indexOf('--optimize-minimize') !== -1;
+
+module.exports = {
+    devtool: 'source-map',
+    entry: {
+        'lib-jitsi-meet': './JitsiMeetJS.js'
+    },
+    module: {
+        loaders: [ {
+            // Version this build of the lib-jitsi-meet library.
+
+            loader: 'string-replace',
+            query: {
+                flags: 'g',
+                replace:
+                    child_process.execSync( // eslint-disable-line camelcase
+                            __dirname + '/get-version.sh')
+
+                        // The type of the return value of
+                        // child_process.execSync is either Buffer or String.
+                        .toString()
+
+                            // Shells may automatically append CR and/or LF
+                            // characters to the output.
+                            .trim(),
+                search: '{#COMMIT_HASH#}'
+            },
+            test: __dirname + '/JitsiMeetJS.js'
+        }, {
+            // Transpile ES2015 (aka ES6) to ES5.
+
+            exclude: [
+                __dirname + '/modules/RTC/adapter.screenshare.js',
+                __dirname + '/node_modules/'
+            ],
+            loader: 'babel',
+            query: {
+                presets: [
+                    'es2015'
+                ]
+            },
+            test: /\.js$/
+        } ]
+    },
+    node: {
+        // Allow the use of the real filename of the module being executed. By
+        // default Webpack does not leak path-related information and provides a
+        // value that is a mock (/index.js).
+        __filename: true
+    },
+    output: {
+        filename: '[name]' + (minimize ? '.min' : '') + '.js',
+        library: 'JitsiMeetJS',
+        libraryTarget: 'umd',
+        sourceMapFilename: '[name].' + (minimize ? 'min' : 'js') + '.map'
+    }
+};