Call mucJoined of video layout when the actual joining occurs, as the local id is needed when the presence for the email is received/processed and avatar is set.

conference.js

             });
 
             APP.UI.updateAuthInfo(room.isAuthEnabled(), room.getAuthLogin());
+            APP.UI.mucJoined();
         });
 
 

libs/lib-jitsi-meet.js

     this.room.muteParticipant(participant.getJid(), true);
 };
 
-JitsiConference.prototype.onMemberJoined = function (jid, email, nick) {
+JitsiConference.prototype.onMemberJoined = function (jid, nick) {
     var id = Strophe.getResourceFromJid(jid);
     if (id === 'focus' || this.myUserId() === id) {
        return;
 var Logger = require("jitsi-meet-logger");
 var RTC = require("./modules/RTC/RTC");
 var Statistics = require("./modules/statistics/statistics");
+var Resolutions = require("./service/RTC/Resolutions");
+
+function getLowerResolution(resolution) {
+    if(!Resolutions[resolution])
+        return null;
+    var order = Resolutions[resolution].order;
+    var res = null;
+    var resName = null;
+    for(var i in Resolutions) {
+        var tmp = Resolutions[i];
+        if (!res || (res.order < tmp.order && tmp.order < order)) {
+            resName = i;
+            res = tmp;
+        }
+    }
+    return resName;
+}
 
 /**
  * Namespace for the interface of Jitsi Meet Library.
                         }
                     }
                 return tracks;
+            }).catch(function (error) {
+                if(error === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {
+                    var oldResolution = options.resolution || '360';
+                    var newResolution = getLowerResolution(oldResolution);
+                    if(newResolution === null)
+                        return Promise.reject(error);
+                    options.resolution = newResolution;
+                    return LibJitsiMeet.createLocalTracks(options);
+                }
+                return Promise.reject(error);
             });
     },
     /**
 
 module.exports = LibJitsiMeet;
 
-},{"./JitsiConferenceErrors":2,"./JitsiConferenceEvents":3,"./JitsiConnection":4,"./JitsiConnectionErrors":5,"./JitsiConnectionEvents":6,"./JitsiTrackErrors":9,"./JitsiTrackEvents":10,"./modules/RTC/RTC":16,"./modules/statistics/statistics":24,"es6-promise":46,"jitsi-meet-logger":48}],8:[function(require,module,exports){
+},{"./JitsiConferenceErrors":2,"./JitsiConferenceEvents":3,"./JitsiConnection":4,"./JitsiConnectionErrors":5,"./JitsiConnectionEvents":6,"./JitsiTrackErrors":9,"./JitsiTrackEvents":10,"./modules/RTC/RTC":16,"./modules/statistics/statistics":24,"./service/RTC/Resolutions":81,"es6-promise":46,"jitsi-meet-logger":48}],8:[function(require,module,exports){
 /* global Strophe */
 
 /**
     /**
      * Returns JitsiTrackErrors based on the error object passed by GUM
      * @param error the error
-     * @param {Object} options the options object given to GUM.
+     * @param {Array} devices Array with the requested devices
      */
-    parseError: function (error, options) {
-        options = options || {};
+    parseError: function (error, devices) {
+        devices = devices || [];
         if (typeof error == "object" && error.constraintName && error.name
             && (error.name == "ConstraintNotSatisfiedError" ||
             error.name == "OverconstrainedError") &&
             error.constraintName == "maxWidth" ||
             error.constraintName == "minHeight" ||
             error.constraintName == "maxHeight") &&
-            options.devices.indexOf("video") !== -1) {
+            devices.indexOf("video") !== -1) {
                 return this.UNSUPPORTED_RESOLUTION;
         } else {
             return this.GENERAL;
 var JitsiTrack = require("./JitsiTrack");
 var RTCBrowserType = require("./RTCBrowserType");
 var JitsiTrackEvents = require('../../JitsiTrackEvents');
-var RTC = require("./RTCUtils");
+var RTCUtils = require("./RTCUtils");
 
 /**
  * Represents a single media track (either audio or video).
         if (mute) {
             this.dontFireRemoveEvent = true;
             this.rtc.room.removeStream(this.stream, function () {});
-            RTC.stopMediaStream(this.stream);
+            RTCUtils.stopMediaStream(this.stream);
             if(isAudio)
                 this.rtc.room.setAudioMute(mute);
             else
             //FIXME: Maybe here we should set the SRC for the containers to something
         } else {
             var self = this;
-            RTC.obtainAudioAndVideoPermissions({
+            RTCUtils.obtainAudioAndVideoPermissions({
                 devices: (isAudio ? ["audio"] : ["video"]),
                 resolution: self.resolution})
                 .then(function (streams) {
 
                     for(var i = 0; i < self.containers.length; i++)
                     {
-                        RTC.attachMediaStream(self.containers[i], self.stream);
+                        RTCUtils.attachMediaStream(
+                            self.containers[i], self.stream);
                     }
 
                     self.rtc.room.addStream(stream.stream,
         return;
     if(this.rtc)
         this.rtc.room.removeStream(this.stream, function () {});
-    RTC.stopMediaStream(this.stream);
+    RTCUtils.stopMediaStream(this.stream);
     this.detach();
 }
 
     }
 
     var device = options.devices.splice(0, 1);
+    var devices = [];
+    devices.push(device);
     options.deviceGUM[device](function (stream) {
             options.streams = options.streams || {};
             options.streams[device] = stream;
         function (error) {
             logger.error(
                 "failed to obtain " + device + " stream - stop", error);
-            options.errorCallback(JitsiTrackErrors.parseError(error));
+            options.errorCallback(JitsiTrackErrors.parseError(error, devices));
         });
 }
 
                     this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
                 }
                 this.attachMediaStream = function (element, stream) {
-                    element.attr('src', webkitURL.createObjectURL(stream));
+
+                    // saves the created url for the stream, so we can reuse it
+                    // and not keep creating urls
+                    if (!stream.jitsiObjectURL) {
+                        stream.jitsiObjectURL
+                            = webkitURL.createObjectURL(stream);
+                    }
+
+                    element.attr('src', stream.jitsiObjectURL);
                 };
                 this.getStreamID = function (stream) {
                     // streams from FF endpoints have the characters '{' and '}'
                 var GUM = function (device, s, e) {
                     this.getUserMediaWithConstraints(device, s, e, options);
                 };
+
                 var deviceGUM = {
                     "audio": GUM.bind(self, ["audio"]),
-                    "video": GUM.bind(self, ["video"]),
-                    "desktop": screenObtainer.obtainStream.bind(screenObtainer)
+                    "video": GUM.bind(self, ["video"])
                 };
+
+                if(screenObtainer.isSupported()){
+                    deviceGUM["desktop"] = screenObtainer.obtainStream.bind(
+                        screenObtainer);
+                }
                 // With FF/IE we can't split the stream into audio and video because FF
                 // doesn't support media stream constructors. So, we need to get the
                 // audio stream separately from the video stream using two distinct GUM
                                             desktopStream: desktopStream});
                                     }, function (error) {
                                         reject(
-                                            JitsiTrackErrors.parseError(error));
+                                            JitsiTrackErrors.parseError(error,
+                                                options.devices));
                                     });
                             } else {
                                 successCallback({audioVideo: stream});
                             }
                         },
                         function (error) {
-                            reject(JitsiTrackErrors.parseError(error));
+                            reject(JitsiTrackErrors.parseError(error,
+                                options.devices));
                         },
                         options);
                 } else if (hasDesktop) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
                             reject(
-                                JitsiTrackErrors.parseError(error));
+                                JitsiTrackErrors.parseError(error,
+                                    ["desktop"]));
                         });
                 }
             }
         if (mediaStream.stop) {
             mediaStream.stop();
         }
+
+        // if we have done createObjectURL, lets clean it
+        if (mediaStream.jitsiObjectURL) {
+            webkitURL.revokeObjectURL(mediaStream.jitsiObjectURL);
+        }
     },
     /**
      * Returns whether the desktop sharing is enabled or not.
     parser.packet2JSON(pres, nodes);
     this.lastPresences[from] = nodes;
     var jibri = null;
+    // process nodes to extract data needed for MUC_JOINED and MUC_MEMBER_JOINED
+    // events
     for(var i = 0; i < nodes.length; i++)
     {
         var node = nodes[i];
         {
             case "nick":
                 member.nick = node.value;
-                if(!member.isFocus) {
-                    var displayName = !this.xmpp.options.displayJids
-                        ? member.nick : Strophe.getResourceFromJid(from);
-
-                    if (displayName && displayName.length > 0) {
-                        this.eventEmitter.emit(XMPPEvents.DISPLAY_NAME_CHANGED, from, displayName);
-                    }
-                }
                 break;
             case "userId":
                 member.id = node.value;
                 break;
-            case "bridgeIsDown":
-                if(!this.bridgeIsDown) {
-                    this.bridgeIsDown = true;
-                    this.eventEmitter.emit(XMPPEvents.BRIDGE_DOWN);
-                }
-                break;
-            case "jibri-recording-status":
-                var jibri = node;
-                break;
-            case "call-control":
-                var att = node.attributes;
-                if(!att)
-                    break;
-                this.phoneNumber = att.phone || null;
-                this.phonePin = att.pin || null;
-                this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
-                break;
-            default :
-                this.processNode(node, from);
         }
-
     }
 
     if (from == this.myroomjid) {
-        if (member.affiliation == 'owner')
-
-            if (this.role !== member.role) {
+        if (member.affiliation == 'owner'
+            &&  this.role !== member.role) {
                 this.role = member.role;
-
-                this.eventEmitter.emit(XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
-            }
+                this.eventEmitter.emit(
+                    XMPPEvents.LOCAL_ROLE_CHANGED, this.role);
+        }
         if (!this.joined) {
             this.joined = true;
             console.log("(TIME) MUC joined:\t", window.performance.now());
-            this.eventEmitter.emit(XMPPEvents.MUC_JOINED, from, member);
+            this.eventEmitter.emit(XMPPEvents.MUC_JOINED);
         }
     } else if (this.members[from] === undefined) {
         // new participant
             logger.info("Ignore focus: " + from + ", real JID: " + member.jid);
         }
         else {
-            this.eventEmitter.emit(XMPPEvents.MUC_MEMBER_JOINED, from, member.id, member.nick);
+            this.eventEmitter.emit(
+                XMPPEvents.MUC_MEMBER_JOINED, from, member.nick);
         }
     } else {
         // Presence update for existing participant
         // Watch role change:
         if (this.members[from].role != member.role) {
             this.members[from].role = member.role;
-            this.eventEmitter.emit(XMPPEvents.MUC_ROLE_CHANGED, from, member.role);
+            this.eventEmitter.emit(
+                XMPPEvents.MUC_ROLE_CHANGED, from, member.role);
         }
 
         // store the new display name
             this.members[from].displayName = member.displayName;
     }
 
+    // after we had fired member or room joined events, lets fire events
+    // for the rest info we got in presence
+    for(var i = 0; i < nodes.length; i++)
+    {
+        var node = nodes[i];
+        switch(node.tagName)
+        {
+            case "nick":
+                if(!member.isFocus) {
+                    var displayName = !this.xmpp.options.displayJids
+                        ? member.nick : Strophe.getResourceFromJid(from);
 
+                    if (displayName && displayName.length > 0) {
+                        this.eventEmitter.emit(
+                            XMPPEvents.DISPLAY_NAME_CHANGED, from, displayName);
+                    }
+                }
+                break;
+            case "bridgeIsDown":
+                if(!this.bridgeIsDown) {
+                    this.bridgeIsDown = true;
+                    this.eventEmitter.emit(XMPPEvents.BRIDGE_DOWN);
+                }
+                break;
+            case "jibri-recording-status":
+                var jibri = node;
+                break;
+            case "call-control":
+                var att = node.attributes;
+                if(!att)
+                    break;
+                this.phoneNumber = att.phone || null;
+                this.phonePin = att.pin || null;
+                this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
+                break;
+            default :
+                this.processNode(node, from);
+        }
+    }
 
     if(!member.isFocus)
         this.eventEmitter.emit(XMPPEvents.USER_ID_CHANGED, from, member.id);

modules/UI/UI.js

         UI.changeDisplayName('localVideoContainer', displayName);
     }
 
-    VideoLayout.mucJoined();
-
     // Make sure we configure our avatar id, before creating avatar for us
     UI.setUserAvatar(id, settings.email || settings.uid);
 
     Toolbar.checkAutoEnableDesktopSharing();
 };
 
+UI.mucJoined = function () {
+    VideoLayout.mucJoined();
+};
+
 function registerListeners() {
     UI.addListener(UIEvents.EMAIL_CHANGED, function (email) {
         UI.setUserAvatar(APP.conference.localId, email);

modules/UI/videolayout/VideoLayout.js

         }
     },
 
+    /**
+     * Get's the localID of the conference and set it to the local video
+     * (small one). This needs to be called as early as possible, when muc is
+     * actually joined. Otherwise events can come with information like email
+     * and setting them assume the id is already set.
+     */
     mucJoined () {
         let id = APP.conference.localId;
         localVideoThumbnail.joined(id);