Source: lib/polyfill/patchedmediakeys_apple.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.PatchedMediaKeysApple');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.DrmEngine');
  12. goog.require('shaka.polyfill');
  13. goog.require('shaka.util.BufferUtils');
  14. goog.require('shaka.util.EventManager');
  15. goog.require('shaka.util.FakeEvent');
  16. goog.require('shaka.util.FakeEventTarget');
  17. goog.require('shaka.util.MediaReadyState');
  18. goog.require('shaka.util.PublicPromise');
  19. goog.require('shaka.util.StringUtils');
  22. /**
  23.  * @summary A polyfill to implement modern, standardized EME on top of Apple's
  24.  * prefixed EME in Safari.
  25.  * @export
  26.  */
  27. shaka.polyfill.PatchedMediaKeysApple = class {
  28.   /**
  29.    * Installs the polyfill if needed.
  30.    * @export
  31.    */
  32.   static install() {
  33.     if (!window.HTMLVideoElement || !window.WebKitMediaKeys) {
  34.       // No HTML5 video or no prefixed EME.
  35.       return;
  36.     }
  38.     /* Unprefixed EME disabled.  See:
  39.        https://github.com/google/shaka-player/pull/3021#issuecomment-766999811
  41.     // Only tested in Safari 14.
  42.     const safariVersion = shaka.util.Platform.safariVersion();
  43.     if (navigator.requestMediaKeySystemAccess &&
  44.         // eslint-disable-next-line no-restricted-syntax
  45.         MediaKeySystemAccess.prototype.getConfiguration &&
  46.         safariVersion && safariVersion >= 14) {
  47.       // Unprefixed EME is preferable.
  48.       return;
  49.     }
  50.     */
  52.     shaka.log.info('Using Apple-prefixed EME');
  54.     // Alias
  55.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  57.     // Delete mediaKeys to work around strict mode compatibility issues.
  58.     // eslint-disable-next-line no-restricted-syntax
  59.     delete HTMLMediaElement.prototype['mediaKeys'];
  60.     // Work around read-only declaration for mediaKeys by using a string.
  61.     // eslint-disable-next-line no-restricted-syntax
  62.     HTMLMediaElement.prototype['mediaKeys'] = null;
  63.     // eslint-disable-next-line no-restricted-syntax
  64.     HTMLMediaElement.prototype.setMediaKeys =
  65.         PatchedMediaKeysApple.setMediaKeys;
  67.     // Install patches
  68.     window.MediaKeys = PatchedMediaKeysApple.MediaKeys;
  69.     window.MediaKeySystemAccess = PatchedMediaKeysApple.MediaKeySystemAccess;
  70.     navigator.requestMediaKeySystemAccess =
  71.         PatchedMediaKeysApple.requestMediaKeySystemAccess;
  72.   }
  74.   /**
  75.    * An implementation of navigator.requestMediaKeySystemAccess.
  76.    * Retrieves a MediaKeySystemAccess object.
  77.    *
  78.    * @this {!Navigator}
  79.    * @param {string} keySystem
  80.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  81.    * @return {!Promise.<!MediaKeySystemAccess>}
  82.    */
  83.   static requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
  84.     shaka.log.debug('PatchedMediaKeysApple.requestMediaKeySystemAccess');
  85.     goog.asserts.assert(this == navigator,
  86.         'bad "this" for requestMediaKeySystemAccess');
  88.     // Alias.
  89.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  90.     try {
  91.       const access = new PatchedMediaKeysApple.MediaKeySystemAccess(
  92.           keySystem, supportedConfigurations);
  93.       return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  94.     } catch (exception) {
  95.       return Promise.reject(exception);
  96.     }
  97.   }
  99.   /**
  100.    * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  101.    * Attaches a MediaKeys object to the media element.
  102.    *
  103.    * @this {!HTMLMediaElement}
  104.    * @param {MediaKeys} mediaKeys
  105.    * @return {!Promise}
  106.    */
  107.   static setMediaKeys(mediaKeys) {
  108.     shaka.log.debug('PatchedMediaKeysApple.setMediaKeys');
  109.     goog.asserts.assert(this instanceof HTMLMediaElement,
  110.         'bad "this" for setMediaKeys');
  112.     // Alias
  113.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  115.     const newMediaKeys =
  116.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */ (
  117.         mediaKeys);
  118.     const oldMediaKeys =
  119.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */ (
  120.         this.mediaKeys);
  122.     if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  123.       goog.asserts.assert(
  124.           oldMediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  125.           'non-polyfill instance of oldMediaKeys');
  126.       // Have the old MediaKeys stop listening to events on the video tag.
  127.       oldMediaKeys.setMedia(null);
  128.     }
  130.     delete this['mediaKeys'];  // in case there is an existing getter
  131.     this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  133.     if (newMediaKeys) {
  134.       goog.asserts.assert(
  135.           newMediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  136.           'non-polyfill instance of newMediaKeys');
  137.       return newMediaKeys.setMedia(this);
  138.     }
  140.     return Promise.resolve();
  141.   }
  143.   /**
  144.    * Handler for the native media elements webkitneedkey event.
  145.    *
  146.    * @this {!HTMLMediaElement}
  147.    * @param {!MediaKeyEvent} event
  148.    * @suppress {constantProperty} We reassign what would be const on a real
  149.    *   MediaEncryptedEvent, but in our look-alike event.
  150.    * @private
  151.    */
  152.   static onWebkitNeedKey_(event) {
  153.     shaka.log.debug('PatchedMediaKeysApple.onWebkitNeedKey_', event);
  155.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  156.     const mediaKeys =
  157.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */(
  158.         this.mediaKeys);
  159.     goog.asserts.assert(mediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  160.         'non-polyfill instance of newMediaKeys');
  162.     goog.asserts.assert(event.initData != null, 'missing init data!');
  164.     // Convert the prefixed init data to match the native 'encrypted' event.
  165.     const uint8 = shaka.util.BufferUtils.toUint8(event.initData);
  166.     const dataview = shaka.util.BufferUtils.toDataView(uint8);
  167.     // The first part is a 4 byte little-endian int, which is the length of
  168.     // the second part.
  169.     const length = dataview.getUint32(
  170.         /* position= */ 0, /* littleEndian= */ true);
  171.     if (length + 4 != uint8.byteLength) {
  172.       throw new RangeError('Malformed FairPlay init data');
  173.     }
  174.     // The remainder is a UTF-16 skd URL.  Convert this to UTF-8 and pass on.
  175.     const str = shaka.util.StringUtils.fromUTF16(
  176.         uint8.subarray(4), /* littleEndian= */ true);
  177.     const initData = shaka.util.StringUtils.toUTF8(str);
  179.     // NOTE: Because "this" is a real EventTarget, the event we dispatch here
  180.     // must also be a real Event.
  181.     const event2 = new Event('encrypted');
  183.     const encryptedEvent =
  184.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  185.     encryptedEvent.initDataType = 'skd';
  186.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(initData);
  188.     this.dispatchEvent(event2);
  189.   }
  190. };
  193. /**
  194.  * An implementation of MediaKeySystemAccess.
  195.  *
  196.  * @implements {MediaKeySystemAccess}
  197.  */
  198. shaka.polyfill.PatchedMediaKeysApple.MediaKeySystemAccess = class {
  199.   /**
  200.    * @param {string} keySystem
  201.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  202.    */
  203.   constructor(keySystem, supportedConfigurations) {
  204.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySystemAccess');
  206.     /** @type {string} */
  207.     this.keySystem = keySystem;
  209.     /** @private {!MediaKeySystemConfiguration} */
  210.     this.configuration_;
  212.     // Optimization: WebKitMediaKeys.isTypeSupported delays responses by a
  213.     // significant amount of time, possibly to discourage fingerprinting.
  214.     // Since we know only FairPlay is supported here, let's skip queries for
  215.     // anything else to speed up the process.
  216.     if (keySystem.startsWith('com.apple.fps')) {
  217.       for (const cfg of supportedConfigurations) {
  218.         const newCfg = this.checkConfig_(cfg);
  219.         if (newCfg) {
  220.           this.configuration_ = newCfg;
  221.           return;
  222.         }
  223.       }
  224.     }
  226.     // According to the spec, this should be a DOMException, but there is not a
  227.     // public constructor for that.  So we make this look-alike instead.
  228.     const unsupportedKeySystemError = new Error('Unsupported keySystem');
  229.     unsupportedKeySystemError.name = 'NotSupportedError';
  230.     unsupportedKeySystemError['code'] = DOMException.NOT_SUPPORTED_ERR;
  231.     throw unsupportedKeySystemError;
  232.   }
  234.   /**
  235.    * Check a single config for MediaKeySystemAccess.
  236.    *
  237.    * @param {MediaKeySystemConfiguration} cfg The requested config.
  238.    * @return {?MediaKeySystemConfiguration} A matching config we can support, or
  239.    *   null if the input is not supportable.
  240.    * @private
  241.    */
  242.   checkConfig_(cfg) {
  243.     if (cfg.persistentState == 'required') {
  244.       // Not supported by the prefixed API.
  245.       return null;
  246.     }
  248.     // Create a new config object and start adding in the pieces which we find
  249.     // support for.  We will return this from getConfiguration() later if
  250.     // asked.
  252.     /** @type {!MediaKeySystemConfiguration} */
  253.     const newCfg = {
  254.       'audioCapabilities': [],
  255.       'videoCapabilities': [],
  256.       // It is technically against spec to return these as optional, but we
  257.       // don't truly know their values from the prefixed API:
  258.       'persistentState': 'optional',
  259.       'distinctiveIdentifier': 'optional',
  260.       // Pretend the requested init data types are supported, since we don't
  261.       // really know that either:
  262.       'initDataTypes': cfg.initDataTypes,
  263.       'sessionTypes': ['temporary'],
  264.       'label': cfg.label,
  265.     };
  267.     // PatchedMediaKeysApple tests for key system availability through
  268.     // WebKitMediaKeys.isTypeSupported.
  269.     let ranAnyTests = false;
  270.     let success = false;
  272.     if (cfg.audioCapabilities) {
  273.       for (const cap of cfg.audioCapabilities) {
  274.         if (cap.contentType) {
  275.           ranAnyTests = true;
  277.           const contentType = cap.contentType.split(';')[0];
  278.           if (WebKitMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  279.             newCfg.audioCapabilities.push(cap);
  280.             success = true;
  281.           }
  282.         }
  283.       }
  284.     }
  286.     if (cfg.videoCapabilities) {
  287.       for (const cap of cfg.videoCapabilities) {
  288.         if (cap.contentType) {
  289.           ranAnyTests = true;
  291.           const contentType = cap.contentType.split(';')[0];
  292.           if (WebKitMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  293.             newCfg.videoCapabilities.push(cap);
  294.             success = true;
  295.           }
  296.         }
  297.       }
  298.     }
  300.     if (!ranAnyTests) {
  301.       // If no specific types were requested, we check all common types to
  302.       // find out if the key system is present at all.
  303.       success = WebKitMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  304.     }
  306.     if (success) {
  307.       return newCfg;
  308.     }
  309.     return null;
  310.   }
  312.   /** @override */
  313.   createMediaKeys() {
  314.     shaka.log.debug(
  315.         'PatchedMediaKeysApple.MediaKeySystemAccess.createMediaKeys');
  317.     // Alias
  318.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  320.     const mediaKeys = new PatchedMediaKeysApple.MediaKeys(this.keySystem);
  321.     return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  322.   }
  324.   /** @override */
  325.   getConfiguration() {
  326.     shaka.log.debug(
  327.         'PatchedMediaKeysApple.MediaKeySystemAccess.getConfiguration');
  328.     return this.configuration_;
  329.   }
  330. };
  333. /**
  334.  * An implementation of MediaKeys.
  335.  *
  336.  * @implements {MediaKeys}
  337.  */
  338. shaka.polyfill.PatchedMediaKeysApple.MediaKeys = class {
  339.   /** @param {string} keySystem */
  340.   constructor(keySystem) {
  341.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys');
  343.     /** @private {!WebKitMediaKeys} */
  344.     this.nativeMediaKeys_ = new WebKitMediaKeys(keySystem);
  346.     /** @private {!shaka.util.EventManager} */
  347.     this.eventManager_ = new shaka.util.EventManager();
  348.   }
  350.   /** @override */
  351.   createSession(sessionType) {
  352.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys.createSession');
  354.     sessionType = sessionType || 'temporary';
  355.     // For now, only the 'temporary' type is supported.
  356.     if (sessionType != 'temporary') {
  357.       throw new TypeError('Session type ' + sessionType +
  358.       ' is unsupported on this platform.');
  359.     }
  361.     // Alias
  362.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  364.     return new PatchedMediaKeysApple.MediaKeySession(
  365.         this.nativeMediaKeys_, sessionType);
  366.   }
  368.   /** @override */
  369.   setServerCertificate(serverCertificate) {
  370.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys.setServerCertificate');
  371.     return Promise.resolve(false);
  372.   }
  374.   /**
  375.    * @param {HTMLMediaElement} media
  376.    * @protected
  377.    * @return {!Promise}
  378.    */
  379.   setMedia(media) {
  380.     // Alias
  381.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  383.     // Remove any old listeners.
  384.     this.eventManager_.removeAll();
  386.     // It is valid for media to be null; null is used to flag that event
  387.     // handlers need to be cleaned up.
  388.     if (!media) {
  389.       return Promise.resolve();
  390.     }
  392.     // Intercept and translate these prefixed EME events.
  393.     this.eventManager_.listen(media, 'webkitneedkey',
  394.     /** @type {shaka.util.EventManager.ListenerType} */
  395.         (PatchedMediaKeysApple.onWebkitNeedKey_));
  397.     // Wrap native HTMLMediaElement.webkitSetMediaKeys with a Promise.
  398.     try {
  399.       // Some browsers require that readyState >=1 before mediaKeys can be
  400.       // set, so check this and wait for loadedmetadata if we are not in the
  401.       // correct state
  402.       shaka.util.MediaReadyState.waitForReadyState(media,
  403.           HTMLMediaElement.HAVE_METADATA,
  404.           this.eventManager_, () => {
  405.             media.webkitSetMediaKeys(this.nativeMediaKeys_);
  406.           });
  408.       return Promise.resolve();
  409.     } catch (exception) {
  410.       return Promise.reject(exception);
  411.     }
  412.   }
  413. };
  416. /**
  417.  * An implementation of MediaKeySession.
  418.  *
  419.  * @implements {MediaKeySession}
  420.  */
  421. shaka.polyfill.PatchedMediaKeysApple.MediaKeySession =
  422. class extends shaka.util.FakeEventTarget {
  423.   /**
  424.    * @param {WebKitMediaKeys} nativeMediaKeys
  425.    * @param {string} sessionType
  426.    */
  427.   constructor(nativeMediaKeys, sessionType) {
  428.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession');
  429.     super();
  431.     /**
  432.      * The native MediaKeySession, which will be created in generateRequest.
  433.      * @private {WebKitMediaKeySession}
  434.      */
  435.     this.nativeMediaKeySession_ = null;
  437.     /** @private {WebKitMediaKeys} */
  438.     this.nativeMediaKeys_ = nativeMediaKeys;
  440.     // Promises that are resolved later
  441.     /** @private {shaka.util.PublicPromise} */
  442.     this.generateRequestPromise_ = null;
  444.     /** @private {shaka.util.PublicPromise} */
  445.     this.updatePromise_ = null;
  447.     /** @private {!shaka.util.EventManager} */
  448.     this.eventManager_ = new shaka.util.EventManager();
  450.     /** @type {string} */
  451.     this.sessionId = '';
  453.     /** @type {number} */
  454.     this.expiration = NaN;
  456.     /** @type {!shaka.util.PublicPromise} */
  457.     this.closed = new shaka.util.PublicPromise();
  459.     /** @type {!shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap} */
  460.     this.keyStatuses =
  461.         new shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap();
  462.   }
  464.   /** @override */
  465.   generateRequest(initDataType, initData) {
  466.     shaka.log.debug(
  467.         'PatchedMediaKeysApple.MediaKeySession.generateRequest');
  469.     this.generateRequestPromise_ = new shaka.util.PublicPromise();
  471.     try {
  472.       // This EME spec version requires a MIME content type as the 1st param to
  473.       // createSession, but doesn't seem to matter what the value is.
  474.       // It also only accepts Uint8Array, not ArrayBuffer, so explicitly make
  475.       // initData into a Uint8Array.
  476.       const session = this.nativeMediaKeys_.createSession(
  477.           'video/mp4', shaka.util.BufferUtils.toUint8(initData));
  478.       this.nativeMediaKeySession_ = session;
  479.       this.sessionId = session.sessionId || '';
  481.       // Attach session event handlers here.
  482.       this.eventManager_.listen(
  483.           this.nativeMediaKeySession_, 'webkitkeymessage',
  484.           /** @type {shaka.util.EventManager.ListenerType} */
  485.           ((event) => this.onWebkitKeyMessage_(event)));
  486.       this.eventManager_.listen(session, 'webkitkeyadded',
  487.           /** @type {shaka.util.EventManager.ListenerType} */
  488.           ((event) => this.onWebkitKeyAdded_(event)));
  489.       this.eventManager_.listen(session, 'webkitkeyerror',
  490.           /** @type {shaka.util.EventManager.ListenerType} */
  491.           ((event) => this.onWebkitKeyError_(event)));
  493.       this.updateKeyStatus_('status-pending');
  494.     } catch (exception) {
  495.       this.generateRequestPromise_.reject(exception);
  496.     }
  498.     return this.generateRequestPromise_;
  499.   }
  501.   /** @override */
  502.   load() {
  503.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.load');
  505.     return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  506.   }
  508.   /** @override */
  509.   update(response) {
  510.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.update');
  512.     this.updatePromise_ = new shaka.util.PublicPromise();
  514.     try {
  515.       // Pass through to the native session.
  516.       this.nativeMediaKeySession_.update(
  517.           shaka.util.BufferUtils.toUint8(response));
  518.     } catch (exception) {
  519.       this.updatePromise_.reject(exception);
  520.     }
  522.     return this.updatePromise_;
  523.   }
  525.   /** @override */
  526.   close() {
  527.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.close');
  529.     try {
  530.       // Pass through to the native session.
  531.       this.nativeMediaKeySession_.close();
  533.       this.closed.resolve();
  534.       this.eventManager_.removeAll();
  535.     } catch (exception) {
  536.       this.closed.reject(exception);
  537.     }
  539.     return this.closed;
  540.   }
  542.   /** @override */
  543.   remove() {
  544.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.remove');
  546.     return Promise.reject(new Error(
  547.         'MediaKeySession.remove is only applicable for persistent licenses, ' +
  548.         'which are not supported on this platform'));
  549.   }
  551.   /**
  552.    * Handler for the native keymessage event on WebKitMediaKeySession.
  553.    *
  554.    * @param {!MediaKeyEvent} event
  555.    * @private
  556.    */
  557.   onWebkitKeyMessage_(event) {
  558.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyMessage_', event);
  560.     // We can now resolve this.generateRequestPromise, which should be non-null.
  561.     goog.asserts.assert(this.generateRequestPromise_,
  562.         'generateRequestPromise_ should be set before now!');
  563.     if (this.generateRequestPromise_) {
  564.       this.generateRequestPromise_.resolve();
  565.       this.generateRequestPromise_ = null;
  566.     }
  568.     const isNew = this.keyStatuses.getStatus() == undefined;
  570.     const data = new Map()
  571.         .set('messageType', isNew ? 'license-request' : 'license-renewal')
  572.         .set('message', shaka.util.BufferUtils.toArrayBuffer(event.message));
  573.     const event2 = new shaka.util.FakeEvent('message', data);
  575.     this.dispatchEvent(event2);
  576.   }
  578.   /**
  579.    * Handler for the native keyadded event on WebKitMediaKeySession.
  580.    *
  581.    * @param {!MediaKeyEvent} event
  582.    * @private
  583.    */
  584.   onWebkitKeyAdded_(event) {
  585.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyAdded_', event);
  587.     // This shouldn't fire while we're in the middle of generateRequest,
  588.     // but if it does, we will need to change the logic to account for it.
  589.     goog.asserts.assert(!this.generateRequestPromise_,
  590.         'Key added during generate!');
  592.     // We can now resolve this.updatePromise, which should be non-null.
  593.     goog.asserts.assert(this.updatePromise_,
  594.         'updatePromise_ should be set before now!');
  595.     if (this.updatePromise_) {
  596.       this.updateKeyStatus_('usable');
  597.       this.updatePromise_.resolve();
  598.       this.updatePromise_ = null;
  599.     }
  600.   }
  602.   /**
  603.    * Handler for the native keyerror event on WebKitMediaKeySession.
  604.    *
  605.    * @param {!MediaKeyEvent} event
  606.    * @private
  607.    */
  608.   onWebkitKeyError_(event) {
  609.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyError_', event);
  611.     const error = new Error('EME PatchedMediaKeysApple key error');
  612.     error['errorCode'] = this.nativeMediaKeySession_.error;
  614.     if (this.generateRequestPromise_ != null) {
  615.       this.generateRequestPromise_.reject(error);
  616.       this.generateRequestPromise_ = null;
  617.     } else if (this.updatePromise_ != null) {
  618.       this.updatePromise_.reject(error);
  619.       this.updatePromise_ = null;
  620.     } else {
  621.       // Unexpected error - map native codes to standardised key statuses.
  622.       // Possible values of this.nativeMediaKeySession_.error.code:
  623.       // MEDIA_KEYERR_UNKNOWN        = 1
  624.       // MEDIA_KEYERR_CLIENT         = 2
  625.       // MEDIA_KEYERR_SERVICE        = 3
  626.       // MEDIA_KEYERR_OUTPUT         = 4
  627.       // MEDIA_KEYERR_HARDWARECHANGE = 5
  628.       // MEDIA_KEYERR_DOMAIN         = 6
  630.       switch (this.nativeMediaKeySession_.error.code) {
  631.         case WebKitMediaKeyError.MEDIA_KEYERR_OUTPUT:
  632.         case WebKitMediaKeyError.MEDIA_KEYERR_HARDWARECHANGE:
  633.           this.updateKeyStatus_('output-not-allowed');
  634.           break;
  635.         default:
  636.           this.updateKeyStatus_('internal-error');
  637.           break;
  638.       }
  639.     }
  640.   }
  642.   /**
  643.    * Updates key status and dispatch a 'keystatuseschange' event.
  644.    *
  645.    * @param {string} status
  646.    * @private
  647.    */
  648.   updateKeyStatus_(status) {
  649.     this.keyStatuses.setStatus(status);
  650.     const event = new shaka.util.FakeEvent('keystatuseschange');
  651.     this.dispatchEvent(event);
  652.   }
  653. };
  656. /**
  657.  * @summary An implementation of MediaKeyStatusMap.
  658.  * This fakes a map with a single key ID.
  659.  *
  660.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  661.  * @implements {MediaKeyStatusMap}
  662.  */
  663. shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap = class {
  664.   /** */
  665.   constructor() {
  666.     /**
  667.      * @type {number}
  668.      */
  669.     this.size = 0;
  671.     /**
  672.      * @private {string|undefined}
  673.      */
  674.     this.status_ = undefined;
  675.   }
  677.   /**
  678.    * An internal method used by the session to set key status.
  679.    * @param {string|undefined} status
  680.    */
  681.   setStatus(status) {
  682.     this.size = status == undefined ? 0 : 1;
  683.     this.status_ = status;
  684.   }
  686.   /**
  687.    * An internal method used by the session to get key status.
  688.    * @return {string|undefined}
  689.    */
  690.   getStatus() {
  691.     return this.status_;
  692.   }
  694.   /** @override */
  695.   forEach(fn) {
  696.     if (this.status_) {
  697.       fn(this.status_, shaka.media.DrmEngine.DUMMY_KEY_ID.value());
  698.     }
  699.   }
  701.   /** @override */
  702.   get(keyId) {
  703.     if (this.has(keyId)) {
  704.       return this.status_;
  705.     }
  706.     return undefined;
  707.   }
  709.   /** @override */
  710.   has(keyId) {
  711.     const fakeKeyId = shaka.media.DrmEngine.DUMMY_KEY_ID.value();
  712.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  713.       return true;
  714.     }
  715.     return false;
  716.   }
  718.   /**
  719.    * @suppress {missingReturn}
  720.    * @override
  721.    */
  722.   entries() {
  723.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  724.   }
  726.   /**
  727.    * @suppress {missingReturn}
  728.    * @override
  729.    */
  730.   keys() {
  731.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  732.   }
  734.   /**
  735.    * @suppress {missingReturn}
  736.    * @override
  737.    */
  738.   values() {
  739.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  740.   }
  741. };
  744. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysApple.install);