ref: enable/disable video button

Dynamically enables/disables the toolbar video button. Prior to that
commit if we would start with no video there would be no way to enable
it later on.

conference.js

 import {
     isFatalJitsiConnectionError
 } from './react/features/base/lib-jitsi-meet';
+import {
+    setVideoAvailable
+} from './react/features/base/media';
 import {
     localParticipantRoleChanged,
     MAX_DISPLAY_NAME_LENGTH,
                     this.isSharingScreen = newStream.videoType === 'desktop';
 
                     APP.UI.addLocalStream(newStream);
-
-                    newStream.videoType === 'camera'
-                        && APP.UI.setCameraButtonEnabled(true);
                 } else {
                     // No video is treated the same way as being video muted
                     this.videoMuted = true;
                     this.isSharingScreen = false;
                 }
                 APP.UI.setVideoMuted(this.getMyUserId(), this.videoMuted);
+                this.updateVideoIconEnabled();
                 APP.UI.updateDesktopSharingButtons();
             });
     },
                 mediaDeviceHelper.setCurrentMediaDevices(devices);
                 APP.UI.onAvailableDevicesChanged(devices);
                 APP.store.dispatch(updateDeviceList(devices));
+                this.updateVideoIconEnabled();
             });
 
             this.deviceChangeListener = (devices) =>
             .then(() => {
                 mediaDeviceHelper.setCurrentMediaDevices(devices);
                 APP.UI.onAvailableDevicesChanged(devices);
+                this.updateVideoIconEnabled();
             });
     },
+    /**
+     * Determines whether or not the video button should be enabled.
+     */
+    updateVideoIconEnabled() {
+        const videoMediaDevices
+            = mediaDeviceHelper.getCurrentMediaDevices().videoinput;
+        const videoDeviceCount
+            = videoMediaDevices ? videoMediaDevices.length : 0;
+        // The video functionality is considered available if there are any
+        // video devices detected or if there is local video stream already
+        // active which could be either screensharing stream or a video track
+        // created before the permissions were rejected (through browser
+        // config).
+        const available = videoDeviceCount > 0 || Boolean(localVideo);
+
+        logger.debug(
+            'Camera button enabled: ' + available,
+            'local video: ' + localVideo,
+            'video devices: ' + videoMediaDevices,
+            'device count: ' + videoDeviceCount);
+
+        APP.store.dispatch(setVideoAvailable(available));
+    },
 
     /**
      * Toggles the local "raised hand" status.

modules/UI/UI.js

     dockToolbox,
     setAudioIconEnabled,
     setToolbarButton,
-    setVideoIconEnabled,
     showDialPadButton,
     showEtherpadButton,
     showSharedVideoButton,
     VideoLayout.onVideoMute(id, muted);
     if (APP.conference.isLocalId(id)) {
         APP.store.dispatch(setVideoMuted(muted));
-        APP.store.dispatch(setToolbarButton('camera', {
-            toggled: muted
-        }));
     }
 };
 
         sharedVideoManager.onSharedVideoStop(id, attributes);
 };
 
-/**
- * Enables / disables camera toolbar button.
- *
- * @param {boolean} enabled indicates if the camera button should be enabled
- * or disabled
- */
-UI.setCameraButtonEnabled
-    = enabled => APP.store.dispatch(setVideoIconEnabled(enabled));
-
 /**
  * Enables / disables microphone toolbar button.
  *

modules/devices/mediaDeviceHelper.js

             availableVideoInputDevices[0].label !== '') {
             return availableVideoInputDevices[0].deviceId;
         }
-        // Otherwise we assume that we don't have any video input devices
-        // to use and that's why disable microphone button on UI.
-        else {
-            APP.UI.setCameraButtonEnabled(false);
-        }
     } else {
         // And here we handle case when we already have some device working,
         // but we plug-in a "preferred" (previously selected in settings, stored

react/features/base/media/actionTypes.js

  */
 export const SET_CAMERA_FACING_MODE = Symbol('SET_CAMERA_FACING_MODE');
 
+/**
+ * The type of (redux) action to adjust the availability of the local video.
+ *
+ * {
+ *     type: SET_VIDEO_AVAILABLE,
+ *     muted: boolean
+ * }
+ */
+export const SET_VIDEO_AVAILABLE = Symbol('SET_VIDEO_AVAILABLE');
+
 /**
  * The type of (redux) action to set the muted state of the local video.
  *

react/features/base/media/actions.js

 import {
     SET_AUDIO_MUTED,
     SET_CAMERA_FACING_MODE,
+    SET_VIDEO_AVAILABLE,
     SET_VIDEO_MUTED,
     TOGGLE_CAMERA_FACING_MODE
 } from './actionTypes';
     };
 }
 
+/**
+ * Action to adjust the availability of the local video.
+ *
+ * @param {boolean} available - True if the local video is to be marked as
+ * available or false if the local video is not available.
+ * @returns {{
+ *      type: SET_VIDEO_AVAILABLE,
+ *      available: boolean
+ *  }}
+ */
+export function setVideoAvailable(available: boolean) {
+    return {
+        type: SET_VIDEO_AVAILABLE,
+        available
+    };
+}
+
 /**
  * Action to set the muted state of the local video.
  *

react/features/base/media/reducer.js

     SET_AUDIO_MUTED,
     SET_CAMERA_FACING_MODE,
     SET_VIDEO_MUTED,
+    SET_VIDEO_AVAILABLE,
     TOGGLE_CAMERA_FACING_MODE
 } from './actionTypes';
 import { CAMERA_FACING_MODE } from './constants';
  */
 const VIDEO_INITIAL_MEDIA_STATE = {
     facingMode: CAMERA_FACING_MODE.USER,
-    muted: false
+    muted: true,
+    available: true
 };
 
 /**
  */
 function _video(state = VIDEO_INITIAL_MEDIA_STATE, action) {
     switch (action.type) {
+    case SET_VIDEO_AVAILABLE:
+        return {
+            ...state,
+            available: action.available
+        };
+
     case SET_CAMERA_FACING_MODE:
         return {
             ...state,

react/features/toolbox/actions.native.js

     };
 }
 
-/**
- * Enables/disables audio toolbar button.
- *
- * @param {boolean} enabled - True if the button should be enabled; otherwise,
- * false.
- * @returns {Function}
- */
-export function setVideoIconEnabled(enabled: boolean = false): Function {
-    return (dispatch: Dispatch<*>) => {
-        const i18nKey = enabled ? 'videomute' : 'cameraDisabled';
-        const i18n = `[content]toolbar.${i18nKey}`;
-        const button = {
-            enabled,
-            i18n,
-            toggled: !enabled
-        };
-
-        dispatch(setToolbarButton('camera', button));
-    };
-}
-
 /**
  * Shows etherpad button if it's not shown.
  *

react/features/toolbox/middleware.js

     SET_TOOLBOX_TIMEOUT
 } from './actionTypes';
 
+import {
+    SET_VIDEO_AVAILABLE,
+    SET_VIDEO_MUTED
+} from '../../features/base/media/actionTypes';
+
+import {
+    setToolbarButton
+} from './actions';
+
+/**
+ * Adjusts the state of toolbar's camera button.
+ *
+ * @param {Store} store - The Redux store instance.
+ * @param {Object} action - Either SET_VIDEO_AVAILABLE or SET_VIDEO_MUTED.
+ *
+ * @returns {*}
+ */
+function setCameraButton(store, action) {
+    const video = store.getState()['features/base/media'].video;
+    let available = video.available;
+
+    if (typeof action.available === 'boolean') {
+        available = action.available;
+    }
+
+    let muted = video.muted;
+
+    if (typeof action.muted === 'boolean') {
+        muted = action.muted;
+    }
+
+    const i18nKey = available ? 'videomute' : 'cameraDisabled';
+    const i18n = `[content]toolbar.${i18nKey}`;
+    const button = {
+        enabled: available,
+        i18n,
+        toggled: available ? muted : true
+    };
+
+    store.dispatch(setToolbarButton('camera', button));
+}
+
 /**
  * Middleware which intercepts Toolbox actions to handle changes to the
  * visibility timeout of the Toolbox.
         action.timeoutID = newTimeoutId;
         break;
     }
+
+    case SET_VIDEO_AVAILABLE:
+    case SET_VIDEO_MUTED: {
+        setCameraButton(store, action);
+        break;
+    }
+
+
     }
 
     return next(action);