Merge branch 'master' into reloads

JitsiConference.js

     this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
         track.ssrcHandler);
 
+    // Report active device to statistics
+    var devices = RTC.getCurrentlyAvailableMediaDevices();
+    device = devices.find(function (d) {
+        return d.kind === track.getTrack().kind + 'input'
+            && d.label === track.getTrack().label;
+    });
+
+    Statistics.sendАctiveDeviceListEvent(
+        RTC.getEventDataForActiveDevice(device));
+
     return new Promise(function (resolve, reject) {
         this.room.addStream(track.getOriginalStream(), function () {
             if (track.isVideoTrack()) {
     return this.room.connectionTimes;
 };
 
+/**
+ * Sets a property for the local participant.
+ */
+JitsiConference.prototype.setLocalParticipantProperty = function(name, value) {
+    this.sendCommand("jitsi_participant_" + name, {value: value});
+};
+
 /**
  * Sends the given feedback through CallStats if enabled.
  *
     conference.room.addListener(XMPPEvents.FOCUS_LEFT, function () {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.FOCUS_LEFT);
     });
+    conference.room.setParticipantPropertyListener(function (node, from) {
+        var participant = conference.getParticipantById(from);
+        if (!participant) {
+            return;
+        }
+
+        participant.setProperty(
+            node.tagName.substring("jitsi_participant_".length),
+            node.value);
+    });
 //    FIXME
 //    conference.room.addListener(XMPPEvents.MUC_JOINED, function () {
 //        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
 
     conference.room.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
         conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED, conference.myUserId(), role);
+
+        // log all events for the recorder operated by the moderator
+        if (conference.statistics && conference.isModerator()) {
+            conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
+                function (status, error) {
+                    Statistics.sendLog(
+                        "[Recorder] status: " + status
+                            + (error? " error: " + error : ""));
+                });
+        }
     });
     conference.room.addListener(XMPPEvents.MUC_ROLE_CHANGED, conference.onUserRoleChanged.bind(conference));
 
                 conference.statistics.sendMuteEvent(track.isMuted(), type);
             });
 
-        // log all events for the recorder operated by the moderator
-        if (conference.isModerator()) {
-            conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
-                function (status, error) {
-                    conference.statistics.sendLog("Recorder: " + status);
-                });
-        }
-
         conference.room.addListener(XMPPEvents.CREATE_OFFER_FAILED, function (e, pc) {
             conference.statistics.sendCreateOfferFailed(e, pc);
         });

JitsiConferenceEvents.js

     /**
      * Indicates that authentication status changed.
      */
-    AUTH_STATUS_CHANGED: "conference.auth_status_changed"
+    AUTH_STATUS_CHANGED: "conference.auth_status_changed",
+    /**
+     * Indicates that a the value of a specific property of a specific
+     * participant has changed.
+     */
+    PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed"
 };
 
 module.exports = JitsiConferenceEvents;

JitsiMediaDevices.js

 var RTC = require("./modules/RTC/RTC");
 var MediaType = require('./service/RTC/MediaType');
 var JitsiMediaDevicesEvents = require('./JitsiMediaDevicesEvents');
+var Statistics = require("./modules/statistics/statistics");
 
 var eventEmitter = new EventEmitter();
 
         eventEmitter.emit(JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED, devices);
     });
 
+RTC.addListener(RTCEvents.DEVICE_LIST_AVAILABLE,
+    function (devices) {
+        // log output device
+        logOutputDevice(
+            JitsiMediaDevices.getAudioOutputDevice(),
+            devices);
+    });
+
+/**
+ * Gathers data and sends it to statistics.
+ * @param deviceID the device id to log
+ * @param devices list of devices
+ */
+function logOutputDevice (deviceID, devices) {
+    var device = devices.find(function (d) {
+        return d.kind === 'audiooutput' && d.deviceId === deviceID;
+    });
+
+    Statistics.sendАctiveDeviceListEvent(
+        RTC.getEventDataForActiveDevice(device));
+}
+
 var JitsiMediaDevices = {
     /**
      * Executes callback with list of media devices connected.
      *      otherwise
      */
     setAudioOutputDevice: function (deviceId) {
+
+        if (RTC.getCurrentlyAvailableMediaDevices().length > 0)
+        {
+            // if we have devices info report device to stats
+            // normally this will not happen on startup as this method is called
+            // too early. This will happen only on user selection of new device
+            logOutputDevice(deviceId, RTC.getCurrentlyAvailableMediaDevices());
+        }
+
         return RTC.setAudioOutputDevice(deviceId);
     },
     /**
      */
     removeEventListener: function (event, handler) {
         eventEmitter.removeListener(event, handler);
+    },
+    /**
+     * Emits an event.
+     * @param {string} event - event name
+     */
+    emitEvent: function (event) {
+        eventEmitter.emit.apply(eventEmitter, arguments);
     }
 };
 

JitsiMediaDevicesEvents.js

      *  MediaDeviceInfo-like objects that are currently connected.
      *  @see https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo
      */
-    DEVICE_LIST_CHANGED: "mediaDevices.devicechange"
+    DEVICE_LIST_CHANGED: "mediaDevices.devicechange",
+    /**
+     * Indicates that the environment is currently showing permission prompt to
+     * access camera and/or microphone. The event provides the following
+     * parameters to its listeners:
+     *
+     * @param {'chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'
+     *      |'react-native'|'android'} environmentType - type of browser or
+     *      other execution environment.
+     */
+    PERMISSION_PROMPT_IS_SHOWN: "mediaDevices.permissionPromptIsShown"
 };
 
 module.exports = JitsiMediaDevicesEvents;

JitsiMeetJS.js

 var Resolutions = require("./service/RTC/Resolutions");
 var ScriptUtil = require("./modules/util/ScriptUtil");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
+var RTCBrowserType = require("./modules/RTC/RTCBrowserType");
+
+// The amount of time to wait until firing
+// JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN event
+var USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
 
 function getLowerResolution(resolution) {
     if(!Resolutions[resolution])
      * will be returned trough the Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
+     * @param {boolean} (firePermissionPromptIsShownEvent) - if event
+     *      JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN should be fired
      * @returns {Promise.<{Array.<JitsiTrack>}, JitsiConferenceError>}
      *     A promise that returns an array of created JitsiTracks if resolved,
      *     or a JitsiConferenceError if rejected.
      */
-    createLocalTracks: function (options) {
-        return RTC.obtainAudioAndVideoPermissions(options || {}).then(
-            function(tracks) {
+    createLocalTracks: function (options, firePermissionPromptIsShownEvent) {
+        var promiseFulfilled = false;
+
+        if (firePermissionPromptIsShownEvent === true) {
+            window.setTimeout(function () {
+                if (!promiseFulfilled) {
+                    var browser = RTCBrowserType.getBrowserType()
+                        .split('rtc_browser.')[1];
+
+                    if (RTCBrowserType.isAndroid()) {
+                        browser = 'android';
+                    }
+
+                    JitsiMediaDevices.emitEvent(
+                        JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
+                        browser);
+                }
+            }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
+        }
+
+        return RTC.obtainAudioAndVideoPermissions(options || {})
+            .then(function(tracks) {
+                promiseFulfilled = true;
+
                 if(!RTC.options.disableAudioLevels)
                     for(var i = 0; i < tracks.length; i++) {
                         var track = tracks[i];
                                 });
                         }
                     }
+
                 return tracks;
             }).catch(function (error) {
+                promiseFulfilled = true;
+
                 Statistics.sendGetUserMediaFailed(error);
 
                 if(error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION) {

JitsiParticipant.js

 /* global Strophe */
+var JitsiConferenceEvents = require('./JitsiConferenceEvents');
 
 /**
  * Represents a participant in (a member of) a conference.
         video: undefined
     };
     this._isHidden = isHidden;
+    this._properties = {};
 }
 
 /**
     return this._conference;
 };
 
+/**
+ * Gets the value of a property of this participant.
+ */
+JitsiParticipant.prototype.getProperty = function(name) {
+    return this._properties[name];
+};
+
+/**
+ * Sets the value of a property of this participant, and fires an event if the
+ * value has changed.
+ * @name the name of the property.
+ * @value the value to set.
+ */
+JitsiParticipant.prototype.setProperty = function(name, value) {
+    var oldValue = this._properties[name];
+    this._properties[name] = value;
+
+    if (value !== oldValue) {
+        this._conference.eventEmitter.emit(
+            JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED,
+            this,
+            name,
+            oldValue,
+            value);
+    }
+};
+
 /**
  * @returns {Array.<JitsiTrack>} The list of media tracks for this participant.
  */

doc/API.md

 JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
 ```
 
-* ```JitsiMeetJS.createLocalTracks(options)``` - Creates the media tracks and returns them trough ```Promise``` object. If rejected, passes ```JitsiTrackError``` instance to catch block.
+* ```JitsiMeetJS.createLocalTracks(options, firePermissionPromptIsShownEvent)``` - Creates the media tracks and returns them trough ```Promise``` object. If rejected, passes ```JitsiTrackError``` instance to catch block.
     - options - JS object with configuration options for the local media tracks. You can change the following properties there:
         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.
         5. minFps - the minimum frame rate for the video stream (passed to GUM)
         6. maxFps - the maximum frame rate for the video stream (passed to GUM)
         7. facingMode - facing mode for a camera (possible values - 'user', 'environment')
+    - firePermissionPromptIsShownEvent - optional boolean parameter. If set to ```true```, ```JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN``` will be fired when browser shows gUM permission prompt.
 
 * ```JitsiMeetJS.enumerateDevices(callback)``` - __DEPRECATED__. Use ```JitsiMeetJS.mediaDevices.enumerateDevices(callback)``` instead.
 * ```JitsiMeetJS.isDeviceListAvailable()``` - __DEPRECATED__. Use ```JitsiMeetJS.mediaDevices.isDeviceListAvailable()``` instead.
     - ```addEventListener(event, handler)``` - attaches an event handler.
     - ```removeEventListener(event, handler)``` - removes an event handler.
 
-
 * ```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```.
 
     4. mediaDevices
         - DEVICE_LIST_CHANGED - indicates that list of currently connected devices has changed (parameters - devices(MediaDeviceInfo[])).
+        - PERMISSION_PROMPT_IS_SHOWN - Indicates that the environment is currently showing permission prompt to access camera and/or microphone (parameters - environmentType ('chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'|'react-native'|'android').
 
 
 * ```JitsiMeetJS.errors``` - JS object that contains all errors used by the API. You can use that object to check the reported errors from the API

modules/RTC/RTC.js

     return RTCUtils.getAudioOutputDevice();
 };
 
+/**
+ * Returns list of available media devices if its obtained, otherwise an
+ * empty array is returned/
+ * @returns {Array} list of available media devices.
+ */
+RTC.getCurrentlyAvailableMediaDevices = function () {
+    return RTCUtils.getCurrentlyAvailableMediaDevices();
+};
+
+/**
+ * Returns event data for device to be reported to stats.
+ * @returns {MediaDeviceInfo} device.
+ */
+RTC.getEventDataForActiveDevice = function (device) {
+    return RTCUtils.getEventDataForActiveDevice(device);
+};
+
 /**
  * Sets current audio output device.
  * @param {string} deviceId - id of 'audiooutput' device from

modules/RTC/RTCBrowserType.js

 
     RTC_BROWSER_REACT_NATIVE: "rtc_browser.react-native",
 
+    /**
+     * Gets current browser type.
+     * @returns {string}
+     */
     getBrowserType: function () {
         return currentBrowser;
     },
 
+    /**
+     * Checks if current browser is Chrome.
+     * @returns {boolean}
+     */
     isChrome: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_CHROME;
     },
 
+    /**
+     * Checks if current browser is Opera.
+     * @returns {boolean}
+     */
     isOpera: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_OPERA;
     },
+
+    /**
+     * Checks if current browser is Firefox.
+     * @returns {boolean}
+     */
     isFirefox: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_FIREFOX;
     },
 
+    /**
+     * Checks if current browser is Internet Explorer.
+     * @returns {boolean}
+     */
     isIExplorer: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_IEXPLORER;
     },
 
+    /**
+     * Checks if current browser is Safari.
+     * @returns {boolean}
+     */
     isSafari: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_SAFARI;
     },
+
+    /**
+     * Checks if current environment is NWJS.
+     * @returns {boolean}
+     */
     isNWJS: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_NWJS;
     },
+
+    /**
+     * Checks if current environment is React Native.
+     * @returns {boolean}
+     */
     isReactNative: function () {
         return currentBrowser === RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
     },
+
+    /**
+     * Checks if Temasys RTC plugin is used.
+     * @returns {boolean}
+     */
     isTemasysPluginUsed: function () {
         return RTCBrowserType.isIExplorer() || RTCBrowserType.isSafari();
     },
+
+    /**
+     * Returns Firefox version.
+     * @returns {number|null}
+     */
     getFirefoxVersion: function () {
         return RTCBrowserType.isFirefox() ? browserVersion : null;
     },
 
+    /**
+     * Returns Chrome version.
+     * @returns {number|null}
+     */
     getChromeVersion: function () {
         return RTCBrowserType.isChrome() ? browserVersion : null;
     },
 
     /**
      * Whether the browser is running on an android device.
+     * @returns {boolean}
      */
     isAndroid: function() {
         return isAndroid;

modules/RTC/RTCUtils.js

 var isAudioOutputDeviceChangeAvailable =
     typeof featureDetectionAudioEl.setSinkId !== 'undefined';
 
-var currentlyAvailableMediaDevices = [];
+var currentlyAvailableMediaDevices;
 
 var rawEnumerateDevicesWithCallback = navigator.mediaDevices
     && navigator.mediaDevices.enumerateDevices
     // and then plug in a new one.
     if (rawEnumerateDevicesWithCallback) {
         rawEnumerateDevicesWithCallback(function (devices) {
-            if (compareAvailableMediaDevices(devices)) {
+            // We don't fire RTCEvents.DEVICE_LIST_CHANGED for the first time
+            // we call enumerateDevices(). This is the initial step.
+            if (typeof currentlyAvailableMediaDevices === 'undefined') {
+                currentlyAvailableMediaDevices = devices.slice(0);
+            } else if (compareAvailableMediaDevices(devices)) {
                 onMediaDevicesListChanged(devices);
             }
 
     eventEmitter.emit(RTCEvents.RTC_READY, true);
     screenObtainer.init(options, GUM);
 
-    if (isDeviceChangeEventSupported && RTCUtils.isDeviceListAvailable()) {
-        navigator.mediaDevices.addEventListener('devicechange', function () {
-            RTCUtils.enumerateDevices(onMediaDevicesListChanged);
+    if (RTCUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
+        rawEnumerateDevicesWithCallback(function (devices) {
+            currentlyAvailableMediaDevices = devices.splice(0);
+
+            eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
+                currentlyAvailableMediaDevices);
+
+            if (isDeviceChangeEventSupported) {
+                navigator.mediaDevices.addEventListener(
+                    'devicechange',
+                    function () {
+                        RTCUtils.enumerateDevices(
+                            onMediaDevicesListChanged);
+                    });
+            } else {
+                pollForAvailableMediaDevices();
+            }
         });
-    } else if (RTCUtils.isDeviceListAvailable()) {
-        pollForAvailableMediaDevices();
     }
 }
 
      */
     getAudioOutputDevice: function () {
         return audioOutputDeviceId;
+    },
+
+    /**
+     * Returns list of available media devices if its obtained, otherwise an
+     * empty array is returned/
+     * @returns {Array} list of available media devices.
+     */
+    getCurrentlyAvailableMediaDevices: function () {
+        return currentlyAvailableMediaDevices;
+    },
+
+    /**
+     * Returns event data for device to be reported to stats.
+     * @returns {MediaDeviceInfo} device.
+     */
+    getEventDataForActiveDevice: function (device) {
+        var devices = [];
+        var deviceData = {
+            "deviceId": device.deviceId,
+            "kind":     device.kind,
+            "label":    device.label,
+            "groupId":  device.groupId
+        };
+        devices.push(deviceData);
+        return { deviceList: devices };
     }
 };
 

modules/statistics/CallStats.js

     getUserMedia:         "getUserMedia",
     iceConnectionFailure: "iceConnectionFailure",
     signalingError:       "signalingError",
-    applicationError:     "applicationError"
+    applicationLog:       "applicationLog"
 };
 
 /**
     fabricTerminated:"fabricTerminated",
     screenShareStart:"screenShareStart",
     screenShareStop:"screenShareStop",
-    dominantSpeaker:"dominantSpeaker"
+    dominantSpeaker:"dominantSpeaker",
+    activeDeviceList:"activeDeviceList"
 };
 
 var callStats = null;
     if (err !== 'success')
         return;
 
+    CallStats.initialized = true;
+
+    var ret = callStats.addNewFabric(this.peerconnection,
+        Strophe.getResourceFromJid(this.session.peerjid),
+        callStats.fabricUsage.multiplex,
+        this.confID,
+        this.pcCallback.bind(this));
+
+    var fabricInitialized = (ret.status === 'success');
+
+    if(!fabricInitialized)
+        console.log("callstats fabric not initilized", ret.message);
+
     // notify callstats about failures if there were any
     if (CallStats.reportsQueue.length) {
         CallStats.reportsQueue.forEach(function (report) {
-            if (report.type === reportType.ERROR)
-            {
+            if (report.type === reportType.ERROR) {
                 var error = report.data;
                 CallStats._reportError.call(this, error.type, error.error,
                     error.pc);
             }
-            else if (report.type === reportType.EVENT)
-            {
-                var data = report.data;
+            // if we have and event to report and we failed to add fabric
+            // this event will not be reported anyway, returning an error
+            else if (report.type === reportType.EVENT
+                && fabricInitialized) {
+                var eventData = report.data;
                 callStats.sendFabricEvent(
-                    this.peerconnection, data.event, this.confID);
+                    this.peerconnection,
+                    eventData.event,
+                    this.confID,
+                    eventData.eventData);
+            } else if (report.type === reportType.MST_WITH_USERID) {
+                var data = report.data;
+                callStats.associateMstWithUserID(
+                    this.peerconnection,
+                    data.callStatsId,
+                    this.confID,
+                    data.ssrc,
+                    data.usageLabel,
+                    data.containerId
+                );
             }
         }, this);
         CallStats.reportsQueue.length = 0;
             this.userID,
             initCallback.bind(this));
 
-        callStats.addNewFabric(this.peerconnection,
-            Strophe.getResourceFromJid(jingleSession.peerjid),
-            callStats.fabricUsage.multiplex,
-            this.confID,
-            this.pcCallback.bind(this));
     } catch (e) {
         // The callstats.io API failed to initialize (e.g. because its
         // download failed to succeed in general or on time). Further
 // and send them to callstats on init
 CallStats.reportsQueue = [];
 
+/**
+ * Whether the library was successfully initialized using its initialize method.
+ * And whether we had successfully called addNewFabric.
+ * @type {boolean}
+ */
+CallStats.initialized = false;
+
 /**
  * Type of pending reports, can be event or an error.
  * @type {{ERROR: string, EVENT: string}}
  */
 var reportType = {
     ERROR: "error",
-    EVENT: "event"
+    EVENT: "event",
+    MST_WITH_USERID: "mstWithUserID"
 };
 
 CallStats.prototype.pcCallback = _try_catch(function (err, msg) {
 /**
  * Lets CallStats module know where is given SSRC rendered by providing renderer
  * tag ID.
+ * If the lib is not initialized yet queue the call for later, when its ready.
  * @param ssrc {number} the SSRC of the stream
  * @param isLocal {boolean} <tt>true<tt> if this stream is local or
  *        <tt>false</tt> otherwise.
             usageLabel,
             containerId
         );
-        callStats.associateMstWithUserID(
-            this.peerconnection,
-            callStatsId,
-            this.confID,
-            ssrc,
-            usageLabel,
-            containerId
-        );
+        if(CallStats.initialized) {
+            callStats.associateMstWithUserID(
+                this.peerconnection,
+                callStatsId,
+                this.confID,
+                ssrc,
+                usageLabel,
+                containerId
+            );
+        }
+        else {
+            CallStats.reportsQueue.push({
+                type: reportType.MST_WITH_USERID,
+                data: {
+                    callStatsId: callStatsId,
+                    ssrc: ssrc,
+                    usageLabel: usageLabel,
+                    containerId: containerId
+                }
+            });
+        }
     }).bind(this)();
 };
 
  * Notifies CallStats for mute events
  * @param mute {boolean} true for muted and false for not muted
  * @param type {String} "audio"/"video"
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendMuteEvent = _try_catch(function (mute, type, cs) {
 
  * Notifies CallStats for screen sharing events
  * @param start {boolean} true for starting screen sharing and
  * false for not stopping
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendScreenSharingEvent = _try_catch(function (start, cs) {
 
 
 /**
  * Notifies CallStats that we are the new dominant speaker in the conference.
+ * @param {CallStats} cs callstats instance related to the event
  */
 CallStats.sendDominantSpeakerEvent = _try_catch(function (cs) {
 
         fabricEvent.dominantSpeaker);
 });
 
+/**
+ * Notifies CallStats about active device.
+ * @param {{deviceList: {String:String}}} list of devices with their data
+ * @param {CallStats} cs callstats instance related to the event
+ */
+CallStats.sendАctiveDeviceListEvent = _try_catch(function (devicesData, cs) {
+
+    CallStats._reportEvent.call(cs, fabricEvent.activeDeviceList, devicesData);
+});
+
 /**
  * Reports an error to callstats.
  *
  * @param type the type of the error, which will be one of the wrtcFuncNames
  * @param e the error
  * @param pc the peerconnection
+ * @param eventData additional data to pass to event
  * @private
  */
-CallStats._reportEvent = function (event) {
-    if (callStats) {
-        callStats.sendFabricEvent(this.peerconnection, event, this.confID);
+CallStats._reportEvent = function (event, eventData) {
+    if (CallStats.initialized) {
+        callStats.sendFabricEvent(
+            this.peerconnection, event, this.confID, eventData);
     } else {
         CallStats.reportsQueue.push({
                 type: reportType.EVENT,
-                data: {event: event}
+                data: {event: event, eventData: eventData}
             });
     }
 };
  * Notifies CallStats for connection setup errors
  */
 CallStats.prototype.sendTerminateEvent = _try_catch(function () {
-    if(!callStats) {
+    if(!CallStats.initialized) {
         return;
     }
     callStats.sendFabricEvent(this.peerconnection,
  */
 CallStats.prototype.sendFeedback = _try_catch(
 function(overallFeedback, detailedFeedback) {
-    if(!callStats) {
+    if(!CallStats.initialized) {
         return;
     }
     var feedbackString =    '{"userID":"' + this.userID + '"' +
         logger.warn("No error is passed!");
         e = new Error("Unknown error");
     }
-    if (callStats) {
+    if (CallStats.initialized) {
         callStats.reportError(pc, this.confID, type, e);
     } else {
         CallStats.reportsQueue.push({
 });
 
 /**
- * Notifies CallStats that there is an unhandled error on the page.
+ * Notifies CallStats that there is a log we want to report.
  *
- * @param {Error} e error to send
- * @param {RTCPeerConnection} pc connection on which failure occured.
+ * @param {Error} e error to send or {String} message
  * @param {CallStats} cs callstats instance related to the error (optional)
  */
-CallStats.sendUnhandledError = _try_catch(function (e, cs) {
+CallStats.sendApplicationLog = _try_catch(function (e, cs) {
     CallStats._reportError
-        .call(cs, wrtcFuncNames.applicationError, e, null);
+        .call(cs, wrtcFuncNames.applicationLog, e, null);
 });
 
 module.exports = CallStats;

modules/statistics/statistics.js

         CallStats.sendDominantSpeakerEvent(this.callstats);
 };
 
+/**
+ * Notifies about active device.
+ * @param {{deviceList: {String:String}}} list of devices with their data
+ */
+Statistics.sendАctiveDeviceListEvent = function (devicesData) {
+    if (Statistics.callsStatsInstances.length) {
+        Statistics.callsStatsInstances.forEach(function (cs) {
+            CallStats.sendАctiveDeviceListEvent(devicesData, cs);
+        });
+    } else {
+        CallStats.sendАctiveDeviceListEvent(devicesData, null);
+    }
+};
+
 /**
  * Lets the underlying statistics module know where is given SSRC rendered by
  * providing renderer tag ID.
 };
 
 /**
- * Notifies CallStats that there is unhandled exception.
+ * Adds to CallStats an application log.
  *
- * @param {Error} e error to send
+ * @param {String} a log message to send or an {Error} object to be reported
  */
-Statistics.sendUnhandledError = function (e) {
+Statistics.sendLog = function (m) {
     if (Statistics.callsStatsInstances.length) {
         Statistics.callsStatsInstances.forEach(function (cs) {
-            CallStats.sendUnhandledError(e, cs);
+            CallStats.sendApplicationLog(m, cs);
         });
     } else {
-        CallStats.sendUnhandledError(e, null);
+        CallStats.sendApplicationLog(m, null);
     }
 };
 
-/**
- * Adds to CallStats an application log.
- *
- * @param {String} a log message to send
- */
-Statistics.sendLog = function (m) {
-    // uses  the same field for cs stat as unhandled error
-    Statistics.sendUnhandledError(m);
-};
-
-/**
- * Adds to CallStats an application log.
- *
- * @param {String} a log message to send
- */
-Statistics.prototype.sendLog = function (m) {
-    // uses  the same field for cs stat as unhandled error
-    CallStats.sendUnhandledError(m, this.callstats);
-};
-
 /**
  * Sends the given feedback through CallStats.
  *
     if (error instanceof JitsiTrackError && error.gum) {
         Statistics.sendGetUserMediaFailed(error);
     } else {
-        Statistics.sendUnhandledError(error);
+        Statistics.sendLog(error);
     }
 };
 

modules/xmpp/ChatRoom.js

     this.phoneNumber = null;
     this.phonePin = null;
     this.connectionTimes = {};
+    this.participantPropertyListener = null;
 }
 
 ChatRoom.prototype.initPresenceMap = function () {
         {
             case "nick":
                 if(!member.isFocus) {
-                    var displayName = !this.xmpp.options.displayJids
-                        ? member.nick : Strophe.getResourceFromJid(from);
+                    var displayName = this.xmpp.options.displayJids
+                        ? Strophe.getResourceFromJid(from) : member.nick;
 
                     if (displayName && displayName.length > 0) {
                         this.eventEmitter.emit(
                 this.phonePin = att.pin || null;
                 this.eventEmitter.emit(XMPPEvents.PHONE_NUMBER_CHANGED);
                 break;
-            default :
+            default:
                 this.processNode(node, from);
         }
     }
     }
 };
 
+/**
+ * Sets the special listener to be used for "command"s whose name starts with
+ * "jitsi_participant_".
+ */
+ChatRoom.prototype.setParticipantPropertyListener = function (listener) {
+    this.participantPropertyListener = listener;
+};
+
 ChatRoom.prototype.processNode = function (node, from) {
     // make sure we catch all errors coming from any handler
     // otherwise we can remove the presence handler from strophe
     try {
         var tagHandler = this.presHandlers[node.tagName];
-        if(tagHandler)
+        if (node.tagName.startsWith("jitsi_participant_")) {
+            tagHandler = this.participantPropertyListener;
+        }
+
+        if(tagHandler) {
             tagHandler(node, Strophe.getResourceFromJid(from), from);
+        }
     } catch (e) {
         GlobalOnErrorHandler.callErrorHandler(e);
         logger.error('Error processing:' + node.tagName + ' node.', e);
 
 ChatRoom.prototype.addToPresence = function (key, values) {
     values.tagName = key;
-    this.presMap["nodes"].push(values);
+    this.removeFromPresence(key);
+    this.presMap.nodes.push(values);
 };
 
 ChatRoom.prototype.removeFromPresence = function (key) {
-    for(var i = 0; i < this.presMap.nodes.length; i++)
-    {
-        if(key === this.presMap.nodes[i].tagName)
-            this.presMap.nodes.splice(i, 1);
-    }
+    var nodes = this.presMap.nodes.filter(function(node) {
+        return key !== node.tagName;});
+    this.presMap.nodes = nodes;
 };
 
 ChatRoom.prototype.addPresenceListener = function (name, handler) {

service/RTC/RTCEvents.js

     AVAILABLE_DEVICES_CHANGED: "rtc.available_devices_changed",
     TRACK_ATTACHED: "rtc.track_attached",
     AUDIO_OUTPUT_DEVICE_CHANGED: "rtc.audio_output_device_changed",
-    DEVICE_LIST_CHANGED: "rtc.device_list_changed"
+    DEVICE_LIST_CHANGED: "rtc.device_list_changed",
+    DEVICE_LIST_AVAILABLE: "rtc.device_list_available"
 };
 
 module.exports = RTCEvents;