fix(RTC) drop the "old gUM" flow

JitsiMeetJS.js

@@ -34,7 +34,6 @@ import ScriptUtil from './modules/util/ScriptUtil';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 import AudioMixer from './modules/webaudio/AudioMixer';
 import * as MediaType from './service/RTC/MediaType';
-import Resolutions from './service/RTC/Resolutions';
 import * as ConnectionQualityEvents
     from './service/connectivity/ConnectionQualityEvents';
 import * as E2ePingEvents from './service/e2eping/E2ePingEvents';
@@ -48,38 +47,6 @@ const logger = Logger.getLogger(__filename);
  */
 const USER_MEDIA_SLOW_PROMISE_TIMEOUT = 1000;
 
-/**
- * Gets the next lowest desirable resolution to try for a camera. If the given
- * resolution is already the lowest acceptable resolution, returns {@code null}.
- *
- * @param resolution the current resolution
- * @return the next lowest resolution from the given one, or {@code null} if it
- * is already the lowest acceptable resolution.
- */
-function getLowerResolution(resolution) {
-    if (!Resolutions[resolution]) {
-        return null;
-    }
-    const order = Resolutions[resolution].order;
-    let res = null;
-    let resName = null;
-
-    Object.keys(Resolutions).forEach(r => {
-        const value = Resolutions[r];
-
-        if (!res || (res.order < value.order && value.order < order)) {
-            resName = r;
-            res = value;
-        }
-    });
-
-    if (resName === resolution) {
-        resName = null;
-    }
-
-    return resName;
-}
-
 /**
  * Extracts from an 'options' objects with a specific format (TODO what IS the
  * format?) the attributes which are to be logged in analytics events.
@@ -327,13 +294,11 @@ export default _mergeNamespaceAndModule({
      * will finish the execution with rejected Promise.
      *
      * @deprecated old firePermissionPromptIsShownEvent
-     * @param originalOptions - internal use only, to be able to store the
-     * originally requested options.
      * @returns {Promise.<{Array.<JitsiTrack>}, JitsiConferenceError>} A promise
      * that returns an array of created JitsiTracks if resolved, or a
      * JitsiConferenceError if rejected.
      */
-    createLocalTracks(options = {}, oldfirePermissionPromptIsShownEvent, originalOptions) {
+    createLocalTracks(options = {}, oldfirePermissionPromptIsShownEvent) {
         let promiseFulfilled = false;
 
         const { firePermissionPromptIsShownEvent, fireSlowPromiseEvent, ...restOptions } = options;
@@ -413,46 +378,7 @@ export default _mergeNamespaceAndModule({
             .catch(error => {
                 promiseFulfilled = true;
 
-                if (error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION
-                    && !browser.usesNewGumFlow()) {
-                    const oldResolution = restOptions.resolution || '720';
-                    const newResolution = getLowerResolution(oldResolution);
-
-                    if (newResolution !== null) {
-                        restOptions.resolution = newResolution;
-
-                        logger.debug(
-                            'Retry createLocalTracks with resolution',
-                            newResolution);
-
-                        Statistics.sendAnalytics(createGetUserMediaEvent(
-                            'warning',
-                            {
-                                'old_resolution': oldResolution,
-                                'new_resolution': newResolution,
-                                reason: 'unsupported resolution'
-                            }));
-
-                        return this.createLocalTracks(
-                            restOptions,
-                            originalOptions || Object.assign({}, restOptions));
-                    }
-
-                    // We tried everything. If there is a mandatory device id,
-                    // remove it and let gum find a device to use.
-                    if (originalOptions
-                        && error.gum.constraints
-                        && error.gum.constraints.video
-                        && error.gum.constraints.video.mandatory
-                        && error.gum.constraints.video.mandatory.sourceId) {
-                        originalOptions.cameraDeviceId = undefined;
-
-                        return this.createLocalTracks(originalOptions);
-                    }
-                }
-
-                if (error.name
-                        === JitsiTrackErrors.SCREENSHARING_USER_CANCELED) {
+                if (error.name === JitsiTrackErrors.SCREENSHARING_USER_CANCELED) {
                     // User cancelled action is not really an error, so only
                     // log it as an event to avoid having conference classified
                     // as partially failed

modules/RTC/JitsiLocalTrack.js

@@ -90,29 +90,21 @@ export default class JitsiLocalTrack extends JitsiTrack {
         this.sourceId = sourceId;
         this.sourceType = sourceType;
 
-        if (browser.usesNewGumFlow()) {
-            // Get the resolution from the track itself because it cannot be
-            // certain which resolution webrtc has fallen back to using.
-            this.resolution = track.getSettings().height;
-            this.maxEnabledResolution = resolution;
-
-            // Cache the constraints of the track in case of any this track
-            // model needs to call getUserMedia again, such as when unmuting.
-            this._constraints = track.getConstraints();
-
-            // Safari returns an empty constraints object, construct the constraints using getSettings.
-            if (!Object.keys(this._constraints).length && videoType === VideoType.CAMERA) {
-                this._constraints = {
-                    height: track.getSettings().height,
-                    width: track.getSettings().width
-                };
-            }
-        } else {
-            // FIXME Currently, Firefox is ignoring our constraints about
-            // resolutions so we do not store it, to avoid wrong reporting of
-            // local track resolution.
-            this.resolution = browser.isFirefox() ? null : resolution;
-            this.maxEnabledResolution = this.resolution;
+        // Get the resolution from the track itself because it cannot be
+        // certain which resolution webrtc has fallen back to using.
+        this.resolution = track.getSettings().height;
+        this.maxEnabledResolution = resolution;
+
+        // Cache the constraints of the track in case of any this track
+        // model needs to call getUserMedia again, such as when unmuting.
+        this._constraints = track.getConstraints();
+
+        // Safari returns an empty constraints object, construct the constraints using getSettings.
+        if (!Object.keys(this._constraints).length && videoType === VideoType.CAMERA) {
+            this._constraints = {
+                height: track.getSettings().height,
+                width: track.getSettings().width
+            };
         }
 
         this.deviceId = deviceId;
@@ -552,30 +544,16 @@ export default class JitsiLocalTrack extends JitsiTrack {
                 facingMode: this.getCameraFacingMode()
             };
 
-            if (browser.usesNewGumFlow()) {
-                promise
-                    = RTCUtils.newObtainAudioAndVideoPermissions(Object.assign(
-                        {},
-                        streamOptions,
-                        { constraints: { video: this._constraints } }));
-            } else {
-                if (this.resolution) {
-                    streamOptions.resolution = this.resolution;
-                }
-
-                promise
-                    = RTCUtils.obtainAudioAndVideoPermissions(streamOptions);
-            }
+            promise
+                = RTCUtils.obtainAudioAndVideoPermissions(Object.assign(
+                    {},
+                    streamOptions,
+                    { constraints: { video: this._constraints } }));
 
             promise = promise.then(streamsInfo => {
                 // The track kind for presenter track is video as well.
                 const mediaType = this.getType() === MediaType.PRESENTER ? MediaType.VIDEO : this.getType();
-                const streamInfo
-                    = browser.usesNewGumFlow()
-                        ? streamsInfo.find(
-                            info => info.track.kind === mediaType)
-                        : streamsInfo.find(
-                            info => info.mediaType === mediaType);
+                const streamInfo = streamsInfo.find(info => info.track.kind === mediaType);
 
                 if (streamInfo) {
                     this._setStream(streamInfo.stream);
@@ -822,15 +800,8 @@ export default class JitsiLocalTrack extends JitsiTrack {
             // Chromium and https://bugzilla.mozilla.org/show_bug.cgi?id=1213517
             // for Firefox. Even if a browser implements getSettings() already,
             // it might still not return anything for 'facingMode'.
-            let trackSettings;
-
-            try {
-                trackSettings = this.track.getSettings();
-            } catch (e) {
-                // XXX React-native-webrtc, for example, defines
-                // MediaStreamTrack#getSettings() but the implementation throws
-                // a "Not implemented" Error.
-            }
+            const trackSettings = this.track.getSettings?.();
+
             if (trackSettings && 'facingMode' in trackSettings) {
                 return trackSettings.facingMode;
             }

modules/RTC/RTC.js

@@ -33,36 +33,6 @@ let peerConnectionIdCounter = 0;
  */
 let rtcTrackIdCounter = 0;
 
-/**
- *
- * @param tracksInfo
- * @param options
- */
-function createLocalTracks(tracksInfo, options) {
-    const newTracks = [];
-    let deviceId = null;
-
-    tracksInfo.forEach(trackInfo => {
-        if (trackInfo.mediaType === MediaType.AUDIO) {
-            deviceId = options.micDeviceId;
-        } else if (trackInfo.videoType === VideoType.CAMERA) {
-            deviceId = options.cameraDeviceId;
-        }
-        rtcTrackIdCounter = safeCounterIncrement(rtcTrackIdCounter);
-        const localTrack = new JitsiLocalTrack({
-            ...trackInfo,
-            deviceId,
-            facingMode: options.facingMode,
-            rtcId: rtcTrackIdCounter,
-            effects: options.effects
-        });
-
-        newTracks.push(localTrack);
-    });
-
-    return newTracks;
-}
-
 /**
  * Creates {@code JitsiLocalTrack} instances from the passed in meta information
  * about MedieaTracks.
@@ -78,7 +48,7 @@ function createLocalTracks(tracksInfo, options) {
  *     effects: Array of effect types
  * }}
  */
-function _newCreateLocalTracks(mediaStreamMetaData = []) {
+function _createLocalTracks(mediaStreamMetaData = []) {
     return mediaStreamMetaData.map(metaData => {
         const {
             sourceId,
@@ -223,8 +193,8 @@ export default class RTC extends Listenable {
      * @param {Array<Object>} tracksInfo
      * @returns {Array<JitsiLocalTrack>}
      */
-    static newCreateLocalTracks(tracksInfo) {
-        return _newCreateLocalTracks(tracksInfo);
+    static createLocalTracks(tracksInfo) {
+        return _createLocalTracks(tracksInfo);
     }
 
     /**
@@ -237,18 +207,9 @@ export default class RTC extends Listenable {
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
     static obtainAudioAndVideoPermissions(options) {
-        const usesNewGumFlow = browser.usesNewGumFlow();
-        const obtainMediaPromise = usesNewGumFlow
-            ? RTCUtils.newObtainAudioAndVideoPermissions(options)
-            : RTCUtils.obtainAudioAndVideoPermissions(options);
-
-        return obtainMediaPromise.then(tracksInfo => {
-            if (usesNewGumFlow) {
-                return _newCreateLocalTracks(tracksInfo);
-            }
+        return RTCUtils.obtainAudioAndVideoPermissions(options)
+            .then(tracksInfo => _createLocalTracks(tracksInfo));
 
-            return createLocalTracks(tracksInfo, options);
-        });
     }
 
     /**

modules/RTC/RTCUtils.js

@@ -13,7 +13,6 @@ import clonedeep from 'lodash.clonedeep';
 import JitsiTrackError from '../../JitsiTrackError';
 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
-import * as MediaType from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import Resolutions from '../../service/RTC/Resolutions';
 import VideoType from '../../service/RTC/VideoType';
@@ -39,19 +38,6 @@ const eventEmitter = new EventEmitter();
 
 const AVAILABLE_DEVICES_POLL_INTERVAL_TIME = 3000; // ms
 
-/**
- * Default resolution to obtain for video tracks if no resolution is specified.
- * This default is used for old gum flow only, as new gum flow uses
- * {@link DEFAULT_CONSTRAINTS}.
- */
-const OLD_GUM_DEFAULT_RESOLUTION = 720;
-
-/**
- * Default devices to obtain when no specific devices are specified. This
- * default is used for old gum flow only.
- */
-const OLD_GUM_DEFAULT_DEVICES = [ 'audio', 'video' ];
-
 /**
  * Default MediaStreamConstraints to use for calls to getUserMedia.
  *
@@ -72,11 +58,6 @@ const DEFAULT_CONSTRAINTS = {
     }
 };
 
-/**
- * The default frame rate for Screen Sharing.
- */
-export const SS_DEFAULT_FRAME_RATE = 5;
-
 // Currently audio output device change is supported only in Chrome and
 // default output always has 'default' device ID
 let audioOutputDeviceId = 'default'; // default device
@@ -95,9 +76,6 @@ let disableNS = false;
 // Disables Automatic Gain Control
 let disableAGC = false;
 
-// Disables Highpass Filter
-let disableHPF = false;
-
 // Enables stereo.
 let stereo = null;
 
@@ -115,246 +93,6 @@ function emptyFuncton() {
     // no-op
 }
 
-/**
- *
- * @param constraints
- * @param isNewStyleConstraintsSupported
- * @param resolution
- */
-function setResolutionConstraints(
-        constraints,
-        isNewStyleConstraintsSupported,
-        resolution) {
-    if (Resolutions[resolution]) {
-        if (isNewStyleConstraintsSupported) {
-            constraints.video.width = {
-                ideal: Resolutions[resolution].width
-            };
-            constraints.video.height = {
-                ideal: Resolutions[resolution].height
-            };
-        }
-
-        constraints.video.mandatory.minWidth = Resolutions[resolution].width;
-        constraints.video.mandatory.minHeight = Resolutions[resolution].height;
-    }
-
-    if (constraints.video.mandatory.minWidth) {
-        constraints.video.mandatory.maxWidth
-            = constraints.video.mandatory.minWidth;
-    }
-
-    if (constraints.video.mandatory.minHeight) {
-        constraints.video.mandatory.maxHeight
-            = constraints.video.mandatory.minHeight;
-    }
-}
-
-/**
- * @param {string[]} um required user media types
- *
- * @param {Object} [options={}] optional parameters
- * @param {string} options.resolution
- * @param {number} options.bandwidth
- * @param {number} options.fps
- * @param {string} options.desktopStream
- * @param {string} options.cameraDeviceId
- * @param {string} options.micDeviceId
- * @param {CameraFacingMode} options.facingMode
- * @param {bool} firefox_fake_device
- * @param {Object} options.frameRate - used only for dekstop sharing.
- * @param {Object} options.frameRate.min - Minimum fps
- * @param {Object} options.frameRate.max - Maximum fps
- * @param {bool}   options.screenShareAudio - Used by electron clients to
- * enable system audio screen sharing.
- */
-function getConstraints(um, options = {}) {
-    const constraints = {
-        audio: false,
-        video: false
-    };
-
-    // Don't mix new and old style settings for Chromium as this leads
-    // to TypeError in new Chromium versions. @see
-    // https://bugs.chromium.org/p/chromium/issues/detail?id=614716
-    // This is a temporary solution, in future we will fully split old and
-    // new style constraints when new versions of Chromium and Firefox will
-    // have stable support of new constraints format. For more information
-    // @see https://github.com/jitsi/lib-jitsi-meet/pull/136
-    const isNewStyleConstraintsSupported
-        = browser.isFirefox()
-            || browser.isWebKitBased()
-            || browser.isReactNative();
-
-    if (um.indexOf('video') >= 0) {
-        // same behaviour as true
-        constraints.video = { mandatory: {},
-            optional: [] };
-
-        if (options.cameraDeviceId) {
-            if (isNewStyleConstraintsSupported) {
-                // New style of setting device id.
-                constraints.video.deviceId = options.cameraDeviceId;
-            }
-
-            // Old style.
-            constraints.video.mandatory.sourceId = options.cameraDeviceId;
-        } else {
-            // Prefer the front i.e. user-facing camera (to the back i.e.
-            // environment-facing camera, for example).
-            // TODO: Maybe use "exact" syntax if options.facingMode is defined,
-            // but this probably needs to be decided when updating other
-            // constraints, as we currently don't use "exact" syntax anywhere.
-            const facingMode = options.facingMode || CameraFacingMode.USER;
-
-            if (isNewStyleConstraintsSupported) {
-                constraints.video.facingMode = facingMode;
-            }
-            constraints.video.optional.push({
-                facingMode
-            });
-        }
-
-        if (options.minFps || options.maxFps || options.fps) {
-            // for some cameras it might be necessary to request 30fps
-            // so they choose 30fps mjpg over 10fps yuy2
-            if (options.minFps || options.fps) {
-                // Fall back to options.fps for backwards compatibility
-                options.minFps = options.minFps || options.fps;
-                constraints.video.mandatory.minFrameRate = options.minFps;
-            }
-            if (options.maxFps) {
-                constraints.video.mandatory.maxFrameRate = options.maxFps;
-            }
-        }
-
-        setResolutionConstraints(
-            constraints, isNewStyleConstraintsSupported, options.resolution);
-    }
-    if (um.indexOf('audio') >= 0) {
-        if (browser.isReactNative()) {
-            // The react-native-webrtc project that we're currently using
-            // expects the audio constraint to be a boolean.
-            constraints.audio = true;
-        } else if (browser.isFirefox()) {
-            if (options.micDeviceId) {
-                constraints.audio = {
-                    mandatory: {},
-                    deviceId: options.micDeviceId, // new style
-                    optional: [ {
-                        sourceId: options.micDeviceId // old style
-                    } ] };
-            } else {
-                constraints.audio = true;
-            }
-        } else {
-            // same behaviour as true
-            constraints.audio = { mandatory: {},
-                optional: [] };
-            if (options.micDeviceId) {
-                if (isNewStyleConstraintsSupported) {
-                    // New style of setting device id.
-                    constraints.audio.deviceId = options.micDeviceId;
-                }
-
-                // Old style.
-                constraints.audio.optional.push({
-                    sourceId: options.micDeviceId
-                });
-            }
-
-            // if it is good enough for hangouts...
-            constraints.audio.optional.push(
-                { echoCancellation: !disableAEC && !disableAP },
-                { googEchoCancellation: !disableAEC && !disableAP },
-                { googAutoGainControl: !disableAGC && !disableAP },
-                { googNoiseSuppression: !disableNS && !disableAP },
-                { googHighpassFilter: !disableHPF && !disableAP },
-                { googNoiseSuppression2: !disableNS && !disableAP },
-                { googEchoCancellation2: !disableAEC && !disableAP },
-                { googAutoGainControl2: !disableAGC && !disableAP }
-            );
-        }
-    }
-    if (um.indexOf('screen') >= 0) {
-        if (browser.isChrome()) {
-            constraints.video = {
-                mandatory: getSSConstraints({
-                    ...options,
-                    source: 'screen'
-                }),
-                optional: []
-            };
-
-        } else if (browser.isFirefox()) {
-            constraints.video = {
-                mozMediaSource: 'window',
-                mediaSource: 'window',
-                frameRate: options.frameRate || {
-                    min: SS_DEFAULT_FRAME_RATE,
-                    max: SS_DEFAULT_FRAME_RATE
-                }
-            };
-
-        } else {
-            const errmsg
-                = '\'screen\' WebRTC media source is supported only in Chrome'
-                    + ' and Firefox';
-
-            GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-            logger.error(errmsg);
-        }
-    }
-    if (um.indexOf('desktop') >= 0) {
-        constraints.video = {
-            mandatory: getSSConstraints({
-                ...options,
-                source: 'desktop'
-            }),
-            optional: []
-        };
-
-        // Audio screen sharing for electron only works for screen type devices.
-        // i.e. when the user shares the whole desktop.
-        if (browser.isElectron() && options.screenShareAudio
-            && (options.desktopStream.indexOf('screen') >= 0)) {
-
-            // Provide constraints as described by the electron desktop capturer
-            // documentation here:
-            // https://www.electronjs.org/docs/api/desktop-capturer
-            // Note. The documentation specifies that chromeMediaSourceId should not be present
-            // which, in the case a users has multiple monitors, leads to them being shared all
-            // at once. However we tested with chromeMediaSourceId present and it seems to be
-            // working properly and also takes care of the previously mentioned issue.
-            constraints.audio = { mandatory: {
-                chromeMediaSource: constraints.video.mandatory.chromeMediaSource
-            } };
-        }
-    }
-
-    if (options.bandwidth) {
-        if (!constraints.video) {
-            // same behaviour as true
-            constraints.video = { mandatory: {},
-                optional: [] };
-        }
-        constraints.video.optional.push({ bandwidth: options.bandwidth });
-    }
-
-    // we turn audio for both audio and video tracks, the fake audio & video
-    // seems to work only when enabled in one getUserMedia call, we cannot get
-    // fake audio separate by fake video this later can be a problem with some
-    // of the tests
-    if (browser.isFirefox() && options.firefox_fake_device) {
-        // seems to be fixed now, removing this experimental fix, as having
-        // multiple audio tracks brake the tests
-        // constraints.audio = true;
-        constraints.fake = true;
-    }
-
-    return constraints;
-}
-
 /**
  * Creates a constraints object to be passed into a call to getUserMedia.
  *
@@ -377,12 +115,22 @@ function getConstraints(um, options = {}) {
  * @private
  * @returns {Object}
  */
-function newGetConstraints(um = [], options = {}) {
+function getConstraints(um = [], options = {}) {
     // Create a deep copy of the constraints to avoid any modification of
     // the passed in constraints object.
     const constraints = clonedeep(options.constraints || DEFAULT_CONSTRAINTS);
 
     if (um.indexOf('video') >= 0) {
+        // The "resolution" option is a shortcut and takes precendence.
+        if (Resolutions[options.resolution]) {
+            const r = Resolutions[options.resolution];
+
+            constraints.video = {
+                height: { ideal: r.height },
+                width: { ideal: r.width }
+            };
+        }
+
         if (!constraints.video) {
             constraints.video = {};
         }
@@ -393,12 +141,12 @@ function newGetConstraints(um = [], options = {}) {
         // TODO: remove this hack when the bug fix is available on Mojave, Sierra and High Sierra.
         if (browser.isWebKitBased()) {
             if (constraints.video.height && constraints.video.height.ideal) {
-                constraints.video.height = { ideal: clonedeep(constraints.video.height.ideal) };
+                constraints.video.height = { ideal: constraints.video.height.ideal };
             } else {
                 logger.warn('Ideal camera height missing, camera may not start properly');
             }
             if (constraints.video.width && constraints.video.width.ideal) {
-                constraints.video.width = { ideal: clonedeep(constraints.video.width.ideal) };
+                constraints.video.width = { ideal: constraints.video.width.ideal };
             } else {
                 logger.warn('Ideal camera width missing, camera may not start properly');
             }
@@ -433,60 +181,6 @@ function newGetConstraints(um = [], options = {}) {
         constraints.audio = false;
     }
 
-    if (um.indexOf('desktop') >= 0) {
-        if (!constraints.video || typeof constraints.video === 'boolean') {
-            constraints.video = {};
-        }
-
-        constraints.video = {
-            mandatory: getSSConstraints({
-                ...options,
-                source: 'desktop'
-            })
-        };
-    }
-
-    return constraints;
-}
-
-/**
- * Generates GUM constraints for screen sharing.
- *
- * @param {Object} options - The options passed to
- * <tt>obtainAudioAndVideoPermissions</tt>.
- * @returns {Object} - GUM constraints.
- *
- * TODO: Currently only the new GUM flow and Chrome is using the method. We
- * should make it work for all use cases.
- */
-function getSSConstraints(options = {}) {
-    const {
-        desktopStream,
-        frameRate = {
-            min: SS_DEFAULT_FRAME_RATE,
-            max: SS_DEFAULT_FRAME_RATE
-        }
-    } = options;
-    const { max, min } = frameRate;
-
-    const constraints = {
-        chromeMediaSource: options.source,
-        maxWidth: window.screen.width,
-        maxHeight: window.screen.height
-    };
-
-    if (typeof min === 'number') {
-        constraints.minFrameRate = min;
-    }
-
-    if (typeof max === 'number') {
-        constraints.maxFrameRate = max;
-    }
-
-    if (typeof desktopStream !== 'undefined') {
-        constraints.chromeMediaSourceId = desktopStream;
-    }
-
     return constraints;
 }
 
@@ -615,92 +309,6 @@ function onMediaDevicesListChanged(devicesReceived) {
     eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, availableDevices);
 }
 
-/**
- * Handles the newly created Media Streams.
- * @param streams the new Media Streams
- * @param resolution the resolution of the video streams
- * @returns {*[]} object that describes the new streams
- */
-function handleLocalStream(streams, resolution) {
-    let audioStream, desktopStream, videoStream;
-    const res = [];
-
-    // XXX The function obtainAudioAndVideoPermissions has examined the type of
-    // the browser, its capabilities, etc. and has taken the decision whether to
-    // invoke getUserMedia per device (e.g. Firefox) or once for both audio and
-    // video (e.g. Chrome). In order to not duplicate the logic here, examine
-    // the specified streams and figure out what we've received based on
-    // obtainAudioAndVideoPermissions' decision.
-    if (streams) {
-        // As mentioned above, certian types of browser (e.g. Chrome) support
-        // (with a result which meets our requirements expressed bellow) calling
-        // getUserMedia once for both audio and video.
-        const audioVideo = streams.audioVideo;
-
-        if (audioVideo) {
-            const audioTracks = audioVideo.getAudioTracks();
-
-            if (audioTracks.length) {
-                audioStream = new MediaStream();
-                for (let i = 0; i < audioTracks.length; i++) {
-                    audioStream.addTrack(audioTracks[i]);
-                }
-            }
-
-            const videoTracks = audioVideo.getVideoTracks();
-
-            if (videoTracks.length) {
-                videoStream = new MediaStream();
-                for (let j = 0; j < videoTracks.length; j++) {
-                    videoStream.addTrack(videoTracks[j]);
-                }
-            }
-
-            audioVideo.release && audioVideo.release(false);
-        } else {
-            // On other types of browser (e.g. Firefox) we choose (namely,
-            // obtainAudioAndVideoPermissions) to call getUserMedia per device
-            // (type).
-            audioStream = streams.audio;
-            videoStream = streams.video;
-        }
-
-        desktopStream = streams.desktop;
-    }
-
-    if (desktopStream) {
-        const { stream, sourceId, sourceType } = desktopStream;
-
-        res.push({
-            stream,
-            sourceId,
-            sourceType,
-            track: stream.getVideoTracks()[0],
-            mediaType: MediaType.VIDEO,
-            videoType: VideoType.DESKTOP
-        });
-    }
-    if (audioStream) {
-        res.push({
-            stream: audioStream,
-            track: audioStream.getAudioTracks()[0],
-            mediaType: MediaType.AUDIO,
-            videoType: null
-        });
-    }
-    if (videoStream) {
-        res.push({
-            stream: videoStream,
-            track: videoStream.getVideoTracks()[0],
-            mediaType: MediaType.VIDEO,
-            videoType: VideoType.CAMERA,
-            resolution
-        });
-    }
-
-    return res;
-}
-
 /**
  *
  */
@@ -738,10 +346,6 @@ class RTCUtils extends Listenable {
             disableAGC = options.disableAGC;
             logger.info(`Disable AGC: ${disableAGC}`);
         }
-        if (typeof options.disableHPF === 'boolean') {
-            disableHPF = options.disableHPF;
-            logger.info(`Disable HPF: ${disableHPF}`);
-        }
         if (typeof options.audioQuality?.stereo === 'boolean') {
             stereo = options.audioQuality.stereo;
             logger.info(`Stereo: ${stereo}`);
@@ -750,19 +354,7 @@ class RTCUtils extends Listenable {
         window.clearInterval(availableDevicesPollTimer);
         availableDevicesPollTimer = undefined;
 
-        if (browser.usesNewGumFlow()) {
-            this.RTCPeerConnectionType = RTCPeerConnection;
-
-            this.attachMediaStream
-                = wrapAttachMediaStream((element, stream) => {
-                    if (element) {
-                        element.srcObject = stream;
-                    }
-                });
-
-            this.getStreamID = ({ id }) => id;
-            this.getTrackID = ({ id }) => id;
-        } else if (browser.isReactNative()) {
+        if (browser.isReactNative()) {
             this.RTCPeerConnectionType = RTCPeerConnection;
 
             this.attachMediaStream = undefined; // Unused on React Native.
@@ -779,10 +371,17 @@ class RTCUtils extends Listenable {
             };
             this.getTrackID = ({ id }) => id;
         } else {
-            const message = 'Endpoint does not appear to be WebRTC-capable';
+            this.RTCPeerConnectionType = RTCPeerConnection;
 
-            logger.error(message);
-            throw new Error(message);
+            this.attachMediaStream
+                = wrapAttachMediaStream((element, stream) => {
+                    if (element) {
+                        element.srcObject = stream;
+                    }
+                });
+
+            this.getStreamID = ({ id }) => id;
+            this.getTrackID = ({ id }) => id;
         }
 
         this.pcConstraints = browser.isChromiumBased() || browser.isReactNative()
@@ -792,9 +391,7 @@ class RTCUtils extends Listenable {
             ] }
             : {};
 
-        screenObtainer.init(
-            options,
-            this.getUserMediaWithConstraints.bind(this));
+        screenObtainer.init(options);
 
         if (this.isDeviceListAvailable()) {
             this.enumerateDevices(ds => {
@@ -839,38 +436,6 @@ class RTCUtils extends Listenable {
             });
     }
 
-    /* eslint-disable max-params */
-
-    /**
-    * @param {string[]} um required user media types
-    * @param {Object} [options] optional parameters
-    * @param {string} options.resolution
-    * @param {number} options.bandwidth
-    * @param {number} options.fps
-    * @param {string} options.desktopStream
-    * @param {string} options.cameraDeviceId
-    * @param {string} options.micDeviceId
-    * @param {Object} options.frameRate - used only for dekstop sharing.
-    * @param {Object} options.frameRate.min - Minimum fps
-    * @param {Object} options.frameRate.max - Maximum fps
-    * @param {bool}   options.screenShareAudio - Used by electron clients to
-    * enable system audio screen sharing.
-    * @param {number} options.timeout - The timeout in ms for GUM.
-    * @returns {Promise} Returns a media stream on success or a JitsiTrackError
-    * on failure.
-    **/
-    getUserMediaWithConstraints(um, options = {}) {
-        const {
-            timeout,
-            ...otherOptions
-        } = options;
-        const constraints = getConstraints(um, otherOptions);
-
-        logger.info('Get media constraints', JSON.stringify(constraints));
-
-        return this._getUserMedia(um, constraints, timeout);
-    }
-
     /**
      * Acquires a media stream via getUserMedia that
      * matches the given constraints
@@ -930,23 +495,17 @@ class RTCUtils extends Listenable {
      * logic compared to use screenObtainer versus normal device capture logic
      * in RTCUtils#_getUserMedia.
      *
-     * @param {Object} options
-     * @param {string[]} options.desktopSharingSources
-     * @param {Object} options.desktopSharingFrameRate
-     * @param {Object} options.desktopSharingFrameRate.min - Minimum fps
-     * @param {Object} options.desktopSharingFrameRate.max - Maximum fps
      * @returns {Promise} A promise which will be resolved with an object which
      * contains the acquired display stream. If desktop sharing is not supported
      * then a rejected promise will be returned.
      */
-    _newGetDesktopMedia(options) {
+    _getDesktopMedia() {
         if (!screenObtainer.isSupported()) {
             return Promise.reject(new Error('Desktop sharing is not supported!'));
         }
 
         return new Promise((resolve, reject) => {
             screenObtainer.obtainStream(
-                this._parseDesktopSharingOptions(options),
                 stream => {
                     resolve(stream);
                 },
@@ -956,108 +515,6 @@ class RTCUtils extends Listenable {
         });
     }
 
-    /* eslint-enable max-params */
-
-    /**
-     * Creates the local MediaStreams.
-     * @param {Object} [options] optional parameters
-     * @param {Array} options.devices the devices that will be requested
-     * @param {string} options.resolution resolution constraints
-     * @param {string} options.cameraDeviceId
-     * @param {string} options.micDeviceId
-     * @param {Object} options.desktopSharingFrameRate
-     * @param {Object} options.desktopSharingFrameRate.min - Minimum fps
-     * @param {Object} options.desktopSharingFrameRate.max - Maximum fps
-     * @returns {*} Promise object that will receive the new JitsiTracks
-     */
-    obtainAudioAndVideoPermissions(options = {}) {
-        options.devices = options.devices || [ ...OLD_GUM_DEFAULT_DEVICES ];
-        options.resolution = options.resolution || OLD_GUM_DEFAULT_RESOLUTION;
-
-        const requestingDesktop = options.devices.includes('desktop');
-
-        if (requestingDesktop && !screenObtainer.isSupported()) {
-            return Promise.reject(
-                new Error('Desktop sharing is not supported!'));
-        }
-
-        return this._getAudioAndVideoStreams(options).then(streams =>
-            handleLocalStream(streams, options.resolution));
-    }
-
-    /**
-     * Performs one call to getUserMedia for audio and/or video and another call
-     * for desktop.
-     *
-     * @param {Object} options - An object describing how the gUM request should
-     * be executed. See {@link obtainAudioAndVideoPermissions} for full options.
-     * @returns {*} Promise object that will receive the new JitsiTracks on
-     * success or a JitsiTrackError on failure.
-     */
-    _getAudioAndVideoStreams(options) {
-        const requestingDesktop = options.devices.includes('desktop');
-
-        options.devices = options.devices.filter(device =>
-            device !== 'desktop');
-
-        const gumPromise = options.devices.length
-            ? this.getUserMediaWithConstraints(options.devices, options)
-            : Promise.resolve(null);
-
-        return gumPromise
-            .then(avStream => {
-                // If any requested devices are missing, call gum again in
-                // an attempt to obtain the actual error. For example, the
-                // requested video device is missing or permission was
-                // denied.
-                const missingTracks
-                    = this._getMissingTracks(options.devices, avStream);
-
-                if (missingTracks.length) {
-                    this.stopMediaStream(avStream);
-
-                    return this.getUserMediaWithConstraints(
-                        missingTracks, options)
-
-                        // GUM has already failed earlier and this success
-                        // handling should not be reached.
-                        .then(() => Promise.reject(new JitsiTrackError(
-                            { name: 'UnknownError' },
-                            getConstraints(options.devices, options),
-                            missingTracks)));
-                }
-
-                return avStream;
-            })
-            .then(audioVideo => {
-                if (!requestingDesktop) {
-                    return { audioVideo };
-                }
-
-                if (options.desktopSharingSourceDevice) {
-                    this.stopMediaStream(audioVideo);
-
-                    throw new Error('Using a camera as screenshare source is'
-                        + 'not supported on this browser.');
-                }
-
-                return new Promise((resolve, reject) => {
-                    screenObtainer.obtainStream(
-                        this._parseDesktopSharingOptions(options),
-                        desktop => resolve({
-                            audioVideo,
-                            desktop
-                        }),
-                        error => {
-                            if (audioVideo) {
-                                this.stopMediaStream(audioVideo);
-                            }
-                            reject(error);
-                        });
-                });
-            });
-    }
-
     /**
      * Private utility for determining if the passed in MediaStream contains
      * tracks of the type(s) specified in the requested devices.
@@ -1091,22 +548,6 @@ class RTCUtils extends Listenable {
         return missingDevices;
     }
 
-    /**
-     * Returns an object formatted for specifying desktop sharing parameters.
-     *
-     * @param {Object} options - Takes in the same options object as
-     * {@link obtainAudioAndVideoPermissions}.
-     * @returns {Object}
-     */
-    _parseDesktopSharingOptions(options) {
-        return {
-            desktopSharingSources: options.desktopSharingSources,
-            gumOptions: {
-                frameRate: options.desktopSharingFrameRate
-            }
-        };
-    }
-
     /**
      * Gets streams from specified device types. This function intentionally
      * ignores errors for upstream to catch and handle instead.
@@ -1125,9 +566,7 @@ class RTCUtils extends Listenable {
      * track. If an error occurs, it will be deferred to the caller for
      * handling.
      */
-    newObtainAudioAndVideoPermissions(options) {
-        logger.info('Using the new gUM flow');
-
+    obtainAudioAndVideoPermissions(options) {
         const {
             timeout,
             ...otherOptions
@@ -1155,9 +594,7 @@ class RTCUtils extends Listenable {
             }
 
             const {
-                desktopSharingSourceDevice,
-                desktopSharingSources,
-                desktopSharingFrameRate
+                desktopSharingSourceDevice
             } = otherOptions;
 
             // Attempt to use a video input device as a screenshare source if
@@ -1178,15 +615,11 @@ class RTCUtils extends Listenable {
                 }
 
                 const requestedDevices = [ 'video' ];
-
-                // Leverage the helper used by {@link _newGetDesktopMedia} to
-                // get constraints for the desktop stream.
-                const { gumOptions } = this._parseDesktopSharingOptions(otherOptions);
-
                 const constraints = {
                     video: {
-                        ...gumOptions,
                         deviceId: matchingDevice.deviceId
+
+                        // frameRate is omited here on purpose since this is a device that we'll pretend is a screen.
                     }
                 };
 
@@ -1199,10 +632,7 @@ class RTCUtils extends Listenable {
                     });
             }
 
-            return this._newGetDesktopMedia({
-                desktopSharingSources,
-                desktopSharingFrameRate
-            });
+            return this._getDesktopMedia();
         }.bind(this);
 
         /**
@@ -1264,8 +694,7 @@ class RTCUtils extends Listenable {
                 return Promise.resolve();
             }
 
-            const constraints = newGetConstraints(
-                requestedCaptureDevices, otherOptions);
+            const constraints = getConstraints(requestedCaptureDevices, otherOptions);
 
             logger.info('Got media constraints: ', JSON.stringify(constraints));
 

modules/RTC/RTCUtils.spec.js

@@ -1,252 +0,0 @@
-import browser from '../browser';
-
-import RTCUtils from './RTCUtils';
-import screenObtainer from './ScreenObtainer';
-
-// TODO move webrtc mocks/polyfills into a easily accessible file when needed
-/**
- * A constructor to create a mock for the native MediaStreamTrack.
- */
-function MediaStreamTrackMock(kind, options = {}) {
-    this.kind = kind;
-    this._settings = {};
-
-    if (options.resolution) {
-        this._settings.height = options.resolution;
-    }
-}
-
-MediaStreamTrackMock.prototype.getSettings = function() {
-    return this._settings;
-};
-
-MediaStreamTrackMock.prototype.stop
-    = function() { /** intentionally blank **/ };
-
-/**
- * A constructor to create a mock for the native MediaStream.
- */
-function MediaStreamMock() {
-    this.id = Date.now();
-    this._audioTracks = [];
-    this._videoTracks = [];
-}
-
-MediaStreamMock.prototype.addTrack = function(track) {
-    if (track.kind === 'audio') {
-        this._audioTracks.push(track);
-    } else if (track.kind === 'video') {
-        this._videoTracks.push(track);
-    }
-};
-
-MediaStreamMock.prototype.getAudioTracks = function() {
-    return this._audioTracks;
-};
-
-MediaStreamMock.prototype.getTracks = function() {
-    return [
-        ...this._audioTracks,
-        ...this._videoTracks
-    ];
-};
-
-MediaStreamMock.prototype.getVideoTracks = function() {
-    return this._videoTracks;
-};
-
-/* eslint-disable max-params */
-/**
- * A mock function to be used for stubbing out the wrapper around getUserMedia.
- *
- * @param {String[]} devices - The media devices to obtain. Valid devices are
- * 'audio', 'video', and 'desktop'.
- * @param {Function} onSuccess - An optional success callback to trigger.
- * @param {Function} onError - An optional error callback to trigger. This is
- * not used in this function.
- * @param {Object} options - An object describing the constraints to pass to
- * gum.
- * @private
- * @returns {Promise} A resolved promise with a MediaStreamMock.
- */
-function successfulGum(devices, options) {
-    /* eslint-enable max-params */
-
-    const mediaStreamMock = new MediaStreamMock();
-
-    if (devices.includes('audio')) {
-        mediaStreamMock.addTrack(new MediaStreamTrackMock('audio', options));
-    }
-
-    if (devices.includes('video')) {
-        mediaStreamMock.addTrack(new MediaStreamTrackMock('video', options));
-    }
-
-    if (devices.includes('desktop')) {
-        mediaStreamMock.addTrack(new MediaStreamTrackMock('video', options));
-    }
-
-    return Promise.resolve(mediaStreamMock);
-}
-
-/**
- * General error handling for a promise chain that threw an unexpected error.
- *
- * @param {Error} error - The error object describing what error occurred.
- * @param {function} done - Jasmine's done function to trigger a failed test.
- * @private
- * @returns {void}
- */
-function unexpectedErrorHandler(error = {}, done) {
-    done.fail(`unexpected error occurred: ${error.message}`);
-}
-
-describe('RTCUtils', () => {
-    describe('obtainAudioAndVideoPermissions', () => {
-        let getUserMediaSpy, isScreenSupportedSpy, oldMediaStream,
-            oldMediaStreamTrack, oldWebkitMediaStream;
-
-        beforeEach(() => {
-            // FIXME: To get some kind of initial testing working assume a
-            // chrome environment so RTCUtils can actually initialize properly.
-            spyOn(browser, 'isChrome').and.returnValue(true);
-            spyOn(screenObtainer, '_createObtainStreamMethod')
-                .and.returnValue(() => { /** intentional no op */ });
-            isScreenSupportedSpy = spyOn(screenObtainer, 'isSupported')
-                .and.returnValue(true);
-
-            oldMediaStreamTrack = window.MediaStreamTrack;
-            window.MediaStreamTrack = MediaStreamTrackMock;
-
-            oldMediaStream = window.MediaStream;
-            window.MediaStream = MediaStreamMock;
-
-            oldWebkitMediaStream = window.webkitMediaStream;
-            window.webkitMediaStream = MediaStreamMock;
-            RTCUtils.init();
-
-            getUserMediaSpy = spyOn(RTCUtils, 'getUserMediaWithConstraints');
-        });
-
-        afterEach(() => {
-            window.MediaStreamTrack = oldMediaStreamTrack;
-            window.MediaStream = oldMediaStream;
-            window.webkitMediaStream = oldWebkitMediaStream;
-        });
-
-        it('gets audio and video by default', done => {
-            getUserMediaSpy.and.callFake(successfulGum);
-
-            RTCUtils.obtainAudioAndVideoPermissions()
-                .then(streams => {
-                    expect(streams.length).toBe(2);
-
-                    const audioStream = streams.find(stream =>
-                        stream.mediaType === 'audio');
-
-                    expect(audioStream).toBeTruthy();
-                    expect(audioStream.stream instanceof MediaStreamMock)
-                        .toBe(true);
-                    expect(audioStream.stream.getAudioTracks().length).toBe(1);
-
-                    const videoStream = streams.find(stream =>
-                        stream.mediaType === 'video');
-
-                    expect(videoStream).toBeTruthy();
-                    expect(videoStream.stream instanceof MediaStreamMock)
-                        .toBe(true);
-                    expect(videoStream.stream.getVideoTracks().length).toBe(1);
-
-                    done();
-                })
-                .catch(error => unexpectedErrorHandler(error, done));
-        });
-
-        it('can get an audio track', done => {
-            getUserMediaSpy.and.callFake(successfulGum);
-
-            RTCUtils.obtainAudioAndVideoPermissions({ devices: [ 'audio' ] })
-                .then(streams => {
-                    expect(streams.length).toBe(1);
-
-                    expect(streams[0].stream instanceof MediaStreamMock)
-                        .toBe(true);
-                    expect(streams[0].stream.getAudioTracks().length).toBe(1);
-
-                    done();
-                })
-                .catch(error => unexpectedErrorHandler(error, done));
-
-        });
-
-        it('can get a video track', done => {
-            getUserMediaSpy.and.callFake(successfulGum);
-
-            RTCUtils.obtainAudioAndVideoPermissions({ devices: [ 'video' ] })
-                .then(streams => {
-                    expect(streams.length).toBe(1);
-
-                    expect(streams[0].stream instanceof MediaStreamMock)
-                        .toBe(true);
-                    expect(streams[0].stream.getVideoTracks().length).toBe(1);
-
-                    done();
-                })
-                .catch(error => unexpectedErrorHandler(error, done));
-        });
-
-        it('gets 720 videor resolution by default', done => {
-            getUserMediaSpy.and.callFake(successfulGum);
-
-            RTCUtils.obtainAudioAndVideoPermissions({ devices: [ 'video' ] })
-                .then(streams => {
-                    const videoTrack = streams[0].stream.getVideoTracks()[0];
-                    const { height } = videoTrack.getSettings();
-
-                    expect(height).toBe(720);
-
-                    done();
-                })
-                .catch(error => unexpectedErrorHandler(error, done));
-        });
-
-        describe('requesting desktop', () => {
-            it('errors if desktop is not supported', done => {
-                isScreenSupportedSpy.and.returnValue(false);
-
-                RTCUtils.obtainAudioAndVideoPermissions({
-                    devices: [ 'desktop' ] })
-                    .then(() => done.fail(
-                        'obtainAudioAndVideoPermissions should not succeed'))
-                    .catch(error => {
-                        expect(error.message)
-                            .toBe('Desktop sharing is not supported!');
-
-                        done();
-                    });
-            });
-
-            it('can obtain a desktop stream', done => {
-                spyOn(screenObtainer, 'obtainStream')
-                    .and.callFake((options, success) => {
-                        const mediaStreamMock = new MediaStreamMock();
-
-                        mediaStreamMock.addTrack(
-                            new MediaStreamTrackMock('video', options));
-
-                        success({ stream: mediaStreamMock });
-                    });
-
-                RTCUtils.obtainAudioAndVideoPermissions({
-                    devices: [ 'desktop' ] })
-                    .then(streams => {
-                        expect(streams.length).toBe(1);
-                        expect(streams[0].videoType).toBe('desktop');
-
-                        done();
-                    })
-                    .catch(error => unexpectedErrorHandler(error, done));
-            });
-        });
-    });
-});

modules/RTC/ScreenObtainer.js

@@ -5,7 +5,10 @@ import browser from '../browser';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
-let gumFunction = null;
+/**
+ * The default frame rate for Screen Sharing.
+ */
+export const SS_DEFAULT_FRAME_RATE = 5;
 
 /**
  * Handles obtaining a stream from a screen capture on different browsers.
@@ -25,12 +28,9 @@ const ScreenObtainer = {
      * (this.obtainStream).
      *
      * @param {object} options
-     * @param {Function} gum GUM method
      */
-    init(options = {}, gum) {
+    init(options = {}) {
         this.options = options;
-        gumFunction = gum;
-
         this.obtainStream = this._createObtainStreamMethod();
 
         if (!this.obtainStream) {
@@ -47,7 +47,7 @@ const ScreenObtainer = {
      */
     _createObtainStreamMethod() {
         if (browser.isNWJS()) {
-            return (_, onSuccess, onFailure) => {
+            return (onSuccess, onFailure) => {
                 window.JitsiMeetNW.obtainDesktopStream(
                     onSuccess,
                     (error, constraints) => {
@@ -93,6 +93,23 @@ const ScreenObtainer = {
         return null;
     },
 
+    /**
+     * Gets the appropriate constraints for audio sharing.
+     *
+     * @returns {Object|boolean}
+     */
+    _getAudioConstraints() {
+        const { audioQuality } = this.options;
+        const audio = audioQuality?.stereo ? {
+            autoGainControl: false,
+            channelCount: 2,
+            echoCancellation: false,
+            noiseSuppression: false
+        } : true;
+
+        return audio;
+    },
+
     /**
      * Checks whether obtaining a screen capture is supported in the current
      * environment.
@@ -105,43 +122,76 @@ const ScreenObtainer = {
     /**
      * Obtains a screen capture stream on Electron.
      *
-     * @param {Object} [options] - Screen sharing options.
-     * @param {Array<string>} [options.desktopSharingSources] - Array with the
-     * sources that have to be displayed in the desktop picker window ('screen',
-     * 'window', etc.).
      * @param onSuccess - Success callback.
      * @param onFailure - Failure callback.
      */
-    obtainScreenOnElectron(options = {}, onSuccess, onFailure) {
-        if (window.JitsiMeetScreenObtainer
-            && window.JitsiMeetScreenObtainer.openDesktopPicker) {
-            const { desktopSharingSources, gumOptions } = options;
+    obtainScreenOnElectron(onSuccess, onFailure) {
+        if (window.JitsiMeetScreenObtainer && window.JitsiMeetScreenObtainer.openDesktopPicker) {
+            const { desktopSharingFrameRate, desktopSharingSources } = this.options;
 
             window.JitsiMeetScreenObtainer.openDesktopPicker(
                 {
                     desktopSharingSources: desktopSharingSources || [ 'screen', 'window' ]
                 },
-                (streamId, streamType, screenShareAudio = false) =>
-                    onGetStreamResponse(
-                        {
-                            response: {
-                                streamId,
-                                streamType,
-                                screenShareAudio
-                            },
-                            gumOptions
-                        },
-                        onSuccess,
-                        onFailure
-                    ),
+                (streamId, streamType, screenShareAudio = false) => {
+                    if (streamId) {
+                        let audioConstraints = false;
+
+                        if (screenShareAudio) {
+                            audioConstraints = {
+                                optional: {
+                                    ...this._getAudioConstraints()
+                                }
+                            };
+
+                            // Audio screen sharing for electron only works for screen type devices.
+                            // i.e. when the user shares the whole desktop.
+                            // Note. The documentation specifies that chromeMediaSourceId should not be present
+                            // which, in the case a users has multiple monitors, leads to them being shared all
+                            // at once. However we tested with chromeMediaSourceId present and it seems to be
+                            // working properly.
+                            if (streamType === 'screen') {
+                                audioConstraints.mandatory = {
+                                    chromeMediaSource: 'desktop'
+                                };
+                            }
+                        }
+
+                        const constraints = {
+                            audio: audioConstraints,
+                            video: {
+                                mandatory: {
+                                    chromeMediaSource: 'desktop',
+                                    chromeMediaSourceId: streamId,
+                                    minFrameRate: desktopSharingFrameRate?.min ?? SS_DEFAULT_FRAME_RATE,
+                                    maxFrameRate: desktopSharingFrameRate?.max ?? SS_DEFAULT_FRAME_RATE,
+                                    maxWidth: window.screen.width,
+                                    maxHeight: window.screen.height
+                                }
+                            }
+                        };
+
+                        // We have to use the old API on Electron to get a desktop stream.
+                        navigator.mediaDevices.getUserMedia(constraints)
+                            .then(stream => onSuccess({
+                                stream,
+                                sourceId: streamId,
+                                sourceType: streamType
+                            }), onFailure);
+                    } else {
+                        // As noted in Chrome Desktop Capture API:
+                        // If user didn't select any source (i.e. canceled the prompt)
+                        // then the callback is called with an empty streamId.
+                        onFailure(new JitsiTrackError(JitsiTrackErrors.SCREENSHARING_USER_CANCELED));
+                    }
+                },
                 err => onFailure(new JitsiTrackError(
                     JitsiTrackErrors.ELECTRON_DESKTOP_PICKER_ERROR,
                     err
                 ))
             );
         } else {
-            onFailure(new JitsiTrackError(
-                JitsiTrackErrors.ELECTRON_DESKTOP_PICKER_NOT_FOUND));
+            onFailure(new JitsiTrackError(JitsiTrackErrors.ELECTRON_DESKTOP_PICKER_NOT_FOUND));
         }
     },
 
@@ -151,7 +201,7 @@ const ScreenObtainer = {
      * @param callback - The success callback.
      * @param errorCallback - The error callback.
      */
-    obtainScreenFromGetDisplayMedia(options, callback, errorCallback) {
+    obtainScreenFromGetDisplayMedia(callback, errorCallback) {
         let getDisplayMedia;
 
         if (navigator.getDisplayMedia) {
@@ -161,15 +211,9 @@ const ScreenObtainer = {
             getDisplayMedia = navigator.mediaDevices.getDisplayMedia.bind(navigator.mediaDevices);
         }
 
-        const { audioQuality } = this.options;
-        const audio = audioQuality?.stereo ? {
-            autoGainControl: false,
-            channelCount: 2,
-            echoCancellation: false,
-            noiseSuppression: false
-        } : true;
-
-        const video = Object.keys(options.gumOptions).length > 0 ? options.gumOptions : true;
+        const { desktopSharingFrameRate } = this.options;
+        const video = typeof desktopSharingFrameRate === 'object' ? { frameRate: desktopSharingFrameRate } : true;
+        const audio = this._getAudioConstraints();
 
         // At the time of this writing 'min' constraint for fps is not supported by getDisplayMedia.
         video.frameRate && delete video.frameRate.min;
@@ -216,7 +260,7 @@ const ScreenObtainer = {
      * @param callback - The success callback.
      * @param errorCallback - The error callback.
      */
-    obtainScreenFromGetDisplayMediaRN(options, callback, errorCallback) {
+    obtainScreenFromGetDisplayMediaRN(callback, errorCallback) {
         logger.info('Using getDisplayMedia for screen sharing');
 
         navigator.mediaDevices.getDisplayMedia({ video: true })
@@ -232,58 +276,4 @@ const ScreenObtainer = {
     }
 };
 
-/**
- * Handles response from external application / extension and calls GUM to
- * receive the desktop streams or reports error.
- * @param {object} options
- * @param {object} options.response
- * @param {string} options.response.streamId - the streamId for the desktop
- * stream.
- * @param {bool}   options.response.screenShareAudio - Used by electron clients to
- * enable system audio screen sharing.
- * @param {string} options.response.error - error to be reported.
- * @param {object} options.gumOptions - options passed to GUM.
- * @param {Function} onSuccess - callback for success.
- * @param {Function} onFailure - callback for failure.
- * @param {object} gumOptions - options passed to GUM.
- */
-function onGetStreamResponse(
-        options = {
-            response: {},
-            gumOptions: {}
-        },
-        onSuccess,
-        onFailure) {
-    const { streamId, streamType, screenShareAudio, error } = options.response || {};
-
-    if (streamId) {
-        const gumOptions = {
-            desktopStream: streamId,
-            screenShareAudio,
-            ...options.gumOptions
-        };
-
-        gumFunction([ 'desktop' ], gumOptions)
-            .then(stream => onSuccess({
-                stream,
-                sourceId: streamId,
-                sourceType: streamType
-            }), onFailure);
-    } else {
-        // As noted in Chrome Desktop Capture API:
-        // If user didn't select any source (i.e. canceled the prompt)
-        // then the callback is called with an empty streamId.
-        if (streamId === '') {
-            onFailure(new JitsiTrackError(
-                JitsiTrackErrors.SCREENSHARING_USER_CANCELED));
-
-            return;
-        }
-
-        onFailure(new JitsiTrackError(
-            JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR,
-            error));
-    }
-}
-
 export default ScreenObtainer;

modules/browser/BrowserCapabilities.js

@@ -239,29 +239,12 @@ export default class BrowserCapabilities extends BrowserDetection {
     }
 
     /**
-     * Returns whether or not the current browser should be using the new
-     * getUserMedia flow, which utilizes the adapter shim. This method should
-     * be temporary and used while migrating all browsers to use adapter and
-     * the new getUserMedia.
-     *
-     * @returns {boolean}
-     */
-    usesNewGumFlow() {
-        if (this.isChromiumBased() || this.isFirefox() || this.isWebKitBased()) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Checks if the browser uses webrtc-adapter. All browsers using the new
-     * getUserMedia flow.
+     * Checks if the browser uses webrtc-adapter. All browsers except React Native do.
      *
      * @returns {boolean}
      */
     usesAdapter() {
-        return this.usesNewGumFlow();
+        return !this.isReactNative();
     }
 
     /**

modules/proxyconnection/ProxyConnectionService.js

@@ -276,7 +276,7 @@ export default class ProxyConnectionService {
         // Grab the webrtc media stream and pipe it through the same processing
         // that would occur for a locally obtained media stream.
         const mediaStream = jitsiRemoteTrack.getOriginalStream();
-        const jitsiLocalTracks = RTC.newCreateLocalTracks(
+        const jitsiLocalTracks = RTC.createLocalTracks(
             [
                 {
                     deviceId:

modules/xmpp/JingleSessionPC.js

@@ -9,7 +9,7 @@ import {
     ICE_STATE_CHANGED
 } from '../../service/statistics/AnalyticsEvents';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
-import { SS_DEFAULT_FRAME_RATE } from '../RTC/RTCUtils';
+import { SS_DEFAULT_FRAME_RATE } from '../RTC/ScreenObtainer';
 import SDP from '../sdp/SDP';
 import SDPDiffer from '../sdp/SDPDiffer';
 import SDPUtil from '../sdp/SDPUtil';

service/RTC/Resolutions.js

@@ -1,67 +1,55 @@
 const Resolutions = {
+    '2160': {
+        width: 3840,
+        height: 2160
+    },
+    '4k': {
+        width: 3840,
+        height: 2160
+    },
     '1080': {
         width: 1920,
-        height: 1080,
-        order: 8
+        height: 1080
     },
     'fullhd': {
         width: 1920,
-        height: 1080,
-        order: 8
+        height: 1080
     },
     '720': {
         width: 1280,
-        height: 720,
-        order: 7
+        height: 720
     },
     'hd': {
         width: 1280,
-        height: 720,
-        order: 7
-    },
-    '960': {
-        width: 960,
-        height: 720,
-        order: 6
+        height: 720
     },
     '540': {
         width: 960,
-        height: 540,
-        order: 5
+        height: 540
     },
     'qhd': {
         width: 960,
-        height: 540,
-        order: 5
+        height: 540
     },
-
-    // 16:9 resolution first.
-    '360': {
+    '480': {
         width: 640,
-        height: 360,
-        order: 4
+        height: 480
     },
-    '640': {
+    'vga': {
         width: 640,
-        height: 480,
-        order: 3
+        height: 480
     },
-    'vga': {
+    '360': {
         width: 640,
-        height: 480,
-        order: 3
+        height: 360
     },
-
-    // 16:9 resolution first.
-    '180': {
+    '240': {
         width: 320,
-        height: 180,
-        order: 2
+        height: 240
     },
-    '320': {
+    '180': {
         width: 320,
-        height: 240,
-        order: 1
+        height: 180
     }
 };