Merge branch 'master' into audio_problem_detection

JitsiConference.js

@@ -309,17 +309,27 @@ JitsiConference.prototype.setSubject = function (subject) {
  * Adds JitsiLocalTrack object to the conference.
  * @param track the JitsiLocalTrack object.
  * @returns {Promise<JitsiLocalTrack>}
- * @throws will throw and error if track is video track
- * and there is already another video track in the conference.
+ * @throws {Error} if the specified track is a video track and there is already
+ * another video track in the conference.
  */
 JitsiConference.prototype.addTrack = function (track) {
-    if(track.disposed)
-    {
+    if (track.disposed) {
         throw new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED);
     }
 
-    if (track.isVideoTrack() && this.rtc.getLocalVideoTrack()) {
-        throw new Error("cannot add second video track to the conference");
+    if (track.isVideoTrack()) {
+        // Ensure there's exactly 1 local video track in the conference.
+        var localVideoTrack = this.rtc.getLocalVideoTrack();
+        if (localVideoTrack) {
+            // Don't be excessively harsh and severe if the API client happens
+            // to attempt to add the same local video track twice.
+            if (track === localVideoTrack) {
+                return Promise.resolve(track);
+            } else {
+                throw new Error(
+                        "cannot add second video track to the conference");
+            }
+        }
     }
 
     track.ssrcHandler = function (conference, ssrcMap) {
@@ -332,6 +342,18 @@ JitsiConference.prototype.addTrack = function (track) {
     this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
         track.ssrcHandler);
 
+    if(track.isAudioTrack() || (track.isVideoTrack() &&
+        track.videoType !== "desktop")) {
+        // 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;
+        });
+        if(device)
+            Statistics.sendActiveDeviceListEvent(
+                RTC.getEventDataForActiveDevice(device));
+    }
     return new Promise(function (resolve, reject) {
         this.room.addStream(track.getOriginalStream(), function () {
             if (track.isVideoTrack()) {
@@ -1146,6 +1168,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));
 
@@ -1404,14 +1436,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,30 @@ 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;
+    });
+
+    if (device) {
+        Statistics.sendActiveDeviceListEvent(
+            RTC.getEventDataForActiveDevice(device));
+    }
+}
+
 var JitsiMediaDevices = {
     /**
      * Executes callback with list of media devices connected.
@@ -71,6 +96,16 @@ var JitsiMediaDevices = {
      *      otherwise
      */
     setAudioOutputDevice: function (deviceId) {
+
+        var availableDevices = RTC.getCurrentlyAvailableMediaDevices();
+        if (availableDevices && availableDevices.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);
     },
     /**

JitsiMeetJS.js

@@ -60,6 +60,9 @@ var LibJitsiMeet = {
         recorder: JitsiRecorderErrors,
         track: JitsiTrackErrors
     },
+    errorTypes: {
+        JitsiTrackError: JitsiTrackError
+    },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
     init: function (options) {
@@ -237,10 +240,6 @@ var LibJitsiMeet = {
     }
 };
 
-// expose JitsiTrackError this way to give library consumers to do checks like
-// if (error instanceof JitsiMeetJS.JitsiTrackError) { }
-LibJitsiMeet.JitsiTrackError = JitsiTrackError;
-
 //Setups the promise object.
 window.Promise = window.Promise || require("es6-promise").Promise;
 

doc/API.md

@@ -171,6 +171,9 @@ JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
         - CHROME_EXTENSION_INSTALLATION_ERROR - an error which indicates that the jidesha extension for Chrome is failed to install.
         - FIREFOX_EXTENSION_NEEDED - An error which indicates that the jidesha extension for Firefox is needed to proceed with screen sharing, and that it is not installed.
         
+* ```JitsiMeetJS.errorTypes``` - constructors for Error instances that can be produced by library. Are useful for checks like ```error instanceof JitsiMeetJS.errorTypes.JitsiTrackError```. Following Errors are available:
+    1. ```JitsiTrackError``` - Error that happened to a JitsiTrack.
+        
 * ```JitsiMeetJS.logLevels``` - object with the log levels:
     1. TRACE
     2. DEBUG

modules/RTC/RTC.js

@@ -313,10 +313,6 @@ RTC.getStreamID = function (stream) {
     return RTCUtils.getStreamID(stream);
 };
 
-RTC.getVideoSrc = function (element) {
-    return RTCUtils.getVideoSrc(element);
-};
-
 /**
  * Returns true if retrieving the the list of input devices is supported and
  * false if not.
@@ -345,6 +341,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/RTCUIHelper.js

@@ -60,16 +60,6 @@ var RTCUIHelper = {
         if (!RTCBrowserType.isIExplorer()) {
             streamElement.autoplay = true;
         }
-    },
-
-    /**
-     * Extract video stream id from the video element.
-     * @param {Element} element
-     * @returns {string} video stream id or empty string
-     */
-    getVideoId: function (element) {
-        var src = RTC.getVideoSrc(element);
-        return src ? String(src) : '';
     }
 };
 

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();
     }
 }
 
@@ -630,59 +642,6 @@ function wrapAttachMediaStream(origAttachMediaStream) {
     }
 }
 
-/**
- * Represents a default implementation of {@link RTCUtils#getVideoSrc} which
- * tries to be browser-agnostic through feature checking. Note though that it
- * was not completely clear from the predating browser-specific implementations
- * what "videoSrc" was because one implementation would return
- * <tt>MediaStream</tt> (e.g. Firefox), another a <tt>string</tt> representation
- * of the <tt>URL</tt> of the <tt>MediaStream</tt> (e.g. Chrome) and the return
- * value was only used by {@link RTCUIHelper#getVideoId} which itself did not
- * appear to be used anywhere. Generally, the implementation will try to follow
- * the related standards i.e. work with the <tt>srcObject</tt> and <tt>src</tt>
- * properties of the specified <tt>element</tt> taking into account vender
- * prefixes.
- *
- * @param element the element to get the associated video source/src of
- * @return the video source/src of the specified <tt>element</tt>
- */
-function defaultGetVideoSrc(element) {
-    // https://www.w3.org/TR/mediacapture-streams/
-    //
-    // User Agents that support this specification must support the srcObject
-    // attribute of the HTMLMediaElement interface defined in [HTML51].
-
-    // https://www.w3.org/TR/2015/WD-html51-20150506/semantics.html#dom-media-srcobject
-    //
-    // There are three ways to specify a media resource: the srcObject IDL
-    // attribute, the src content attribute, and source elements. The IDL
-    // attribute takes priority, followed by the content attribute, followed by
-    // the elements.
-
-    // srcObject
-    var srcObject = element.srcObject || element.mozSrcObject;
-    if (srcObject) {
-        // Try the optimized path to the URL of a MediaStream.
-        var url = srcObject.jitsiObjectURL;
-        if (url) {
-            return url.toString();
-        }
-        // Go via the unoptimized path to the URL of a MediaStream then.
-        var URL = (window.URL || webkitURL);
-        if (URL) {
-            url = URL.createObjectURL(srcObject);
-            try {
-                return url.toString();
-            } finally {
-                URL.revokeObjectURL(url);
-            }
-        }
-    }
-
-    // src
-    return element.src;
-}
-
 /**
  * Represents a default implementation of setting a <tt>MediaStream</tt> as the
  * source of a video element that tries to be browser-agnostic through feature
@@ -787,7 +746,6 @@ var RTCUtils = {
                     }
                     return SDPUtil.filter_special_chars(id);
                 };
-                this.getVideoSrc = defaultGetVideoSrc;
                 RTCSessionDescription = mozRTCSessionDescription;
                 RTCIceCandidate = mozRTCIceCandidate;
             } else if (RTCBrowserType.isChrome() ||
@@ -825,7 +783,6 @@ var RTCUtils = {
                             ? id
                             : SDPUtil.filter_special_chars(id));
                 };
-                this.getVideoSrc = defaultGetVideoSrc;
                 // DTLS should now be enabled by default but..
                 this.pc_constraints = {'optional': [
                     {'DtlsSrtpKeyAgreement': 'true'}
@@ -886,24 +843,6 @@ var RTCUtils = {
                     self.getStreamID = function (stream) {
                         return SDPUtil.filter_special_chars(stream.label);
                     };
-                    self.getVideoSrc = function (element) {
-                        // There's nothing standard about getVideoSrc in the
-                        // case of Temasys so there's no point to try to
-                        // generalize it through defaultGetVideoSrc.
-                        if (!element) {
-                            logger.warn(
-                                "Attempt to get video SRC of null element");
-                            return null;
-                        }
-                        var children = element.children;
-                        for (var i = 0; i !== children.length; ++i) {
-                            if (children[i].name === 'streamId') {
-                                return children[i].value;
-                            }
-                        }
-                        //logger.info(element.id + " SRC: " + src);
-                        return null;
-                    };
 
                     onReady(options, self.getUserMediaWithConstraints);
                     resolve();
@@ -1207,6 +1146,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.sendActiveDeviceListEvent = _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,
@@ -301,7 +361,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 + '"' +
@@ -326,7 +386,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({
@@ -403,15 +463,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

@@ -259,6 +259,21 @@ Statistics.prototype.sendDominantSpeakerEvent = function () {
         CallStats.sendDominantSpeakerEvent(this.callstats);
 };
 
+/**
+ * Notifies about active device.
+ * @param {{deviceList: {String:String}}} devicesData - list of devices with
+ *      their data
+ */
+Statistics.sendActiveDeviceListEvent = function (devicesData) {
+    if (Statistics.callsStatsInstances.length) {
+        Statistics.callsStatsInstances.forEach(function (cs) {
+            CallStats.sendActiveDeviceListEvent(devicesData, cs);
+        });
+    } else {
+        CallStats.sendActiveDeviceListEvent(devicesData, null);
+    }
+};
+
 /**
  * Lets the underlying statistics module know where is given SSRC rendered by
  * providing renderer tag ID.
@@ -368,40 +383,20 @@ Statistics.prototype.sendDetectedAudioProblem = function (e) {
 };
 
 /**
- * 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.
  *
@@ -424,7 +419,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;