Comply w/ codying style: naming, formatting, etc.

conference.js

     _onConferenceFailed(err, ...params) {
         APP.store.dispatch(conferenceFailed(room, err, ...params));
         logger.error('CONFERENCE FAILED:', err, ...params);
-        APP.UI.hideRingOverLay();
+        APP.UI.hideRingOverlay();
         switch (err) {
 
         case ConferenceErrors.CONNECTION_ERROR:
      */
     hangup(requestFeedback = false) {
         eventEmitter.emit(JitsiMeetConferenceEvents.BEFORE_HANGUP);
-        APP.UI.hideRingOverLay();
+        APP.UI.hideRingOverlay();
         let requestFeedbackPromise = requestFeedback
                 ? APP.UI.requestFeedbackOnHangup()
                 // false - because the thank you dialog shouldn't be displayed

modules/UI/UI.js

 
 var UI = {};
 
-import {
-    updateDeviceList
-} from '../../react/features/base/devices';
-
 import Chat from "./side_pannels/chat/Chat";
 import SidePanels from "./side_pannels/SidePanels";
 import Avatar from "./avatar/Avatar";
 import UIErrors from './UIErrors';
 import { debounce } from "../util/helpers";
 
+
+import {
+    updateDeviceList
+} from '../../react/features/base/devices';
 import {
     setAudioMuted,
     setVideoMuted
 UI.addUser = function (user) {
     var id = user.getId();
     var displayName = user.getDisplayName();
-    UI.hideRingOverLay();
+    UI.hideRingOverlay();
     if (UI.ContactList)
         UI.ContactList.addContact(id);
 
     Filmstrip.toggleFilmstrip(false, false);
 };
 
-UI.hideRingOverLay = function () {
-    if (!RingOverlay.hide())
-        return;
-    Filmstrip.toggleFilmstrip(true, false);
-};
+UI.hideRingOverlay
+    = () => RingOverlay.hide() && Filmstrip.toggleFilmstrip(true, false);
 
 /**
  * Indicates if any the "top" overlays are currently visible. The check includes
- * the call overlay, suspended overlay, GUM permissions overlay
- * and a page reload overlay.
+ * the call overlay, the suspended overlay, the GUM permissions overlay, and the
+ * page-reload overlay.
  *
- * @returns {*|boolean} {true} if the overlay is visible, {false} otherwise
+ * @returns {*|boolean} {true} if an overlay is visible; {false}, otherwise
  */
 UI.isOverlayVisible = function () {
-    return RingOverlay.isVisible() || this.overlayVisible;
+    return this.isRingOverlayVisible() || this.overlayVisible;
 };
 
 /**

modules/UI/ring_overlay/RingOverlay.js

 /* global $, APP */
-/* jshint -W101 */
+
 import UIEvents from "../../../service/UI/UIEvents";
 
 /**
     /**
      *
      * @param callee The callee (Object) as defined by the JWT support.
-     * @param {boolean} disableRingingSound if true the ringing sound wont be played.
+     * @param {boolean} disableRinging if true the ringing sound wont be played.
      */
-    constructor(callee, disableRingingSound) {
+    constructor(callee, disableRinging) {
         this._containerId = 'ringOverlay';
         this._audioContainerId = 'ringOverlayRinging';
         this.isRinging = true;
         this.callee = callee;
-        this.disableRingingSound = disableRingingSound;
+        this.disableRinging = disableRinging;
         this.render();
-        if(!disableRingingSound)
+        if (!disableRinging)
             this._initAudio();
-        this._timeout = setTimeout(() => {
-            this.destroy();
-            this.render();
-        }, 30000);
+        this._timeout
+            = setTimeout(
+                    () => {
+                        this.destroy();
+                        this.render();
+                    },
+                    30000);
     }
 
     /**
     _initAudio() {
         this.audio = document.getElementById(this._audioContainerId);
         this.audio.play();
-        this._setAudioTimeout();
+        this.interval = setInterval(() => this.audio.play(), 5000);
     }
 
     /**
      */
     _changeBackground(solid) {
         const container = $("#" + this._containerId);
-        if(solid) {
+
+        if (solid) {
             container.addClass("solidBG");
         } else {
             container.removeClass("solidBG");
     _getHtmlStr(callee) {
         let callingLabel = this.isRinging ? "<p>Calling...</p>" : "";
         let callerStateLabel =  this.isRinging ? "" : " isn't available";
-        let audioHTML = this.disableRingingSound ? ""
+        let audioHTML = this.disableRinging ? ""
             : "<audio id=\"" + this._audioContainerId
                 + "\" src=\"./sounds/ring.ogg\" />";
+
         return `
             <div id="${this._containerId}" class='ringing' >
                 <div class='ringing__content'>
         if (this.interval) {
             clearInterval(this.interval);
         }
-        if(this._timeout) {
+        if (this._timeout) {
             clearTimeout(this._timeout);
         }
     }
-
-    /**
-     * Sets the interval that is going to play the ringing sound.
-     */
-    _setAudioTimeout() {
-        this.interval = setInterval( () => {
-            this.audio.play();
-        }, 5000);
-    }
 }
 
 export default {
      *
      * @param {Object} callee - The callee. Object containing data about
      * callee.
-     * @param {boolean} disableRingingSound - If true the ringing sound won't be
+     * @param {boolean} disableRinging - If true the ringing sound won't be
      * played.
      * @returns {void}
      */
-    show(callee, disableRingingSound = false) {
-        if(overlay) {
+    show(callee, disableRinging = false) {
+        if (overlay) {
             this.hide();
         }
 
-        overlay = new RingOverlay(callee, disableRingingSound);
+        overlay = new RingOverlay(callee, disableRinging);
         APP.UI.addListener(UIEvents.LARGE_VIDEO_AVATAR_VISIBLE,
             onAvatarVisible);
     },
      * overlay.
      */
     hide() {
-        if(!overlay) {
+        if (!overlay) {
             return false;
         }
         overlay.destroy();
      * @returns {boolean} true if the ring overlay is currently displayed or
      * false otherwise.
      */
-    isVisible () {
+    isVisible() {
         return overlay !== null;
     }
 };

react/features/base/connection/actions.web.js

             }
         })
             .catch(error => {
-                APP.UI.hideRingOverLay();
+                APP.UI.hideRingOverlay();
                 APP.API.notifyConferenceLeft(APP.conference.roomName);
                 logger.error(error);
 

react/features/overlay/components/OverlayContainer.js

 
         this.state = {
             /**
-             * Indicates whether the filmstrip only mode is enabled or not.
+             * The indicator which determines whether filmstrip-only mode is
+             * enabled.
              *
              * @type {boolean}
              */
-            filmstripOnly: interfaceConfig.filmStripOnly
+            filmstripOnly:
+                typeof interfaceConfig === 'object'
+                    && interfaceConfig.filmStripOnly
         };
     }
 
      * @protected
      */
     componentDidUpdate() {
-        // FIXME: Temporary workaround until everything is moved to react.
-        APP.UI.overlayVisible
-            = (this.props._connectionEstablished && this.props._haveToReload)
-                || this.props._suspendDetected
-                || this.props._isMediaPermissionPromptVisible;
+        if (typeof APP === 'object') {
+            APP.UI.overlayVisible
+                = (this.props._connectionEstablished
+                        && this.props._haveToReload)
+                    || this.props._suspendDetected
+                    || this.props._isMediaPermissionPromptVisible;
+        }
     }
 
     /**
                 = filmstripOnly
                     ? UserMediaPermissionsFilmstripOnlyOverlay
                     : UserMediaPermissionsOverlay;
-            props = { browser: this.props._browser };
+            props = {
+                browser: this.props._browser
+            };
         }
 
         return (

react/features/unsupported-browser/components/HideNotificationBarStyle.js

+/* @flow */
+
 import React, { Component } from 'react';
 
 /**