feat(browser_caps): Implement browser capabilities API. (#690)

In order to include browser capabilities in RTCBrowserType I needed to
refactor RTCBrowserType.

.eslintignore

 lib-jitsi-meet.js.map
 lib-jitsi-meet.min.js
 lib-jitsi-meet.min.map
+browser_capabilities.js
+browser_capabilities.js.map
+browser_capabilities.min.js
+browser_capabilities.min.map
 
 # Third-party source code which we (1) do not want to modify or (2) try to
 # modify as little as possible.

.gitignore

 .idea/
 *.iml
 .*.tmp
+browser_capabilities.*
 deploy-local.sh
 .remote-sync.json
 lib-jitsi-meet.*

JitsiConference.js

     from './modules/connectivity/ParticipantConnectionStatus';
 import P2PDominantSpeakerDetection from './modules/P2PDominantSpeakerDetection';
 import RTC from './modules/RTC/RTC';
-import RTCBrowserType from './modules/RTC/RTCBrowserType';
+import browser from './modules/browser';
 import * as RTCEvents from './service/RTC/RTCEvents';
 import Statistics from './modules/statistics/statistics';
 import TalkMutedDetection from './modules/TalkMutedDetection';
             errorMsg: 'Rejecting session-initiate from non-focus and'
                         + `non-moderator user: ${jingleSession.remoteJid}`
         };
-    } else if (!RTCBrowserType.isP2PSupported()) {
+    } else if (!browser.supportsP2P()) {
         rejectReason = {
             reason: 'unsupported-applications',
             reasonDescription: 'P2P not supported',
     }
 
     if (bridgeChannelType === 'datachannel'
-        && !RTCBrowserType.supportsDataChannels()) {
+        && !browser.supportsDataChannels()) {
         bridgeChannelType = 'websocket';
     }
 
  * @private
  */
 JitsiConference.prototype._maybeStartOrStopP2P = function(userLeftEvent) {
-    if (!RTCBrowserType.isP2PSupported()
+    if (!browser.supportsP2P()
         || !this.isP2PEnabled()
         || this.isP2PTestModeEnabled()) {
         logger.info('Auto P2P disabled');

JitsiMediaDevices.js

 import EventEmitter from 'events';
-import * as JitsiMediaDevicesEvents from './JitsiMediaDevicesEvents';
+
 import * as MediaType from './service/RTC/MediaType';
+import browser from './modules/browser';
 import RTC from './modules/RTC/RTC';
-import RTCBrowserType from './modules/RTC/RTCBrowserType';
 import RTCEvents from './service/RTC/RTCEvents';
 import Statistics from './modules/statistics/statistics';
 
+import * as JitsiMediaDevicesEvents from './JitsiMediaDevicesEvents';
+
 const eventEmitter = new EventEmitter();
 
 /**
      * @returns {boolean}
      */
     isMultipleAudioInputSupported() {
-        return !RTCBrowserType.isFirefox();
+        return !browser.isFirefox();
     },
 
     /**
      * @returns {boolean}
      */
     supportsVideo() {
-        // Defer to RTCBrowserType to allow exposure of the api to the consumer
-        // but prevent other files from having to import JitsiMediaDevices.
-        return RTCBrowserType.supportsVideo();
+        // Defer to the browser capabilities to allow exposure of the api to the
+        // consumer but prevent other files from having to import
+        // JitsiMediaDevices.
+        return browser.supportsVideo();
     }
 };
 

JitsiMeetJS.js

 import { ParticipantConnectionStatus }
     from './modules/connectivity/ParticipantConnectionStatus';
 import RTC from './modules/RTC/RTC';
-import RTCBrowserType from './modules/RTC/RTCBrowserType';
+import browser from './modules/browser';
 import RTCUIHelper from './modules/RTC/RTCUIHelper';
 import ScriptUtil from './modules/util/ScriptUtil';
 import Statistics from './modules/statistics/statistics';
                 if (!promiseFulfilled) {
                     JitsiMediaDevices.emitEvent(
                         JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                        RTCBrowserType.getBrowserName());
+                        browser.getName());
                 }
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }
                 promiseFulfilled = true;
 
                 if (error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION
-                    && !RTCBrowserType.usesNewGumFlow()) {
+                    && !browser.usesNewGumFlow()) {
                     const oldResolution = options.resolution || '720';
                     const newResolution = getLowerResolution(oldResolution);
 
         AuthUtil,
         RTCUIHelper,
         ScriptUtil,
-        RTCBrowserType
+        browser
     }
 };

doc/browser-capabilities.md

+# Jitsi Meet browser capabilities
+
+An API for checking browser capabilities for Jitsi Meet.
+
+## Installation
+
+To use the Jitsi Meet browser capabilities API in your application you need to add a JS file with `BrowserCapabilities` implementation:
+
+```javascript
+<script src="https://example.com/libs/browser_capabilities.min.js"></script>
+```
+
+## API
+
+### Constructor
+
+* **isUsingIFrame**: `true` if Jitsi Meet is loaded in iframe and `false` otherwise. The default value is `false`.
+* **browserInfo**: Information about the browser which capabilities will be checked. If not specified `BrowserCapabilities` class will detect the current browser. `browserInfo` is JS object with the following properties:
+    * **name**: The name of the browser compatible with the names returned by [bowser](https://github.com/lancedikson/bowser#all-detected-browsers)
+    * **version**: The version of the browser compatible with the version returned by [bowser](https://github.com/lancedikson/bowser#all-detected-browsers)
+
+**Example:**
+```javascript
+const browserCapabilities = new BrowserCapabilities(); // not using iframe;  capabilities for the current browser
+const browserCapabilities1 = new BrowserCapabilities(true); // using iframe; capabilities for the current browser.
+const browserCapabilities1 = new BrowserCapabilities(true, {
+    name: 'Chrome',
+    version: '63.0'
+}); // using iframe; capabilities for Chrome 63.0
+```
+
+### Methods:
+
+* **isSupported** - returns `true` if the browser is supported by Jitsi Meet and `false` otherwise.
+
+* **supportsAudioIn** - returns `true` if the browser supports incoming audio and `false` otherwise.
+
+* **supportsAudioOut** - returns `true` if the browser supports outgoing audio and `false` otherwise.
+
+* **supportsVideoIn** - returns `true` if the browser is supports incoming video and `false` otherwise.
+
+* **supportsVideoOut** - returns `true` if the browser is supports outgoing video and `false` otherwise.
+
+* **supportsScreenSharing** - returns `true` if the browser is supports screen sharing and `false` otherwise.

modules/RTC/JitsiLocalTrack.js

     NO_DATA_FROM_SOURCE,
     TRACK_MUTE_CHANGED
 } from '../../JitsiTrackEvents';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 import RTCUtils from './RTCUtils';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
 import * as MediaType from '../../service/RTC/MediaType';
         this.sourceId = sourceId;
         this.sourceType = sourceType;
 
-        if (RTCBrowserType.usesNewGumFlow()) {
+        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;
             // 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 = RTCBrowserType.isFirefox() ? null : resolution;
+            this.resolution = browser.isFirefox() ? null : resolution;
         }
 
         this.deviceId = deviceId;
 
         if (this.isAudioTrack()
                 || this.videoType === VideoType.DESKTOP
-                || !RTCBrowserType.doesVideoMuteByStreamRemove()) {
+                || !browser.doesVideoMuteByStreamRemove()) {
             logMuteInfo();
             if (this.track) {
                 this.track.enabled = !muted;
                 facingMode: this.getCameraFacingMode()
             };
 
-            if (RTCBrowserType.usesNewGumFlow()) {
+            if (browser.usesNewGumFlow()) {
                 promise
                     = RTCUtils.newObtainAudioAndVideoPermissions(Object.assign(
                         {},
             promise.then(streamsInfo => {
                 const mediaType = this.getType();
                 const streamInfo
-                    = RTCBrowserType.usesNewGumFlow()
+                    = browser.usesNewGumFlow()
                         ? streamsInfo.find(
                             info => info.track.kind === mediaType)
                         : streamsInfo.find(

modules/RTC/JitsiRemoteTrack.js

 import { createTtfmEvent } from '../../service/statistics/AnalyticsEvents';
 import JitsiTrack from './JitsiTrack';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 import Statistics from '../statistics/statistics';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
             ttfmTrackerVideoAttached = true;
         }
 
-        if (RTCBrowserType.isTemasysPluginUsed()) {
+        if (browser.isTemasysPluginUsed()) {
             // XXX Don't require Temasys unless it's to be used because it
             // doesn't run on React Native, for example.
             const AdapterJS = require('./adapter.screenshare');

modules/RTC/RTC.js

 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 import Listenable from '../util/Listenable';
 import * as MediaType from '../../service/RTC/MediaType';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import RTCUtils from './RTCUtils';
 import Statistics from '../statistics/statistics';
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
     static obtainAudioAndVideoPermissions(options) {
-        const usesNewGumFlow = RTCBrowserType.usesNewGumFlow();
+        const usesNewGumFlow = browser.usesNewGumFlow();
         const obtainMediaPromise = usesNewGumFlow
             ? RTCUtils.newObtainAudioAndVideoPermissions(options)
             : RTCUtils.obtainAudioAndVideoPermissions(options);

modules/RTC/RTCBrowserType.js

-import { getLogger } from 'jitsi-meet-logger';
-
-let browserVersion; // eslint-disable-line prefer-const
-
-let currentBrowser;
-
-const logger = getLogger(__filename);
-
-const RTCBrowserType = {
-
-    RTC_BROWSER_CHROME: 'rtc_browser.chrome',
-
-    RTC_BROWSER_OPERA: 'rtc_browser.opera',
-
-    RTC_BROWSER_FIREFOX: 'rtc_browser.firefox',
-
-    RTC_BROWSER_IEXPLORER: 'rtc_browser.iexplorer',
-
-    RTC_BROWSER_EDGE: 'rtc_browser.edge',
-
-    RTC_BROWSER_SAFARI: 'rtc_browser.safari',
-
-    RTC_BROWSER_NWJS: 'rtc_browser.nwjs',
-
-    RTC_BROWSER_ELECTRON: 'rtc_browser.electron',
-
-    RTC_BROWSER_REACT_NATIVE: 'rtc_browser.react-native',
-
-    /**
-     * Tells whether or not the <tt>MediaStream/tt> is removed from
-     * the <tt>PeerConnection</tt> and disposed on video mute (in order to turn
-     * off the camera device).
-     * @return {boolean} <tt>true</tt> if the current browser supports this
-     * strategy or <tt>false</tt> otherwise.
-     */
-    doesVideoMuteByStreamRemove() {
-        return !(
-            RTCBrowserType.isFirefox()
-            || RTCBrowserType.isEdge()
-            || RTCBrowserType.isSafariWithWebrtc()
-        );
-    },
-
-    /**
-     * Gets current browser type.
-     * @returns {string}
-     */
-    getBrowserType() {
-        return currentBrowser;
-    },
-
-    /**
-     * Gets current browser name, split from the type.
-     * @returns {string}
-     */
-    getBrowserName() {
-        const isAndroid = navigator.userAgent.indexOf('Android') !== -1;
-
-        if (isAndroid) {
-            return 'android';
-        }
-
-        return currentBrowser.split('rtc_browser.')[1];
-    },
-
-    /**
-     * Checks if current browser is Chrome.
-     * @returns {boolean}
-     */
-    isChrome() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_CHROME;
-    },
-
-    /**
-     * Checks if current browser is Opera.
-     * @returns {boolean}
-     */
-    isOpera() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_OPERA;
-    },
-
-    /**
-     * Checks if current browser is Firefox.
-     * @returns {boolean}
-     */
-    isFirefox() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_FIREFOX;
-    },
-
-    /**
-     * Checks if current browser is Internet Explorer.
-     * @returns {boolean}
-     */
-    isIExplorer() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_IEXPLORER;
-    },
-
-    /**
-     * Checks if current browser is Microsoft Edge.
-     * @returns {boolean}
-     */
-    isEdge() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_EDGE;
-    },
-
-    /**
-     * Checks if current browser is Safari.
-     * @returns {boolean}
-     */
-    isSafari() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_SAFARI;
-    },
-
-    /**
-     * Checks if current browser is a Safari and a version of Safari that
-     * supports native webrtc.
-     *
-     * @returns {boolean}
-     */
-    isSafariWithWebrtc() {
-        return RTCBrowserType.isSafari()
-            && RTCBrowserType.getSafariVersion() >= 11;
-    },
-
-    /**
-     * Checks if current environment is NWJS.
-     * @returns {boolean}
-     */
-    isNWJS() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_NWJS;
-    },
-
-    /**
-     * Checks if current environment is Electron.
-     * @returns {boolean}
-     */
-    isElectron() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_ELECTRON;
-    },
-
-    /**
-     * Check whether or not the current browser support peer to peer connections
-     * @return {boolean} <tt>true</tt> if p2p is supported or <tt>false</tt>
-     * otherwise.
-     */
-    isP2PSupported() {
-        return !RTCBrowserType.isEdge();
-    },
-
-    /**
-     * Checks if current environment is React Native.
-     * @returns {boolean}
-     */
-    isReactNative() {
-        return currentBrowser === RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
-    },
-
-    /**
-     * Checks if Temasys RTC plugin is used.
-     * @returns {boolean}
-     */
-    isTemasysPluginUsed() {
-        // Temasys do not support Microsoft Edge:
-        // http://support.temasys.com.sg/support/solutions/articles/
-        // 5000654345-can-the-temasys-webrtc-plugin-be-used-with-microsoft-edge-
-        return (
-            (RTCBrowserType.isSafari()
-                && !RTCBrowserType.isSafariWithWebrtc())
-            || (RTCBrowserType.isIExplorer()
-                && RTCBrowserType.getIExplorerVersion() < 12)
-        );
-    },
-
-    /**
-     * 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() {
-        return (RTCBrowserType.isChrome()
-                && RTCBrowserType.getChromeVersion() >= 61)
-            || RTCBrowserType.isFirefox()
-            || RTCBrowserType.isSafariWithWebrtc();
-
-    },
-
-    /**
-     * Checks if the current browser triggers 'onmute'/'onunmute' events when
-     * user's connection is interrupted and the video stops playback.
-     * @returns {*|boolean} 'true' if the event is supported or 'false'
-     * otherwise.
-     */
-    isVideoMuteOnConnInterruptedSupported() {
-        return RTCBrowserType.isChrome() || RTCBrowserType.isElectron();
-    },
-
-    /**
-     * Returns Firefox version.
-     * @returns {number|null}
-     */
-    getFirefoxVersion() {
-        return RTCBrowserType.isFirefox() ? browserVersion : null;
-    },
-
-    /**
-     * Returns Chrome version.
-     * @returns {number|null}
-     */
-    getChromeVersion() {
-        return RTCBrowserType.isChrome() ? browserVersion : null;
-    },
-
-    /**
-     * Returns Opera version.
-     * @returns {number|null}
-     */
-    getOperaVersion() {
-        return RTCBrowserType.isOpera() ? browserVersion : null;
-    },
-
-    /**
-     * Returns Internet Explorer version.
-     *
-     * @returns {number|null}
-     */
-    getIExplorerVersion() {
-        return RTCBrowserType.isIExplorer() ? browserVersion : null;
-    },
-
-    /**
-     * Returns Edge version.
-     *
-     * @returns {number|null}
-     */
-    getEdgeVersion() {
-        return RTCBrowserType.isEdge() ? browserVersion : null;
-    },
-
-    /**
-     * Returns Safari version.
-     *
-     * @returns {number|null}
-     */
-    getSafariVersion() {
-        return RTCBrowserType.isSafari ? browserVersion : null;
-    },
-
-    usesPlanB() {
-        return !RTCBrowserType.usesUnifiedPlan();
-    },
-
-    usesUnifiedPlan() {
-        return RTCBrowserType.isFirefox();
-    },
-
-    /**
-     * Checks if the current browser reports upload and download bandwidth
-     * statistics.
-     * @return {boolean}
-     */
-    supportsBandwidthStatistics() {
-        // FIXME bandwidth stats are currently not implemented for FF on our
-        // side, but not sure if not possible ?
-        return !RTCBrowserType.isFirefox() && !RTCBrowserType.isEdge();
-    },
-
-    /**
-     * Checks if the current browser supports WebRTC datachannels.
-     * @return {boolean}
-     */
-    supportsDataChannels() {
-        // NOTE: Edge does not yet implement DataChannel.
-        return !RTCBrowserType.isEdge();
-    },
-
-    /**
-     * Checks if the current browser reports round trip time statistics for
-     * the ICE candidate pair.
-     * @return {boolean}
-     */
-    supportsRTTStatistics() {
-        // Firefox does not seem to report RTT for ICE candidate pair:
-        // eslint-disable-next-line max-len
-        // https://www.w3.org/TR/webrtc-stats/#dom-rtcicecandidatepairstats-currentroundtriptime
-        // It does report mozRTT for RTP streams, but at the time of this
-        // writing it's value does not make sense most of the time
-        // (is reported as 1):
-        // https://bugzilla.mozilla.org/show_bug.cgi?id=1241066
-        // For Chrome and others we rely on 'googRtt'.
-        return !RTCBrowserType.isFirefox() && !RTCBrowserType.isEdge();
-    },
-
-    /**
-     * Whether jitsi-meet supports simulcast on the current browser.
-     * @returns {boolean}
-     */
-    supportsSimulcast() {
-        return RTCBrowserType.isChrome()
-            || RTCBrowserType.isFirefox()
-            || RTCBrowserType.isElectron()
-            || RTCBrowserType.isNWJS()
-            || RTCBrowserType.isReactNative();
-    },
-
-    supportsRtx() {
-        return !RTCBrowserType.isFirefox();
-    },
-
-    supportsRtpSender() {
-        return RTCBrowserType.isFirefox();
-    },
-
-    /**
-     * Returns whether or not the current browser can support capturing video,
-     * be it camera or desktop, and displaying received video.
-     *
-     * @returns {boolean}
-     */
-    supportsVideo() {
-        // Currently Safari using webrtc/adapter does not support video due in
-        // part to Safari only supporting H264 and the bridge sending VP8.
-        return !RTCBrowserType.isSafariWithWebrtc();
-    }
-};
-
-/**
- * detectOpera() must be called before detectChrome() !!!
- * otherwise Opera wil be detected as Chrome
- */
-function detectChrome() {
-    if (navigator.webkitGetUserMedia) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_CHROME;
-
-        // We can assume that user agent is chrome, because it's enforced when
-        // 'ext' streaming method is set.
-        const verMatch = navigator.userAgent.match(/chrome\/(\d+)\./i);
-        const ver = verMatch ? parseInt(verMatch[1], 10) : 'undefined';
-
-        logger.log(`This appears to be Chrome, ver: ${ver}`);
-
-        return ver;
-    }
-
-    return null;
-}
-
-/**
- *
- */
-function detectOpera() {
-    const userAgent = navigator.userAgent;
-
-    if (userAgent.match(/Opera|OPR/)) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_OPERA;
-        const version = userAgent.match(/(Opera|OPR) ?\/?(\d+)\.?/)[2];
-
-        logger.info(`This appears to be Opera, ver: ${version}`);
-
-        return version;
-    }
-
-    return null;
-}
-
-/**
- *
- */
-function detectFirefox() {
-    if (navigator.mozGetUserMedia) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_FIREFOX;
-        const version = parseInt(
-            navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1], 10);
-
-        logger.log(`This appears to be Firefox, ver: ${version}`);
-
-        return version;
-    }
-
-    return null;
-}
-
-/**
- *
- */
-function detectSafari() {
-    if (/^((?!chrome).)*safari/i.test(navigator.userAgent)) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
-
-        const matchedVersionParts
-            = navigator.userAgent.match(/version\/(\d+(\.\d+)?)/i);
-        const versionString = matchedVersionParts && matchedVersionParts[1];
-        const version = versionString ? parseInt(versionString, 10) : -1;
-
-        logger.info(`This appears to be Safari, ver: ${version}`);
-
-        return version;
-    }
-
-    return null;
-}
-
-/**
- * Detects IE.
- */
-function detectIE() {
-    let version;
-    const ua = window.navigator.userAgent;
-
-    const msie = ua.indexOf('MSIE ');
-
-    if (msie > 0) {
-        // IE 10 or older => return version number
-        version = parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
-    }
-
-    const trident = ua.indexOf('Trident/');
-
-    if (!version && trident > 0) {
-        // IE 11 => return version number
-        const rv = ua.indexOf('rv:');
-
-        version = parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
-    }
-
-    if (version) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_IEXPLORER;
-        logger.info(`This appears to be IExplorer, ver: ${version}`);
-    }
-
-    return version;
-}
-
-/**
- * Detects Edge.
- */
-function detectEdge() {
-    let version;
-    const ua = window.navigator.userAgent;
-
-    const edge = ua.indexOf('Edge/');
-
-    if (!version && edge > 0) {
-        version = parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
-    }
-
-    if (version) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_EDGE;
-        logger.info(`This appears to be Edge, ver: ${version}`);
-    }
-
-    return version;
-}
-
-/**
- * Detects Electron environment.
- */
-function detectElectron() {
-    const userAgent = navigator.userAgent;
-
-    if (userAgent.match(/Electron/)) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_ELECTRON;
-        const version = userAgent.match(/Electron\/([\d.]+)/)[1];
-
-        logger.info(`This appears to be Electron, ver: ${version}`);
-
-        return version;
-    }
-
-    return null;
-}
-
-/**
- *
- */
-function detectNWJS() {
-    const userAgent = navigator.userAgent;
-
-    if (userAgent.match(/JitsiMeetNW/)) {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_NWJS;
-        const version = userAgent.match(/JitsiMeetNW\/([\d.]+)/)[1];
-
-        logger.info(`This appears to be JitsiMeetNW, ver: ${version}`);
-
-        return version;
-    }
-
-    return null;
-}
-
-/**
- *
- */
-function detectReactNative() {
-    const match
-        = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
-    let version;
-
-    // If we're remote debugging a React Native app, it may be treated as
-    // Chrome. Check navigator.product as well and always return some version
-    // even if we can't get the real one.
-
-    if (match || navigator.product === 'ReactNative') {
-        currentBrowser = RTCBrowserType.RTC_BROWSER_REACT_NATIVE;
-        let name;
-
-        if (match && match.length > 2) {
-            name = match[1];
-            version = match[2];
-        }
-        name || (name = 'react-native');
-        version || (version = 'unknown');
-        console.info(`This appears to be ${name}, ver: ${version}`);
-    } else {
-        // We're not running in a React Native environment.
-        version = null;
-    }
-
-    return version;
-}
-
-/**
- *
- */
-function detectBrowser() {
-    let version;
-    const detectors = [
-        detectReactNative,
-        detectElectron,
-        detectNWJS,
-        detectOpera,
-        detectChrome,
-        detectFirefox,
-        detectEdge,
-        detectIE,
-        detectSafari
-    ];
-
-    // Try all browser detectors
-
-    for (let i = 0; i < detectors.length; i++) {
-        version = detectors[i]();
-        if (version) {
-            return version;
-        }
-    }
-    logger.warn('Browser type defaults to Safari ver 1');
-    currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
-
-    return 1;
-}
-
-browserVersion = detectBrowser();
-
-export default RTCBrowserType;

modules/RTC/RTCUIHelper.js

 /* global $ */
 
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
      * @returns {string} 'video' or 'object' string name of WebRTC video element
      */
     getVideoElementName() {
-        return RTCBrowserType.isTemasysPluginUsed() ? 'object' : 'video';
+        return browser.isTemasysPluginUsed() ? 'object' : 'video';
     },
 
     /**
     findVideoElement(containerElement) {
         const videoElemName = RTCUIHelper.getVideoElementName();
 
-        if (!RTCBrowserType.isTemasysPluginUsed()) {
+        if (!browser.isTemasysPluginUsed()) {
             return $(containerElement).find(videoElemName)[0];
         }
         const matching
      * @returns {boolean}
      */
     isResizeEventSupported() {
-        return !RTCBrowserType.isTemasysPluginUsed();
+        return !browser.isTemasysPluginUsed();
     },
 
     /**
      * @param volume the volume value to be set.
      */
     setVolume(streamElement, volume) {
-        if (!RTCBrowserType.isIExplorer()) {
+        if (!browser.isIExplorer()) {
             streamElement.volume = volume;
         }
     },
      * @param autoPlay 'true' or 'false'
      */
     setAutoPlay(streamElement, autoPlay) {
-        if (!RTCBrowserType.isIExplorer()) {
+        if (!browser.isIExplorer()) {
             streamElement.autoplay = autoPlay;
         }
     }

modules/RTC/RTCUtils.js

 import Listenable from '../util/Listenable';
 import * as MediaType from '../../service/RTC/MediaType';
 import Resolutions from '../../service/RTC/Resolutions';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import ortcRTCPeerConnection from './ortc/RTCPeerConnection';
 import screenObtainer from './ScreenObtainer';
 // XXX Don't require Temasys unless it's to be used because it doesn't run on
 // React Native, for example.
 const AdapterJS
-    = RTCBrowserType.isTemasysPluginUsed()
+    = browser.isTemasysPluginUsed()
         ? require('./adapter.screenshare')
         : undefined;
 
 // Require adapter only for certain browsers. This is being done for
 // react-native, which has its own shims, and while browsers are being migrated
 // over to use adapter's shims.
-if (RTCBrowserType.usesNewGumFlow()) {
+if (browser.usesNewGumFlow()) {
     require('webrtc-adapter');
 }
 
     // have stable support of new constraints format. For more information
     // @see https://github.com/jitsi/lib-jitsi-meet/pull/136
     const isNewStyleConstraintsSupported
-        = RTCBrowserType.isFirefox()
-        || RTCBrowserType.isEdge()
-        || RTCBrowserType.isReactNative()
-        || RTCBrowserType.isTemasysPluginUsed();
+        = browser.isFirefox()
+        || browser.isEdge()
+        || browser.isReactNative()
+        || browser.isTemasysPluginUsed();
 
     if (um.indexOf('video') >= 0) {
         // same behaviour as true
             constraints, isNewStyleConstraintsSupported, options.resolution);
     }
     if (um.indexOf('audio') >= 0) {
-        if (RTCBrowserType.isReactNative()) {
+        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 (RTCBrowserType.isFirefox()) {
+        } else if (browser.isFirefox()) {
             if (options.micDeviceId) {
                 constraints.audio = {
                     mandatory: {},
         }
     }
     if (um.indexOf('screen') >= 0) {
-        if (RTCBrowserType.isChrome()) {
+        if (browser.isChrome()) {
             constraints.video = {
                 mandatory: {
                     chromeMediaSource: 'screen',
                 },
                 optional: []
             };
-        } else if (RTCBrowserType.isTemasysPluginUsed()) {
+        } else if (browser.isTemasysPluginUsed()) {
             constraints.video = {
                 optional: [
                     {
                     }
                 ]
             };
-        } else if (RTCBrowserType.isFirefox()) {
+        } else if (browser.isFirefox()) {
             constraints.video = {
                 mozMediaSource: 'window',
                 mediaSource: 'window'
     // 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 (RTCBrowserType.isFirefox() && options.firefox_fake_device) {
+    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;
         initRawEnumerateDevicesWithCallback();
 
         return new Promise((resolve, reject) => {
-            if (RTCBrowserType.usesNewGumFlow()) {
+            if (browser.usesNewGumFlow()) {
                 this.RTCPeerConnectionType = window.RTCPeerConnection;
 
                 this.getUserMedia
 
                 this.getStreamID = stream => stream.id;
                 this.getTrackID = track => track.id;
-            } else if (RTCBrowserType.isChrome() // this is chrome < 61
-                    || RTCBrowserType.isOpera()
-                    || RTCBrowserType.isNWJS()
-                    || RTCBrowserType.isElectron()
-                    || RTCBrowserType.isReactNative()) {
+            } else if (browser.isChrome() // this is chrome < 61
+                    || browser.isOpera()
+                    || browser.isNWJS()
+                    || browser.isElectron()
+                    || browser.isReactNative()) {
 
                 this.RTCPeerConnectionType = webkitRTCPeerConnection;
                 const getUserMedia
                         return this.audioTracks;
                     };
                 }
-            } else if (RTCBrowserType.isEdge()) {
+            } else if (browser.isEdge()) {
                 this.RTCPeerConnectionType = ortcRTCPeerConnection;
                 this.getUserMedia
                     = wrapGetUserMedia(
                 this.getTrackID = function(track) {
                     return track.jitsiRemoteId || track.id;
                 };
-            } else if (RTCBrowserType.isTemasysPluginUsed()) {
+            } else if (browser.isTemasysPluginUsed()) {
                 // Detect IE/Safari
                 const webRTCReadyCb = () => {
                     this.RTCPeerConnectionType = RTCPeerConnection;
                                 // is in use
                                 const containerSel = $(element);
 
-                                if (RTCBrowserType.isTemasysPluginUsed()
+                                if (browser.isTemasysPluginUsed()
                                         && !containerSel.is(':visible')) {
                                     containerSel.show();
                                 }
             this._initPCConstraints(options);
 
             // Call onReady() if Temasys plugin is not used
-            if (!RTCBrowserType.isTemasysPluginUsed()) {
+            if (!browser.isTemasysPluginUsed()) {
                 onReady(options, this.getUserMediaWithConstraints.bind(this));
                 resolve();
             }
      * in peer to peer connection mode.
      */
     _initPCConstraints(options) {
-        if (RTCBrowserType.isFirefox()) {
+        if (browser.isFirefox()) {
             this.pcConstraints = {};
-        } else if (RTCBrowserType.isChrome()
-            || RTCBrowserType.isOpera()
-            || RTCBrowserType.isNWJS()
-            || RTCBrowserType.isElectron()
-            || RTCBrowserType.isReactNative()) {
+        } else if (browser.isChrome()
+            || browser.isOpera()
+            || browser.isNWJS()
+            || browser.isElectron()
+            || browser.isReactNative()) {
             this.pcConstraints = { optional: [
                 { googHighStartBitrate: 0 },
                 { googPayloadPadding: true },
     _newGetDesktopMedia(
             desktopSharingExtensionExternalInstallation,
             desktopSharingSources) {
-        if (!screenObtainer.isSupported() || !RTCBrowserType.supportsVideo()) {
+        if (!screenObtainer.isSupported() || !browser.supportsVideo()) {
             return Promise.reject(
                 new Error('Desktop sharing is not supported!'));
         }
                 && options.devices.indexOf('desktop') !== -1) {
                 reject(new Error('Desktop sharing is not supported!'));
             }
-            if (RTCBrowserType.isFirefox()
+            if (browser.isFirefox()
 
                     // XXX The react-native-webrtc implementation that we
                     // utilize on React Native at the time of this writing does
                     // https://www.w3.org/TR/mediacapture-streams/#constructors
                     // and instead has a single constructor which expects (an
                     // NSNumber as) a MediaStream ID.
-                    || RTCBrowserType.isReactNative()
-                    || RTCBrowserType.isTemasysPluginUsed()) {
+                    || browser.isReactNative()
+                    || browser.isTemasysPluginUsed()) {
                 const GUM = function(device, s, e) {
                     this.getUserMediaWithConstraints(device, s, e, options);
                 };
             const umDevices = options.devices || [ 'audio', 'video' ];
             const requestedCaptureDevices = umDevices.filter(device =>
                 device === 'audio'
-                || (device === 'video' && RTCBrowserType.supportsVideo()));
+                || (device === 'video' && browser.supportsVideo()));
 
             if (!requestedCaptureDevices.length) {
                 return Promise.resolve();
     isDeviceChangeAvailable(deviceType) {
         return deviceType === 'output' || deviceType === 'audiooutput'
             ? isAudioOutputDeviceChangeAvailable
-            : RTCBrowserType.isChrome()
-                || RTCBrowserType.isFirefox()
-                || RTCBrowserType.isOpera()
-                || RTCBrowserType.isTemasysPluginUsed()
-                || RTCBrowserType.isNWJS()
-                || RTCBrowserType.isElectron()
-                || RTCBrowserType.isEdge();
+            : browser.isChrome()
+                || browser.isFirefox()
+                || browser.isOpera()
+                || browser.isTemasysPluginUsed()
+                || browser.isNWJS()
+                || browser.isElectron()
+                || browser.isEdge();
     }
 
     /**
     stopMediaStream(mediaStream) {
         mediaStream.getTracks().forEach(track => {
             // stop() not supported with IE
-            if (!RTCBrowserType.isTemasysPluginUsed() && track.stop) {
+            if (!browser.isTemasysPluginUsed() && track.stop) {
                 track.stop();
             }
         });

modules/RTC/ScreenObtainer.js

 
 import JitsiTrackError from '../../JitsiTrackError';
 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
      * @private
      */
     _createObtainStreamMethod(options) {
-        if (RTCBrowserType.isNWJS()) {
+        if (browser.isNWJS()) {
             return (_, onSuccess, onFailure) => {
                 window.JitsiMeetNW.obtainDesktopStream(
                     onSuccess,
                             && onFailure(jitsiError);
                     });
             };
-        } else if (RTCBrowserType.isElectron()) {
+        } else if (browser.isElectron()) {
             return this.obtainScreenOnElectron;
-        } else if (RTCBrowserType.isTemasysPluginUsed()) {
+        } else if (browser.isTemasysPluginUsed()) {
             // XXX Don't require Temasys unless it's to be used because it
             // doesn't run on React Native, for example.
             const plugin
             logger.info('Using Temasys plugin for desktop sharing');
 
             return obtainWebRTCScreen;
-        } else if (RTCBrowserType.isChrome() || RTCBrowserType.isOpera()) {
-            if ((RTCBrowserType.getChromeVersion()
-                    || RTCBrowserType.getOperaVersion()) < 34) {
+        } else if (browser.isChrome() || browser.isOpera()) {
+            if (browser.isVersionLessThan('34')) {
                 logger.info('Chrome extension not supported until ver 34');
 
                 return null;
                 });
 
             return this.obtainScreenFromExtension;
-        } else if (RTCBrowserType.isFirefox()) {
+        } else if (browser.isFirefox()) {
             if (options.desktopSharingFirefoxDisabled) {
                 return null;
             } else if (window.location.protocol === 'http:') {
 
         logger.log(
             'Screen sharing not supported by the current browser: ',
-            RTCBrowserType.getBrowserType(),
-            RTCBrowserType.getBrowserName());
+            browser.getName());
 
         return null;
     },
 
         if (desktopSharingFirefoxMaxVersionExtRequired === -1
             || (desktopSharingFirefoxMaxVersionExtRequired >= 0
-                && RTCBrowserType.getFirefoxVersion()
-                    <= desktopSharingFirefoxMaxVersionExtRequired)) {
+                && !browser.isVersionGreaterThan(
+                    desktopSharingFirefoxMaxVersionExtRequired))) {
             extensionRequired = true;
             logger.log(
                 `Jidesha extension required on firefox version ${
-                    RTCBrowserType.getFirefoxVersion()}`);
+                    browser.getVersion()}`);
         }
 
         if (!extensionRequired || firefoxExtInstalled === true) {
             // extension "Download Chrome Extension" allows us to open
             // the chrome webstore and install from there and then activate our
             // extension
-            if (RTCBrowserType.isOpera()) {
+            if (browser.isOpera()) {
                 this.handleExternalInstall(options, streamCallback,
                     failCallback);
 

modules/RTC/TraceablePeerConnection.js

 import LocalSdpMunger from './LocalSdpMunger';
 import RTC from './RTC';
 import RTCUtils from './RTCUtils';
-import RTCBrowserType from './RTCBrowserType';
+import browser from '../browser';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import RtxModifier from '../xmpp/RtxModifier';
 
         logger.debug(what, info);
 
         /*
-        if (info && RTCBrowserType.isIExplorer()) {
+        if (info && browser.isIExplorer()) {
             if (info.length > 1024) {
                 logger.warn('WTRACE', what, info.substr(1024));
             }
     this.onicecandidate = null;
     this.peerconnection.onicecandidate = event => {
         // FIXME: this causes stack overflow with Temasys Plugin
-        if (!RTCBrowserType.isTemasysPluginUsed()) {
+        if (!browser.isTemasysPluginUsed()) {
             this.trace(
                 'onicecandidate',
                 JSON.stringify(event.candidate, null, ' '));
     };
 
     // XXX: do all non-firefox browsers which we support also support this?
-    if (!RTCBrowserType.isFirefox() && this.maxstats) {
+    if (!browser.isFirefox() && this.maxstats) {
         this.statsinterval = window.setInterval(() => {
             this.peerconnection.getStats(stats => {
                 const results = stats.result();
  */
 TraceablePeerConnection.prototype.isSimulcastOn = function() {
     return !this.options.disableSimulcast
-        && RTCBrowserType.supportsSimulcast()
+        && browser.supportsSimulcast()
 
         // Firefox has been added as supporting simulcast, but it is
         // experimental so we only want to do it for firefox if the config
-        // option is set.  Unfortunately, RTCBrowserType::supportsSimulcast()
+        // option is set.  Unfortunately, browser::supportsSimulcast()
         // doesn't have a reference to the config options, so we have
         // to do it here
-        && (!RTCBrowserType.isFirefox()
+        && (!browser.isFirefox()
             || this.options.enableFirefoxSimulcast);
 };
 
     }
 
     // Bind 'addtrack'/'removetrack' event handlers
-    if (RTCBrowserType.isChrome() || RTCBrowserType.isNWJS()
-        || RTCBrowserType.isElectron() || RTCBrowserType.isEdge()) {
+    if (browser.isChrome() || browser.isNWJS()
+        || browser.isElectron() || browser.isEdge()) {
         stream.onaddtrack = event => {
             this._remoteTrackAdded(stream, event.track);
         };
     ssrcLines = ssrcLines.filter(
         line => {
             const msid
-                = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
+                = browser.isTemasysPluginUsed() ? 'mslabel' : 'msid';
 
 
             return line.indexOf(`${msid}:${streamId}`) !== -1;
         this.trace('getLocalDescription::preTransform', dumpSDP(desc));
 
         // if we're running on FF, transform to Plan B first.
-        if (RTCBrowserType.usesUnifiedPlan()) {
+        if (browser.usesUnifiedPlan()) {
             desc = this.interop.toPlanB(desc);
             this.trace('getLocalDescription::postTransform (Plan B)',
                 dumpSDP(desc));
                 dumpSDP(desc));
         }
 
-        if (RTCBrowserType.doesVideoMuteByStreamRemove()) {
+        if (browser.doesVideoMuteByStreamRemove()) {
             desc = this.localSdpMunger.maybeAddMutedLocalVideoTracksToSDP(desc);
             logger.debug(
                 'getLocalDescription::postTransform (munge local SDP)', desc);
         this.trace('getRemoteDescription::preTransform', dumpSDP(desc));
 
         // if we're running on FF, transform to Plan B first.
-        if (RTCBrowserType.usesUnifiedPlan()) {
+        if (browser.usesUnifiedPlan()) {
             desc = this.interop.toPlanB(desc);
             this.trace(
                 'getRemoteDescription::postTransform (Plan B)', dumpSDP(desc));
         this._addStream(webrtcStream);
 
     // It's not ok for a track to not have a WebRTC stream if:
-    } else if (!RTCBrowserType.doesVideoMuteByStreamRemove()
+    } else if (!browser.doesVideoMuteByStreamRemove()
                 || track.isAudioTrack()
                 || (track.isVideoTrack() && !track.isMuted())) {
         logger.error(`${this} no WebRTC stream for: ${track}`);
     }
 
     // Muted video tracks do not have WebRTC stream
-    if (RTCBrowserType.doesVideoMuteByStreamRemove()
+    if (browser.doesVideoMuteByStreamRemove()
             && track.isVideoTrack() && track.isMuted()) {
         const ssrcInfo = this.generateNewStreamSSRCInfo(track);
 
  * @param {MediaStream} mediaStream
  */
 TraceablePeerConnection.prototype._removeStream = function(mediaStream) {
-    if (RTCBrowserType.isFirefox()) {
+    if (browser.isFirefox()) {
         this._handleFirefoxRemoveStream(mediaStream);
     } else {
         this.peerconnection.removeStream(mediaStream);
     this.localSSRCs.delete(localTrack.rtcId);
 
     if (webRtcStream) {
-        if (RTCBrowserType.isFirefox()) {
+        if (browser.isFirefox()) {
             this._handleFirefoxRemoveStream(webRtcStream);
         } else {
             this.peerconnection.removeStream(webRtcStream);
     localSdp = this._ensureSimulcastGroupIsLast(localSdp);
 
     // if we're using unified plan, transform to it first.
-    if (RTCBrowserType.usesUnifiedPlan()) {
+    if (browser.usesUnifiedPlan()) {
         localSdp = this.interop.toUnifiedPlan(localSdp);
         this.trace(
             'setLocalDescription::postTransform (Unified Plan)',
     }
 
     // If the browser uses unified plan, transform to it first
-    if (RTCBrowserType.usesUnifiedPlan()) {
+    if (browser.usesUnifiedPlan()) {
         // eslint-disable-next-line no-param-reassign
         description = new RTCSessionDescription({
             type: description.type,
 
     // Safari WebRTC errors when no supported video codec is found in the offer.
     // To prevent the error, inject H264 into the video mLine.
-    if (RTCBrowserType.isSafariWithWebrtc()) {
+    if (browser.isSafariWithWebrtc()) {
         logger.debug('Maybe injecting H264 into the remote description');
 
         // eslint-disable-next-line no-param-reassign
  * @private
  */
 const _fixAnswerRFC4145Setup = function(offer, answer) {
-    if (!RTCBrowserType.isChrome()) {
+    if (!browser.isChrome()) {
         // It looks like Firefox doesn't agree with the fix (at least in its
         // current implementation) because it effectively remains active even
         // after we tell it to become passive. Apart from Firefox which I tested
         successCallback,
         failureCallback,
         constraints) {
-    if (RTCBrowserType.supportsRtpSender() && this.isSimulcastOn()) {
+    if (browser.supportsRtpSender() && this.isSimulcastOn()) {
         const videoSender
             = this.peerconnection.getSenders().find(sender =>
                 sender.track.kind === 'video');
                 `create${logName}OnSuccess::preTransform`, dumpSDP(resultSdp));
 
             // if we're using unified plan, transform to Plan B.
-            if (RTCBrowserType.usesUnifiedPlan()) {
+            if (browser.usesUnifiedPlan()) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = this.interop.toPlanB(resultSdp);
                 this.trace(
              *  after that, when we try and go back to unified plan it will
              *  complain about unmapped ssrcs)
              */
-            if (!RTCBrowserType.isFirefox()) {
+            if (!browser.isFirefox()) {
                 // If there are no local video tracks, then a "recvonly"
                 // SSRC needs to be generated
                 if (!this.hasAnyTracksOfType(MediaType.VIDEO)
                     dumpSDP(resultSdp));
             }
 
-            if (!this.options.disableRtx && RTCBrowserType.supportsRtx()) {
+            if (!this.options.disableRtx && browser.supportsRtx()) {
                 // eslint-disable-next-line no-param-reassign
                 resultSdp = new RTCSessionDescription({
                     type: resultSdp.type,
     // TODO (brian): After moving all browsers to adapter, check if adapter is
     // accounting for different getStats apis, making the browser-checking-if
     // unnecessary.
-    if (RTCBrowserType.isFirefox()
-            || RTCBrowserType.isTemasysPluginUsed()
-            || RTCBrowserType.isReactNative()) {
+    if (browser.isFirefox()
+            || browser.isTemasysPluginUsed()
+            || browser.isReactNative()) {
         this.peerconnection.getStats(
             null,
             callback,
                 // Making sure that getStats won't fail if error callback is
                 // not passed.
             }));
-    } else if (RTCBrowserType.isSafariWithWebrtc()) {
+    } else if (browser.isSafariWithWebrtc()) {
         // FIXME: Safari's native stats implementation is not compatibile with
         // existing stats processing logic. Skip implementing stats for now to
         // at least get native webrtc Safari available for use.
             groups: []
         };
     }
-    if (!this.options.disableRtx && RTCBrowserType.supportsRtx()) {
+    if (!this.options.disableRtx && browser.supportsRtx()) {
         // Specifically use a for loop here because we'll
         //  be adding to the list we're iterating over, so we
         //  only want to iterate through the items originally

modules/RTC/ortc/README.md

 
 * BUNDLE is assumed (single transport for all the local and remote media streams).
 * `rtcp-mux` is assumed (not a real problem nowadays).
-* Calling `createOffer()` is not implemented, so P2P mode is not supported (`RTCBrowserType.isP2PSupported()` returns `false`).
+* Calling `createOffer()` is not implemented, so P2P mode is not supported (`browser.supportsP2P()` returns `false`).
 * Calling `setRemoteDescription()` with a SDP answer with mangled SSRC values is currently unsupported (those new SSRC values will not be used for sending media).
 * If the app calls `createAnswer()`, mangles SSRC values, and applies by calling `setLocalDescription()`, those new SSRC values are currently ignored.
 * Simulcast not supported (currently Edge supports `maxFramerate` per encoding but it does not support `maxBitrate`, `resolutionScale` or `framerateScale`, so it's not worth it).

modules/browser/BrowserCapabilities.js

+import BrowserDetection from './BrowserDetection';
+import capabilitiesDB from './capabilities.json';
+
+// TODO: All methods should use capabilities.json when possible.
+
+// NOTE: Now we are extending BrowserDetection in order to preserve
+// RTCBrowserType interface but maybe it worth exporting BrowserCapabilities
+// and BrowserDetection as separate objects in future.
+
+/**
+ * Implements browser capabilities for lib-jitsi-meet.
+ */
+export default class BrowserCapabilities extends BrowserDetection {
+    /**
+     * Creates new BrowserCapabilities instance.
+     *
+     * @param {boolean} [isUsingIFrame] - True if Jitsi Meet is loaded in iframe
+     * and false otherwise.
+     * @param {Object} [browserInfo] - Information about the browser.
+     * @param {string} browserInfo.name - The name of the browser.
+     * @param {string} browserInfo.version - The version of the browser.
+     */
+    constructor(isUsingIFrame = false, browserInfo) {
+        super(browserInfo);
+
+        const browserCapabilities = capabilitiesDB[this.getName()] || [];
+        const capabilitiesByVersion = browserCapabilities.find(({ version }) =>
+            !version || !this.isVersionLessThan(version));
+
+        if (!capabilitiesByVersion || !capabilitiesByVersion.capabilities) {
+            this._capabilities = { isSupported: false };
+        } else if (isUsingIFrame) {
+            this._capabilities = {
+                ...capabilitiesByVersion.capabilities,
+                ...capabilitiesByVersion.iframeCapabilities
+            };
+        } else {
+            this._capabilities = capabilitiesByVersion.capabilities;
+        }
+
+        if (typeof this._capabilities.isSupported === 'undefined') {
+            // we have some capabilities but isSupported property is not filled.
+            this._capabilities.isSupported = true;
+        } else if (this._capabilities.isSupported === false) {
+            this._capabilities = { isSupported: false };
+        }
+    }
+
+    /**
+     * Tells whether or not the <tt>MediaStream/tt> is removed from
+     * the <tt>PeerConnection</tt> and disposed on video mute (in order to turn
+     * off the camera device).
+     * @return {boolean} <tt>true</tt> if the current browser supports this
+     * strategy or <tt>false</tt> otherwise.
+     */
+    doesVideoMuteByStreamRemove() {
+        return !(
+            this.isFirefox()
+            || this.isEdge()
+            || this.isSafariWithWebrtc()
+        );
+    }
+
+    /**
+     * Check whether or not the current browser support peer to peer connections
+     * @return {boolean} <tt>true</tt> if p2p is supported or <tt>false</tt>
+     * otherwise.
+     */
+    supportsP2P() {
+        return !this.isEdge();
+    }
+
+    /**
+     * Checks if current browser is a Safari and a version of Safari that
+     * supports native webrtc.
+     *
+     * @returns {boolean}
+     */
+    isSafariWithWebrtc() {
+        return this.isSafari()
+            && !this.isVersionLessThan('11');
+    }
+
+    /**
+     * Checks whether the browser is supported by Jitsi Meet.
+     *
+     * @returns {boolean}
+     */
+    isSupported() {
+        return this._capabilities.isSupported;
+    }
+
+    /**
+     * Checks if Temasys RTC plugin is used.
+     * @returns {boolean}
+     */
+    isTemasysPluginUsed() {
+        // Temasys do not support Microsoft Edge:
+        // http://support.temasys.com.sg/support/solutions/articles/
+        // 5000654345-can-the-temasys-webrtc-plugin-be-used-with-microsoft-edge-
+        return (
+            (this.isSafari()
+                && !this.isSafariWithWebrtc())
+            || (this.isIExplorer()
+                && this.isVersionLessThan('12'))
+        );
+    }
+
+    /**
+     * Checks if the current browser triggers 'onmute'/'onunmute' events when
+     * user's connection is interrupted and the video stops playback.
+     * @returns {*|boolean} 'true' if the event is supported or 'false'
+     * otherwise.
+     */
+    supportsVideoMuteOnConnInterrupted() {
+        return this.isChrome() || this.isElectron();
+    }
+
+
+    /**
+     * Checks whether the browser supports incoming audio.
+     *
+     * @returns {boolean}
+     */
+    supportsAudioIn() {
+        return this._capabilities.audioIn || false;
+    }
+
+    /**
+     * Checks whether the browser supports outgoing audio.
+     *
+     * @returns {boolean}
+     */
+    supportsAudioOut() {
+        return this._capabilities.audioOut || false;
+    }
+
+    /**
+     * Checks if the current browser reports upload and download bandwidth
+     * statistics.
+     * @return {boolean}
+     */
+    supportsBandwidthStatistics() {
+        // FIXME bandwidth stats are currently not implemented for FF on our
+        // side, but not sure if not possible ?
+        return !this.isFirefox() && !this.isEdge();
+    }
+
+    /**
+     * Checks if the current browser supports WebRTC datachannels.
+     * @return {boolean}
+     */
+    supportsDataChannels() {
+        // NOTE: Edge does not yet implement DataChannel.
+        return !this.isEdge();
+    }
+
+    /**
+     * Checks if the current browser reports round trip time statistics for
+     * the ICE candidate pair.
+     * @return {boolean}
+     */
+    supportsRTTStatistics() {
+        // Firefox does not seem to report RTT for ICE candidate pair:
+        // eslint-disable-next-line max-len
+        // https://www.w3.org/TR/webrtc-stats/#dom-rtcicecandidatepairstats-currentroundtriptime
+        // It does report mozRTT for RTP streams, but at the time of this
+        // writing it's value does not make sense most of the time
+        // (is reported as 1):
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1241066
+        // For Chrome and others we rely on 'googRtt'.
+        return !this.isFirefox() && !this.isEdge();
+    }
+
+    /**
+     * Checks whether the browser supports RTPSender.
+     *
+     * @returns {boolean}
+     */
+    supportsRtpSender() {
+        return this.isFirefox();
+    }
+
+    /**
+     * Checks whether the browser supports RTX.
+     *
+     * @returns {boolean}
+     */
+    supportsRtx() {
+        return !this.isFirefox();
+    }
+
+    /**
+     * Checks whether the browser supports screen sharing.
+     *
+     * @returns {boolean}
+     */
+    supportsScreenSharing() {
+        return this._capabilities.screenSharing || false;
+    }
+
+    /**
+     * Whether jitsi-meet supports simulcast on the current browser.
+     * @returns {boolean}
+     */
+    supportsSimulcast() {
+        return this.isChrome()
+            || this.isFirefox()
+            || this.isElectron()
+            || this.isNWJS()
+            || this.isReactNative();
+    }
+
+    /**
+     * Returns whether or not the current browser can support capturing video,
+     * be it camera or desktop, and displaying received video.
+     *
+     * @returns {boolean}
+     */
+    supportsVideo() {
+        // FIXME: Check if we can use supportsVideoOut and supportsVideoIn. I
+        // leave the old implementation here in order not to brake something.
+
+        // Currently Safari using webrtc/adapter does not support video due in
+        // part to Safari only supporting H264 and the bridge sending VP8.
+        return !this.isSafariWithWebrtc();
+    }
+
+    /**
+     * Checks whether the browser supports incomming video.
+     *
+     * @returns {boolean}
+     */
+    supportsVideoIn() {
+        return this._capabilities.videoIn || false;
+    }
+
+    /**
+     * Checks whether the browser supports incomming video.
+     *
+     * @returns {boolean}
+     */
+    supportsVideoOut() {
+        return this._capabilities.videoOut || false;
+    }
+
+    /**
+     * Checks if the browser uses plan B.
+     *
+     * @returns {boolean}
+     */
+    usesPlanB() {
+        return !this.usesUnifiedPlan();
+    }
+
+    /**
+     * Checks if the browser uses unified plan.
+     *
+     * @returns {boolean}
+     */
+    usesUnifiedPlan() {
+        return this.isFirefox();
+    }
+
+    /**
+     * 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() {
+        return (this.isChrome()
+                && !this.isVersionLessThan('61'))
+            || this.isFirefox()
+            || this.isSafariWithWebrtc();
+
+    }
+}

modules/browser/BrowserDetection.js

+import bowser from 'bowser';
+import { getLogger } from 'jitsi-meet-logger';
+
+import {
+    CHROME,
+    OPERA,
+    FIREFOX,
+    INTERNET_EXPLORER,
+    EDGE,
+    SAFARI,
+    NWJS,
+    ELECTRON,
+    REACT_NATIVE
+} from './browsers';
+
+const logger = getLogger(__filename);
+
+/**
+ * Maps the names of the browsers from bowser to the internal names defined in
+ * ./browsers.js
+ */
+const bowserNameToJitsiName = {
+    'Chrome': CHROME,
+    'Opera': OPERA,
+    'Firefox': FIREFOX,
+    'Internet Explorer': INTERNET_EXPLORER,
+    'Microsoft Edge': EDGE,
+    'Safari': SAFARI
+};
+
+/**
+ * Detects Electron environment.
+ *
+ * @returns {Object} - The name (ELECTRON) and version.
+ */
+function _detectElectron() {
+    const userAgent = navigator.userAgent;
+
+    if (userAgent.match(/Electron/)) {
+        const version = userAgent.match(/Electron\/([\d.]+)/)[1];
+
+        logger.info(`This appears to be Electron, ver: ${version}`);
+
+        return {
+            name: ELECTRON,
+            version
+        };
+    }
+}
+
+/**
+ * Detects NWJS environment.
+ *
+ * @returns {Object} - The name (NWJS) and version.
+ */
+function _detectNWJS() {
+    const userAgent = navigator.userAgent;
+
+    if (userAgent.match(/JitsiMeetNW/)) {
+        const version = userAgent.match(/JitsiMeetNW\/([\d.]+)/)[1];
+
+        logger.info(`This appears to be JitsiMeetNW, ver: ${version}`);
+
+        return {
+            name: NWJS,
+            version
+        };
+    }
+}
+
+/**
+ * Detects React Native environment.
+ * @returns {Object} - The name (REACT_NATIVE) and version
+ */
+function _detectReactNative() {
+    const match
+        = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
+    let version;
+
+    // If we're remote debugging a React Native app, it may be treated as
+    // Chrome. Check navigator.product as well and always return some version
+    // even if we can't get the real one.
+
+    if (match || navigator.product === 'ReactNative') {
+        let name;
+
+        if (match && match.length > 2) {
+            name = match[1];
+            version = match[2];
+        }
+        name || (name = 'react-native');
+        version || (version = 'unknown');
+        logger.info(`This appears to be ${name}, ver: ${version}`);
+
+        return {
+            name: REACT_NATIVE,
+            version
+        };
+    }
+}
+
+/**
+ * Returns information about the current browser.
+ *
+ * @returns {Object} - The name and version of the browser.
+ */
+function _detect() {
+    let browserInfo;
+    const detectors = [
+        _detectReactNative,
+        _detectElectron,
+        _detectNWJS
+    ];
+
+    // Try all browser detectors
+    for (let i = 0; i < detectors.length; i++) {
+        browserInfo = detectors[i]();
+        if (browserInfo) {
+            return browserInfo;
+        }
+    }
+
+    const { name, version } = bowser;
+
+    if (name in bowserNameToJitsiName) {
+        return {
+            name: bowserNameToJitsiName[name],
+            version
+        };
+    }
+
+    logger.warn('Browser type defaults to Safari ver 1');
+
+    return {
+        name: SAFARI,
+        version: '1'
+    };
+}
+
+/**
+ * Implements browser detection.
+ */
+export default class BrowserDetection {
+    /**
+     * Creates new BrowserDetection instance.
+     *
+     * @param {Object} [browserInfo] - Information about the browser.
+     * @param {string} browserInfo.name - The name of the browser.
+     * @param {string} browserInfo.version - The version of the browser.
+     */
+    constructor(browserInfo = _detect()) {
+        const { name, version } = browserInfo;
+
+        this._name = name;
+        this._version = version;
+    }
+
+    /**
+     * Gets current browser name.
+     * @returns {string}
+     */
+    getName() {
+        return this._name;
+    }
+
+    /**
+     * Checks if current browser is Chrome.
+     * @returns {boolean}
+     */
+    isChrome() {
+        return this._name === CHROME;
+    }
+
+    /**
+     * Checks if current browser is Opera.
+     * @returns {boolean}
+     */
+    isOpera() {
+        return this._name === OPERA;
+    }
+
+    /**
+     * Checks if current browser is Firefox.
+     * @returns {boolean}
+     */
+    isFirefox() {
+        return this._name === FIREFOX;
+    }
+
+    /**
+     * Checks if current browser is Internet Explorer.
+     * @returns {boolean}
+     */
+    isIExplorer() {
+        return this._name === INTERNET_EXPLORER;
+    }
+
+    /**
+     * Checks if current browser is Microsoft Edge.
+     * @returns {boolean}
+     */
+    isEdge() {
+        return this._name === EDGE;
+    }
+
+    /**
+     * Checks if current browser is Safari.
+     * @returns {boolean}
+     */
+    isSafari() {
+        return this._name === SAFARI;
+    }
+
+    /**
+     * Checks if current environment is NWJS.
+     * @returns {boolean}
+     */
+    isNWJS() {
+        return this._name === NWJS;
+    }
+
+    /**
+     * Checks if current environment is Electron.
+     * @returns {boolean}
+     */
+    isElectron() {
+        return this._name === ELECTRON;
+    }
+
+    /**
+     * Checks if current environment is React Native.
+     * @returns {boolean}
+     */
+    isReactNative() {
+        return this._name === REACT_NATIVE;
+    }
+
+    /**
+     * Returns the version of the current browser.
+     * @returns {string}
+     */
+    getVersion() {
+        return this._version;
+    }
+
+    /**
+     * Compares the passed version with the current browser version.
+     * {@see https://github.com/lancedikson/bowser}
+     */
+    static compareVersions = bowser.compareVersions;
+
+    /**
+     * Compares the passed version with the current browser version.
+     *
+     * @param {string} version - The version to compare with.
+     * @returns {number|undefined} - Returns 0 if the version is equal to the
+     * current one, 1 if the version is greater than the current one, -1 if the
+     * version is lower than the current one and undefined if the current
+     * browser version is unknown.
+     */
+    compareVersion(version) {
+        if (this._version) {
+            return bowser.compareVersions([ version, this._version ]);
+        }
+    }
+
+    /**
+     * Compares the passed version with the current browser version.
+     *
+     * @param {string} version - The version to compare with.
+     * @returns {boolean|undefined} - Returns true if the current version is
+     * greater than the passed version and false otherwise.
+     */
+    isVersionGreaterThan(version) {
+        if (this._version) {
+            return this.compareVersion(version) === 1;
+        }
+    }
+
+    /**
+     * Compares the passed version with the current browser version.
+     *
+     * @param {string} version - The version to compare with.
+     * @returns {boolean|undefined} - Returns true if the current version is
+     * lower than the passed version and false otherwise.
+     */
+    isVersionLessThan(version) {
+        if (this._version) {
+            return this.compareVersion(version) === -1;
+        }
+    }
+
+    /**
+     * Compares the passed version with the current browser version.
+     *
+     * @param {string} version - The version to compare with.
+     * @returns {boolean|undefined} - Returns true if the current version is
+     * equal to the passed version and false otherwise.
+     */
+    isVersionEqualTo(version) {
+        if (this._version) {
+            return this.compareVersion(version) === 0;
+        }
+    }
+}

modules/browser/ExternalBrowserCapabilities.js

+import BrowserCapabilities from './BrowserCapabilities';
+
+/**
+ * API for checking the capabilities for Jitsi Meet for the current or passed
+ * browser.
+ */
+export default class ExternalBrowserCapabilities {
+    /**
+     * Creates new ExternalBrowserCapabilities instance.
+     *
+     * @param {boolean} [isUsingIFrame] - True if Jitsi Meet is loaded in iframe
+     * and false otherwise.
+     * @param {Object} [browserInfo] - Information about the browser.
+     * @param {string} browserInfo.name - The name of the browser.
+     * @param {string} browserInfo.version - The version of the browser.
+     */
+    constructor(isUsingIFrame, browserInfo) {
+        this._capabilities
+            = new BrowserCapabilities(isUsingIFrame, browserInfo);
+    }
+
+    /**
+     * Checks whether the browser is supported by Jitsi Meet.
+     *
+     * @returns {boolean}
+     */
+    isSupported() {
+        return this._capabilities.isSupported();
+    }
+
+    /**
+     * Checks whether the browser supports incoming audio.
+     *
+     * @returns {boolean}
+     */
+    supportsAudioIn() {
+        return this._capabilities.supportsAudioIn();
+    }
+
+    /**
+     * Checks whether the browser supports outgoing audio.
+     *
+     * @returns {boolean}
+     */
+    supportsAudioOut() {
+        return this._capabilities.supportsAudioOut();
+    }
+
+    /**
+     * Checks whether the browser supports video.
+     *
+     * @returns {boolean}
+     */
+    supportsVideo() {
+        return this._capabilities.supportsVideo();
+    }
+
+    /**
+     * Checks whether the browser supports screen sharing.
+     *
+     * @returns {boolean}
+     */
+    supportsScreenSharing() {
+        return this._capabilities.supportsScreenSharing();
+    }
+}

modules/browser/browsers.js

+// TODO: Maybe fix the values to 'Chrome', 'Internet Explorer', etc. Currently
+// this values needs to be as they are becuse they are going to analytics,
+// callstats, etc.
+
+export const CHROME = 'chrome';
+
+export const OPERA = 'opera';
+
+export const FIREFOX = 'firefox';
+
+export const INTERNET_EXPLORER = 'iexplorer';
+
+export const EDGE = 'edge';
+
+export const SAFARI = 'safari';
+
+export const NWJS = 'nwjs';
+
+export const ELECTRON = 'electron';
+
+export const REACT_NATIVE = 'react-native';

modules/browser/capabilities-structure.md

+capabilities.json stores the capabilities of Jitsi Meet per browser per version of the browser. The JSON structure is the following:
+```
+{
+    <browser_name>: Array<CapabilitiesByVersion>
+}
+```
+
+If there is no entry for a browser, this browser is considered unsupported. The browser name should be compatible with the names returned by the bowser package.
+
+The `CapabilitiesByVersion` objects have the following structure:
+```
+{
+    version: <browser_version>,
+    capabilities: {
+        ...
+    },
+    iframeCapabilities: {
+        ...
+    }
+}
+```
+`CapabilitiesByVersion` objects are storing the capabilities for a range of versions. The range of versions for a `CapabilitiesByVersion` object is from the version filled in the previous `CapabilitiesByVersion` object to the version filled in the current object.  For example:
+```
+"Chrome": [
+    {
+        "version": "1.0.0.0",
+        capabilities: A
+    },
+    {
+        "version": "3.0.0.0",
+        capabilities: B
+    },
+    {
+        capabilities: C
+    }
+]
+```
+
+For versions of Chrome lower or equal to 1.0.0.0 will have capabilities A, versions between 1.0.0.0 and 3.0.0.0 will have capabilities B and versions greater than 3.0.0.0 will have capabilities C. The last element in the array doesn't have a version property because it stores information for any version that is greater than 3.0.0.0.
+
+The capabilities property of `CapabilitiesByVersion` object stores the capabilities for the use case where Jitsi Meet is not loaded in an iframe. For the use case when Jitsi Meet is loaded in an iframe the capabilities are calculated by `Object.assign(capabilities, iframeCapabilities)`.
+
+
+If the calculated capabilities are `undefined` this version is considered  unsupported.

modules/browser/capabilities.json

+{
+    "safari": [
+        {"version": "6.3" },
+        {
+            "version": "10.2",
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        },
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": false,
+                "videoOut": false,
+                "screenSharing": false
+            },
+            "iframeCapabilities": {
+                "isSupported": false
+            }
+        }
+    ],
+    "chrome":
+    [
+        {"version": "34" },
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        }
+    ],
+    "opera":
+    [
+        {"version": "22" },
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": false
+            }
+        }
+    ],
+    "firefox": [
+        {"version": "52.4" },
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        }
+    ],
+    "iexplorer": [
+        {"version": "9" },
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        }
+    ],
+    "edge": [
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": false
+            }
+        }
+    ],
+    "nwjs": [
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        }
+    ],
+    "electron": [
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": true
+            }
+        }
+    ],
+    "react-native": [
+        {
+            "capabilities": {
+                "audioIn": true,
+                "audioOut": true,
+                "videoIn": true,
+                "videoOut": true,
+                "screenSharing": false
+            }
+        }
+    ]
+}

modules/browser/index.js

+import BrowserCapabilities from './BrowserCapabilities';
+
+// Export for browser_capabilities bundle.
+export ExternalBrowserCapabilities from './ExternalBrowserCapabilities';
+
+export * as browsers from './browsers';
+export default new BrowserCapabilities();

modules/connectivity/ParticipantConnectionStatus.js

 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import * as MediaType from '../../service/RTC/MediaType';
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import Statistics from '../statistics/statistics';
 
         }
 
         // Logic when isVideoTrackFrozen is supported
-        if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+        if (browser.supportsVideoMuteOnConnInterrupted()) {
             if (!isVideoTrackFrozen) {
                 // If the video is playing we're good
                 return ParticipantConnectionStatus.ACTIVE;
      * @private
      */
     static _getNewStateForP2PMode(isVideoMuted, isVideoTrackFrozen) {
-        if (!RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+        if (!browser.supportsVideoMuteOnConnInterrupted()) {
             // There's no way to detect problems in P2P when there's no video
             // track frozen detection...
             return ParticipantConnectionStatus.ACTIVE;
         // On some browsers MediaStreamTrack trigger "onmute"/"onunmute"
         // events for video type tracks when they stop receiving data which is
         // often a sign that remote user is having connectivity issues
-        if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+        if (browser.supportsVideoMuteOnConnInterrupted()) {
 
             this._onTrackRtcMuted = this.onTrackRtcMuted.bind(this);
             this.rtc.addListener(
             RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
             this._onEndpointConnStatusChanged);
 
-        if (RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+        if (browser.supportsVideoMuteOnConnInterrupted()) {
             this.rtc.removeListener(
                 RTCEvents.REMOTE_TRACK_MUTE,
                 this._onTrackRtcMuted);
      *
      */
     isVideoTrackFrozen(participant) {
-        if (!RTCBrowserType.isVideoMuteOnConnInterruptedSupported()) {
+        if (!browser.supportsVideoMuteOnConnInterrupted()) {
             return false;
         }
 

modules/statistics/AnalyticsAdapter.js

     TYPE_UI
 } from '../../service/statistics/AnalyticsEvents';
 import { getLogger } from 'jitsi-meet-logger';
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import Settings from '../settings/Settings';
 
 const MAX_CACHE_SIZE = 100;
         this.addPermanentProperties({
             'callstats_name': Settings.callStatsUserName,
             'user_agent': navigator.userAgent,
-            'browser_name': RTCBrowserType.getBrowserName()
+            'browser_name': browser.getName()
         });
     }
 

modules/statistics/AvgRTPStatsReporter.js

     from '../../service/connectivity/ConnectionQualityEvents';
 import * as ConferenceEvents from '../../JitsiConferenceEvents';
 import * as MediaType from '../../service/RTC/MediaType';
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import Statistics from './statistics';
 import * as VideoType from '../../service/RTC/VideoType';
 
             return;
         }
 
-        if (RTCBrowserType.supportsRTTStatistics()) {
+        if (browser.supportsRTTStatistics()) {
             if (data.transport && data.transport.length) {
                 this._avgRTT.addNext(data.transport[0].rtt);
             }
         this._sampleIdx += 1;
 
         if (this._sampleIdx >= this._n) {
-            if (RTCBrowserType.supportsRTTStatistics()) {
+            if (browser.supportsRTTStatistics()) {
                 const conference = this._avgRtpStatsReporter._conference;
 
                 const batchReport = {
         this._avgVideoBitrateUp.addNext(bitrate.video.upload);
         this._avgVideoBitrateDown.addNext(bitrate.video.download);
 
-        if (RTCBrowserType.supportsBandwidthStatistics()) {
+        if (browser.supportsBandwidthStatistics()) {
             this._avgBandwidthUp.addNext(bandwidth.upload);
             this._avgBandwidthDown.addNext(bandwidth.download);
         }
             this._avgVideoBitrateUp.appendReport(batchReport);
             this._avgVideoBitrateDown.appendReport(batchReport);
 
-            if (RTCBrowserType.supportsBandwidthStatistics()) {
+            if (browser.supportsBandwidthStatistics()) {
                 this._avgBandwidthUp.appendReport(batchReport);
                 this._avgBandwidthDown.appendReport(batchReport);
             }

modules/statistics/CallStats.js

 /* global callstats */
 
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
                 // NOTE it is not safe to log whole objects on react-native as
                 // those contain too many circular references and may crash
                 // the app.
-                if (!RTCBrowserType.isReactNative()) {
+                if (!browser.isReactNative()) {
                     console && console.debug('reportError', pc, cs, type);
                 }
             } else {
             // imports are only allowed at top-level, so we must use require
             // here. Sigh.
             const CallStatsBackend
-                = RTCBrowserType.isReactNative()
+                = browser.isReactNative()
                     ? require('react-native-callstats/callstats')
                     : callstats;
 
                 configParams = {
                     applicationVersion:
                         `${options.applicationName} (${
-                            RTCBrowserType.getBrowserName()})`
+                            browser.getName()})`
                 };
             }
 

modules/statistics/LocalStatsCollector.js

  * Provides statistics for the local stream.
  */
 
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 
 /**
  * Size of the webaudio analyzer buffer.
  * @returns {boolean}
  */
 LocalStatsCollector.isLocalStatsSupported = function() {
-    return Boolean(context && !RTCBrowserType.isTemasysPluginUsed());
+    return Boolean(context && !browser.isTemasysPluginUsed());
 };

modules/statistics/RTPStatsCollector.js

-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser, { browsers } from '../browser';
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /* Whether we support the browser we are running into for logging statistics */
-const browserSupported = RTCBrowserType.isChrome()
-        || RTCBrowserType.isOpera() || RTCBrowserType.isFirefox()
-        || RTCBrowserType.isNWJS() || RTCBrowserType.isElectron()
-        || RTCBrowserType.isTemasysPluginUsed() || RTCBrowserType.isEdge();
+const browserSupported = browser.isChrome()
+        || browser.isOpera() || browser.isFirefox()
+        || browser.isNWJS() || browser.isElectron()
+        || browser.isTemasysPluginUsed() || browser.isEdge();
 
 /**
  * The lib-jitsi-meet browser-agnostic names of the browser-specific keys
- * reported by RTCPeerConnection#getStats mapped by RTCBrowserType.
+ * reported by RTCPeerConnection#getStats mapped by browser.
  */
 const KEYS_BY_BROWSER_TYPE = {};
 
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
+KEYS_BY_BROWSER_TYPE[browsers.FIREFOX] = {
     'ssrc': 'ssrc',
     'packetsReceived': 'packetsReceived',
     'packetsLost': 'packetsLost',
     'bytesSent': 'bytesSent',
     'framerateMean': 'framerateMean'
 };
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME] = {
+KEYS_BY_BROWSER_TYPE[browsers.CHROME] = {
     'receiveBandwidth': 'googAvailableReceiveBandwidth',
     'sendBandwidth': 'googAvailableSendBandwidth',
     'remoteAddress': 'googRemoteAddress',
     'remoteCandidateType': 'googRemoteCandidateType',
     'localCandidateType': 'googLocalCandidateType'
 };
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_EDGE] = {
+KEYS_BY_BROWSER_TYPE[browsers.EDGE] = {
     'sendBandwidth': 'googAvailableSendBandwidth',
     'remoteAddress': 'remoteAddress',
     'transportType': 'protocol',
     'audioOutputLevel': 'audioLevel',
     'currentRoundTripTime': 'roundTripTime'
 };
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_OPERA]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_NWJS]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_ELECTRON]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_IEXPLORER]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_SAFARI]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
-KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_REACT_NATIVE]
-    = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.OPERA]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.NWJS]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.ELECTRON]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.IEXPLORER]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.SAFARI]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
+KEYS_BY_BROWSER_TYPE[browsers.REACT_NATIVE]
+    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 
 /**
  * Calculates packet lost percent using the number of lost packets and the
         eventEmitter) {
     // StatsCollector depends entirely on the format of the reports returned by
     // RTCPeerConnection#getStats. Given that the value of
-    // RTCBrowserType#getBrowserType() is very unlikely to change at runtime, it
+    // browser#getName() is very unlikely to change at runtime, it
     // makes sense to discover whether StatsCollector supports the executing
     // browser as soon as possible. Otherwise, (1) getStatValue would have to
     // needlessly check a "static" condition multiple times very very often and
     // reported multiple times very very often too late in the execution in some
     // totally unrelated callback.
     /**
-     * The RTCBrowserType supported by this StatsCollector. In other words, the
-     * RTCBrowserType of the browser which initialized this StatsCollector
+     * The browser type supported by this StatsCollector. In other words, the
+     * type of the browser which initialized this StatsCollector
      * instance.
      * @private
      */
-    this._browserType = RTCBrowserType.getBrowserType();
+    this._browserType = browser.getName();
     const keys = KEYS_BY_BROWSER_TYPE[this._browserType];
 
     if (!keys) {
     let itemStatByKey;
 
     switch (this._browserType) {
-    case RTCBrowserType.RTC_BROWSER_CHROME:
-    case RTCBrowserType.RTC_BROWSER_OPERA:
-    case RTCBrowserType.RTC_BROWSER_NWJS:
-    case RTCBrowserType.RTC_BROWSER_ELECTRON:
+    case browsers.CHROME:
+    case browsers.OPERA:
+    case browsers.NWJS:
+    case browsers.ELECTRON:
         // TODO What about other types of browser which are based on Chrome such
         // as NW.js? Every time we want to support a new type browser we have to
         // go and add more conditions (here and in multiple other places).
         // retrieve the value associated with a specific key.
         itemStatByKey = (item, key) => item.stat(key);
         break;
-    case RTCBrowserType.RTC_BROWSER_REACT_NATIVE:
+    case browsers.REACT_NATIVE:
         // The implementation provided by react-native-webrtc follows the
         // Objective-C WebRTC API: RTCStatsReport has a values property of type
         // Array in which each element is a key-value pair.
             return value;
         };
         break;
-    case RTCBrowserType.RTC_BROWSER_EDGE:
+    case browsers.EDGE:
         itemStatByKey = (item, key) => item[key];
         break;
     default:
 
         // NOTE: In Edge, stats with type "inboundrtp" and "outboundrtp" are
         // completely useless, so ignore them.
-        if (RTCBrowserType.isEdge()
+        if (browser.isEdge()
             && (now.type === 'inboundrtp' || now.type === 'outboundrtp')) {
             continue;
         }
         // In new W3 stats spec, type="track" has a remoteSource boolean
         // property.
         // Edge uses the new format, so skip this check.
-        if (!RTCBrowserType.isEdge()
+        if (!browser.isEdge()
                 && (now.isRemote === true || now.remoteSource === true)) {
             continue;
         }
             // In Edge the range is -100..0 (-100 == silence) measured in dB,
             // so convert to linear. The levels are set to 0 for remote tracks,
             // so don't convert those, since 0 means "the maximum" in Edge.
-            if (RTCBrowserType.isEdge()) {
+            if (browser.isEdge()) {
                 audioLevel = audioLevel < 0 ? Math.pow(10, audioLevel / 20) : 0;
 
             // TODO: Can't find specs about what this value really is, but it

modules/statistics/statistics.js

 import LocalStats from './LocalStatsCollector';
 import RTPStats from './RTPStatsCollector';
 
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import Settings from '../settings/Settings';
 import ScriptUtil from '../util/ScriptUtil';
 import JitsiTrackError from '../../JitsiTrackError';
             // requests to any third parties.
             && (Statistics.disableThirdPartyRequests !== true);
     if (this.callStatsIntegrationEnabled) {
-        if (RTCBrowserType.isReactNative()) {
+        if (browser.isReactNative()) {
             _initCallStatsBackend(this.options);
         } else {
             loadCallStatsAPI(this.options);

modules/xmpp/SDPUtil.js

 const logger = getLogger(__filename);
 
 import RandomUtil from '../util/RandomUtil';
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 
 const SDPUtil = {
     filterSpecialChars(text) {
 
         // use tcp candidates for FF
 
-        if (RTCBrowserType.isFirefox() && protocol.toLowerCase() === 'ssltcp') {
+        if (browser.isFirefox() && protocol.toLowerCase() === 'ssltcp') {
             protocol = 'tcp';
         }
 

modules/xmpp/moderator.js

     = require('../../service/authentication/AuthenticationEvents');
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import Settings from '../settings/Settings';
 
 /**
         break;
     }
 
-    if (openSctp && !RTCBrowserType.supportsDataChannels()) {
+    if (openSctp && !browser.supportsDataChannels()) {
         openSctp = false;
     }
 

modules/xmpp/xmpp.js

 import RandomUtil from '../util/RandomUtil';
 import * as JitsiConnectionErrors from '../../JitsiConnectionErrors';
 import * as JitsiConnectionEvents from '../../JitsiConnectionEvents';
-import RTCBrowserType from '../RTC/RTCBrowserType';
+import browser from '../browser';
 import initEmuc from './strophe.emuc';
 import initJingle from './strophe.jingle';
 import initStropheUtil from './strophe.util';
         this.caps.addFeature('urn:xmpp:jingle:apps:rtp:audio');
         this.caps.addFeature('urn:xmpp:jingle:apps:rtp:video');
 
-        if (!this.options.disableRtx && RTCBrowserType.supportsRtx()) {
+        if (!this.options.disableRtx && browser.supportsRtx()) {
             this.caps.addFeature('urn:ietf:rfc:4588');
         }
 
         // this.caps.addFeature('urn:ietf:rfc:5576'); // a=ssrc
 
         // Enable Lipsync ?
-        if (RTCBrowserType.isChrome() && this.options.enableLipSync !== false) {
+        if (browser.isChrome() && this.options.enableLipSync !== false) {
             logger.info('Lip-sync enabled !');
             this.caps.addFeature('http://jitsi.org/meet/lipsync');
         }

package.json

     "babel-loader": "7.1.2",
     "babel-preset-env": "1.6.1",
     "babel-preset-stage-1": "6.24.1",
+    "bowser": "1.9.1",
     "core-js": "2.5.1",
     "eslint": "4.12.1",
     "eslint-config-jitsi": "github:jitsi/eslint-config-jitsi#v0.1",

webpack.config.js

     }));
 }
 
-module.exports = {
+const config = {
     devtool: 'source-map',
-    entry: {
-        'lib-jitsi-meet': './index.js'
-    },
     module: {
         rules: [ {
             // Version this build of the lib-jitsi-meet library.
     },
     output: {
         filename: `[name]${minimize ? '.min' : ''}.js`,
-        library: 'JitsiMeetJS',
-        libraryTarget: 'umd',
         sourceMapFilename: `[name].${minimize ? 'min' : 'js'}.map`
     },
     plugins
 };
+
+module.exports = [
+    Object.assign({}, config, {
+        entry: {
+            'lib-jitsi-meet': './index.js'
+        },
+        output: Object.assign({}, config.output, {
+            library: 'JitsiMeetJS',
+            libraryTarget: 'umd'
+        })
+    }),
+
+    // The Webpack configuration to bundle browser_capabilities.js (API for
+    // browser capabilities).
+    Object.assign({}, config, {
+        entry: {
+            'browser_capabilities':
+                './modules/browser/index.js'
+        },
+        output: Object.assign({}, config.output, {
+            library: 'BrowserCapabilities',
+            libraryExport: 'ExternalBrowserCapabilities',
+            libraryTarget: 'umd'
+        })
+    })
+];