ref(no-data-from-source): logic.

lang/main.json

         "maxUsersLimitReachedTitle": "Maximum members limit reached",
         "micConstraintFailedError": "Your microphone does not satisfy some of the required constraints.",
         "micNotFoundError": "Microphone was not found.",
-        "micNotSendingData": "We are unable to access your microphone. Please select another device from the settings menu or try to reload the application.",
-        "micNotSendingDataTitle": "Unable to access microphone",
+        "micNotSendingData": "Go to your computer's settings to unmute your mic and adjust its level",
+        "micNotSendingDataTitle": "Your mic is muted by your system settings",
         "micPermissionDeniedError": "You have not granted permission to use your microphone. You can still join the conference but others won't hear you. Use the camera button in the address bar to fix this.",
         "micUnknownError": "Cannot use microphone for an unknown reason.",
         "muteParticipantBody": "You won't be able to unmute them, but they can unmute themselves at any time.",

modules/UI/UI.js

     });
 };
 
-/**
- * Shows error dialog that informs the user that no data is received from the
- * device.
- *
- * @param {boolean} isAudioTrack - Whether or not the dialog is for an audio
- * track error.
- * @returns {void}
- */
-UI.showTrackNotWorkingDialog = function(isAudioTrack) {
-    messageHandler.showError({
-        descriptionKey: isAudioTrack
-            ? 'dialog.micNotSendingData' : 'dialog.cameraNotSendingData',
-        titleKey: isAudioTrack
-            ? 'dialog.micNotSendingDataTitle'
-            : 'dialog.cameraNotSendingDataTitle'
-    });
-};
-
 UI.updateDevicesAvailability = function(id, devices) {
     VideoLayout.setDeviceAvailabilityIcons(id, devices);
 };

package-lock.json

       }
     },
     "lib-jitsi-meet": {
-      "version": "github:jitsi/lib-jitsi-meet#afa08b4ea5e81475aa7dcb1a418111e5a281edff",
-      "from": "github:jitsi/lib-jitsi-meet#afa08b4ea5e81475aa7dcb1a418111e5a281edff",
+      "version": "github:jitsi/lib-jitsi-meet#40446bb948823468acd284a5a70bfd8bd7a086f1",
+      "from": "github:jitsi/lib-jitsi-meet#40446bb948823468acd284a5a70bfd8bd7a086f1",
       "requires": {
         "@jitsi/sdp-interop": "0.1.14",
         "@jitsi/sdp-simulcast": "0.2.1",

package.json

     "js-utils": "github:jitsi/js-utils#73a67a7a60d52f8e895f50939c8fcbd1f20fe7b5",
     "jsrsasign": "8.0.12",
     "jwt-decode": "2.2.0",
-    "lib-jitsi-meet": "github:jitsi/lib-jitsi-meet#afa08b4ea5e81475aa7dcb1a418111e5a281edff",
+    "lib-jitsi-meet": "github:jitsi/lib-jitsi-meet#40446bb948823468acd284a5a70bfd8bd7a086f1",
     "libflacjs": "github:mmig/libflac.js#93d37e7f811f01cf7d8b6a603e38bd3c3810907d",
     "lodash": "4.17.11",
     "moment": "2.19.4",

react/features/base/tracks/actionTypes.js

  */
 export const TRACK_CREATE_ERROR = 'TRACK_CREATE_ERROR';
 
+/**
+ * The type of redux action dispatched when a track has triggered no data from source event.
+ *
+ * {
+ *     type: TRACK_NO_DATA_FROM_SOURCE,
+ *     track: Track
+ * }
+ */
+export const TRACK_NO_DATA_FROM_SOURCE = 'TRACK_NO_DATA_FROM_SOURCE';
+
 /**
  * The type of redux action dispatched when a track has been (locally or
  * remotely) removed from the conference.

react/features/base/tracks/actions.js

     sendAnalytics
 } from '../../analytics';
 import { JitsiTrackErrors, JitsiTrackEvents } from '../lib-jitsi-meet';
+import { showErrorNotification, showNotification } from '../../notifications';
 import {
     CAMERA_FACING_MODE,
     MEDIA_TYPE,
     TRACK_ADDED,
     TRACK_CREATE_CANCELED,
     TRACK_CREATE_ERROR,
+    TRACK_NO_DATA_FROM_SOURCE,
     TRACK_REMOVED,
     TRACK_UPDATED,
     TRACK_WILL_CREATE
 } from './actionTypes';
-import { createLocalTracksF, getLocalTrack, getLocalTracks } from './functions';
+import { createLocalTracksF, getLocalTrack, getLocalTracks, getTrackByJitsiTrack } from './functions';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
     };
 }
 
+/**
+ * Signals that the passed JitsiLocalTrack has triggered a no data from source event.
+ *
+ * @param {JitsiLocalTrack} track - The track.
+ * @returns {{
+*     type: TRACK_NO_DATA_FROM_SOURCE,
+*     track: Track
+* }}
+*/
+export function noDataFromSource(track) {
+    return {
+        type: TRACK_NO_DATA_FROM_SOURCE,
+        track
+    };
+}
+
+/**
+ * Displays a no data from source video error if needed.
+ *
+ * @param {JitsiLocalTrack} jitsiTrack - The track.
+ * @returns {Function}
+ */
+export function showNoDataFromSourceVideoError(jitsiTrack) {
+    return (dispatch, getState) => {
+        let notificationInfo;
+
+        const track = getTrackByJitsiTrack(getState()['features/base/tracks'], jitsiTrack);
+
+        if (!track) {
+            return;
+        }
+
+        if (track.isReceivingData) {
+            notificationInfo = undefined;
+        } else {
+            const notificationAction = showErrorNotification({
+                descriptionKey: 'dialog.cameraNotSendingData',
+                titleKey: 'dialog.cameraNotSendingDataTitle'
+            });
+
+            dispatch(notificationAction);
+            notificationInfo = {
+                uid: notificationAction.uid
+            };
+        }
+        dispatch(trackNoDataFromSourceNotificationInfoChanged(jitsiTrack, notificationInfo));
+    };
+}
+
 /**
  * Signals that the local participant is ending screensharing or beginning the
  * screensharing flow.
 
         // participantId
         const local = track.isLocal();
-        let participantId;
+        const mediaType = track.getType();
+        let isReceivingData, noDataFromSourceNotificationInfo, participantId;
 
         if (local) {
             const participant = getLocalParticipant(getState);
             if (participant) {
                 participantId = participant.id;
             }
+
+            isReceivingData = track.isReceivingData();
+            track.on(JitsiTrackEvents.NO_DATA_FROM_SOURCE, () => dispatch(noDataFromSource({ jitsiTrack: track })));
+            if (!isReceivingData) {
+                if (mediaType === MEDIA_TYPE.AUDIO) {
+                    const notificationAction = showNotification({
+                        descriptionKey: 'dialog.micNotSendingData',
+                        titleKey: 'dialog.micNotSendingDataTitle'
+                    });
+
+                    dispatch(notificationAction);
+                    noDataFromSourceNotificationInfo = { uid: notificationAction.uid };
+                } else {
+                    const timeout = setTimeout(() => dispatch(showNoDataFromSourceVideoError(track)), 5000);
+
+                    noDataFromSourceNotificationInfo = { timeout };
+                }
+
+            }
         } else {
             participantId = track.getParticipantId();
+            isReceivingData = true;
         }
 
         return dispatch({
             type: TRACK_ADDED,
             track: {
                 jitsiTrack: track,
+                isReceivingData,
                 local,
-                mediaType: track.getType(),
+                mediaType,
                 mirror: _shouldMirror(track),
                 muted: track.isMuted(),
+                noDataFromSourceNotificationInfo,
                 participantId,
                 videoStarted: false,
                 videoType: track.videoType
     };
 }
 
+/**
+ * Create an action for when a track's no data from source notification information changes.
+ *
+ * @param {JitsiLocalTrack} track - JitsiTrack instance.
+ * @param {Object} noDataFromSourceNotificationInfo - Information about no data from source notification.
+ * @returns {{
+ *     type: TRACK_UPDATED,
+ *     track: Track
+ * }}
+ */
+export function trackNoDataFromSourceNotificationInfoChanged(track, noDataFromSourceNotificationInfo) {
+    return {
+        type: TRACK_UPDATED,
+        track: {
+            jitsiTrack: track,
+            noDataFromSourceNotificationInfo
+        }
+    };
+}
+
 /**
  * Create an action for when a track has been signaled for removal from the
  * conference.
 export function trackRemoved(track) {
     track.removeAllListeners(JitsiTrackEvents.TRACK_MUTE_CHANGED);
     track.removeAllListeners(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED);
+    track.removeAllListeners(JitsiTrackEvents.NO_DATA_FROM_SOURCE);
 
     return {
         type: TRACK_REMOVED,

react/features/base/tracks/functions.js

 /* global APP */
 
-import JitsiMeetJS, { JitsiTrackErrors, JitsiTrackEvents }
-    from '../lib-jitsi-meet';
+import JitsiMeetJS, { JitsiTrackErrors } from '../lib-jitsi-meet';
 import { MEDIA_TYPE } from '../media';
 import {
     getUserSelectedCameraDeviceId,
                 resolution
             },
             firePermissionPromptIsShownEvent)
-        .then(tracks => {
-            // TODO JitsiTrackEvents.NO_DATA_FROM_SOURCE should probably be
-            // dispatched in the redux store here and then
-            // APP.UI.showTrackNotWorkingDialog should be in a middleware
-            // somewhere else.
-            if (typeof APP !== 'undefined') {
-                tracks.forEach(track =>
-                    track.on(
-                        JitsiTrackEvents.NO_DATA_FROM_SOURCE,
-                        APP.UI.showTrackNotWorkingDialog.bind(
-                            null, track.isAudioTrack())));
-            }
-
-            return tracks;
-        })
         .catch(err => {
             logger.error('Failed to create local tracks', options.devices, err);
 

react/features/base/tracks/middleware.js

     TOGGLE_CAMERA_FACING_MODE,
     toggleCameraFacingMode
 } from '../media';
+import { hideNotification } from '../../notifications';
 import { MiddlewareRegistry } from '../redux';
 import UIEvents from '../../../../service/UI/UIEvents';
 
-import { createLocalTracksA } from './actions';
+import {
+    createLocalTracksA,
+    showNoDataFromSourceVideoError,
+    trackNoDataFromSourceNotificationInfoChanged
+} from './actions';
 import {
     TOGGLE_SCREENSHARING,
+    TRACK_NO_DATA_FROM_SOURCE,
+    TRACK_REMOVED,
     TRACK_UPDATED
 } from './actionTypes';
-import { getLocalTrack, setTrackMuted } from './functions';
+import { getLocalTrack, getTrackByJitsiTrack, setTrackMuted } from './functions';
 
 declare var APP: Object;
 
  */
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
+    case TRACK_NO_DATA_FROM_SOURCE: {
+        const result = next(action);
+
+        _handleNoDataFromSourceErrors(store, action);
+
+        return result;
+    }
+    case TRACK_REMOVED: {
+        _removeNoDataFromSourceNotification(store, action.track);
+        break;
+    }
     case SET_AUDIO_MUTED:
         _setMuted(store, action, MEDIA_TYPE.AUDIO);
         break;
     return next(action);
 });
 
+/**
+ * Handles no data from source errors.
+ *
+ * @param {Store} store - The redux store in which the specified action is
+ * dispatched.
+ * @param {Action} action - The redux action dispatched in the specified store.
+ * @private
+ * @returns {void}
+ */
+function _handleNoDataFromSourceErrors(store, action) {
+    const { getState, dispatch } = store;
+
+    const track = getTrackByJitsiTrack(getState()['features/base/tracks'], action.track.jitsiTrack);
+
+    if (!track || !track.local) {
+        return;
+    }
+
+    const { jitsiTrack } = track;
+
+    if (track.mediaType === MEDIA_TYPE.AUDIO && track.isReceivingData) {
+        _removeNoDataFromSourceNotification(store, action.track);
+    }
+
+    if (track.mediaType === MEDIA_TYPE.VIDEO) {
+        const { noDataFromSourceNotificationInfo = {} } = track;
+
+        if (track.isReceivingData) {
+            if (noDataFromSourceNotificationInfo.timeout) {
+                clearTimeout(noDataFromSourceNotificationInfo.timeout);
+                dispatch(trackNoDataFromSourceNotificationInfoChanged(jitsiTrack, undefined));
+            }
+
+            // try to remove the notification if there is one.
+            _removeNoDataFromSourceNotification(store, action.track);
+        } else {
+            if (noDataFromSourceNotificationInfo.timeout) {
+                return;
+            }
+
+            const timeout = setTimeout(() => dispatch(showNoDataFromSourceVideoError(jitsiTrack)), 5000);
+
+            dispatch(trackNoDataFromSourceNotificationInfoChanged(jitsiTrack, { timeout }));
+        }
+    }
+}
+
 /**
  * Gets the local track associated with a specific {@code MEDIA_TYPE} in a
  * specific redux store.
             includePending));
 }
 
+/**
+ * Removes the no data from source notification associated with the JitsiTrack if displayed.
+ *
+ * @param {Store} store - The redux store.
+ * @param {Track} track - The redux action dispatched in the specified store.
+ * @returns {void}
+ */
+function _removeNoDataFromSourceNotification({ getState, dispatch }, track) {
+    const t = getTrackByJitsiTrack(getState()['features/base/tracks'], track.jitsiTrack);
+    const { jitsiTrack, noDataFromSourceNotificationInfo = {} } = t || {};
+
+    if (noDataFromSourceNotificationInfo && noDataFromSourceNotificationInfo.uid) {
+        dispatch(hideNotification(noDataFromSourceNotificationInfo.uid));
+        dispatch(trackNoDataFromSourceNotificationInfoChanged(jitsiTrack, undefined));
+    }
+}
+
 /**
  * Mutes or unmutes a local track with a specific media type.
  *

react/features/base/tracks/reducer.js

     TRACK_ADDED,
     TRACK_CREATE_CANCELED,
     TRACK_CREATE_ERROR,
+    TRACK_NO_DATA_FROM_SOURCE,
     TRACK_REMOVED,
     TRACK_UPDATED,
     TRACK_WILL_CREATE
         }
         break;
     }
+    case TRACK_NO_DATA_FROM_SOURCE: {
+        const t = action.track;
+
+        if (state.jitsiTrack === t.jitsiTrack) {
+            const isReceivingData = t.jitsiTrack.isReceivingData();
+
+            if (state.isReceivingData !== isReceivingData) {
+                return {
+                    ...state,
+                    isReceivingData
+                };
+            }
+        }
+        break;
+    }
     }
 
     return state;
 ReducerRegistry.register('features/base/tracks', (state = [], action) => {
     switch (action.type) {
     case PARTICIPANT_ID_CHANGED:
+    case TRACK_NO_DATA_FROM_SOURCE:
     case TRACK_UPDATED:
         return state.map(t => track(t, action));