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.log');
  10. goog.require('shaka.util.DrmUtils');
  11. goog.require('shaka.util.Timer');
  14. /**
  15.  * A wrapper for platform-specific functions.
  16.  *
  17.  * @final
  18.  */
  19. shaka.util.Platform = class {
  20.   /**
  21.    * Check if the current platform supports media source. We assume that if
  22.    * the current platform supports media source, then we can use media source
  23.    * as per its design.
  24.    *
  25.    * @return {boolean}
  26.    */
  27.   static supportsMediaSource() {
  28.     const mediaSource = window.ManagedMediaSource || window.MediaSource;
  29.     // Browsers that lack a media source implementation will have no reference
  30.     // to |window.MediaSource|. Platforms that we see having problematic media
  31.     // source implementations will have this reference removed via a polyfill.
  32.     if (!mediaSource) {
  33.       return false;
  34.     }
  36.     // Some very old MediaSource implementations didn't have isTypeSupported.
  37.     if (!mediaSource.isTypeSupported) {
  38.       return false;
  39.     }
  41.     return true;
  42.   }
  44.   /**
  45.    * Returns true if the media type is supported natively by the platform.
  46.    *
  47.    * @param {string} mimeType
  48.    * @return {boolean}
  49.    */
  50.   static supportsMediaType(mimeType) {
  51.     const video = shaka.util.Platform.anyMediaElement();
  52.     return video.canPlayType(mimeType) != '';
  53.   }
  55.   /**
  56.    * Check if the current platform is MS Edge.
  57.    *
  58.    * @return {boolean}
  59.    */
  60.   static isEdge() {
  61.     // Legacy Edge contains "Edge/version".
  62.     // Chromium-based Edge contains "Edg/version" (no "e").
  63.     if (navigator.userAgent.match(/Edge?\//)) {
  64.       return true;
  65.     }
  67.     return false;
  68.   }
  70.   /**
  71.    * Check if the current platform is Legacy Edge.
  72.    *
  73.    * @return {boolean}
  74.    */
  75.   static isLegacyEdge() {
  76.     // Legacy Edge contains "Edge/version".
  77.     // Chromium-based Edge contains "Edg/version" (no "e").
  78.     if (navigator.userAgent.match(/Edge\//)) {
  79.       return true;
  80.     }
  82.     return false;
  83.   }
  85.   /**
  86.    * Check if the current platform is MS IE.
  87.    *
  88.    * @return {boolean}
  89.    */
  90.   static isIE() {
  91.     return shaka.util.Platform.userAgentContains_('Trident/');
  92.   }
  94.   /**
  95.    * Check if the current platform is an Xbox One.
  96.    *
  97.    * @return {boolean}
  98.    */
  99.   static isXboxOne() {
  100.     return shaka.util.Platform.userAgentContains_('Xbox One');
  101.   }
  103.   /**
  104.    * Check if the current platform is a Tizen TV.
  105.    *
  106.    * @return {boolean}
  107.    */
  108.   static isTizen() {
  109.     return shaka.util.Platform.userAgentContains_('Tizen');
  110.   }
  112.   /**
  113.    * Check if the current platform is a Tizen 6 TV.
  114.    *
  115.    * @return {boolean}
  116.    */
  117.   static isTizen6() {
  118.     return shaka.util.Platform.userAgentContains_('Tizen 6');
  119.   }
  121.   /**
  122.    * Check if the current platform is a Tizen 5.0 TV.
  123.    *
  124.    * @return {boolean}
  125.    */
  126.   static isTizen5_0() {
  127.     return shaka.util.Platform.userAgentContains_('Tizen 5.0');
  128.   }
  130.   /**
  131.    * Check if the current platform is a Tizen 5 TV.
  132.    *
  133.    * @return {boolean}
  134.    */
  135.   static isTizen5() {
  136.     return shaka.util.Platform.userAgentContains_('Tizen 5');
  137.   }
  139.   /**
  140.    * Check if the current platform is a Tizen 4 TV.
  141.    *
  142.    * @return {boolean}
  143.    */
  144.   static isTizen4() {
  145.     return shaka.util.Platform.userAgentContains_('Tizen 4');
  146.   }
  148.   /**
  149.    * Check if the current platform is a Tizen 3 TV.
  150.    *
  151.    * @return {boolean}
  152.    */
  153.   static isTizen3() {
  154.     return shaka.util.Platform.userAgentContains_('Tizen 3');
  155.   }
  157.   /**
  158.    * Check if the current platform is a Tizen 2 TV.
  159.    *
  160.    * @return {boolean}
  161.    */
  162.   static isTizen2() {
  163.     return shaka.util.Platform.userAgentContains_('Tizen 2');
  164.   }
  166.   /**
  167.    * Check if the current platform is a WebOS.
  168.    *
  169.    * @return {boolean}
  170.    */
  171.   static isWebOS() {
  172.     return shaka.util.Platform.userAgentContains_('Web0S');
  173.   }
  175.   /**
  176.    * Check if the current platform is a WebOS 3.
  177.    *
  178.    * @return {boolean}
  179.    */
  180.   static isWebOS3() {
  181.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  182.     return shaka.util.Platform.isWebOS() &&
  183.         shaka.util.Platform.chromeVersion() === 38;
  184.   }
  186.   /**
  187.    * Check if the current platform is a WebOS 4.
  188.    *
  189.    * @return {boolean}
  190.    */
  191.   static isWebOS4() {
  192.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  193.     return shaka.util.Platform.isWebOS() &&
  194.         shaka.util.Platform.chromeVersion() === 53;
  195.   }
  197.   /**
  198.    * Check if the current platform is a WebOS 5.
  199.    *
  200.    * @return {boolean}
  201.    */
  202.   static isWebOS5() {
  203.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  204.     return shaka.util.Platform.isWebOS() &&
  205.         shaka.util.Platform.chromeVersion() === 68;
  206.   }
  208.   /**
  209.    * Check if the current platform is a Google Chromecast.
  210.    *
  211.    * @return {boolean}
  212.    */
  213.   static isChromecast() {
  214.     return shaka.util.Platform.userAgentContains_('CrKey');
  215.   }
  217.   /**
  218.    * Check if the current platform is a Google Chromecast with Android
  219.    * (i.e. Chromecast with GoogleTV).
  220.    *
  221.    * @return {boolean}
  222.    */
  223.   static isAndroidCastDevice() {
  224.     const Platform = shaka.util.Platform;
  225.     return Platform.isChromecast() && Platform.isAndroid();
  226.   }
  228.   /**
  229.    * Check if the current platform is a Google Chromecast with Fuchsia
  230.    * (i.e. Google Nest Hub).
  231.    *
  232.    * @return {boolean}
  233.    */
  234.   static isFuchsiaCastDevice() {
  235.     const Platform = shaka.util.Platform;
  236.     return Platform.isChromecast() && Platform.isFuchsia();
  237.   }
  239.   /**
  240.    * Returns a major version number for Chrome, or Chromium-based browsers.
  241.    *
  242.    * For example:
  243.    *   - Chrome 106.0.5249.61 returns 106.
  244.    *   - Edge 106.0.1370.34 returns 106 (since this is based on Chromium).
  245.    *   - Safari returns null (since this is independent of Chromium).
  246.    *
  247.    * @return {?number} A major version number or null if not Chromium-based.
  248.    */
  249.   static chromeVersion() {
  250.     if (!shaka.util.Platform.isChrome()) {
  251.       return null;
  252.     }
  254.     // Looking for something like "Chrome/106.0.0.0".
  255.     const match = navigator.userAgent.match(/Chrome\/(\d+)/);
  256.     if (match) {
  257.       return parseInt(match[1], /* base= */ 10);
  258.     }
  260.     return null;
  261.   }
  263.   /**
  264.    * Check if the current platform is Google Chrome.
  265.    *
  266.    * @return {boolean}
  267.    */
  268.   static isChrome() {
  269.     // The Edge Legacy user agent will also contain the "Chrome" keyword, so we
  270.     // need to make sure this is not Edge Legacy.
  271.     return shaka.util.Platform.userAgentContains_('Chrome') &&
  272.            !shaka.util.Platform.isLegacyEdge();
  273.   }
  275.   /**
  276.    * Check if the current platform is Firefox.
  277.    *
  278.    * @return {boolean}
  279.    */
  280.   static isFirefox() {
  281.     return shaka.util.Platform.userAgentContains_('Firefox');
  282.   }
  284.   /**
  285.    * Check if the current platform is from Apple.
  286.    *
  287.    * Returns true on all iOS browsers and on desktop Safari.
  288.    *
  289.    * Returns false for non-Safari browsers on macOS, which are independent of
  290.    * Apple.
  291.    *
  292.    * @return {boolean}
  293.    */
  294.   static isApple() {
  295.     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
  296.         !shaka.util.Platform.isTizen() &&
  297.         !shaka.util.Platform.isEOS() &&
  298.         !shaka.util.Platform.isAPL() &&
  299.         !shaka.util.Platform.isVirginMedia() &&
  300.         !shaka.util.Platform.isOrange() &&
  301.         !shaka.util.Platform.isPS4() &&
  302.         !shaka.util.Platform.isAmazonFireTV() &&
  303.         !shaka.util.Platform.isWPE() &&
  304.         !shaka.util.Platform.isZenterio();
  305.   }
  307.   /**
  308.    * Check if the current platform is Playstation 5.
  309.    *
  310.    * Returns true on Playstation 5 browsers.
  311.    *
  312.    * Returns false for Playstation 5 browsers
  313.    *
  314.    * @return {boolean}
  315.    */
  316.   static isPS5() {
  317.     return shaka.util.Platform.userAgentContains_('PlayStation 5');
  318.   }
  320.   /**
  321.    * Check if the current platform is Playstation 4.
  322.    */
  323.   static isPS4() {
  324.     return shaka.util.Platform.userAgentContains_('PlayStation 4');
  325.   }
  327.   /**
  328.    * Check if the current platform is Hisense.
  329.    */
  330.   static isHisense() {
  331.     return shaka.util.Platform.userAgentContains_('Hisense') ||
  332.         shaka.util.Platform.userAgentContains_('VIDAA');
  333.   }
  335.   /**
  336.    * Check if the current platform is Virgin Media device.
  337.    */
  338.   static isVirginMedia() {
  339.     return shaka.util.Platform.userAgentContains_('VirginMedia');
  340.   }
  342.   /**
  343.    * Check if the current platform is Orange.
  344.    */
  345.   static isOrange() {
  346.     return shaka.util.Platform.userAgentContains_('SOPOpenBrowser');
  347.   }
  349.   /**
  350.    * Check if the current platform is Amazon Fire TV.
  351.    * https://developer.amazon.com/docs/fire-tv/identify-amazon-fire-tv-devices.html
  352.    *
  353.    * @return {boolean}
  354.    */
  355.   static isAmazonFireTV() {
  356.     return shaka.util.Platform.userAgentContains_('AFT');
  357.   }
  359.   /**
  360.    * Check if the current platform is Comcast X1.
  361.    * @return {boolean}
  362.    */
  363.   static isWPE() {
  364.     return shaka.util.Platform.userAgentContains_('WPE');
  365.   }
  367.   /**
  368.    * Check if the current platform is Deutsche Telecom Zenterio STB.
  369.    * @return {boolean}
  370.    */
  371.   static isZenterio() {
  372.     return shaka.util.Platform.userAgentContains_('DT_STB_BCM');
  373.   }
  375.   /**
  376.    * Returns a major version number for Safari, or Safari-based iOS browsers.
  377.    *
  378.    * For example:
  379.    *   - Safari 13.0.4 on macOS returns 13.
  380.    *   - Safari on iOS 13.3.1 returns 13.
  381.    *   - Chrome on iOS 13.3.1 returns 13 (since this is based on Safari/WebKit).
  382.    *   - Chrome on macOS returns null (since this is independent of Apple).
  383.    *
  384.    * Returns null on Firefox on iOS, where this version information is not
  385.    * available.
  386.    *
  387.    * @return {?number} A major version number or null if not iOS.
  388.    */
  389.   static safariVersion() {
  390.     // All iOS browsers and desktop Safari will return true for isApple().
  391.     if (!shaka.util.Platform.isApple()) {
  392.       return null;
  393.     }
  395.     // This works for iOS Safari and desktop Safari, which contain something
  396.     // like "Version/13.0" indicating the major Safari or iOS version.
  397.     let match = navigator.userAgent.match(/Version\/(\d+)/);
  398.     if (match) {
  399.       return parseInt(match[1], /* base= */ 10);
  400.     }
  402.     // This works for all other browsers on iOS, which contain something like
  403.     // "OS 13_3" indicating the major & minor iOS version.
  404.     match = navigator.userAgent.match(/OS (\d+)(?:_\d+)?/);
  405.     if (match) {
  406.       return parseInt(match[1], /* base= */ 10);
  407.     }
  409.     return null;
  410.   }
  412.   /**
  413.    * Check if the current platform is Apple Safari
  414.    * or Safari-based iOS browsers.
  415.    *
  416.    * @return {boolean}
  417.    */
  418.   static isSafari() {
  419.     return !!shaka.util.Platform.safariVersion();
  420.   }
  422.   /**
  423.    * Check if the current platform is an EOS set-top box.
  424.    *
  425.    * @return {boolean}
  426.    */
  427.   static isEOS() {
  428.     return shaka.util.Platform.userAgentContains_('PC=EOS');
  429.   }
  431.   /**
  432.    * Check if the current platform is an APL set-top box.
  433.    *
  434.    * @return {boolean}
  435.    */
  436.   static isAPL() {
  437.     return shaka.util.Platform.userAgentContains_('PC=APL');
  438.   }
  440.   /**
  441.    * Guesses if the platform is a mobile one (iOS or Android).
  442.    *
  443.    * @return {boolean}
  444.    */
  445.   static isMobile() {
  446.     if (/(?:iPhone|iPad|iPod|Android)/.test(navigator.userAgent)) {
  447.       // This is Android, iOS, or iPad < 13.
  448.       return true;
  449.     }
  451.     // Starting with iOS 13 on iPad, the user agent string no longer has the
  452.     // word "iPad" in it.  It looks very similar to desktop Safari.  This seems
  453.     // to be intentional on Apple's part.
  454.     // See: https://forums.developer.apple.com/thread/119186
  455.     //
  456.     // So if it's an Apple device with multi-touch support, assume it's a mobile
  457.     // device.  If some future iOS version starts masking their user agent on
  458.     // both iPhone & iPad, this clause should still work.  If a future
  459.     // multi-touch desktop Mac is released, this will need some adjustment.
  460.     //
  461.     // As of January 2020, this is mainly used to adjust the default UI config
  462.     // for mobile devices, so it's low risk if something changes to break this
  463.     // detection.
  464.     return shaka.util.Platform.isApple() && navigator.maxTouchPoints > 1;
  465.   }
  467.   /**
  468.    * Return true if the platform is a Mac, regardless of the browser.
  469.    *
  470.    * @return {boolean}
  471.    */
  472.   static isMac() {
  473.     // Try the newer standard first.
  474.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  475.       return navigator.userAgentData.platform.toLowerCase() == 'macos';
  476.     }
  477.     // Fall back to the old API, with less strict matching.
  478.     if (!navigator.platform) {
  479.       return false;
  480.     }
  481.     return navigator.platform.toLowerCase().includes('mac');
  482.   }
  484.   /**
  485.    * Return true if the platform is a Windows, regardless of the browser.
  486.    *
  487.    * @return {boolean}
  488.    */
  489.   static isWindows() {
  490.     // Try the newer standard first.
  491.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  492.       return navigator.userAgentData.platform.toLowerCase() == 'windows';
  493.     }
  494.     // Fall back to the old API, with less strict matching.
  495.     if (!navigator.platform) {
  496.       return false;
  497.     }
  498.     return navigator.platform.toLowerCase().includes('windows');
  499.   }
  501.   /**
  502.    * Return true if the platform is a Android, regardless of the browser.
  503.    *
  504.    * @return {boolean}
  505.    */
  506.   static isAndroid() {
  507.     return shaka.util.Platform.userAgentContains_('Android');
  508.   }
  510.   /**
  511.    * Return true if the platform is a Fuchsia, regardless of the browser.
  512.    *
  513.    * @return {boolean}
  514.    */
  515.   static isFuchsia() {
  516.     return shaka.util.Platform.userAgentContains_('Fuchsia');
  517.   }
  519.   /**
  520.    * Return true if the platform is controlled by a remote control.
  521.    *
  522.    * @return {boolean}
  523.    */
  524.   static isSmartTV() {
  525.     const Platform = shaka.util.Platform;
  526.     if (Platform.isTizen() || Platform.isWebOS() ||
  527.         Platform.isXboxOne() || Platform.isPS4() ||
  528.         Platform.isPS5() || Platform.isAmazonFireTV() ||
  529.         Platform.isEOS() || Platform.isAPL() ||
  530.         Platform.isVirginMedia() || Platform.isOrange() ||
  531.         Platform.isWPE() || Platform.isChromecast() ||
  532.         Platform.isHisense() || Platform.isZenterio()) {
  533.       return true;
  534.     }
  535.     return false;
  536.   }
  538.   /**
  539.    * Check if the user agent contains a key. This is the best way we know of
  540.    * right now to detect platforms. If there is a better way, please send a
  541.    * PR.
  542.    *
  543.    * @param {string} key
  544.    * @return {boolean}
  545.    * @private
  546.    */
  547.   static userAgentContains_(key) {
  548.     const userAgent = navigator.userAgent || '';
  549.     return userAgent.includes(key);
  550.   }
  552.   /**
  553.    * For canPlayType queries, we just need any instance.
  554.    *
  555.    * First, use a cached element from a previous query.
  556.    * Second, search the page for one.
  557.    * Third, create a temporary one.
  558.    *
  559.    * Cached elements expire in one second so that they can be GC'd or removed.
  560.    *
  561.    * @return {!HTMLMediaElement}
  562.    */
  563.   static anyMediaElement() {
  564.     const Platform = shaka.util.Platform;
  565.     if (Platform.cachedMediaElement_) {
  566.       return Platform.cachedMediaElement_;
  567.     }
  569.     if (!Platform.cacheExpirationTimer_) {
  570.       Platform.cacheExpirationTimer_ = new shaka.util.Timer(() => {
  571.         Platform.cachedMediaElement_ = null;
  572.       });
  573.     }
  575.     Platform.cachedMediaElement_ = /** @type {HTMLMediaElement} */(
  576.       document.getElementsByTagName('video')[0] ||
  577.       document.getElementsByTagName('audio')[0]);
  579.     if (!Platform.cachedMediaElement_) {
  580.       Platform.cachedMediaElement_ = /** @type {!HTMLMediaElement} */(
  581.         document.createElement('video'));
  582.     }
  584.     Platform.cacheExpirationTimer_.tickAfter(/* seconds= */ 1);
  585.     return Platform.cachedMediaElement_;
  586.   }
  588.   /**
  589.    * Returns true if the platform requires encryption information in all init
  590.    * segments.  For such platforms, MediaSourceEngine will attempt to work
  591.    * around a lack of such info by inserting fake encryption information into
  592.    * initialization segments.
  593.    *
  594.    * @param {?string} keySystem
  595.    * @return {boolean}
  596.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  597.    */
  598.   static requiresEncryptionInfoInAllInitSegments(keySystem) {
  599.     const Platform = shaka.util.Platform;
  600.     const isPlayReady = shaka.util.DrmUtils.isPlayReadyKeySystem(keySystem);
  601.     return Platform.isTizen() || Platform.isXboxOne() || Platform.isOrange() ||
  602.       (Platform.isEdge() && Platform.isWindows() && isPlayReady);
  603.   }
  605.   /**
  606.    * Returns true if the platform supports SourceBuffer "sequence mode".
  607.    *
  608.    * @return {boolean}
  609.    */
  610.   static supportsSequenceMode() {
  611.     const Platform = shaka.util.Platform;
  612.     if (Platform.isTizen3() || Platform.isTizen2() ||
  613.         Platform.isWebOS3() || Platform.isPS4()) {
  614.       return false;
  615.     }
  616.     return true;
  617.   }
  619.   /**
  620.    * Returns if codec switching SMOOTH is known reliable device support.
  621.    *
  622.    * Some devices are known not to support `MediaSource.changeType`
  623.    * well. These devices should use the reload strategy. If a device
  624.    * reports that it supports `changeType` but support it reliabley
  625.    * it should be added to this list.
  626.    *
  627.    * @return {boolean}
  628.    */
  629.   static supportsSmoothCodecSwitching() {
  630.     const Platform = shaka.util.Platform;
  631.     if (Platform.isTizen2() || Platform.isTizen3() || Platform.isTizen4() ||
  632.         Platform.isTizen5() || Platform.isTizen6() || Platform.isWebOS3() ||
  633.         Platform.isWebOS4() || Platform.isWebOS5()) {
  634.       return false;
  635.     }
  636.     // Older chromecasts without GoogleTV seem to not support SMOOTH properly.
  637.     if (Platform.isChromecast() && !Platform.isAndroidCastDevice() &&
  638.         !Platform.isFuchsiaCastDevice()) {
  639.       return false;
  640.     }
  641.     // See: https://chromium-review.googlesource.com/c/chromium/src/+/4577759
  642.     if (Platform.isWindows() && Platform.isEdge()) {
  643.       return false;
  644.     }
  645.     return true;
  646.   }
  648.   /**
  649.    * On some platforms, such as v1 Chromecasts, the act of seeking can take a
  650.    * significant amount of time.
  651.    *
  652.    * @return {boolean}
  653.    */
  654.   static isSeekingSlow() {
  655.     const Platform = shaka.util.Platform;
  656.     if (Platform.isChromecast()) {
  657.       if (Platform.isAndroidCastDevice()) {
  658.         // Android-based Chromecasts are new enough to not be a problem.
  659.         return false;
  660.       } else {
  661.         return true;
  662.       }
  663.     }
  664.     return false;
  665.   }
  667.   /**
  668.    * Returns true if MediaKeys is polyfilled
  669.    *
  670.    * @param {string=} polyfillType
  671.    * @return {boolean}
  672.    */
  673.   static isMediaKeysPolyfilled(polyfillType) {
  674.     if (polyfillType) {
  675.       return polyfillType === window.shakaMediaKeysPolyfill;
  676.     }
  677.     return !!window.shakaMediaKeysPolyfill;
  678.   }
  681.   /**
  682.    * Detect the maximum resolution that the platform's hardware can handle.
  683.    *
  684.    * @return {!Promise.<shaka.extern.Resolution>}
  685.    */
  686.   static async detectMaxHardwareResolution() {
  687.     const Platform = shaka.util.Platform;
  689.     /** @type {shaka.extern.Resolution} */
  690.     const maxResolution = {
  691.       width: Infinity,
  692.       height: Infinity,
  693.     };
  695.     if (Platform.isChromecast()) {
  696.       // In our tests, the original Chromecast seems to have trouble decoding
  697.       // above 1080p. It would be a waste to select a higher res anyway, given
  698.       // that the device only outputs 1080p to begin with.
  699.       // Chromecast has an extension to query the device/display's resolution.
  700.       const hasCanDisplayType = window.cast && cast.__platform__ &&
  701.           cast.__platform__.canDisplayType;
  703.       // Some hub devices can only do 720p. Default to that.
  704.       maxResolution.width = 1280;
  705.       maxResolution.height = 720;
  707.       try {
  708.         if (hasCanDisplayType && await cast.__platform__.canDisplayType(
  709.             'video/mp4; codecs="avc1.640028"; width=3840; height=2160')) {
  710.           // The device and display can both do 4k. Assume a 4k limit.
  711.           maxResolution.width = 3840;
  712.           maxResolution.height = 2160;
  713.         } else if (hasCanDisplayType && await cast.__platform__.canDisplayType(
  714.             'video/mp4; codecs="avc1.640028"; width=1920; height=1080')) {
  715.           // Most Chromecasts can do 1080p.
  716.           maxResolution.width = 1920;
  717.           maxResolution.height = 1080;
  718.         }
  719.       } catch (error) {
  720.         // This shouldn't generally happen. Log the error.
  721.         shaka.log.alwaysError('Failed to check canDisplayType:', error);
  722.         // Now ignore the error and let the 720p default stand.
  723.       }
  724.     } else if (Platform.isTizen()) {
  725.       maxResolution.width = 1920;
  726.       maxResolution.height = 1080;
  727.       try {
  728.         if (webapis.systeminfo && webapis.systeminfo.getMaxVideoResolution) {
  729.           const maxVideoResolution =
  730.               webapis.systeminfo.getMaxVideoResolution();
  731.           maxResolution.width = maxVideoResolution.width;
  732.           maxResolution.height = maxVideoResolution.height;
  733.         } else {
  734.           if (webapis.productinfo.is8KPanelSupported &&
  735.               webapis.productinfo.is8KPanelSupported()) {
  736.             maxResolution.width = 7680;
  737.             maxResolution.height = 4320;
  738.           } else if (webapis.productinfo.isUdPanelSupported &&
  739.               webapis.productinfo.isUdPanelSupported()) {
  740.             maxResolution.width = 3840;
  741.             maxResolution.height = 2160;
  742.           }
  743.         }
  744.       } catch (e) {
  745.         shaka.log.alwaysWarn('Tizen: Error detecting screen size, default ' +
  746.             'screen size 1920x1080.');
  747.       }
  748.     } else if (Platform.isXboxOne()) {
  749.       maxResolution.width = 1920;
  750.       maxResolution.height = 1080;
  751.       try {
  752.         let winRT = undefined;
  754.         // Try to access to WinRT for WebView, if it's not defined,
  755.         // try to access to WinRT for WebView2, if it's not defined either,
  756.         // let it throw.
  757.         if (typeof Windows !== 'undefined') {
  758.           winRT = Windows;
  759.         } else {
  760.           winRT = chrome.webview.hostObjects.sync.Windows;
  761.         }
  763.         const protectionCapabilities =
  764.             new winRT.Media.Protection.ProtectionCapabilities();
  765.         const protectionResult =
  766.             winRT.Media.Protection.ProtectionCapabilityResult;
  767.         // isTypeSupported may return "maybe", which means the operation is not
  768.         // completed. This means we need to retry
  769.         // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
  770.         let result = null;
  771.         const type =
  772.             'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
  773.             'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
  774.             'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
  775.             'display-bpc=8"';
  776.         const keySystem = 'com.microsoft.playready.recommendation';
  777.         do {
  778.           result = protectionCapabilities.isTypeSupported(type, keySystem);
  779.         } while (result === protectionResult.maybe);
  780.         if (result === protectionResult.probably) {
  781.           maxResolution.width = 3840;
  782.           maxResolution.height = 2160;
  783.         }
  784.       } catch (e) {
  785.         shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
  786.             'screen size 1920x1080.');
  787.       }
  788.     } else if (Platform.isWebOS()) {
  789.       try {
  790.         const deviceInfo =
  791.         /** @type {{screenWidth: number, screenHeight: number}} */(
  792.             JSON.parse(window.PalmSystem.deviceInfo));
  793.         // WebOS has always been able to do 1080p.  Assume a 1080p limit.
  794.         maxResolution.width = Math.max(1920, deviceInfo['screenWidth']);
  795.         maxResolution.height = Math.max(1080, deviceInfo['screenHeight']);
  796.       } catch (e) {
  797.         shaka.log.alwaysWarn('WebOS: Error detecting screen size, default ' +
  798.             'screen size 1920x1080.');
  799.         maxResolution.width = 1920;
  800.         maxResolution.height = 1080;
  801.       }
  802.     } else if (Platform.isHisense()) {
  803.       // eslint-disable-next-line new-cap
  804.       if (window.Hisense_Get4KSupportState &&
  805.           // eslint-disable-next-line new-cap
  806.           window.Hisense_Get4KSupportState()) {
  807.         maxResolution.width = 3840;
  808.         maxResolution.height = 2160;
  809.       } else {
  810.         maxResolution.width = 1920;
  811.         maxResolution.height = 1080;
  812.       }
  813.     } else if (Platform.isPS4() || Platform.isPS5()) {
  814.       let supports4K = false;
  815.       try {
  816.         const result = await window.msdk.device.getDisplayInfo();
  817.         supports4K = result.resolution === '4K';
  818.       } catch (e) {
  819.         try {
  820.           const result = await window.msdk.device.getDisplayInfoImmediate();
  821.           supports4K = result.resolution === '4K';
  822.         } catch (e) {
  823.           shaka.log.alwaysWarn(
  824.               'PlayStation: Failed to get the display info:', e);
  825.         }
  826.       }
  827.       if (supports4K) {
  828.         maxResolution.width = 3840;
  829.         maxResolution.height = 2160;
  830.       } else {
  831.         maxResolution.width = 1920;
  832.         maxResolution.height = 1080;
  833.       }
  834.     }
  835.     return maxResolution;
  836.   }
  837. };
  839. /** @private {shaka.util.Timer} */
  840. shaka.util.Platform.cacheExpirationTimer_ = null;
  842. /** @private {HTMLMediaElement} */
  843. shaka.util.Platform.cachedMediaElement_ = null;