fix(recording): Show the button when the dropbox integration is disabled

react/features/recording/components/Recording/AbstractRecordButton.js

     getLocalParticipant,
     isLocalParticipantModerator
 } from '../../../base/participants';
-import { isEnabled as isDropboxEnabled } from '../../../dropbox';
 import {
     AbstractButton,
     type AbstractButtonProps
         const { features = {} } = getLocalParticipant(state);
 
         visible = isModerator
-            && fileRecordingsEnabled
-            && isDropboxEnabled(state);
+            && fileRecordingsEnabled;
 
         if (enableFeaturesBasedOnToken) {
             visible = visible && String(features.recording) === 'true';

react/features/recording/components/Recording/StartRecordingDialog.js

 } from '../../../analytics';
 import { Dialog } from '../../../base/dialog';
 import { JitsiRecordingConstants } from '../../../base/lib-jitsi-meet';
+import {
+    getDropboxData,
+    isEnabled as isDropboxEnabled
+} from '../../../dropbox';
 
 import StartRecordingDialogContent from './StartRecordingDialogContent';
-import { getDropboxData } from '../../../dropbox';
 
 type Props = {
 
      */
     _appKey: string,
 
+    /**
+     * If true the dropbox integration is enabled, otherwise - disabled.
+     */
+    _isDropboxEnabled: boolean,
+
     /**
      * The dropbox access token.
      */
      * @returns {void}
      */
     _onTokenUpdated() {
-        const { _appKey, _token } = this.props;
+        const { _appKey, _isDropboxEnabled, _token } = this.props;
+
+        if (!_isDropboxEnabled) {
+            return;
+        }
 
         if (typeof _token === 'undefined') {
             this.setState({
      */
     render() {
         const { isTokenValid, isValidating, spaceLeft, userName } = this.state;
+        const { _isDropboxEnabled } = this.props;
 
         return (
             <Dialog
-                okDisabled = { !isTokenValid }
+                okDisabled = { !isTokenValid && _isDropboxEnabled }
                 okTitleKey = 'dialog.confirm'
                 onSubmit = { this._onSubmit }
                 titleKey = 'dialog.recording'
                 width = 'small'>
                 <StartRecordingDialogContent
+                    integrationsEnabled = { _isDropboxEnabled }
                     isTokenValid = { isTokenValid }
                     isValidating = { isValidating }
                     spaceLeft = { spaceLeft }
         sendAnalytics(
             createRecordingDialogEvent('start', 'confirm.button')
         );
-        const { _conference, _token } = this.props;
+        const { _conference, _isDropboxEnabled, _token } = this.props;
+        let appData;
 
-        _conference.startRecording({
-            mode: JitsiRecordingConstants.mode.FILE,
-            appData: JSON.stringify({
+        if (_isDropboxEnabled) {
+            appData = JSON.stringify({
                 'file_recording_metadata': {
                     'upload_credentials': {
                         'service_name': 'dropbox',
                         'token': _token
                     }
                 }
-            })
+            });
+        }
+
+        _conference.startRecording({
+            mode: JitsiRecordingConstants.mode.FILE,
+            appData
         });
 
         return true;
     return {
         _appKey: dropbox.appKey,
         _conference: state['features/base/conference'].conference,
+        _isDropboxEnabled: isDropboxEnabled(state),
         _token: state['features/dropbox'].token
     };
 }

react/features/recording/components/Recording/StartRecordingDialogContent.js

      */
     dispatch: Function,
 
+    /**
+     * If true the content related to the integrations will be shown.
+     */
+    integrationsEnabled: boolean,
+
     /**
      * <tt>true</tt> if we have valid oauth token.
      */
      * @returns {React$Component}
      */
     render() {
+        if (this.props.integrationsEnabled) {
+            return this._renderIntegrationsContent();
+        }
+
+        return this._renderNoIntegrationsContent();
+    }
+
+    /**
+     * Renders the content in case no integrations were enabled.
+     *
+     * @returns {React$Component}
+     */
+    _renderNoIntegrationsContent() {
+        return (
+            <Container>
+                { this.props.t('recording.startRecordingBody') }
+            </Container>
+        );
+    }
+
+    /**
+     * Renders the content in case integrations were enabled.
+     *
+     * @protected
+     * @returns {React$Component}
+     */
+    _renderIntegrationsContent() {
         const { isTokenValid, isValidating, t } = this.props;
 
         let content = null;