Merge branch 'master' into reloads

JitsiConference.js

         video: undefined
     };
     this.isMutedByFocus = false;
+    this.reportedAudioSSRCs = {};
 }
 
 /**
     }
 
     this.room = null;
+
+    this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
 }
 /**
  * Leaves the conference.
  */
 JitsiConference.prototype.addTrack = function (track) {
     if (track.disposed) {
-        throw new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED);
+        return Promise.reject(
+            new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED));
     }
 
     if (track.isVideoTrack()) {
             if (track === localVideoTrack) {
                 return Promise.resolve(track);
             } else {
-                throw new Error(
-                        "cannot add second video track to the conference");
+                return Promise.reject(new Error(
+                    "cannot add second video track to the conference"));
             }
         }
     }
  * @returns {Promise}
  */
 JitsiConference.prototype.removeTrack = function (track) {
-    if(track.disposed)
-    {
-        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+    if (track.disposed) {
+        return Promise.reject(
+            new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED));
     }
 
     if(!this.room){
         ssrc, track.isLocal(), track.getUsageLabel(), container.id);
 }
 
+/**
+ * Reports detected audio problem with the media stream related to the passed
+ * ssrc.
+ * @param ssrc {string} the ssrc
+ */
+JitsiConference.prototype._reportAudioProblem = function (ssrc) {
+    if(this.reportedAudioSSRCs[ssrc])
+        return;
+    var track = this.rtc.getRemoteTrackBySSRC(ssrc);
+    if(!track || !track.isAudioTrack())
+        return;
+
+    this.reportedAudioSSRCs[ssrc] = true;
+    var errorContent = {
+        errMsg: "The audio is received but not played",
+        ssrc: ssrc
+    };
+
+    var mstream = track.stream, mtrack = track.track;
+    if(mstream) {
+        errorContent.MediaStream = {
+            active: mstream.active,
+            id: mstream.id
+        }
+    }
+
+    if(mtrack) {
+        errorContent.MediaStreamTrack = {
+            enabled: mtrack.enabled,
+            id: mtrack.id,
+            label: mtrack.label,
+            muted: mtrack.muted
+        }
+    }
+
+    if(track.containers) {
+        errorContent.containers = [];
+        track.containers.forEach(function (container) {
+            errorContent.containers.push({
+                autoplay: container.autoplay,
+                muted: container.muted,
+                src: container.src,
+                volume: container.volume,
+                id: container.id,
+                ended: container.ended,
+                paused: container.paused,
+                readyState: container.readyState
+            });
+        });
+    }
+
+    this.statistics.sendDetectedAudioProblem(
+        new Error(JSON.stringify(errorContent)));
+    logger.error("Audio problem detected. The audio is received but not played",
+        errorContent);
+}
+
 /**
  * Setups the listeners needed for the conference.
  */

modules/RTC/RTC.js

         return this.conference.myUserId();
     }
 
-    var self = this;
-    var resultResource = null;
-    Object.keys(this.remoteTracks).some(function (resource) {
-        var audioTrack = self.getRemoteAudioTrack(resource);
-        var videoTrack = self.getRemoteVideoTrack(resource);
-        if((audioTrack && audioTrack.getSSRC() == ssrc) ||
-            (videoTrack && videoTrack.getSSRC() == ssrc)) {
-            resultResource = resource;
-            return true;
-        }
-    });
+    var track = this.getRemoteTrackBySSRC(ssrc);
+    return track? track.getParticipantId() : null;
+};
 
-    return resultResource;
+/**
+ * Searches in remoteTracks for the ssrc and returns the corresponding track.
+ * @param ssrc the ssrc to check.
+ */
+RTC.prototype.getRemoteTrackBySSRC = function (ssrc) {
+    for (var resource in this.remoteTracks) {
+        var track = this.getRemoteAudioTrack(resource);
+        if(track && track.getSSRC() == ssrc) {
+            return track;
+        }
+        track = this.getRemoteVideoTrack(resource);
+        if(track && track.getSSRC() == ssrc) {
+            return track;
+        }
+    }
+    return null;
 };
 
 /**

modules/statistics/CallStats.js

         callStats.fabricEvent.fabricTerminated, this.confID);
 });
 
+/**
+ * Notifies CallStats that audio problems are detected.
+ *
+ * @param {Error} e error to send
+ * @param {CallStats} cs callstats instance related to the error (optional)
+ */
+CallStats.prototype.sendDetectedAudioProblem = _try_catch(function (e) {
+    CallStats._reportError.call(this, wrtcFuncNames.signalingError, e,
+        this.peerconnection);
+});
+
+
 /**
  * Notifies CallStats for ice connection failed
  * @param {RTCPeerConnection} pc connection on which failure occured.

modules/statistics/RTPStatsCollector.js

             bytesSent = Math.round(((bytesSent * 8) / time) / 1000);
         }
 
+        //detect audio issues (receiving data but audioLevel == 0)
+        if(bytesReceived > 10 && ssrcStats.ssrc2AudioLevel === 0) {
+            this.eventEmitter.emit(StatisticsEvents.AUDIO_NOT_WORKING, ssrc);
+        }
+
         ssrcStats.setSsrcBitrate({
             "download": bytesReceived,
             "upload": bytesSent

modules/statistics/statistics.js

     this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
 };
 
+/**
+ * Adds listener for detected audio problems.
+ * @param listener the listener.
+ */
+Statistics.prototype.addAudioProblemListener = function (listener) {
+    this.eventEmitter.on(StatisticsEvents.AUDIO_NOT_WORKING, listener);
+};
+
 Statistics.prototype.removeConnectionStatsListener = function (listener) {
     this.eventEmitter.removeListener(StatisticsEvents.CONNECTION_STATS, listener);
 };
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
 };
 
+/**
+ * Notifies CallStats that audio problems are detected.
+ *
+ * @param {Error} e error to send
+ */
+Statistics.prototype.sendDetectedAudioProblem = function (e) {
+    if(this.callstats)
+        this.callstats.sendDetectedAudioProblem(e);
+};
+
 /**
  * Adds to CallStats an application log.
  *

service/statistics/Events.js

      * FIXME: needs documentation.
      */
     AUDIO_LEVEL: "statistics.audioLevel",
+    /**
+     * Notifies about audio problem with remote participant.
+     */
+    AUDIO_NOT_WORKING: "statistics.audio_not_working"
 };