Merge pull request #166 from jitsi/reloads

Implements reload functionality for JitsiConnection and JitsiConference

JitsiConference.js

 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTC = require("./modules/RTC/RTC");
 var XMPPEvents = require("./service/xmpp/XMPPEvents");
-var AuthenticationEvents = require("./service/authentication/AuthenticationEvents");
-var RTCEvents = require("./service/RTC/RTCEvents");
 var EventEmitter = require("events");
 var JitsiConferenceEvents = require("./JitsiConferenceEvents");
 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var Settings = require("./modules/settings/Settings");
 var ComponentsVersions = require("./modules/version/ComponentsVersions");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
+var JitsiConferenceEventManager = require("./JitsiConferenceEventManager");
 
 /**
  * Creates a JitsiConference object with the given name and properties.
         logger.error(errmsg);
         throw new Error(errmsg);
     }
-    this.options = options;
-    this.connection = this.options.connection;
-    this.xmpp = this.connection.xmpp;
     this.eventEmitter = new EventEmitter();
-    var confID = this.options.name  + '@' + this.xmpp.options.hosts.muc;
     this.settings = new Settings();
-    this.room = this.xmpp.createRoom(this.options.name, this.options.config,
-        this.settings);
-    this.componentsVersions = new ComponentsVersions(this.room);
-    this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
-    this.rtc = new RTC(this.room, options);
-    this.statistics = new Statistics(this.xmpp, {
-        callStatsID: this.options.config.callStatsID,
-        callStatsSecret: this.options.config.callStatsSecret,
-        disableThirdPartyRequests:
-            this.options.config.disableThirdPartyRequests,
-        roomName: this.options.name
-    });
-    setupListeners(this);
+    this.retries = 0;
+    this.options = options;
+    this.eventManager = new JitsiConferenceEventManager(this);
+    this._init(options);
+    this.componentsVersions = new ComponentsVersions(this);
     this.participants = {};
     this.lastDominantSpeaker = null;
     this.dtmfManager = null;
     this.reportedAudioSSRCs = {};
 }
 
+/**
+ * Initializes the conference object properties
+ * @param options {object}
+ * @param connection {JitsiConnection} overrides this.connection
+ * @param roomState {object} the state of the ChatRoom instance received by
+ * ChatRoom.exportState. If this property is set it will be passed to
+ * ChatRoom.loadState
+ */
+JitsiConference.prototype._init = function (options) {
+    if(!options)
+        options = {};
+
+    // Override connection and xmpp properties (Usefull if the connection
+    // reloaded)
+    if(options.connection) {
+        this.connection = options.connection;
+        this.xmpp = this.connection.xmpp;
+        // Setup XMPP events only if we have new connection object.
+        this.eventManager.setupXMPPListeners();
+    }
+
+    this.retries++;
+    this.room = this.xmpp.createRoom(this.options.name, this.options.config,
+        this.settings, (this.retries < 4 ? 3 : null));
+
+    this.eventManager.setupChatRoomListeners();
+
+    //restore previous presence options
+    if(options.roomState) {
+        this.room.loadState(options.roomState);
+    }
+    this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
+
+    if(!this.rtc) {
+        this.rtc = new RTC(this, options);
+        this.eventManager.setupRTCListeners();
+    }
+
+
+    if(!this.statistics) {
+        this.statistics = new Statistics(this.xmpp, {
+            callStatsID: this.options.config.callStatsID,
+            callStatsSecret: this.options.config.callStatsSecret,
+            disableThirdPartyRequests:
+                this.options.config.disableThirdPartyRequests,
+            roomName: this.options.name
+        });
+    }
+    // Always add listeners because on reload we are executing leave and the
+    // listeners are removed from statistics module.
+    this.eventManager.setupStatisticsListeners();
+}
+
+/**
+ * Reloads the conference
+ * @param options {object} options to be overriden
+ */
+JitsiConference.prototype._reload = function (options) {
+    var roomState = this.room.exportState();
+    if(!options)
+        options = {};
+    options.roomState = roomState;
+    this.leave(true);
+    this._init(options);
+    this.join();
+}
+
 /**
  * Joins the conference.
  * @param password {string} the password
  * Leaves the conference and calls onMemberLeft for every participant.
  */
 JitsiConference.prototype._leaveRoomAndRemoveParticipants = function () {
+    // remove all participants
+    this.getParticipants().forEach(function (participant) {
+        this.onMemberLeft(participant.getJid());
+    }.bind(this));
+
     // leave the conference
     if (this.room) {
         this.room.leave();
     }
 
     this.room = null;
-    // remove all participants
-    this.getParticipants().forEach(function (participant) {
-        this.onMemberLeft(participant.getJid());
-    }.bind(this));
 
     this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
 }
  * Leaves the conference.
  * @returns {Promise}
  */
-JitsiConference.prototype.leave = function () {
+JitsiConference.prototype.leave = function (dontRemoveLocalTracks) {
     var conference = this;
 
+    this.statistics.stopCallStats();
+    this.rtc.closeAllDataChannels();
+    if(dontRemoveLocalTracks) {
+        this._leaveRoomAndRemoveParticipants();
+        return  Promise.resolve();
+    }
+
     return Promise.all(
         conference.getLocalTracks().map(function (track) {
             return conference.removeTrack(track);
                 });
             }
             this.rtc.addLocalTrack(track);
+
             if (track.startMuted) {
                 track.mute();
             }
                                    track.muteHandler);
             track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                                    track.audioLevelHandler);
-            //FIXME: This dependacy is not necessary. This is quick fix.
+
             track._setConference(this);
 
             // send event for starting screen sharing
     emitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
 };
 
+/**
+ * Handles incoming call event.
+ */
+JitsiConference.prototype.onIncomingCall =
+function (jingleSession, jingleOffer, now) {
+    if (!this.room.isFocus(jingleSession.peerjid)) {
+        // Error cause this should never happen unless something is wrong!
+        var errmsg = "Rejecting session-initiate from non-focus user: "
+                + jingleSession.peerjid;
+        GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
+        logger.error(errmsg);
+        return;
+    }
+
+    // Accept incoming call
+    this.room.setJingleSession(jingleSession);
+    this.room.connectionTimes["session.initiate"] = now;
+    try{
+        jingleSession.initialize(false /* initiator */,this.room);
+    } catch (error) {
+        GlobalOnErrorHandler.callErrorHandler(error);
+    };
+
+    this.rtc.onIncommingCall(jingleSession);
+    // Add local Tracks to the ChatRoom
+    this.rtc.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));
+
+    jingleSession.acceptOffer(jingleOffer, null,
+        function (error) {
+            GlobalOnErrorHandler.callErrorHandler(error);
+            logger.error(
+                "Failed to accept incoming Jingle session", error);
+        }
+    );
+
+    // Start callstats as soon as peerconnection is initialized,
+    // do not wait for XMPPEvents.PEERCONNECTION_READY, as it may never
+    // happen in case if user doesn't have or denied permission to
+    // both camera and microphone.
+    this.statistics.startCallStats(jingleSession, this.settings);
+    this.statistics.startRemoteStats(jingleSession.peerconnection);
+}
+
 JitsiConference.prototype.updateDTMFSupport = function () {
     var somebodySupportsDTMF = false;
     var participants = this.getParticipants();
     return this.statistics.isCallstatsEnabled();
 }
 
+
+/**
+ * Handles track attached to container (Calls associateStreamWithVideoTag method
+ * from statistics module)
+ * @param track the track
+ * @param container the container
+ */
+JitsiConference.prototype._onTrackAttach = function(track, container) {
+    var ssrc = track.getSSRC();
+    if (!container.id || !ssrc) {
+        return;
+    }
+    this.statistics.associateStreamWithVideoTag(
+        ssrc, track.isLocal(), track.getUsageLabel(), container.id);
+}
+
 /**
  * Reports detected audio problem with the media stream related to the passed
  * ssrc.
 };
 
 /**
- * Setups the listeners needed for the conference.
- * @param conference the conference
+ * 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.
  */
-function setupListeners(conference) {
-    conference.xmpp.addListener(
-        XMPPEvents.CALL_INCOMING, function (jingleSession, jingleOffer, now) {
-
-        if (conference.room.isFocus(jingleSession.peerjid)) {
-            // Accept incoming call
-            conference.room.setJingleSession(jingleSession);
-            conference.room.connectionTimes["session.initiate"] = now;
-            try{
-                jingleSession.initialize(false /* initiator */,
-                    conference.room);
-            } catch (error) {
-                GlobalOnErrorHandler.callErrorHandler(error);
-            };
-            conference.rtc.onIncommingCall(jingleSession);
-            jingleSession.acceptOffer(jingleOffer, null,
-                function (error) {
-                    GlobalOnErrorHandler.callErrorHandler(error);
-                    logger.error(
-                        "Failed to accept incoming Jingle session", error);
-                }
-            );
-            // Start callstats as soon as peerconnection is initialized,
-            // do not wait for XMPPEvents.PEERCONNECTION_READY, as it may never
-            // happen in case if user doesn't have or denied permission to
-            // both camera and microphone.
-            conference.statistics.startCallStats(jingleSession, conference.settings);
-            conference.statistics.startRemoteStats(jingleSession.peerconnection);
-        } else {
-            // Error cause this should never happen unless something is wrong!
-            var errmsg
-                = "Rejecting session-initiate from non-focus user: "
-                    + jingleSession.peerjid;
-            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-            logger.error(errmsg);
-        }
-    });
-
-    conference.room.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();
-    });
-
-    conference.room.addListener(XMPPEvents.LOCAL_UFRAG_CHANGED, function (ufrag) {
-        Statistics.sendLog("Local ufrag: " + ufrag);
-    });
-    conference.room.addListener(XMPPEvents.REMOTE_UFRAG_CHANGED, function (ufrag) {
-        Statistics.sendLog("Remote ufrag: " + ufrag);
-    });
-
-    conference.room.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
-        function (data) {
-            var track = conference.rtc.createRemoteTrack(data);
-            if (track) {
-                conference.onTrackAdded(track);
-            }
-        }
-    );
-    conference.room.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.eventEmitter.emit(
-                            JitsiConferenceEvents.TRACK_REMOVED, track);
-                        return;
-                    }
-                }
-            });
-        }
-    );
-
-    conference.room.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");
-                });
-        }
-    );
-
-    conference.room.addListener(XMPPEvents.SUBJECT_CHANGED, function (subject) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.SUBJECT_CHANGED,
-            subject);
-    });
-
-    conference.room.addListener(XMPPEvents.MUC_JOINED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_JOINED);
-    });
-    conference.room.addListener(XMPPEvents.ROOM_JOIN_ERROR, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-            JitsiConferenceErrors.CONNECTION_ERROR, pres);
-    });
-    conference.room.addListener(XMPPEvents.ROOM_CONNECT_ERROR, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-            JitsiConferenceErrors.CONNECTION_ERROR, pres);
-    });
-    conference.room.addListener(XMPPEvents.ROOM_MAX_USERS_ERROR,
-    function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-            JitsiConferenceErrors.CONFERENCE_MAX_USERS, pres);
-    });
-    conference.room.addListener(XMPPEvents.PASSWORD_REQUIRED, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.PASSWORD_REQUIRED, pres);
-    });
-    conference.room.addListener(XMPPEvents.AUTHENTICATION_REQUIRED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.AUTHENTICATION_REQUIRED);
-    });
-    conference.room.addListener(XMPPEvents.BRIDGE_DOWN, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
-    });
-    conference.room.addListener(XMPPEvents.RESERVATION_ERROR, function (code, msg) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.RESERVATION_ERROR, code, msg);
-    });
-    conference.room.addListener(XMPPEvents.GRACEFUL_SHUTDOWN, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
-    });
-    conference.room.addListener(XMPPEvents.JINGLE_FATAL_ERROR, function (session, error) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
-    });
-    conference.room.addListener(XMPPEvents.MUC_DESTROYED, function (reason) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.CONFERENCE_DESTROYED, reason);
-    });
-    conference.room.addListener(XMPPEvents.CHAT_ERROR_RECEIVED, function (err, msg) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_ERROR, JitsiConferenceErrors.CHAT_ERROR, err, msg);
-    });
-    conference.room.addListener(XMPPEvents.FOCUS_DISCONNECTED, function (focus, retrySec) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.FOCUS_DISCONNECTED, focus, retrySec);
-    });
-    conference.room.addListener(XMPPEvents.FOCUS_LEFT, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.FOCUS_LEFT);
-    });
-    conference.room.setParticipantPropertyListener(function (node, from) {
-        var participant = conference.getParticipantById(from);
-        if (!participant) {
-            return;
-        }
-
-        participant.setProperty(
-            node.tagName.substring("jitsi_participant_".length),
-            node.value);
-    });
-
-    conference.room.addListener(XMPPEvents.KICKED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.KICKED);
-    });
-
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_JOINED, conference.onMemberJoined.bind(conference));
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_LEFT, conference.onMemberLeft.bind(conference));
-
-    conference.room.addListener(XMPPEvents.DISPLAY_NAME_CHANGED, conference.onDisplayNameChanged.bind(conference));
-
-    conference.room.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) {
-                    Statistics.sendLog(
-                        "[Recorder] status: " + status
-                            + (error? " error: " + error : ""));
-                });
-        }
-    });
-    conference.room.addListener(XMPPEvents.MUC_ROLE_CHANGED, conference.onUserRoleChanged.bind(conference));
-
-    conference.room.addListener(XMPPEvents.CONNECTION_INTERRUPTED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_INTERRUPTED);
-    });
-
-    conference.room.addListener(XMPPEvents.RECORDER_STATE_CHANGED,
-        function (state) {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.RECORDER_STATE_CHANGED, state);
-        });
-
-    conference.room.addListener(XMPPEvents.PHONE_NUMBER_CHANGED, function () {
-        conference.eventEmitter.emit(
-            JitsiConferenceEvents.PHONE_NUMBER_CHANGED);
-    });
-
-    conference.room.addListener(XMPPEvents.CONNECTION_RESTORED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_RESTORED);
-    });
-    conference.room.addListener(XMPPEvents.CONFERENCE_SETUP_FAILED,
-    function (error) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
-            JitsiConferenceErrors.SETUP_FAILED, error);
-    });
-
-    conference.room.addListener(AuthenticationEvents.IDENTITY_UPDATED, function (authEnabled, authIdentity) {
-        conference.authEnabled = authEnabled;
-        conference.authIdentity = authIdentity;
-        conference.eventEmitter.emit(JitsiConferenceEvents.AUTH_STATUS_CHANGED, authEnabled, authIdentity);
-    });
-
-    conference.room.addListener(XMPPEvents.MESSAGE_RECEIVED, function (jid, displayName, txt, myJid, ts) {
-        var id = Strophe.getResourceFromJid(jid);
-        conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED, id, txt, ts);
-    });
-
-    conference.room.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.rtc.addListener(RTCEvents.DOMINANTSPEAKER_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;
-    });
-
-    conference.rtc.addListener(RTCEvents.LASTN_CHANGED, function (oldValue, newValue) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.IN_LAST_N_CHANGED, oldValue, newValue);
-    });
-
-    conference.rtc.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
-        function (lastNEndpoints, endpointsEnteringLastN) {
-            conference.eventEmitter.emit(JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
-                lastNEndpoints, endpointsEnteringLastN);
-        });
-
-    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) {
-                if (conference.startAudioMuted && track.isAudioTrack()) {
-                    track.mute();
-                }
-                if (conference.startVideoMuted && track.isVideoTrack()) {
-                    track.mute();
-                }
-            });
-
-            conference.eventEmitter.emit(JitsiConferenceEvents.STARTED_MUTED);
-        });
-
-    conference.room.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
-            );
-        }
-    });
-
-    conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED, function (devices) {
-        conference.room.updateDeviceAvailability(devices);
-    });
-    conference.room.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) {
-        //FIXME: Maybe remove event should not be associated with the conference.
-        conference.statistics.addAudioLevelListener(function (ssrc, level) {
-            var userId = null;
-
-            var resource = conference.rtc.getResourceBySSRC(ssrc);
-            if (!resource)
-                return;
-
-            conference.rtc.setAudioLevel(resource, level);
-        });
-
-        conference.statistics.addAudioProblemListener(function (ssrc) {
-            conference._reportAudioProblem(ssrc)
-        });
-
-        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.room.addListener(XMPPEvents.DISPOSE_CONFERENCE,
-            function () {
-                conference.statistics.dispose();
-            });
-
-        conference.room.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-            function (pc) {
-                conference.statistics.sendIceConnectionFailedEvent(pc);
-                conference.room.eventEmitter.emit(
-                    XMPPEvents.CONFERENCE_SETUP_FAILED,
-                    new Error("ICE fail"));
-            });
-
-        conference.rtc.addListener(RTCEvents.TRACK_ATTACHED,
-            function(track, container) {
-                var ssrc = track.getSSRC();
-                if (!container.id || !ssrc) {
-                    return;
-                }
-                conference.statistics.associateStreamWithVideoTag(
-                    ssrc, track.isLocal(), track.getUsageLabel(), container.id);
-
-            });
-
-        conference.on(JitsiConferenceEvents.TRACK_MUTE_CHANGED,
-            function (track) {
-                if(!track.isLocal())
-                    return;
-                var type = (track.getType() === "audio")? "audio" : "video";
-                conference.statistics.sendMuteEvent(track.isMuted(), type);
-            });
-
-        conference.room.addListener(XMPPEvents.CREATE_OFFER_FAILED, function (e, pc) {
-            conference.statistics.sendCreateOfferFailed(e, pc);
-        });
-
-        conference.room.addListener(XMPPEvents.CREATE_ANSWER_FAILED, function (e, pc) {
-            conference.statistics.sendCreateAnswerFailed(e, pc);
-        });
-
-        conference.room.addListener(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
-            function (e, pc) {
-                conference.statistics.sendSetLocalDescFailed(e, pc);
-            }
-        );
-
-        conference.room.addListener(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
-            function (e, pc) {
-                conference.statistics.sendSetRemoteDescFailed(e, pc);
-            }
-        );
-
-        conference.room.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
-            function (e, pc) {
-                conference.statistics.sendAddIceCandidateFailed(e, pc);
-            }
-        );
-    }
-}
+JitsiConference.prototype._isFocus = function (mucJid) {
+    return this.room.isFocus(mucJid);
+};
 
+/**
+ * Fires CONFERENCE_FAILED event with INCOMPATIBLE_SERVER_VERSIONS parameter
+ */
+JitsiConference.prototype._fireIncompatibleVersionsEvent = function () {
+    this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.INCOMPATIBLE_SERVER_VERSIONS);
+};
 
 module.exports = JitsiConference;

JitsiConferenceErrors.js

     /**
      * Indicates that max users limit has been reached.
      */
-    CONFERENCE_MAX_USERS: "conference.max_users"
+    CONFERENCE_MAX_USERS: "conference.max_users",
+    /**
+     * Indicates that the versions of the server side components are
+     * incompatible with the client side.
+     */
+    INCOMPATIBLE_SERVER_VERSIONS: "conference.incompatible_server_versions"
     /**
      * Many more errors TBD here.
      */

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");
+var JitsiConferenceEvents = require("./JitsiConferenceEvents");
+var JitsiConferenceErrors = require("./JitsiConferenceErrors");
+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.eventEmitter.emit(
+                            JitsiConferenceEvents.TRACK_REMOVED, 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);
+
+    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_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);
+
+    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 (pc) {
+            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 () {
+            if(!conference.connection._reload())
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.FOCUS_LEFT);
+        });
+
+    chatRoom.addListener(XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR,
+        function () {
+            conference.connection._reload();
+        });
+
+    this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
+        JitsiConferenceEvents.CONNECTION_INTERRUPTED);
+
+    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);
+
+    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.MUC_MEMBER_JOINED,
+        conference.onMemberJoined.bind(conference));
+    chatRoom.addListener(XMPPEvents.MUC_MEMBER_LEFT,
+        conference.onMemberLeft.bind(conference));
+
+    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) {
+                    Statistics.sendLog("[Recorder] status: " + status
+                        + (error? " error: " + error : ""));
+                });
+        }
+    });
+
+    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);
+        });
+
+    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.DISPOSE_CONFERENCE,
+            function () {
+                conference.statistics.dispose();
+            });
+
+        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;
+    conference.rtc.addListener(RTCEvents.DOMINANTSPEAKER_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;
+    });
+
+    conference.rtc.addListener(RTCEvents.LASTN_CHANGED,
+        function (oldValue, newValue) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.IN_LAST_N_CHANGED, oldValue, newValue);
+        });
+
+    conference.rtc.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
+        function (lastNEndpoints, endpointsEnteringLastN) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
+                lastNEndpoints, endpointsEnteringLastN);
+        });
+
+    conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
+        function (devices) {
+            conference.room.updateDeviceAvailability(devices);
+        });
+};
+
+/**
+ * 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.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);
+    });
+};
+
+module.exports = JitsiConferenceEventManager;

JitsiConnection.js

 var JitsiConference = require("./JitsiConference");
 var XMPP = require("./modules/xmpp/xmpp");
+var JitsiConnectionEvents = require("./JitsiConnectionEvents");
+var JitsiConnectionErrors = require("./JitsiConnectionErrors");
 
 /**
  * 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.retryOnFail = 0;
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+        function () {
+            this.retryOnFail = 3;
+        }.bind(this));
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
+        function (errType, msg) {
+            if(errType === JitsiConnectionErrors.OTHER_ERROR &&
+                (msg === "item-not-found" || msg === "host-unknown")) {
+                    // FIXME: don't report the error if we are going to reload
+                    this._reload();
+                }
+        }.bind(this));
 }
 
 /**
     this.xmpp.attach(options);
 }
 
+/**
+ * Reloads the JitsiConnection instance and all related conferences
+ */
+JitsiConnection.prototype._reload = function () {
+    if(this.retryOnFail === 0)
+        return false;
+    this.retryOnFail--;
+    var states = {};
+    for(var name in this.conferences) {
+        states[name] = this.conferences[name].room.exportState();
+        this.conferences[name].leave(true);
+    }
+    this.connectionEstablishedHandler =
+        this._reloadConferences.bind(this, states);
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+        this.connectionEstablishedHandler);
+    this.xmpp.reload();
+    return true;
+}
+
+/**
+ * Reloads all conferences related to this JitsiConnection instance
+ * @param states {object} the exported states per conference
+ */
+JitsiConnection.prototype._reloadConferences = function (states) {
+    this.removeEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+        this.connectionEstablishedHandler);
+    this.connectionEstablishedHandler = null;
+    states = states || {};
+    for(var name in this.conferences) {
+        this.conferences[name]._init({roomState: states[name]});
+        this.conferences[name].join();
+    }
+}
+
 /**
  * Disconnect the client from the server.
  */

modules/RTC/JitsiLocalTrack.js

     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;
 
         resolve();
         return;
     }
-    if(!this.rtc) {
+    if(!this.conference) {
         this.startMuted = mute;
         resolve();
         return;
         if (this.track)
             this.track.enabled = !mute;
         if(isAudio)
-            this.rtc.room.setAudioMute(mute, callbackFunction);
+            this.conference.room.setAudioMute(mute, callbackFunction);
         else
-            this.rtc.room.setVideoMute(mute, callbackFunction);
+            this.conference.room.setVideoMute(mute, callbackFunction);
     } else {
         if (mute) {
             this.dontFireRemoveEvent = true;
-            this.rtc.room.removeStream(this.stream, function () {
+            this.conference.room.removeStream(this.stream, function () {
                     RTCUtils.stopMediaStream(this.stream);
                     setStreamToNull = true;
                     if(isAudio)
-                        this.rtc.room.setAudioMute(mute, callbackFunction);
+                        this.conference.room.setAudioMute(mute,
+                            callbackFunction);
                     else
-                        this.rtc.room.setVideoMute(mute, callbackFunction);
+                        this.conference.room.setVideoMute(mute,
+                            callbackFunction);
                     //FIXME: Maybe here we should set the SRC for the containers to something
                 }.bind(this),
                 function (error) {
                                     self.containers[i], self.stream);
                     }
 
-                    self.rtc.room.addStream(self.stream,
+                    self.conference.room.addStream(self.stream,
                         function () {
                             if(isAudio)
-                                self.rtc.room.setAudioMute(
+                                self.conference.room.setAudioMute(
                                     mute, callbackFunction);
                             else
-                                self.rtc.room.setVideoMute(
+                                self.conference.room.setVideoMute(
                                     mute, callbackFunction);
                         }, function (error) {
                             reject(error);
     }
 };
 
-/**
- * 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]);
+    }
 };
 
 /**

modules/RTC/JitsiRemoteTrack.js

  * @param muted intial muted state of the JitsiRemoteTrack
  * @constructor
  */
-function JitsiRemoteTrack(RTC, ownerJid, stream, track, mediaType, videoType,
+function JitsiRemoteTrack(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.conference = conference;
     this.peerjid = ownerJid;
     this.muted = muted;
 }

modules/RTC/JitsiTrack.js

  * @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();
  * @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);
     }
 };
 

modules/RTC/RTC.js

     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);
-        }
-    });
 
     // Switch audio output device on all remote audio tracks. Local audio tracks
     // handle this event by themselves.
     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));
 };
 
 RTC.prototype.selectEndpoint = function (id) {
         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.conference,  ownerJid, event.stream,    event.track,
         event.mediaType, event.videoType, event.ssrc, event.muted);
     var resource = Strophe.getResourceFromJid(ownerJid);
     var remoteTracks
  * Closes all currently opened data channels.
  */
 RTC.prototype.closeAllDataChannels = function () {
-    this.dataChannels.closeAllChannels();
+    if(this.dataChannels)
+        this.dataChannels.closeAllChannels();
 };
 
 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);
+    }
+}
+
 module.exports = RTC;

modules/statistics/CallStats.js

         .call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 
+/**
+ * Clears allocated resources.
+ */
+CallStats.dispose = function () {
+    callStats = null;
+    CallStats.initialized = false;
+};
+
 module.exports = CallStats;

modules/statistics/statistics.js

 var ScriptUtil = require('../util/ScriptUtil');
 var JitsiTrackError = require("../../JitsiTrackError");
 
+/**
+ * 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
 // respond. Consequently, it is in our best interest (in the sense that the
 // 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);
+    if(!isCallstatsLoaded) {
+        ScriptUtil.loadScript(
+                'https://api.callstats.io/static/callstats.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).
 }
     }
 };
 
+/**
+ * Removes the callstats.io instances.
+ */
+Statistics.prototype.stopCallStats = function () {
+    if(this.callstats) {
+        var index = Statistics.callsStatsInstances.indexOf(this.callstats);
+        Statistics.callsStatsInstances.splice(index, 1);
+        this.callstats = null;
+        CallStats.dispose();
+    }
+};
+
 /**
  * Returns true if the callstats integration is enabled, otherwise returns
  * false.

modules/util/EventEmitterForwarder.js

+var EventEmitter = require("events");
+
+/**
+ * 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/version/ComponentsVersions.js

 
 /**
  * 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));
 }
 
         return;
     }
 
-    if (!this.chatRoom.isFocus(mucJid)) {
+    if (!this.conference._isFocus(mucJid)) {
         logger.warn(
             "Received versions not from the focus user: " + node, mucJid);
         return;
 
         var version = item.value;
         if (this.versions[componentName] !== version) {
+            if(this.versions[componentName] &&
+                componentName !== ComponentsVersions.FOCUS_COMPONENT &&
+                componentName !== ComponentsVersions.VIDEOBRIDGE_COMPONENT) {
+                //version is changed during the call
+                this.conference._fireIncompatibleVersionsEvent();
+            }
             this.versions[componentName] = version;
             logger.info("Got " + componentName + " version: " + version);
 
 };
 
 module.exports = ComponentsVersions;
-

modules/xmpp/ChatRoom.js

     return res;
 }
 
-function ChatRoom(connection, jid, password, XMPP, options, settings) {
+function ChatRoom(connection, jid, password, XMPP, options, settings,
+    maxRetries) {
     this.eventEmitter = new EventEmitter();
     this.xmpp = XMPP;
     this.connection = connection;
     this.presMap = {};
     this.presHandlers = {};
     this.joined = false;
-    this.role = 'none';
+    this.role = null;
     this.focusMucJid = null;
     this.bridgeIsDown = false;
     this.options = options || {};
     this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
-        settings, {connection: this.xmpp.options, conference: this.options});
+        settings, {connection: this.xmpp.options, conference: this.options},
+        maxRetries);
     this.initPresenceMap();
     this.session = null;
     var self = this;
     member.jid = jid;
     member.isFocus
         = jid && jid.indexOf(this.moderator.getFocusUserJid() + "/") === 0;
-
     member.isHiddenDomain
         = jid && jid.indexOf("@") > 0
             && this.options.hiddenDomain
     }
 
     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) {
         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;
     }
 };
 
+/**
+ * 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_".
     delete this.presHandlers[name];
 };
 
+/**
+ * Exports the current state of the ChatRoom instance.
+ * @returns {object}
+ */
+ChatRoom.prototype.exportState = function () {
+    return {
+        presHandlers: this.presHandlers,
+        presMapNodes: this.presMap.nodes
+    }
+}
+
+/**
+ * Loads previously exported state object from ChatRoom instance into current
+ * ChatRoom instance.
+ * @param state {object} the state received by ChatRoom.exportState method.
+ */
+ChatRoom.prototype.loadState = function (state) {
+    if(!state || !state.presHandlers || !state.presMapNodes)
+        throw new Error("Invalid state object passed");
+
+    this.presHandlers = state.presHandlers;
+    this.presMap.nodes = state.presMapNodes;
+}
+
 /**
  * Checks if the user identified by given <tt>mucJid</tt> is the conference
  * focus.

modules/xmpp/JingleSessionPC.js

             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) {

modules/xmpp/moderator.js

     };
 }
 
-function Moderator(roomName, xmpp, emitter, settings, options) {
+function Moderator(roomName, xmpp, emitter, settings, options, maxRetries) {
     this.roomName = roomName;
     this.xmppService = xmpp;
     this.getNextTimeout = createExpBackoffTimer(1000);
     this.externalAuthEnabled = false;
     this.settings = settings;
     this.options = options;
+    this.maxRetries = maxRetries || Infinity;
+    this.retries = 0;
 
     // Sip gateway can be enabled by configuring Jigasi host in config.js or
     // it will be enabled automatically if focus detects the component through
                 });
         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/strophe.emuc.js

             this.connection.addHandler(this.onMute.bind(this),
                 'http://jitsi.org/jitmeet/audio', 'iq', 'set',null,null);
         },
-        createRoom: function (jid, password, options, settings) {
+        createRoom: function (jid, password, options, settings, maxRetries) {
             var roomJid = Strophe.getBareJidFromJid(jid);
             if (this.rooms[roomJid]) {
                 var errmsg = "You are already in the room!";
                 return;
             }
             this.rooms[roomJid] = new ChatRoom(this.connection, jid,
-                password, XMPP, options, settings);
+                password, XMPP, options, settings, maxRetries);
             return this.rooms[roomJid];
         },
         doLeave: function (jid) {

modules/xmpp/xmpp.js

     this.connectionTimes = {};
     this.forceMuted = false;
     this.options = options;
+    this.connectParams = {};
+    this.token = token;
     initStrophePlugins(this);
 
     this.connection = createConnection(options.bosh, token);
     $(window).on('beforeunload unload', this.disconnect.bind(this));
 }
 
+/**
+ * Reloads the XMPP module
+ */
+XMPP.prototype.reload = function () {
+    this.disconnect();
+    this.connection.pause();
+    this.connection = createConnection(this.options.bosh, this.token);
+
+    // Initialize features advertised in disco-info
+    this.initFeaturesList();
+
+    //getData for attach
+    if(this.options.prebindURL &&
+        typeof(createConnectionExternally) === "function") {
+        var self = this;
+        createConnectionExternally(this.options.prebindURL, function (data) {
+            self.attach(data);
+        }, function (error) {
+            //connect
+            self.connect(this.connectParams.jid, this.connectParams.password);
+        });
+    } else {
+        //connect
+        this.connect(this.connectParams.jid, this.connectParams.password);
+    }
+
+}
+
 /**
  * Initializes the list of feature advertised through the disco-info mechanism
  */
 }
 
 XMPP.prototype.connect = function (jid, password) {
+    this.connectParams = {
+        jid: jid,
+        password: password
+    };
     if (!jid) {
         var configDomain
             = this.options.hosts.anonymousdomain || this.options.hosts.domain;
     return this._connect(jid, password);
 };
 
-XMPP.prototype.createRoom = function (roomName, options, settings) {
+XMPP.prototype.createRoom = function (roomName, options, settings, maxRetries) {
     var roomjid = roomName  + '@' + this.options.hosts.muc;
 
     if (options.useNicks) {
         roomjid += '/' + tmpJid;
     }
 
-    return this.connection.emuc.createRoom(roomjid, null, options, settings);
+    return this.connection.emuc.createRoom(roomjid, null, options, settings,
+        maxRetries);
 }
 
 XMPP.prototype.addListener = function(type, listener) {

service/xmpp/XMPPEvents.js

     // audio.
     AUDIO_MUTED_BY_FOCUS: "xmpp.audio_muted_by_focus",
     AUTHENTICATION_REQUIRED: "xmpp.authentication_required",
+    /**
+     * Max retries value of Moderator.allocateConferenceFocus failures is
+     * reached.
+     */
+    ALLOCATE_FOCUS_MAX_RETRIES_ERROR: "xmpp.allocate_focus_max_retries_error",
     BRIDGE_DOWN: "xmpp.bridge_down",
     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.