Added ability to switch audio output device - changes after review

JitsiMeetJS.js

         return RTC.isDeviceListAvailable();
     },
     /**
-     * Returns true if changing the camera / microphone device is supported and
-     * false if not.
+     * Returns true if changing the input (camera / microphone) or output
+     * (audio) device is supported and false if not.
+     * @params {string} [deviceType] - type of device to change. Default is
+     *      undefined or 'input', 'output' - for audio output device change.
      * @returns {boolean} true if available, false otherwise.
      */
-    isDeviceChangeAvailable: function () {
-        return RTC.isDeviceChangeAvailable();
-    },
-    /**
-     * Returns true if changing the audio output of media elements is supported
-     * and false if not.
-     */
-    isAudioOutputDeviceChangeAvailable: function () {
-        return RTC.isAudioOutputDeviceChangeAvailable();
+    isDeviceChangeAvailable: function (deviceType) {
+        return RTC.isDeviceChangeAvailable(deviceType);
     },
     /**
      * Returns currently used audio output device id, '' stands for default
     /**
      * Sets current audio output device.
      * @param {string} deviceId - id of 'audiooutput' device from
-     *      navigator.mediaDevices.enumerateDevices()
+     *      navigator.mediaDevices.enumerateDevices(), '' is for default device
      * @returns {Promise} - resolves when audio output is changed, is rejected
      *      otherwise
      */

doc/example/example.js

 });
 
 
-if (JitsiMeetJS.isAudioOutputDeviceChangeAvailable()) {
+if (JitsiMeetJS.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.enumerateDevices(function(devices) {
         var audioOutputDevices = devices.filter(function(d) { return d.kind === 'audiooutput'; });
 

modules/RTC/JitsiTrack.js

 };
 
 /**
- * Set new audio output device for track's DOM elements.
+ * Sets new audio output device for track's DOM elements. Video tracks are
+ * ignored.
  * @param {string} audioOutputDeviceId - id of 'audiooutput' device from
- *      navigator.mediaDevices.enumerateDevices()
+ *      navigator.mediaDevices.enumerateDevices(), '' for default device
  * @emits JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED
  * @returns {Promise}
  */
 JitsiTrack.prototype.setAudioOutput = function (audioOutputDeviceId) {
     var self = this;
 
-    if (!RTCUtils.isAudioOutputDeviceChangeAvailable()) {
+    if (!RTCUtils.isDeviceChangeAvailable('output')) {
         return Promise.reject(
             new Error('Audio output device change is not supported'));
     }
 
+    // All audio communication is done through audio tracks, so ignore changing
+    // audio output for video tracks at all.
+    if (this.isVideoTrack()) {
+        return Promise.resolve();
+    }
+
     return Promise.all(this.containers.map(function(element) {
         return element.setSinkId(audioOutputDeviceId)
             .catch(function (error) {
-                console.error('Failed to change audio output device on element',
+                logger.error('Failed to change audio output device on element',
                     element, error);
 
-                // TODO: for some reason 'AbortError' is raised on video
-                // elements with local track blobs. Maybe this is something
-                // similar to https://goo.gl/TKLiqx. Ignoring this error for
-                // now. Spec says that "If the device identified by the given
-                // sinkId cannot be used due to a unspecified error, throw a
-                // DOMException whose name is AbortError."
-                // In any case, all audio communication is done via separate
-                // audio elements, so maybe it doesn't make sense to change
-                // sinkId for <video> elements at all.
-                if (!(self.isVideoTrack() && self.isLocal && self.isLocal() &&
-                    error.name === 'AbortError')) {
                     throw error;
-                }
             });
     }))
     .then(function () {

modules/RTC/RTC.js

 };
 
 /**
- * Returns true if changing the camera / microphone device is supported and
- * false if not.
- */
-RTC.isDeviceChangeAvailable = function () {
-    return RTCUtils.isDeviceChangeAvailable();
-};
-
-/**
- * Returns true if changing the audio output of media elements is supported
- * and false if not.
+ * Returns true if changing the input (camera / microphone) or output
+ * (audio) device is supported and false if not.
+ * @params {string} [deviceType] - type of device to change. Default is
+ *      undefined or 'input', 'output' - for audio output device change.
+ * @returns {boolean} true if available, false otherwise.
  */
-RTC.isAudioOutputDeviceChangeAvailable = function () {
-    return RTCUtils.isAudioOutputDeviceChangeAvailable();
+RTC.isDeviceChangeAvailable = function (deviceType) {
+    return RTCUtils.isDeviceChangeAvailable(deviceType);
 };
 
 /**
  * Returns <tt>true<tt/> if given WebRTC MediaStream is considered a valid
  * "user" stream which means that it's not a "receive only" stream nor a "mixed"
  * JVB stream.
- * 
+ *
  * Clients that implement Unified Plan, such as Firefox use recvonly
  * "streams/channels/tracks" for receiving remote stream/tracks, as opposed to
  * Plan B where there are only 3 channels: audio, video and data.
- * 
+ *
  * @param stream WebRTC MediaStream instance
  * @returns {boolean}
  */

modules/RTC/RTCUtils.js

 
 var audioOuputDeviceId = ''; // default device
 
-var featureDetectionVideoEl = document.createElement('video');
+var featureDetectionAudioEl = document.createElement('audio');
+var isAudioOutputDeviceChangeAvailable =
+    typeof featureDetectionAudioEl.setSinkId !== 'undefined';
 
 var rtcReady = false;
 
             return {
                 facing: source.facing || null,
                 label: source.label,
-                // theoretically deprecated MediaStreamTrack.getSources should not return 'audiooutput' devices but
-                // let's handle it in any case
-                kind: kind ? (kind === 'audiooutput' ? kind : kind + 'input') : null,
+                // theoretically deprecated MediaStreamTrack.getSources should
+                // not return 'audiooutput' devices but let's handle it in any
+                // case
+                kind: kind
+                    ? (kind === 'audiooutput' ? kind : kind + 'input')
+                    : null,
                 deviceId: source.id,
                 groupId: source.groupId || null
             };
     return function(element, stream) {
         var res = origAttachMediaStream.apply(RTCUtils, arguments);
 
-        if (RTCUtils.isAudioOutputDeviceChangeAvailable()) {
+        if (RTCUtils.isDeviceChangeAvailable('output') &&
+            stream.getAudioTracks && stream.getAudioTracks().length) {
             element.setSinkId(RTCUtils.getAudioOutputDevice())
                 .catch(function (ex) {
-                    console.error('Failed to set audio output on element',
+                    logger.error('Failed to set audio output on element',
                         element, ex);
                 });
         }
         return (MediaStreamTrack && MediaStreamTrack.getSources)? true : false;
     },
     /**
-     * Returns true if changing the camera / microphone device is supported and
-     * false if not.
-     */
-    isDeviceChangeAvailable: function () {
-        return RTCBrowserType.isChrome() ||
-            RTCBrowserType.isFirefox() ||
-            RTCBrowserType.isOpera() ||
-            RTCBrowserType.isTemasysPluginUsed();
-    },
-    /**
-     * Returns true if changing the audio output of media elements is supported
-     * and false if not.
+     * Returns true if changing the input (camera / microphone) or output
+     * (audio) device is supported and false if not.
+     * @params {string} [deviceType] - type of device to change. Default is
+     *      undefined or 'input', 'output' - for audio output device change.
+     * @returns {boolean} true if available, false otherwise.
      */
-    isAudioOutputDeviceChangeAvailable: function () {
-        return typeof featureDetectionVideoEl.setSinkId !== 'undefined';
+    isDeviceChangeAvailable: function (deviceType) {
+        return deviceType === 'output' || deviceType === 'audiooutput'
+            ? isAudioOutputDeviceChangeAvailable
+            : RTCBrowserType.isChrome() ||
+                RTCBrowserType.isFirefox() ||
+                RTCBrowserType.isOpera() ||
+                RTCBrowserType.isTemasysPluginUsed();
     },
     /**
      * A method to handle stopping of the stream.
     /**
      * Sets current audio output device.
      * @param {string} deviceId - id of 'audiooutput' device from
-     *      navigator.mediaDevices.enumerateDevices()
+     *      navigator.mediaDevices.enumerateDevices(), '' for default device
      * @returns {Promise} - resolves when audio output is changed, is rejected
      *      otherwise
      */
     setAudioOutputDevice: function (deviceId) {
-        if (!this.isAudioOutputDeviceChangeAvailable()) {
+        if (!this.isDeviceChangeAvailable('output')) {
             Promise.reject(
                 new Error('Audio output device change is not supported'));
         }
-        
-        return featureDetectionVideoEl.setSinkId(deviceId)
+
+        return featureDetectionAudioEl.setSinkId(deviceId)
             .then(function() {
                 audioOuputDeviceId = deviceId;
 
+                logger.log('Audio output device set to ' + deviceId);
+
                 eventEmitter.emit(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
                     deviceId);
             });