Merge remote-tracking branch 'remotes/upstream/master' into set_mute

JitsiConference.js

@@ -98,8 +98,6 @@ JitsiConference.prototype._init = function (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
         });
     }
@@ -786,6 +784,8 @@ function (jingleSession, jingleOffer, now) {
     // Accept incoming call
     this.room.setJingleSession(jingleSession);
     this.room.connectionTimes["session.initiate"] = now;
+    Statistics.analytics.sendEvent("muc.idle",
+        (now - this.room.connectionTimes["muc.joined"]));
     try{
         jingleSession.initialize(false /* initiator */,this.room);
     } catch (error) {

JitsiConferenceEventManager.js

@@ -92,6 +92,19 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
 
     this.chatRoomForwarder.forward(XMPPEvents.MUC_JOINED,
         JitsiConferenceEvents.CONFERENCE_JOINED);
+    // send some analytics events
+    chatRoom.addListener(XMPPEvents.MUC_JOINED,
+        function ()
+        {
+            for (var ckey in chatRoom.connectionTimes){
+                var cvalue = chatRoom.connectionTimes[ckey];
+                Statistics.analytics.sendEvent('conference.' + ckey, cvalue);
+            }
+            for (var xkey in chatRoom.xmpp.connectionTimes){
+                var xvalue = chatRoom.xmpp.connectionTimes[xkey];
+                Statistics.analytics.sendEvent('xmpp.' + xkey, xvalue);
+            }
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.ROOM_JOIN_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
@@ -116,6 +129,10 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
     this.chatRoomForwarder.forward(XMPPEvents.BRIDGE_DOWN,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
+    chatRoom.addListener(XMPPEvents.BRIDGE_DOWN,
+        function (){
+            Statistics.analytics.sendEvent('conference.bridgeDown');
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.RESERVATION_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
@@ -153,19 +170,24 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
 
     chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
         function () {
+            Statistics.analytics.sendEvent('conference.focusLeft');
             if(!conference.connection._reload())
                 conference.eventEmitter.emit(
                     JitsiConferenceEvents.CONFERENCE_FAILED,
                     JitsiConferenceErrors.FOCUS_LEFT);
         });
 
-    chatRoom.addListener(XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR,
-        function () {
-            conference.connection._reload();
-        });
+    var reloadHandler = function () { conference.connection._reload(); };
+    chatRoom.addListener(
+        XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR, reloadHandler);
+    chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT, reloadHandler);
 
     this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
         JitsiConferenceEvents.CONNECTION_INTERRUPTED);
+    chatRoom.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
+        function () {
+            Statistics.analytics.sendEvent('connection.interrupted');
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
         JitsiConferenceEvents.RECORDER_STATE_CHANGED);
@@ -428,6 +450,7 @@ JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
+        Statistics.analytics.sendEvent('conference.dataChannel.open', now);
     });
 
     this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,

JitsiConnection.js

@@ -2,6 +2,7 @@ var JitsiConference = require("./JitsiConference");
 var XMPP = require("./modules/xmpp/xmpp");
 var JitsiConnectionEvents = require("./JitsiConnectionEvents");
 var JitsiConnectionErrors = require("./JitsiConnectionErrors");
+var Statistics = require("./modules/statistics/statistics");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
@@ -25,12 +26,23 @@ function JitsiConnection(appID, token, options) {
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
         function (errType, msg) {
+            Statistics.analytics.sendEvent('connection.failed.' + errType);
             if(errType === JitsiConnectionErrors.OTHER_ERROR &&
                 (msg === "item-not-found" || msg === "host-unknown")) {
                     // FIXME: don't report the error if we are going to reload
                     this._reload();
                 }
         }.bind(this));
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+        function (msg) {
+            // we can see disconnects from normal tab closing of the browser
+            // and then there are no msgs, but we want to log only disconnects
+            // when there is real error
+            if(msg)
+                Statistics.analytics.sendEvent(
+                    'connection.disconnected.' + msg);
+        });
 }
 
 /**
@@ -62,6 +74,7 @@ JitsiConnection.prototype.attach = function (options) {
 JitsiConnection.prototype._reload = function () {
     if(this.retryOnFail === 0)
         return false;
+    Statistics.analytics.sendEvent('connection.reload');
     this.retryOnFail--;
     var states = {};
     for(var name in this.conferences) {

JitsiMediaDevices.js

@@ -46,7 +46,9 @@ var JitsiMediaDevices = {
     },
     /**
      * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
      */
     isDeviceListAvailable: function () {
         return RTC.isDeviceListAvailable();

JitsiMeetJS.js

@@ -41,6 +41,29 @@ function getLowerResolution(resolution) {
     return resName;
 }
 
+/**
+ * Checks the available devices in options and concatenate the data to the
+ * name, which will be used as analytics event name. Adds resolution for the
+ * devices.
+ * @param name name of event
+ * @param options gum options
+ * @returns {*}
+ */
+function addDeviceTypeToAnalyticsEvent(name, options) {
+    if (options.devices.indexOf("audio") !== -1) {
+        name += ".audio";
+    }
+    if (options.devices.indexOf("desktop") !== -1) {
+        name += ".desktop";
+    }
+    if (options.devices.indexOf("video") !== -1) {
+        // we have video add resolution
+        name += ".video." + options.resolution;
+    }
+
+    return name;
+}
+
 /**
  * Namespace for the interface of Jitsi Meet Library.
  */
@@ -66,13 +89,11 @@ var LibJitsiMeet = {
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
+    analytics: null,
     init: function (options) {
         var logObject, attr;
-        Statistics.audioLevelsEnabled = !options.disableAudioLevels;
-
-        if(typeof options.audioLevelsInterval === 'number') {
-            Statistics.audioLevelsInterval = options.audioLevelsInterval;
-        }
+        Statistics.init(options);
+        this.analytics = Statistics.analytics;
 
         if (options.enableWindowOnErrorHandler) {
             GlobalOnErrorHandler.addHandler(
@@ -125,6 +146,28 @@ var LibJitsiMeet = {
      * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
+     * @param {object} options.desktopSharingExtensionExternalInstallation -
+     * enables external installation process for desktop sharing extension if
+     * the inline installation is not posible. The following properties should
+     * be provided:
+     * @param {intiger} interval - the interval (in ms) for
+     * checking whether the desktop sharing extension is installed or not
+     * @param {Function} checkAgain - returns boolean. While checkAgain()==true
+     * createLocalTracks will wait and check on every "interval" ms for the
+     * extension. If the desktop extension is not install and checkAgain()==true
+     * createLocalTracks will finish with rejected Promise.
+     * @param {Function} listener - The listener will be called to notify the
+     * user of lib-jitsi-meet that createLocalTracks is starting external
+     * extension installation process.
+     * NOTE: If the inline installation process is not possible and external
+     * installation is enabled the listener property will be called to notify
+     * the start of external installation process. After that createLocalTracks
+     * will start to check for the extension on every interval ms until the
+     * plugin is installed or until checkAgain return false. If the extension
+     * is found createLocalTracks will try to get the desktop sharing track and
+     * will finish the execution. If checkAgain returns false, createLocalTracks
+     * will finish the execution with rejected Promise.
+     *
      * @param {boolean} (firePermissionPromptIsShownEvent) - if event
      *      JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN should be fired
      * @returns {Promise.<{Array.<JitsiTrack>}, JitsiConferenceError>}
@@ -137,24 +180,28 @@ var LibJitsiMeet = {
         if (firePermissionPromptIsShownEvent === true) {
             window.setTimeout(function () {
                 if (!promiseFulfilled) {
-                    var browser = RTCBrowserType.getBrowserType()
-                        .split('rtc_browser.')[1];
-
-                    if (RTCBrowserType.isAndroid()) {
-                        browser = 'android';
-                    }
-
                     JitsiMediaDevices.emitEvent(
                         JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                        browser);
+                        RTCBrowserType.getBrowserName());
                 }
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }
 
+        if(!window.connectionTimes)
+            window.connectionTimes = {};
+        window.connectionTimes["obtainPermissions.start"] =
+            window.performance.now();
+
         return RTC.obtainAudioAndVideoPermissions(options || {})
             .then(function(tracks) {
                 promiseFulfilled = true;
 
+                window.connectionTimes["obtainPermissions.end"] =
+                    window.performance.now();
+
+                Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
+                    "getUserMedia.success", options), options);
+
                 if(!RTC.options.disableAudioLevels)
                     for(var i = 0; i < tracks.length; i++) {
                         var track = tracks[i];
@@ -184,6 +231,9 @@ var LibJitsiMeet = {
                         logger.debug("Retry createLocalTracks with resolution",
                             newResolution);
 
+                        Statistics.analytics.sendEvent(
+                            "getUserMedia.fail.resolution." + oldResolution);
+
                         return LibJitsiMeet.createLocalTracks(options);
                     }
                 }
@@ -198,17 +248,30 @@ var LibJitsiMeet = {
                         message: error.message
                     };
                     Statistics.sendLog(JSON.stringify(logObject));
+                    Statistics.analytics.sendEvent(
+                        "getUserMedia.userCancel.extensionInstall");
                 } else {
                     // Report gUM failed to the stats
                     Statistics.sendGetUserMediaFailed(error);
                 }
 
+                window.connectionTimes["obtainPermissions.end"] =
+                    window.performance.now();
+
+
+                Statistics.analytics.sendEvent(
+                    addDeviceTypeToAnalyticsEvent(
+                        "getUserMedia.failed", options) + '.' + error.name,
+                    options);
+
                 return Promise.reject(error);
             }.bind(this));
     },
     /**
      * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
      * @deprecated use JitsiMeetJS.mediaDevices.isDeviceListAvailable instead
      */
     isDeviceListAvailable: function () {

doc/API.md

@@ -50,6 +50,8 @@ The ```options``` parameter is JS object with the following properties:
     9. disableAudioLevels - boolean property. Enables/disables audio levels.
     10. disableSimulcast - boolean property. Enables/disables simulcast.
     11. enableWindowOnErrorHandler - boolean property (default false). Enables/disables attaching global onerror handler (window.onerror).
+    12. disableThirdPartyRequests - if true - callstats will be disabled and the callstats API won't be included.
+    13. analyticsScriptUrl - (optional) custom url to search for the analytics lib, if missing js file will be expected to be next to the library file (the location it is sourced from) 
 
 * ```JitsiMeetJS.JitsiConnection``` - the ```JitsiConnection``` constructor. You can use that to create new server connection.
 
@@ -214,8 +216,6 @@ This objects represents the server connection. You can create new ```JitsiConnec
         3. jirecon
         4. callStatsID - callstats credentials
         5. callStatsSecret - callstats credentials
-        6. disableThirdPartyRequests - if true - callstats will be disabled and
-        the callstats API won't be included.
         **NOTE: if 4 and 5 are set the library is going to send events to callstats. Otherwise the callstats integration will be disabled.**
 
 5. addEventListener(event, listener) - Subscribes the passed listener to the event.

modules/RTC/JitsiLocalTrack.js

@@ -7,7 +7,9 @@ var JitsiTrackErrors = require("../../JitsiTrackErrors");
 var JitsiTrackError = require("../../JitsiTrackError");
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
+var MediaType = require('../../service/RTC/MediaType');
 var VideoType = require('../../service/RTC/VideoType');
+var CameraFacingMode = require('../../service/RTC/CameraFacingMode');
 
 /**
  * Represents a single media track(either audio or video).
@@ -18,10 +20,11 @@ var VideoType = require('../../service/RTC/VideoType');
  * @param videoType the VideoType of the JitsiRemoteTrack
  * @param resolution the video resoultion if it's a video track
  * @param deviceId the ID of the local device for this track
+ * @param facingMode the camera facing mode used in getUserMedia call
  * @constructor
  */
 function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
-                         deviceId) {
+                         deviceId, facingMode) {
     var self = this;
 
     JitsiTrack.call(this,
@@ -40,6 +43,12 @@ function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
     this.initialMSID = this.getMSID();
     this.inMuteOrUnmuteProgress = false;
 
+    /**
+     * The facing mode of the camera from which this JitsiLocalTrack instance
+     * was obtained.
+     */
+    this._facingMode = facingMode;
+
     // Currently there is no way to know the MediaStreamTrack ended due to to
     // device disconnect in Firefox through e.g. "readyState" property. Instead
     // we will compare current track's label with device labels from
@@ -204,6 +213,7 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
             var streamOptions = {
                 cameraDeviceId: this.getDeviceId(),
                 devices: ["video"],
+                facingMode: this.getCameraFacingMode(),
                 resolution: this.resolution
             };
 
@@ -241,7 +251,7 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
 
     return promise
         .then(function() {
-            return self._setConferenceMute(mute);
+            return self._sendMuteStatus(mute);
         })
         .then(function() {
             self.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
@@ -302,13 +312,13 @@ JitsiLocalTrack.prototype._removeStreamFromConferenceAsMute = function () {
 };
 
 /**
- * Synchronizes muted stated of track with muted state of conference.
+ * Sends mute status for a track to conference if any.
  *
  * @param {boolean} mute - If track is muted.
  * @private
  * @returns {Promise}
  */
-JitsiLocalTrack.prototype._setConferenceMute = function(mute) {
+JitsiLocalTrack.prototype._sendMuteStatus = function(mute) {
     if (!this.conference || !this.conference.room) {
         return Promise.resolve();
     }
@@ -316,11 +326,10 @@ JitsiLocalTrack.prototype._setConferenceMute = function(mute) {
     var self = this;
 
     return new Promise(function(resolve) {
-        if (self.isAudioTrack()) {
-            self.conference.room.setAudioMute(mute, resolve);
-        } else {
-            self.conference.room.setVideoMute(mute, resolve);
-        }
+        self.conference.room[
+            self.isAudioTrack()
+                ? 'setAudioMute'
+                : 'setVideoMute'](mute, resolve);
     });
 };
 
@@ -436,4 +445,41 @@ JitsiLocalTrack.prototype.getDeviceId = function () {
     return this._realDeviceId || this.deviceId;
 };
 
+/**
+ * Returns facing mode for video track from camera. For other cases (e.g. audio
+ * track or 'desktop' video track) returns undefined.
+ *
+ * @returns {CameraFacingMode|undefined}
+ */
+JitsiLocalTrack.prototype.getCameraFacingMode = function () {
+    if (this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
+        // MediaStreamTrack#getSettings() is not implemented in many browsers,
+        // so we need a feature checking here. Progress on the respective
+        // browser's implementation can be tracked at
+        // https://bugs.chromium.org/p/webrtc/issues/detail?id=2481 for Chromium
+        // and https://bugzilla.mozilla.org/show_bug.cgi?id=1213517 for Firefox.
+        // Even if a browser implements getSettings() already, it might still
+        // not return anything for 'facingMode'.
+        var trackSettings;
+
+        if (this.track &&
+            typeof this.track.getSettings === 'function' &&
+            (trackSettings = this.track.getSettings()) &&
+            'facingMode' in trackSettings) {
+            return trackSettings.facingMode;
+        } else if (typeof this._facingMode !== 'undefined') {
+            return this._facingMode;
+        } else {
+            // In most cases we are showing a webcam. So if we've gotten here,
+            // it should be relatively safe to assume that we are probably
+            // showing the user-facing camera.
+            return CameraFacingMode.USER;
+        }
+
+    }
+
+    return undefined;
+};
+
+
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiRemoteTrack.js

@@ -1,5 +1,11 @@
 var JitsiTrack = require("./JitsiTrack");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
+var RTCBrowserType = require("./RTCBrowserType");
+var Statistics = require("../statistics/statistics");
+var AdapterJS = require("./adapter.screenshare");
+
+var ttfmTrackerAudioAttached = false;
+var ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
@@ -20,6 +26,10 @@ function JitsiRemoteTrack(conference, ownerJid, stream, track, mediaType, videoT
     this.conference = conference;
     this.peerjid = ownerJid;
     this.muted = muted;
+    // we want to mark whether the track has been ever muted
+    // to detect ttfm events for startmuted conferences, as it can significantly
+    // increase ttfm values
+    this.hasBeenMuted = muted;
 }
 
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
@@ -33,6 +43,9 @@ JitsiRemoteTrack.prototype.setMute = function (value) {
     if(this.muted === value)
         return;
 
+    if(value)
+        this.hasBeenMuted = true;
+
     // we can have a fake video stream
     if(this.stream)
         this.stream.muted = value;
@@ -84,4 +97,51 @@ JitsiRemoteTrack.prototype._setVideoType = function (type) {
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
 
+JitsiRemoteTrack.prototype._playCallback = function () {
+    var type = (this.isVideoTrack() ? 'video' : 'audio');
+
+    var now = window.performance.now();
+    console.log("(TIME) Render " + type + ":\t", now);
+    this.conference.getConnectionTimes()[type + ".render"] = now;
+
+    var ttfm = now
+        - (this.conference.getConnectionTimes()["session.initiate"]
+        - this.conference.getConnectionTimes()["muc.joined"])
+        - (window.connectionTimes["obtainPermissions.end"]
+        - window.connectionTimes["obtainPermissions.start"]);
+    this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
+    console.log("(TIME) TTFM " + type + ":\t", ttfm);
+    var eventName = type +'.ttfm';
+    if(this.hasBeenMuted)
+        eventName += '.muted';
+    Statistics.analytics.sendEvent(eventName, ttfm);
+};
+
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
+    if((ttfmTrackerAudioAttached && this.isAudioTrack())
+        || (ttfmTrackerVideoAttached && this.isVideoTrack()))
+        return;
+
+    if (this.isAudioTrack())
+        ttfmTrackerAudioAttached = true;
+    if (this.isVideoTrack())
+        ttfmTrackerVideoAttached = true;
+
+    if (RTCBrowserType.isTemasysPluginUsed()) {
+        // FIXME: this is not working for IE11
+        AdapterJS.addEvent(container, 'play', this._playCallback.bind(this));
+    }
+    else {
+        container.addEventListener("canplay", this._playCallback.bind(this));
+    }
+};
+
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

@@ -189,6 +189,8 @@ JitsiTrack.prototype.attach = function (container) {
 
     this._maybeFireTrackAttached(container);
 
+    this._attachTTFMTracker(container);
+
     return container;
 };
 
@@ -216,6 +218,17 @@ JitsiTrack.prototype.detach = function (container) {
     }
 };
 
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiTrack.prototype._attachTTFMTracker = function (container) {
+};
+
 /**
  * Removes attached event listeners.
  *

modules/RTC/RTC.js

@@ -17,16 +17,19 @@ function createLocalTracks(tracksInfo, options) {
     var deviceId = null;
     tracksInfo.forEach(function(trackInfo){
         if (trackInfo.mediaType === MediaType.AUDIO) {
-          deviceId = options.micDeviceId;
+            deviceId = options.micDeviceId;
         } else if (trackInfo.videoType === VideoType.CAMERA){
-          deviceId = options.cameraDeviceId;
+            deviceId = options.cameraDeviceId;
         }
         var localTrack
             = new JitsiLocalTrack(
                 trackInfo.stream,
                 trackInfo.track,
                 trackInfo.mediaType,
-                trackInfo.videoType, trackInfo.resolution, deviceId);
+                trackInfo.videoType,
+                trackInfo.resolution,
+                deviceId,
+                options.facingMode);
         newTracks.push(localTrack);
     });
     return newTracks;

modules/RTC/RTCBrowserType.js

@@ -30,6 +30,18 @@ var RTCBrowserType = {
         return currentBrowser;
     },
 
+    /**
+     * Gets current browser name, split from the type.
+     * @returns {string}
+     */
+    getBrowserName: function () {
+        var browser = currentBrowser.split('rtc_browser.')[1];
+        if (RTCBrowserType.isAndroid()) {
+            browser = 'android';
+        }
+        return browser;
+    },
+
     /**
      * Checks if current browser is Chrome.
      * @returns {boolean}

modules/RTC/RTCUtils.js

@@ -17,6 +17,7 @@ var JitsiTrackErrors = require("../../JitsiTrackErrors");
 var JitsiTrackError = require("../../JitsiTrackError");
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
+var CameraFacingMode = require("../../service/RTC/CameraFacingMode");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 var eventEmitter = new EventEmitter();
@@ -42,20 +43,33 @@ var isAudioOutputDeviceChangeAvailable =
 
 var currentlyAvailableMediaDevices;
 
-var rawEnumerateDevicesWithCallback = navigator.mediaDevices
-    && navigator.mediaDevices.enumerateDevices
+var rawEnumerateDevicesWithCallback = undefined;
+/**
+ * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
+ * ready. Otherwise it is too early to assume that the devices listing is not
+ * supported.
+ */
+function initRawEnumerateDevicesWithCallback() {
+    rawEnumerateDevicesWithCallback = navigator.mediaDevices
+        && navigator.mediaDevices.enumerateDevices
         ? function(callback) {
-            navigator.mediaDevices.enumerateDevices().then(callback, function () {
-                callback([]);
+            navigator.mediaDevices.enumerateDevices().then(
+                callback, function () {
+                    callback([]);
             });
         }
+        // Safari:
+        // "ReferenceError: Can't find variable: MediaStreamTrack"
+        // when Temasys plugin is not installed yet, have to delay this call
+        // until WebRTC is ready.
         : (MediaStreamTrack && MediaStreamTrack.getSources)
-            ? function (callback) {
-                MediaStreamTrack.getSources(function (sources) {
-                    callback(sources.map(convertMediaStreamTrackSource));
-                });
-            }
-            : undefined;
+        ? function (callback) {
+            MediaStreamTrack.getSources(function (sources) {
+                callback(sources.map(convertMediaStreamTrackSource));
+            });
+        }
+        : undefined;
+}
 
 // TODO: currently no browser supports 'devicechange' event even in nightly
 // builds so no feature/browser detection is used at all. However in future this
@@ -103,7 +117,7 @@ function setResolutionConstraints(constraints, resolution) {
  * @param {string} options.desktopStream
  * @param {string} options.cameraDeviceId
  * @param {string} options.micDeviceId
- * @param {'user'|'environment'} options.facingMode
+ * @param {CameraFacingMode} options.facingMode
  * @param {bool} firefox_fake_device
  */
 function getConstraints(um, options) {
@@ -140,12 +154,13 @@ function getConstraints(um, options) {
             // TODO: Maybe use "exact" syntax if options.facingMode is defined,
             // but this probably needs to be decided when updating other
             // constraints, as we currently don't use "exact" syntax anywhere.
+            var facingMode = options.facingMode || CameraFacingMode.USER;
+
             if (isNewStyleConstraintsSupported) {
-                constraints.video.facingMode = options.facingMode || 'user';
+                constraints.video.facingMode = facingMode;
             }
-
             constraints.video.optional.push({
-                facingMode: options.facingMode || 'user'
+                facingMode: facingMode
             });
         }
 
@@ -386,6 +401,9 @@ function onReady (options, GUM) {
     eventEmitter.emit(RTCEvents.RTC_READY, true);
     screenObtainer.init(options, GUM);
 
+    // Initialize rawEnumerateDevicesWithCallback
+    initRawEnumerateDevicesWithCallback();
+
     if (RTCUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
         rawEnumerateDevicesWithCallback(function (devices) {
             currentlyAvailableMediaDevices = devices.splice(0);
@@ -925,6 +943,7 @@ var RTCUtils = {
         var self = this;
 
         options = options || {};
+        var dsOptions = options.desktopSharingExtensionExternalInstallation;
         return new Promise(function (resolve, reject) {
             var successCallback = function (stream) {
                 resolve(handleLocalStream(stream, options.resolution));
@@ -955,7 +974,8 @@ var RTCUtils = {
 
                 if(screenObtainer.isSupported()){
                     deviceGUM["desktop"] = screenObtainer.obtainStream.bind(
-                        screenObtainer);
+                        screenObtainer,
+                        dsOptions);
                 }
                 // With FF/IE we can't split the stream into audio and video because FF
                 // doesn't support media stream constructors. So, we need to get the
@@ -1016,6 +1036,7 @@ var RTCUtils = {
                             }
                             if(hasDesktop) {
                                 screenObtainer.obtainStream(
+                                    dsOptions,
                                     function (desktopStream) {
                                         successCallback({audioVideo: stream,
                                             desktopStream: desktopStream});
@@ -1034,6 +1055,7 @@ var RTCUtils = {
                         options);
                 } else if (hasDesktop) {
                     screenObtainer.obtainStream(
+                        dsOptions,
                         function (stream) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
@@ -1055,17 +1077,51 @@ var RTCUtils = {
     isRTCReady: function () {
         return rtcReady;
     },
-    /**
-     * Checks if its possible to enumerate available cameras/micropones.
-     * @returns {boolean} true if available, false otherwise.
-     */
-    isDeviceListAvailable: function () {
+    _isDeviceListAvailable: function () {
+        if (!rtcReady)
+            throw new Error("WebRTC not ready yet");
         var isEnumerateDevicesAvailable
             = navigator.mediaDevices && navigator.mediaDevices.enumerateDevices;
         if (isEnumerateDevicesAvailable) {
             return true;
         }
-        return (MediaStreamTrack && MediaStreamTrack.getSources)? true : false;
+        return (typeof MediaStreamTrack !== "undefined" &&
+            MediaStreamTrack.getSources)? true : false;
+    },
+    /**
+     * Returns a promise which can be used to make sure that the WebRTC stack
+     * has been initialized.
+     *
+     * @returns {Promise} which is resolved only if the WebRTC stack is ready.
+     * Note that currently we do not detect stack initialization failure and
+     * the promise is never rejected(unless unexpected error occurs).
+     */
+    onRTCReady: function() {
+        if (rtcReady) {
+            return Promise.resolve();
+        } else {
+            return new Promise(function (resolve) {
+                var listener = function () {
+                    eventEmitter.removeListener(RTCEvents.RTC_READY, listener);
+                    resolve();
+                };
+                eventEmitter.addListener(RTCEvents.RTC_READY, listener);
+                // We have no failed event, so... it either resolves or nothing
+                // happens
+            });
+        }
+    },
+    /**
+     * Checks if its possible to enumerate available cameras/microphones.
+     *
+     * @returns {Promise<boolean>} a Promise which will be resolved only once
+     * the WebRTC stack is ready, either with true if the device listing is
+     * available available or with false otherwise.
+     */
+    isDeviceListAvailable: function () {
+        return this.onRTCReady().then(function() {
+            return this._isDeviceListAvailable();
+        }.bind(this));
     },
     /**
      * Returns true if changing the input (camera / microphone) or output

modules/RTC/ScreenObtainer.js

@@ -36,6 +36,19 @@ var reDetectFirefoxExtension = false;
 
 var GUM = null;
 
+/**
+ * The error returned by chrome when trying to start inline installation from
+ * popup.
+ */
+var CHROME_EXTENSION_POPUP_ERROR =
+    "Inline installs can not be initiated from pop-up windows.";
+
+/**
+ * The error message returned by chrome when the extension is installed.
+ */
+var CHROME_NO_EXTENSION_ERROR_MSG =
+    "Could not establish connection. Receiving end does not exist.";
+
 /**
  * Handles obtaining a stream from a screen capture on different browsers.
  */
@@ -52,6 +65,8 @@ var ScreenObtainer = {
      * or disable screen capture (if the value is other).
      * Note that for the "screen" media source to work the
      * 'chrome://flags/#enable-usermedia-screen-capture' flag must be set.
+     * @param options {object}
+     * @param gum {Function} GUM method
      */
     init: function(options, gum) {
         var obtainDesktopStream = null;
@@ -66,7 +81,7 @@ var ScreenObtainer = {
             (options.desktopSharingChromeMethod || options.desktopSharing);
 
         if (RTCBrowserType.isNWJS()) {
-            obtainDesktopStream = function (onSuccess, onFailure) {
+            obtainDesktopStream = function (options, onSuccess, onFailure) {
                 window.JitsiMeetNW.obtainDesktopStream (
                     onSuccess, function (error, constraints) {
                         onFailure && onFailure(new JitsiTrackError(
@@ -133,7 +148,7 @@ var ScreenObtainer = {
      * @param errorCallback
      */
     obtainScreenOnFirefox:
-           function (callback, errorCallback) {
+           function (options, callback, errorCallback) {
         var self = this;
         var extensionRequired = false;
         if (this.options.desktopSharingFirefoxMaxVersionExtRequired === -1 ||
@@ -146,7 +161,7 @@ var ScreenObtainer = {
         }
 
         if (!extensionRequired || firefoxExtInstalled === true) {
-            obtainWebRTCScreen(callback, errorCallback);
+            obtainWebRTCScreen(options, callback, errorCallback);
             return;
         }
 
@@ -186,7 +201,7 @@ var ScreenObtainer = {
      * Asks Chrome extension to call chooseDesktopMedia and gets chrome
      * 'desktop' stream for returned stream token.
      */
-    obtainScreenFromExtension: function (streamCallback, failCallback) {
+    obtainScreenFromExtension: function(options, streamCallback, failCallback) {
         var self = this;
         if (chromeExtInstalled) {
             doGetStreamFromExtension(this.options, streamCallback,
@@ -211,24 +226,60 @@ var ScreenObtainer = {
                                 streamCallback, failCallback);
                         }, 500);
                     },
-                    handleExtensionInstallationError
+                    this.handleExtensionInstallationError.bind(this,
+                        options, streamCallback, failCallback)
                 );
             } catch(e) {
-                handleExtensionInstallationError(e);
+                this.handleExtensionInstallationError(options, streamCallback,
+                    failCallback, e);
             }
         }
+    },
+    handleExtensionInstallationError: function (options, streamCallback,
+        failCallback, e) {
+        if( CHROME_EXTENSION_POPUP_ERROR === e && options.interval > 0 &&
+            typeof(options.checkAgain) === "function" &&
+            typeof(options.listener) === "function") {
+            options.listener(getWebStoreInstallUrl(this.options));
+            this.checkForChromeExtensionOnInterval(options,
+                streamCallback, failCallback, e);
+            return;
+        }
+        var msg = "Failed to install the extension from "
+            + getWebStoreInstallUrl(this.options);
 
-        function handleExtensionInstallationError(e) {
-            var msg = "Failed to install the extension from "
-                + getWebStoreInstallUrl(self.options);
-
-            logger.log(msg, e);
+        logger.log(msg, e);
 
+        failCallback(new JitsiTrackError(
+            JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
+            msg
+        ));
+    },
+    checkForChromeExtensionOnInterval: function (options,
+        streamCallback, failCallback, e) {
+        if ( CHROME_EXTENSION_POPUP_ERROR !== e &&
+            (e.name !== JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR ||
+            !e.message ||
+            e.message.message !== CHROME_NO_EXTENSION_ERROR_MSG)) {
+            this.handleExtensionInstallationError(null, streamCallback,
+                failCallback, e);
+            return;
+        }
+        if (options.checkAgain() === false) {
             failCallback(new JitsiTrackError(
-                JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
-                msg
-            ));
+                JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR));
+            return;
         }
+        var args = arguments;
+        var self = this;
+        window.setTimeout(function () {
+            doGetStreamFromExtension(self.options,
+                function () {
+                    chromeExtInstalled = true;
+                    streamCallback.apply(null, arguments);
+                }, self.checkForChromeExtensionOnInterval.bind(
+                    self, options, streamCallback, failCallback));
+        }, options.interval);
     }
 };
 
@@ -243,7 +294,7 @@ var ScreenObtainer = {
  * 'media.getusermedia.screensharing.allowed_domains' preference in
  * 'about:config'.
  */
-function obtainWebRTCScreen(streamCallback, failCallback) {
+function obtainWebRTCScreen(options, streamCallback, failCallback) {
     GUM(
         ['screen'],
         streamCallback,

modules/statistics/AnalyticsAdapter.js

@@ -0,0 +1,27 @@
+var RTCBrowserType = require("../RTC/RTCBrowserType");
+
+function NoopAnalytics() {}
+NoopAnalytics.prototype.sendEvent = function () {};
+
+function AnalyticsAdapter() {
+    this.browserActionSuffix = '.' + RTCBrowserType.getBrowserName();
+}
+
+// XXX Since we asynchronously load the integration of the analytics API and the
+// analytics API may asynchronously load its implementation (e.g. Google
+// Analytics), we cannot make the decision with respect to which analytics
+// implementation we will use here and we have to postpone it i.e. we will make
+// a lazy decision.
+AnalyticsAdapter.prototype.sendEvent = function (action, data)
+{
+    if (this.analytics === null || typeof this.analytics === 'undefined') {
+        var AnalyticsImpl = window.Analytics || NoopAnalytics;
+
+        this.analytics = new AnalyticsImpl();
+    }
+    try {
+        this.analytics.sendEvent(action + this.browserActionSuffix, data);
+    } catch (ignored) {}
+};
+
+module.exports = new AnalyticsAdapter();

modules/statistics/CallStats.js

@@ -50,11 +50,13 @@ var callStats = null;
 function initCallback (err, msg) {
     logger.log("CallStats Status: err=" + err + " msg=" + msg);
 
+    CallStats.initializeInProgress = false;
+
     // there is no lib, nothing to report to
-    if (err !== 'success')
+    if (err !== 'success') {
+        CallStats.initializeFailed = true;
         return;
-
-    CallStats.initialized = true;
+    }
 
     var ret = callStats.addNewFabric(this.peerconnection,
         Strophe.getResourceFromJid(this.session.peerjid),
@@ -64,8 +66,14 @@ function initCallback (err, msg) {
 
     var fabricInitialized = (ret.status === 'success');
 
-    if(!fabricInitialized)
+    if(!fabricInitialized) {
+        CallStats.initializeFailed = true;
         console.log("callstats fabric not initilized", ret.message);
+        return;
+    }
+
+    CallStats.initializeFailed = false;
+    CallStats.initialized = true;
 
     // notify callstats about failures if there were any
     if (CallStats.reportsQueue.length) {
@@ -145,9 +153,13 @@ var CallStats = _try_catch(function(jingleSession, Settings, options) {
         // The confID is case sensitive!!!
         this.confID = location.hostname + "/" + options.roomName;
 
+        this.callStatsID = options.callStatsID;
+        this.callStatsSecret = options.callStatsSecret;
+
+        CallStats.initializeInProgress = true;
         //userID is generated or given by the origin server
-        callStats.initialize(options.callStatsID,
-            options.callStatsSecret,
+        callStats.initialize(this.callStatsID,
+            this.callStatsSecret,
             this.userID,
             initCallback.bind(this));
 
@@ -173,6 +185,37 @@ CallStats.reportsQueue = [];
  */
 CallStats.initialized = false;
 
+/**
+ * Whether we are in progress of initializing.
+ * @type {boolean}
+ */
+CallStats.initializeInProgress = false;
+
+/**
+ * Whether we tried to initialize and it failed.
+ * @type {boolean}
+ */
+CallStats.initializeFailed = false;
+
+/**
+ * Checks whether we need to re-initialize callstats and starts the process.
+ * @private
+ */
+CallStats._checkInitialize = function () {
+    if (CallStats.initialized || !CallStats.initializeFailed
+        || !callStats || CallStats.initializeInProgress)
+        return;
+
+    // callstats object created, not initialized and it had previously failed,
+    // and there is no init in progress, so lets try initialize it again
+    CallStats.initializeInProgress = true;
+    callStats.initialize(
+        callStats.callStatsID,
+        callStats.callStatsSecret,
+        callStats.userID,
+        initCallback.bind(callStats));
+};
+
 /**
  * Type of pending reports, can be event or an error.
  * @type {{ERROR: string, EVENT: string}}
@@ -243,6 +286,7 @@ function (ssrc, isLocal, usageLabel, containerId) {
                     containerId: containerId
                 }
             });
+            CallStats._checkInitialize();
         }
     }).bind(this)();
 };
@@ -316,6 +360,7 @@ CallStats._reportEvent = function (event, eventData) {
                 type: reportType.EVENT,
                 data: {event: event, eventData: eventData}
             });
+        CallStats._checkInitialize();
     }
 };
 
@@ -393,6 +438,7 @@ CallStats._reportError = function (type, e, pc) {
             type: reportType.ERROR,
             data: { type: type, error: e, pc: pc}
         });
+        CallStats._checkInitialize();
     }
     // else just ignore it
 };
@@ -479,6 +525,8 @@ CallStats.sendApplicationLog = _try_catch(function (e, cs) {
 CallStats.dispose = function () {
     callStats = null;
     CallStats.initialized = false;
+    CallStats.initializeFailed = false;
+    CallStats.initializeInProgress = false;
 };
 
 module.exports = CallStats;

modules/statistics/statistics.js

@@ -4,6 +4,7 @@ var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTPStats = require("./RTPStatsCollector.js");
 var EventEmitter = require("events");
 var StatisticsEvents = require("../../service/statistics/Events");
+var AnalyticsAdapter = require("./AnalyticsAdapter");
 var CallStats = require("./CallStats");
 var ScriptUtil = require('../util/ScriptUtil');
 var JitsiTrackError = require("../../JitsiTrackError");
@@ -32,6 +33,24 @@ function loadCallStatsAPI() {
     // have loaded by the time we needed it (i.e. CallStats.init is invoked).
 }
 
+// Load the integration of a third-party analytics API such as Google Analytics.
+// Since we cannot guarantee the quality of the third-party service (e.g. their
+// server may take noticeably long time to respond), it is in our best interest
+// (in the sense that the intergration of the analytics API is important to us
+// but not enough to allow it to prevent people from joining a conference) to
+// download the API asynchronously. Additionally, Google Analytics will download
+// its implementation asynchronously anyway so it makes sense to append the
+// loading on our side rather than prepend it.
+function loadAnalytics(customScriptUrl) {
+    // if we have a custom script url passed as parameter we don't want to
+    // search it relatively near the library
+    ScriptUtil.loadScript(
+        customScriptUrl ? customScriptUrl : 'analytics.js',
+        /* async */ true,
+        /* prepend */ false,
+        /* relativeURL */ customScriptUrl ? false : true);
+}
+
 /**
  * Log stats via the focus once every this many milliseconds.
  */
@@ -66,6 +85,23 @@ function formatJitsiTrackErrorForCallStats(error) {
     return err;
 }
 
+/**
+ * Init statistic options
+ * @param options
+ */
+Statistics.init = function (options) {
+    Statistics.audioLevelsEnabled = !options.disableAudioLevels;
+
+    if(typeof options.audioLevelsInterval === 'number') {
+        Statistics.audioLevelsInterval = options.audioLevelsInterval;
+    }
+
+    Statistics.disableThirdPartyRequests = options.disableThirdPartyRequests;
+
+    if (Statistics.disableThirdPartyRequests !== true)
+        loadAnalytics(options.analyticsScriptUrl);
+}
+
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
@@ -76,7 +112,7 @@ function Statistics(xmpp, options) {
             // Even though AppID and AppSecret may be specified, the integration
             // of callstats.io may be disabled because of globally-disallowed
             // requests to any third parties.
-            && (this.options.disableThirdPartyRequests !== true);
+            && (Statistics.disableThirdPartyRequests !== true);
     if(this.callStatsIntegrationEnabled)
         loadCallStatsAPI();
     this.callStats = null;
@@ -88,6 +124,8 @@ function Statistics(xmpp, options) {
 }
 Statistics.audioLevelsEnabled = false;
 Statistics.audioLevelsInterval = 200;
+Statistics.disableThirdPartyRequests = false;
+Statistics.analytics = AnalyticsAdapter;
 
 /**
  * Array of callstats instances. Used to call Statistics static methods and

modules/util/ScriptUtil.js

@@ -1,3 +1,6 @@
+var currentExecutingScript = require("current-executing-script");
+
+
 /**
  * Implements utility functions which facilitate the dealing with scripts such
  * as the download and execution of a JavaScript file.
@@ -12,21 +15,38 @@ var ScriptUtil = {
      * @param prepend true to schedule the loading of the script as soon as
      * possible or false to schedule the loading of the script at the end of the
      * scripts known at the time
+     * @param relativeURL whether we need load the library from url relative
+     * to the url that lib-jitsi-meet was loaded. Useful when sourcing the
+     * library from different location than the app that is using it
      */
-    loadScript: function (src, async, prepend) {
+    loadScript: function (src, async, prepend, relativeURL) {
         var d = document;
         var tagName = 'script';
         var script = d.createElement(tagName);
         var referenceNode = d.getElementsByTagName(tagName)[0];
 
         script.async = async;
+
+        if (relativeURL) {
+            // finds the src url of the current loaded script
+            // and use it as base of the src supplied argument
+            var scriptEl = currentExecutingScript();
+            if(scriptEl) {
+                var scriptSrc = scriptEl.src;
+                var baseScriptSrc
+                    = scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);
+                if (scriptSrc && baseScriptSrc)
+                    src = baseScriptSrc + src;
+            }
+        }
+
         script.src = src;
         if (prepend) {
             referenceNode.parentNode.insertBefore(script, referenceNode);
         } else {
             referenceNode.parentNode.appendChild(script);
         }
-    },
+    }
 };
 
 module.exports = ScriptUtil;

modules/xmpp/JingleSessionPC.js

@@ -12,6 +12,7 @@ var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+var Statistics = require("../statistics/statistics");
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
@@ -132,6 +133,8 @@ JingleSessionPC.prototype.doInitialize = function () {
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
+        Statistics.analytics.sendEvent(
+            'ice.' + self.peerconnection.iceConnectionState, now);
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 
@@ -432,15 +435,34 @@ JingleSessionPC.prototype.sendSessionAccept = function (localSDP,
     // Calling tree() to print something useful
     accept = accept.tree();
     logger.info("Sending session-accept", accept);
-
+    var self = this;
     this.connection.sendIQ(accept,
         success,
-        this.newJingleErrorHandler(accept, failure),
+        this.newJingleErrorHandler(accept, function (error) {
+            failure(error);
+            // 'session-accept' is a critical timeout and we'll have to restart
+            self.room.eventEmitter.emit(XMPPEvents.SESSION_ACCEPT_TIMEOUT);
+        }),
         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();
+    //
+    // FIXME Flushing the connection at this point triggers an issue with BOSH
+    // request handling in Prosody on slow connections.
+    //
+    // The problem is that this request will be quite large and it may take time
+    // before it reaches Prosody. In the meantime Strophe may decide to send
+    // the next one. And it was observed that a small request with
+    // 'transport-info' usually follows this one. It does reach Prosody before
+    // the previous one was completely received. 'rid' on the server is
+    // increased and Prosody ignores the request with 'session-accept'. It will
+    // never reach Jicofo and everything in the request table is lost. Removing
+    // the flush does not guarantee it will never happen, but makes it much less
+    // likely('transport-info' is bundled with 'session-accept' and any
+    // immediate requests).
+    //
+    // this.connection.flush();
 };
 
 /**

modules/xmpp/strophe.jingle.js

@@ -6,7 +6,7 @@ var JingleSession = require("./JingleSessionPC");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-
+var Statistics = require("../statistics/statistics");
 
 module.exports = function(XMPP, eventEmitter) {
     Strophe.addConnectionPlugin('jingle', {
@@ -101,6 +101,8 @@ module.exports = function(XMPP, eventEmitter) {
                             .up();
                         this.terminate(sess.sid);
                     }
+                    Statistics.analytics.sendEvent(
+                        'xmpp.session-initiate', now);
                     break;
                 case 'session-terminate':
                     logger.log('terminating...', sess.sid);
@@ -114,13 +116,18 @@ module.exports = function(XMPP, eventEmitter) {
                     this.terminate(sess.sid, reasonCondition, reasonText);
                     break;
                 case 'transport-replace':
-                    logger.info("(TIME) Start transport replace",
-                                window.performance.now());
+                    var now = window.performance.now();
+                    logger.info("(TIME) Start transport replace", now);
+                    Statistics.analytics.sendEvent(
+                        'xmpp.transport-replace.start', now);
+
                     sess.replaceTransport($(iq).find('>jingle'),
                         function () {
+                            var now = window.performance.now();
                             logger.info(
-                                "(TIME) Transport replace success!",
-                                window.performance.now());
+                                "(TIME) Transport replace success!", now);
+                            Statistics.analytics.sendEvent(
+                                'xmpp.transport-replace.success', now);
                         },
                         function(error) {
                             GlobalOnErrorHandler.callErrorHandler(error);

package.json

@@ -27,7 +27,8 @@
     "jitsi-meet-logger": "git+https://github.com/jitsi/jitsi-meet-logger.git",
     "strophe": "^1.2.2",
     "strophejs-plugins": "^0.0.6",
-    "socket.io-client": "1.3.6"
+    "socket.io-client": "1.3.6",
+    "current-executing-script": "*"
   },
   "devDependencies": {
     "browserify": "11.1.x",

service/RTC/CameraFacingMode.js

@@ -0,0 +1,22 @@
+/* global module */
+/**
+ * The possible camera facing modes. For now support only 'user' and
+ * 'environment' because 'left' and 'right' are not used anywhere in our
+ * projects at the time of this writing. For more information please refer to
+ * https://w3c.github.io/mediacapture-main/getusermedia.html#def-constraint-facingMode
+ *
+ * @enum {string}
+ */
+var CameraFacingMode = {
+    /**
+     * The mode which specifies the environment-facing camera.
+     */
+    ENVIRONMENT: "environment",
+
+    /**
+     * The mode which specifies the user-facing camera.
+     */
+    USER: "user"
+};
+
+module.exports = CameraFacingMode;

service/xmpp/XMPPEvents.js

@@ -144,6 +144,17 @@ var XMPPEvents = {
      * Indicates that the local sendrecv streams in local SDP are changed.
      */
     SENDRECV_STREAMS_CHANGED: "xmpp.sendrecv_streams_changed",
+    /**
+     * Event fired when we do not get our 'session-accept' acknowledged by
+     * Jicofo. It most likely means that there is serious problem with our
+     * connection or XMPP server and we should reload the conference.
+     *
+     * We have seen that to happen in BOSH requests race condition when the BOSH
+     * request table containing the 'session-accept' was discarded by Prosody.
+     * Jicofo does send the RESULT immediately without any condition, so missing
+     * packets means that most likely it has never seen our IQ.
+     */
+    SESSION_ACCEPT_TIMEOUT: "xmpp.session_accept_timeout",
     // TODO: only used in a hack, should probably be removed.
     SET_LOCAL_DESCRIPTION_ERROR: 'xmpp.set_local_description_error',