feat(subject): UI

conference.js

     conferenceFailed,
     conferenceJoined,
     conferenceLeft,
+    conferenceSubjectChanged,
     conferenceWillJoin,
     conferenceWillLeave,
     dataChannelOpened,
     onStartMutedPolicyChanged,
     p2pStatusChanged,
     sendLocalParticipant,
-    setDesktopSharingEnabled,
-    setSubject
+    setDesktopSharingEnabled
 } from './react/features/base/conference';
 import {
     getAvailableDevices,
             APP.UI.showToolbar(6000);
         });
         room.on(JitsiConferenceEvents.SUBJECT_CHANGED,
-            subject => APP.API.notifySubjectChanged(subject));
+            subject => APP.store.dispatch(conferenceSubjectChanged(subject)));
 
         room.on(
             JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
         APP.API.notifyAudioMutedStatusChanged(muted);
     },
 
-    /**
-     * Changes the subject of the conference.
-     * Note: available only for moderator.
-     *
-     * @param subject {string} the new subject for the conference.
-     */
-    setSubject(subject) {
-        APP.store.dispatch(setSubject(subject));
-    },
-
     /**
      * Dispatches the passed in feedback for submission. The submitted score
      * should be a number inclusively between 1 through 5, or -1 for no score.

css/_subject.scss

+.subject {
+    top: -120px;
+    transition: top .3s ease-in;
+    height: 95px;
+    width: 100%;
+    position: absolute;
+    padding: 25px 140px 0 140px;
+    text-align: center;
+    font-size: 17px;
+    color: #fff;
+    z-index: $toolbarBackgroundZ;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    box-sizing: border-box;
+    white-space: nowrap;
+    background-image: linear-gradient(to bottom, rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0));
+
+    &.visible {
+        top: 0px;
+    }
+}

css/main.scss

 @import 'modals/local-recording/local-recording';
 @import 'videolayout_default';
 @import 'notice';
+@import 'subject';
 @import 'popup_menu';
 @import 'recording';
 @import 'login_menu';

modules/API/API.js

     createApiEvent,
     sendAnalytics
 } from '../../react/features/analytics';
+import { setSubject } from '../../react/features/base/conference';
 import { parseJWTFromURLParams } from '../../react/features/base/jwt';
 import { invite } from '../../react/features/invite';
 import { getJitsiMeetTransport } from '../transport';
         },
         'subject': subject => {
             sendAnalytics(createApiEvent('subject.changed'));
-            APP.conference.setSubject(subject);
+            APP.store.dispatch(setSubject(subject));
         },
         'submit-feedback': feedback => {
             sendAnalytics(createApiEvent('submit.feedback'));

modules/API/external/external_api.js

      * {@code displayName} - Sets the display name of the local participant to
      * the value passed in the arguments array.
      * {@code subject} - Sets the subject of the conference, the value passed
-     * in the arguments array. Note: available only for moderator.
+     * in the arguments array. Note: Available only for moderator.
      *
      * {@code toggleAudio} - Mutes / unmutes audio with no arguments.
      * {@code toggleVideo} - Mutes / unmutes video with no arguments.

react/features/base/conference/actionTypes.js

  */
 export const CONFERENCE_LEFT = Symbol('CONFERENCE_LEFT');
 
+/**
+ * The type of (redux) action, which indicates conference subject changes.
+ *
+ * {
+ *     type: CONFERENCE_SUBJECT_CHANGED
+ *     subject: string
+ * }
+ */
+export const CONFERENCE_SUBJECT_CHANGED = Symbol('CONFERENCE_SUBJECT_CHANGED');
+
 /**
  * The type of (redux) action which signals that a specific conference will be
  * joined.
  */
 export const SET_AUDIO_ONLY = Symbol('SET_AUDIO_ONLY');
 
-/**
- * The type of (redux) action, which indicates to set conference subject.
- *
- * {
- *     type: SET_CONFERENCE_SUBJECT
- *     subject: string
- * }
- */
-export const SET_CONFERENCE_SUBJECT = Symbol('SET_CONFERENCE_SUBJECT');
-
 /**
  * The type of (redux) action which sets the desktop sharing enabled flag for
  * the current conference.
  */
 export const SET_PASSWORD_FAILED = Symbol('SET_PASSWORD_FAILED');
 
+/**
+ * The type of (redux) action which signals for pending subject changes.
+ *
+ * {
+ *     type: SET_PENDING_SUBJECT_CHANGE,
+ *     subject: string
+ * }
+ */
+export const SET_PENDING_SUBJECT_CHANGE = Symbol('SET_PENDING_SUBJECT_CHANGE');
+
 /**
  * The type of (redux) action which sets the preferred maximum video height that
  * should be received from remote participants.

react/features/base/conference/actions.js

     CONFERENCE_FAILED,
     CONFERENCE_JOINED,
     CONFERENCE_LEFT,
+    CONFERENCE_SUBJECT_CHANGED,
     CONFERENCE_WILL_JOIN,
     CONFERENCE_WILL_LEAVE,
     DATA_CHANNEL_OPENED,
     LOCK_STATE_CHANGED,
     P2P_STATUS_CHANGED,
     SET_AUDIO_ONLY,
-    SET_CONFERENCE_SUBJECT,
     SET_DESKTOP_SHARING_ENABLED,
     SET_FOLLOW_ME,
     SET_LASTN,
     SET_PASSWORD_FAILED,
     SET_PREFERRED_RECEIVER_VIDEO_QUALITY,
     SET_ROOM,
+    SET_PENDING_SUBJECT_CHANGE,
     SET_START_MUTED_POLICY
 } from './actionTypes';
 import {
     };
 }
 
+/**
+ * Signals that the conference subject has been changed.
+ *
+ * @param {string} subject - The new subject.
+ * @returns {{
+ *     type: CONFERENCE_SUBJECT_CHANGED,
+ *     subject: string
+ * }}
+ */
+export function conferenceSubjectChanged(subject: string) {
+    return {
+        type: CONFERENCE_SUBJECT_CHANGED,
+        subject
+    };
+}
+
 /**
  * Adds any existing local tracks to a specific conference before the conference
  * is joined. Then signals the intention of the application to have the local
  * @param {string} subject - The new subject.
  * @returns {void}
  */
-export function setSubject(subject: String) {
-    return {
-        type: SET_CONFERENCE_SUBJECT,
-        subject
+export function setSubject(subject: string = '') {
+    return (dispatch: Dispatch<*>, getState: Function) => {
+        const { conference } = getState()['features/base/conference'];
+
+        if (conference) {
+            dispatch({
+                type: SET_PENDING_SUBJECT_CHANGE,
+                subject: undefined
+            });
+            conference.setSubject(subject);
+        } else {
+            dispatch({
+                type: SET_PENDING_SUBJECT_CHANGE,
+                subject
+            });
+        }
     };
 }

react/features/base/conference/middleware.js

     conferenceLeft,
     conferenceWillLeave,
     createConference,
-    setLastN
+    setLastN,
+    setSubject
 } from './actions';
 import {
     CONFERENCE_FAILED,
     CONFERENCE_JOINED,
+    CONFERENCE_SUBJECT_CHANGED,
     CONFERENCE_WILL_LEAVE,
     DATA_CHANNEL_OPENED,
     SET_AUDIO_ONLY,
-    SET_CONFERENCE_SUBJECT,
     SET_LASTN,
     SET_ROOM
 } from './actionTypes';
     case CONNECTION_FAILED:
         return _connectionFailed(store, next, action);
 
+    case CONFERENCE_SUBJECT_CHANGED:
+        return _conferenceSubjectChanged(store, next, action);
+
     case CONFERENCE_WILL_LEAVE:
         _conferenceWillLeave();
         break;
     case SET_AUDIO_ONLY:
         return _setAudioOnly(store, next, action);
 
-    case SET_CONFERENCE_SUBJECT:
-        return _setSubject(store, next, action);
-
     case SET_LASTN:
         return _setLastN(store, next, action);
 
 function _conferenceJoined({ dispatch, getState }, next, action) {
     const result = next(action);
 
-    const { audioOnly, conference } = getState()['features/base/conference'];
+    const {
+        audioOnly,
+        conference,
+        pendingSubjectChange
+    } = getState()['features/base/conference'];
+
+    if (pendingSubjectChange) {
+        dispatch(setSubject(pendingSubjectChange));
+    }
 
     // FIXME On Web the audio only mode for "start audio only" is toggled before
     // conference is added to the redux store ("on conference joined" action)
     return result;
 }
 
+/**
+ * Notifies the feature base/conference that the action
+ * {@code CONFERENCE_SUBJECT_CHANGED} is being dispatched within a specific
+ *  redux store.
+ *
+ * @param {Store} store - The redux store in which the specified {@code action}
+ * is being dispatched.
+ * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
+ * specified {@code action} to the specified {@code store}.
+ * @param {Action} action - The redux action {@code CONFERENCE_SUBJECT_CHANGED}
+ * which is being dispatched in the specified {@code store}.
+ * @private
+ * @returns {Object} The value returned by {@code next(action)}.
+ */
+function _conferenceSubjectChanged({ getState }, next, action) {
+    const result = next(action);
+    const { subject } = getState()['features/base/conference'];
+
+    typeof APP === 'object' && APP.API.notifySubjectChanged(subject);
+
+    return result;
+}
+
 /**
  * Notifies the feature base/conference that the action
  * {@code CONFERENCE_WILL_LEAVE} is being dispatched within a specific redux
 
     return result;
 }
-
-/**
- * Changing conference subject.
- *
- * @param {Store} store - The redux store in which the specified {@code action}
- * is being dispatched.
- * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
- * specified {@code action} to the specified {@code store}.
- * @param {Action} action - The redux action which is being dispatched in the
- * specified {@code store}.
- * @private
- * @returns {Object} The value returned by {@code next(action)}.
- */
-function _setSubject({ getState }, next, action) {
-    const { conference } = getState()['features/base/conference'];
-    const { subject } = action;
-
-    if (subject) {
-        conference.setSubject(subject);
-    }
-
-    return next(action);
-}

react/features/base/conference/reducer.js

     CONFERENCE_FAILED,
     CONFERENCE_JOINED,
     CONFERENCE_LEFT,
+    CONFERENCE_SUBJECT_CHANGED,
     CONFERENCE_WILL_JOIN,
     CONFERENCE_WILL_LEAVE,
     LOCK_STATE_CHANGED,
     SET_FOLLOW_ME,
     SET_MAX_RECEIVER_VIDEO_QUALITY,
     SET_PASSWORD,
+    SET_PENDING_SUBJECT_CHANGE,
     SET_PREFERRED_RECEIVER_VIDEO_QUALITY,
     SET_ROOM,
     SET_SIP_GATEWAY_ENABLED,
         case CONFERENCE_JOINED:
             return _conferenceJoined(state, action);
 
+        case CONFERENCE_SUBJECT_CHANGED:
+            return set(state, 'subject', action.subject);
+
         case CONFERENCE_LEFT:
         case CONFERENCE_WILL_LEAVE:
             return _conferenceLeftOrWillLeave(state, action);
         case SET_PASSWORD:
             return _setPassword(state, action);
 
+        case SET_PENDING_SUBJECT_CHANGE:
+            return set(state, 'pendingSubjectChange', action.subject);
+
         case SET_PREFERRED_RECEIVER_VIDEO_QUALITY:
             return set(
                 state,

react/features/conference/components/web/Conference.js

 
 import Labels from './Labels';
 import { default as Notice } from './Notice';
+import { default as Subject } from './Subject';
 
 declare var APP: Object;
 declare var config: Object;
                 id = 'videoconference_page'
                 onMouseMove = { this._onShowToolbar }>
                 <Notice />
+                <Subject />
                 <div id = 'videospace'>
                     <LargeVideo />
                     { hideVideoQualityLabel

react/features/conference/components/web/Subject.js

+/* @flow */
+
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+
+import { isToolboxVisible } from '../../../toolbox';
+
+/**
+ * The type of the React {@code Component} props of {@link Subject}.
+ */
+type Props = {
+
+    /**
+     * The subject of the conference.
+     */
+    _subject: string,
+
+    /**
+     * Indicates whether the component should be visible or not.
+     */
+    _visible: boolean
+};
+
+/**
+ * Subject react component.
+ *
+ * @class Subject
+ */
+class Subject extends Component<Props> {
+
+    /**
+     * Implements React's {@link Component#render()}.
+     *
+     * @inheritdoc
+     * @returns {ReactElement}
+     */
+    render() {
+        const { _subject, _visible } = this.props;
+
+        return (
+            <div className = { `subject ${_visible ? 'visible' : ''}` }>
+                { _subject }
+            </div>
+        );
+    }
+}
+
+/**
+ * Maps (parts of) the Redux state to the associated
+ * {@code Subject}'s props.
+ *
+ * @param {Object} state - The Redux state.
+ * @private
+ * @returns {{
+ *     _subject: string,
+ *     _visible: boolean
+ * }}
+ */
+function _mapStateToProps(state) {
+    const { subject } = state['features/base/conference'];
+
+    return {
+        _subject: subject,
+        _visible: isToolboxVisible(state)
+    };
+}
+export default connect(_mapStateToProps)(Subject);

react/features/toolbox/components/web/Toolbox.js

     setToolbarHovered
 } from '../../actions';
 import AudioMuteButton from '../AudioMuteButton';
+import { isToolboxVisible } from '../../functions';
 import HangupButton from '../HangupButton';
 import OverflowMenuButton from './OverflowMenuButton';
 import OverflowMenuProfileItem from './OverflowMenuProfileItem';
     } = state['features/base/config'];
     const sharedVideoStatus = state['features/shared-video'].status;
     const {
-        alwaysVisible,
         fullScreen,
-        overflowMenuVisible,
-        timeoutID,
-        visible
+        overflowMenuVisible
     } = state['features/toolbox'];
     const localParticipant = getLocalParticipant(state);
     const localRecordingStates = state['features/local-recording'];
         _sharingVideo: sharedVideoStatus === 'playing'
             || sharedVideoStatus === 'start'
             || sharedVideoStatus === 'pause',
-        _visible: Boolean(timeoutID || visible || alwaysVisible),
+        _visible: isToolboxVisible(state),
 
         // XXX: We are not currently using state here, but in the future, when
         // interfaceConfig is part of redux we will.

react/features/toolbox/functions.any.js

-// @flow
-
-import { toState } from '../base/redux';
-
-/**
- * Returns true if the toolbox is visible.
- *
- * @param {Object | Function} stateful - A function or object that can be
- * resolved to Redux state by the function {@code toState}.
- * @returns {boolean}
- */
-export function isToolboxVisible(stateful: Object | Function) {
-    const { alwaysVisible, enabled, visible }
-        = toState(stateful)['features/toolbox'];
-
-    return enabled && (alwaysVisible || visible);
-}

react/features/toolbox/functions.native.js

 // @flow
 
-export * from './functions.any';
+import { toState } from '../base/redux';
+
+/**
+ * Returns true if the toolbox is visible.
+ *
+ * @param {Object | Function} stateful - A function or object that can be
+ * resolved to Redux state by the function {@code toState}.
+ * @returns {boolean}
+ */
+export function isToolboxVisible(stateful: Object | Function) {
+    const { alwaysVisible, enabled, visible }
+        = toState(stateful)['features/toolbox'];
+
+    return enabled && (alwaysVisible || visible);
+}

react/features/toolbox/functions.web.js

 // @flow
 
-export * from './functions.any';
-
 declare var interfaceConfig: Object;
 
 /**
 export function isButtonEnabled(name: string) {
     return interfaceConfig.TOOLBAR_BUTTONS.indexOf(name) !== -1;
 }
+
+
+/**
+ * Indicates if the toolbox is visible or not.
+ *
+ * @param {string} state - The state from the Redux store.
+ * @returns {boolean} - True to indicate that the toolbox is visible, false -
+ * otherwise.
+ */
+export function isToolboxVisible(state: Object) {
+    const {
+        alwaysVisible,
+        timeoutID,
+        visible
+    } = state['features/toolbox'];
+
+    return Boolean(timeoutID || visible || alwaysVisible);
+}