Implements JitsiConnection.reload. Minor fixes related to JitsiConference.reload.

JitsiConference.js

     this.eventEmitter = new EventEmitter();
     this.settings = new Settings();
     this._init(options);
+    this.componentsVersions = new ComponentsVersions(this);
     this.rtc = new RTC(this, options);
     this.statistics = new Statistics(this.xmpp, {
         callStatsID: this.options.config.callStatsID,
 
     this.room = this.xmpp.createRoom(this.options.name, this.options.config,
         this.settings);
-    this.componentsVersions = new ComponentsVersions(this.room);
+
+    //restore previous presence options
+    if(options.roomState) {
+        this.room.loadState(options.roomState);
+    }
     this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
 }
 
  * @param options {object} options to be overriden
  */
 JitsiConference.prototype.reload = function (options) {
-    this.statistics.stopCallStats();
-    this.rtc.closeAllDataChannels();
-    this._leaveRoomAndRemoveParticipants();
+    var roomState = this.room.exportState();
+    if(!options)
+        options = {};
+    options.roomState = roomState;
+    this.leave(true);
+    this.reinitialize(options);
+}
+
+/**
+ * Reinitializes JitsiConference instance
+ * @param options {object} options to be overriden
+ */
+JitsiConference.prototype.reinitialize = function (options) {
     this._init(options || {});
     this.eventManager.setupChatRoomListeners();
-    //if we have new xmpp instance we should set it's listeners again.
-    if(options.connection)
-        this.eventManager.setupXMPPListeners();
+    this.eventManager.setupStatisticsListeners();
     this.join();
 }
 
  * 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));
 }
 /**
  * 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.eventManager.setupStatisticsListeners();
 }
 
+/**
+ * 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.
+ */
+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.
      */

JitsiConnection.js

 var JitsiConference = require("./JitsiConference");
 var XMPP = require("./modules/xmpp/xmpp");
+var JitsiConnectionEvents = require("./JitsiConnectionEvents");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
     this.xmpp.attach(options);
 }
 
+/**
+ * Reloads the JitsiConnection instance and all related conferences
+ * @param options {object} options to be overriden
+ */
+JitsiConnection.prototype.reload = function (options) {
+    var states = {};
+    for(var name in this.conferences) {
+        states[name] = this.conferences[name].room.exportState();
+        this.conferences[name].leave(true);
+    }
+    this.connectionEstablishedHandler =
+        this.reloadConferneces.bind(this, states);
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+        this.connectionEstablishedHandler);
+    this.xmpp.reload(options || {});
+}
+
+/**
+ * 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].reinitialize({connection: this,
+            roomState: states[name]});
+    }
+}
+
 /**
  * Disconnect the client from the server.
  */

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

     this.presMap = {};
     this.presHandlers = {};
     this.joined = false;
-    this.role = 'none';
+    this.role = null;
     this.focusMucJid = null;
     this.bridgeIsDown = false;
     this.options = options || {};
     }
 
     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) {
     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/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
+ * @param options {object} options to be overriden
+ */
+XMPP.prototype.reload = function (options) {
+    if(!options)
+        options = {};
+    if(!this.options) {
+        this.options = options;
+    } else {
+        // Override config options
+        for(var key in options)
+            this.options[key] = options[key] || this.options[key];
+    }
+
+    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;