Implements create local streams.

JitsiConference.js

  */
 JitsiConference.prototype.join = function (password) {
 
-    this.room.joinRoom(password);
+    this.room.join(password);
 }
 
 /**
  *     or a JitsiConferenceError if rejected.
  */
 JitsiConference.prototype.createLocalTracks = function (options) {
-    this.rtc.obtainAudioAndVideoPermissions();
+    return this.rtc.obtainAudioAndVideoPermissions(options || {});
 }
 
 /**

JitsiMeetJS.js

 }
 
 //Setups the promise object.
-require("es6-promise").polyfill();
+window.Promise = window.Promise || require("es6-promise").polyfill();
 
 module.exports = LibJitsiMeet;

modules/RTC/LocalStream.js

     };
 }
 
-function LocalStream(stream, type, eventEmitter, videoType, isGUMStream) {
+function LocalStream(RTC, stream, type, eventEmitter, videoType, isGUMStream) {
+    this.rtc = RTC;
     this.stream = stream;
     this.eventEmitter = eventEmitter;
     this.type = type;
             this.eventEmitter.emit(eventType, true);
         } else {
             var self = this;
-            APP.RTC.rtcUtils.obtainAudioAndVideoPermissions(
-                (this.isAudioStream() ? ["audio"] : ["video"]),
-                function (stream) {
+            this.rtcUtils.obtainAudioAndVideoPermissions(
+                (this.isAudioStream() ? ["audio"] : ["video"]))
+                .then(function (stream) {
                     if (isAudio) {
-                        APP.RTC.changeLocalAudio(stream,
+                        self.rtc.changeLocalAudio(stream,
                             function () {
                                 self.eventEmitter.emit(eventType, false);
                             });
                     } else {
-                        APP.RTC.changeLocalVideo(stream, false,
+                        self.rtc.changeLocalVideo(stream, false,
                             function () {
                                 self.eventEmitter.emit(eventType, false);
                             });

modules/RTC/RTC.js

 }
 
 
-function RTC()
+function RTC(options)
 {
     this.rtcUtils = null;
     this.devices = {
     this.localVideo = null;
     this.eventEmitter = new EventEmitter();
     var self = this;
+    this.options = options || {};
     desktopsharing.addListener(
         function (stream, isUsingScreenStream, callback) {
             self.changeLocalVideo(stream, isUsingScreenStream, callback);
     }
 }
 
-RTC.prototype.obtainAudioAndVideoPermissions = function () {
-    this.rtcUtils.obtainAudioAndVideoPermissions(
-        null, null, getMediaStreamUsage());
+RTC.prototype.obtainAudioAndVideoPermissions = function (options) {
+    return this.rtcUtils.obtainAudioAndVideoPermissions(
+        null, getMediaStreamUsage(), options.resolution);
 }
 
 RTC.prototype.onIncommingCall = function(event) {
 
 RTC.prototype.createLocalStreams = function (streams, change) {
     for (var i = 0; i < streams.length; i++) {
-        var localStream = new LocalStream(streams.stream,
-            streams.type, this.eventEmitter, streams.videoType,
-            streams.isGUMStream);
+        var localStream = new LocalStream(this, streams[i].stream,
+            streams[i].type, this.eventEmitter, streams[i].videoType,
+            streams[i].isGUMStream);
         this.localStreams.push(localStream);
-        if (streams.isMuted === true)
+        if (streams[i].isMuted === true)
             localStream.setMute(true);
 
-        if (streams.type == "audio") {
+        if (streams[i].type == "audio") {
             this.localAudio = localStream;
         } else {
             this.localVideo = localStream;
         if (change)
             eventType = StreamEventTypes.EVENT_TYPE_LOCAL_CHANGED;
 
-        this.eventEmitter.emit(eventType, localStream, streams.isMuted);
+        this.eventEmitter.emit(eventType, localStream, streams[i].isMuted);
     }
     return this.localStreams;
 };

modules/RTC/RTCUtils.js

 }
 
 //Options parameter is to pass config options. Currently uses only "useIPv6".
-function RTCUtils(RTCService, onTemasysPluginReady, options)
+function RTCUtils(RTCService, onTemasysPluginReady)
 {
     var self = this;
     this.service = RTCService;
         };
         // DTLS should now be enabled by default but..
         this.pc_constraints = {'optional': [{'DtlsSrtpKeyAgreement': 'true'}]};
-        if (options.useIPv6) {
+        if (this.service.options.useIPv6) {
             // https://code.google.com/p/webrtc/issues/detail?id=2828
             this.pc_constraints.optional.push({googIPv6: true});
         }
  * not to ask twice.
  */
 RTCUtils.prototype.obtainAudioAndVideoPermissions =
-    function(devices, callback, usageOptions)
+    function(devices, usageOptions, resolution)
 {
     var self = this;
     // Get AV
 
-    var successCallback = function (stream) {
-        if(callback)
-            callback(stream, usageOptions);
-        else
-            self.successCallback(stream, usageOptions);
-    };
+    return new Promise(function(resolve, reject) {
+        var successCallback = function (stream) {
+            resolve(self.successCallback(stream, usageOptions));
+        };
 
-    if(!devices)
-        devices = ['audio', 'video'];
+        if (!devices)
+            devices = ['audio', 'video'];
 
-    var newDevices = [];
+        var newDevices = [];
 
 
-    if(usageOptions)
-        for(var i = 0; i < devices.length; i++) {
-            var device = devices[i];
-            if(usageOptions[device] === true)
-                newDevices.push(device);
-        }
-    else
-        newDevices = devices;
+        if (usageOptions)
+            for (var i = 0; i < devices.length; i++) {
+                var device = devices[i];
+                if (usageOptions[device] === true)
+                    newDevices.push(device);
+            }
+        else
+            newDevices = devices;
 
-    if(newDevices.length === 0) {
-        successCallback();
-        return;
-    }
+        if (newDevices.length === 0) {
+            successCallback();
+            return;
+        }
 
-    if (RTCBrowserType.isFirefox() || RTCBrowserType.isTemasysPluginUsed()) {
-
-        // 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
-        // calls. Not very user friendly :-( but we don't have many other
-        // options neither.
-        //
-        // Note that we pack those 2 streams in a single object and pass it to
-        // the successCallback method.
-        var obtainVideo = function (audioStream) {
-            self.getUserMediaWithConstraints(
-                ['video'],
-                function (videoStream) {
-                    return successCallback({
-                        audioStream: audioStream,
-                        videoStream: videoStream
-                    });
+        if (RTCBrowserType.isFirefox() || RTCBrowserType.isTemasysPluginUsed()) {
+
+            // 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
+            // calls. Not very user friendly :-( but we don't have many other
+            // options neither.
+            //
+            // Note that we pack those 2 streams in a single object and pass it to
+            // the successCallback method.
+            var obtainVideo = function (audioStream) {
+                self.getUserMediaWithConstraints(
+                    ['video'],
+                    function (videoStream) {
+                        return successCallback({
+                            audioStream: audioStream,
+                            videoStream: videoStream
+                        });
+                    },
+                    function (error) {
+                        console.error(
+                            'failed to obtain video stream - stop', error);
+                        self.errorCallback(error, resolve);
+                    },
+                        config.resolution || '360');
+            };
+            var obtainAudio = function () {
+                self.getUserMediaWithConstraints(
+                    ['audio'],
+                    function (audioStream) {
+                        if (newDevices.indexOf('video') !== -1)
+                            obtainVideo(audioStream);
+                    },
+                    function (error) {
+                        console.error(
+                            'failed to obtain audio stream - stop', error);
+                        self.errorCallback(error, resolve);
+                    }
+                );
+            };
+            if (newDevices.indexOf('audio') !== -1) {
+                obtainAudio();
+            } else {
+                obtainVideo(null);
+            }
+        } else {
+            this.getUserMediaWithConstraints(
+                newDevices,
+                function (stream) {
+                    successCallback(stream);
                 },
                 function (error) {
-                    console.error(
-                        'failed to obtain video stream - stop', error);
-                    self.errorCallback(error);
-                },
-                config.resolution || '360');
-        };
-        var obtainAudio = function () {
-            self.getUserMediaWithConstraints(
-                ['audio'],
-                function (audioStream) {
-                    if (newDevices.indexOf('video') !== -1)
-                        obtainVideo(audioStream);
+                    self.errorCallback(error, resolve);
                 },
-                function (error) {
-                    console.error(
-                        'failed to obtain audio stream - stop', error);
-                    self.errorCallback(error);
-                }
-            );
-        };
-        if (newDevices.indexOf('audio') !== -1) {
-            obtainAudio();
-        } else {
-            obtainVideo(null);
+                resolution || '360');
         }
-    } else {
-        this.getUserMediaWithConstraints(
-        newDevices,
-        function (stream) {
-            successCallback(stream);
-        },
-        function (error) {
-            self.errorCallback(error);
-        },
-        config.resolution || '360');
-    }
+    }.bind(this));
 };
 
 RTCUtils.prototype.successCallback = function (stream, usageOptions) {
     return this.handleLocalStream(stream, usageOptions);
 };
 
-RTCUtils.prototype.errorCallback = function (error) {
+RTCUtils.prototype.errorCallback = function (error, resolve) {
     var self = this;
     console.error('failed to obtain audio/video stream - trying audio only', error);
     var resolution = getPreviousResolution(currentResolution);
     {
         self.getUserMediaWithConstraints(['audio', 'video'],
             function (stream) {
-                return self.successCallback(stream);
+                resolve(self.successCallback(stream));
             }, function (error) {
                 return self.errorCallback(error);
             }, resolution);
         self.getUserMediaWithConstraints(
             ['audio'],
             function (stream) {
-                return self.successCallback(stream);
+                resolve(self.successCallback(stream));
             },
             function (error) {
                 console.error('failed to obtain audio/video stream - stop',
                     error);
-                return self.successCallback(null);
+                resolve(self.successCallback(null));
             }
         );
     }

modules/xmpp/JingleSessionPC.js

 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var SSRCReplacement = require("./LocalSSRCReplacement");
-var RTC = require("../RTC/RTC");
 
 // Jingle stuff
 function JingleSessionPC(me, sid, connection, service, eventEmitter) {