Source: lib/util/platform.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Platform');
  9. goog.require('shaka.util.Timer');
  12. /**
  13.  * A wrapper for platform-specific functions.
  14.  *
  15.  * @final
  16.  */
  17. shaka.util.Platform = class {
  18.   /**
  19.    * Check if the current platform supports media source. We assume that if
  20.    * the current platform supports media source, then we can use media source
  21.    * as per its design.
  22.    *
  23.    * @return {boolean}
  24.    */
  25.   static supportsMediaSource() {
  26.     // Browsers that lack a media source implementation will have no reference
  27.     // to |window.MediaSource|. Platforms that we see having problematic media
  28.     // source implementations will have this reference removed via a polyfill.
  29.     if (!window.MediaSource) {
  30.       return false;
  31.     }
  33.     // Some very old MediaSource implementations didn't have isTypeSupported.
  34.     if (!MediaSource.isTypeSupported) {
  35.       return false;
  36.     }
  38.     return true;
  39.   }
  41.   /**
  42.    * Returns true if the media type is supported natively by the platform.
  43.    *
  44.    * @param {string} mimeType
  45.    * @return {boolean}
  46.    */
  47.   static supportsMediaType(mimeType) {
  48.     const video = shaka.util.Platform.anyMediaElement();
  49.     return video.canPlayType(mimeType) != '';
  50.   }
  52.   /**
  53.    * Check if the current platform is MS Edge.
  54.    *
  55.    * @return {boolean}
  56.    */
  57.   static isEdge() {
  58.     // Legacy Edge contains "Edge/version".
  59.     // Chromium-based Edge contains "Edg/version" (no "e").
  60.     if (navigator.userAgent.match(/Edge?\//)) {
  61.       return true;
  62.     }
  64.     return false;
  65.   }
  67.   /**
  68.    * Check if the current platform is Legacy Edge.
  69.    *
  70.    * @return {boolean}
  71.    */
  72.   static isLegacyEdge() {
  73.     // Legacy Edge contains "Edge/version".
  74.     // Chromium-based Edge contains "Edg/version" (no "e").
  75.     if (navigator.userAgent.match(/Edge\//)) {
  76.       return true;
  77.     }
  79.     return false;
  80.   }
  82.   /**
  83.    * Check if the current platform is MS IE.
  84.    *
  85.    * @return {boolean}
  86.    */
  87.   static isIE() {
  88.     return shaka.util.Platform.userAgentContains_('Trident/');
  89.   }
  91.   /**
  92.    * Check if the current platform is an Xbox One.
  93.    *
  94.    * @return {boolean}
  95.    */
  96.   static isXboxOne() {
  97.     return shaka.util.Platform.userAgentContains_('Xbox One');
  98.   }
  100.   /**
  101.    * Check if the current platform is a Tizen TV.
  102.    *
  103.    * @return {boolean}
  104.    */
  105.   static isTizen() {
  106.     return shaka.util.Platform.userAgentContains_('Tizen');
  107.   }
  109.   /**
  110.    * Check if the current platform is a Tizen 4 TV.
  111.    *
  112.    * @return {boolean}
  113.    */
  114.   static isTizen4() {
  115.     return shaka.util.Platform.userAgentContains_('Tizen 4');
  116.   }
  118.   /**
  119.    * Check if the current platform is a Tizen 3 TV.
  120.    *
  121.    * @return {boolean}
  122.    */
  123.   static isTizen3() {
  124.     return shaka.util.Platform.userAgentContains_('Tizen 3');
  125.   }
  127.   /**
  128.    * Check if the current platform is a Tizen 2 TV.
  129.    *
  130.    * @return {boolean}
  131.    */
  132.   static isTizen2() {
  133.     return shaka.util.Platform.userAgentContains_('Tizen 2');
  134.   }
  136.   /**
  137.    * Check if the current platform is a WebOS.
  138.    *
  139.    * @return {boolean}
  140.    */
  141.   static isWebOS() {
  142.     return shaka.util.Platform.userAgentContains_('Web0S');
  143.   }
  145.   /**
  146.    * Check if the current platform is a WebOS 3.
  147.    *
  148.    * @return {boolean}
  149.    */
  150.   static isWebOS3() {
  151.     // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
  152.     return shaka.util.Platform.userAgentContains_('Web0S') &&
  153.         shaka.util.Platform.userAgentContains_(
  154.             'Chrome/38.0.2125.122 Safari/537.36');
  155.   }
  157.   /**
  158.    * Check if the current platform is a Google Chromecast.
  159.    *
  160.    * @return {boolean}
  161.    */
  162.   static isChromecast() {
  163.     return shaka.util.Platform.userAgentContains_('CrKey');
  164.   }
  166.   /**
  167.    * Check if the current platform is a Android-based Cast devices.
  168.    *
  169.    * @return {boolean}
  170.    */
  171.   static isAndroidCastDevice() {
  172.     return shaka.util.Platform.isChromecast() &&
  173.         shaka.util.Platform.userAgentContains_('Android');
  174.   }
  176.   /**
  177.    * Check if the current platform is Google Chrome.
  178.    *
  179.    * @return {boolean}
  180.    */
  181.   static isChrome() {
  182.     // The Edge user agent will also contain the "Chrome" keyword, so we need
  183.     // to make sure this is not Edge.
  184.     return shaka.util.Platform.userAgentContains_('Chrome') &&
  185.            !shaka.util.Platform.isEdge();
  186.   }
  188.   /**
  189.    * Check if the current platform is from Apple.
  190.    *
  191.    * Returns true on all iOS browsers and on desktop Safari.
  192.    *
  193.    * Returns false for non-Safari browsers on macOS, which are independent of
  194.    * Apple.
  195.    *
  196.    * @return {boolean}
  197.    */
  198.   static isApple() {
  199.     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
  200.         !shaka.util.Platform.isTizen();
  201.   }
  203.   /**
  204.    * Check if the current platform is Playstation 5.
  205.    *
  206.    * Returns true on Playstation 5 browsers.
  207.    *
  208.    * Returns false for Playstation 5 browsers
  209.    *
  210.    * @return {boolean}
  211.    */
  212.   static isPS5() {
  213.     return shaka.util.Platform.userAgentContains_('PlayStation 5');
  214.   }
  216.   /**
  217.    * Returns a major version number for Safari, or Safari-based iOS browsers.
  218.    *
  219.    * For example:
  220.    *   - Safari 13.0.4 on macOS returns 13.
  221.    *   - Safari on iOS 13.3.1 returns 13.
  222.    *   - Chrome on iOS 13.3.1 returns 13 (since this is based on Safari/WebKit).
  223.    *   - Chrome on macOS returns null (since this is independent of Apple).
  224.    *
  225.    * Returns null on Firefox on iOS, where this version information is not
  226.    * available.
  227.    *
  228.    * @return {?number} A major version number or null if not iOS.
  229.    */
  230.   static safariVersion() {
  231.     // All iOS browsers and desktop Safari will return true for isApple().
  232.     if (!shaka.util.Platform.isApple()) {
  233.       return null;
  234.     }
  236.     // This works for iOS Safari and desktop Safari, which contain something
  237.     // like "Version/13.0" indicating the major Safari or iOS version.
  238.     let match = navigator.userAgent.match(/Version\/(\d+)/);
  239.     if (match) {
  240.       return parseInt(match[1], /* base= */ 10);
  241.     }
  243.     // This works for all other browsers on iOS, which contain something like
  244.     // "OS 13_3" indicating the major & minor iOS version.
  245.     match = navigator.userAgent.match(/OS (\d+)(?:_\d+)?/);
  246.     if (match) {
  247.       return parseInt(match[1], /* base= */ 10);
  248.     }
  250.     return null;
  251.   }
  253.   /**
  254.    * Check if the current platform is Apple Safari
  255.    * or Safari-based iOS browsers.
  256.    *
  257.    * @return {boolean}
  258.    */
  259.   static isSafari() {
  260.     return !!shaka.util.Platform.safariVersion();
  261.   }
  263.   /**
  264.    * Guesses if the platform is a mobile one (iOS or Android).
  265.    *
  266.    * @return {boolean}
  267.    */
  268.   static isMobile() {
  269.     if (/(?:iPhone|iPad|iPod|Android)/.test(navigator.userAgent)) {
  270.       // This is Android, iOS, or iPad < 13.
  271.       return true;
  272.     }
  274.     // Starting with iOS 13 on iPad, the user agent string no longer has the
  275.     // word "iPad" in it.  It looks very similar to desktop Safari.  This seems
  276.     // to be intentional on Apple's part.
  277.     // See: https://forums.developer.apple.com/thread/119186
  278.     //
  279.     // So if it's an Apple device with multi-touch support, assume it's a mobile
  280.     // device.  If some future iOS version starts masking their user agent on
  281.     // both iPhone & iPad, this clause should still work.  If a future
  282.     // multi-touch desktop Mac is released, this will need some adjustment.
  283.     //
  284.     // As of January 2020, this is mainly used to adjust the default UI config
  285.     // for mobile devices, so it's low risk if something changes to break this
  286.     // detection.
  287.     return shaka.util.Platform.isApple() && navigator.maxTouchPoints > 1;
  288.   }
  290.   /**
  291.    * Check if the user agent contains a key. This is the best way we know of
  292.    * right now to detect platforms. If there is a better way, please send a
  293.    * PR.
  294.    *
  295.    * @param {string} key
  296.    * @return {boolean}
  297.    * @private
  298.    */
  299.   static userAgentContains_(key) {
  300.     const userAgent = navigator.userAgent || '';
  301.     return userAgent.includes(key);
  302.   }
  304.   /**
  305.    * For canPlayType queries, we just need any instance.
  306.    *
  307.    * First, use a cached element from a previous query.
  308.    * Second, search the page for one.
  309.    * Third, create a temporary one.
  310.    *
  311.    * Cached elements expire in one second so that they can be GC'd or removed.
  312.    *
  313.    * @return {!HTMLMediaElement}
  314.    */
  315.   static anyMediaElement() {
  316.     const Platform = shaka.util.Platform;
  317.     if (Platform.cachedMediaElement_) {
  318.       return Platform.cachedMediaElement_;
  319.     }
  321.     if (!Platform.cacheExpirationTimer_) {
  322.       Platform.cacheExpirationTimer_ = new shaka.util.Timer(() => {
  323.         Platform.cachedMediaElement_ = null;
  324.       });
  325.     }
  327.     Platform.cachedMediaElement_ = /** @type {HTMLMediaElement} */(
  328.       document.getElementsByTagName('video')[0] ||
  329.       document.getElementsByTagName('audio')[0]);
  331.     if (!Platform.cachedMediaElement_) {
  332.       Platform.cachedMediaElement_ = /** @type {!HTMLMediaElement} */(
  333.         document.createElement('video'));
  334.     }
  336.     Platform.cacheExpirationTimer_.tickAfter(/* seconds= */ 1);
  337.     return Platform.cachedMediaElement_;
  338.   }
  340.   /**
  341.    * Returns true if the platform requires encryption information in all init
  342.    * segments.  For such platforms, MediaSourceEngine will attempt to work
  343.    * around a lack of such info by inserting fake encryption information into
  344.    * initialization segments.
  345.    *
  346.    * @return {boolean}
  347.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  348.    */
  349.   static requiresEncryptionInfoInAllInitSegments() {
  350.     const Platform = shaka.util.Platform;
  351.     return Platform.isTizen() || Platform.isXboxOne();
  352.   }
  354.   /**
  355.    * Returns true if MediaKeys is polyfilled
  356.    *
  357.    * @return {boolean}
  358.    */
  359.   static isMediaKeysPolyfilled() {
  360.     if (window.shakaMediaKeysPolyfill) {
  361.       return true;
  362.     }
  364.     return false;
  365.   }
  366. };
  368. /** @private {shaka.util.Timer} */
  369. shaka.util.Platform.cacheExpirationTimer_ = null;
  371. /** @private {HTMLMediaElement} */
  372. shaka.util.Platform.cachedMediaElement_ = null;