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.     const mediaSource = window.ManagedMediaSource || window.MediaSource;
  27.     // Browsers that lack a media source implementation will have no reference
  28.     // to |window.MediaSource|. Platforms that we see having problematic media
  29.     // source implementations will have this reference removed via a polyfill.
  30.     if (!mediaSource) {
  31.       return false;
  32.     }
  34.     // Some very old MediaSource implementations didn't have isTypeSupported.
  35.     if (!mediaSource.isTypeSupported) {
  36.       return false;
  37.     }
  39.     return true;
  40.   }
  42.   /**
  43.    * Returns true if the media type is supported natively by the platform.
  44.    *
  45.    * @param {string} mimeType
  46.    * @return {boolean}
  47.    */
  48.   static supportsMediaType(mimeType) {
  49.     const video = shaka.util.Platform.anyMediaElement();
  50.     return video.canPlayType(mimeType) != '';
  51.   }
  53.   /**
  54.    * Check if the current platform is MS Edge.
  55.    *
  56.    * @return {boolean}
  57.    */
  58.   static isEdge() {
  59.     // Legacy Edge contains "Edge/version".
  60.     // Chromium-based Edge contains "Edg/version" (no "e").
  61.     if (navigator.userAgent.match(/Edge?\//)) {
  62.       return true;
  63.     }
  65.     return false;
  66.   }
  68.   /**
  69.    * Check if the current platform is Legacy Edge.
  70.    *
  71.    * @return {boolean}
  72.    */
  73.   static isLegacyEdge() {
  74.     // Legacy Edge contains "Edge/version".
  75.     // Chromium-based Edge contains "Edg/version" (no "e").
  76.     if (navigator.userAgent.match(/Edge\//)) {
  77.       return true;
  78.     }
  80.     return false;
  81.   }
  83.   /**
  84.    * Check if the current platform is MS IE.
  85.    *
  86.    * @return {boolean}
  87.    */
  88.   static isIE() {
  89.     return shaka.util.Platform.userAgentContains_('Trident/');
  90.   }
  92.   /**
  93.    * Check if the current platform is an Xbox One.
  94.    *
  95.    * @return {boolean}
  96.    */
  97.   static isXboxOne() {
  98.     return shaka.util.Platform.userAgentContains_('Xbox One');
  99.   }
  101.   /**
  102.    * Check if the current platform is a Tizen TV.
  103.    *
  104.    * @return {boolean}
  105.    */
  106.   static isTizen() {
  107.     return shaka.util.Platform.userAgentContains_('Tizen');
  108.   }
  110.   /**
  111.    * Check if the current platform is a Tizen 6 TV.
  112.    *
  113.    * @return {boolean}
  114.    */
  115.   static isTizen6() {
  116.     return shaka.util.Platform.userAgentContains_('Tizen 6');
  117.   }
  119.   /**
  120.    * Check if the current platform is a Tizen 5.0 TV.
  121.    *
  122.    * @return {boolean}
  123.    */
  124.   static isTizen5_0() {
  125.     return shaka.util.Platform.userAgentContains_('Tizen 5.0');
  126.   }
  128.   /**
  129.    * Check if the current platform is a Tizen 5 TV.
  130.    *
  131.    * @return {boolean}
  132.    */
  133.   static isTizen5() {
  134.     return shaka.util.Platform.userAgentContains_('Tizen 5');
  135.   }
  137.   /**
  138.    * Check if the current platform is a Tizen 4 TV.
  139.    *
  140.    * @return {boolean}
  141.    */
  142.   static isTizen4() {
  143.     return shaka.util.Platform.userAgentContains_('Tizen 4');
  144.   }
  146.   /**
  147.    * Check if the current platform is a Tizen 3 TV.
  148.    *
  149.    * @return {boolean}
  150.    */
  151.   static isTizen3() {
  152.     return shaka.util.Platform.userAgentContains_('Tizen 3');
  153.   }
  155.   /**
  156.    * Check if the current platform is a Tizen 2 TV.
  157.    *
  158.    * @return {boolean}
  159.    */
  160.   static isTizen2() {
  161.     return shaka.util.Platform.userAgentContains_('Tizen 2');
  162.   }
  164.   /**
  165.    * Check if the current platform is a WebOS.
  166.    *
  167.    * @return {boolean}
  168.    */
  169.   static isWebOS() {
  170.     return shaka.util.Platform.userAgentContains_('Web0S');
  171.   }
  173.   /**
  174.    * Check if the current platform is a WebOS 3.
  175.    *
  176.    * @return {boolean}
  177.    */
  178.   static isWebOS3() {
  179.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  180.     return shaka.util.Platform.isWebOS() &&
  181.         shaka.util.Platform.chromeVersion() === 38;
  182.   }
  184.   /**
  185.    * Check if the current platform is a WebOS 4.
  186.    *
  187.    * @return {boolean}
  188.    */
  189.   static isWebOS4() {
  190.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  191.     return shaka.util.Platform.isWebOS() &&
  192.         shaka.util.Platform.chromeVersion() === 53;
  193.   }
  195.   /**
  196.    * Check if the current platform is a WebOS 5.
  197.    *
  198.    * @return {boolean}
  199.    */
  200.   static isWebOS5() {
  201.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  202.     return shaka.util.Platform.isWebOS() &&
  203.         shaka.util.Platform.chromeVersion() === 68;
  204.   }
  206.   /**
  207.    * Check if the current platform is a Google Chromecast.
  208.    *
  209.    * @return {boolean}
  210.    */
  211.   static isChromecast() {
  212.     return shaka.util.Platform.userAgentContains_('CrKey');
  213.   }
  215.   /**
  216.    * Check if the current platform is a Google Chromecast with Android
  217.    * (i.e. Chromecast with GoogleTV).
  218.    *
  219.    * @return {boolean}
  220.    */
  221.   static isAndroidCastDevice() {
  222.     const Platform = shaka.util.Platform;
  223.     return Platform.isChromecast() && Platform.isAndroid();
  224.   }
  226.   /**
  227.    * Check if the current platform is a Google Chromecast with Fuchsia
  228.    * (i.e. Google Nest Hub).
  229.    *
  230.    * @return {boolean}
  231.    */
  232.   static isFuchsiaCastDevice() {
  233.     const Platform = shaka.util.Platform;
  234.     return Platform.isChromecast() && Platform.isFuchsia();
  235.   }
  237.   /**
  238.    * Returns a major version number for Chrome, or Chromium-based browsers.
  239.    *
  240.    * For example:
  241.    *   - Chrome 106.0.5249.61 returns 106.
  242.    *   - Edge 106.0.1370.34 returns 106 (since this is based on Chromium).
  243.    *   - Safari returns null (since this is independent of Chromium).
  244.    *
  245.    * @return {?number} A major version number or null if not Chromium-based.
  246.    */
  247.   static chromeVersion() {
  248.     if (!shaka.util.Platform.isChrome()) {
  249.       return null;
  250.     }
  252.     // Looking for something like "Chrome/106.0.0.0".
  253.     const match = navigator.userAgent.match(/Chrome\/(\d+)/);
  254.     if (match) {
  255.       return parseInt(match[1], /* base= */ 10);
  256.     }
  258.     return null;
  259.   }
  261.   /**
  262.    * Check if the current platform is Google Chrome.
  263.    *
  264.    * @return {boolean}
  265.    */
  266.   static isChrome() {
  267.     // The Edge Legacy user agent will also contain the "Chrome" keyword, so we
  268.     // need to make sure this is not Edge Legacy.
  269.     return shaka.util.Platform.userAgentContains_('Chrome') &&
  270.            !shaka.util.Platform.isLegacyEdge();
  271.   }
  273.   /**
  274.    * Check if the current platform is Firefox.
  275.    *
  276.    * @return {boolean}
  277.    */
  278.   static isFirefox() {
  279.     return shaka.util.Platform.userAgentContains_('Firefox');
  280.   }
  282.   /**
  283.    * Check if the current platform is from Apple.
  284.    *
  285.    * Returns true on all iOS browsers and on desktop Safari.
  286.    *
  287.    * Returns false for non-Safari browsers on macOS, which are independent of
  288.    * Apple.
  289.    *
  290.    * @return {boolean}
  291.    */
  292.   static isApple() {
  293.     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
  294.         !shaka.util.Platform.isTizen() &&
  295.         !shaka.util.Platform.isEOS() &&
  296.         !shaka.util.Platform.isAPL() &&
  297.         !shaka.util.Platform.isVirginMedia() &&
  298.         !shaka.util.Platform.isOrange() &&
  299.         !shaka.util.Platform.isPS4() &&
  300.         !shaka.util.Platform.isAmazonFireTV() &&
  301.         !shaka.util.Platform.isWPE();
  302.   }
  304.   /**
  305.    * Check if the current platform is Playstation 5.
  306.    *
  307.    * Returns true on Playstation 5 browsers.
  308.    *
  309.    * Returns false for Playstation 5 browsers
  310.    *
  311.    * @return {boolean}
  312.    */
  313.   static isPS5() {
  314.     return shaka.util.Platform.userAgentContains_('PlayStation 5');
  315.   }
  317.   /**
  318.    * Check if the current platform is Playstation 4.
  319.    */
  320.   static isPS4() {
  321.     return shaka.util.Platform.userAgentContains_('PlayStation 4');
  322.   }
  324.   /**
  325.    * Check if the current platform is Hisense.
  326.    */
  327.   static isHisense() {
  328.     return shaka.util.Platform.userAgentContains_('Hisense') ||
  329.         shaka.util.Platform.userAgentContains_('VIDAA');
  330.   }
  332.   /**
  333.    * Check if the current platform is Virgin Media device.
  334.    */
  335.   static isVirginMedia() {
  336.     return shaka.util.Platform.userAgentContains_('VirginMedia');
  337.   }
  339.   /**
  340.    * Check if the current platform is Orange.
  341.    */
  342.   static isOrange() {
  343.     return shaka.util.Platform.userAgentContains_('SOPOpenBrowser');
  344.   }
  346.   /**
  347.    * Check if the current platform is Amazon Fire TV.
  348.    * https://developer.amazon.com/docs/fire-tv/identify-amazon-fire-tv-devices.html
  349.    *
  350.    * @return {boolean}
  351.    */
  352.   static isAmazonFireTV() {
  353.     return shaka.util.Platform.userAgentContains_('AFT');
  354.   }
  356.   /**
  357.    * Check if the current platform is Comcast X1.
  358.    * @return {boolean}
  359.    */
  360.   static isWPE() {
  361.     return shaka.util.Platform.userAgentContains_('WPE');
  362.   }
  364.   /**
  365.    * Returns a major version number for Safari, or Safari-based iOS browsers.
  366.    *
  367.    * For example:
  368.    *   - Safari 13.0.4 on macOS returns 13.
  369.    *   - Safari on iOS 13.3.1 returns 13.
  370.    *   - Chrome on iOS 13.3.1 returns 13 (since this is based on Safari/WebKit).
  371.    *   - Chrome on macOS returns null (since this is independent of Apple).
  372.    *
  373.    * Returns null on Firefox on iOS, where this version information is not
  374.    * available.
  375.    *
  376.    * @return {?number} A major version number or null if not iOS.
  377.    */
  378.   static safariVersion() {
  379.     // All iOS browsers and desktop Safari will return true for isApple().
  380.     if (!shaka.util.Platform.isApple()) {
  381.       return null;
  382.     }
  384.     // This works for iOS Safari and desktop Safari, which contain something
  385.     // like "Version/13.0" indicating the major Safari or iOS version.
  386.     let match = navigator.userAgent.match(/Version\/(\d+)/);
  387.     if (match) {
  388.       return parseInt(match[1], /* base= */ 10);
  389.     }
  391.     // This works for all other browsers on iOS, which contain something like
  392.     // "OS 13_3" indicating the major & minor iOS version.
  393.     match = navigator.userAgent.match(/OS (\d+)(?:_\d+)?/);
  394.     if (match) {
  395.       return parseInt(match[1], /* base= */ 10);
  396.     }
  398.     return null;
  399.   }
  401.   /**
  402.    * Check if the current platform is Apple Safari
  403.    * or Safari-based iOS browsers.
  404.    *
  405.    * @return {boolean}
  406.    */
  407.   static isSafari() {
  408.     return !!shaka.util.Platform.safariVersion();
  409.   }
  411.   /**
  412.    * Check if the current platform is an EOS set-top box.
  413.    *
  414.    * @return {boolean}
  415.    */
  416.   static isEOS() {
  417.     return shaka.util.Platform.userAgentContains_('PC=EOS');
  418.   }
  420.   /**
  421.    * Check if the current platform is an APL set-top box.
  422.    *
  423.    * @return {boolean}
  424.    */
  425.   static isAPL() {
  426.     return shaka.util.Platform.userAgentContains_('PC=APL');
  427.   }
  429.   /**
  430.    * Guesses if the platform is a mobile one (iOS or Android).
  431.    *
  432.    * @return {boolean}
  433.    */
  434.   static isMobile() {
  435.     if (/(?:iPhone|iPad|iPod|Android)/.test(navigator.userAgent)) {
  436.       // This is Android, iOS, or iPad < 13.
  437.       return true;
  438.     }
  440.     // Starting with iOS 13 on iPad, the user agent string no longer has the
  441.     // word "iPad" in it.  It looks very similar to desktop Safari.  This seems
  442.     // to be intentional on Apple's part.
  443.     // See: https://forums.developer.apple.com/thread/119186
  444.     //
  445.     // So if it's an Apple device with multi-touch support, assume it's a mobile
  446.     // device.  If some future iOS version starts masking their user agent on
  447.     // both iPhone & iPad, this clause should still work.  If a future
  448.     // multi-touch desktop Mac is released, this will need some adjustment.
  449.     //
  450.     // As of January 2020, this is mainly used to adjust the default UI config
  451.     // for mobile devices, so it's low risk if something changes to break this
  452.     // detection.
  453.     return shaka.util.Platform.isApple() && navigator.maxTouchPoints > 1;
  454.   }
  456.   /**
  457.    * Return true if the platform is a Mac, regardless of the browser.
  458.    *
  459.    * @return {boolean}
  460.    */
  461.   static isMac() {
  462.     // Try the newer standard first.
  463.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  464.       return navigator.userAgentData.platform.toLowerCase() == 'macos';
  465.     }
  466.     // Fall back to the old API, with less strict matching.
  467.     if (!navigator.platform) {
  468.       return false;
  469.     }
  470.     return navigator.platform.toLowerCase().includes('mac');
  471.   }
  473.   /**
  474.    * Return true if the platform is a Windows, regardless of the browser.
  475.    *
  476.    * @return {boolean}
  477.    */
  478.   static isWindows() {
  479.     // Try the newer standard first.
  480.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  481.       return navigator.userAgentData.platform.toLowerCase() == 'windows';
  482.     }
  483.     // Fall back to the old API, with less strict matching.
  484.     if (!navigator.platform) {
  485.       return false;
  486.     }
  487.     return navigator.platform.toLowerCase().includes('windows');
  488.   }
  490.   /**
  491.    * Return true if the platform is a Android, regardless of the browser.
  492.    *
  493.    * @return {boolean}
  494.    */
  495.   static isAndroid() {
  496.     return shaka.util.Platform.userAgentContains_('Android');
  497.   }
  499.   /**
  500.    * Return true if the platform is a Fuchsia, regardless of the browser.
  501.    *
  502.    * @return {boolean}
  503.    */
  504.   static isFuchsia() {
  505.     return shaka.util.Platform.userAgentContains_('Fuchsia');
  506.   }
  508.   /**
  509.    * Return true if the platform is controlled by a remote control.
  510.    *
  511.    * @return {boolean}
  512.    */
  513.   static isSmartTV() {
  514.     const Platform = shaka.util.Platform;
  515.     if (Platform.isTizen() || Platform.isWebOS() ||
  516.         Platform.isXboxOne() || Platform.isPS4() ||
  517.         Platform.isPS5() || Platform.isAmazonFireTV() ||
  518.         Platform.isEOS() || Platform.isAPL() ||
  519.         Platform.isVirginMedia() || Platform.isOrange() ||
  520.         Platform.isWPE() || Platform.isChromecast() ||
  521.         Platform.isHisense()) {
  522.       return true;
  523.     }
  524.     return false;
  525.   }
  527.   /**
  528.    * Check if the user agent contains a key. This is the best way we know of
  529.    * right now to detect platforms. If there is a better way, please send a
  530.    * PR.
  531.    *
  532.    * @param {string} key
  533.    * @return {boolean}
  534.    * @private
  535.    */
  536.   static userAgentContains_(key) {
  537.     const userAgent = navigator.userAgent || '';
  538.     return userAgent.includes(key);
  539.   }
  541.   /**
  542.    * For canPlayType queries, we just need any instance.
  543.    *
  544.    * First, use a cached element from a previous query.
  545.    * Second, search the page for one.
  546.    * Third, create a temporary one.
  547.    *
  548.    * Cached elements expire in one second so that they can be GC'd or removed.
  549.    *
  550.    * @return {!HTMLMediaElement}
  551.    */
  552.   static anyMediaElement() {
  553.     const Platform = shaka.util.Platform;
  554.     if (Platform.cachedMediaElement_) {
  555.       return Platform.cachedMediaElement_;
  556.     }
  558.     if (!Platform.cacheExpirationTimer_) {
  559.       Platform.cacheExpirationTimer_ = new shaka.util.Timer(() => {
  560.         Platform.cachedMediaElement_ = null;
  561.       });
  562.     }
  564.     Platform.cachedMediaElement_ = /** @type {HTMLMediaElement} */(
  565.       document.getElementsByTagName('video')[0] ||
  566.       document.getElementsByTagName('audio')[0]);
  568.     if (!Platform.cachedMediaElement_) {
  569.       Platform.cachedMediaElement_ = /** @type {!HTMLMediaElement} */(
  570.         document.createElement('video'));
  571.     }
  573.     Platform.cacheExpirationTimer_.tickAfter(/* seconds= */ 1);
  574.     return Platform.cachedMediaElement_;
  575.   }
  577.   /**
  578.    * Returns true if the platform requires encryption information in all init
  579.    * segments.  For such platforms, MediaSourceEngine will attempt to work
  580.    * around a lack of such info by inserting fake encryption information into
  581.    * initialization segments.
  582.    *
  583.    * @return {boolean}
  584.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  585.    */
  586.   static requiresEncryptionInfoInAllInitSegments() {
  587.     const Platform = shaka.util.Platform;
  588.     return Platform.isTizen() || Platform.isXboxOne() || Platform.isOrange();
  589.   }
  591.   /**
  592.    * Returns true if the platform supports SourceBuffer "sequence mode".
  593.    *
  594.    * @return {boolean}
  595.    */
  596.   static supportsSequenceMode() {
  597.     const Platform = shaka.util.Platform;
  598.     if (Platform.isTizen3() || Platform.isTizen2() ||
  599.         Platform.isWebOS3() || Platform.isPS4()) {
  600.       return false;
  601.     }
  602.     return true;
  603.   }
  605.   /**
  606.    * Returns if codec switching SMOOTH is known reliable device support.
  607.    *
  608.    * Some devices are known not to support `MediaSource.changeType`
  609.    * well. These devices should use the reload strategy. If a device
  610.    * reports that it supports `changeType` but support it reliabley
  611.    * it should be added to this list.
  612.    *
  613.    * @return {boolean}
  614.    */
  615.   static supportsSmoothCodecSwitching() {
  616.     const Platform = shaka.util.Platform;
  617.     if (Platform.isTizen2() || Platform.isTizen3() || Platform.isTizen4() ||
  618.         Platform.isTizen5() || Platform.isTizen6() || Platform.isWebOS3() ||
  619.         Platform.isWebOS4() || Platform.isWebOS5()) {
  620.       return false;
  621.     }
  622.     // Older chromecasts without GoogleTV seem to not support SMOOTH properly.
  623.     if (Platform.isChromecast() && !Platform.isAndroidCastDevice() &&
  624.         !Platform.isFuchsiaCastDevice()) {
  625.       return false;
  626.     }
  627.     // See: https://chromium-review.googlesource.com/c/chromium/src/+/4577759
  628.     if (Platform.isWindows() && Platform.isEdge()) {
  629.       return false;
  630.     }
  631.     return true;
  632.   }
  634.   /**
  635.    * Returns true if MediaKeys is polyfilled
  636.    *
  637.    * @return {boolean}
  638.    */
  639.   static isMediaKeysPolyfilled() {
  640.     if (window.shakaMediaKeysPolyfill) {
  641.       return true;
  642.     }
  644.     return false;
  645.   }
  646. };
  648. /** @private {shaka.util.Timer} */
  649. shaka.util.Platform.cacheExpirationTimer_ = null;
  651. /** @private {HTMLMediaElement} */
  652. shaka.util.Platform.cachedMediaElement_ = null;