JitsiMeetJS.init returns Promise.

JitsiConferenceEvents.js

      */
     TRACK_ADDED: "conference.trackAdded",
     /**
-     * The media track was removed to the conference.
+     * The media track was removed from the conference.
      */
     TRACK_REMOVED: "conference.trackRemoved",
     /**
      */
     IN_LAST_N_CHANGED: "conference.lastNEndpointsChanged",
     /**
-     * A media track mute status was changed.
+     * A media track ( attached to the conference) mute status was changed.
      */
     TRACK_MUTE_CHANGED: "conference.trackMuteChanged",
     /**
-     * Audio levels of a media track was changed.
+     * Audio levels of a media track ( attached to the conference) was changed.
      */
     TRACK_AUDIO_LEVEL_CHANGED: "conference.audioLevelsChanged",
     /**

JitsiMeetJS.js

 var JitsiConnectionEvents = require("./JitsiConnectionEvents");
 var JitsiConnectionErrors = require("./JitsiConnectionErrors");
 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
+var JitsiTrackEvents = require("./JitsiTrackEvents");
+var JitsiTrackErrors = require("./JitsiTrackErrors");
 var Logger = require("jitsi-meet-logger");
 var RTC = require("./modules/RTC/RTC");
 
     JitsiConnection: JitsiConnection,
     events: {
         conference: JitsiConferenceEvents,
-        connection: JitsiConnectionEvents
+        connection: JitsiConnectionEvents,
+        track: JitsiTrackEvents
     },
     errors: {
         conference: JitsiConferenceErrors,
-        connection: JitsiConnectionErrors
+        connection: JitsiConnectionErrors,
+        track: JitsiTrackErrors
     },
     logLevels: Logger.levels,
     init: function (options) {
-        RTC.init(options || {});
+        return RTC.init(options || {});
     },
     setLogLevel: function (level) {
         Logger.setLogLevel(level);

JitsiMeetJSErrors.js → JitsiTrackErrors.js

 module.exports = {
     /**
-     * Returns JitsiMeetJSError based on the error object passed by GUM
-     * @param error the error
+     * Returns JitsiTrackErrors based on the error object passed by GUM * @param error the error
      * @param {Object} options the options object given to GUM.
      */
     parseError: function (error, options) {
             error.constraintName == "minHeight" ||
             error.constraintName == "maxHeight") &&
             options.devices.indexOf("video") !== -1) {
-                return this.GET_TRACKS_RESOLUTION;
+                return this.UNSUPPORTED_RESOLUTION;
         } else {
-            return this.GET_TRACKS_GENERAL;
+            return this.GENERAL;
         }
     },
-    GET_TRACKS_RESOLUTION: "gum.get_tracks_resolution",
-    GET_TRACKS_GENERAL: "gum.get_tracks_general"
+    UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution",
+    GENERAL: "gum.general"
 };

JitsiTrackEvents.js

+var JitsiTrackEvents = {
+    /**
+     * A media track mute status was changed.
+     */
+    TRACK_MUTE_CHANGED: "track.trackMuteChanged",
+    /**
+     * Audio levels of a this track was changed.
+     */
+    TRACK_AUDIO_LEVEL_CHANGED: "track.audioLevelsChanged",
+    /**
+     * The media track was removed to the conference.
+     */
+    TRACK_STOPPED: "track.TRACK_STOPPED",
+};
+
+module.exports = JitsiTrackEvents;

doc/example/example.js

             $("body").append("<audio autoplay='1' id='localAudio" + i + "' />");
             localTracks[i].attach($("#localAudio" + i ));
         }
-
-            room.addTrack(localTracks[i]);
         console.log(localTracks[i]);
     }
 }
  */
 function onConferenceJoined () {
     console.log("conference joined!");
-    JitsiMeetJS.createLocalTracks({devices: ["audio", "video", "desktop"]}).then(onLocalTracks).catch(function (error) {
-        console.log(error);
-    });
+    for(var i = 0; i < localTracks.length; i++)
+        room.addTrack(localTracks[i]);
 }
 
 function onUserLeft(id) {
     // The URL to the Firefox extension for desktop sharing.
     desktopSharingFirefoxExtensionURL: null
 }
-JitsiMeetJS.init(initOptions);
+JitsiMeetJS.init(initOptions).then(function(){
+    JitsiMeetJS.createLocalTracks({devices: ["audio", "video"]}).
+        then(onLocalTracks).catch(function (error) {
+            console.log(error);
+        });
+    }).catch(function (error) {
+        console.log(error);
+    });
 
 var connection = null;
 var room = null;

modules/RTC/RTCUtils.js

 var SDPUtil = require("../xmpp/SDPUtil");
 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
-var JitsiMeetJSError = require("../../JitsiMeetJSErrors");
+var JitsiTrackErrors = require("../../JitsiTrackErrors");
 
 var eventEmitter = new EventEmitter();
 
         function (error) {
             logger.error(
                 "failed to obtain " + device + " stream - stop", error);
-            options.errorCallback(JitsiMeetJSError.parseError(error));
+            options.errorCallback(JitsiTrackErrors.parseError(error));
         });
 }
 
 //Options parameter is to pass config options. Currently uses only "useIPv6".
 var RTCUtils = {
     init: function (options) {
-        var self = this;
-        if (RTCBrowserType.isFirefox()) {
-            var FFversion = RTCBrowserType.getFirefoxVersion();
-            if (FFversion >= 40) {
+        return new Promise(function(resolve, reject) {
+            if (RTCBrowserType.isFirefox()) {
+                var FFversion = RTCBrowserType.getFirefoxVersion();
+                if (FFversion < 40) {
+                    logger.error(
+                            "Firefox version too old: " + FFversion +
+                            ". Required >= 40.");
+                    reject(new Error("Firefox version too old: " + FFversion +
+                    ". Required >= 40."));
+                    return;
+                }
                 this.peerconnection = mozRTCPeerConnection;
                 this.getUserMedia = wrapGetUserMedia(navigator.mozGetUserMedia.bind(navigator));
                 this.enumerateDevices = wrapEnumerateDevices(
                 };
                 RTCSessionDescription = mozRTCSessionDescription;
                 RTCIceCandidate = mozRTCIceCandidate;
-            } else {
-                logger.error(
-                        "Firefox version too old: " + FFversion + ". Required >= 40.");
-                window.location.href = 'unsupported_browser.html';
-                return;
-            }
-
-        } else if (RTCBrowserType.isChrome() || RTCBrowserType.isOpera()) {
-            this.peerconnection = webkitRTCPeerConnection;
-            var getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
-            if (navigator.mediaDevices) {
-                this.getUserMedia = wrapGetUserMedia(getUserMedia);
-                this.enumerateDevices = wrapEnumerateDevices(
-                    navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices)
-                );
-            } else {
-                this.getUserMedia = getUserMedia;
-                this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
-            }
-            this.attachMediaStream = function (element, stream) {
-                element.attr('src', webkitURL.createObjectURL(stream));
-            };
-            this.getStreamID = function (stream) {
-                // streams from FF endpoints have the characters '{' and '}'
-                // that make jQuery choke.
-                return SDPUtil.filter_special_chars(stream.id);
-            };
-            this.getVideoSrc = function (element) {
-                if (!element)
-                    return null;
-                return element.getAttribute("src");
-            };
-            this.setVideoSrc = function (element, src) {
-                if (element)
-                    element.setAttribute("src", src);
-            };
-            // DTLS should now be enabled by default but..
-            this.pc_constraints = {'optional': [
-                {'DtlsSrtpKeyAgreement': 'true'}
-            ]};
-            if (options.useIPv6) {
-                // https://code.google.com/p/webrtc/issues/detail?id=2828
-                this.pc_constraints.optional.push({googIPv6: true});
-            }
-            if (RTCBrowserType.isAndroid()) {
-                this.pc_constraints = {}; // disable DTLS on Android
-            }
-            if (!webkitMediaStream.prototype.getVideoTracks) {
-                webkitMediaStream.prototype.getVideoTracks = function () {
-                    return this.videoTracks;
+            } else if (RTCBrowserType.isChrome() || RTCBrowserType.isOpera()) {
+                this.peerconnection = webkitRTCPeerConnection;
+                var getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
+                if (navigator.mediaDevices) {
+                    this.getUserMedia = wrapGetUserMedia(getUserMedia);
+                    this.enumerateDevices = wrapEnumerateDevices(
+                        navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices)
+                    );
+                } else {
+                    this.getUserMedia = getUserMedia;
+                    this.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
+                }
+                this.attachMediaStream = function (element, stream) {
+                    element.attr('src', webkitURL.createObjectURL(stream));
                 };
-            }
-            if (!webkitMediaStream.prototype.getAudioTracks) {
-                webkitMediaStream.prototype.getAudioTracks = function () {
-                    return this.audioTracks;
+                this.getStreamID = function (stream) {
+                    // streams from FF endpoints have the characters '{' and '}'
+                    // that make jQuery choke.
+                    return SDPUtil.filter_special_chars(stream.id);
                 };
+                this.getVideoSrc = function (element) {
+                    if (!element)
+                        return null;
+                    return element.getAttribute("src");
+                };
+                this.setVideoSrc = function (element, src) {
+                    if (element)
+                        element.setAttribute("src", src);
+                };
+                // DTLS should now be enabled by default but..
+                this.pc_constraints = {'optional': [
+                    {'DtlsSrtpKeyAgreement': 'true'}
+                ]};
+                if (options.useIPv6) {
+                    // https://code.google.com/p/webrtc/issues/detail?id=2828
+                    this.pc_constraints.optional.push({googIPv6: true});
+                }
+                if (RTCBrowserType.isAndroid()) {
+                    this.pc_constraints = {}; // disable DTLS on Android
+                }
+                if (!webkitMediaStream.prototype.getVideoTracks) {
+                    webkitMediaStream.prototype.getVideoTracks = function () {
+                        return this.videoTracks;
+                    };
+                }
+                if (!webkitMediaStream.prototype.getAudioTracks) {
+                    webkitMediaStream.prototype.getAudioTracks = function () {
+                        return this.audioTracks;
+                    };
+                }
             }
-        }
-        // Detect IE/Safari
-        else if (RTCBrowserType.isTemasysPluginUsed()) {
+            // Detect IE/Safari
+            else if (RTCBrowserType.isTemasysPluginUsed()) {
 
-            //AdapterJS.WebRTCPlugin.setLogLevel(
-            //    AdapterJS.WebRTCPlugin.PLUGIN_LOG_LEVELS.VERBOSE);
+                //AdapterJS.WebRTCPlugin.setLogLevel(
+                //    AdapterJS.WebRTCPlugin.PLUGIN_LOG_LEVELS.VERBOSE);
 
-            AdapterJS.webRTCReady(function (isPlugin) {
+                AdapterJS.webRTCReady(function (isPlugin) {
 
-                self.peerconnection = RTCPeerConnection;
-                self.getUserMedia = window.getUserMedia;
-                self.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
-                self.attachMediaStream = function (elSel, stream) {
+                    self.peerconnection = RTCPeerConnection;
+                    self.getUserMedia = window.getUserMedia;
+                    self.enumerateDevices = enumerateDevicesThroughMediaStreamTrack;
+                    self.attachMediaStream = function (elSel, stream) {
 
-                    if (stream.id === "dummyAudio" || stream.id === "dummyVideo") {
-                        return;
-                    }
+                        if (stream.id === "dummyAudio" || stream.id === "dummyVideo") {
+                            return;
+                        }
 
-                    attachMediaStream(elSel[0], stream);
-                };
-                self.getStreamID = function (stream) {
-                    var id = SDPUtil.filter_special_chars(stream.label);
-                    return id;
-                };
-                self.getVideoSrc = function (element) {
-                    if (!element) {
-                        logger.warn("Attempt to get video SRC of null element");
+                        attachMediaStream(elSel[0], stream);
+                    };
+                    self.getStreamID = function (stream) {
+                        var id = SDPUtil.filter_special_chars(stream.label);
+                        return id;
+                    };
+                    self.getVideoSrc = function (element) {
+                        if (!element) {
+                            logger.warn("Attempt to get video SRC of null element");
+                            return null;
+                        }
+                        var children = element.children;
+                        for (var i = 0; i !== children.length; ++i) {
+                            if (children[i].name === 'streamId') {
+                                return children[i].value;
+                            }
+                        }
+                        //logger.info(element.id + " SRC: " + src);
                         return null;
-                    }
-                    var children = element.children;
-                    for (var i = 0; i !== children.length; ++i) {
-                        if (children[i].name === 'streamId') {
-                            return children[i].value;
+                    };
+                    self.setVideoSrc = function (element, src) {
+                        //logger.info("Set video src: ", element, src);
+                        if (!src) {
+                            logger.warn("Not attaching video stream, 'src' is null");
+                            return;
                         }
-                    }
-                    //logger.info(element.id + " SRC: " + src);
-                    return null;
-                };
-                self.setVideoSrc = function (element, src) {
-                    //logger.info("Set video src: ", element, src);
-                    if (!src) {
-                        logger.warn("Not attaching video stream, 'src' is null");
-                        return;
-                    }
-                    AdapterJS.WebRTCPlugin.WaitForPluginReady();
-                    var stream = AdapterJS.WebRTCPlugin.plugin
-                        .getStreamWithId(AdapterJS.WebRTCPlugin.pageId, src);
-                    attachMediaStream(element, stream);
-                };
+                        AdapterJS.WebRTCPlugin.WaitForPluginReady();
+                        var stream = AdapterJS.WebRTCPlugin.plugin
+                            .getStreamWithId(AdapterJS.WebRTCPlugin.pageId, src);
+                        attachMediaStream(element, stream);
+                    };
+
+                    onReady(options, self.getUserMediaWithConstraints);
+                    resolve();
+                });
+            } else {
+                try {
+                    logger.error('Browser does not appear to be WebRTC-capable');
+                } catch (e) {
+                }
+                reject('Browser does not appear to be WebRTC-capable');
+                return;
+            }
 
+            // Call onReady() if Temasys plugin is not used
+            if (!RTCBrowserType.isTemasysPluginUsed()) {
                 onReady(options, self.getUserMediaWithConstraints);
-            });
-        } else {
-            try {
-                logger.error('Browser does not appear to be WebRTC-capable');
-            } catch (e) {
+                resolve();
             }
-            return;
-        }
-
-        // Call onReady() if Temasys plugin is not used
-        if (!RTCBrowserType.isTemasysPluginUsed()) {
-            onReady(options, self.getUserMediaWithConstraints);
-        }
-
+        }.bind(this));
     },
     /**
     * @param {string[]} um required user media types
                                             desktopStream: desktopStream});
                                     }, function (error) {
                                         reject(
-                                            JitsiMeetJSError.parseError(error));
+                                            JitsiTrackErrors.parseError(error));
                                     });
                             } else {
                                 successCallback({audioVideo: stream});
                             }
                         },
                         function (error) {
-                            reject(JitsiMeetJSError.parseError(error));
+                            reject(JitsiTrackErrors.parseError(error));
                         },
                         options);
                 } else if (hasDesktop) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
                             reject(
-                                JitsiMeetJSError.parseError(error));
+                                JitsiTrackErrors.parseError(error));
                         });
                 }
             }