Source: lib/util/platform.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.Platform');
  20. goog.require('shaka.util.Timer');
  23. /**
  24.  * A wrapper for platform-specific functions.
  25.  *
  26.  * @final
  27.  */
  28. shaka.util.Platform = class {
  29.   /**
  30.    * Check if the current platform supports media source. We assume that if
  31.    * the current platform supports media source, then we can use media source
  32.    * as per its design.
  33.    *
  34.    * @return {boolean}
  35.    */
  36.   static supportsMediaSource() {
  37.     // Browsers that lack a media source implementation will have no reference
  38.     // to |window.MediaSource|. Platforms that we see having problematic media
  39.     // source implementations will have this reference removed via a polyfill.
  40.     if (!window.MediaSource) {
  41.       return false;
  42.     }
  44.     // Some very old MediaSource implementations didn't have isTypeSupported.
  45.     if (!MediaSource.isTypeSupported) {
  46.       return false;
  47.     }
  49.     return true;
  50.   }
  52.   /**
  53.    * Returns true if the media type is supported natively by the platform.
  54.    *
  55.    * @param {string} mimeType
  56.    * @return {boolean}
  57.    */
  58.   static supportsMediaType(mimeType) {
  59.     const video = shaka.util.Platform.anyMediaElement();
  60.     return video.canPlayType(mimeType) != '';
  61.   }
  63.   /**
  64.    * Check if the current platform is MS Edge.
  65.    *
  66.    * @return {boolean}
  67.    */
  68.   static isEdge() {
  69.     // Legacy Edge contains "Edge/version".
  70.     // Chromium-based Edge contains "Edg/version" (no "e").
  71.     if (navigator.userAgent.match(/Edge?\//)) {
  72.       return true;
  73.     }
  75.     return false;
  76.   }
  78.   /**
  79.    * Check if the current platform is Legacy Edge.
  80.    *
  81.    * @return {boolean}
  82.    */
  83.   static isLegacyEdge() {
  84.     // Legacy Edge contains "Edge/version".
  85.     // Chromium-based Edge contains "Edg/version" (no "e").
  86.     if (navigator.userAgent.match(/Edge\//)) {
  87.       return true;
  88.     }
  90.     return false;
  91.   }
  93.   /**
  94.    * Check if the current platform is MS IE.
  95.    *
  96.    * @return {boolean}
  97.    */
  98.   static isIE() {
  99.     return shaka.util.Platform.userAgentContains_('Trident/');
  100.   }
  102.   /**
  103.    * Check if the current platform is an Xbox One.
  104.    *
  105.    * @return {boolean}
  106.    */
  107.   static isXboxOne() {
  108.     return shaka.util.Platform.userAgentContains_('Xbox One');
  109.   }
  111.   /**
  112.    * Check if the current platform is a Tizen TV.
  113.    *
  114.    * @return {boolean}
  115.    */
  116.   static isTizen() {
  117.     return shaka.util.Platform.userAgentContains_('Tizen');
  118.   }
  120.   /**
  121.    * Check if the current platform is a Tizen 4 TV.
  122.    *
  123.    * @return {boolean}
  124.    */
  125.   static isTizen4() {
  126.     return shaka.util.Platform.userAgentContains_('Tizen 4');
  127.   }
  129.   /**
  130.    * Check if the current platform is a Tizen 3 TV.
  131.    *
  132.    * @return {boolean}
  133.    */
  134.   static isTizen3() {
  135.     return shaka.util.Platform.userAgentContains_('Tizen 3');
  136.   }
  138.   /**
  139.    * Check if the current platform is a Tizen 2 TV.
  140.    *
  141.    * @return {boolean}
  142.    */
  143.   static isTizen2() {
  144.     return shaka.util.Platform.userAgentContains_('Tizen 2');
  145.   }
  147.   /**
  148.    * Check if the current platform is a WebOS.
  149.    *
  150.    * @return {boolean}
  151.    */
  152.   static isWebOS() {
  153.     return shaka.util.Platform.userAgentContains_('Web0S');
  154.   }
  156.   /**
  157.    * Check if the current platform is a Google Chromecast.
  158.    *
  159.    * @return {boolean}
  160.    */
  161.   static isChromecast() {
  162.     return shaka.util.Platform.userAgentContains_('CrKey');
  163.   }
  165.   /**
  166.    * Check if the current platform is Google Chrome.
  167.    *
  168.    * @return {boolean}
  169.    */
  170.   static isChrome() {
  171.     // The Edge user agent will also contain the "Chrome" keyword, so we need
  172.     // to make sure this is not Edge.
  173.     return shaka.util.Platform.userAgentContains_('Chrome') &&
  174.            !shaka.util.Platform.isEdge();
  175.   }
  178.   /**
  179.    * Check if the current platform is from Apple.
  180.    *
  181.    * Returns true on all iOS browsers and on desktop Safari.
  182.    *
  183.    * Returns false for non-Safari browsers on macOS, which are independent of
  184.    * Apple.
  185.    *
  186.    * @return {boolean}
  187.    */
  188.   static isApple() {
  189.     return !!navigator.vendor && navigator.vendor.includes('Apple')
  190.             && !shaka.util.Platform.isTizen();
  191.   }
  193.   /**
  194.    * Returns a major version number for Safari, or Safari-based iOS browsers.
  195.    *
  196.    * For example:
  197.    *   - Safari 13.0.4 on macOS returns 13.
  198.    *   - Safari on iOS 13.3.1 returns 13.
  199.    *   - Chrome on iOS 13.3.1 returns 13 (since this is based on Safari/WebKit).
  200.    *   - Chrome on macOS returns null (since this is independent of Apple).
  201.    *
  202.    * Returns null on Firefox on iOS, where this version information is not
  203.    * available.
  204.    *
  205.    * @return {?number} A major version number or null if not iOS.
  206.    */
  207.   static safariVersion() {
  208.     // All iOS browsers and desktop Safari will return true for isApple().
  209.     if (!shaka.util.Platform.isApple()) {
  210.       return null;
  211.     }
  213.     // This works for iOS Safari and desktop Safari, which contain something
  214.     // like "Version/13.0" indicating the major Safari or iOS version.
  215.     let match = navigator.userAgent.match(/Version\/(\d+)/);
  216.     if (match) {
  217.       return parseInt(match[1], /* base= */ 10);
  218.     }
  220.     // This works for all other browsers on iOS, which contain something like
  221.     // "OS 13_3" indicating the major & minor iOS version.
  222.     match = navigator.userAgent.match(/OS (\d+)(?:_\d+)?/);
  223.     if (match) {
  224.       return parseInt(match[1], /* base= */ 10);
  225.     }
  227.     return null;
  228.   }
  230.   /**
  231.    * Guesses if the platform is a mobile one (iOS or Android).
  232.    *
  233.    * @return {boolean}
  234.    */
  235.   static isMobile() {
  236.     if (/(?:iPhone|iPad|iPod|Android)/.test(navigator.userAgent)) {
  237.       // This is Android, iOS, or iPad < 13.
  238.       return true;
  239.     }
  241.     // Starting with iOS 13 on iPad, the user agent string no longer has the
  242.     // word "iPad" in it.  It looks very similar to desktop Safari.  This seems
  243.     // to be intentional on Apple's part.
  244.     // See: https://forums.developer.apple.com/thread/119186
  245.     //
  246.     // So if it's an Apple device with multi-touch support, assume it's a mobile
  247.     // device.  If some future iOS version starts masking their user agent on
  248.     // both iPhone & iPad, this clause should still work.  If a future
  249.     // multi-touch desktop Mac is released, this will need some adjustment.
  250.     //
  251.     // As of January 2020, this is mainly used to adjust the default UI config
  252.     // for mobile devices, so it's low risk if something changes to break this
  253.     // detection.
  254.     return shaka.util.Platform.isApple() && navigator.maxTouchPoints > 1;
  255.   }
  257.   /**
  258.    * Check if the user agent contains a key. This is the best way we know of
  259.    * right now to detect platforms. If there is a better way, please send a
  260.    * PR.
  261.    *
  262.    * @param {string} key
  263.    * @return {boolean}
  264.    * @private
  265.    */
  266.   static userAgentContains_(key) {
  267.     const userAgent = navigator.userAgent || '';
  268.     return userAgent.includes(key);
  269.   }
  271.   /**
  272.    * For canPlayType queries, we just need any instance.
  273.    *
  274.    * First, use a cached element from a previous query.
  275.    * Second, search the page for one.
  276.    * Third, create a temporary one.
  277.    *
  278.    * Cached elements expire in one second so that they can be GC'd or removed.
  279.    *
  280.    * @return {!HTMLMediaElement}
  281.    */
  282.   static anyMediaElement() {
  283.     const Platform = shaka.util.Platform;
  284.     if (Platform.cachedMediaElement_) {
  285.       return Platform.cachedMediaElement_;
  286.     }
  288.     if (!Platform.cacheExpirationTimer_) {
  289.       Platform.cacheExpirationTimer_ = new shaka.util.Timer(() => {
  290.         Platform.cachedMediaElement_ = null;
  291.       });
  292.     }
  294.     Platform.cachedMediaElement_ = /** @type {HTMLMediaElement} */(
  295.       document.getElementsByTagName('video')[0] ||
  296.       document.getElementsByTagName('audio')[0]);
  298.     if (!Platform.cachedMediaElement_) {
  299.       Platform.cachedMediaElement_ = /** @type {!HTMLMediaElement} */(
  300.           document.createElement('video'));
  301.     }
  303.     Platform.cacheExpirationTimer_.tickAfter(/* seconds= */ 1);
  304.     return Platform.cachedMediaElement_;
  305.   }
  306. };
  308. /** @private {shaka.util.Timer} */
  309. shaka.util.Platform.cacheExpirationTimer_ = null;
  311. /** @private {HTMLMediaElement} */
  312. shaka.util.Platform.cachedMediaElement_ = null;