Source: lib/polyfill/orientation.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.Orientation');
  9. goog.require('shaka.util.FakeEvent');
  10. goog.require('shaka.util.FakeEventTarget');
  11. goog.require('shaka.polyfill');
  14. /**
  15.  * @summary A polyfill for systems that do not implement screen.orientation.
  16.  * For now, this only handles systems that implement the deprecated
  17.  * window.orientation feature... e.g. iPad.
  18.  * @export
  19.  */
  20. shaka.polyfill.Orientation = class {
  21.   /**
  22.    * Install the polyfill if needed.
  23.    * @export
  24.    */
  25.   static install() {
  26.     if (screen.orientation) {
  27.       // Not needed.
  28.       return;
  29.     }
  31.     // There is no way to check to see if the 'orientationchange' event exists
  32.     // on window, which could theoretically lead to this making a
  33.     // screen.orientation object that doesn't actually work.
  34.     // However, it looks like all platforms that support the deprecated
  35.     // window.orientation feature also support that event.
  36.     if (window.orientation != undefined) {
  37.       shaka.polyfill.Orientation.installBasedOnWindowMethods_();
  38.     }
  39.   }
  41.   /**
  42.    * Makes a polyfill for orientation, based on window methods.
  43.    * Note that some of the features this is based on are deprecated, so this
  44.    * will not necessarily work on all platforms.
  45.    * @private
  46.    */
  47.   static installBasedOnWindowMethods_() {
  48.     const orientation = new shaka.polyfill.Orientation.FakeOrientation();
  49.     screen.orientation = /** @type {!ScreenOrientation} */ (orientation);
  50.     const setValues = () => {
  51.       switch (window.orientation) {
  52.         case -90:
  53.           orientation.type = 'landscape-secondary';
  54.           orientation.angle = 270;
  55.           break;
  56.         case 0:
  57.           orientation.type = 'portrait-primary';
  58.           orientation.angle = 0;
  59.           break;
  60.         case 90:
  61.           orientation.type = 'landscape-primary';
  62.           orientation.angle = 90;
  63.           break;
  64.         case 180:
  65.           orientation.type = 'portrait-secondary';
  66.           orientation.angle = 180;
  67.           break;
  68.       }
  69.     };
  71.     setValues();
  72.     window.addEventListener('orientationchange', () => {
  73.       setValues();
  74.       orientation.dispatchChangeEvent();
  75.     });
  76.   }
  77. };
  80. shaka.polyfill.Orientation.FakeOrientation =
  81. class extends shaka.util.FakeEventTarget {
  82.   /** */
  83.   constructor() {
  84.     super();
  86.     /** @type {string} */
  87.     this.type = '';
  89.     /** @type {number} */
  90.     this.angle = 0;
  91.   }
  93.   /** Dispatch a 'change' event. */
  94.   dispatchChangeEvent() {
  95.     const event = new shaka.util.FakeEvent('change');
  96.     this.dispatchEvent(event);
  97.   }
  99.   /**
  100.    * @param {string} orientation
  101.    * @return {!Promise}
  102.    */
  103.   lock(orientation) {
  104.     /**
  105.      * @param {string} orientation
  106.      * @return {boolean}
  107.      */
  108.     const lockOrientation = (orientation) => {
  109.       if (screen.lockOrientation) {
  110.         return screen.lockOrientation(orientation);
  111.       }
  112.       if (screen.mozLockOrientation) {
  113.         return screen.mozLockOrientation(orientation);
  114.       }
  115.       if (screen.msLockOrientation) {
  116.         return screen.msLockOrientation(orientation);
  117.       }
  118.       return false;
  119.     };
  121.     let success = false;
  122.     // The set of input strings for screen.orientation.lock and for
  123.     // screen.lockOrientation are almost, but not entirely, the same.
  124.     switch (orientation) {
  125.       case 'natural':
  126.         success = lockOrientation('default');
  127.         break;
  128.       case 'any':
  129.         // It's not quite clear what locking the screen orientation to 'any'
  130.         // is supposed to mean... presumably, that's equivalent to not being
  131.         // locked?
  132.         success = true;
  133.         this.unlock();
  134.         break;
  135.       default:
  136.         success = lockOrientation(orientation);
  137.         break;
  138.     }
  139.     // According to the docs, there "may be a delay" between the
  140.     // lockOrientation method being called and the screen actually being
  141.     // locked.  Unfortunately, without any idea as to how long that delay is,
  142.     // and with no events to listen for, we cannot account for it here.
  143.     if (success) {
  144.       return Promise.resolve();
  145.     }
  146.     // Either locking was not available, or the process failed... either way,
  147.     // reject this with a mock error.
  148.     // This should be a DOMException, but there is not a public constructor for
  149.     // that.  So we make this look-alike instead.
  150.     const unsupportedKeySystemError =
  151.         new Error('screen.orientation.lock() is not available on this device');
  152.     unsupportedKeySystemError.name = 'NotSupportedError';
  153.     unsupportedKeySystemError['code'] = DOMException.NOT_SUPPORTED_ERR;
  154.     return Promise.reject(unsupportedKeySystemError);
  155.   }
  157.   /** Unlock the screen orientation. */
  158.   unlock() {
  159.     // screen.unlockOrientation has a return value, but
  160.     // screen.orientation.unlock does not. So ignore the return value.
  161.     if (screen.unlockOrientation) {
  162.       screen.unlockOrientation();
  163.     } else if (screen.mozUnlockOrientation) {
  164.       screen.mozUnlockOrientation();
  165.     } else if (screen.msUnlockOrientation) {
  166.       screen.msUnlockOrientation();
  167.     }
  168.   }
  169. };
  172. shaka.polyfill.register(shaka.polyfill.Orientation.install);