Implement audio problem detection

JitsiConference.js

 var ComponentsVersions = require("./modules/version/ComponentsVersions");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
 var JitsiConferenceEventManager = require("./JitsiConferenceEventManager");
+var VideoType = require('../../service/RTC/VideoType');
 
 /**
  * Creates a JitsiConference object with the given name and properties.
         track.ssrcHandler);
 
     if(track.isAudioTrack() || (track.isVideoTrack() &&
-        track.videoType !== "desktop")) {
+        track.videoType !== VideoType.DESKTOP)) {
         // Report active device to statistics
         var devices = RTC.getCurrentlyAvailableMediaDevices();
         device = devices.find(function (d) {
             // send event for starting screen sharing
             // FIXME: we assume we have only one screen sharing track
             // if we change this we need to fix this check
-            if (track.isVideoTrack() && track.videoType === "desktop")
+            if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP)
                 this.statistics.sendScreenSharingEvent(true);
 
             this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
     // send event for stopping screen sharing
     // FIXME: we assume we have only one screen sharing track
     // if we change this we need to fix this check
-    if (track.isVideoTrack() && track.videoType === "desktop")
+    if (track.isVideoTrack() && track.videoType === VideoType.DESKTOP)
         this.statistics.sendScreenSharingEvent(false);
 
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);

JitsiConferenceEventManager.js

     conference.statistics.addAudioProblemListener(function (ssrc) {
         conference._reportAudioProblem(ssrc);
     });
+
+    conference.statistics.addByteSentStatsListener(function (stats) {
+        var tracks = conference.getLocalTracks();
+        conference.getLocalTracks().forEach(function (track) {
+            var ssrc = track.getSSRC();
+            if(!track.isAudioTrack() || !ssrc || !stats.hasOwnProperty(ssrc))
+                return;
+
+            track._setByteSent(stats[ssrc]);
+        });
+    });
 };
 
 module.exports = JitsiConferenceEventManager;

JitsiTrackEvents.js

     /**
      * The audio output of the track was changed.
      */
-    TRACK_AUDIO_OUTPUT_CHANGED: "track.audioOutputChanged"
+    TRACK_AUDIO_OUTPUT_CHANGED: "track.audioOutputChanged",
+    /**
+     * Detects that no audio have been sent.
+     */
+    TRACK_AUDIO_NOT_WORKING: "track.audioNotWorking"
 };
 
 module.exports = JitsiTrackEvents;

modules/RTC/JitsiLocalTrack.js

     // enumerateDevices() list.
     this._trackEnded = false;
 
+    this._bytesSent = null;
+
+    this._testByteSent = true;
+
     // Currently there is no way to determine with what device track was
     // created (until getConstraints() support), however we can associate tracks
     // with real devices obtained from enumerateDevices() call as soon as it's
     return this._realDeviceId || this.deviceId;
 };
 
+/**
+ * Sets the value of bytes sent statistic.
+ * @param bytesSent {intiger} the new value
+ * NOTE: used only for audio tracks to detect audio issues.
+ */
+JitsiLocalTrack.prototype._setByteSent = function (bytesSent) {
+    this._bytesSent = bytesSent;
+    if(this._testByteSent) {
+        setTimeout(function () {
+            if(this._bytesSent <= 0){
+                //we are not receiving anything from the microphone
+                this.eventEmitter.emit(JitsiTrackEvents.TRACK_AUDIO_NOT_WORKING);
+            }
+        }.bind(this), 3000);
+        this._testByteSent = false;
+    }
+}
+
 /**
  * Returns facing mode for video track from camera. For other cases (e.g. audio
  * track or 'desktop' video track) returns undefined.

modules/statistics/RTPStatsCollector.js

  * @param audioLevelsInterval
  * @param statsInterval stats refresh interval given in ms.
  * @param eventEmitter
- * @param config {object} supports the following properties: disableAudioLevels,
- * disableStats, logStats
  * @constructor
  */
 function StatsCollector(
         peerconnection,
         audioLevelsInterval,
         statsInterval,
-        eventEmitter,
-        config) {
+        eventEmitter) {
     // StatsCollector depends entirely on the format of the reports returned by
     // RTCPeerConnection#getStats. Given that the value of
     // RTCBrowserType#getBrowserType() is very unlikely to change at runtime, it
     this.baselineStatsReport = null;
     this.audioLevelsIntervalId = null;
     this.eventEmitter = eventEmitter;
-    this.config = config || {};
     this.conferenceStats = new ConferenceStats();
 
     /**
 /**
  * Starts stats updates.
  */
-StatsCollector.prototype.start = function () {
+StatsCollector.prototype.start = function (startAudioLevelStats) {
     var self = this;
-    this.audioLevelsIntervalId = setInterval(
-        function () {
-            // Interval updates
-            self.peerconnection.getStats(
-                function (report) {
-                    var results = null;
-                    if (!report || !report.result ||
-                        typeof report.result != 'function') {
-                        results = report;
-                    }
-                    else {
-                        results = report.result();
-                    }
-                    self.currentAudioLevelsReport = results;
-                    self.processAudioLevelReport();
-                    self.baselineAudioLevelsReport =
-                        self.currentAudioLevelsReport;
-                },
-                self.errorCallback
-            );
-        },
-        self.audioLevelsIntervalMilis
-    );
+    if(startAudioLevelStats) {
+        this.audioLevelsIntervalId = setInterval(
+            function () {
+                // Interval updates
+                self.peerconnection.getStats(
+                    function (report) {
+                        var results = null;
+                        if (!report || !report.result ||
+                            typeof report.result != 'function') {
+                            results = report;
+                        }
+                        else {
+                            results = report.result();
+                        }
+                        self.currentAudioLevelsReport = results;
+                        self.processAudioLevelReport();
+                        self.baselineAudioLevelsReport =
+                            self.currentAudioLevelsReport;
+                    },
+                    self.errorCallback
+                );
+            },
+            self.audioLevelsIntervalMilis
+        );
+    }
 
-    if (!this.config.disableStats && browserSupported) {
+    if (browserSupported) {
         this.statsIntervalId = setInterval(
             function () {
                 // Interval updates
         );
     }
 
-    if (this.config.logStats
-            && browserSupported
+    if (browserSupported
             // logging statistics does not support firefox
             && this._browserType !== RTCBrowserType.RTC_BROWSER_FIREFOX) {
         this.gatherStatsIntervalId = setInterval(
     }
 
     var getStatValue = this._getStatValue;
+    byteSentStats = {};
 
     for (var idx in this.currentStatsReport) {
         var now = this.currentStatsReport[idx];
                 = nowBytesTransmitted - getStatValue(before, "bytesReceived");
         }
         nowBytesTransmitted = getStatValue(now, "bytesSent");
-        if (nowBytesTransmitted) {
-            bytesSent = nowBytesTransmitted - getStatValue(before, "bytesSent");
+        if(typeof(nowBytesTransmitted) === "number" ||
+            typeof(nowBytesTransmitted) === "string") {
+            nowBytesTransmitted = Number(nowBytesTransmitted);
+            if(!isNaN(nowBytesTransmitted)){
+                byteSentStats[ssrc] = nowBytesTransmitted;
+                if (nowBytesTransmitted > 0) {
+                    bytesSent = nowBytesTransmitted -
+                        getStatValue(before, "bytesSent");
+                }
+            }
         }
 
         var time = Math.round((now.timestamp - before.timestamp) / 1000);
     Object.keys(this.ssrc2stats).forEach(
         function (ssrc) {
             var ssrcStats = this.ssrc2stats[ssrc];
-
             // process package loss stats
             var ssrc2Loss = ssrcStats.ssrc2Loss;
             var type = ssrc2Loss.isDownloadStream ? "download" : "upload";
         this
     );
 
+    this.eventEmitter.emit(StatisticsEvents.BYTE_SENT_STATS, byteSentStats);
+
     this.conferenceStats.bitrate
       = {"upload": bitrateUpload, "download": bitrateDownload};
 

modules/statistics/statistics.js

 Statistics.callsStatsInstances = [];
 
 Statistics.prototype.startRemoteStats = function (peerconnection) {
-    if(!Statistics.audioLevelsEnabled)
-        return;
-
     this.stopRemoteStats();
 
     try {
         this.rtpStats
             = new RTPStats(peerconnection,
                     Statistics.audioLevelsInterval, 2000, this.eventEmitter);
-        this.rtpStats.start();
+        this.rtpStats.start(Statistics.audioLevelsEnabled);
     } catch (e) {
         this.rtpStats = null;
         logger.error('Failed to start collecting remote statistics: ' + e);
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
 };
 
-Statistics.prototype.addConnectionStatsListener = function (listener) {
-    this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
-};
-
 /**
  * Adds listener for detected audio problems.
  * @param listener the listener.
     this.eventEmitter.on(StatisticsEvents.AUDIO_NOT_WORKING, listener);
 };
 
+Statistics.prototype.addConnectionStatsListener = function (listener) {
+    this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
+};
+
 Statistics.prototype.removeConnectionStatsListener = function (listener) {
     this.eventEmitter.removeListener(StatisticsEvents.CONNECTION_STATS, listener);
 };
 
+Statistics.prototype.addByteSentStatsListener = function (listener) {
+    this.eventEmitter.on(StatisticsEvents.BYTE_SENT_STATS, listener);
+};
+
+Statistics.prototype.removeByteSentStatsListener = function (listener) {
+    this.eventEmitter.removeListener(StatisticsEvents.BYTE_SENT_STATS,
+        listener);
+};
+
 Statistics.prototype.dispose = function () {
-    if(Statistics.audioLevelsEnabled) {
-        this.stopRemoteStats();
-        if(this.eventEmitter)
-            this.eventEmitter.removeAllListeners();
-    }
+    this.stopRemoteStats();
+    if(this.eventEmitter)
+        this.eventEmitter.removeAllListeners();
 };
 
 Statistics.stopLocalStats = function (stream) {
 };
 
 Statistics.prototype.stopRemoteStats = function () {
-    if (!Statistics.audioLevelsEnabled || !this.rtpStats) {
+    if (!this.rtpStats) {
         return;
     }
 

service/statistics/Events.js

 module.exports = {
-    /**
-     * An event carrying connection statistics.
-     */
-    CONNECTION_STATS: "statistics.connectionstats",
     /**
      * FIXME: needs documentation.
      */
     /**
      * Notifies about audio problem with remote participant.
      */
-    AUDIO_NOT_WORKING: "statistics.audio_not_working"
+    AUDIO_NOT_WORKING: "statistics.audio_not_working",
+    /**
+     * An event carrying connection statistics.
+     */
+    CONNECTION_STATS: "statistics.connectionstats",
+    /**
+     * An event carrying all statistics by ssrc.
+     */
+    BYTE_SENT_STATS: "statistics.byte_sent_stats"
 };