Fixes minor Firefox issues. Adds methods for the desktop sharing.

JitsiMeetJS.js

     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);
     },

doc/API.md

 *  ```JitsiMeetJS.init(options)``` - this method initialized Jitsi Meet API.
 The ```options``` parameter is JS object with the following properties:
     1. useIPv6 - boolean property
-
+    2. desktopSharingChromeMethod - Desktop sharing method. Can be set to 'ext', 'webrtc' or false to disable.
+    3. desktopSharingChromeExtId - The ID of the jidesha extension for Chrome or Firefox. Example: 'mbocklcggfhnbahlnepmldehdhpjfcjp'
+    desktopSharingChromeSources - Array of strings with the media sources to use when using screen sharing with the Chrome extension. Example: ['screen', 'window']
+    4. desktopSharingChromeMinExtVersion - Required version of Chrome extension. Example: '0.1'
+    5. desktopSharingFirefoxExtId - The ID of the jidesha extension for Firefox. If null, we assume that no extension is required.
+    6. desktopSharingFirefoxDisabled - Boolean. Whether desktop sharing should be disabled on Firefox. Example: false.
+    7. desktopSharingFirefoxMaxVersionExtRequired - The maximum version of Firefox which requires a jidesha extension. Example: if set to 41, we will require the extension for Firefox versions up to and including 41. On Firefox 42 and higher, we will run without the extension. If set to -1, an extension will be required for all versions of Firefox.
+    8. desktopSharingFirefoxExtensionURL - The URL to the Firefox extension for desktop sharing. "null" if no extension is required.
 
 * ```JitsiMeetJS.JitsiConnection``` - the ```JitsiConnection``` constructor. You can use that to create new server connection.
 
 
 * ```JitsiMeetJS.createLocalTracks(options)``` - Creates the media tracks and returns them trough ```Promise``` object.
     - options - JS object with configuration options for the local media tracks. You can change the following properties there:
-        1. devices - array with the devices - "video" and "audio" that will be passed to GUM. If that property is not set GUM will try to get all available devices.
+        1. devices - array with the devices - "desktop", "video" and "audio" that will be passed to GUM. If that property is not set GUM will try to get all available devices.
         2. resolution - the prefered resolution for the local video.
         3. cameraDeviceId - the deviceID for the video device that is going to be used
         4. micDeviceId - the deviceID for the audio device that is going to be used
 
 * ```JitsiMeetJS.isDeviceListAvailable()```- returns true if retrieving the device list is support and false - otherwise.
 
+* ```JitsiMeetJS.isDesktopSharingEnabled()``` - returns true if desktop sharing is supported and false otherwise. NOTE: that method can be used after ```JitsiMeetJS.init(options)``` is completed otherwise the result will be always null.
+
 * ```JitsiMeetJS.events``` - JS object that contains all events used by the API. You will need that JS object when you try to subscribe for connection or conference events.
     We have two event types - connection and conference. You can access the events with the following code ```JitsiMeetJS.events.<event_type>.<event_name>```.
     For example if you want to use the conference event that is fired when somebody leave conference you can use the following code - ```JitsiMeetJS.events.conference.USER_LEFT```.
 
 5. You also may want to get your local tracks from the camera and microphone:
 ```javascript
-room.createLocalTracks().then(onLocalTracks);
+JitsiMeetJS.createLocalTracks().then(onLocalTracks);
 ```
 
 NOTE: Adding listeners and creating local streams are not mandatory steps.

doc/example/example.js

     room.leave();
     connection.disconnect();
 }
+var isVideo = true;
+function switchVideo() {
+    isVideo = !isVideo;
+    if(localTracks[1]) {
+        localTracks[1].stop();
+        localTracks.pop();
+    }
+    JitsiMeetJS.createLocalTracks({devices: isVideo? ["video"] : ["desktop"]}).
+        then(function (tracks) {
+            localTracks.push(tracks[0]);
+            localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_MUTE_CHANGED,
+                function () {
+                    console.log("local track muted");
+                });
+            localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+                function () {
+                    console.log("local track stoped");
+                });
+            localTracks[1].attach($("#localVideo1"));
+            room.addTrack(localTracks[1]);
+        }).catch(function (error) {
+            console.log(error);
+        });
+}
 
 $(window).bind('beforeunload', unload);
 $(window).bind('unload', unload);

doc/example/index.html

 </head>
 <body>
     <a href="#" onclick="unload()">Unload</a>
+    <a href="#" onclick="switchVideo()">switchVideo</a>
     <!-- <video id="localVideo" autoplay="true"></video> -->
     <!--<audio id="localAudio" autoplay="true" muted="true"></audio>-->
 </body>

modules/RTC/JitsiTrack.js

 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

modules/RTC/RTC.js

     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';
 };

modules/RTC/RTCUtils.js

                 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();
     }
 
 };

modules/xmpp/ChatRoom.js

 
 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) {

modules/xmpp/SDP.js

                     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;
-