Merge pull request #137 from jitsi/cs-refactor

Refactor callstats removing improve static calls to Statistics.

JitsiConference.js

         roomName: this.options.name
     });
     setupListeners(this);
-    var JitsiMeetJS = this.connection.JitsiMeetJS;
-    JitsiMeetJS._gumFailedHandler.push(function(error) {
-        this.statistics.sendGetUserMediaFailed(error);
-    }.bind(this));
-    JitsiMeetJS._globalOnErrorHandler.push(
-        Statistics.reportGlobalError.bind(this.statistics));
     this.participants = {};
     this.lastDominantSpeaker = null;
     this.dtmfManager = null;
         video: undefined
     };
     this.isMutedByFocus = false;
-
-    // Lets send some general stats useful for debugging problems
-    if (window.jitsiRegionInfo
-            && Object.keys(window.jitsiRegionInfo).length > 0) {
-        // remove quotes to make it prettier
-        Statistics.sendLog(
-            JSON.stringify(window.jitsiRegionInfo).replace(/\"/g, ""));
-    }
-
-    if(JitsiMeetJS.version)
-        Statistics.sendLog("LibJitsiMeet:" + JitsiMeetJS.version);
 }
 
 /**

JitsiConnection.js

 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
  * JitsiConference interface.
- * @param JitsiMeetJS the JitsiMeetJS instance which is initializing the new
- * JitsiConnection instance
  * @param appID identification for the provider of Jitsi Meet video conferencing services.
  * @param token the JWT token used to authenticate with the server(optional)
  * @param options Object with properties / settings related to connection with the server.
  * @constructor
  */
-function JitsiConnection(JitsiMeetJS, appID, token, options) {
-    /**
-     * The {JitsiMeetJS} instance which has initialized this {JitsiConnection}
-     * instance.
-     * @public
-     */
-    this.JitsiMeetJS = JitsiMeetJS;
+function JitsiConnection(appID, token, options) {
     this.appID = appID;
     this.token = token;
     this.options = options;

JitsiMeetJS.js

 
     version: '{#COMMIT_HASH#}',
 
+    JitsiConnection: JitsiConnection,
     events: {
         conference: JitsiConferenceEvents,
         connection: JitsiConnectionEvents,
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
-    /**
-     * Array of functions that will receive the GUM error.
-     */
-    _gumFailedHandler: [],
     init: function (options) {
         Statistics.audioLevelsEnabled = !options.disableAudioLevels;
 
                 this.getGlobalOnErrorHandler.bind(this));
         }
 
+        // Lets send some general stats useful for debugging problems
+        if (window.jitsiRegionInfo
+            && Object.keys(window.jitsiRegionInfo).length > 0) {
+            // remove quotes to make it prettier
+            Statistics.sendLog(
+                JSON.stringify(window.jitsiRegionInfo).replace(/\"/g, ""));
+        }
+
+        if(JitsiMeetJS.version)
+            Statistics.sendLog("LibJitsiMeet:" + JitsiMeetJS.version);
+
         return RTC.init(options || {});
     },
     /**
                     }
                 return tracks;
             }).catch(function (error) {
-                this._gumFailedHandler.forEach(function (handler) {
-                    handler(error);
-                });
-
-                if(!this._gumFailedHandler.length) {
-                    Statistics.sendGetUserMediaFailed(error);
-                }
+                Statistics.sendGetUserMediaFailed(error);
 
                 if(error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {
                     var oldResolution = options.resolution || '360',
             'JitsiMeetJS.mediaDevices.enumerateDevices instead');
         this.mediaDevices.enumerateDevices(callback);
     },
-    /**
-     * Array of functions that will receive the unhandled errors.
-     */
-    _globalOnErrorHandler: [],
     /**
      * @returns function that can be used to be attached to window.onerror and
      * if options.enableWindowOnErrorHandler is enabled returns
             'Line: ' + lineno,
             'Column: ' + colno,
             'StackTrace: ', error);
-        var globalOnErrorHandler = this._globalOnErrorHandler;
-        if (globalOnErrorHandler.length) {
-          globalOnErrorHandler.forEach(function (handler) {
-              handler(error);
-          });
-        } else {
-            Statistics.reportGlobalError(error);
-        }
+        Statistics.reportGlobalError(error);
     },
 
     /**
     }
 };
 
-// XXX JitsiConnection or the instances it initializes and is associated with
-// (e.g. JitsiConference) may need a reference to LibJitsiMeet (aka
-// JitsiMeetJS). An approach could be to declare LibJitsiMeet global (which is
-// what we do in Jitsi Meet) but that could be seen as not such a cool decision
-// certainly looks even worse within the lib-jitsi-meet library itself. That's
-// why the decision is to provide LibJitsiMeet as a parameter of
-// JitsiConnection.
-LibJitsiMeet.JitsiConnection = JitsiConnection.bind(null, LibJitsiMeet);
-
 // expose JitsiTrackError this way to give library consumers to do checks like
 // if (error instanceof JitsiMeetJS.JitsiTrackError) { }
 LibJitsiMeet.JitsiTrackError = JitsiTrackError;

modules/statistics/statistics.js

 }
 Statistics.audioLevelsEnabled = false;
 
+/**
+ * Array of callstats instances. Used to call Statistics static methods and
+ * send stats to all cs instances.
+ */
+Statistics.callsStatsInstances = [];
+
 Statistics.prototype.startRemoteStats = function (peerconnection) {
     if(!Statistics.audioLevelsEnabled)
         return;
 Statistics.prototype.startCallStats = function (session, settings) {
     if(this.callStatsIntegrationEnabled && !this.callstats) {
         this.callstats = new CallStats(session, settings, this.options);
+        Statistics.callsStatsInstances.push(this.callstats);
     }
 };
 
  *
  * @param {Error} e error to send
  */
-Statistics.prototype.sendGetUserMediaFailed = function (e) {
-    if(this.callstats) {
+Statistics.sendGetUserMediaFailed = function (e) {
+
+    if (Statistics.callsStatsInstances.length) {
+        Statistics.callsStatsInstances.forEach(function (cs) {
+            CallStats.sendGetUserMediaFailed(
+                e instanceof JitsiTrackError
+                    ? formatJitsiTrackErrorForCallStats(e)
+                    : e,
+                cs);
+        });
+    } else {
         CallStats.sendGetUserMediaFailed(
             e instanceof JitsiTrackError
                 ? formatJitsiTrackErrorForCallStats(e)
                 : e,
-            this.callstats);
+            null);
     }
 };
 
-/**
- * Notifies CallStats that getUserMedia failed.
- *
- * @param {Error} e error to send
- */
-Statistics.sendGetUserMediaFailed = function (e) {
-    CallStats.sendGetUserMediaFailed(
-        e instanceof JitsiTrackError
-            ? formatJitsiTrackErrorForCallStats(e)
-            : e,
-        null);
-};
-
 /**
  * Notifies CallStats that peer connection failed to create offer.
  *
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
 };
 
-/**
- * Notifies CallStats that there is an unhandled error on the page.
- *
- * @param {Error} e error to send
- * @param {RTCPeerConnection} pc connection on which failure occured.
- */
-Statistics.prototype.sendUnhandledError = function (e) {
-    if(this.callstats)
-        CallStats.sendUnhandledError(e, this.callstats);
-};
-
 /**
  * Notifies CallStats that there is unhandled exception.
  *
  * @param {Error} e error to send
  */
 Statistics.sendUnhandledError = function (e) {
-    CallStats.sendUnhandledError(e, null);
+    if (Statistics.callsStatsInstances.length) {
+        Statistics.callsStatsInstances.forEach(function (cs) {
+            CallStats.sendUnhandledError(e, cs);
+        });
+    } else {
+        CallStats.sendUnhandledError(e, null);
+    }
 };
 
 /**
  */
 Statistics.sendLog = function (m) {
     // uses  the same field for cs stat as unhandled error
-    CallStats.sendUnhandledError(m, null);
+    Statistics.sendUnhandledError(m);
 };
 
 /**
  */
 Statistics.reportGlobalError = function (error) {
     if (error instanceof JitsiTrackError && error.gum) {
-        this.sendGetUserMediaFailed(error);
+        Statistics.sendGetUserMediaFailed(error);
     } else {
-        this.sendUnhandledError(error);
+        Statistics.sendUnhandledError(error);
     }
 };