Source: lib/device/webos.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2025 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.device.WebOS');
  9. goog.require('shaka.config.CrossBoundaryStrategy');
  10. goog.require('shaka.device.AbstractDevice');
  11. goog.require('shaka.device.DeviceFactory');
  12. goog.require('shaka.device.IDevice');
  13. goog.require('shaka.log');
  16. /**
  17.  * @final
  18.  */
  19. shaka.device.WebOS = class extends shaka.device.AbstractDevice {
  20.   constructor() {
  21.     super();
  23.     /** @private {?number} */
  24.     this.osVersion_ = this.guessWebOSVersion_();
  25.   }
  27.   /**
  28.    * @override
  29.    */
  30.   getVersion() {
  31.     return this.osVersion_;
  32.   }
  34.   /**
  35.    * @override
  36.    */
  37.   getDeviceName() {
  38.     return 'WebOS';
  39.   }
  41.   /**
  42.    * @override
  43.    */
  44.   getDeviceType() {
  45.     return shaka.device.IDevice.DeviceType.TV;
  46.   }
  48.   /**
  49.    * @override
  50.    */
  51.   getBrowserEngine() {
  52.     return shaka.device.IDevice.BrowserEngine.CHROMIUM;
  53.   }
  55.   /**
  56.    * @override
  57.    */
  58.   supportsMediaCapabilities() {
  59.     return false;
  60.   }
  62.   /**
  63.    * @override
  64.    */
  65.   supportsSequenceMode() {
  66.     const version = this.getVersion();
  67.     return version !== null ? version > 3 : super.supportsSequenceMode();
  68.   }
  70.   /**
  71.    * @override
  72.    */
  73.   supportsSmoothCodecSwitching() {
  74.     const version = this.getVersion();
  75.     return version !== null ?
  76.         version > 6 : super.supportsSmoothCodecSwitching();
  77.   }
  79.   /**
  80.    * @override
  81.    */
  82.   supportsServerCertificate() {
  83.     const version = this.getVersion();
  84.     return version !== null ? version > 3 : super.supportsServerCertificate();
  85.   }
  87.   /**
  88.    * @override
  89.    */
  90.   detectMaxHardwareResolution() {
  91.     const maxResolution = {width: 1920, height: 1080};
  92.     try {
  93.       const deviceInfo =
  94.       /** @type {{screenWidth: number, screenHeight: number}} */(
  95.           JSON.parse(window.PalmSystem.deviceInfo));
  96.       // WebOS has always been able to do 1080p.  Assume a 1080p limit.
  97.       maxResolution.width = Math.max(1920, deviceInfo['screenWidth']);
  98.       maxResolution.height = Math.max(1080, deviceInfo['screenHeight']);
  99.     } catch (e) {
  100.       shaka.log.alwaysWarn('WebOS: Error detecting screen size, default ' +
  101.           'screen size 1920x1080.');
  102.     }
  104.     return Promise.resolve(maxResolution);
  105.   }
  107.   /**
  108.    * @override
  109.    */
  110.   adjustConfig(config) {
  111.     super.adjustConfig(config);
  113.     if (this.getVersion() === 3) {
  114.       config.streaming.crossBoundaryStrategy =
  115.           shaka.config.CrossBoundaryStrategy.RESET;
  116.     }
  117.     config.streaming.shouldFixTimestampOffset = true;
  118.     // WebOS has long hardware pipeline that respond slowly to seeking.
  119.     // Therefore we should not seek when we detect a stall on this platform.
  120.     // Instead, default stallSkip to 0 to force the stall detector to pause
  121.     // and play instead.
  122.     config.streaming.stallSkip = 0;
  123.     return config;
  124.   }
  126.   /**
  127.    * @return {?number}
  128.    * @private
  129.    */
  130.   guessWebOSVersion_() {
  131.     let browserVersion = null;
  132.     const match = navigator.userAgent.match(/Chrome\/(\d+)/);
  133.     if (match) {
  134.       browserVersion = parseInt(match[1], /* base= */ 10);
  135.     }
  137.     switch (browserVersion) {
  138.       case 38:
  139.         return 3;
  140.       case 53:
  141.         return 4;
  142.       case 68:
  143.         return 5;
  144.       case 79:
  145.         return 6;
  146.       case 87:
  147.         return 22;
  148.       case 94:
  149.         return 23;
  150.       case 108:
  151.         return 24;
  152.       case 120:
  153.         return 25;
  154.       default:
  155.         return null;
  156.     }
  157.   }
  159.   /**
  160.    * @override
  161.    */
  162.   supportStandardVP9Checking() {
  163.     return false;
  164.   }
  166.   /**
  167.    * @return {boolean}
  168.    * @private
  169.    */
  170.   static isWebOS_() {
  171.     return navigator.userAgent.includes('Web0S');
  172.   }
  173. };
  175. if (shaka.device.WebOS.isWebOS_()) {
  176.   shaka.device.DeviceFactory.registerDeviceFactory(
  177.       () => new shaka.device.WebOS());
  178. }