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.drm.DrmUtils');
  10. goog.require('shaka.log');
  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 WebOS 6.
  210.    *
  211.    * @return {boolean}
  212.    */
  213.   static isWebOS6() {
  214.     // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
  215.     return shaka.util.Platform.isWebOS() &&
  216.         shaka.util.Platform.chromeVersion() === 79;
  217.   }
  219.   /**
  220.    * Check if the current platform is a Google Chromecast.
  221.    *
  222.    * @return {boolean}
  223.    */
  224.   static isChromecast() {
  225.     const Platform = shaka.util.Platform;
  226.     return Platform.userAgentContains_('CrKey') && !Platform.isVizio();
  227.   }
  229.   /**
  230.    * Check if the current platform is a Google Chromecast without
  231.    * Android or Fuchsia.
  232.    *
  233.    * @return {boolean}
  234.    */
  235.   static isOlderChromecast() {
  236.     const Platform = shaka.util.Platform;
  237.     return Platform.isChromecast() &&
  238.         !Platform.isAndroid() && !Platform.isFuchsia();
  239.   }
  241.   /**
  242.    * Check if the current platform is a Google Chromecast with Android
  243.    * (i.e. Chromecast with GoogleTV).
  244.    *
  245.    * @return {boolean}
  246.    */
  247.   static isAndroidCastDevice() {
  248.     const Platform = shaka.util.Platform;
  249.     return Platform.isChromecast() && Platform.isAndroid();
  250.   }
  252.   /**
  253.    * Check if the current platform is a Google Chromecast with Fuchsia
  254.    * (i.e. Google Nest Hub).
  255.    *
  256.    * @return {boolean}
  257.    */
  258.   static isFuchsiaCastDevice() {
  259.     const Platform = shaka.util.Platform;
  260.     return Platform.isChromecast() && Platform.isFuchsia();
  261.   }
  263.   /**
  264.    * Returns a major version number for Chrome, or Chromium-based browsers.
  265.    *
  266.    * For example:
  267.    *   - Chrome 106.0.5249.61 returns 106.
  268.    *   - Edge 106.0.1370.34 returns 106 (since this is based on Chromium).
  269.    *   - Safari returns null (since this is independent of Chromium).
  270.    *
  271.    * @return {?number} A major version number or null if not Chromium-based.
  272.    */
  273.   static chromeVersion() {
  274.     if (!shaka.util.Platform.isChrome()) {
  275.       return null;
  276.     }
  278.     // Looking for something like "Chrome/106.0.0.0".
  279.     const match = navigator.userAgent.match(/Chrome\/(\d+)/);
  280.     if (match) {
  281.       return parseInt(match[1], /* base= */ 10);
  282.     }
  284.     return null;
  285.   }
  287.   /**
  288.    * Check if the current platform is Google Chrome.
  289.    *
  290.    * @return {boolean}
  291.    */
  292.   static isChrome() {
  293.     // The Edge Legacy user agent will also contain the "Chrome" keyword, so we
  294.     // need to make sure this is not Edge Legacy.
  295.     return shaka.util.Platform.userAgentContains_('Chrome') &&
  296.            !shaka.util.Platform.isLegacyEdge();
  297.   }
  299.   /**
  300.    * Check if the current platform is Firefox.
  301.    *
  302.    * @return {boolean}
  303.    */
  304.   static isFirefox() {
  305.     return shaka.util.Platform.userAgentContains_('Firefox');
  306.   }
  308.   /**
  309.    * Check if the current platform is from Apple.
  310.    *
  311.    * Returns true on all iOS browsers and on desktop Safari.
  312.    *
  313.    * Returns false for non-Safari browsers on macOS, which are independent of
  314.    * Apple.
  315.    *
  316.    * @return {boolean}
  317.    */
  318.   static isApple() {
  319.     return shaka.util.Platform.isAppleVendor_() &&
  320.         (shaka.util.Platform.isMac() || shaka.util.Platform.isIOS());
  321.   }
  323.   /**
  324.    * Check if the current platform is Playstation 5.
  325.    *
  326.    * Returns true on Playstation 5 browsers.
  327.    *
  328.    * Returns false for Playstation 5 browsers
  329.    *
  330.    * @return {boolean}
  331.    */
  332.   static isPS5() {
  333.     return shaka.util.Platform.userAgentContains_('PlayStation 5');
  334.   }
  336.   /**
  337.    * Check if the current platform is Playstation 4.
  338.    * @return {boolean}
  339.    */
  340.   static isPS4() {
  341.     return shaka.util.Platform.userAgentContains_('PlayStation 4');
  342.   }
  344.   /**
  345.    * Check if the current platform is Hisense.
  346.    * @return {boolean}
  347.    */
  348.   static isHisense() {
  349.     return shaka.util.Platform.userAgentContains_('Hisense') ||
  350.         shaka.util.Platform.userAgentContains_('VIDAA');
  351.   }
  353.   /**
  354.    * Check if the current platform is Vizio TV.
  355.    * @return {boolean}
  356.    */
  357.   static isVizio() {
  358.     return shaka.util.Platform.userAgentContains_('VIZIO SmartCast');
  359.   }
  361.   /**
  362.    * Check if the current platform is Orange.
  363.    * @return {boolean}
  364.    */
  365.   static isOrange() {
  366.     return shaka.util.Platform.userAgentContains_('SOPOpenBrowser');
  367.   }
  369.   /**
  370.    * Check if the current platform is SkyQ STB.
  371.    * @return {boolean}
  372.    */
  373.   static isSkyQ() {
  374.     return shaka.util.Platform.userAgentContains_('Sky_STB');
  375.   }
  377.   /**
  378.    * Check if the current platform is Deutsche Telecom Zenterio STB.
  379.    * @return {boolean}
  380.    */
  381.   static isZenterio() {
  382.     return shaka.util.Platform.userAgentContains_('DT_STB_BCM');
  383.   }
  385.   /**
  386.    * Returns a major version number for Safari, or Webkit-based STBs,
  387.    * or Safari-based iOS browsers.
  388.    *
  389.    * For example:
  390.    *   - Safari 13.0.4 on macOS returns 13.
  391.    *   - Safari on iOS 13.3.1 returns 13.
  392.    *   - Chrome on iOS 13.3.1 returns 13 (since this is based on Safari/WebKit).
  393.    *   - Chrome on macOS returns null (since this is independent of Apple).
  394.    *
  395.    * Returns null on Firefox on iOS, where this version information is not
  396.    * available.
  397.    *
  398.    * @return {?number} A major version number or null if not iOS.
  399.    */
  400.   static safariVersion() {
  401.     // All iOS browsers and desktop Safari will return true for isApple().
  402.     if (!shaka.util.Platform.isApple() && !shaka.util.Platform.isWebkitSTB()) {
  403.       return null;
  404.     }
  406.     // This works for iOS Safari and desktop Safari, which contain something
  407.     // like "Version/13.0" indicating the major Safari or iOS version.
  408.     let match = navigator.userAgent.match(/Version\/(\d+)/);
  409.     if (match) {
  410.       return parseInt(match[1], /* base= */ 10);
  411.     }
  413.     // This works for all other browsers on iOS, which contain something like
  414.     // "OS 13_3" indicating the major & minor iOS version.
  415.     match = navigator.userAgent.match(/OS (\d+)(?:_\d+)?/);
  416.     if (match) {
  417.       return parseInt(match[1], /* base= */ 10);
  418.     }
  420.     return null;
  421.   }
  423.   /**
  424.    * Guesses if the platform is an Apple mobile one (iOS, iPad, iPod).
  425.    * @return {boolean}
  426.    */
  427.   static isIOS() {
  428.     if (/(?:iPhone|iPad|iPod)/.test(navigator.userAgent)) {
  429.       // This is Android, iOS, or iPad < 13.
  430.       return true;
  431.     }
  433.     // Starting with iOS 13 on iPad, the user agent string no longer has the
  434.     // word "iPad" in it.  It looks very similar to desktop Safari.  This seems
  435.     // to be intentional on Apple's part.
  436.     // See: https://forums.developer.apple.com/thread/119186
  437.     //
  438.     // So if it's an Apple device with multi-touch support, assume it's a mobile
  439.     // device.  If some future iOS version starts masking their user agent on
  440.     // both iPhone & iPad, this clause should still work.  If a future
  441.     // multi-touch desktop Mac is released, this will need some adjustment.
  442.     //
  443.     // As of January 2020, this is mainly used to adjust the default UI config
  444.     // for mobile devices, so it's low risk if something changes to break this
  445.     // detection.
  446.     return shaka.util.Platform.isAppleVendor_() && navigator.maxTouchPoints > 1;
  447.   }
  449.   /**
  450.    * Guesses if the platform is a mobile one.
  451.    * @return {boolean}
  452.    */
  453.   static isMobile() {
  454.     if (navigator.userAgentData) {
  455.       return navigator.userAgentData.mobile;
  456.     }
  457.     return shaka.util.Platform.isIOS() || shaka.util.Platform.isAndroid();
  458.   }
  460.   /**
  461.    * Return true if the platform is a Mac, regardless of the browser.
  462.    *
  463.    * @return {boolean}
  464.    */
  465.   static isMac() {
  466.     // Try the newer standard first.
  467.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  468.       return navigator.userAgentData.platform.toLowerCase() == 'macos';
  469.     }
  470.     // Fall back to the old API, with less strict matching.
  471.     if (!navigator.platform) {
  472.       return false;
  473.     }
  474.     return navigator.platform.toLowerCase().includes('mac');
  475.   }
  477.   /**
  478.    * Return true if the platform is a VisionOS.
  479.    *
  480.    * @return {boolean}
  481.    */
  482.   static isVisionOS() {
  483.     if (!shaka.util.Platform.isMac()) {
  484.       return false;
  485.     }
  486.     if (!('xr' in navigator)) {
  487.       return false;
  488.     }
  489.     return true;
  490.   }
  492.   /**
  493.    * Checks is non-Apple STB based on Webkit.
  494.    * @return {boolean}
  495.    */
  496.   static isWebkitSTB() {
  497.     return shaka.util.Platform.isAppleVendor_() &&
  498.         !shaka.util.Platform.isApple();
  499.   }
  501.   /**
  502.    * Return true if the platform is a Windows, regardless of the browser.
  503.    *
  504.    * @return {boolean}
  505.    */
  506.   static isWindows() {
  507.     // Try the newer standard first.
  508.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  509.       return navigator.userAgentData.platform.toLowerCase() == 'windows';
  510.     }
  511.     // Fall back to the old API, with less strict matching.
  512.     if (!navigator.platform) {
  513.       return false;
  514.     }
  515.     return navigator.platform.toLowerCase().includes('win32');
  516.   }
  518.   /**
  519.    * Return true if the platform is a Android, regardless of the browser.
  520.    *
  521.    * @return {boolean}
  522.    */
  523.   static isAndroid() {
  524.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  525.       return navigator.userAgentData.platform.toLowerCase() == 'android';
  526.     }
  527.     return shaka.util.Platform.userAgentContains_('Android');
  528.   }
  530.   /**
  531.    * Return true if the platform is a Fuchsia, regardless of the browser.
  532.    *
  533.    * @return {boolean}
  534.    */
  535.   static isFuchsia() {
  536.     if (navigator.userAgentData && navigator.userAgentData.platform) {
  537.       return navigator.userAgentData.platform.toLowerCase() == 'fuchsia';
  538.     }
  539.     return shaka.util.Platform.userAgentContains_('Fuchsia');
  540.   }
  542.   /**
  543.    * Return true if the platform is controlled by a remote control.
  544.    *
  545.    * @return {boolean}
  546.    */
  547.   static isSmartTV() {
  548.     const Platform = shaka.util.Platform;
  549.     if (Platform.isTizen() || Platform.isWebOS() ||
  550.         Platform.isXboxOne() || Platform.isPS4() ||
  551.         Platform.isPS5() || Platform.isChromecast() ||
  552.         Platform.isHisense() || Platform.isVizio() ||
  553.         Platform.isWebkitSTB()) {
  554.       return true;
  555.     }
  556.     return false;
  557.   }
  559.   /**
  560.    * Check if the user agent contains a key. This is the best way we know of
  561.    * right now to detect platforms. If there is a better way, please send a
  562.    * PR.
  563.    *
  564.    * @param {string} key
  565.    * @return {boolean}
  566.    * @private
  567.    */
  568.   static userAgentContains_(key) {
  569.     const userAgent = navigator.userAgent || '';
  570.     return userAgent.includes(key);
  571.   }
  573.   /**
  574.    * @return {boolean}
  575.    * @private
  576.    */
  577.   static isAppleVendor_() {
  578.     return (navigator.vendor || '').includes('Apple');
  579.   }
  581.   /**
  582.    * For canPlayType queries, we just need any instance.
  583.    *
  584.    * First, use a cached element from a previous query.
  585.    * Second, search the page for one.
  586.    * Third, create a temporary one.
  587.    *
  588.    * Cached elements expire in one second so that they can be GC'd or removed.
  589.    *
  590.    * @return {!HTMLMediaElement}
  591.    */
  592.   static anyMediaElement() {
  593.     const Platform = shaka.util.Platform;
  594.     if (Platform.cachedMediaElement_) {
  595.       return Platform.cachedMediaElement_;
  596.     }
  598.     if (!Platform.cacheExpirationTimer_) {
  599.       Platform.cacheExpirationTimer_ = new shaka.util.Timer(() => {
  600.         Platform.cachedMediaElement_ = null;
  601.       });
  602.     }
  604.     Platform.cachedMediaElement_ = /** @type {HTMLMediaElement} */(
  605.       document.getElementsByTagName('video')[0] ||
  606.       document.getElementsByTagName('audio')[0]);
  608.     if (!Platform.cachedMediaElement_) {
  609.       Platform.cachedMediaElement_ = /** @type {!HTMLMediaElement} */(
  610.         document.createElement('video'));
  611.     }
  613.     Platform.cacheExpirationTimer_.tickAfter(/* seconds= */ 1);
  614.     return Platform.cachedMediaElement_;
  615.   }
  617.   /**
  618.    * Returns true if the platform requires encryption information in all init
  619.    * segments.  For such platforms, MediaSourceEngine will attempt to work
  620.    * around a lack of such info by inserting fake encryption information into
  621.    * initialization segments.
  622.    *
  623.    * @param {?string} keySystem
  624.    * @param {string} contentType
  625.    * @return {boolean}
  626.    * @see https://github.com/shaka-project/shaka-player/issues/2759
  627.    */
  628.   static requiresEncryptionInfoInAllInitSegments(keySystem, contentType) {
  629.     const Platform = shaka.util.Platform;
  630.     const isPlayReady = shaka.drm.DrmUtils.isPlayReadyKeySystem(keySystem);
  631.     return (Platform.isApple() && contentType === 'audio') ||
  632.       Platform.isTizen() || Platform.isXboxOne() || Platform.isOrange() ||
  633.       (Platform.isEdge() && Platform.isWindows() && isPlayReady);
  634.   }
  636.   /**
  637.    * @param {string} contentType
  638.    * @return {boolean}
  639.    */
  640.   static requiresTfhdFix(contentType) {
  641.     return shaka.util.Platform.isApple() && contentType === 'audio';
  642.   }
  644.   /**
  645.    * Returns true if the platform requires AC-3 signalling in init
  646.    * segments to be replaced with EC-3 signalling.
  647.    * For such platforms, MediaSourceEngine will attempt to work
  648.    * around it by inserting fake EC-3 signalling into
  649.    * initialization segments.
  650.    *
  651.    * @return {boolean}
  652.    */
  653.   static requiresEC3InitSegments() {
  654.     return shaka.util.Platform.isTizen3();
  655.   }
  657.   /**
  658.    * Returns true if the platform supports SourceBuffer "sequence mode".
  659.    *
  660.    * @return {boolean}
  661.    */
  662.   static supportsSequenceMode() {
  663.     const Platform = shaka.util.Platform;
  664.     if (Platform.isTizen3() || Platform.isTizen2() ||
  665.         Platform.isWebOS3() || Platform.isPS4() || Platform.isPS5()) {
  666.       return false;
  667.     }
  668.     // See: https://bugs.webkit.org/show_bug.cgi?id=210341
  669.     const safariVersion = Platform.safariVersion();
  670.     if (Platform.isWebkitSTB() && safariVersion != null && safariVersion < 15) {
  671.       return false;
  672.     }
  673.     return true;
  674.   }
  676.   /**
  677.    * Returns if codec switching SMOOTH is known reliable device support.
  678.    *
  679.    * Some devices are known not to support <code>SourceBuffer.changeType</code>
  680.    * well. These devices should use the reload strategy. If a device
  681.    * reports that it supports <code<changeType</code> but supports it unreliably
  682.    * it should be disallowed in this method.
  683.    *
  684.    * @return {boolean}
  685.    */
  686.   static supportsSmoothCodecSwitching() {
  687.     const Platform = shaka.util.Platform;
  688.     // All Tizen versions (up to Tizen 8) do not support SMOOTH so far.
  689.     // webOS seems to support SMOOTH from webOS 22.
  690.     if (Platform.isTizen() || Platform.isPS4() || Platform.isPS5() ||
  691.         Platform.isWebOS6()) {
  692.       return false;
  693.     }
  694.     // Older chromecasts without GoogleTV seem to not support SMOOTH properly.
  695.     if (Platform.isOlderChromecast()) {
  696.       return false;
  697.     }
  698.     // See: https://chromium-review.googlesource.com/c/chromium/src/+/4577759
  699.     if (Platform.isWindows() && Platform.isEdge()) {
  700.       return false;
  701.     }
  702.     return true;
  703.   }
  705.   /**
  706.    * On some platforms, such as v1 Chromecasts, the act of seeking can take a
  707.    * significant amount of time.
  708.    *
  709.    * @return {boolean}
  710.    */
  711.   static isSeekingSlow() {
  712.     const Platform = shaka.util.Platform;
  713.     if (Platform.isChromecast()) {
  714.       if (Platform.isAndroidCastDevice()) {
  715.         // Android-based Chromecasts are new enough to not be a problem.
  716.         return false;
  717.       } else {
  718.         return true;
  719.       }
  720.     }
  721.     return false;
  722.   }
  725.   /**
  726.    * Detect the maximum resolution that the platform's hardware can handle.
  727.    *
  728.    * @return {!Promise<shaka.extern.Resolution>}
  729.    */
  730.   static async detectMaxHardwareResolution() {
  731.     const Platform = shaka.util.Platform;
  733.     /** @type {shaka.extern.Resolution} */
  734.     const maxResolution = {
  735.       width: Infinity,
  736.       height: Infinity,
  737.     };
  739.     if (Platform.isChromecast()) {
  740.       // In our tests, the original Chromecast seems to have trouble decoding
  741.       // above 1080p. It would be a waste to select a higher res anyway, given
  742.       // that the device only outputs 1080p to begin with.
  743.       // Chromecast has an extension to query the device/display's resolution.
  744.       const hasCanDisplayType = window.cast && cast.__platform__ &&
  745.           cast.__platform__.canDisplayType;
  747.       // Some hub devices can only do 720p. Default to that.
  748.       maxResolution.width = 1280;
  749.       maxResolution.height = 720;
  751.       try {
  752.         if (hasCanDisplayType && await cast.__platform__.canDisplayType(
  753.             'video/mp4; codecs="avc1.640028"; width=3840; height=2160')) {
  754.           // The device and display can both do 4k. Assume a 4k limit.
  755.           maxResolution.width = 3840;
  756.           maxResolution.height = 2160;
  757.         } else if (hasCanDisplayType && await cast.__platform__.canDisplayType(
  758.             'video/mp4; codecs="avc1.640028"; width=1920; height=1080')) {
  759.           // Most Chromecasts can do 1080p.
  760.           maxResolution.width = 1920;
  761.           maxResolution.height = 1080;
  762.         }
  763.       } catch (error) {
  764.         // This shouldn't generally happen. Log the error.
  765.         shaka.log.alwaysError('Failed to check canDisplayType:', error);
  766.         // Now ignore the error and let the 720p default stand.
  767.       }
  768.     } else if (Platform.isTizen()) {
  769.       const devicePixelRatio = window.devicePixelRatio;
  770.       maxResolution.width = window.screen.width * devicePixelRatio > 1920 ?
  771.           3840 : 1920;
  772.       maxResolution.height = window.screen.height * devicePixelRatio > 1080 ?
  773.           2160 : 1080;
  774.       try {
  775.         if (webapis.systeminfo && webapis.systeminfo.getMaxVideoResolution) {
  776.           const maxVideoResolution =
  777.               webapis.systeminfo.getMaxVideoResolution();
  778.           maxResolution.width = maxVideoResolution.width;
  779.           maxResolution.height = maxVideoResolution.height;
  780.         } else {
  781.           if (webapis.productinfo.is8KPanelSupported &&
  782.               webapis.productinfo.is8KPanelSupported()) {
  783.             maxResolution.width = 7680;
  784.             maxResolution.height = 4320;
  785.           } else if (webapis.productinfo.isUdPanelSupported &&
  786.               webapis.productinfo.isUdPanelSupported()) {
  787.             maxResolution.width = 3840;
  788.             maxResolution.height = 2160;
  789.           }
  790.         }
  791.       } catch (e) {
  792.         shaka.log.alwaysWarn('Tizen: Error detecting screen size, default ' +
  793.             'screen size 1920x1080.');
  794.       }
  795.     } else if (Platform.isWebOS()) {
  796.       try {
  797.         const deviceInfo =
  798.         /** @type {{screenWidth: number, screenHeight: number}} */(
  799.             JSON.parse(window.PalmSystem.deviceInfo));
  800.         // WebOS has always been able to do 1080p.  Assume a 1080p limit.
  801.         maxResolution.width = Math.max(1920, deviceInfo['screenWidth']);
  802.         maxResolution.height = Math.max(1080, deviceInfo['screenHeight']);
  803.       } catch (e) {
  804.         shaka.log.alwaysWarn('WebOS: Error detecting screen size, default ' +
  805.             'screen size 1920x1080.');
  806.         maxResolution.width = 1920;
  807.         maxResolution.height = 1080;
  808.       }
  809.     } else if (Platform.isHisense()) {
  810.       let supports4k = null;
  811.       if (window.Hisense_Get4KSupportState) {
  812.         try {
  813.           // eslint-disable-next-line new-cap
  814.           supports4k = window.Hisense_Get4KSupportState();
  815.         } catch (e) {
  816.           shaka.log.debug('Hisense: Failed to get 4K support state', e);
  817.         }
  818.       }
  819.       if (supports4k == null) {
  820.         // If API is not there or not working for whatever reason, fallback to
  821.         // user agent check, as it contains UHD or FHD info.
  822.         supports4k = Platform.userAgentContains_('UHD');
  823.       }
  824.       if (supports4k) {
  825.         maxResolution.width = 3840;
  826.         maxResolution.height = 2160;
  827.       } else {
  828.         maxResolution.width = 1920;
  829.         maxResolution.height = 1080;
  830.       }
  831.     } else if (Platform.isPS4() || Platform.isPS5()) {
  832.       let supports4K = false;
  833.       try {
  834.         const result = await window.msdk.device.getDisplayInfo();
  835.         supports4K = result.resolution === '4K';
  836.       } catch (e) {
  837.         try {
  838.           const result = await window.msdk.device.getDisplayInfoImmediate();
  839.           supports4K = result.resolution === '4K';
  840.         } catch (e) {
  841.           shaka.log.alwaysWarn(
  842.               'PlayStation: Failed to get the display info:', e);
  843.         }
  844.       }
  845.       if (supports4K) {
  846.         maxResolution.width = 3840;
  847.         maxResolution.height = 2160;
  848.       } else {
  849.         maxResolution.width = 1920;
  850.         maxResolution.height = 1080;
  851.       }
  852.     } else {
  853.       // For Xbox and UWP apps.
  854.       let winRT = undefined;
  855.       try {
  856.         // Try to access to WinRT for WebView, if it's not defined,
  857.         // try to access to WinRT for WebView2, if it's not defined either,
  858.         // let it throw.
  859.         if (typeof Windows !== 'undefined') {
  860.           winRT = Windows;
  861.         } else {
  862.           winRT = chrome.webview.hostObjects.sync.Windows;
  863.         }
  864.       } catch (e) {}
  865.       if (winRT) {
  866.         maxResolution.width = 1920;
  867.         maxResolution.height = 1080;
  868.         try {
  869.           const protectionCapabilities =
  870.               new winRT.Media.Protection.ProtectionCapabilities();
  871.           const protectionResult =
  872.               winRT.Media.Protection.ProtectionCapabilityResult;
  873.           // isTypeSupported may return "maybe", which means the operation
  874.           // is not completed. This means we need to retry
  875.           // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
  876.           let result = null;
  877.           const type =
  878.               'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
  879.               'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
  880.               'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
  881.               'display-bpc=8"';
  882.           const keySystem = 'com.microsoft.playready.recommendation';
  883.           do {
  884.             result = protectionCapabilities.isTypeSupported(type, keySystem);
  885.           } while (result === protectionResult.maybe);
  886.           if (result === protectionResult.probably) {
  887.             maxResolution.width = 3840;
  888.             maxResolution.height = 2160;
  889.           }
  890.         } catch (e) {
  891.           shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
  892.               'screen size 1920x1080.');
  893.         }
  894.       } else if (Platform.isXboxOne()) {
  895.         maxResolution.width = 1920;
  896.         maxResolution.height = 1080;
  897.         shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
  898.             'screen size 1920x1080.');
  899.       }
  900.     }
  901.     return maxResolution;
  902.   }
  903. };
  905. /** @private {shaka.util.Timer} */
  906. shaka.util.Platform.cacheExpirationTimer_ = null;
  908. /** @private {HTMLMediaElement} */
  909. shaka.util.Platform.cachedMediaElement_ = null;