Unifrms messageHandler access and adds enable disable

modules/UI/Feedback.js

 /* global $, APP, config, interfaceConfig */
 import UIEvents from "../../service/UI/UIEvents";
 
-/*
- * Created by Yana Stamcheva on 2/10/15.
- */
-var messageHandler = require("./util/MessageHandler");
-
 /**
  * Constructs the html for the overall feedback window.
  *

modules/UI/UI.js

         $("#downloadlog").css("display", "none");
         BottomToolbar.hide();
         FilmStrip.setupFilmStripOnly();
-        messageHandler.disableNotifications();
+        messageHandler.enableNotifications(false);
         $('body').popover("disable");
         JitsiPopover.enabled = false;
     }

modules/UI/authentication/LoginDialog.js

 /* global $, APP, config*/
 
-var messageHandler = require('../util/MessageHandler');
-
 /**
  * Build html for "password required" dialog.
  * @returns {string} html string
         }
     };
 
-    var connDialog = messageHandler.openDialogWithStates(
+    var connDialog = APP.UI.messageHandler.openDialogWithStates(
         states, { persistent: true, closeText: '' }, null
     );
 
      * @returns auth dialog
      */
     showExternalAuthDialog: function (url, callback) {
-        var dialog = messageHandler.openCenteredPopup(
+        var dialog = APP.UI.messageHandler.openCenteredPopup(
             url, 910, 660,
             // On closed
             callback
         );
 
         if (!dialog) {
-            messageHandler.openMessageDialog(null, "dialog.popupError");
+            APP.UI.messageHandler.openMessageDialog(null, "dialog.popupError");
         }
 
         return dialog;

modules/UI/authentication/RoomLocker.js

 /* global APP, JitsiMeetJS */
-import messageHandler from '../util/MessageHandler';
 import UIUtil from '../util/UIUtil';
 //FIXME:
 import AnalyticsAdapter from '../../statistics/AnalyticsAdapter';
     `;
 
     return new Promise(function (resolve, reject) {
-        messageHandler.openTwoButtonDialog(
+        APP.UI.messageHandler.openTwoButtonDialog(
             null, null, null,
             msg, false, "dialog.Save",
             function (e, v, m, f) {
                     resolve(UIUtil.escapeHtml(f.lockKey));
                 }
                 else {
-                    reject(messageHandler.CANCEL);
+                    reject(APP.UI.messageHandler.CANCEL);
                 }
             },
             null, null, 'input:first'
                placeholder="${passMsg}" autofocus>
     `;
     return new Promise(function (resolve, reject) {
-        messageHandler.openTwoButtonDialog(
+        APP.UI.messageHandler.openTwoButtonDialog(
             null, null, null, msg,
             true, "dialog.Ok",
             function (e, v, m, f) {}, null,
                 if (v && f.lockKey) {
                     resolve(UIUtil.escapeHtml(f.lockKey));
                 } else {
-                    reject(messageHandler.CANCEL);
+                    reject(APP.UI.messageHandler.CANCEL);
                 }
             },
             ':input:first'
  */
 function askToUnlock () {
     return new Promise(function (resolve, reject) {
-        messageHandler.openTwoButtonDialog(
+        APP.UI.messageHandler.openTwoButtonDialog(
             null, null, "dialog.passwordCheck",
             null, false, "dialog.Remove",
             function (e, v) {
                 if (v) {
                     resolve();
                 } else {
-                    reject(messageHandler.CANCEL);
+                    reject(APP.UI.messageHandler.CANCEL);
                 }
             }
         );
  */
 function notifyPasswordNotSupported () {
     console.warn('room passwords not supported');
-    messageHandler.showError("dialog.warning", "dialog.passwordNotSupported");
+    APP.UI.messageHandler.showError(
+        "dialog.warning", "dialog.passwordNotSupported");
 }
 
 /**
  */
 function notifyPasswordFailed(err) {
     console.warn('setting password failed', err);
-    messageHandler.showError("dialog.lockTitle", "dialog.lockMessage");
+    APP.UI.messageHandler.showError(
+        "dialog.lockTitle", "dialog.lockMessage");
 }
 
 const ConferenceErrors = JitsiMeetJS.errors.conference;
                 AnalyticsAdapter.sendEvent('toolbar.lock.disabled');
             }).catch(
                 reason => {
-                    if (reason !== messageHandler.CANCEL)
+                    if (reason !== APP.UI.messageHandler.CANCEL)
                         console.error(reason);
                 }
             );
                 AnalyticsAdapter.sendEvent('toolbar.lock.enabled');
             }).catch(
                 reason => {
-                    if (reason !== messageHandler.CANCEL)
+                    if (reason !== APP.UI.messageHandler.CANCEL)
                         console.error(reason);
                 }
             );
                 newPass => { password = newPass; }
             ).catch(
                 reason => {
-                    if (reason !== messageHandler.CANCEL)
+                    if (reason !== APP.UI.messageHandler.CANCEL)
                         console.error(reason);
                 }
             );
          */
         notifyModeratorRequired () {
             if (password) {
-                messageHandler.openMessageDialog(null, "dialog.passwordError");
+                APP.UI.messageHandler
+                    .openMessageDialog(null, "dialog.passwordError");
             } else {
-                messageHandler.openMessageDialog(null, "dialog.passwordError2");
+                APP.UI.messageHandler
+                    .openMessageDialog(null, "dialog.passwordError2");
             }
         }
     };

modules/UI/recording/Recording.js

             Feedback.enableFeedback(false);
             Toolbar.enable(false);
             BottomToolbar.enable(false);
+            APP.UI.messageHandler.enableNotifications(false);
+            APP.UI.messageHandler.enablePopups(false);
         }
     },
 

modules/UI/shared_video/SharedVideo.js

 /* global $, APP, YT, onPlayerReady, onPlayerStateChange, onPlayerError */
 
-import messageHandler from '../util/MessageHandler';
 import UIUtil from '../util/UIUtil';
 import UIEvents from '../../../service/UI/UIEvents';
 
                 this.emitter.emit(
                     UIEvents.UPDATE_SHARED_VIDEO, this.url, 'stop'));
         } else {
-            messageHandler.openMessageDialog(
+            APP.UI.messageHandler.openMessageDialog(
                 "dialog.shareVideoTitle",
                 "dialog.alreadySharedVideoMsg"
             );
  */
 function showStopVideoPropmpt() {
     return new Promise(function (resolve, reject) {
-        messageHandler.openTwoButtonDialog(
+        APP.UI.messageHandler.openTwoButtonDialog(
             "dialog.removeSharedVideoTitle",
             null,
             "dialog.removeSharedVideoMsg",
     const defaultUrl = i18n.translateString("defaultLink", i18nOptions);
 
     return new Promise(function (resolve, reject) {
-        let dialog = messageHandler.openDialogWithStates({
+        let dialog = APP.UI.messageHandler.openDialogWithStates({
             state0: {
                 html:  `
                     <h2>${title}</h2>

modules/UI/toolbars/Toolbar.js

 /* global APP, $, config, interfaceConfig */
 /* jshint -W101 */
-import messageHandler from '../util/MessageHandler';
 import UIUtil from '../util/UIUtil';
 import AnalyticsAdapter from '../../statistics/AnalyticsAdapter';
 import UIEvents from '../../../service/UI/UIEvents';
     } else {
         inviteAttributes = "value=\"" + encodeURI(roomUrl) + "\"";
     }
-    messageHandler.openTwoButtonDialog(
+    APP.UI.messageHandler.openTwoButtonDialog(
         "dialog.shareLink", null, null,
         `<input id="inviteLinkRef" type="text" ${inviteAttributes} onclick="this.select();" readonly>`,
         false, "dialog.Invite",
     "toolbar_button_logout": function () {
         AnalyticsAdapter.sendEvent('toolbar.authenticate.logout.clicked');
         // Ask for confirmation
-        messageHandler.openTwoButtonDialog(
+        APP.UI.messageHandler.openTwoButtonDialog(
             "dialog.logoutTitle",
             null,
             "dialog.logoutQuestion",
         : '';
 
     let sipMsg = APP.translation.generateTranslationHTML("dialog.sipMsg");
-    messageHandler.openTwoButtonDialog(
+    APP.UI.messageHandler.openTwoButtonDialog(
         null, null, null,
         `<h2>${sipMsg}</h2>
             <input name="sipNumber" type="text" value="${defaultNumber}" autofocus>`,

modules/UI/util/MessageHandler.js

  * Flag for enable/disable of the notifications.
  * @type {boolean}
  */
-var notificationsEnabled = true;
+let notificationsEnabled = true;
+
+/**
+ * Flag for enabling/disabling popups.
+ * @type {boolean}
+ */
+let popupEnabled = true;
+
+var messageHandler = {
+    OK: "dialog.OK",
+    CANCEL: "dialog.Cancel",
 
-var messageHandler = (function(my) {
-    my.OK = "dialog.OK",
-    my.CANCEL = "dialog.Cancel",
     /**
      * Shows a message to the user.
      *
      * @param message the message to show. If a falsy value is provided,
      * messageKey will be used to get a message via the translation API.
      */
-    my.openMessageDialog = function(titleKey, messageKey, title, message) {
+    openMessageDialog: function(titleKey, messageKey, title, message) {
+        if (!popupEnabled)
+            return;
+
         if (!title) {
             title = APP.translation.generateTranslationHTML(titleKey);
         }
         $.prompt(message,
             {title: title, persistent: false}
         );
-    };
-
+    },
     /**
      * Shows a message to the user with two buttons: first is given as a
      * parameter and the second is Cancel.
      * @param defaultButton index of default button which will be activated when
      *        the user press 'enter'. Indexed from 0.
      */
-    my.openTwoButtonDialog = function(titleKey, titleString, msgKey, msgString,
+    openTwoButtonDialog: function(titleKey, titleString, msgKey, msgString,
         persistent, leftButtonKey, submitFunction, loadedFunction,
         closeFunction, focus, defaultButton) {
+
+        if (!popupEnabled)
+            return;
+
         var buttons = [];
 
         var leftButton = APP.translation.generateTranslationHTML(leftButtonKey);
             submit: submitFunction,
             close: closeFunction
         });
-    };
+    },
 
     /**
      * Shows a message to the user with two buttons: first is given as a
      * @param loadedFunction function to be called after the prompt is fully
      *        loaded
      */
-    my.openDialog = function (titleString, msgString, persistent, buttons,
+    openDialog: function (titleString, msgString, persistent, buttons,
                               submitFunction, loadedFunction) {
+        if (!popupEnabled)
+            return;
+
         var args = {
             title: titleString,
             persistent: persistent,
             args.closeText = '';
         }
         return new Impromptu(msgString, args);
-    };
+    },
 
     /**
      * Closes currently opened dialog.
      */
-    my.closeDialog = function () {
+    closeDialog: function () {
         $.prompt.close();
-    };
+    },
 
     /**
      * Shows a dialog with different states to the user.
      *
      * @param statesObject object containing all the states of the dialog.
      */
-    my.openDialogWithStates = function (statesObject, options) {
+    openDialogWithStates: function (statesObject, options) {
+        if (!popupEnabled)
+            return;
+
         return new Impromptu(statesObject, options);
-    };
+    },
 
     /**
      * Opens new popup window for given <tt>url</tt> centered over current
      * @returns {object} popup window object if opened successfully or undefined
      *          in case we failed to open it(popup blocked)
      */
-    my.openCenteredPopup = function (url, w, h, onPopupClosed) {
+    openCenteredPopup: function (url, w, h, onPopupClosed) {
+        if (!popupEnabled)
+            return;
+
         var l = window.screenX + (window.innerWidth / 2) - (w / 2);
         var t = window.screenY + (window.innerHeight / 2) - (h / 2);
         var popup = window.open(
             }, 200);
         }
         return popup;
-    };
+    },
 
     /**
      * Shows a dialog prompting the user to send an error report.
      * @param msgKey the text of the message
      * @param error the error that is being reported
      */
-    my.openReportDialog = function(titleKey, msgKey, error) {
-        my.openMessageDialog(titleKey, msgKey);
+    openReportDialog: function(titleKey, msgKey, error) {
+        this.openMessageDialog(titleKey, msgKey);
         console.log(error);
         //FIXME send the error to the server
-    };
+    },
 
     /**
      *  Shows an error dialog to the user.
      * @param titleKey the title of the message.
      * @param msgKey the text of the message.
      */
-    my.showError = function(titleKey, msgKey) {
+    showError: function(titleKey, msgKey) {
 
         if (!titleKey) {
             titleKey = "dialog.oops";
             msgKey = "dialog.defaultError";
         }
         messageHandler.openMessageDialog(titleKey, msgKey);
-    };
+    },
 
     /**
      * Displayes notification.
      * @param messageArguments object with the arguments for the message.
      * @param options object with language options.
      */
-    my.notify = function(displayName, displayNameKey,
+    notify: function(displayName, displayNameKey,
                          cls, messageKey, messageArguments, options) {
+
         if(!notificationsEnabled)
             return;
+
         var displayNameSpan = '<span class="nickname" ';
         if (displayName) {
             displayNameSpan += ">" + UIUtil.escapeHtml(displayName);
             APP.translation.translateString(messageKey,
                 messageArguments) +
             '</span>', null, options);
-    };
+    },
 
     /**
      * Removes the toaster.
      * @param toasterElement
      */
-    my.remove = function(toasterElement) {
+    remove: function(toasterElement) {
         toasterElement.remove();
-    };
-
-    /**
-     * Disables notifications.
-     */
-    my.disableNotifications = function () {
-        notificationsEnabled = false;
-    };
+    },
 
     /**
-     * Enables notifications.
+     * Enables / disables notifications.
      */
-    my.enableNotifications = function () {
-        notificationsEnabled = true;
-    };
+    enableNotifications: function (enable) {
+        notificationsEnabled = enable;
+    },
 
-    return my;
-}(messageHandler || {}));
+    enablePopups: function (enable) {
+        popupEnabled = enable;
+    }
+};
 
 module.exports = messageHandler;