Resolve xmpp dependacies in RTC module

JitsiConference.js

 var Settings = require("./modules/settings/Settings");
 var ComponentsVersions = require("./modules/version/ComponentsVersions");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
+var MediaType = require("./service/RTC/MediaType");
 
 /**
  * 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._init(options);
+    this.rtc = new RTC(this, options);
     this.statistics = new Statistics(this.xmpp, {
         callStatsID: this.options.config.callStatsID,
         callStatsSecret: this.options.config.callStatsSecret,
     this.isMutedByFocus = false;
 }
 
+/**
+ * Initializes the conference object properties
+ * @param options overrides this.options
+ */
+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;
+
+    this.room = this.xmpp.createRoom(this.options.name, this.options.config,
+        this.settings);
+    this.componentsVersions = new ComponentsVersions(this.room);
+    this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
+
+}
+
+/**
+ * Reloads the conference
+ * @param options {object} options to be overriden
+ */
+JitsiConference.prototype.reload = function (options) {
+    this.leave().then(function(){
+        this._init(options || {});
+        this.join();
+    }.bind(this));
+}
+
 /**
  * Joins the conference.
  * @param password {string} the password
                 });
             }
             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
     return new Promise(function (resolve, reject) {
         this.room.removeStream(track.getOriginalStream(), function(){
             track._setSSRC(null);
-            //FIXME: This dependacy is not necessary. This is quick fix.
-            track._setConference(this);
+            track._setConference(null);
             this.rtc.removeLocalTrack(track);
             track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
                 track.muteHandler);
     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);
+}
+
 /**
  * Setups the listeners needed for the conference.
  * @param conference the conference
  */
 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);
-        }
-    });
+        XMPPEvents.CALL_INCOMING, conference.onIncomingCall.bind(conference));
 
     conference.room.addListener(XMPPEvents.ICE_RESTARTING, function () {
         // All data channels have to be closed, before ICE restart
     conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED, function (devices) {
         conference.room.updateDeviceAvailability(devices);
     });
+
+    conference.room.addPresenceListener("videomuted", function (values, from) {
+        conference.rtc.handleRemoteTrackMute(MediaType.VIDEO,
+            values.value == "true", from);
+    });
+
+    conference.room.addPresenceListener("audiomuted", function (values, from) {
+        conference.rtc.handleRemoteTrackMute(MediaType.AUDIO,
+            values.value == "true", from);
+    });
+
+    conference.room.addPresenceListener("videoType", function(data, from) {
+        conference.rtc.handleRemoteTrackVideoTypeChanged(data.value, from);
+    });
+
     conference.room.addPresenceListener("devices", function (data, from) {
         var isAudioAvailable = false;
         var isVideoAvailable = false;
                     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())

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.selectedEndpoint = 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
 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 self = this;
     return resultResource;
 };
 
+/**
+ * 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;