Merge branch 'master' into ice_restart

# Conflicts:
#	modules/xmpp/JingleSessionPC.js

JitsiConference.js

@@ -673,7 +673,7 @@ JitsiConference.prototype.isRecordingSupported = function () {
 JitsiConference.prototype.getRecordingState = function () {
     if(this.room)
         return this.room.getRecordingState();
-    return "off";
+    return Recording.status.OFF;
 }
 
 /**
@@ -692,10 +692,10 @@ JitsiConference.prototype.toggleRecording = function (options) {
     if(this.room)
         return this.room.toggleRecording(options, function (status, error) {
             this.eventEmitter.emit(
-                JitsiConferenceEvents.RECORDING_STATE_CHANGED, status, error);
+                JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
         }.bind(this));
     this.eventEmitter.emit(
-        JitsiConferenceEvents.RECORDING_STATE_CHANGED, "error",
+        JitsiConferenceEvents.RECORDER_STATE_CHANGED, "error",
         new Error("The conference is not created yet!"));
 }
 
@@ -822,6 +822,13 @@ JitsiConference.prototype.getLogs = function () {
     return data;
 };
 
+/**
+ * Returns measured performanceTimes.
+ */
+JitsiConference.prototype.getPerformanceTimes = function () {
+    return this.room.performanceTimes;
+};
+
 /**
  * Sends the given feedback through CallStats if enabled.
  *
@@ -851,11 +858,12 @@ JitsiConference.prototype.isCallstatsEnabled = function () {
  */
 function setupListeners(conference) {
     conference.xmpp.addListener(
-        XMPPEvents.CALL_INCOMING, function (jingleSession, jingleOffer) {
+        XMPPEvents.CALL_INCOMING, function (jingleSession, jingleOffer, now) {
 
         if (conference.room.isFocus(jingleSession.peerjid)) {
             // Accept incoming call
             conference.room.setJingleSession(jingleSession);
+            conference.room.performanceTimes["session.initiate"] = now;
             jingleSession.initialize(false /* initiator */, conference.room);
             conference.rtc.onIncommingCall(jingleSession);
             jingleSession.acceptOffer(jingleOffer, null,
@@ -994,10 +1002,10 @@ function setupListeners(conference) {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_INTERRUPTED);
     });
 
-    conference.room.addListener(XMPPEvents.RECORDING_STATE_CHANGED,
-        function () {
+    conference.room.addListener(XMPPEvents.RECORDER_STATE_CHANGED,
+        function (state) {
             conference.eventEmitter.emit(
-                JitsiConferenceEvents.RECORDING_STATE_CHANGED);
+                JitsiConferenceEvents.RECORDER_STATE_CHANGED, state);
         });
 
     conference.room.addListener(XMPPEvents.PHONE_NUMBER_CHANGED, function () {

JitsiConferenceEvents.js

@@ -111,7 +111,7 @@ var JitsiConferenceEvents = {
     /**
      * Indicates that recording state changed.
      */
-    RECORDING_STATE_CHANGED: "conference.recordingStateChanged",
+    RECORDER_STATE_CHANGED: "conference.recorderStateChanged",
     /**
      * Indicates that phone number changed.
      */

JitsiConnection.js

@@ -13,13 +13,14 @@ function JitsiConnection(appID, token, options) {
     this.appID = appID;
     this.token = token;
     this.options = options;
-    this.xmpp = new XMPP(options);
+    this.xmpp = new XMPP(options, token);
     this.conferences = {};
 }
 
 /**
  * Connect the client with the server.
- * @param options {object} connecting options (for example authentications parameters).
+ * @param options {object} connecting options
+ * (for example authentications parameters).
  */
 JitsiConnection.prototype.connect = function (options) {
     if(!options)
@@ -28,6 +29,17 @@ JitsiConnection.prototype.connect = function (options) {
     this.xmpp.connect(options.id, options.password);
 }
 
+/**
+ * Attach to existing connection. Can be used for optimizations. For example:
+ * if the connection is created on the server we can attach to it and start
+ * using it.
+ *
+ * @param options {object} connecting options - rid, sid and jid.
+ */
+JitsiConnection.prototype.attach = function (options) {
+    this.xmpp.attach(options);
+}
+
 /**
  * Disconnect the client from the server.
  */
@@ -81,4 +93,11 @@ JitsiConnection.prototype.removeEventListener = function (event, listener) {
     this.xmpp.removeListener(event, listener);
 }
 
+/**
+ * Returns measured performanceTimes.
+ */
+JitsiConnection.prototype.getPerformanceTimes = function () {
+    return this.xmpp.performanceTimes;
+};
+
 module.exports = JitsiConnection;

JitsiRecorderErrors.js

@@ -0,0 +1,23 @@
+/**
+ * Enumeration with the errors for the conference.
+ * @type {{string: string}}
+ */
+var JitsiRecorderErrors = {
+    /**
+     * Indicates that the recorder is currently unavailable.
+     */
+    RECORDER_UNAVAILABLE: "recorder.unavailable",
+
+    /**
+     * Indicates that the authentication token is missing.
+     */
+    NO_TOKEN: "recorder.noToken",
+
+    /**
+     * Indicates that a state change failed.
+     */
+    STATE_CHANGE_FAILED: "recorder.stateChangeFailed",
+
+};
+
+module.exports = JitsiRecorderErrors;

README.md

@@ -21,5 +21,11 @@ To build the Lib Jitsi Meet, just type
 npm install
 ```
 
+For development, use watch to recompile your browserify bundle on file changes:
+
+```
+npm run watch
+```
+
 ## Discuss
 Please use the [Jitsi dev mailing list](http://lists.jitsi.org/pipermail/dev/) to discuss feature requests before opening an issue on Github. 

connection_optimization/external_connect.js

@@ -0,0 +1,61 @@
+/**
+ * Requests the given webservice that will create the connection and will return
+ * the necessary details(rid, sid and jid) to attach to this connection and
+ * start using it. This script can be used for optimizing the connection startup
+ * time. The function will send AJAX request to a webservice that should
+ * create the bosh session much faster than the client because the webservice
+ * can be started on the same machine as the XMPP serever.
+ *
+ * NOTE: It's vert important to execute this function as early as you can for
+ * optimal results.
+ *
+ * @param webserviceUrl the url for the web service that is going to create the
+ * connection.
+ * @param success_callback callback function called with the result of the AJAX
+ * request if the request was successfull. The callback will receive one
+ * parameter which will be JS Object with properties - rid, sid and jid. This
+ * result should be passed to JitsiConnection.attach method in order to use that
+ * connection.
+ * @param error_callback callback function called the AJAX request fail. This
+ * callback is going to receive one parameter which is going to be JS error
+ * object with a reason for failure in it.
+ */
+function createConnectionExternally(webserviceUrl, success_callback,
+    error_callback) {
+    if (!window.XMLHttpRequest) {
+        error_callback(new Error("XMLHttpRequest is not supported!"));
+        return;
+    }
+
+    var HTTP_STATUS_OK = 200;
+
+    var xhttp = new XMLHttpRequest();
+
+    xhttp.onreadystatechange = function() {
+        if (xhttp.readyState == xhttp.DONE) {
+            var now = window.performanceTimes["external_connect.done"] =
+                window.performance.now();
+            console.log("(TIME) external connect XHR done:\t", now);
+            if (xhttp.status == HTTP_STATUS_OK) {
+                try {
+                    var data = JSON.parse(xhttp.responseText);
+                    success_callback(data);
+                } catch (e) {
+                    error_callback(e);
+                }
+            } else {
+                error_callback(new Error("XMLHttpRequest error. Status: " +
+                    xhttp.status + ". Error message: " + xhttp.statusText));
+            }
+        }
+    };
+
+    xhttp.timeout = 3000;
+
+    xhttp.open("GET", webserviceUrl, true);
+    window.performanceTimes = {};
+    var now = window.performanceTimes["external_connect.sending"] =
+        window.performance.now();
+    console.log("(TIME) Sending external connect XHR:\t", now);
+    xhttp.send();
+}

doc/example/example.js

@@ -121,7 +121,7 @@ function onConnectionSuccess(){
       function(userID, audioLevel){
           console.log(userID + " - " + audioLevel);
       });
-    room.on(JitsiMeetJS.events.conference.RECORDING_STATE_CHANGED, function () {
+    room.on(JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED, function () {
         console.log(room.isRecordingSupported() + " - " +
             room.getRecordingState() + " - " +
             room.getRecordingURL());

doc/tokens.md

@@ -61,7 +61,7 @@ just install 'jitsi-meet-tokens' on top of it. In order to have it configured au
 jitsi-meet is required which comes with special Prosody config template.
 
 ```
-apt-get install jitsi-meet-token
+apt-get install jitsi-meet-tokens
 ```
 
 Proceed to "Patching Prosody" section to finish configuration.

modules/xmpp/ChatRoom.js

@@ -83,6 +83,7 @@ function ChatRoom(connection, jid, password, XMPP, options, settings) {
     this.lastPresences = {};
     this.phoneNumber = null;
     this.phonePin = null;
+    this.performanceTimes = {};
 }
 
 ChatRoom.prototype.initPresenceMap = function () {
@@ -117,19 +118,19 @@ ChatRoom.prototype.join = function (password) {
     if(password)
         this.password = password;
     var self = this;
-    this.moderator.allocateConferenceFocus(function()
-    {
+    this.moderator.allocateConferenceFocus(function () {
         self.sendPresence(true);
-    }.bind(this));
+    });
 };
 
 ChatRoom.prototype.sendPresence = function (fromJoin) {
-    if (!this.presMap['to'] || (!this.joined && !fromJoin)) {
+    var to = this.presMap['to'];
+    if (!to || (!this.joined && !fromJoin)) {
         // Too early to send presence - not initialized
         return;
     }
 
-    var pres = $pres({to: this.presMap['to'] });
+    var pres = $pres({to: to });
     pres.c('x', {xmlns: this.presMap['xns']});
 
     if (this.password) {
@@ -139,13 +140,22 @@ ChatRoom.prototype.sendPresence = function (fromJoin) {
     pres.up();
 
     // Send XEP-0115 'c' stanza that contains our capabilities info
-    if (this.connection.caps) {
-        this.connection.caps.node = this.xmpp.options.clientNode;
-        pres.c('c', this.connection.caps.generateCapsAttrs()).up();
+    var connection = this.connection;
+    var caps = connection.caps;
+    if (caps) {
+        caps.node = this.xmpp.options.clientNode;
+        pres.c('c', caps.generateCapsAttrs()).up();
     }
 
     parser.JSON2packet(this.presMap.nodes, pres);
-    this.connection.send(pres);
+    connection.send(pres);
+    if (fromJoin) {
+        // XXX We're pressed for time here because we're beginning a complex
+        // and/or lengthy conference-establishment process which supposedly
+        // involves multiple RTTs. We don't have the time to wait for Strophe to
+        // decide to send our IQ.
+        connection.flush();
+    }
 };
 
 
@@ -215,17 +225,16 @@ ChatRoom.prototype.onPresence = function (pres) {
     var member = {};
     member.show = $(pres).find('>show').text();
     member.status = $(pres).find('>status').text();
-    var tmp = $(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item');
-    member.affiliation = tmp.attr('affiliation');
-    member.role = tmp.attr('role');
+    var mucUserItem
+        = $(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item');
+    member.affiliation = mucUserItem.attr('affiliation');
+    member.role = mucUserItem.attr('role');
 
     // Focus recognition
-    member.jid = tmp.attr('jid');
-    member.isFocus = false;
-    if (member.jid
-        && member.jid.indexOf(this.moderator.getFocusUserJid() + "/") === 0) {
-        member.isFocus = true;
-    }
+    var jid = mucUserItem.attr('jid');
+    member.jid = jid;
+    member.isFocus
+        = !!jid && jid.indexOf(this.moderator.getFocusUserJid() + "/") === 0;
 
     $(pres).find(">x").remove();
     var nodes = [];
@@ -249,15 +258,15 @@ ChatRoom.prototype.onPresence = function (pres) {
     }
 
     if (from == this.myroomjid) {
-        if (member.affiliation == 'owner'
-            &&  this.role !== member.role) {
-                this.role = member.role;
-                this.eventEmitter.emit(
-                    XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
+        if (member.affiliation == 'owner' && this.role !== member.role) {
+            this.role = member.role;
+            this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
         }
         if (!this.joined) {
             this.joined = true;
-            console.log("(TIME) MUC joined:\t", window.performance.now());
+            var now = this.performanceTimes["muc.joined"] =
+                window.performance.now();
+            console.log("(TIME) MUC joined:\t", now);
             this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
         }
     } else if (this.members[from] === undefined) {
@@ -273,7 +282,7 @@ ChatRoom.prototype.onPresence = function (pres) {
                 if(this.lastJibri)
                     this.recording.handleJibriPresence(this.lastJibri);
             }
-            logger.info("Ignore focus: " + from + ", real JID: " + member.jid);
+            logger.info("Ignore focus: " + from + ", real JID: " + jid);
         }
         else {
             this.eventEmitter.emit(
@@ -282,15 +291,16 @@ ChatRoom.prototype.onPresence = function (pres) {
     } else {
         // Presence update for existing participant
         // Watch role change:
-        if (this.members[from].role != member.role) {
-            this.members[from].role = member.role;
+        var memberOfThis = this.members[from];
+        if (memberOfThis.role != member.role) {
+            memberOfThis.role = member.role;
             this.eventEmitter.emit(
                 XMPPEvents.MUC_ROLE_CHANGED, from, member.role);
         }
 
         // store the new display name
         if(member.displayName)
-            this.members[from].displayName = member.displayName;
+            memberOfThis.displayName = member.displayName;
     }
 
     // after we had fired member or room joined events, lets fire events
@@ -344,13 +354,19 @@ ChatRoom.prototype.onPresence = function (pres) {
         if(this.recording)
             this.recording.handleJibriPresence(jibri);
     }
-
 };
 
 ChatRoom.prototype.processNode = function (node, from) {
-    if(this.presHandlers[node.tagName])
-        this.presHandlers[node.tagName](
+    // make sure we catch all errors coming from any handler
+    // otherwise we can remove the presence handler from strophe
+    try {
+        if(this.presHandlers[node.tagName])
+            this.presHandlers[node.tagName](
                 node, Strophe.getResourceFromJid(from), from);
+    } catch (e) {
+        logger.error('Error processing:' + node.tagName
+            + ' node.', e);
+    }
 };
 
 ChatRoom.prototype.sendMessage = function (body, nickname) {

modules/xmpp/JingleSessionPC.js

@@ -152,8 +152,13 @@ JingleSessionPC.prototype.doInitialize = function () {
      */
     this.peerconnection.oniceconnectionstatechange = function (event) {
         if (!(self && self.peerconnection)) return;
+        self.room.performanceTimes["ice.state"] =
+            self.room.performanceTimes["ice.state"] || [];
+        var now = window.performance.now();
+        self.room.performanceTimes["ice.state"].push(
+            {state: self.peerconnection.iceConnectionState, time: now});
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
-                    ":\t", window.performance.now());
+                    ":\t", now);
         self.updateModifySourcesQueue();
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
@@ -383,7 +388,14 @@ JingleSessionPC.prototype.createAnswer = function (success, failure) {
     //logger.log('createAnswer');
     var self = this;
     this.peerconnection.createAnswer(
-        success,
+        function (answer) {
+            var modifiedAnswer = new SDP(answer.sdp);
+            JingleSessionPC._fixAnswerRFC4145Setup(
+                /* offer */ self.remoteSDP,
+                /* answer */ modifiedAnswer);
+            answer.sdp = modifiedAnswer.raw;
+            success(answer);
+        },
         function (error) {
             logger.error("createAnswer failed", error);
             if (failure)
@@ -425,6 +437,65 @@ JingleSessionPC.prototype.setLocalDescription = function (sdp, success,
     }
 };
 
+/**
+ * Modifies the values of the setup attributes (defined by
+ * {@link http://tools.ietf.org/html/rfc4145#section-4}) of a specific SDP
+ * answer in order to overcome a delay of 1 second in the connection
+ * establishment between Chrome and Videobridge.
+ *
+ * @param {SDP} offer - the SDP offer to which the specified SDP answer is
+ * being prepared to respond
+ * @param {SDP} answer - the SDP to modify
+ * @private
+ */
+JingleSessionPC._fixAnswerRFC4145Setup = function (offer, answer) {
+    if (!RTCBrowserType.isChrome()) {
+        // It looks like Firefox doesn't agree with the fix (at least in its
+        // current implementation) because it effectively remains active even
+        // after we tell it to become passive. Apart from Firefox which I tested
+        // after the fix was deployed, I tested Chrome only. In order to prevent
+        // issues with other browsers, limit the fix to Chrome for the time
+        // being.
+        return;
+    }
+
+    // XXX Videobridge is the (SDP) offerer and WebRTC (e.g. Chrome) is the
+    // answerer (as orchestrated by Jicofo). In accord with
+    // http://tools.ietf.org/html/rfc5245#section-5.2 and because both peers
+    // are ICE FULL agents, Videobridge will take on the controlling role and
+    // WebRTC will take on the controlled role. In accord with
+    // https://tools.ietf.org/html/rfc5763#section-5, Videobridge will use the
+    // setup attribute value of setup:actpass and WebRTC will be allowed to
+    // choose either the setup attribute value of setup:active or
+    // setup:passive. Chrome will by default choose setup:active because it is
+    // RECOMMENDED by the respective RFC since setup:passive adds additional
+    // latency. The case of setup:active allows WebRTC to send a DTLS
+    // ClientHello as soon as an ICE connectivity check of its succeeds.
+    // Unfortunately, Videobridge will be unable to respond immediately because
+    // may not have WebRTC's answer or may have not completed the ICE
+    // connectivity establishment. Even more unfortunate is that in the
+    // described scenario Chrome's DTLS implementation will insist on
+    // retransmitting its ClientHello after a second (the time is in accord
+    // with the respective RFC) and will thus cause the whole connection
+    // establishment to exceed at least 1 second. To work around Chrome's
+    // idiosyncracy, don't allow it to send a ClientHello i.e. change its
+    // default choice of setup:active to setup:passive.
+    if (offer && answer
+            && offer.media && answer.media
+            && offer.media.length == answer.media.length) {
+        answer.media.forEach(function (a, i) {
+            if (SDPUtil.find_line(
+                    offer.media[i],
+                    'a=setup:actpass',
+                    offer.session)) {
+                answer.media[i]
+                    = a.replace(/a=setup:active/g, 'a=setup:passive');
+            }
+        });
+        answer.raw = answer.session + answer.media.join('');
+    }
+};
+
 /**
  * Although it states "replace transport" it does accept full Jingle offer
  * which should contain new ICE transport details.
@@ -482,6 +553,10 @@ JingleSessionPC.prototype.sendSessionAccept = function (localSDP,
         success,
         this.newJingleErrorHandler(accept, failure),
         IQ_TIMEOUT);
+    // XXX Videobridge needs WebRTC's answer (ICE ufrag and pwd, DTLS
+    // fingerprint and setup) ASAP in order to start the connection
+    // establishment.
+    this.connection.flush();
 };
 
 /**

modules/xmpp/SDP.js

@@ -5,29 +5,33 @@ var SDPUtil = require("./SDPUtil");
 
 // SDP STUFF
 function SDP(sdp) {
-    /**
-     * Whether or not to remove TCP ice candidates when translating from/to jingle.
-     * @type {boolean}
-     */
-    this.removeTcpCandidates = false;
-
-    /**
-     * Whether or not to remove UDP ice candidates when translating from/to jingle.
-     * @type {boolean}
-     */
-    this.removeUdpCandidates = false;
-
-    this.media = sdp.split('\r\nm=');
-    for (var i = 1; i < this.media.length; i++) {
-        this.media[i] = 'm=' + this.media[i];
-        if (i != this.media.length - 1) {
-            this.media[i] += '\r\n';
+    var media = sdp.split('\r\nm=');
+    for (var i = 1, length = media.length; i < length; i++) {
+        var media_i = 'm=' + media[i];
+        if (i != length - 1) {
+            media_i += '\r\n';
         }
+        media[i] = media_i;
     }
-    this.session = this.media.shift() + '\r\n';
-    this.raw = this.session + this.media.join('');
+    var session = media.shift() + '\r\n';
+
+    this.media = media;
+    this.raw = session + media.join('');
+    this.session = session;
 }
 
+/**
+ * Whether or not to remove TCP ice candidates when translating from/to jingle.
+ * @type {boolean}
+ */
+SDP.prototype.removeTcpCandidates = false;
+
+/**
+ * Whether or not to remove UDP ice candidates when translating from/to jingle.
+ * @type {boolean}
+ */
+SDP.prototype.removeUdpCandidates = false;
+
 /**
  * Returns map of MediaChannel mapped per channel idx.
  */
@@ -57,7 +61,7 @@ SDP.prototype.getMediaSsrcMap = function() {
             media.ssrcs[linessrc].lines.push(line);
         });
         tmp = SDPUtil.find_lines(self.media[mediaindex], 'a=ssrc-group:');
-        tmp.forEach(function(line){
+        tmp.forEach(function(line) {
             var idx = line.indexOf(' ');
             var semantics = line.substr(0, idx).substr(13);
             var ssrcs = line.substr(14 + semantics.length).split(' ');
@@ -107,13 +111,10 @@ SDP.prototype.mangle = function () {
                 if (rtpmap.name == 'CN' || rtpmap.name == 'ISAC')
                     continue;
                 mline.fmt.push(rtpmap.id);
-                newdesc += lines[j] + '\r\n';
-            } else {
-                newdesc += lines[j] + '\r\n';
             }
+            newdesc += lines[j] + '\r\n';
         }
-        this.media[i] = SDPUtil.build_mline(mline) + '\r\n';
-        this.media[i] += newdesc;
+        this.media[i] = SDPUtil.build_mline(mline) + '\r\n' + newdesc;
     }
     this.raw = this.session + this.media.join('');
 };
@@ -146,8 +147,8 @@ SDP.prototype.toJingle = function (elem, thecreator) {
     var self = this;
     var i, j, k, mline, ssrc, rtpmap, tmp, lines;
     // new bundle plan
-    if (SDPUtil.find_line(this.session, 'a=group:')) {
-        lines = SDPUtil.find_lines(this.session, 'a=group:');
+    lines = SDPUtil.find_lines(this.session, 'a=group:');
+    if (lines.length) {
         for (i = 0; i < lines.length; i++) {
             tmp = lines[i].split(' ');
             var semantics = tmp.shift().substr(8);
@@ -162,20 +163,21 @@ SDP.prototype.toJingle = function (elem, thecreator) {
         mline = SDPUtil.parse_mline(this.media[i].split('\r\n')[0]);
         if (!(mline.media === 'audio' ||
               mline.media === 'video' ||
-              mline.media === 'application'))
-        {
+              mline.media === 'application')) {
             continue;
         }
-        if (SDPUtil.find_line(this.media[i], 'a=ssrc:')) {
-            ssrc = SDPUtil.find_line(this.media[i], 'a=ssrc:').substring(7).split(' ')[0]; // take the first
+        var assrcline = SDPUtil.find_line(this.media[i], 'a=ssrc:');
+        if (assrcline) {
+            ssrc = assrcline.substring(7).split(' ')[0]; // take the first
         } else {
             ssrc = false;
         }
 
         elem.c('content', {creator: thecreator, name: mline.media});
-        if (SDPUtil.find_line(this.media[i], 'a=mid:')) {
+        var amidline = SDPUtil.find_line(this.media[i], 'a=mid:');
+        if (amidline) {
             // prefer identifier from a=mid if present
-            var mid = SDPUtil.parse_mid(SDPUtil.find_line(this.media[i], 'a=mid:'));
+            var mid = SDPUtil.parse_mid(amidline);
             elem.attrs({ name: mid });
         }
 
@@ -190,8 +192,9 @@ SDP.prototype.toJingle = function (elem, thecreator) {
                 rtpmap = SDPUtil.find_line(this.media[i], 'a=rtpmap:' + mline.fmt[j]);
                 elem.c('payload-type', SDPUtil.parse_rtpmap(rtpmap));
                 // put any 'a=fmtp:' + mline.fmt[j] lines into <param name=foo value=bar/>
-                if (SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j])) {
-                    tmp = SDPUtil.parse_fmtp(SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]));
+                var afmtpline = SDPUtil.find_line(this.media[i], 'a=fmtp:' + mline.fmt[j]);
+                if (afmtpline) {
+                    tmp = SDPUtil.parse_fmtp(afmtpline);
                     for (k = 0; k < tmp.length; k++) {
                         elem.c('parameter', tmp[k]).up();
                     }
@@ -200,9 +203,9 @@ SDP.prototype.toJingle = function (elem, thecreator) {
 
                 elem.up();
             }
-            if (SDPUtil.find_line(this.media[i], 'a=crypto:', this.session)) {
+            var crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
+            if (crypto.length) {
                 elem.c('encryption', {required: 1});
-                var crypto = SDPUtil.find_lines(this.media[i], 'a=crypto:', this.session);
                 crypto.forEach(function(line) {
                     elem.c('crypto', SDPUtil.parse_crypto(line)).up();
                 });
@@ -244,16 +247,12 @@ SDP.prototype.toJingle = function (elem, thecreator) {
                     elem.attrs({name: "cname", value:Math.random().toString(36).substring(7)});
                     elem.up();
                     var msid = null;
-                    if(mline.media == "audio")
-                    {
+                    if(mline.media == "audio") {
                         msid = APP.RTC.localAudio._getId();
-                    }
-                    else
-                    {
+                    } else {
                         msid = APP.RTC.localVideo._getId();
                     }
-                    if(msid != null)
-                    {
+                    if(msid != null) {
                         msid = SDPUtil.filter_special_chars(msid);
                         elem.c('parameter');
                         elem.attrs({name: "msid", value:msid});
@@ -293,8 +292,8 @@ SDP.prototype.toJingle = function (elem, thecreator) {
             this.rtcpFbToJingle(i, elem, '*');
 
             // XEP-0294
-            if (SDPUtil.find_line(this.media[i], 'a=extmap:')) {
-                lines = SDPUtil.find_lines(this.media[i], 'a=extmap:');
+            lines = SDPUtil.find_lines(this.media[i], 'a=extmap:');
+            if (lines.length) {
                 for (j = 0; j < lines.length; j++) {
                     tmp = SDPUtil.parse_extmap(lines[j]);
                     elem.c('rtp-hdrext', { xmlns: 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
@@ -351,24 +350,19 @@ SDP.prototype.transportToJingle = function (mediaindex, elem) {
     elem.c('transport');
 
     // XEP-0343 DTLS/SCTP
-    if (SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:').length)
-    {
-        sctpmap = SDPUtil.find_line(
-            this.media[mediaindex], 'a=sctpmap:', self.session);
-        if (sctpmap)
-        {
-            sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
-            elem.c('sctpmap',
-                {
-                    xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
-                    number: sctpAttrs[0], /* SCTP port */
-                    protocol: sctpAttrs[1] /* protocol */
-                });
-            // Optional stream count attribute
-            if (sctpAttrs.length > 2)
-                elem.attrs({ streams: sctpAttrs[2]});
-            elem.up();
-        }
+    sctpmap
+        = SDPUtil.find_line(this.media[mediaindex], 'a=sctpmap:', self.session);
+    if (sctpmap) {
+        sctpAttrs = SDPUtil.parse_sctpmap(sctpmap);
+        elem.c('sctpmap', {
+                xmlns: 'urn:xmpp:jingle:transports:dtls-sctp:1',
+                number: sctpAttrs[0], /* SCTP port */
+                protocol: sctpAttrs[1] /* protocol */
+            });
+        // Optional stream count attribute
+        if (sctpAttrs.length > 2)
+            elem.attrs({ streams: sctpAttrs[2]});
+        elem.up();
     }
     // XEP-0320
     fingerprints = SDPUtil.find_lines(this.media[mediaindex], 'a=fingerprint:', this.session);
@@ -499,11 +493,9 @@ SDP.prototype.jingle2media = function (content) {
         // estos hack to reject an m-line.
         tmp.port = '0';
     }
-    if (content.find('>transport>fingerprint').length || desc.find('encryption').length) {
-        if (sctp.length)
-            tmp.proto = 'DTLS/SCTP';
-        else
-            tmp.proto = 'RTP/SAVPF';
+    if (content.find('>transport>fingerprint').length
+            || desc.find('encryption').length) {
+        tmp.proto = sctp.length ? 'DTLS/SCTP' : 'RTP/SAVPF';
     } else {
         tmp.proto = 'RTP/AVPF';
     }

modules/xmpp/SDPUtil.js

@@ -8,11 +8,12 @@ SDPUtil = {
     },
     iceparams: function (mediadesc, sessiondesc) {
         var data = null;
-        if (SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc) &&
-            SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc)) {
+        var ufrag, pwd;
+        if ((ufrag = SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc))
+                && (pwd = SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))) {
             data = {
-                ufrag: SDPUtil.parse_iceufrag(SDPUtil.find_line(mediadesc, 'a=ice-ufrag:', sessiondesc)),
-                pwd: SDPUtil.parse_icepwd(SDPUtil.find_line(mediadesc, 'a=ice-pwd:', sessiondesc))
+                ufrag: SDPUtil.parse_iceufrag(ufrag),
+                pwd: SDPUtil.parse_icepwd(pwd)
             };
         }
         return data;

modules/xmpp/moderator.js

@@ -246,103 +246,138 @@ Moderator.prototype.parseConfigOptions =  function (resultIq) {
     logger.info("Sip gateway enabled:  " + this.sipGatewayEnabled);
 };
 
-// FIXME =  we need to show the fact that we're waiting for the focus
-// to the user(or that focus is not available)
+// FIXME We need to show the fact that we're waiting for the focus to the user
+// (or that the focus is not available)
+/**
+ * Allocates the conference focus.
+ *
+ * @param {Function} callback - the function to be called back upon the
+ * successful allocation of the conference focus
+ */
 Moderator.prototype.allocateConferenceFocus =  function (callback) {
     // Try to use focus user JID from the config
     this.setFocusUserJid(this.xmppService.options.focusUserJid);
     // Send create conference IQ
-    var iq = this.createConferenceIq();
     var self = this;
     this.connection.sendIQ(
-        iq,
+        this.createConferenceIq(),
         function (result) {
-
-            // Setup config options
-            self.parseConfigOptions(result);
-
-            if ('true' === $(result).find('conference').attr('ready')) {
-                // Reset both timers
-                self.getNextTimeout(true);
-                self.getNextErrorTimeout(true);
-                // Exec callback
-                callback();
-            } else {
-                var waitMs = self.getNextTimeout();
-                logger.info("Waiting for the focus... " + waitMs);
-                // Reset error timeout
-                self.getNextErrorTimeout(true);
-                window.setTimeout(
-                    function () {
-                        self.allocateConferenceFocus(callback);
-                    }, waitMs);
-            }
+            self._allocateConferenceFocusSuccess(result, callback);
         },
         function (error) {
-            // Invalid session ? remove and try again
-            // without session ID to get a new one
-            var invalidSession
-                = $(error).find('>error>session-invalid').length;
-            if (invalidSession) {
-                logger.info("Session expired! - removing");
-                self.settings.clearSessionId();
-            }
-            if ($(error).find('>error>graceful-shutdown').length) {
-                self.eventEmitter.emit(XMPPEvents.GRACEFUL_SHUTDOWN);
-                return;
-            }
-            // Check for error returned by the reservation system
-            var reservationErr = $(error).find('>error>reservation-error');
-            if (reservationErr.length) {
-                // Trigger error event
-                var errorCode = reservationErr.attr('error-code');
-                var errorMsg;
-                if ($(error).find('>error>text')) {
-                    errorMsg = $(error).find('>error>text').text();
-                }
-                self.eventEmitter.emit(
-                    XMPPEvents.RESERVATION_ERROR, errorCode, errorMsg);
-                return;
-            }
-            // Not authorized to create new room
-            if ($(error).find('>error>not-authorized').length) {
-                logger.warn("Unauthorized to start the conference", error);
-                var toDomain
-                    = Strophe.getDomainFromJid(error.getAttribute('to'));
-                if (toDomain !==
-                    self.xmppService.options.hosts.anonymousdomain) {
-                    //FIXME:  "is external" should come either from
-                    // the focus or config.js
-                    self.externalAuthEnabled = true;
-                }
-                self.eventEmitter.emit(
-                    XMPPEvents.AUTHENTICATION_REQUIRED,
-                    function () {
-                        self.allocateConferenceFocus(
-                            callback);
-                    });
-                return;
-            }
-            var waitMs = self.getNextErrorTimeout();
-            logger.error("Focus error, retry after " + waitMs, error);
-            // Show message
-            var focusComponent = self.getFocusComponent();
-            var retrySec = waitMs / 1000;
-            //FIXME:  message is duplicated ?
-            // Do not show in case of session invalid
-            // which means just a retry
-            if (!invalidSession) {
-                self.eventEmitter.emit(XMPPEvents.FOCUS_DISCONNECTED,
-                    focusComponent, retrySec);
-            }
-            // Reset response timeout
-            self.getNextTimeout(true);
-            window.setTimeout(
+            self._allocateConferenceFocusError(error);
+        });
+    // XXX We're pressed for time here because we're beginning a complex and/or
+    // lengthy conference-establishment process which supposedly involves
+    // multiple RTTs. We don't have the time to wait for Strophe to decide to
+    // send our IQ.
+    this.connection.flush();
+};
+
+/**
+ * Invoked by {@link #allocateConferenceFocus} upon its request receiving an
+ * error result.
+ *
+ * @param error - the error result of the request that
+ * {@link #allocateConferenceFocus} sent
+ * @param {Function} callback - the function to be called back upon the
+ * successful allocation of the conference focus
+ */
+Moderator.prototype._allocateConferenceFocusError = function (error, callback) {
+    var self = this;
+
+    // If the session is invalid, remove and try again without session ID to get
+    // a new one
+    var invalidSession = $(error).find('>error>session-invalid').length;
+    if (invalidSession) {
+        logger.info("Session expired! - removing");
+        self.settings.clearSessionId();
+    }
+    if ($(error).find('>error>graceful-shutdown').length) {
+        self.eventEmitter.emit(XMPPEvents.GRACEFUL_SHUTDOWN);
+        return;
+    }
+    // Check for error returned by the reservation system
+    var reservationErr = $(error).find('>error>reservation-error');
+    if (reservationErr.length) {
+        // Trigger error event
+        var errorCode = reservationErr.attr('error-code');
+        var errorTextNode = $(error).find('>error>text');
+        var errorMsg;
+        if (errorTextNode) {
+            errorMsg = errorTextNode.text();
+        }
+        self.eventEmitter.emit(
+                XMPPEvents.RESERVATION_ERROR, errorCode, errorMsg);
+        return;
+    }
+    // Not authorized to create new room
+    if ($(error).find('>error>not-authorized').length) {
+        logger.warn("Unauthorized to start the conference", error);
+        var toDomain = Strophe.getDomainFromJid(error.getAttribute('to'));
+        if (toDomain !== self.xmppService.options.hosts.anonymousdomain) {
+            //FIXME "is external" should come either from the focus or config.js
+            self.externalAuthEnabled = true;
+        }
+        self.eventEmitter.emit(
+                XMPPEvents.AUTHENTICATION_REQUIRED,
                 function () {
                     self.allocateConferenceFocus(callback);
-                }, waitMs);
-        }
-    );
+                });
+        return;
+    }
+    var waitMs = self.getNextErrorTimeout();
+    logger.error("Focus error, retry after " + waitMs, error);
+    // Show message
+    var focusComponent = self.getFocusComponent();
+    var retrySec = waitMs / 1000;
+    //FIXME: message is duplicated ? Do not show in case of session invalid
+    // which means just a retry
+    if (!invalidSession) {
+        self.eventEmitter.emit(
+                XMPPEvents.FOCUS_DISCONNECTED, focusComponent, retrySec);
+    }
+    // Reset response timeout
+    self.getNextTimeout(true);
+    window.setTimeout(
+            function () {
+                self.allocateConferenceFocus(callback);
+            },
+            waitMs);
+};
+
+/**
+ * Invoked by {@link #allocateConferenceFocus} upon its request receiving a
+ * success (i.e. non-error) result.
+ *
+ * @param result - the success (i.e. non-error) result of the request that
+ * {@link #allocateConferenceFocus} sent
+ * @param {Function} callback - the function to be called back upon the
+ * successful allocation of the conference focus
+ */
+Moderator.prototype._allocateConferenceFocusSuccess = function (
+        result,
+        callback) {
+    // Setup config options
+    this.parseConfigOptions(result);
+
+    // Reset the error timeout (because we haven't failed here).
+    this.getNextErrorTimeout(true);
+    if ('true' === $(result).find('conference').attr('ready')) {
+        // Reset the non-error timeout (because we've succeeded here).
+        this.getNextTimeout(true);
+        // Exec callback
+        callback();
+    } else {
+        var waitMs = this.getNextTimeout();
+        logger.info("Waiting for the focus... " + waitMs);
+        var self = this;
+        window.setTimeout(
+                function () {
+                    self.allocateConferenceFocus(callback);
+                },
+                waitMs);
+    }
 };
 
 Moderator.prototype.authenticate = function () {

modules/xmpp/recording.js

@@ -1,19 +1,26 @@
 /* global $, $iq, config, connection, focusMucJid, messageHandler,
    Toolbar, Util, Promise */
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+var JitsiRecorderErrors = require("../../JitsiRecorderErrors");
+
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 
 function Recording(type, eventEmitter, connection, focusMucJid, jirecon,
     roomjid) {
     this.eventEmitter = eventEmitter;
     this.connection = connection;
-    this.state = "off";
+    this.state = null;
     this.focusMucJid = focusMucJid;
     this.jirecon = jirecon;
     this.url = null;
     this.type = type;
-    this._isSupported = ((type === Recording.types.JIBRI)
-        || (type === Recording.types.JIRECON && !this.jirecon))? false : true;
+    this._isSupported
+        = ( type === Recording.types.JIRECON && !this.jirecon
+            || type === Recording.types.JIBRI && !this._isServiceAvailable)
+            ? false : true;
+
+    this._isServiceAvailable = false;
+
     /**
      * The ID of the jirecon recording session. Jirecon generates it when we
      * initially start recording, and it needs to be used in subsequent requests
@@ -29,18 +36,43 @@ Recording.types = {
     JIBRI: "jibri"
 };
 
+Recording.status = {
+    ON: "on",
+    OFF: "off",
+    AVAILABLE: "available",
+    UNAVAILABLE: "unavailable",
+    START: "start",
+    STOP: "stop",
+    PENDING: "pending"
+};
+
 Recording.prototype.handleJibriPresence = function (jibri) {
     var attributes = jibri.attributes;
     if(!attributes)
         return;
 
-    this._isSupported =
-        (attributes.status && attributes.status !== "undefined");
-    if(this._isSupported) {
-        this.url = attributes.url || null;
-        this.state = attributes.status || "off";
-    }
-    this.eventEmitter.emit(XMPPEvents.RECORDING_STATE_CHANGED);
+    var newState = attributes.status;
+    console.log("handle jibri presence : ", newState);
+    var oldIsAvailable = this._isServiceAvailable;
+    // The service is available if the statu isn't undefined.
+    this._isServiceAvailable =
+        (newState && newState !== "undefined");
+
+    if (newState === "undefined"
+        || oldIsAvailable != this._isServiceAvailable
+        // If we receive an OFF state without any recording in progress we
+        // consider this to be an initial available state.
+        || (this.state === Recording.status.AVAILABLE
+            && newState === Recording.status.OFF))
+        this.state = (newState === "undefined")
+                        ? Recording.status.UNAVAILABLE
+                        : Recording.status.AVAILABLE;
+    else
+        this.state = attributes.status;
+
+    logger.log("Handle Jibri presence: ", this.state);
+
+    this.eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, this.state);
 };
 
 Recording.prototype.setRecordingJibri = function (state, callback, errCallback,
@@ -49,21 +81,23 @@ Recording.prototype.setRecordingJibri = function (state, callback, errCallback,
         errCallback(new Error("Invalid state!"));
     }
     options = options || {};
-    // FIXME jibri does not accept IQ without 'url' attribute set ?
 
+    // FIXME jibri does not accept IQ without 'url' attribute set ?
     var iq = $iq({to: this.focusMucJid, type: 'set'})
         .c('jibri', {
-            "xmlns": 'http://jitsi.org/protocol/jibri',
-            "action": (state === 'on') ? 'start' : 'stop',
-            "streamid": options.streamId,
-            "follow-entity": options.followEntity
+        "xmlns": 'http://jitsi.org/protocol/jibri',
+        "action": (state === Recording.status.ON)
+                    ? Recording.status.START
+                    : Recording.status.STOP,
+        "streamid": options.streamId,
         }).up();
 
-    logger.log('Set jibri recording: '+state, iq.nodeTree);
-    console.log(iq.nodeTree);
+    logger.log('Set jibri recording: ' + state, iq.nodeTree);
+    logger.log(iq.nodeTree);
     this.connection.sendIQ(
         iq,
         function (result) {
+            logger.log("Result", result);
             callback($(result).find('jibri').attr('state'),
             $(result).find('jibri').attr('url'));
         },
@@ -74,20 +108,23 @@ Recording.prototype.setRecordingJibri = function (state, callback, errCallback,
 };
 
 Recording.prototype.setRecordingJirecon =
-function (state, callback, errCallback, options) {
+    function (state, callback, errCallback, options) {
+
     if (state == this.state){
         errCallback(new Error("Invalid state!"));
     }
 
     var iq = $iq({to: this.jirecon, type: 'set'})
         .c('recording', {xmlns: 'http://jitsi.org/protocol/jirecon',
-            action: (state === 'on') ? 'start' : 'stop',
+            action: (state === Recording.status.ON)
+                ? Recording.status.START
+                : Recording.status.STOP,
             mucjid: this.roomjid});
     if (state === 'off'){
         iq.attrs({rid: this.jireconRid});
     }
 
-    console.log('Start recording');
+    logger.log('Start recording');
     var self = this;
     this.connection.sendIQ(
         iq,
@@ -96,10 +133,10 @@ function (state, callback, errCallback, options) {
             // provisional?
             self.jireconRid = $(result).find('recording').attr('rid');
             console.log('Recording ' +
-                ((state === 'on') ? 'started' : 'stopped') +
+                ((state === Recording.status.ON) ? 'started' : 'stopped') +
                 '(jirecon)' + result);
             self.state = state;
-            if (state === 'off'){
+            if (state === Recording.status.OFF){
                 self.jireconRid = null;
             }
 
@@ -168,30 +205,46 @@ function (state, callback, errCallback, options) {
 };
 
 /**
- *Starts/stops the recording
+ * Starts/stops the recording.
  * @param token token for authentication
  * @param statusChangeHandler {function} receives the new status as argument.
  */
 Recording.prototype.toggleRecording = function (options, statusChangeHandler) {
-    if ((!options.token && this.type === Recording.types.COLIBRI) ||
-        (!options.streamId && this.type === Recording.types.JIBRI)){
-        statusChangeHandler("error", new Error("No token passed!"));
+    var oldState = this.state;
+
+    // If the recorder is currently unavailable we throw an error.
+    if (oldState === Recording.status.UNAVAILABLE)
+        statusChangeHandler("error",
+            new Error(JitsiRecorderErrors.RECORDER_UNAVAILABLE));
+
+    // If we're about to turn ON the recording we need either a streamId or
+    // an authentication token depending on the recording type. If we don't
+    // have any of those we throw an error.
+    if ((oldState === Recording.status.OFF
+        || oldState === Recording.status.AVAILABLE)
+        && ((!options.token && this.type === Recording.types.COLIBRI) ||
+        (!options.streamId && this.type === Recording.types.JIBRI))) {
+        statusChangeHandler("error",
+            new Error(JitsiRecorderErrors.NO_TOKEN));
         logger.error("No token passed!");
         return;
     }
 
-    var oldState = this.state;
-    var newState = (oldState === 'off' || !oldState) ? 'on' : 'off';
+    var newState = (oldState === Recording.status.AVAILABLE
+                    || oldState === Recording.status.OFF)
+                    ? Recording.status.ON
+                    : Recording.status.OFF;
+
     var self = this;
+    logger.log("Toggle recording (old state, new state): ", oldState, newState);
     this.setRecording(newState,
         function (state, url) {
-            logger.log("New recording state: ", state);
+            // If the state is undefined we're going to wait for presence
+            // update.
             if (state && state !== oldState) {
                 self.state = state;
                 self.url = url;
                 statusChangeHandler(state);
-            } else {
-                statusChangeHandler("error", new Error("Status not changed!"));
             }
         }, function (error) {
             statusChangeHandler("error", error);

modules/xmpp/strophe.jingle.js

@@ -94,8 +94,8 @@ module.exports = function(XMPP, eventEmitter) {
             // see http://xmpp.org/extensions/xep-0166.html#concepts-session
             switch (action) {
                 case 'session-initiate':
-                    console.log("(TIME) received session-initiate:\t",
-                                window.performance.now());
+                    var now = window.performance.now();
+                    console.log("(TIME) received session-initiate:\t", now);
                     var startMuted = $(iq).find('jingle>startmuted');
                     if (startMuted && startMuted.length > 0) {
                         var audioMuted = startMuted.attr("audio");
@@ -116,7 +116,7 @@ module.exports = function(XMPP, eventEmitter) {
                     var jingleOffer = $(iq).find('>jingle');
                     // FIXME there's no nice way with event to get the reason
                     // why the call was rejected
-                    eventEmitter.emit(XMPPEvents.CALL_INCOMING, sess, jingleOffer);
+                    eventEmitter.emit(XMPPEvents.CALL_INCOMING, sess, jingleOffer, now);
                     if (!sess.active())
                     {
                         // Call not accepted
@@ -267,4 +267,3 @@ module.exports = function(XMPP, eventEmitter) {
         }
     });
 };
-

modules/xmpp/xmpp.js

@@ -11,12 +11,12 @@ var RTC = require("../RTC/RTC");
 
 var authenticatedUser = false;
 
-function createConnection(bosh) {
+function createConnection(bosh, token) {
     bosh = bosh || '/http-bind';
 
     // Append token as URL param
-    if (this.token) {
-        bosh += (bosh.indexOf('?') == -1 ? '?' : '&') + 'token=' + this.token;
+    if (token) {
+        bosh += (bosh.indexOf('?') == -1 ? '?' : '&') + 'token=' + token;
     }
 
     return new Strophe.Connection(bosh);
@@ -33,16 +33,16 @@ function initStrophePlugins(XMPP) {
     require("./strophe.logger")();
 }
 
-function XMPP(options) {
+function XMPP(options, token) {
     this.eventEmitter = new EventEmitter();
     this.connection = null;
     this.disconnectInProgress = false;
-
+    this.performanceTimes = {status: []};
     this.forceMuted = false;
     this.options = options;
     initStrophePlugins(this);
 
-    this.connection = createConnection(options.bosh);
+    this.connection = createConnection(options.bosh, token);
 
     // Setup a disconnect on unload as a way to facilitate API consumers. It
     // sounds like they would want that. A problem for them though may be if
@@ -54,8 +54,81 @@ function XMPP(options) {
 
 XMPP.prototype.getConnection = function () { return this.connection; };
 
+/**
+ * Receive connection status changes and handles them.
+ * @password {string} the password passed in connect method
+ * @status the connection status
+ * @msg message
+ */
+XMPP.prototype.connectionHandler = function (password, status, msg) {
+    var now = window.performance.now();
+    this.performanceTimes["status"].push(
+        {state: Strophe.getStatusString(status),
+        time: now});
+    logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
+        (msg ? "[" + msg + "]" : "") + ":\t", now);
+    if (status === Strophe.Status.CONNECTED ||
+        status === Strophe.Status.ATTACHED) {
+        if (this.options.useStunTurn) {
+            this.connection.jingle.getStunAndTurnCredentials();
+        }
+
+        logger.info("My Jabber ID: " + this.connection.jid);
+
+        // Schedule ping ?
+        var pingJid = this.connection.domain;
+        this.connection.ping.hasPingSupport(
+            pingJid,
+            function (hasPing) {
+                if (hasPing)
+                    this.connection.ping.startInterval(pingJid);
+                else
+                    logger.warn("Ping NOT supported by " + pingJid);
+            }.bind(this));
+
+        if (password)
+            authenticatedUser = true;
+        if (this.connection && this.connection.connected &&
+            Strophe.getResourceFromJid(this.connection.jid)) {
+            // .connected is true while connecting?
+//                this.connection.send($pres());
+            this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+                    Strophe.getResourceFromJid(this.connection.jid));
+        }
+    } else if (status === Strophe.Status.CONNFAIL) {
+        if (msg === 'x-strophe-bad-non-anon-jid') {
+            this.anonymousConnectionFailed = true;
+        } else {
+            this.connectionFailed = true;
+        }
+        this.lastErrorMsg = msg;
+    } else if (status === Strophe.Status.DISCONNECTED) {
+        // Stop ping interval
+        this.connection.ping.stopInterval();
+        this.disconnectInProgress = false;
+        if (this.anonymousConnectionFailed) {
+            // prompt user for username and password
+            this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+                JitsiConnectionErrors.PASSWORD_REQUIRED);
+        } else if(this.connectionFailed) {
+            this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+                JitsiConnectionErrors.OTHER_ERROR,
+                msg ? msg : this.lastErrorMsg);
+        } else {
+            this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+                    msg ? msg : this.lastErrorMsg);
+        }
+    } else if (status === Strophe.Status.AUTHFAIL) {
+        // wrong password or username, prompt user
+        this.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
+            JitsiConnectionErrors.PASSWORD_REQUIRED);
+
+    }
+}
+
 XMPP.prototype._connect = function (jid, password) {
-    var self = this;
     // connection.connect() starts the connection process.
     //
     // As the connection process proceeds, the user supplied callback will
@@ -83,72 +156,25 @@ XMPP.prototype._connect = function (jid, password) {
     //  Status.DISCONNECTING - The connection is currently being terminated
     //  Status.ATTACHED - The connection has been attached
 
-    var anonymousConnectionFailed = false;
-    var connectionFailed = false;
-    var lastErrorMsg;
-    this.connection.connect(jid, password, function (status, msg) {
-        logger.log("(TIME) Strophe " + Strophe.getStatusString(status) +
-            (msg ? "[" + msg + "]" : "") + "\t:" + window.performance.now());
-        if (status === Strophe.Status.CONNECTED) {
-            if (self.options.useStunTurn) {
-                self.connection.jingle.getStunAndTurnCredentials();
-            }
-
-            logger.info("My Jabber ID: " + self.connection.jid);
-
-            // Schedule ping ?
-            var pingJid = self.connection.domain;
-            self.connection.ping.hasPingSupport(
-                pingJid,
-                function (hasPing) {
-                    if (hasPing)
-                        self.connection.ping.startInterval(pingJid);
-                    else
-                        logger.warn("Ping NOT supported by " + pingJid);
-                }
-            );
-
-            if (password)
-                authenticatedUser = true;
-            if (self.connection && self.connection.connected &&
-                Strophe.getResourceFromJid(self.connection.jid)) {
-                // .connected is true while connecting?
-//                self.connection.send($pres());
-                self.eventEmitter.emit(
-                        JitsiConnectionEvents.CONNECTION_ESTABLISHED,
-                        Strophe.getResourceFromJid(self.connection.jid));
-            }
-        } else if (status === Strophe.Status.CONNFAIL) {
-            if (msg === 'x-strophe-bad-non-anon-jid') {
-                anonymousConnectionFailed = true;
-            } else {
-                connectionFailed = true;
-            }
-            lastErrorMsg = msg;
-        } else if (status === Strophe.Status.DISCONNECTED) {
-            // Stop ping interval
-            self.connection.ping.stopInterval();
-            self.disconnectInProgress = false;
-            if (anonymousConnectionFailed) {
-                // prompt user for username and password
-                self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                    JitsiConnectionErrors.PASSWORD_REQUIRED);
-            } else if(connectionFailed) {
-                self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                    JitsiConnectionErrors.OTHER_ERROR,
-                    msg ? msg : lastErrorMsg);
-            } else {
-                self.eventEmitter.emit(
-                        JitsiConnectionEvents.CONNECTION_DISCONNECTED,
-                        msg ? msg : lastErrorMsg);
-            }
-        } else if (status === Strophe.Status.AUTHFAIL) {
-            // wrong password or username, prompt user
-            self.eventEmitter.emit(JitsiConnectionEvents.CONNECTION_FAILED,
-                JitsiConnectionErrors.PASSWORD_REQUIRED);
+    this.anonymousConnectionFailed = false;
+    this.connectionFailed = false;
+    this.lastErrorMsg;
+    this.connection.connect(jid, password,
+        this.connectionHandler.bind(this, password));
+}
 
-        }
-    });
+/**
+ * Attach to existing connection. Can be used for optimizations. For example:
+ * if the connection is created on the server we can attach to it and start
+ * using it.
+ *
+ * @param options {object} connecting options - rid, sid, jid and password.
+ */
+ XMPP.prototype.attach = function (options) {
+    var now = this.performanceTimes["attaching"] = window.performance.now();
+    logger.log("(TIME) Strophe Attaching\t:" + now);
+    this.connection.attach(options.jid, options.sid, parseInt(options.rid,10)+1,
+        this.connectionHandler.bind(this, options.password));
 }
 
 XMPP.prototype.connect = function (jid, password) {

package.json

@@ -34,15 +34,16 @@
     "jshint": "^2.8.0",
     "precommit-hook": "^3.0.0",
     "exorcist": "*",
-    "uglify-js": "2.4.24"
+    "uglify-js": "2.4.24",
+    "watchify": "^3.7.0"
   },
   "scripts": {
     "install": "npm run browserify && npm run version && npm run uglifyjs",
 
     "browserify": "browserify -d JitsiMeetJS.js -s JitsiMeetJS | exorcist lib-jitsi-meet.js.map > lib-jitsi-meet.js ",
-    "version": "VERSION=`./get-version.sh` && sed -i'' -e s/{#COMMIT_HASH#}/${VERSION}/g lib-jitsi-meet.js",
+    "version": "VERSION=`./get-version.sh` && echo lib-jitsi-meet version is:${VERSION} && sed -i'' -e s/{#COMMIT_HASH#}/${VERSION}/g lib-jitsi-meet.js",
     "uglifyjs": "uglifyjs -p relative lib-jitsi-meet.js -o lib-jitsi-meet.min.js --source-map lib-jitsi-meet.min.map --in-source-map lib-jitsi-meet.js.map",
-
+    "watch": "watchify JitsiMeetJS.js -s JitsiMeetJS -o lib-jitsi-meet.js -v",
     "lint": "jshint .",
     "validate": "npm ls"
   },

service/UI/UIEvents.js

@@ -1,7 +0,0 @@
-var UIEvents = {
-    NICKNAME_CHANGED: "UI.nickname_changed",
-    SELECTED_ENDPOINT: "UI.selected_endpoint",
-    PINNED_ENDPOINT: "UI.pinned_endpoint",
-    LARGEVIDEO_INIT: "UI.largevideo_init"
-};
-module.exports = UIEvents;

service/xmpp/XMPPEvents.js

@@ -95,7 +95,7 @@ var XMPPEvents = {
     /**
      * Indicates that recording state changed.
      */
-    RECORDING_STATE_CHANGED: "xmpp.recordingStateChanged",
+    RECORDER_STATE_CHANGED: "xmpp.recorderStateChanged",
     // Designates an event indicating that we received statistics from a
     // participant in the MUC.
     REMOTE_STATS: "xmpp.remote_stats",