ref(JitsiLocalTrack): NO_DATA_FROM_SOURCE logic

modules/RTC/JitsiLocalTrack.js

          */
         this._noDataFromSourceTimeout = null;
 
+        this._onTrackMuted = this._onTrackMuted.bind(this);
+
+        this._trackMutedTS = 0;
+
         this._onDeviceListWillChange = devices => {
             const oldRealDeviceId = this._realDeviceId;
 
      * issues.
      */
     _initNoDataFromSourceHandlers() {
+        if (!this._isNoDataFromSourceEventsEnabled()) {
+            return;
+        }
+
+        this._setHandler('track_mute', () => {
+            this._trackMutedTS = window.performance.now();
+            this._fireNoDataFromSourceEvent();
+        });
+
+        this._setHandler('track_unmute', () => {
+            this._fireNoDataFromSourceEvent();
+            Statistics.sendAnalyticsAndLog(
+                TRACK_UNMUTED,
+                {
+                    'media_type': this.getType(),
+                    'track_type': 'local',
+                    value: window.performance.now() - this._trackMutedTS
+                });
+        });
+
         if (this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
-            const _onNoDataFromSourceError
-                = this._onNoDataFromSourceError.bind(this);
-
-            this._setHandler('track_mute', () => {
-                if (this._checkForCameraIssues()) {
-                    const now = window.performance.now();
-
-                    this._noDataFromSourceTimeout
-                        = setTimeout(_onNoDataFromSourceError, 5000);
-                    this._setHandler('track_unmute', () => {
-                        this._clearNoDataFromSourceMuteResources();
-                        Statistics.sendAnalyticsAndLog(
-                            TRACK_UNMUTED,
-                            {
-                                'media_type': this.getType(),
-                                'track_type': 'local',
-                                value: window.performance.now() - now
-                            });
-                    });
+            this._setHandler('track_ended', () => {
+                if (!this.isReceivingData()) {
+                    this._fireNoDataFromSourceEvent();
                 }
             });
-            this._setHandler('track_ended', _onNoDataFromSourceError);
-        }
-    }
-
-    /**
-     * Clears all timeouts and handlers set on MediaStreamTrack mute event.
-     * FIXME: Change the name of the method with better one.
-     */
-    _clearNoDataFromSourceMuteResources() {
-        if (this._noDataFromSourceTimeout) {
-            clearTimeout(this._noDataFromSourceTimeout);
-            this._noDataFromSourceTimeout = null;
         }
-        this._setHandler('track_unmute', undefined);
     }
 
     /**
-     * Called when potential camera issue is detected. Clears the handlers and
-     * timeouts set on MediaStreamTrack muted event. Verifies that the camera
-     * issue persists and fires NO_DATA_FROM_SOURCE event.
+     * Returns true if no data from source events are enabled for this JitsiLocalTrack and false otherwise.
+     *
+     * @returns {boolean} - True if no data from source events are enabled for this JitsiLocalTrack and false otherwise.
      */
-    _onNoDataFromSourceError() {
-        this._clearNoDataFromSourceMuteResources();
-        if (this._checkForCameraIssues()) {
-            this._fireNoDataFromSourceEvent();
-        }
+    _isNoDataFromSourceEventsEnabled() {
+        // Disable the events for screen sharing.
+        return !this.isVideoTrack() || this.videoType !== VideoType.DESKTOP;
     }
 
     /**
      * Fires NO_DATA_FROM_SOURCE event and logs it to analytics and callstats.
      */
     _fireNoDataFromSourceEvent() {
-        this.emit(NO_DATA_FROM_SOURCE);
+        const value = !this.isReceivingData();
 
-        Statistics.sendAnalytics(createNoDataFromSourceEvent(this.getType()));
-        const log = { name: NO_DATA_FROM_SOURCE };
+        this.emit(NO_DATA_FROM_SOURCE, value);
 
-        if (this.isAudioTrack()) {
-            log.isReceivingData = this._isReceivingData();
-        }
-        Statistics.sendLog(JSON.stringify(log));
+        // FIXME: Should we report all of those events
+        Statistics.sendAnalytics(createNoDataFromSourceEvent(this.getType(), value));
+        Statistics.sendLog(JSON.stringify({
+            name: NO_DATA_FROM_SOURCE,
+            log: value
+        }));
     }
 
     /**
         }
     }
 
-    /**
-     * Detects camera issues, i.e. returns true if we expect this track to be
-     * receiving data from its source, but it isn't receiving data.
-     *
-     * @returns {boolean} true if an issue is detected and false otherwise
-     */
-    _checkForCameraIssues() {
-        if (!this.isVideoTrack()
-                || this._stopStreamInProgress
-                || this.videoType === VideoType.DESKTOP) {
-            return false;
-        }
-
-        return !this._isReceivingData();
-    }
-
     /**
      * Checks whether the attached MediaStream is receiving data from source or
      * not. If the stream property is null(because of mute or another reason)
      * @returns {boolean} true if the stream is receiving data and false
      * this otherwise.
      */
-    _isReceivingData() {
+    isReceivingData() {
+        if (this.isVideoTrack()
+            && (this.isMuted() || this._stopStreamInProgress || this.videoType === VideoType.DESKTOP)) {
+            return true;
+        }
+
         if (!this.stream) {
             return false;
         }

service/statistics/AnalyticsEvents.js

  * @param mediaType {String} the media type of the local track ('audio' or
  * 'video').
  */
-export const createNoDataFromSourceEvent = function(mediaType) {
+export const createNoDataFromSourceEvent = function(mediaType, value) {
     return {
-        attributes: { 'media_type': mediaType },
+        attributes: {
+            'media_type': mediaType,
+            value
+        },
         action: 'track.no.data.from.source',
         type: TYPE_OPERATIONAL
     };