Merge pull request #232 from jitsi/implement_muted_ended_track_events

Implement interface for adding handlers to MediaStreamTrack object

JitsiTrackError.js

     = "Track does not have an associated Media Stream";
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS]
     = "Track mute/unmute process is currently in progress";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.NO_DATA_FROM_SOURCE]
+    = "The track has stopped receiving data from it's source";
 
 /**
  * Represents an error that occurred to a JitsiTrack. Can represent various

JitsiTrackErrors.js

  * by a webcam.
  */
 export const UNSUPPORTED_RESOLUTION = "gum.unsupported_resolution";
+/**
+ * Indicates that the track is no receiving any data without reason(the
+ * stream was stopped, etc)
+ */
+export const NO_DATA_FROM_SOURCE = "track.no_data_from_source";

JitsiTrackEvents.js

  * The video type("camera" or "desktop") of the track was changed.
  */
 export const TRACK_VIDEOTYPE_CHANGED = "track.videoTypeChanged";
+/**
+ * Indicates that the track is no receiving any data without reason(the
+ * stream was stopped, etc)
+ */
+export const NO_DATA_FROM_SOURCE = "track.no_data_from_source";

modules/RTC/JitsiLocalTrack.js

     // called.
     this._realDeviceId = this.deviceId === '' ? undefined : this.deviceId;
 
+    /**
+     * Indicates that we have called RTCUtils.stopMediaStream for the
+     * MediaStream related to this JitsiTrack object.
+     */
+    this.stopStreamInProgress = false;
+
     this._onDeviceListChanged = function (devices) {
         self._setRealDeviceIdFromDeviceList(devices);
 
 
     RTCUtils.addListener(RTCEvents.DEVICE_LIST_CHANGED,
         this._onDeviceListChanged);
+
+    if(this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
+        this._setHandler("track_mute", () => {
+            if(this._checkForCameraIssues())
+                this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
+        });
+        this._setHandler("track_ended", () => {
+            if(this._checkForCameraIssues())
+                this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
+        });
+    }
 }
 
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
                 this._removeStreamFromConferenceAsMute(() => {
                     //FIXME: Maybe here we should set the SRC for the containers
                     // to something
-                    RTCUtils.stopMediaStream(this.stream);
+                    this._stopMediaStream();
                     this._setStream(null);
                     resolve();
                 }, (err) => {
     }
 
     if (this.stream) {
-        RTCUtils.stopMediaStream(this.stream);
+        this._stopMediaStream();
         this.detach();
     }
 
         setTimeout(function () {
             if(this._bytesSent <= 0){
                 //we are not receiving anything from the microphone
-                this.eventEmitter.emit(JitsiTrackEvents.TRACK_AUDIO_NOT_WORKING);
+                this.eventEmitter.emit(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
             }
         }.bind(this), 3000);
         this._testByteSent = false;
     return undefined;
 };
 
+/**
+ * Stops the associated MediaStream.
+ */
+JitsiLocalTrack.prototype._stopMediaStream = function () {
+    this.stopStreamInProgress = true;
+    RTCUtils.stopMediaStream(this.stream);
+    this.stopStreamInProgress = false;
+}
+
+/**
+ * Detects camera issues on ended and mute events from MediaStreamTrack.
+ * @returns {boolean} true if an issue is detected and false otherwise
+ */
+JitsiLocalTrack.prototype._checkForCameraIssues = function () {
+    if(!this.isVideoTrack() || this.stopStreamInProgress ||
+        this.videoType === VideoType.DESKTOP)
+        return false;
+
+    return !this._isReceivingData();
+}
+
+/**
+ * Checks whether the attached MediaStream is reveiving data from source or
+ * not. If the stream property is null(because of mute or another reason) this
+ * method will return false.
+ * NOTE: This method doesn't indicate problem with the streams directly.
+ * For example in case of video mute the method will return false or if the
+ * user has disposed the track.
+ * @returns {boolean} true if the stream is receiving data and false otherwise.
+ */
+JitsiLocalTrack.prototype._isReceivingData = function () {
+    if(!this.stream)
+        return false;
+    // In older version of the spec there is no muted property and
+    // readyState can have value muted. In the latest versions
+    // readyState can have values "live" and "ended" and there is
+    // muted boolean property. If the stream is muted that means that
+    // we aren't receiving any data from the source. We want to notify
+    // the users for error if the stream is muted or ended on it's
+    // creation.
+    return this.stream.getTracks().some(track =>
+        ((!("readyState" in track) || track.readyState === "live")
+            && (!("muted" in track) || track.muted === false)));
+}
 
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiTrack.js

 var EventEmitter = require("events");
 var MediaType = require("../../service/RTC/MediaType");
 
+/**
+ * Maps our handler types to MediaStreamTrack properties.
+ */
+var trackHandler2Prop = {
+    "track_mute": "onmute",//Not supported on FF
+    "track_unmute": "onunmute",
+    "track_ended": "onended"
+};
+
 /**
  * This implements 'onended' callback normally fired by WebRTC after the stream
  * is stopped. There is no such behaviour yet in FF, so we have to add it.
  * @param {Function} handler the handler.
  */
 JitsiTrack.prototype._setHandler = function (type, handler) {
-    if(this.stream) {
-        if(type === "inactive") {
-            if (RTCBrowserType.isFirefox()) {
-                implementOnEndedHandling(this);
-            }
-            addMediaStreamInactiveHandler(this.stream, handler);
+    this.handlers[type] = handler;
+    if(!this.stream)
+        return;
+
+    if(type === "inactive") {
+        if (RTCBrowserType.isFirefox()) {
+            implementOnEndedHandling(this);
         }
+        addMediaStreamInactiveHandler(this.stream, handler);
+    } else if(trackHandler2Prop.hasOwnProperty(type)) {
+        this.stream.getVideoTracks().forEach(function (track) {
+            track[trackHandler2Prop[type]] = handler;
+        }, this);
     }
-    this.handlers[type] = handler;
 }
 
 /**

modules/RTC/RTC.js

 var RTCUtils = require("./RTCUtils.js");
 var JitsiTrack = require("./JitsiTrack");
 var JitsiLocalTrack = require("./JitsiLocalTrack.js");
+var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var DataChannels = require("./DataChannels");
 var JitsiRemoteTrack = require("./JitsiRemoteTrack.js");
 var MediaType = require("../../service/RTC/MediaType");
 RTC.obtainAudioAndVideoPermissions = function (options) {
     return RTCUtils.obtainAudioAndVideoPermissions(options).then(
         function (tracksInfo) {
-            return createLocalTracks(tracksInfo, options);
+            var tracks = createLocalTracks(tracksInfo, options);
+            return !tracks.some(track => !track._isReceivingData())? tracks :
+                Promise.reject(new JitsiTrackError(
+                    JitsiTrackErrors.NO_DATA_FROM_SOURCE));
     });
 };