store userId and callStatsUserName globally (was per-conference)

move sessionId reading/storing into Settings.js

.jshintignore

 modules/xmpp/ChatRoom.js
 modules/statistics/RTPStatsCollector.js
 modules/statistics/LocalStatsCollector.js
-modules/settings/Settings.js
 modules/connectionquality/connectionquality.js
 modules/RTC/adapter.screenshare.js
 modules/statistics/statistics.js

JitsiConference.js

     this.xmpp = this.connection.xmpp;
     this.eventEmitter = new EventEmitter();
     var confID = this.options.name  + '@' + this.xmpp.options.hosts.muc;
-    this.settings = new Settings(confID);
+    this.settings = new Settings();
     this.room = this.xmpp.createRoom(this.options.name, this.options.config,
         this.settings);
     this.room.updateDeviceAvailability(RTC.getDeviceAvailability());

modules/settings/Settings.js

 
 var UsernameGenerator = require('../util/UsernameGenerator');
 
+/**
+ * Check if browser supports localStorage.
+ * @returns {boolean} true if supports, false otherwise
+ */
 function supportsLocalStorage() {
     try {
         return 'localStorage' in window && window.localStorage !== null;
     } catch (e) {
-        logger.log("localstorage is not supported");
         return false;
     }
 }
     return _p8() + _p8() + _p8() + _p8();
 }
 
-function Settings(conferenceID) {
-    this.displayName = '';
+/**
+ * Generate unique id.
+ * @returns {string} random unique id
+ */
+function generateJitsiMeetId() {
+    var jitsiMeetId = generateUniqueId();
+    logger.log("generated id", jitsiMeetId);
+
+    return jitsiMeetId;
+}
+
+/**
+ * Generate fake username for callstats.
+ * @returns {string} fake random username
+ */
+function generateCallStatsUsername() {
+    var username = UsernameGenerator.generateUsername();
+    logger.log('generated callstats uid', username);
+
+    return username;
+}
+
+function Settings() {
     this.userId;
-    this.confSettings = null;
-    this.conferenceID = conferenceID;
     this.callStatsUserName;
+
     if (supportsLocalStorage()) {
-        if(!window.localStorage.getItem(conferenceID))
-            this.confSettings = {};
-        else
-            this.confSettings = JSON.parse(window.localStorage.getItem(conferenceID));
-        if(!this.confSettings.jitsiMeetId) {
-            this.confSettings.jitsiMeetId = generateUniqueId();
-            logger.log("generated id", this.confSettings.jitsiMeetId);
-            this.save();
-        }
-        if (!this.confSettings.callStatsUserName) {
-            this.confSettings.callStatsUserName
-                = UsernameGenerator.generateUsername();
-            logger.log('generated callstats uid',
-                this.confSettings.callStatsUserName);
-            this.save();
-        }
-
-        this.userId = this.confSettings.jitsiMeetId || '';
-        this.displayName = this.confSettings.displayname || '';
-        this.callStatsUserName = this.confSettings.callStatsUserName || '';
+        this.userId = window.localStorage.getItem('jitsiMeetId')
+            || generateJitsiMeetId();
+
+
+        this.callStatsUserName = window.localStorage.getItem(
+            'callStatsUserName'
+        ) || generateCallStatsUsername();
+
+        this.save();
     } else {
-        logger.log("local storage is not supported");
-        this.userId = generateUniqueId();
-        this.callStatsUserName = UsernameGenerator.generateUsername();
+        logger.log("localStorage is not supported");
+        this.userId = generateJitsiMeetId();
+        this.callStatsUserName = generateCallStatsUsername();
     }
 }
 
+/**
+ * Save settings to localStorage if browser supports that.
+ */
 Settings.prototype.save = function () {
-    if (supportsLocalStorage()) {
-        window.localStorage.setItem(
-            this.conferenceID, JSON.stringify(this.confSettings)
-        );
+    if (!supportsLocalStorage()) {
+        return;
     }
-};
 
-Settings.prototype.setDisplayName = function (newDisplayName) {
-    this.displayName = newDisplayName;
-    if(this.confSettings != null)
-        this.confSettings.displayname = displayName;
-    this.save();
-    return this.displayName;
-}
+    window.localStorage.setItem('jitsiMeetId', this.userId);
+    window.localStorage.setItem('callStatsUserName', this.callStatsUserName);
+};
 
-Settings.prototype.getSettings = function () {
-    return {
-        displayName: this.displayName,
-        uid: this.userId
-    };
-}
+/**
+ * Returns current user id.
+ * @returns {string} user id
+ */
+Settings.prototype.getUserId = function () {
+    return this.userId;
+};
 
 /**
  * Returns fake username for callstats
  */
 Settings.prototype.getCallStatsUserName = function () {
     return this.callStatsUserName;
-}
+};
+
+/**
+ * Save current session id.
+ * @param {string} sessionId session id
+ */
+Settings.prototype.setSessionId = function (sessionId) {
+    if (sessionId) {
+        window.localStorage.setItem('sessionId', sessionId);
+    } else {
+        window.localStorage.removeItem('sessionId');
+    }
+};
+
+/**
+ * Clear current session id.
+ */
+Settings.prototype.clearSessionId = function () {
+    this.setSessionId(undefined);
+};
+
+/**
+ * Returns current session id.
+ * @returns {string} current session id
+ */
+Settings.prototype.getSessionId = function () {
+    // we can update session id in localStorage from
+    // another JitsiConference instance
+    // thats why we should always re-read it
+    return window.localStorage.getItem('sessionId');
+};
 
 module.exports = Settings;

modules/xmpp/moderator.js

                     event.origin);
                 return;
             }
-            localStorage.setItem('sessionId', event.data.sessionId);
+            settings.setSessionId(event.data.sessionId);
             // After popup is closed we will authenticate
         }
     }
     var elem = $iq({to: this.getFocusComponent(), type: 'set'});
 
     // Session Id used for authentication
-    var sessionId = localStorage.getItem('sessionId');
-    var machineUID = this.settings.getSettings().uid;
+    var sessionId = this.settings.getSessionId();
+    var machineUID = this.settings.getUserId();
 
     logger.info(
             "Session ID: " + sessionId + " machine UID: " + machineUID);
     var sessionId = $(resultIq).find('conference').attr('session-id');
     if (sessionId) {
         logger.info('Received sessionId:  ' + sessionId);
-        localStorage.setItem('sessionId', sessionId);
+        this.settings.setSessionId(sessionId);
     }
 };
 
                 = $(error).find('>error>session-invalid').length;
             if (invalidSession) {
                 logger.info("Session expired! - removing");
-                localStorage.removeItem("sessionId");
+                self.settings.clearSessionId();
             }
             if ($(error).find('>error>graceful-shutdown').length) {
                 self.eventEmitter.emit(XMPPEvents.GRACEFUL_SHUTDOWN);
     iq.c('login-url', {
         xmlns: 'http://jitsi.org/protocol/focus',
         room: this.roomName,
-        'machine-uid': this.settings.getSettings().uid
+        'machine-uid': this.settings.getUserId()
     });
     this.connection.sendIQ(
         iq,
     iq.c('login-url', {
         xmlns: 'http://jitsi.org/protocol/focus',
         room: this.roomName,
-        'machine-uid': this.settings.getSettings().uid,
+        'machine-uid': this.settings.getUserId(),
         popup: true
     });
     this.connection.sendIQ(
 
 Moderator.prototype.logout =  function (callback) {
     var iq = $iq({to: this.getFocusComponent(), type: 'set'});
-    var sessionId = localStorage.getItem('sessionId');
+    var sessionId = this.settings.getSessionId();
     if (!sessionId) {
         callback();
         return;
                 logoutUrl = decodeURIComponent(logoutUrl);
             }
             logger.info("Log out OK, url: " + logoutUrl, result);
-            localStorage.removeItem('sessionId');
+            this.settings.clearSessionId();
             callback(logoutUrl);
-        },
+        }.bind(this),
         function (error) {
             logger.error("Logout error", error);
         }