ref(gum): try to reduce complexity of obtainAudioAndVideoPermissions (#707)

* ref(gum): try to reduce complexity of obtainAudioAndVideoPermissions

Even though I walk through the valley of the shadow of death
I will fear no evil... Reduce indenting and repeated calls to
getting desktop streams by creating a promise chain.

* squash: use arrow func

* squash: move constructor support to helper

* squash: put ff into mediastream constructor check

* squash: ff support media stream constructor

MDN states its been supported since 44. ESR is currently
52.

* squash: rename dsoptions, constant defaults

* squash: move comment about missing tracks error handling

* squash: wrap getUserMediaWithConstraints in promise

* squash: split up av funcs

* squash: hey, some tests...are better than no tests?

modules/RTC/RTCUtils.js

@@ -46,6 +46,36 @@ 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.
+ *
+ * @private
+ */
+const DEFAULT_CONSTRAINTS = {
+    video: {
+        aspectRatio: 16 / 9,
+        height: {
+            ideal: 1080,
+            max: 1080,
+            min: 240
+        }
+    }
+};
+
+
 // TODO (brian): Move this devices hash, maybe to a model, so RTCUtils remains
 // stateless.
 const devices = {
@@ -353,22 +383,6 @@ function getConstraints(um, options) {
     return constraints;
 }
 
-/**
- * Default MediaStreamConstraints to use for calls to getUserMedia.
- *
- * @private
- */
-const DEFAULT_CONSTRAINTS = {
-    video: {
-        aspectRatio: 16 / 9,
-        height: {
-            ideal: 1080,
-            max: 1080,
-            min: 240
-        }
-    }
-};
-
 /**
  * Creates a constraints object to be passed into a call to getUserMedia.
  *
@@ -1158,6 +1172,8 @@ class RTCUtils extends Listenable {
     * @param {string} options.desktopStream
     * @param {string} options.cameraDeviceId
     * @param {string} options.micDeviceId
+    * @returns {Promise} Returns a media stream on success or a JitsiTrackError
+    * on failure.
     **/
     getUserMediaWithConstraints(
             um,
@@ -1168,31 +1184,46 @@ class RTCUtils extends Listenable {
 
         logger.info('Get media constraints', constraints);
 
-        try {
-            this.getUserMedia(
-                constraints,
-                stream => {
-                    logger.log('onUserMediaSuccess');
-                    setAvailableDevices(um, stream);
-                    successCallback(stream);
-                },
-                error => {
-                    setAvailableDevices(um, undefined);
-                    logger.warn('Failed to get access to local media. Error ',
-                        error, constraints);
+        return new Promise((resolve, reject) => {
+            try {
+                this.getUserMedia(
+                    constraints,
+                    stream => {
+                        logger.log('onUserMediaSuccess');
+                        setAvailableDevices(um, stream);
 
-                    if (failureCallback) {
-                        failureCallback(
-                            new JitsiTrackError(error, constraints, um));
-                    }
-                });
-        } catch (e) {
-            logger.error('GUM failed: ', e);
+                        if (successCallback) {
+                            successCallback(stream);
+                        }
+
+                        resolve(stream);
+                    },
+                    error => {
+                        setAvailableDevices(um, undefined);
+                        logger.warn(
+                            'Failed to get access to local media. Error ',
+                            error, constraints);
+                        const jitsiTrackError
+                            = new JitsiTrackError(error, constraints, um);
+
+                        if (failureCallback) {
+                            failureCallback(jitsiTrackError);
+                        }
+
+                        reject(jitsiTrackError);
+                    });
+            } catch (e) {
+                logger.error('GUM failed: ', e);
+                const jitsiTrackError
+                    = new JitsiTrackError(e, constraints, um);
 
-            if (failureCallback) {
-                failureCallback(new JitsiTrackError(e, constraints, um));
+                if (failureCallback) {
+                    failureCallback(jitsiTrackError);
+                }
+
+                reject(jitsiTrackError);
             }
-        }
+        });
     }
 
     /**
@@ -1287,169 +1318,175 @@ class RTCUtils extends Listenable {
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
     obtainAudioAndVideoPermissions(options = {}) {
-        const self = this;
+        options.devices = options.devices || [ ...OLD_GUM_DEFAULT_DEVICES ];
+        options.resolution = options.resolution || OLD_GUM_DEFAULT_RESOLUTION;
 
-        const dsOptions = {
-            ...options.desktopSharingExtensionExternalInstallation,
-            desktopSharingSources: options.desktopSharingSources
-        };
+        const requestingDesktop = options.devices.includes('desktop');
 
-        return new Promise((resolve, reject) => {
-            const successCallback = function(stream) {
-                resolve(handleLocalStream(stream, options.resolution));
-            };
+        if (requestingDesktop && !screenObtainer.isSupported()) {
+            return Promise.reject(
+                new Error('Desktop sharing is not supported!'));
+        }
 
-            options.devices = options.devices || [ 'audio', 'video' ];
-            options.resolution = options.resolution || '720';
+        let gumPromise;
 
-            if (!screenObtainer.isSupported()
-                && options.devices.indexOf('desktop') !== -1) {
-                reject(new Error('Desktop sharing is not supported!'));
-            }
-            if (browser.isFirefox()
-
-                    // XXX The react-native-webrtc implementation that we
-                    // utilize on React Native at the time of this writing does
-                    // not support the MediaStream constructors defined by
-                    // https://www.w3.org/TR/mediacapture-streams/#constructors
-                    // and instead has a single constructor which expects (an
-                    // NSNumber as) a MediaStream ID.
-                    || browser.isReactNative()
-                    || browser.isTemasysPluginUsed()) {
-                const GUM = function(device, s, e) {
-                    this.getUserMediaWithConstraints(device, s, e, options);
-                };
+        if (browser.supportsMediaStreamConstructor()) {
+            gumPromise = this._getAudioAndVideoStreams(options);
+        } else {
+            // If the MediaStream constructor is not supported, then get tracks
+            // in separate GUM calls in order to keep different tracks separate.
+            gumPromise = this._getAudioAndVideoStreamsSeparately(options);
+        }
 
-                const deviceGUM = {
-                    'audio': GUM.bind(self, [ 'audio' ]),
-                    'video': GUM.bind(self, [ 'video' ])
-                };
+        return gumPromise.then(streams =>
+            handleLocalStream(streams, options.resolution));
+    }
 
-                if (screenObtainer.isSupported()) {
-                    deviceGUM.desktop = screenObtainer.obtainStream.bind(
-                        screenObtainer,
-                        dsOptions);
+    /**
+     * 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, null, null, 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)));
                 }
 
-                // With FF/IE we can't split the stream into audio and video
-                // because FF doesn't support media stream constructors. So, we
-                // need to get the audio stream separately from the video stream
-                // using two distinct GUM calls. Not very user friendly :-( but
-                // we don't have many other options neither.
-                //
-                // Note that we pack those 2 streams in a single object and pass
-                // it to the successCallback method.
-                obtainDevices({
-                    devices: options.devices,
-                    streams: [],
-                    successCallback,
-                    errorCallback: reject,
-                    deviceGUM
+                return avStream;
+            })
+            .then(audioVideo => {
+                if (!requestingDesktop) {
+                    return { audioVideo };
+                }
+
+                return new Promise((resolve, reject) => {
+                    screenObtainer.obtainStream(
+                        this._parseDesktopSharingOptions(options),
+                        desktop => resolve({
+                            audioVideo,
+                            desktop
+                        }),
+                        error => {
+                            if (audioVideo) {
+                                this.stopMediaStream(audioVideo);
+                            }
+                            reject(error);
+                        });
                 });
-            } else {
-                const hasDesktop = options.devices.indexOf('desktop') > -1;
+            });
+    }
 
-                if (hasDesktop) {
-                    options.devices.splice(
-                        options.devices.indexOf('desktop'),
-                        1);
-                }
+    /**
+     * Private utility for determining if the passed in MediaStream contains
+     * tracks of the type(s) specified in the requested devices.
+     *
+     * @param {string[]} requestedDevices - The track types that are expected to
+     * be includes in the stream.
+     * @param {MediaStream} stream - The MediaStream to check if it has the
+     * expected track types.
+     * @returns {string[]} An array of string with the missing track types. The
+     * array will be empty if all requestedDevices are found in the stream.
+     */
+    _getMissingTracks(requestedDevices = [], stream) {
+        const missingDevices = [];
 
-                if (options.devices.length) {
-                    this.getUserMediaWithConstraints(
-                        options.devices,
-                        stream => {
-                            const audioDeviceRequested
-                                = options.devices.indexOf('audio') !== -1;
-                            const videoDeviceRequested
-                                = options.devices.indexOf('video') !== -1;
-                            const audioTracksReceived
-                                = stream.getAudioTracks().length > 0;
-                            const videoTracksReceived
-                                = stream.getVideoTracks().length > 0;
-
-                            if ((audioDeviceRequested && !audioTracksReceived)
-                                    || (videoDeviceRequested
-                                        && !videoTracksReceived)) {
-                                self.stopMediaStream(stream);
-
-                                // We are getting here in case if we requested
-                                // 'audio' or 'video' devices or both, but
-                                // didn't get corresponding MediaStreamTrack in
-                                // response stream. We don't know the reason why
-                                // this happened, so reject with general error.
-                                // eslint-disable-next-line no-shadow
-                                const devices = [];
-
-                                if (audioDeviceRequested
-                                        && !audioTracksReceived) {
-                                    devices.push('audio');
-                                }
+        const audioDeviceRequested = requestedDevices.includes('audio');
+        const audioTracksReceived
+            = stream && stream.getAudioTracks().length > 0;
 
-                                if (videoDeviceRequested
-                                        && !videoTracksReceived) {
-                                    devices.push('video');
-                                }
+        if (audioDeviceRequested && !audioTracksReceived) {
+            missingDevices.push('audio');
+        }
 
-                                // we are missing one of the media we requested
-                                // in order to get the actual error that caused
-                                // this missing media we will call one more time
-                                // getUserMedia so we can obtain the actual
-                                // error (Example usecases are requesting
-                                // audio and video and video device is missing
-                                // or device is denied to be used and chrome is
-                                // set to not ask for permissions)
-                                self.getUserMediaWithConstraints(
-                                    devices,
-                                    () => {
-                                        // we already failed to obtain this
-                                        // media, so we are not supposed in any
-                                        // way to receive success for this call
-                                        // any way we will throw an error to be
-                                        // sure the promise will finish
-                                        reject(new JitsiTrackError(
-                                            { name: 'UnknownError' },
-                                            getConstraints(
-                                                options.devices,
-                                                options),
-                                            devices)
-                                        );
-                                    },
-                                    error => {
-                                        // rejects with real error for not
-                                        // obtaining the media
-                                        reject(error);
-                                    }, options);
-
-                                return;
-                            }
-                            if (hasDesktop) {
-                                screenObtainer.obtainStream(
-                                    dsOptions,
-                                    desktop => {
-                                        successCallback({ audioVideo: stream,
-                                            desktop });
-                                    }, error => {
-                                        self.stopMediaStream(stream);
-
-                                        reject(error);
-                                    });
-                            } else {
-                                successCallback({ audioVideo: stream });
-                            }
-                        },
-                        error => reject(error),
-                        options);
-                } else if (hasDesktop) {
+        const videoDeviceRequested = requestedDevices.includes('video');
+        const videoTracksReceived
+            = stream && stream.getVideoTracks().length > 0;
+
+        if (videoDeviceRequested && !videoTracksReceived) {
+            missingDevices.push('video');
+        }
+
+        return missingDevices;
+    }
+
+    /**
+     * Performs separate getUserMedia calls for audio and video instead of in
+     * one call. Will also request desktop if specified.
+     *
+     * @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.
+     */
+    _getAudioAndVideoStreamsSeparately(options) {
+        return new Promise((resolve, reject) => {
+            const deviceGUM = {
+                audio: (...args) =>
+                    this.getUserMediaWithConstraints([ 'audio' ], ...args),
+                video: (...args) =>
+                    this.getUserMediaWithConstraints([ 'video' ], ...args),
+                desktop: (...args) =>
                     screenObtainer.obtainStream(
-                        dsOptions,
-                        desktop => successCallback({ desktop }),
-                        error => reject(error));
-                }
-            }
+                        this._parseDesktopSharingOptions(options), ...args)
+            };
+
+            obtainDevices({
+                devices: options.devices,
+                streams: [],
+                successCallback: resolve,
+                errorCallback: reject,
+                deviceGUM
+            });
         });
     }
 
+    /**
+     * 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 {
+            ...options.desktopSharingExtensionExternalInstallation,
+            desktopSharingSources: options.desktopSharingSources
+        };
+    }
+
     /**
      * Gets streams from specified device types. This function intentionally
      * ignores errors for upstream to catch and handle instead.

modules/RTC/RTCUtils.spec.js

@@ -0,0 +1,286 @@
+import RTCUtils from './RTCUtils';
+import browser from '../browser';
+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, onSuccess, onError, 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));
+    }
+
+    if (onSuccess) {
+        onSuccess(mediaStreamMock);
+    }
+
+    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,
+            supportsMediaConstructorSpy;
+
+        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);
+            supportsMediaConstructorSpy
+                = spyOn(browser, 'supportsMediaStreamConstructor')
+                    .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));
+            });
+        });
+
+        describe('without MediaStream constructor support', () => {
+            it('makes separate getUserMedia calls', done => {
+                supportsMediaConstructorSpy.and.returnValue(false);
+                getUserMediaSpy.and.callFake(successfulGum);
+
+                RTCUtils.obtainAudioAndVideoPermissions({
+                    devices: [ 'audio', 'video' ] })
+                    .then(streams => {
+                        expect(getUserMediaSpy.calls.count()).toBe(2);
+                        expect(streams.length).toBe(2);
+
+                        const audioStream = streams.find(stream =>
+                            stream.mediaType === 'audio');
+
+                        expect(audioStream).toBeTruthy();
+
+                        const videoStream = streams.find(stream =>
+                            stream.mediaType === 'video');
+
+                        expect(videoStream).toBeTruthy();
+
+                        done();
+                    })
+                    .catch(error => unexpectedErrorHandler(error, done));
+            });
+        });
+    });
+});

modules/browser/BrowserCapabilities.js

@@ -103,6 +103,19 @@ export default class BrowserCapabilities extends BrowserDetection {
         return !this.isEdge();
     }
 
+
+    /**
+     * Checks if the current browser supports the MediaStream constructor as
+     * defined by https://www.w3.org/TR/mediacapture-streams/#constructors. In
+     * cases where there is no support, it maybe be necessary to get audio
+     * and video in two distinct GUM calls.
+     * @return {boolean}
+     */
+    supportsMediaStreamConstructor() {
+        return !this.isReactNative()
+            && !this.isTemasysPluginUsed();
+    }
+
     /**
      * Checks if the current browser reports round trip time statistics for
      * the ICE candidate pair.