fixes after rebase

app.js

 const ConferenceEvents = JitsiMeetJS.events.conference;
 const ConferenceErrors = JitsiMeetJS.errors.conference;
 
-const TrackEvents = JitsiMeetJS.events.track;
-const TrackErrors = JitsiMeetJS.errors.track;
-
 let localVideo, localAudio;
 
 const Commands = {
     CONNECTION_QUALITY: "connectionQuality",
     EMAIL: "email",
-    VIDEO_TYPE: "videoType"
+    VIDEO_TYPE: "videoType",
     ETHERPAD: "etherpad",
     PREZI: "prezi",
     STOP_PREZI: "stop-prezi"
     statistics,
     settings,
 
+    createLocalTracks (...devices) {
+        return JitsiMeetJS.createLocalTracks({
+            // copy array to avoid mutations inside library
+            devices: devices.slice(0),
+            resolution: config.resolution
+        }).catch(function (err) {
+            console.error('failed to create local tracks', ...devices, err);
+            APP.statistics.onGetUserMediaFailed(err);
+            return [];
+        });
+    },
+
     init () {
         let roomName = buildRoomName();
         this.conference = {
 
     const addTrack = (track) => {
         room.addTrack(track);
-        if(track.getType() === "audio")
+        if (track.isAudioTrack()) {
             return;
+        }
+
         room.removeCommand(Commands.VIDEO_TYPE);
         room.sendCommand(Commands.VIDEO_TYPE, {
             value: track.videoType,
     APP.conference.listMembersIds = function () {
         return room.getParticipants().map(p => p.getId());
     };
-    /**
-     * Creates video track (desktop or camera).
-     * @param type "camera" or "video"
-     * @param endedHandler onended function
-     * @returns Promise
-     */
-    APP.conference.createVideoTrack = (type, endedHandler) => {
-        return JitsiMeetJS.createLocalTracks({
-            devices: [type], resolution: config.resolution
-        }).then((tracks) => {
-            tracks[0].on(TrackEvents.TRACK_STOPPED, endedHandler);
-            return tracks;
-        });
-    };
-
-    APP.conference.changeLocalVideo = (track, callback) => {
-        const localCallback = (newTrack) => {
-            if (newTrack.isLocal() && newTrack === localVideo) {
-                if(localVideo.isMuted() &&
-                    localVideo.videoType !== track.videoType) {
-                        localVideo.mute();
-                }
-                callback();
-                room.off(ConferenceEvents.TRACK_ADDED, localCallback);
-            }
-        };
-
-        room.on(ConferenceEvents.TRACK_ADDED, localCallback);
-
-        localVideo.stop();
-        localVideo = track;
-        addTrack(track);
-        APP.UI.addLocalStream(track);
-    };
 
     APP.conference.sipGatewayEnabled = () => {
         return room.isSIPCallingSupported();
             return APP.settings.getDisplayName();
         }
 
-        var participant = room.getParticipantById(id);
+        let participant = room.getParticipantById(id);
         if (participant && participant.getDisplayName()) {
             return participant.getDisplayName();
         }
     // add local streams when joined to the conference
     room.on(ConferenceEvents.CONFERENCE_JOINED, function () {
         localTracks.forEach(function (track) {
-            if(track.getType() === "audio") {
+            if(track.isAudioTrack()) {
                 localAudio = track;
             }
-            else if (track.getType() === "video") {
+            else if (track.isVideoTrack()) {
                 localVideo = track;
             }
             addTrack(track);
             APP.conference.isModerator = room.isModerator();
             APP.UI.updateLocalRole(room.isModerator());
         } else {
-            var user = room.getParticipantById(id);
+            let user = room.getParticipantById(id);
             if (user) {
                 APP.UI.updateUserRole(user);
             }
         });
     });
 
-    room.addCommandListener(Commands.VIDEO_TYPE, (data, from) => {
-        APP.UI.onPeerVideoTypeChanged(from, data.value);
+    room.addCommandListener(Commands.VIDEO_TYPE, ({value}, from) => {
+        APP.UI.onPeerVideoTypeChanged(from, value);
     });
 
 
         });
     }
 
-    var email = APP.settings.getEmail();
+    let email = APP.settings.getEmail();
     email && sendEmail(email);
     APP.UI.addListener(UIEvents.EMAIL_CHANGED, function (email) {
         APP.settings.setEmail(email);
         APP.UI.updateDTMFSupport(isDTMFSupported);
     });
 
+    APP.desktopsharing.addListener(
+        DesktopSharingEventTypes.NEW_STREAM_CREATED,
+        (track, callback) => {
+            const localCallback = (newTrack) => {
+                if (newTrack.isLocal() && newTrack === localVideo) {
+                    if(localVideo.isMuted() &&
+                       localVideo.videoType !== track.videoType) {
+                        localVideo.mute();
+                    }
+                    callback();
+                    room.off(ConferenceEvents.TRACK_ADDED, localCallback);
+                }
+            };
+
+            room.on(ConferenceEvents.TRACK_ADDED, localCallback);
+
+            localVideo.stop();
+            localVideo = track;
+            addTrack(track);
+            APP.UI.addLocalStream(track);
+        }
+    );
+
     $(window).bind('beforeunload', function () {
         room.leave();
     });
     });
 }
 
-function createLocalTracks () {
-    return JitsiMeetJS.createLocalTracks({
-        devices: ['audio', 'video']
-    }).catch(function (err) {
-        console.error('failed to create local tracks', err);
-        APP.statistics.onGetUserMediaFailed(err);
-        return [];
-    });
-}
-
 function connect() {
     return openConnection({retry: true}).catch(function (err) {
         if (err === ConnectionErrors.PASSWORD_REQUIRED) {
     JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.TRACE);
 
     JitsiMeetJS.init(config).then(function () {
-        return Promise.all([createLocalTracks(), connect()]);
+        return Promise.all([
+            APP.createLocalTracks('audio', 'video'),
+            connect()
+        ]);
     }).then(function ([tracks, connection]) {
         console.log('initialized with %s local tracks', tracks.length);
         return initConference(tracks, connection);
             APP.settings.setLanguage(language);
         });
 
-        APP.desktopsharing.addListener(
-            DesktopSharingEventTypes.NEW_STREAM_CREATED,
-            (stream, callback) => {
-                APP.conference.changeLocalVideo(stream,
-                    callback);
-            });
         APP.desktopsharing.init(JitsiMeetJS.isDesktopSharingEnabled());
         APP.statistics.start();
         APP.connectionquality.init();

libs/lib-jitsi-meet.js

         reject(new Error("The conference is not created yet!"))});
 }
 
+/**
+ * Returns true if the SIP calls are supported and false otherwise
+ */
+JitsiConference.prototype.isSIPCallingSupported = function () {
+    if(this.room)
+        return this.room.isSIPCallingSupported();
+    return false;
+}
+
 /**
  * Dials a number.
  * @param number the number
     init: function (options) {
         return RTC.init(options || {});
     },
+    /**
+     * Returns whether the desktop sharing is enabled or not.
+     * @returns {boolean}
+     */
+    isDesktopSharingEnabled: function () {
+        return RTC.isDesktopSharingEnabled();
+    },
     setLogLevel: function (level) {
         Logger.setLogLevel(level);
     },
 var RTCBrowserType = require("./RTCBrowserType");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
 var EventEmitter = require("events");
+var RTC = require("./RTCUtils");
 
 /**
  * This implements 'onended' callback normally fired by WebRTC after the stream
  * Returns id of the track.
  * @returns {string} id of the track or null if this is fake track.
  */
-JitsiTrack.prototype.getId = function () {
+JitsiTrack.prototype._getId = function () {
     var tracks = this.stream.getTracks();
     if(!tracks || tracks.length === 0)
         return null;
     return tracks[0].id;
 };
 
+/**
+ * Returns id of the track.
+ * @returns {string} id of the track or null if this is fake track.
+ */
+JitsiTrack.prototype.getId = function () {
+    return RTC.getStreamID(this.stream);
+};
+
 /**
  * Checks whether the MediaStream is avtive/not ended.
  * When there is no check for active we don't have information and so
     RTCUtils.stopMediaStream(mediaStream);
 };
 
+/**
+ * Returns whether the desktop sharing is enabled or not.
+ * @returns {boolean}
+ */
+RTC.isDesktopSharingEnabled = function () {
+    return RTCUtils.isDesktopSharingEnabled();
+}
+
 RTC.prototype.getVideoElementName = function () {
     return RTCBrowserType.isTemasysPluginUsed() ? 'object' : 'video';
 };
                 var deviceGUM = {
                     "audio": GUM.bind(self, ["audio"]),
                     "video": GUM.bind(self, ["video"]),
-                    "desktop": screenObtainer.obtainStream
+                    "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
         if (mediaStream.stop) {
             mediaStream.stop();
         }
+    },
+    /**
+     * Returns whether the desktop sharing is enabled or not.
+     * @returns {boolean}
+     */
+    isDesktopSharingEnabled: function () {
+        return screenObtainer.isSupported();
     }
 
 };
 
 ChatRoom.prototype.processNode = function (node, from) {
     if(this.presHandlers[node.tagName])
-        this.presHandlers[node.tagName](node, from);
+        this.presHandlers[node.tagName](node, Strophe.getResourceFromJid(from));
 };
 
 ChatRoom.prototype.sendMessage = function (body, nickname) {
         reject(new Error("The conference is not created yet!"))});
 }
 
+/**
+ * Returns true if the SIP calls are supported and false otherwise
+ */
+ChatRoom.prototype.isSIPCallingSupported = function () {
+    if(this.moderator)
+        return this.moderator.isSipGatewayEnabled();
+    return false;
+}
+
 /**
  * Dials a number.
  * @param number the number
                     var msid = null;
                     if(mline.media == "audio")
                     {
-                        msid = APP.RTC.localAudio.getId();
+                        msid = APP.RTC.localAudio._getId();
                     }
                     else
                     {
-                        msid = APP.RTC.localVideo.getId();
+                        msid = APP.RTC.localVideo._getId();
                     }
                     if(msid != null)
                     {
 
 module.exports = SDP;
 
-
 }).call(this,"/modules/xmpp/SDP.js")
 },{"./SDPUtil":32,"jitsi-meet-logger":48}],31:[function(require,module,exports){
 var SDPUtil = require("./SDPUtil");
     // Sip gateway can be enabled by configuring Jigasi host in config.js or
     // it will be enabled automatically if focus detects the component through
     // service discovery.
-    this.sipGatewayEnabled =
+    this.sipGatewayEnabled = this.xmppService.options.hosts &&
         this.xmppService.options.hosts.call_control !== undefined;
 
     this.eventEmitter = emitter;

modules/UI/UI.js

 //     VideoLayout.setPresenceStatus(Strophe.getResourceFromJid(jid), info.status);
 // }
 
-UI.onPeerVideoTypeChanged = (resourceJid, newVideoType) => {
-    VideoLayout.onVideoTypeChanged(resourceJid, newVideoType);
+UI.onPeerVideoTypeChanged = (id, newVideoType) => {
+    VideoLayout.onVideoTypeChanged(id, newVideoType);
 };
 
 UI.updateLocalRole = function (isModerator) {

modules/UI/videolayout/LargeVideo.js

     constructor (onPlay) {
         super();
         this.stream = null;
+        this.videoType = null;
 
         this.$avatar = $('#activeSpeaker');
         this.$wrapper = $('#largeVideoWrapper');
 
     getVideoSize (containerWidth, containerHeight) {
         let { width, height } = this.getStreamSize();
-        if (this.stream && this.stream.isScreenSharing()) {
+        if (this.stream && this.isScreenSharing()) {
             return getDesktopVideoSize(width, height, containerWidth, containerHeight);
         } else {
             return getCameraVideoSize(width, height, containerWidth, containerHeight);
     }
 
     getVideoPosition (width, height, containerWidth, containerHeight) {
-        if (this.stream && this.stream.isScreenSharing()) {
+        if (this.stream && this.isScreenSharing()) {
             return getDesktopVideoPosition(width, height, containerWidth, containerHeight);
         } else {
             return getCameraVideoPosition(width, height, containerWidth, containerHeight);
         });
     }
 
-    setStream (stream) {
+    setStream (stream, videoType) {
         this.stream = stream;
+        this.videoType = videoType;
 
         stream.attach(this.$video);
 
-        let flipX = stream.isLocal() && !stream.isScreenSharing();
+        let flipX = stream.isLocal() && !this.isScreenSharing();
         this.$video.css({
             transform: flipX ? 'scaleX(-1)' : 'none'
         });
     }
 
+    isScreenSharing () {
+        return this.videoType === 'desktop';
+    }
+
     showAvatar (show) {
         this.$avatar.css("visibility", show ? "visible" : "hidden");
     }
         return this.videoContainer.id;
     }
 
-    updateLargeVideo (stream) {
+    updateLargeVideo (stream, videoType) {
         let id = getStreamId(stream);
 
         let container = this.getContainer(this.state);
         container.hide().then(() => {
             console.info("hover in %s", id);
             this.state = VideoContainerType;
-            this.videoContainer.setStream(stream);
+            this.videoContainer.setStream(stream, videoType);
             this.videoContainer.show();
         });
     }

modules/UI/videolayout/VideoLayout.js

         localVideoThumbnail.createConnectionIndicator();
 
         let localId = APP.conference.localId;
-        this.onVideoTypeChanged(localId, stream.getType());
+        this.onVideoTypeChanged(localId, stream.videoType);
 
         let {thumbWidth, thumbHeight} = this.calculateThumbnailSize();
         AudioLevels.updateAudioLevelCanvas(null, thumbWidth, thumbHeight);
     electLastVisibleVideo () {
         // pick the last visible video in the row
         // if nobody else is left, this picks the local video
-        let thumbs = BottomToolbar.getThumbs(true).filter('id!="mixedstream"');
+        let thumbs = BottomToolbar.getThumbs(true).filter('[id!="mixedstream"]');
 
         let lastVisible = thumbs.filter(':visible:last');
         if (lastVisible.length) {
 
             let smallVideo = this.getSmallVideo(id);
 
-            largeVideo.updateLargeVideo(smallVideo.stream);
+            let videoType = this.getRemoteVideoType(id);
+            largeVideo.updateLargeVideo(smallVideo.stream, videoType);
 
             smallVideo.enableDominantSpeaker(true);
         } else if (currentId) {

modules/desktopsharing/desktopsharing.js

-/* global APP, config */
+/* global APP, JitsiMeetJS, config */
 var EventEmitter = require("events");
 var DesktopSharingEventTypes
     = require("../../service/desktopsharing/DesktopSharingEventTypes");
 
+const TrackEvents = JitsiMeetJS.events.track;
+
 /**
  * Indicates that desktop stream is currently in use (for toggle purpose).
  * @type {boolean}
         track, streamSwitchDone);
 }
 
-function getVideoStreamFailed(error) {
-    console.error("Failed to obtain the stream to switch to", error);
+function getVideoStreamFailed() {
+    console.error("Failed to obtain the stream to switch to");
     switchInProgress = false;
     isUsingScreenStream = false;
     newStreamCreated(null);
 }
 
-function getDesktopStreamFailed(error) {
-    console.error("Failed to obtain the stream to switch to", error);
+function getDesktopStreamFailed() {
+    console.error("Failed to obtain the stream to switch to");
     switchInProgress = false;
 }
 
             return;
         }
         switchInProgress = true;
-        let type, handler;
+        let type;
         if (!isUsingScreenStream) {
             // Switch to desktop stream
-            handler = onEndedHandler;
             type = "desktop";
         } else {
-            handler = () => {};
             type = "video";
         }
-        APP.conference.createVideoTrack(type, handler).then(
-            (tracks) => {
-                // We now use screen stream
-                isUsingScreenStream = type === "desktop";
-                newStreamCreated(tracks[0]);
-            }).catch(getDesktopStreamFailed);
+        APP.createLocalTracks(type).then(function (tracks) {
+            if (!tracks.length) {
+                if (type === 'desktop') {
+                    getDesktopStreamFailed();
+                } else {
+                    getVideoStreamFailed();
+                }
+
+                return;
+            }
+
+            let stream = tracks[0];
+
+            // We now use screen stream
+            isUsingScreenStream = type === "desktop";
+            if (isUsingScreenStream) {
+                stream.on(TrackEvents.TRACK_STOPPED, onEndedHandler);
+            }
+
+            newStreamCreated(stream);
+        });
     },
     /*
      * Exports the event emitter to allow use by ScreenObtainer. Not for outside