better error handling while establishing connection

app.js

 import RoomnameGenerator from './modules/util/RoomnameGenerator';
 import CQEvents from './service/connectionquality/CQEvents';
 import UIEvents from './service/UI/UIEvents';
-import LoginDialog from './modules/UI/authentication/LoginDialog';
-import UIUtil from './modules/UI/util/UIUtil';
 
 import {openConnection} from './modules/connection';
 import AuthHandler from './modules/AuthHandler';
             room.addTrack(track);
             APP.UI.addLocalStream(track);
         });
+
+        APP.UI.updateAuthInfo(room.isAuthEnabled(), room.getAuthLogin());
     });
 
 
         APP.statistics.start();
         APP.connectionquality.init();
         APP.keyboardshortcut.init();
+    }).catch(function (err) {
+        console.error(err);
     });
 }
 

lib-jitsi-meet.js

     this.connection = this.options.connection;
     this.xmpp = this.connection.xmpp;
     this.eventEmitter = new EventEmitter();
-    this.room = this.xmpp.createRoom(this.options.name, null, null, this.options.config);
+    this.room = this.xmpp.createRoom(this.options.name, this.options.config);
     this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
     this.rtc = new RTC(this.room, options);
     if(!RTC.options.disableAudioLevels)
     this.lastActiveSpeaker = null;
     this.dtmfManager = null;
     this.somebodySupportsDTMF = false;
+    this.authEnabled = false;
+    this.authIdentity;
 }
 
 /**
     return this.options.name;
 };
 
+/**
+ * Check if authentication is enabled for this conference.
+ */
+JitsiConference.prototype.isAuthEnabled = function () {
+    return this.authEnabled;
+};
+
+/**
+ * Check if user is logged in.
+ */
+JitsiConference.prototype.isLoggedIn = function () {
+    return !!this.authIdentity;
+};
+
+/**
+ * Get authorized login.
+ */
+JitsiConference.prototype.getAuthLogin = function () {
+    return this.authIdentity;
+};
+
 /**
  * Check if external authentication is enabled for this conference.
  */
 
 JitsiConference.prototype.onMemberLeft = function (jid) {
     var id = Strophe.getResourceFromJid(jid);
+    if (id === 'focus') {
+       return;
+    }
     var participant = this.participants[id];
     delete this.participants[id];
     this.eventEmitter.emit(JitsiConferenceEvents.USER_LEFT, id, participant);
     });
 
     conference.room.addListener(AuthenticationEvents.IDENTITY_UPDATED, function (authEnabled, authIdentity) {
-        console.error(authEnabled, authIdentity);
+        conference.authEnabled = authEnabled;
+        conference.authIdentity = authIdentity;
     });
 
     conference.room.addListener(XMPPEvents.MESSAGE_RECEIVED, function (jid, displayName, txt, myJid, ts) {
     return this._connect(jid, password);
 };
 
-XMPP.prototype.createRoom = function (roomName, options, useNicks, nick) {
+XMPP.prototype.createRoom = function (roomName, options) {
     var roomjid = roomName  + '@' + this.options.hosts.muc;
 
-    if (useNicks) {
-        if (nick) {
-            roomjid += '/' + nick;
+    if (options.useNicks) {
+        if (options.nick) {
+            roomjid += '/' + options.nick;
         } else {
             roomjid += '/' + Strophe.getNodeFromJid(this.connection.jid);
         }

modules/UI/UI.js

     VideoLayout.updateConnectionStats(jid, percent, stats);
 };
 
-UI.showAuthenticateButton = function (show) {
-    Toolbar.showAuthenticateButton(show);
-};
-
 UI.markVideoInterrupted = function (interrupted) {
     if (interrupted) {
         VideoLayout.onVideoInterrupted();
     messageHandler.showError("dialog.error", "dialog.tokenAuthFailed");
 };
 
+UI.updateAuthInfo = function (isAuthEnabled, login) {
+    let loggedIn = !!login;
+
+    if (isAuthEnabled) {
+        Toolbar.setAuthenticatedIdentity(login);
+
+        Toolbar.showLoginButton(!loggedIn);
+        Toolbar.showLogoutButton(loggedIn);
+    }
+};
+
 module.exports = UI;

modules/UI/authentication/LoginDialog.js

         <h2 data-i18n="dialog.passwordRequired">${passRequiredMsg}</h2>
         <input name="username" type="text" placeholder=${placeholder} autofocus>
         <input name="password" type="password"
-               data-i18n="[placeholder]dialog.userPassword"
-               placeholder="user password">
-    `;
+    data-i18n="[placeholder]dialog.userPassword"
+    placeholder="user password">
+        `;
+}
+
+function toJid(id) {
+    if (id.indexOf("@") >= 0) {
+        return id;
+    }
+
+    let jid = id.concat('@');
+    if (config.hosts.authdomain) {
+        jid += config.hosts.authdomain;
+    } else {
+        jid += config.hosts.domain;
+    }
+
+    return jid;
+}
+
+function cancelButton() {
+    return {
+        title: APP.translation.generateTranslationHTML("dialog.Cancel"),
+        value: false
+    };
 }
 
 function Dialog(successCallback, cancelCallback) {
+    let loginButtons = [{
+        title: APP.translation.generateTranslationHTML("dialog.Ok"),
+        value: true
+    }];
+    let finishedButtons = [{
+        title: APP.translation.translateString('dialog.retry'),
+        value: 'retry'
+    }];
+
+    // show "cancel" button only if cancelCallback provided
+    if (cancelCallback) {
+        loginButtons.push(cancelButton());
+        finishedButtons.push(cancelButton());
+    }
+
     const states = {
         login: {
             html: getPasswordInputHtml(),
-            buttons: [{
-                title: APP.translation.generateTranslationHTML("dialog.Ok"),
-                value: true
-            }, {
-                title: APP.translation.generateTranslationHTML("dialog.Cancel"),
-                value: false
-            }],
+            buttons: loginButtons,
             focus: ':input:first',
             submit: function (e, v, m, f) {
                 e.preventDefault();
                     let password = f.password;
                     if (jid && password) {
                         connDialog.goToState('connecting');
-                        successCallback(jid, password);
+                        successCallback(toJid(jid), password);
                     }
                 } else {
                     // User cancelled
         finished: {
             title: APP.translation.translateString('dialog.error'),
             html:   '<div id="errorMessage"></div>',
-            buttons: [{
-                title: APP.translation.translateString('dialog.retry'),
-                value: 'retry'
-            }, {
-                title: APP.translation.generateTranslationHTML("dialog.Cancel"),
-                value: false
-            }],
+            buttons: finishedButtons,
             defaultButton: 0,
             submit: function (e, v, m, f) {
                 e.preventDefault();

modules/connection.js

 const ConnectionEvents = JitsiMeetJS.events.connection;
 const ConnectionErrors = JitsiMeetJS.errors.connection;
 
-export function openConnection({retry, id, password}) {
+function connect(id, password) {
     let connection = new JitsiMeetJS.JitsiConnection(null, null, {
         hosts: config.hosts,
         bosh: config.bosh,
             ConnectionEvents.CONNECTION_ESTABLISHED, handleConnectionEstablished
         );
         connection.addEventListener(
-            ConnectionEvents.CONNECTION_FAILED, onConnectionFailed
+            ConnectionEvents.CONNECTION_FAILED, handleConnectionFailed
         );
-        let authDialog;
 
         function unsubscribe() {
             connection.removeEventListener(
                 handleConnectionEstablished
             );
             connection.removeEventListener(
-                ConnectionEvents.CONNECTION_FAILED, onConnectionFailed
+                ConnectionEvents.CONNECTION_FAILED,
+                handleConnectionFailed
             );
-            if (authDialog) {
-                authDialog.close();
-            }
         }
 
         function handleConnectionEstablished() {
 
         function handleConnectionFailed(err) {
             unsubscribe();
+            console.error("CONNECTION FAILED:", err);
             reject(err);
         }
 
-        function onConnectionFailed (err) {
-            console.error("CONNECTION FAILED:", err);
+        connection.connect({id, password});
+    });
+}
 
-            if (!retry) {
-                handleConnectionFailed(err);
-                return;
+function requestAuth() {
+    return new Promise(function (resolve, reject) {
+        let authDialog = LoginDialog.showAuthDialog(
+            function (id, password) {
+                connect(id, password).then(function (connection) {
+                    authDialog.close();
+                    resolve(connection);
+                }, function (err) {
+                    if (err === ConnectionErrors.PASSWORD_REQUIRED) {
+                        authDialog.displayError(err);
+                    } else {
+                        authDialog.close();
+                        reject(err);
+                    }
+                });
             }
+        );
+    });
+}
 
-            // retry only if auth failed
-            if (err !== ConnectionErrors.PASSWORD_REQUIRED) {
-                handleConnectionFailed(err);
-                return;
-            }
+export function openConnection({id, password, retry}) {
+    return connect(id, password).catch(function (err) {
+        if (!retry) {
+            throw err;
+        }
 
+        if (err === ConnectionErrors.PASSWORD_REQUIRED) {
             // do not retry if token is not valid
             if (config.token) {
-                handleConnectionFailed(err);
-                return;
-            }
-
-            // ask for password and try again
-
-            if (authDialog) {
-                authDialog.displayError(err);
-                return;
+                throw err;
+            } else {
+                return requestAuth();
             }
-
-            authDialog = LoginDialog.showAuthDialog(
-                function (id, password) {
-                    connection.connect({id, password});
-                }
-            );
+        } else {
+            throw err;
         }
-
-        connection.connect(id, password);
     });
 }

modules/desktopsharing/desktopsharing.js

     
     init: function () {
         // Called when RTC finishes initialization
+        return;
         APP.RTC.addListener(RTCEvents.RTC_READY,
             function() {
                 screenObtainer.init(eventEmitter);

modules/statistics/statistics.js

         stopRemote();
     },
     start: function () {
+        return;
         APP.RTC.addStreamListener(onStreamCreated,
             StreamEventTypes.EVENT_TYPE_LOCAL_CREATED);
         APP.xmpp.addListener(XMPPEvents.DISPOSE_CONFERENCE,