Merge branch 'master' into reloads

JitsiConference.js

  */
 JitsiConference.prototype.selectParticipant = function(participantId) {
     if (this.rtc) {
-        this.rtc.selectedEndpoint(participantId);
+        this.rtc.selectEndpoint(participantId);
     }
 };
 
         new Error(JSON.stringify(errorContent)));
     logger.error("Audio problem detected. The audio is received but not played",
         errorContent);
-}
+};
+
+/**
+ * Logs an "application log" message
+ */
+JitsiConference.prototype.sendApplicationLog = function(message) {
+    Statistics.sendLog(message);
+};
 
 /**
  * Setups the listeners needed for the conference.
     this.eventManager.setupChatRoomListeners();
     this.eventManager.setupRTCListeners();
     this.eventManager.setupStatisticsListeners();
-}
+};
 
 /**
  * Checks if the user identified by given <tt>mucJid</tt> is the conference
  */
 JitsiConference.prototype._isFocus = function (mucJid) {
     return this.room.isFocus(mucJid);
-}
+};
 
 /**
  * Fires CONFERENCE_FAILED event with INCOMPATIBLE_SERVER_VERSIONS parameter
 JitsiConference.prototype._fireIncompatibleVersionsEvent = function () {
     this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.INCOMPATIBLE_SERVER_VERSIONS);
-}
+};
 
 module.exports = JitsiConference;

modules/RTC/DataChannels.js

 DataChannels.prototype.onDataChannel = function (event) {
     var dataChannel = event.channel;
     var self = this;
-    var lastSelectedEndpoint = null;
+    var selectedEndpoint = null;
 
     dataChannel.onopen = function () {
         logger.info("Data channel opened by the Videobridge!", dataChannel);
         // selections so that it can do adaptive simulcast,
         // we want the notification to trigger even if userJid is undefined,
         // or null.
-        self.handleSelectedEndpointEvent(self.lastSelectedEndpoint);
+        // XXX why do we not do the same for pinned endpoints?
+        self.sendSelectedEndpointMessage(self.selectedEndpoint);
     };
 
     dataChannel.onerror = function (error) {
     });
 };
 
-DataChannels.prototype.handleSelectedEndpointEvent = function (userResource) {
-    this.lastSelectedEndpoint = userResource;
-    this._onXXXEndpointChanged("selected", userResource);
+/**
+ * Sends a "selected endpoint changed" message via the data channel.
+ */
+DataChannels.prototype.sendSelectedEndpointMessage = function (endpointId) {
+    this.selectedEndpoint = endpointId;
+    this._onXXXEndpointChanged("selected", endpointId);
 };
 
-DataChannels.prototype.handlePinnedEndpointEvent = function (userResource) {
-    this._onXXXEndpointChanged("pinnned", userResource);
+/**
+ * Sends a "pinned endpoint changed" message via the data channel.
+ */
+DataChannels.prototype.sendPinnedEndpointMessage = function (endpointId) {
+    this._onXXXEndpointChanged("pinnned", endpointId);
 };
 
 /**

modules/RTC/RTC.js

             this.eventEmitter);
 };
 
-RTC.prototype.selectedEndpoint = function (id) {
+RTC.prototype.selectEndpoint = function (id) {
     if(this.dataChannels)
-        this.dataChannels.handleSelectedEndpointEvent(id);
+        this.dataChannels.sendSelectedEndpointMessage(id);
 };
 
 RTC.prototype.pinEndpoint = function (id) {
     if(this.dataChannels)
-        this.dataChannels.handlePinnedEndpointEvent(id);
+        this.dataChannels.sendPinnedEndpointMessage(id);
 };
 
 RTC.prototype.addListener = function (type, listener) {

modules/xmpp/JingleSessionPC.js

     this.modifyingLocalStreams = false;
     this.modifiedSSRCs = {};
 
+    /**
+     * The local ICE username fragment for this session.
+     */
+    this.localUfrag = null;
+
+    /**
+     * The remote ICE username fragment for this session.
+     */
+    this.remoteUfrag = null;
+
     /**
      * A map that stores SSRCs of remote streams. And is used only locally
      * We store the mapping when jingle is received, and later is used
             // complete.
             return;
         }
+        // XXX this is broken, candidate is not parsed.
         var candidate = ev.candidate;
         if (candidate) {
             // Discard candidates of disabled protocols.
         GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
         queueCallback(err);
     };
+
+    var ufrag = getUfrag(sdp.raw);
+    if (ufrag != self.remoteUfrag) {
+        self.remoteUfrag = ufrag;
+        self.room.eventEmitter.emit(
+                XMPPEvents.REMOTE_UFRAG_CHANGED, ufrag);
+    }
+
     this.peerconnection.setRemoteDescription(
         new RTCSessionDescription({type: 'offer', sdp: sdp.raw}),
         function() {
                     answer.sdp = modifiedAnswer.raw;
                     self.localSDP = new SDP(answer.sdp);
                     answer.sdp = self.localSDP.raw;
+                    var ufrag = getUfrag(answer.sdp);
+                    if (ufrag != self.localUfrag) {
+                        self.localUfrag = ufrag;
+                        self.room.eventEmitter.emit(
+                                XMPPEvents.LOCAL_UFRAG_CHANGED, ufrag);
+                    }
                     self.peerconnection.setLocalDescription(answer,
                         function() {
                             successCallback && successCallback();
     return desc;
 }
 
+/**
+ * Extracts the ice username fragment from an SDP string.
+ */
+function getUfrag(sdp) {
+    var ufragLines = sdp.split('\n').filter(function(line) {
+        return line.startsWith("a=ice-ufrag:");});
+    if (ufragLines.length > 0) {
+        return ufragLines[0].substr("a=ice-ufrag:".length)
+    }
+}
+
 module.exports = JingleSessionPC;

package.json

   "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 ",
+    "browserify": "browserify -d JitsiMeetJS.js -s JitsiMeetJS | exorcist lib-jitsi-meet.js.map > lib-jitsi-meet.js && [ -s 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",

service/xmpp/XMPPEvents.js

     START_MUTED_FROM_FOCUS: "xmpp.start_muted_from_focus",
     // Designates an event indicating that the subject of the XMPP MUC has
     // changed.
-    SUBJECT_CHANGED: "xmpp.subject_changed"
+    SUBJECT_CHANGED: "xmpp.subject_changed",
+    // Designates an event indicating that the local ICE username fragment of
+    // the jingle session has changed.
+    LOCAL_UFRAG_CHANGED: "xmpp.local_ufrag_changed",
+    // Designates an event indicating that the local ICE username fragment of
+    // the jingle session has changed.
+    REMOTE_UFRAG_CHANGED: "xmpp.remote_ufrag_changed"
 };
 module.exports = XMPPEvents;