Fixes issues after review PR #166

JitsiConference.js

     this.eventEmitter = new EventEmitter();
     this.settings = new Settings();
     this.retries = 0;
+    this.options = options;
+    this.eventManager = new JitsiConferenceEventManager(this);
     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,
-        callStatsSecret: this.options.config.callStatsSecret,
-        disableThirdPartyRequests:
-            this.options.config.disableThirdPartyRequests,
-        roomName: this.options.name
-    });
-    this.eventManager = new JitsiConferenceEventManager(this);
-    this._setupListeners();
     this.participants = {};
     this.lastDominantSpeaker = null;
     this.dtmfManager = null;
 
 /**
  * Initializes the conference object properties
- * @param options overrides this.options
+ * @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 = {};
-    if(!this.options) {
-        this.options = options;
-    } else {
-        // Override config options
-        var config = options.config || {};
-        for(var key in config)
-            this.options.config[key] = config[key] || this.options.config[key];
-    }
 
     // Override connection and xmpp properties (Usefull if the connection
     // reloaded)
-    this.connection = options.connection || this.connection;
-    this.xmpp = this.connection.xmpp;
+    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();
 }
 
 /**
         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();
-    this.eventManager.setupStatisticsListeners();
+    this._init(options);
     this.join();
 }
 
     Statistics.sendLog(message);
 };
 
-/**
- * Setups the listeners needed for the conference.
- */
-JitsiConference.prototype._setupListeners = function () {
-    this.eventManager.setupXMPPListeners();
-    this.eventManager.setupChatRoomListeners();
-    this.eventManager.setupRTCListeners();
-    this.eventManager.setupStatisticsListeners();
-};
-
 /**
  * Checks if the user identified by given <tt>mucJid</tt> is the conference
  * focus.

JitsiConferenceEventManager.js

  */
 function JitsiConferenceEventManager(conference) {
     this.conference = conference;
-    this.chatRoomForwarder = new EventEmitterForwarder(this.conference.room,
-        this.conference.eventEmitter);
+
+    //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());
+        });
 }
 
 /**
  */
 JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
     var conference = this.conference;
+    var chatRoom = conference.room;
+    this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
+        this.conference.eventEmitter);
 
-    conference.room.addListener(XMPPEvents.ICE_RESTARTING, function () {
+    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();
     });
 
-    conference.room.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
+    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
         function (data) {
             var track = conference.rtc.createRemoteTrack(data);
             if (track) {
             }
         }
     );
-    conference.room.addListener(XMPPEvents.REMOTE_TRACK_REMOVED,
+    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_REMOVED,
         function (streamId, trackId) {
             conference.getParticipants().forEach(function(participant) {
                 var tracks = participant.getTracks();
         }
     );
 
-    conference.room.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
+    chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
         function (value) {
             // set isMutedByFocus when setAudioMute Promise ends
             conference.rtc.setAudioMute(value).then(
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.GRACEFUL_SHUTDOWN);
 
-    conference.room.addListener(XMPPEvents.JINGLE_FATAL_ERROR,
+    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);
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.FOCUS_DISCONNECTED);
 
-    conference.room.addListener(XMPPEvents.FOCUS_LEFT,
+    chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
         function () {
             if(!conference.connection._reload())
                 conference.eventEmitter.emit(
                     JitsiConferenceErrors.FOCUS_LEFT);
         });
 
-    conference.room.addListener(XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR,
+    chatRoom.addListener(XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR,
         function () {
             conference.connection._reload();
         });
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.SETUP_FAILED);
 
-    conference.room.setParticipantPropertyListener(function (node, from) {
+    chatRoom.setParticipantPropertyListener(function (node, from) {
         var participant = conference.getParticipantById(from);
         if (!participant) {
             return;
     this.chatRoomForwarder.forward(XMPPEvents.KICKED,
         JitsiConferenceEvents.KICKED);
 
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_JOINED,
+    chatRoom.addListener(XMPPEvents.MUC_MEMBER_JOINED,
         conference.onMemberJoined.bind(conference));
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_LEFT,
+    chatRoom.addListener(XMPPEvents.MUC_MEMBER_LEFT,
         conference.onMemberLeft.bind(conference));
 
-    conference.room.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
+    chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
         conference.onDisplayNameChanged.bind(conference));
 
-    conference.room.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
+    chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
         conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED,
             conference.myUserId(), role);
 
         }
     });
 
-    conference.room.addListener(XMPPEvents.MUC_ROLE_CHANGED,
+    chatRoom.addListener(XMPPEvents.MUC_ROLE_CHANGED,
         conference.onUserRoleChanged.bind(conference));
 
-    conference.room.addListener(AuthenticationEvents.IDENTITY_UPDATED,
+    chatRoom.addListener(AuthenticationEvents.IDENTITY_UPDATED,
         function (authEnabled, authIdentity) {
             conference.authEnabled = authEnabled;
             conference.authIdentity = authIdentity;
                 authIdentity);
         });
 
-    conference.room.addListener(XMPPEvents.MESSAGE_RECEIVED,
+    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);
         });
 
-    conference.room.addListener(XMPPEvents.PRESENCE_STATUS,
+    chatRoom.addListener(XMPPEvents.PRESENCE_STATUS,
         function (jid, status) {
             var id = Strophe.getResourceFromJid(jid);
             var participant = conference.getParticipantById(id);
                 JitsiConferenceEvents.USER_STATUS_CHANGED, id, status);
         });
 
-    conference.room.addPresenceListener("startmuted", function (data, from) {
+    chatRoom.addPresenceListener("startmuted", function (data, from) {
         var isModerator = false;
         if (conference.myUserId() === from && conference.isModerator()) {
             isModerator = true;
         }
     });
 
-    conference.room.addPresenceListener("videomuted", function (values, from) {
+    chatRoom.addPresenceListener("videomuted", function (values, from) {
         conference.rtc.handleRemoteTrackMute(MediaType.VIDEO,
             values.value == "true", from);
     });
 
-    conference.room.addPresenceListener("audiomuted", function (values, from) {
+    chatRoom.addPresenceListener("audiomuted", function (values, from) {
         conference.rtc.handleRemoteTrackMute(MediaType.AUDIO,
             values.value == "true", from);
     });
 
-    conference.room.addPresenceListener("videoType", function(data, from) {
+    chatRoom.addPresenceListener("videoType", function(data, from) {
         conference.rtc.handleRemoteTrackVideoTypeChanged(data.value, from);
     });
 
-    conference.room.addPresenceListener("devices", function (data, from) {
+    chatRoom.addPresenceListener("devices", function (data, from) {
         var isAudioAvailable = false;
         var isVideoAvailable = false;
         data.children.forEach(function (config) {
     });
 
     if(conference.statistics) {
-        conference.room.addListener(XMPPEvents.DISPOSE_CONFERENCE,
+        chatRoom.addListener(XMPPEvents.DISPOSE_CONFERENCE,
             function () {
                 conference.statistics.dispose();
             });
 
-        conference.room.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
+        chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
             function (pc) {
                 conference.statistics.sendIceConnectionFailedEvent(pc);
-                conference.room.eventEmitter.emit(
-                    XMPPEvents.CONFERENCE_SETUP_FAILED,
-                    new Error("ICE fail"));
             });
 
-        conference.room.addListener(XMPPEvents.CREATE_OFFER_FAILED,
+        chatRoom.addListener(XMPPEvents.CREATE_OFFER_FAILED,
             function (e, pc) {
                 conference.statistics.sendCreateOfferFailed(e, pc);
             });
 
-        conference.room.addListener(XMPPEvents.CREATE_ANSWER_FAILED,
+        chatRoom.addListener(XMPPEvents.CREATE_ANSWER_FAILED,
             function (e, pc) {
                 conference.statistics.sendCreateAnswerFailed(e, pc);
             });
 
-        conference.room.addListener(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
+        chatRoom.addListener(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
             function (e, pc) {
                 conference.statistics.sendSetLocalDescFailed(e, pc);
             });
 
-        conference.room.addListener(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
+        chatRoom.addListener(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
             function (e, pc) {
                 conference.statistics.sendSetRemoteDescFailed(e, pc);
             });
 
-        conference.room.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
+        chatRoom.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
             function (e, pc) {
                 conference.statistics.sendAddIceCandidateFailed(e, pc);
             });
             // 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();
+                switch (track.getType()) {
+                    case MediaType.AUDIO:
+                        conference.startAudioMuted && track.mute();
+                        break;
+                    case MediaType.VIDEO:
+                        conference.startVideoMuted && track.mute();
+                        break;
                 }
             });
 
         return;
 
     conference.statistics.addAudioLevelListener(function (ssrc, level) {
-        var userId = null;
-
         var resource = conference.rtc.getResourceBySSRC(ssrc);
         if (!resource)
             return;
         conference.eventEmitter.emit(
             JitsiConferenceEvents.CONNECTION_STATS, stats);
     });
-
-    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);
-        });
 };
 
 module.exports = JitsiConferenceEventManager;

JitsiConnection.js

 
 /**
  * Reloads the JitsiConnection instance and all related conferences
- * @param options {object} options to be overriden
  */
-JitsiConnection.prototype._reload = function (options) {
+JitsiConnection.prototype._reload = function () {
     if(this.retryOnFail === 0)
         return false;
     this.retryOnFail--;
         this._reloadConferences.bind(this, states);
     this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
         this.connectionEstablishedHandler);
-    this.xmpp.reload(options || {});
+    this.xmpp.reload();
     return true;
 }
 
     this.connectionEstablishedHandler = null;
     states = states || {};
     for(var name in this.conferences) {
-        this.conferences[name]._reinitialize({connection: this,
-            roomState: states[name]});
+        this.conferences[name]._init({roomState: states[name]});
+        this.conferences[name].join();
     }
 }
 

modules/statistics/statistics.js

 // downloading their API as soon as possible and (2) do the downloading
 // asynchronously.
 function loadCallStatsAPI() {
-    if(!isCallstatsLoaded)
+    if(!isCallstatsLoaded) {
         ScriptUtil.loadScript(
                 'https://api.callstats.io/static/callstats.min.js',
                 /* async */ true,
                 /* prepend */ true);
-    isCallstatsLoaded = 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.callStatsIntegrationEnabled && this.callstats) {
-        var callstatsList = Statistics.callsStatsInstances;
-        for(var i = 0;i < callstatsList.length; i++) {
-            if(this.callstats === callstatsList[i]) {
-                Statistics.callsStatsInstances.splice(i, 1);
-                break;
-            }
-        }
+    if(this.callstats) {
+        var index = Statistics.callsStatsInstances.indexOf(this.callstats);
+        Statistics.callsStatsInstances.splice(index, 1);
         this.callstats = null;
         CallStats.dispose();
     }

modules/xmpp/JingleSessionPC.js

             error.source = request.tree();
         }
 
-        // 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
+        // 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);

modules/xmpp/xmpp.js

 
 /**
  * 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];
-    }
-
+XMPP.prototype.reload = function () {
     this.disconnect();
     this.connection.pause();
     this.connection = createConnection(this.options.bosh, this.token);