Moves loading of analytics in the library.

JitsiConference.js

 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var JitsiParticipant = require("./JitsiParticipant");
 var Statistics = require("./modules/statistics/statistics");
-var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
         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
         });
     }
     // Accept incoming call
     this.room.setJingleSession(jingleSession);
     this.room.connectionTimes["session.initiate"] = now;
-    AnalyticsAdapter.sendEvent("muc.idle",
+    Statistics.analytics.sendEvent("muc.idle",
         (now - this.room.connectionTimes["muc.joined"]));
     try{
         jingleSession.initialize(false /* initiator */,this.room);

JitsiConferenceEventManager.js

 var AuthenticationEvents =
     require("./service/authentication/AuthenticationEvents");
 var Statistics = require("./modules/statistics/statistics");
-var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var MediaType = require("./service/RTC/MediaType");
 
 /**
         {
             for (var ckey in chatRoom.connectionTimes){
                 var cvalue = chatRoom.connectionTimes[ckey];
-                AnalyticsAdapter.sendEvent('conference.' + ckey, cvalue);
+                Statistics.analytics.sendEvent('conference.' + ckey, cvalue);
             }
             for (var xkey in chatRoom.xmpp.connectionTimes){
                 var xvalue = chatRoom.xmpp.connectionTimes[xkey];
-                AnalyticsAdapter.sendEvent('xmpp.' + xkey, xvalue);
+                Statistics.analytics.sendEvent('xmpp.' + xkey, xvalue);
             }
         });
 
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
     chatRoom.addListener(XMPPEvents.BRIDGE_DOWN,
         function (){
-            AnalyticsAdapter.sendEvent('conference.bridgeDown');
+            Statistics.analytics.sendEvent('conference.bridgeDown');
         });
 
     this.chatRoomForwarder.forward(XMPPEvents.RESERVATION_ERROR,
 
     chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
         function () {
-            AnalyticsAdapter.sendEvent('conference.focusLeft');
+            Statistics.analytics.sendEvent('conference.focusLeft');
             if(!conference.connection._reload())
                 conference.eventEmitter.emit(
                     JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceEvents.CONNECTION_INTERRUPTED);
     chatRoom.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
         function () {
-            AnalyticsAdapter.sendEvent('connection.interrupted');
+            Statistics.analytics.sendEvent('connection.interrupted');
         });
 
     this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
-        AnalyticsAdapter.sendEvent('conference.dataChannel.open', now);
+        Statistics.analytics.sendEvent('conference.dataChannel.open', now);
     });
 
     this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,

JitsiConnection.js

 var XMPP = require("./modules/xmpp/xmpp");
 var JitsiConnectionEvents = require("./JitsiConnectionEvents");
 var JitsiConnectionErrors = require("./JitsiConnectionErrors");
-var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
         function (errType, msg) {
-            AnalyticsAdapter.sendEvent('connection.failed.' + errType);
+            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
             // and then there are no msgs, but we want to log only disconnects
             // when there is real error
             if(msg)
-                AnalyticsAdapter.sendEvent('connection.disconnected.' + msg);
+                Statistics.analytics.sendEvent(
+                    'connection.disconnected.' + msg);
         });
 }
 
 JitsiConnection.prototype._reload = function () {
     if(this.retryOnFail === 0)
         return false;
-    AnalyticsAdapter.sendEvent('connection.reload');
+    Statistics.analytics.sendEvent('connection.reload');
     this.retryOnFail--;
     var states = {};
     for(var name in this.conferences) {

JitsiMeetJS.js

 var RTC = require("./modules/RTC/RTC");
 var RTCUIHelper = require("./modules/RTC/RTCUIHelper");
 var Statistics = require("./modules/statistics/statistics");
-var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var Resolutions = require("./service/RTC/Resolutions");
 var ScriptUtil = require("./modules/util/ScriptUtil");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
-    analytics: AnalyticsAdapter,
+    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(

doc/API.md

     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.
 
 * ```JitsiMeetJS.JitsiConnection``` - the ```JitsiConnection``` constructor. You can use that to create new server connection.
 
         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/JitsiRemoteTrack.js

 var JitsiTrack = require("./JitsiTrack");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
 var RTCBrowserType = require("./RTCBrowserType");
-var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
 
 var ttfmTrackerAudioAttached = false;
 var ttfmTrackerVideoAttached = false;
             - this.conference.getConnectionTimes()["muc.joined"]);
         this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
         console.log("(TIME) TTFM " + type + ":\t", ttfm);
-        AnalyticsAdapter.sendEvent(type +'.ttfm', ttfm);
+        Statistics.analytics.sendEvent(type +'.ttfm', ttfm);
     }.bind(this));
 };
 

modules/statistics/AnalyticsAdapter.js

 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.
-
-function AnalyticsAdapter() {
-    this.browserActionSuffix = '.' + RTCBrowserType.getBrowserName();
-}
-
 AnalyticsAdapter.prototype.sendEvent = function (action, data)
 {
-    var a = this.analytics;
-
-    if (a === null || typeof a === 'undefined') {
+    if (this.analytics === null || typeof this.analytics === 'undefined') {
         var AnalyticsImpl = window.Analytics || NoopAnalytics;
 
-        this.analytics = a = new AnalyticsImpl();
+        this.analytics = new AnalyticsImpl();
     }
     try {
-        a.sendEvent(action + this.browserActionSuffix, data);
+        this.analytics.sendEvent(action + this.browserActionSuffix, data);
     } catch (ignored) {}
 };
 

modules/statistics/statistics.js

 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");
     // 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() {
+    JitsiMeetJS.util.ScriptUtil.loadScript(
+        'analytics.js?v=1',
+        /* async */ true,
+        /* prepend */ false);
+}
+
 /**
  * Log stats via the focus once every this many milliseconds.
  */
     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();
+}
+
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
             // 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;
 }
 Statistics.audioLevelsEnabled = false;
 Statistics.audioLevelsInterval = 200;
+Statistics.disableThirdPartyRequests = false;
+Statistics.analytics = AnalyticsAdapter;
 
 /**
  * Array of callstats instances. Used to call Statistics static methods and

modules/xmpp/JingleSessionPC.js

 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
+var Statistics = require("../statistics/statistics");
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
-        AnalyticsAdapter.sendEvent(
+        Statistics.analytics.sendEvent(
             'ice.' + self.peerconnection.iceConnectionState, now);
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':

modules/xmpp/strophe.jingle.js

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