Merge pull request #150 from jitsi/cs-devices-2

Logs active devices to callstats (updated).

JitsiConference.js

@@ -331,6 +331,16 @@ JitsiConference.prototype.addTrack = function (track) {
     this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
         track.ssrcHandler);
 
+    // Report active device to statistics
+    var devices = RTC.getCurrentlyAvailableMediaDevices();
+    device = devices.find(function (d) {
+        return d.kind === track.getTrack().kind + 'input'
+            && d.label === track.getTrack().label;
+    });
+
+    Statistics.sendАctiveDeviceListEvent(
+        RTC.getEventDataForActiveDevice(device));
+
     return new Promise(function (resolve, reject) {
         this.room.addStream(track.getOriginalStream(), function () {
             if (track.isVideoTrack()) {
@@ -1088,6 +1098,16 @@ function setupListeners(conference) {
 
     conference.room.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
         conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED, conference.myUserId(), role);
+
+        // log all events for the recorder operated by the moderator
+        if (conference.statistics && conference.isModerator()) {
+            conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
+                function (status, error) {
+                    Statistics.sendLog(
+                        "[Recorder] status: " + status
+                            + (error? " error: " + error : ""));
+                });
+        }
     });
     conference.room.addListener(XMPPEvents.MUC_ROLE_CHANGED, conference.onUserRoleChanged.bind(conference));
 
@@ -1341,14 +1361,6 @@ function setupListeners(conference) {
                 conference.statistics.sendMuteEvent(track.isMuted(), type);
             });
 
-        // log all events for the recorder operated by the moderator
-        if (conference.isModerator()) {
-            conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
-                function (status, error) {
-                    conference.statistics.sendLog("Recorder: " + status);
-                });
-        }
-
         conference.room.addListener(XMPPEvents.CREATE_OFFER_FAILED, function (e, pc) {
             conference.statistics.sendCreateOfferFailed(e, pc);
         });

JitsiMediaDevices.js

@@ -3,6 +3,7 @@ var RTCEvents = require('./service/RTC/RTCEvents');
 var RTC = require("./modules/RTC/RTC");
 var MediaType = require('./service/RTC/MediaType');
 var JitsiMediaDevicesEvents = require('./JitsiMediaDevicesEvents');
+var Statistics = require("./modules/statistics/statistics");
 
 var eventEmitter = new EventEmitter();
 
@@ -11,6 +12,28 @@ RTC.addListener(RTCEvents.DEVICE_LIST_CHANGED,
         eventEmitter.emit(JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED, devices);
     });
 
+RTC.addListener(RTCEvents.DEVICE_LIST_AVAILABLE,
+    function (devices) {
+        // log output device
+        logOutputDevice(
+            JitsiMediaDevices.getAudioOutputDevice(),
+            devices);
+    });
+
+/**
+ * Gathers data and sends it to statistics.
+ * @param deviceID the device id to log
+ * @param devices list of devices
+ */
+function logOutputDevice (deviceID, devices) {
+    var device = devices.find(function (d) {
+        return d.kind === 'audiooutput' && d.deviceId === deviceID;
+    });
+
+    Statistics.sendАctiveDeviceListEvent(
+        RTC.getEventDataForActiveDevice(device));
+}
+
 var JitsiMediaDevices = {
     /**
      * Executes callback with list of media devices connected.
@@ -71,6 +94,15 @@ var JitsiMediaDevices = {
      *      otherwise
      */
     setAudioOutputDevice: function (deviceId) {
+
+        if (RTC.getCurrentlyAvailableMediaDevices().length > 0)
+        {
+            // if we have devices info report device to stats
+            // normally this will not happen on startup as this method is called
+            // too early. This will happen only on user selection of new device
+            logOutputDevice(deviceId, RTC.getCurrentlyAvailableMediaDevices());
+        }
+
         return RTC.setAudioOutputDevice(deviceId);
     },
     /**

modules/RTC/RTC.js

@@ -345,6 +345,23 @@ RTC.getAudioOutputDevice = function () {
     return RTCUtils.getAudioOutputDevice();
 };
 
+/**
+ * Returns list of available media devices if its obtained, otherwise an
+ * empty array is returned/
+ * @returns {Array} list of available media devices.
+ */
+RTC.getCurrentlyAvailableMediaDevices = function () {
+    return RTCUtils.getCurrentlyAvailableMediaDevices();
+};
+
+/**
+ * Returns event data for device to be reported to stats.
+ * @returns {MediaDeviceInfo} device.
+ */
+RTC.getEventDataForActiveDevice = function (device) {
+    return RTCUtils.getEventDataForActiveDevice(device);
+};
+
 /**
  * Sets current audio output device.
  * @param {string} deviceId - id of 'audiooutput' device from

modules/RTC/RTCUtils.js

@@ -386,12 +386,24 @@ function onReady (options, GUM) {
     eventEmitter.emit(RTCEvents.RTC_READY, true);
     screenObtainer.init(options, GUM);
 
-    if (isDeviceChangeEventSupported && RTCUtils.isDeviceListAvailable()) {
-        navigator.mediaDevices.addEventListener('devicechange', function () {
-            RTCUtils.enumerateDevices(onMediaDevicesListChanged);
+    if (RTCUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
+        rawEnumerateDevicesWithCallback(function (devices) {
+            currentlyAvailableMediaDevices = devices.splice(0);
+
+            eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
+                currentlyAvailableMediaDevices);
+
+            if (isDeviceChangeEventSupported) {
+                navigator.mediaDevices.addEventListener(
+                    'devicechange',
+                    function () {
+                        RTCUtils.enumerateDevices(
+                            onMediaDevicesListChanged);
+                    });
+            } else {
+                pollForAvailableMediaDevices();
+            }
         });
-    } else if (RTCUtils.isDeviceListAvailable()) {
-        pollForAvailableMediaDevices();
     }
 }
 
@@ -1207,6 +1219,31 @@ var RTCUtils = {
      */
     getAudioOutputDevice: function () {
         return audioOutputDeviceId;
+    },
+
+    /**
+     * Returns list of available media devices if its obtained, otherwise an
+     * empty array is returned/
+     * @returns {Array} list of available media devices.
+     */
+    getCurrentlyAvailableMediaDevices: function () {
+        return currentlyAvailableMediaDevices;
+    },
+
+    /**
+     * Returns event data for device to be reported to stats.
+     * @returns {MediaDeviceInfo} device.
+     */
+    getEventDataForActiveDevice: function (device) {
+        var devices = [];
+        var deviceData = {
+            "deviceId": device.deviceId,
+            "kind":     device.kind,
+            "label":    device.label,
+            "groupId":  device.groupId
+        };
+        devices.push(deviceData);
+        return { deviceList: devices };
     }
 };
 

modules/statistics/CallStats.js

@@ -20,7 +20,7 @@ var wrtcFuncNames = {
     getUserMedia:         "getUserMedia",
     iceConnectionFailure: "iceConnectionFailure",
     signalingError:       "signalingError",
-    applicationError:     "applicationError"
+    applicationLog:       "applicationLog"
 };
 
 /**
@@ -41,7 +41,8 @@ var fabricEvent = {
     fabricTerminated:"fabricTerminated",
     screenShareStart:"screenShareStart",
     screenShareStop:"screenShareStop",
-    dominantSpeaker:"dominantSpeaker"
+    dominantSpeaker:"dominantSpeaker",
+    activeDeviceList:"activeDeviceList"
 };
 
 var callStats = null;
@@ -53,20 +54,47 @@ function initCallback (err, msg) {
     if (err !== 'success')
         return;
 
+    CallStats.initialized = true;
+
+    var ret = callStats.addNewFabric(this.peerconnection,
+        Strophe.getResourceFromJid(this.session.peerjid),
+        callStats.fabricUsage.multiplex,
+        this.confID,
+        this.pcCallback.bind(this));
+
+    var fabricInitialized = (ret.status === 'success');
+
+    if(!fabricInitialized)
+        console.log("callstats fabric not initilized", ret.message);
+
     // notify callstats about failures if there were any
     if (CallStats.reportsQueue.length) {
         CallStats.reportsQueue.forEach(function (report) {
-            if (report.type === reportType.ERROR)
-            {
+            if (report.type === reportType.ERROR) {
                 var error = report.data;
                 CallStats._reportError.call(this, error.type, error.error,
                     error.pc);
             }
-            else if (report.type === reportType.EVENT)
-            {
-                var data = report.data;
+            // if we have and event to report and we failed to add fabric
+            // this event will not be reported anyway, returning an error
+            else if (report.type === reportType.EVENT
+                && fabricInitialized) {
+                var eventData = report.data;
                 callStats.sendFabricEvent(
-                    this.peerconnection, data.event, this.confID);
+                    this.peerconnection,
+                    eventData.event,
+                    this.confID,
+                    eventData.eventData);
+            } else if (report.type === reportType.MST_WITH_USERID) {
+                var data = report.data;
+                callStats.associateMstWithUserID(
+                    this.peerconnection,
+                    data.callStatsId,
+                    this.confID,
+                    data.ssrc,
+                    data.usageLabel,
+                    data.containerId
+                );
             }
         }, this);
         CallStats.reportsQueue.length = 0;
@@ -123,11 +151,6 @@ var CallStats = _try_catch(function(jingleSession, Settings, options) {
             this.userID,
             initCallback.bind(this));
 
-        callStats.addNewFabric(this.peerconnection,
-            Strophe.getResourceFromJid(jingleSession.peerjid),
-            callStats.fabricUsage.multiplex,
-            this.confID,
-            this.pcCallback.bind(this));
     } catch (e) {
         // The callstats.io API failed to initialize (e.g. because its
         // download failed to succeed in general or on time). Further
@@ -143,13 +166,21 @@ var CallStats = _try_catch(function(jingleSession, Settings, options) {
 // and send them to callstats on init
 CallStats.reportsQueue = [];
 
+/**
+ * Whether the library was successfully initialized using its initialize method.
+ * And whether we had successfully called addNewFabric.
+ * @type {boolean}
+ */
+CallStats.initialized = false;
+
 /**
  * Type of pending reports, can be event or an error.
  * @type {{ERROR: string, EVENT: string}}
  */
 var reportType = {
     ERROR: "error",
-    EVENT: "event"
+    EVENT: "event",
+    MST_WITH_USERID: "mstWithUserID"
 };
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
@@ -162,6 +193,7 @@ CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
 /**
  * Lets CallStats module know where is given SSRC rendered by providing renderer
  * tag ID.
+ * If the lib is not initialized yet queue the call for later, when its ready.
  * @param ssrc {number} the SSRC of the stream
  * @param isLocal {boolean} <tt>true<tt> if this stream is local or
  *        <tt>false</tt> otherwise.
@@ -191,14 +223,27 @@ function (ssrc, isLocal, usageLabel, containerId) {
             usageLabel,
             containerId
         );
-        callStats.associateMstWithUserID(
-            this.peerconnection,
-            callStatsId,
-            this.confID,
-            ssrc,
-            usageLabel,
-            containerId
-        );
+        if(CallStats.initialized) {
+            callStats.associateMstWithUserID(
+                this.peerconnection,
+                callStatsId,
+                this.confID,
+                ssrc,
+                usageLabel,
+                containerId
+            );
+        }
+        else {
+            CallStats.reportsQueue.push({
+                type: reportType.MST_WITH_USERID,
+                data: {
+                    callStatsId: callStatsId,
+                    ssrc: ssrc,
+                    usageLabel: usageLabel,
+                    containerId: containerId
+                }
+            });
+        }
     }).bind(this)();
 };
 
@@ -206,6 +251,7 @@ function (ssrc, isLocal, usageLabel, containerId) {
  * Notifies CallStats for mute events
  * @param mute {boolean} true for muted and false for not muted
  * @param type {String} "audio"/"video"
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendMuteEvent = _try_catch(function (mute, type, cs) {
 
@@ -224,6 +270,7 @@ CallStats.sendMuteEvent = _try_catch(function (mute, type, cs) {
  * Notifies CallStats for screen sharing events
  * @param start {boolean} true for starting screen sharing and
  * false for not stopping
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendScreenSharingEvent = _try_catch(function (start, cs) {
 
@@ -233,6 +280,7 @@ CallStats.sendScreenSharingEvent = _try_catch(function (start, cs) {
 
 /**
  * Notifies CallStats that we are the new dominant speaker in the conference.
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendDominantSpeakerEvent = _try_catch(function (cs) {
 
@@ -240,21 +288,33 @@ CallStats.sendDominantSpeakerEvent = _try_catch(function (cs) {
         fabricEvent.dominantSpeaker);
 });
 
+/**
+ * Notifies CallStats about active device.
+ * @param {{deviceList: {String:String}}} list of devices with their data
+ * @param {CallStats} cs callstats instance related to the event
+ */
+CallStats.sendАctiveDeviceListEvent = _try_catch(function (devicesData, cs) {
+
+    CallStats._reportEvent.call(cs, fabricEvent.activeDeviceList, devicesData);
+});
+
 /**
  * Reports an error to callstats.
  *
  * @param type the type of the error, which will be one of the wrtcFuncNames
  * @param e the error
  * @param pc the peerconnection
+ * @param eventData additional data to pass to event
  * @private
  */
-CallStats._reportEvent = function (event) {
-    if (callStats) {
-        callStats.sendFabricEvent(this.peerconnection, event, this.confID);
+CallStats._reportEvent = function (event, eventData) {
+    if (CallStats.initialized) {
+        callStats.sendFabricEvent(
+            this.peerconnection, event, this.confID, eventData);
     } else {
         CallStats.reportsQueue.push({
                 type: reportType.EVENT,
-                data: {event: event}
+                data: {event: event, eventData: eventData}
             });
     }
 };
@@ -263,7 +323,7 @@ CallStats._reportEvent = function (event) {
  * Notifies CallStats for connection setup errors
  */
 CallStats.prototype.sendTerminateEvent = _try_catch(function () {
-    if(!callStats) {
+    if(!CallStats.initialized) {
         return;
     }
     callStats.sendFabricEvent(this.peerconnection,
@@ -289,7 +349,7 @@ CallStats.prototype.sendIceConnectionFailedEvent = _try_catch(function (pc, cs){
  */
 CallStats.prototype.sendFeedback = _try_catch(
 function(overallFeedback, detailedFeedback) {
-    if(!callStats) {
+    if(!CallStats.initialized) {
         return;
     }
     var feedbackString =    '{"userID":"' + this.userID + '"' +
@@ -314,7 +374,7 @@ CallStats._reportError = function (type, e, pc) {
         logger.warn("No error is passed!");
         e = new Error("Unknown error");
     }
-    if (callStats) {
+    if (CallStats.initialized) {
         callStats.reportError(pc, this.confID, type, e);
     } else {
         CallStats.reportsQueue.push({
@@ -391,15 +451,14 @@ CallStats.sendAddIceCandidateFailed = _try_catch(function (e, pc, cs) {
 });
 
 /**
- * Notifies CallStats that there is an unhandled error on the page.
+ * Notifies CallStats that there is a log we want to report.
  *
- * @param {Error} e error to send
- * @param {RTCPeerConnection} pc connection on which failure occured.
+ * @param {Error} e error to send or {String} message
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendUnhandledError = _try_catch(function (e, cs) {
+CallStats.sendApplicationLog = _try_catch(function (e, cs) {
     CallStats._reportError
-        .call(cs, wrtcFuncNames.applicationError, e, null);
+        .call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 
 module.exports = CallStats;

modules/statistics/statistics.js

@@ -251,6 +251,20 @@ Statistics.prototype.sendDominantSpeakerEvent = function () {
         CallStats.sendDominantSpeakerEvent(this.callstats);
 };
 
+/**
+ * Notifies about active device.
+ * @param {{deviceList: {String:String}}} list of devices with their data
+ */
+Statistics.sendАctiveDeviceListEvent = function (devicesData) {
+    if (Statistics.callsStatsInstances.length) {
+        Statistics.callsStatsInstances.forEach(function (cs) {
+            CallStats.sendАctiveDeviceListEvent(devicesData, cs);
+        });
+    } else {
+        CallStats.sendАctiveDeviceListEvent(devicesData, null);
+    }
+};
+
 /**
  * Lets the underlying statistics module know where is given SSRC rendered by
  * providing renderer tag ID.
@@ -350,40 +364,20 @@ Statistics.prototype.sendAddIceCandidateFailed = function (e, pc) {
 };
 
 /**
- * Notifies CallStats that there is unhandled exception.
+ * Adds to CallStats an application log.
  *
- * @param {Error} e error to send
+ * @param {String} a log message to send or an {Error} object to be reported
  */
-Statistics.sendUnhandledError = function (e) {
+Statistics.sendLog = function (m) {
     if (Statistics.callsStatsInstances.length) {
         Statistics.callsStatsInstances.forEach(function (cs) {
-            CallStats.sendUnhandledError(e, cs);
+            CallStats.sendApplicationLog(m, cs);
         });
     } else {
-        CallStats.sendUnhandledError(e, null);
+        CallStats.sendApplicationLog(m, null);
     }
 };
 
-/**
- * Adds to CallStats an application log.
- *
- * @param {String} a log message to send
- */
-Statistics.sendLog = function (m) {
-    // uses  the same field for cs stat as unhandled error
-    Statistics.sendUnhandledError(m);
-};
-
-/**
- * Adds to CallStats an application log.
- *
- * @param {String} a log message to send
- */
-Statistics.prototype.sendLog = function (m) {
-    // uses  the same field for cs stat as unhandled error
-    CallStats.sendUnhandledError(m, this.callstats);
-};
-
 /**
  * Sends the given feedback through CallStats.
  *
@@ -406,7 +400,7 @@ Statistics.reportGlobalError = function (error) {
     if (error instanceof JitsiTrackError && error.gum) {
         Statistics.sendGetUserMediaFailed(error);
     } else {
-        Statistics.sendUnhandledError(error);
+        Statistics.sendLog(error);
     }
 };
 

service/RTC/RTCEvents.js

@@ -7,7 +7,8 @@ var RTCEvents = {
     AVAILABLE_DEVICES_CHANGED: "rtc.available_devices_changed",
     TRACK_ATTACHED: "rtc.track_attached",
     AUDIO_OUTPUT_DEVICE_CHANGED: "rtc.audio_output_device_changed",
-    DEVICE_LIST_CHANGED: "rtc.device_list_changed"
+    DEVICE_LIST_CHANGED: "rtc.device_list_changed",
+    DEVICE_LIST_AVAILABLE: "rtc.device_list_available"
 };
 
 module.exports = RTCEvents;