Source: lib/ads/interstitial_ad_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  8. goog.provide('shaka.ads.InterstitialAdManager');
  10. goog.require('goog.asserts');
  11. goog.require('shaka.Player');
  12. goog.require('shaka.ads.InterstitialAd');
  13. goog.require('shaka.ads.InterstitialStaticAd');
  14. goog.require('shaka.ads.Utils');
  15. goog.require('shaka.device.DeviceFactory');
  16. goog.require('shaka.device.IDevice');
  17. goog.require('shaka.log');
  18. goog.require('shaka.media.PreloadManager');
  19. goog.require('shaka.net.NetworkingEngine');
  20. goog.require('shaka.net.NetworkingUtils');
  21. goog.require('shaka.util.Dom');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.EventManager');
  24. goog.require('shaka.util.FakeEvent');
  25. goog.require('shaka.util.IReleasable');
  26. goog.require('shaka.util.PublicPromise');
  27. goog.require('shaka.util.StringUtils');
  28. goog.require('shaka.util.Timer');
  29. goog.require('shaka.util.TXml');
  32. /**
  33.  * A class responsible for Interstitial ad interactions.
  34.  *
  35.  * @implements {shaka.util.IReleasable}
  36.  */
  37. shaka.ads.InterstitialAdManager = class {
  38.   /**
  39.    * @param {HTMLElement} adContainer
  40.    * @param {shaka.Player} basePlayer
  41.    * @param {HTMLMediaElement} baseVideo
  42.    * @param {function(!shaka.util.FakeEvent)} onEvent
  43.    */
  44.   constructor(adContainer, basePlayer, baseVideo, onEvent) {
  45.     /** @private {?shaka.extern.AdsConfiguration} */
  46.     this.config_ = null;
  48.     /** @private {HTMLElement} */
  49.     this.adContainer_ = adContainer;
  51.     /** @private {shaka.Player} */
  52.     this.basePlayer_ = basePlayer;
  54.     /** @private {HTMLMediaElement} */
  55.     this.baseVideo_ = baseVideo;
  57.     /** @private {?HTMLMediaElement} */
  58.     this.adVideo_ = null;
  60.     /** @private {boolean} */
  61.     this.usingBaseVideo_ = true;
  63.     /** @private {HTMLMediaElement} */
  64.     this.video_ = this.baseVideo_;
  66.     /** @private {function(!shaka.util.FakeEvent)} */
  67.     this.onEvent_ = onEvent;
  69.     /** @private {!Set<string>} */
  70.     this.interstitialIds_ = new Set();
  72.     /** @private {!Set<shaka.extern.AdInterstitial>} */
  73.     this.interstitials_ = new Set();
  75.     /**
  76.      * @private {!Map<shaka.extern.AdInterstitial,
  77.      *                 Promise<?shaka.media.PreloadManager>>}
  78.      */
  79.     this.preloadManagerInterstitials_ = new Map();
  81.     /**
  82.      * @private {!Map<shaka.extern.AdInterstitial, !Array<!HTMLLinkElement>>}
  83.      */
  84.     this.preloadOnDomElements_ = new Map();
  86.     /** @private {shaka.Player} */
  87.     this.player_ = new shaka.Player();
  89.     this.updatePlayerConfig_();
  91.     /** @private {shaka.util.EventManager} */
  92.     this.eventManager_ = new shaka.util.EventManager();
  94.     /** @private {shaka.util.EventManager} */
  95.     this.adEventManager_ = new shaka.util.EventManager();
  97.     /** @private {boolean} */
  98.     this.playingAd_ = false;
  100.     /** @private {?number} */
  101.     this.lastTime_ = null;
  103.     /** @private {?shaka.extern.AdInterstitial} */
  104.     this.lastPlayedAd_ = null;
  106.     /** @private {?shaka.util.Timer} */
  107.     this.playoutLimitTimer_ = null;
  109.     /** @private {?function()} */
  110.     this.lastOnSkip_ = null;
  112.     /** @private {boolean} */
  113.     this.usingListeners_ = false;
  115.     /** @private {number} */
  116.     this.videoCallbackId_ = -1;
  118.     // Note: checkForInterstitials_ and onTimeUpdate_ are defined here because
  119.     // we use it on listener callback, and for unlisten is necessary use the
  120.     // same callback.
  122.     /** @private {function()} */
  123.     this.checkForInterstitials_ = () => {
  124.       if (this.playingAd_ || !this.lastTime_ ||
  125.           this.basePlayer_.isRemotePlayback()) {
  126.         return;
  127.       }
  128.       this.lastTime_ = this.baseVideo_.currentTime;
  129.       const currentInterstitial = this.getCurrentInterstitial_();
  130.       if (currentInterstitial) {
  131.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  132.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  133.       }
  134.     };
  136.     /** @private {function()} */
  137.     this.onTimeUpdate_ = () => {
  138.       if (this.playingAd_ || this.lastTime_ ||
  139.           this.basePlayer_.isRemotePlayback()) {
  140.         return;
  141.       }
  142.       this.lastTime_ = this.baseVideo_.currentTime;
  143.       let currentInterstitial = this.getCurrentInterstitial_(
  144.           /* needPreRoll= */ true);
  145.       if (!currentInterstitial) {
  146.         currentInterstitial = this.getCurrentInterstitial_();
  147.       }
  148.       if (currentInterstitial) {
  149.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  150.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  151.       }
  152.     };
  154.     /** @private {function()} */
  155.     this.onSeeked_ = () => {
  156.       if (this.playingAd_ || !this.lastTime_ ||
  157.           this.basePlayer_.isRemotePlayback()) {
  158.         return;
  159.       }
  160.       const currentTime = this.baseVideo_.currentTime;
  161.       // Remove last played ad when the new time is before the ad time.
  162.       if (this.lastPlayedAd_ &&
  163.           !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  164.           currentTime < (this.lastPlayedAd_.endTime ||
  165.           this.lastPlayedAd_.startTime)) {
  166.         this.lastPlayedAd_ = null;
  167.       }
  168.     };
  170.     /** @private {shaka.util.Timer} */
  171.     this.timeUpdateTimer_ = new shaka.util.Timer(this.checkForInterstitials_);
  174.     /** @private {shaka.util.Timer} */
  175.     this.pollTimer_ = new shaka.util.Timer(async () => {
  176.       if (this.interstitials_.size && this.lastTime_ != null) {
  177.         const currentLoadMode = this.basePlayer_.getLoadMode();
  178.         if (currentLoadMode == shaka.Player.LoadMode.DESTROYED ||
  179.             currentLoadMode == shaka.Player.LoadMode.NOT_LOADED) {
  180.           return;
  181.         }
  182.         let cuepointsChanged = false;
  183.         const interstitials = Array.from(this.interstitials_);
  184.         const seekRange = this.basePlayer_.seekRange();
  185.         for (const interstitial of interstitials) {
  186.           if (interstitial == this.lastPlayedAd_) {
  187.             continue;
  188.           }
  189.           const comparisonTime = interstitial.endTime || interstitial.startTime;
  190.           if ((seekRange.start - comparisonTime) >= 1) {
  191.             if (this.preloadManagerInterstitials_.has(interstitial)) {
  192.               const preloadManager =
  193.                   // eslint-disable-next-line no-await-in-loop
  194.                   await this.preloadManagerInterstitials_.get(interstitial);
  195.               if (preloadManager) {
  196.                 preloadManager.destroy();
  197.               }
  198.               this.preloadManagerInterstitials_.delete(interstitial);
  199.             }
  200.             this.removePreloadOnDomElements_(interstitial);
  201.             const interstitialId = JSON.stringify(interstitial);
  202.             if (this.interstitialIds_.has(interstitialId)) {
  203.               this.interstitialIds_.delete(interstitialId);
  204.             }
  205.             this.interstitials_.delete(interstitial);
  206.             this.removeEventListeners_();
  207.             if (!interstitial.overlay) {
  208.               cuepointsChanged = true;
  209.             }
  210.           } else {
  211.             const difference = interstitial.startTime - this.lastTime_;
  212.             if (difference > 0 && difference <= 10) {
  213.               if (!this.preloadManagerInterstitials_.has(interstitial) &&
  214.                   this.isPreloadAllowed_(interstitial)) {
  215.                 this.preloadManagerInterstitials_.set(
  216.                     interstitial, this.player_.preload(
  217.                         interstitial.uri,
  218.                         /* startTime= */ null,
  219.                         interstitial.mimeType || undefined));
  220.               }
  221.               this.checkPreloadOnDomElements_(interstitial);
  222.             }
  223.           }
  224.         }
  225.         if (cuepointsChanged) {
  226.           this.cuepointsChanged_();
  227.         }
  228.       }
  229.     });
  231.     this.configure(this.basePlayer_.getConfiguration().ads);
  232.   }
  234.   /**
  235.    * Called by the AdManager to provide an updated configuration any time it
  236.    * changes.
  237.    *
  238.    * @param {shaka.extern.AdsConfiguration} config
  239.    */
  240.   configure(config) {
  241.     this.config_ = config;
  242.     this.determineIfUsingBaseVideo_();
  243.   }
  245.   /**
  246.    * @private
  247.    */
  248.   addEventListeners_() {
  249.     if (this.usingListeners_ || !this.interstitials_.size) {
  250.       return;
  251.     }
  252.     this.eventManager_.listen(
  253.         this.baseVideo_, 'playing', this.onTimeUpdate_);
  254.     this.eventManager_.listen(
  255.         this.baseVideo_, 'timeupdate', this.onTimeUpdate_);
  256.     this.eventManager_.listen(
  257.         this.baseVideo_, 'seeked', this.onSeeked_);
  258.     this.eventManager_.listen(
  259.         this.baseVideo_, 'ended', this.checkForInterstitials_);
  260.     if ('requestVideoFrameCallback' in this.baseVideo_ && !this.isSmartTV_()) {
  261.       const baseVideo = /** @type {!HTMLVideoElement} */ (this.baseVideo_);
  262.       const videoFrameCallback = (now, metadata) => {
  263.         if (this.videoCallbackId_ == -1) {
  264.           return;
  265.         }
  266.         this.checkForInterstitials_();
  267.         // It is necessary to check this again because this callback can be
  268.         // executed in another thread by the browser and we have to be sure
  269.         // again here that we have not cancelled it in the middle of an
  270.         // execution.
  271.         if (this.videoCallbackId_ == -1) {
  272.           return;
  273.         }
  274.         this.videoCallbackId_ =
  275.             baseVideo.requestVideoFrameCallback(videoFrameCallback);
  276.       };
  277.       this.videoCallbackId_ =
  278.           baseVideo.requestVideoFrameCallback(videoFrameCallback);
  279.     } else {
  280.       this.timeUpdateTimer_.tickEvery(/* seconds= */ 0.025);
  281.     }
  283.     if (this.pollTimer_) {
  284.       this.pollTimer_.tickEvery(/* seconds= */ 1); ;
  285.     }
  286.     this.usingListeners_ = true;
  287.   }
  289.   /**
  290.    * @private
  291.    */
  292.   removeEventListeners_() {
  293.     if (!this.usingListeners_ || this.interstitials_.size) {
  294.       return;
  295.     }
  296.     this.eventManager_.unlisten(
  297.         this.baseVideo_, 'playing', this.onTimeUpdate_);
  298.     this.eventManager_.unlisten(
  299.         this.baseVideo_, 'timeupdate', this.onTimeUpdate_);
  300.     this.eventManager_.unlisten(
  301.         this.baseVideo_, 'seeked', this.onSeeked_);
  302.     this.eventManager_.unlisten(
  303.         this.baseVideo_, 'ended', this.checkForInterstitials_);
  304.     if (this.videoCallbackId_ != -1) {
  305.       const baseVideo = /** @type {!HTMLVideoElement} */ (this.baseVideo_);
  306.       baseVideo.cancelVideoFrameCallback(this.videoCallbackId_);
  307.       this.videoCallbackId_ = -1;
  308.     }
  309.     if (this.timeUpdateTimer_) {
  310.       this.timeUpdateTimer_.stop();
  311.     }
  312.     if (this.pollTimer_) {
  313.       this.pollTimer_.stop();
  314.     }
  315.     this.usingListeners_ = false;
  316.   }
  318.   /**
  319.    * @private
  320.    */
  321.   determineIfUsingBaseVideo_() {
  322.     if (!this.adContainer_ || !this.config_ || this.playingAd_) {
  323.       this.usingBaseVideo_ = true;
  324.       return;
  325.     }
  326.     let supportsMultipleMediaElements =
  327.         this.config_.supportsMultipleMediaElements;
  328.     const video = /** @type {HTMLVideoElement} */(this.baseVideo_);
  329.     if (video.webkitPresentationMode &&
  330.         video.webkitPresentationMode !== 'inline') {
  331.       supportsMultipleMediaElements = false;
  332.     }
  333.     if (this.usingBaseVideo_ != supportsMultipleMediaElements) {
  334.       return;
  335.     }
  336.     this.usingBaseVideo_ = !supportsMultipleMediaElements;
  337.     if (this.usingBaseVideo_) {
  338.       this.video_ = this.baseVideo_;
  339.       if (this.adVideo_) {
  340.         if (this.adVideo_.parentElement) {
  341.           this.adContainer_.removeChild(this.adVideo_);
  342.         }
  343.         this.adVideo_ = null;
  344.       }
  345.     } else {
  346.       if (!this.adVideo_) {
  347.         this.adVideo_ = this.createMediaElement_();
  348.       }
  349.       this.video_ = this.adVideo_;
  350.     }
  351.   }
  354.   /**
  355.    * Resets the Interstitial manager and removes any continuous polling.
  356.    */
  357.   stop() {
  358.     if (this.adEventManager_) {
  359.       this.adEventManager_.removeAll();
  360.     }
  361.     this.interstitialIds_.clear();
  362.     this.interstitials_.clear();
  363.     this.player_.destroyAllPreloads();
  364.     if (this.preloadManagerInterstitials_.size) {
  365.       const values = Array.from(this.preloadManagerInterstitials_.values());
  366.       for (const value of values) {
  367.         if (value) {
  368.           value.then((preloadManager) => {
  369.             if (preloadManager) {
  370.               preloadManager.destroy();
  371.             }
  372.           });
  373.         }
  374.       };
  375.     }
  376.     this.preloadManagerInterstitials_.clear();
  377.     if (this.preloadOnDomElements_.size) {
  378.       const interstitials = Array.from(this.preloadOnDomElements_.keys());
  379.       for (const interstitial of interstitials) {
  380.         this.removePreloadOnDomElements_(interstitial);
  381.       }
  382.     }
  383.     this.preloadOnDomElements_.clear();
  384.     this.player_.detach();
  385.     this.playingAd_ = false;
  386.     this.lastTime_ = null;
  387.     this.lastPlayedAd_ = null;
  388.     this.usingBaseVideo_ = true;
  389.     this.video_ = this.baseVideo_;
  390.     this.adVideo_ = null;
  391.     this.removeBaseStyles_();
  392.     this.removeEventListeners_();
  393.     if (this.adContainer_) {
  394.       shaka.util.Dom.removeAllChildren(this.adContainer_);
  395.     }
  396.     if (this.playoutLimitTimer_) {
  397.       this.playoutLimitTimer_.stop();
  398.       this.playoutLimitTimer_ = null;
  399.     }
  400.   }
  402.   /** @override */
  403.   release() {
  404.     this.stop();
  405.     if (this.eventManager_) {
  406.       this.eventManager_.release();
  407.     }
  408.     if (this.adEventManager_) {
  409.       this.adEventManager_.release();
  410.     }
  411.     if (this.timeUpdateTimer_) {
  412.       this.timeUpdateTimer_.stop();
  413.       this.timeUpdateTimer_ = null;
  414.     }
  415.     if (this.pollTimer_) {
  416.       this.pollTimer_.stop();
  417.       this.pollTimer_ = null;
  418.     }
  419.     this.player_.destroy();
  420.   }
  422.   /**
  423.    * @return {shaka.Player}
  424.    */
  425.   getPlayer() {
  426.     return this.player_;
  427.   }
  429.   /**
  430.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  431.    */
  432.   async addMetadata(hlsInterstitial) {
  433.     this.updatePlayerConfig_();
  434.     const adInterstitials = await this.getInterstitialsInfo_(hlsInterstitial);
  435.     if (adInterstitials.length) {
  436.       this.addInterstitials(adInterstitials);
  437.     } else {
  438.       shaka.log.alwaysWarn('Unsupported HLS interstitial', hlsInterstitial);
  439.     }
  440.   }
  442.   /**
  443.    * @param {shaka.extern.TimelineRegionInfo} region
  444.    */
  445.   addRegion(region) {
  446.     const TXml = shaka.util.TXml;
  447.     const isReplace =
  448.         region.schemeIdUri == 'urn:mpeg:dash:event:alternativeMPD:replace:2025';
  449.     const isInsert =
  450.         region.schemeIdUri == 'urn:mpeg:dash:event:alternativeMPD:insert:2025';
  451.     if (!isReplace && !isInsert) {
  452.       shaka.log.warning('Unsupported alternative media presentation', region);
  453.       return;
  454.     }
  456.     const startTime = region.startTime;
  457.     let endTime = region.endTime;
  458.     let playoutLimit = null;
  459.     let resumeOffset = 0;
  460.     let interstitialUri;
  461.     for (const node of region.eventNode.children) {
  462.       if (node.tagName == 'AlternativeMPD') {
  463.         const uri = node.attributes['uri'];
  464.         if (uri) {
  465.           interstitialUri = uri;
  466.           break;
  467.         }
  468.       } else if (node.tagName == 'InsertPresentation' ||
  469.           node.tagName == 'ReplacePresentation') {
  470.         const url = node.attributes['url'];
  471.         if (url) {
  472.           interstitialUri = url;
  473.           const unscaledMaxDuration =
  474.               TXml.parseAttr(node, 'maxDuration', TXml.parseInt);
  475.           if (unscaledMaxDuration) {
  476.             playoutLimit = unscaledMaxDuration / region.timescale;
  477.           }
  478.           const unscaledReturnOffset =
  479.               TXml.parseAttr(node, 'returnOffset', TXml.parseInt);
  480.           if (unscaledReturnOffset) {
  481.             resumeOffset = unscaledReturnOffset / region.timescale;
  482.           }
  483.           if (isReplace && resumeOffset) {
  484.             endTime = startTime + resumeOffset;
  485.           }
  486.           break;
  487.         }
  488.       }
  489.     }
  490.     if (!interstitialUri) {
  491.       shaka.log.warning('Unsupported alternative media presentation', region);
  492.       return;
  493.     }
  495.     /** @type {!shaka.extern.AdInterstitial} */
  496.     const interstitial = {
  497.       id: region.id,
  498.       groupId: null,
  499.       startTime,
  500.       endTime,
  501.       uri: interstitialUri,
  502.       mimeType: null,
  503.       isSkippable: false,
  504.       skipOffset: null,
  505.       skipFor: null,
  506.       canJump: true,
  507.       resumeOffset: isInsert ? resumeOffset : null,
  508.       playoutLimit,
  509.       once: false,
  510.       pre: false,
  511.       post: false,
  512.       timelineRange: isReplace && !isInsert,
  513.       loop: false,
  514.       overlay: null,
  515.       displayOnBackground: false,
  516.       currentVideo: null,
  517.       background: null,
  518.     };
  519.     this.addInterstitials([interstitial]);
  520.   }
  522.   /**
  523.    * @param {shaka.extern.TimelineRegionInfo} region
  524.    */
  525.   addOverlayRegion(region) {
  526.     const TXml = shaka.util.TXml;
  528.     goog.asserts.assert(region.eventNode, 'Need a region eventNode');
  529.     const overlayEvent = TXml.findChild(region.eventNode, 'OverlayEvent');
  530.     const uri = overlayEvent.attributes['uri'];
  531.     const mimeType = overlayEvent.attributes['mimeType'];
  532.     const loop = overlayEvent.attributes['loop'] == 'true';
  533.     const z = TXml.parseAttr(overlayEvent, 'z', TXml.parseInt);
  534.     if (!uri || z == 0) {
  535.       shaka.log.warning('Unsupported OverlayEvent', region);
  536.       return;
  537.     }
  539.     let background = null;
  540.     const backgroundElement = TXml.findChild(overlayEvent, 'Background');
  541.     if (backgroundElement) {
  542.       const backgroundUri = backgroundElement.attributes['uri'];
  543.       if (backgroundUri) {
  544.         background = `center / contain no-repeat url('${backgroundUri}')`;
  545.       } else {
  546.         background = TXml.getContents(backgroundElement);
  547.       }
  548.     }
  550.     const viewport = {
  551.       x: 1920,
  552.       y: 1080,
  553.     };
  555.     const viewportElement = TXml.findChild(overlayEvent, 'Viewport');
  556.     if (viewportElement) {
  557.       const viewportX = TXml.parseAttr(viewportElement, 'x', TXml.parseInt);
  558.       if (viewportX == null) {
  559.         shaka.log.warning('Unsupported OverlayEvent', region);
  560.         return;
  561.       }
  562.       const viewportY = TXml.parseAttr(viewportElement, 'y', TXml.parseInt);
  563.       if (viewportY == null) {
  564.         shaka.log.warning('Unsupported OverlayEvent', region);
  565.         return;
  566.       }
  567.       viewport.x = viewportX;
  568.       viewport.y = viewportY;
  569.     }
  571.     /** @type {!shaka.extern.AdPositionInfo} */
  572.     const overlay = {
  573.       viewport: {
  574.         x: viewport.x,
  575.         y: viewport.y,
  576.       },
  577.       topLeft: {
  578.         x: 0,
  579.         y: 0,
  580.       },
  581.       size: {
  582.         x: viewport.x,
  583.         y: viewport.y,
  584.       },
  585.     };
  587.     const overlayElement = TXml.findChild(overlayEvent, 'Overlay');
  588.     if (viewportElement && overlayElement) {
  589.       const topLeft = TXml.findChild(overlayElement, 'TopLeft');
  590.       const size = TXml.findChild(overlayElement, 'Size');
  591.       if (topLeft && size) {
  592.         const topLeftX = TXml.parseAttr(topLeft, 'x', TXml.parseInt);
  593.         if (topLeftX == null) {
  594.           shaka.log.warning('Unsupported OverlayEvent', region);
  595.           return;
  596.         }
  597.         const topLeftY = TXml.parseAttr(topLeft, 'y', TXml.parseInt);
  598.         if (topLeftY == null) {
  599.           shaka.log.warning('Unsupported OverlayEvent', region);
  600.           return;
  601.         }
  602.         const sizeX = TXml.parseAttr(size, 'x', TXml.parseInt);
  603.         if (sizeX == null) {
  604.           shaka.log.warning('Unsupported OverlayEvent', region);
  605.           return;
  606.         }
  607.         const sizeY = TXml.parseAttr(size, 'y', TXml.parseInt);
  608.         if (sizeY == null) {
  609.           shaka.log.warning('Unsupported OverlayEvent', region);
  610.           return;
  611.         }
  612.         overlay.topLeft.x = topLeftX;
  613.         overlay.topLeft.y = topLeftY;
  614.         overlay.size.x = sizeX;
  615.         overlay.size.y = sizeY;
  616.       }
  617.     }
  618.     let currentVideo = null;
  619.     const squeezeElement = TXml.findChild(overlayEvent, 'Squeeze');
  620.     if (viewportElement && squeezeElement) {
  621.       const topLeft = TXml.findChild(squeezeElement, 'TopLeft');
  622.       const size = TXml.findChild(squeezeElement, 'Size');
  623.       if (topLeft && size) {
  624.         const topLeftX = TXml.parseAttr(topLeft, 'x', TXml.parseInt);
  625.         if (topLeftX == null) {
  626.           shaka.log.warning('Unsupported OverlayEvent', region);
  627.           return;
  628.         }
  629.         const topLeftY = TXml.parseAttr(topLeft, 'y', TXml.parseInt);
  630.         if (topLeftY == null) {
  631.           shaka.log.warning('Unsupported OverlayEvent', region);
  632.           return;
  633.         }
  634.         const sizeX = TXml.parseAttr(size, 'x', TXml.parseInt);
  635.         if (sizeX == null) {
  636.           shaka.log.warning('Unsupported OverlayEvent', region);
  637.           return;
  638.         }
  639.         const sizeY = TXml.parseAttr(size, 'y', TXml.parseInt);
  640.         if (sizeY == null) {
  641.           shaka.log.warning('Unsupported OverlayEvent', region);
  642.           return;
  643.         }
  644.         currentVideo = {
  645.           viewport: {
  646.             x: viewport.x,
  647.             y: viewport.y,
  648.           },
  649.           topLeft: {
  650.             x: topLeftX,
  651.             y: topLeftY,
  652.           },
  653.           size: {
  654.             x: sizeX,
  655.             y: sizeY,
  656.           },
  657.         };
  658.       }
  659.     }
  661.     /** @type {!shaka.extern.AdInterstitial} */
  662.     const interstitial = {
  663.       id: region.id,
  664.       groupId: null,
  665.       startTime: region.startTime,
  666.       endTime: region.endTime,
  667.       uri,
  668.       mimeType,
  669.       isSkippable: false,
  670.       skipOffset: null,
  671.       skipFor: null,
  672.       canJump: true,
  673.       resumeOffset: null,
  674.       playoutLimit: null,
  675.       once: false,
  676.       pre: false,
  677.       post: false,
  678.       timelineRange: true,
  679.       loop,
  680.       overlay,
  681.       displayOnBackground: z == -1,
  682.       currentVideo,
  683.       background,
  684.     };
  685.     this.addInterstitials([interstitial]);
  686.   }
  688.   /**
  689.    * @param {string} url
  690.    * @return {!Promise}
  691.    */
  692.   async addAdUrlInterstitial(url) {
  693.     const NetworkingEngine = shaka.net.NetworkingEngine;
  694.     const context = {
  695.       type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_AD_URL,
  696.     };
  697.     const responseData = await this.makeAdRequest_(url, context);
  698.     const data = shaka.util.TXml.parseXml(responseData, 'VAST,vmap:VMAP');
  699.     if (!data) {
  700.       throw new shaka.util.Error(
  701.           shaka.util.Error.Severity.CRITICAL,
  702.           shaka.util.Error.Category.ADS,
  703.           shaka.util.Error.Code.VAST_INVALID_XML);
  704.     }
  705.     /** @type {!Array<shaka.extern.AdInterstitial>} */
  706.     let interstitials = [];
  707.     if (data.tagName == 'VAST') {
  708.       interstitials = shaka.ads.Utils.parseVastToInterstitials(
  709.           data, this.lastTime_);
  710.     } else if (data.tagName == 'vmap:VMAP') {
  711.       const vastProcessing = async (ad) => {
  712.         const vastResponseData = await this.makeAdRequest_(ad.uri, context);
  713.         const vast = shaka.util.TXml.parseXml(vastResponseData, 'VAST');
  714.         if (!vast) {
  715.           throw new shaka.util.Error(
  716.               shaka.util.Error.Severity.CRITICAL,
  717.               shaka.util.Error.Category.ADS,
  718.               shaka.util.Error.Code.VAST_INVALID_XML);
  719.         }
  720.         interstitials.push(...shaka.ads.Utils.parseVastToInterstitials(
  721.             vast, ad.time));
  722.       };
  723.       const promises = [];
  724.       for (const ad of shaka.ads.Utils.parseVMAP(data)) {
  725.         promises.push(vastProcessing(ad));
  726.       }
  727.       if (promises.length) {
  728.         await Promise.all(promises);
  729.       }
  730.     }
  731.     this.addInterstitials(interstitials);
  732.   }
  735.   /**
  736.    * @param {!Array<shaka.extern.AdInterstitial>} interstitials
  737.    */
  738.   async addInterstitials(interstitials) {
  739.     let cuepointsChanged = false;
  740.     for (const interstitial of interstitials) {
  741.       if (!interstitial.uri) {
  742.         shaka.log.alwaysWarn('Missing URL in interstitial', interstitial);
  743.         continue;
  744.       }
  745.       if (!interstitial.mimeType) {
  746.         try {
  747.           const netEngine = this.player_.getNetworkingEngine();
  748.           goog.asserts.assert(netEngine, 'Need networking engine');
  749.           // eslint-disable-next-line no-await-in-loop
  750.           interstitial.mimeType = await shaka.net.NetworkingUtils.getMimeType(
  751.               interstitial.uri, netEngine,
  752.               this.basePlayer_.getConfiguration().streaming.retryParameters);
  753.         } catch (error) {}
  754.       }
  755.       const interstitialId = interstitial.id || JSON.stringify(interstitial);
  756.       if (this.interstitialIds_.has(interstitialId)) {
  757.         continue;
  758.       }
  759.       if (interstitial.loop && !interstitial.overlay) {
  760.         shaka.log.alwaysWarn('Loop is only supported in overlay interstitials',
  761.             interstitial);
  762.       }
  763.       if (!interstitial.overlay) {
  764.         cuepointsChanged = true;
  765.       }
  766.       this.interstitialIds_.add(interstitialId);
  767.       this.interstitials_.add(interstitial);
  768.       let shouldPreload = false;
  769.       if (interstitial.pre && this.lastTime_ == null) {
  770.         shouldPreload = true;
  771.       } else if (interstitial.startTime == 0 && !interstitial.canJump) {
  772.         shouldPreload = true;
  773.       } else if (this.lastTime_ != null) {
  774.         const difference = interstitial.startTime - this.lastTime_;
  775.         if (difference > 0 && difference <= 10) {
  776.           shouldPreload = true;
  777.         }
  778.       }
  779.       if (shouldPreload) {
  780.         if (!this.preloadManagerInterstitials_.has(interstitial) &&
  781.             this.isPreloadAllowed_(interstitial)) {
  782.           this.preloadManagerInterstitials_.set(
  783.               interstitial, this.player_.preload(
  784.                   interstitial.uri,
  785.                   /* startTime= */ null,
  786.                   interstitial.mimeType || undefined));
  787.         }
  788.         this.checkPreloadOnDomElements_(interstitial);
  789.       }
  790.     }
  791.     if (cuepointsChanged) {
  792.       this.cuepointsChanged_();
  793.     }
  794.     this.addEventListeners_();
  795.   }
  797.   /**
  798.    * @return {!HTMLMediaElement}
  799.    * @private
  800.    */
  801.   createMediaElement_() {
  802.     const video = /** @type {!HTMLMediaElement} */(
  803.       document.createElement(this.baseVideo_.tagName));
  804.     video.autoplay = true;
  805.     video.style.position = 'absolute';
  806.     video.style.top = '0';
  807.     video.style.left = '0';
  808.     video.style.width = '100%';
  809.     video.style.height = '100%';
  810.     video.style.display = 'none';
  811.     video.setAttribute('playsinline', '');
  812.     return video;
  813.   }
  816.   /**
  817.    * @param {boolean=} needPreRoll
  818.    * @param {?number=} numberToSkip
  819.    * @return {?shaka.extern.AdInterstitial}
  820.    * @private
  821.    */
  822.   getCurrentInterstitial_(needPreRoll = false, numberToSkip = null) {
  823.     let skipped = 0;
  824.     let currentInterstitial = null;
  825.     if (this.interstitials_.size && this.lastTime_ != null) {
  826.       const isEnded = this.baseVideo_.ended;
  827.       const interstitials = Array.from(this.interstitials_).sort((a, b) => {
  828.         return b.startTime - a.startTime;
  829.       });
  830.       const roundDecimals = (number) => {
  831.         return Math.round(number * 1000) / 1000;
  832.       };
  833.       let interstitialsToCheck = interstitials;
  834.       if (needPreRoll) {
  835.         interstitialsToCheck = interstitials.filter((i) => i.pre);
  836.       } else if (isEnded) {
  837.         interstitialsToCheck = interstitials.filter((i) => i.post);
  838.       } else {
  839.         interstitialsToCheck = interstitials.filter((i) => !i.pre && !i.post);
  840.       }
  841.       for (const interstitial of interstitialsToCheck) {
  842.         let isValid = false;
  843.         if (needPreRoll) {
  844.           isValid = interstitial.pre;
  845.         } else if (isEnded) {
  846.           isValid = interstitial.post;
  847.         } else if (!interstitial.pre && !interstitial.post) {
  848.           const difference =
  849.               this.lastTime_ - roundDecimals(interstitial.startTime);
  850.           let maxDifference = 1;
  851.           if (this.config_.allowStartInMiddleOfInterstitial &&
  852.               interstitial.endTime && interstitial.endTime != Infinity) {
  853.             maxDifference = interstitial.endTime - interstitial.startTime;
  854.           }
  855.           if ((difference > 0 || (difference == 0 && this.lastTime_ == 0)) &&
  856.               (difference <= maxDifference || !interstitial.canJump)) {
  857.             if (numberToSkip == null && this.lastPlayedAd_ &&
  858.                 !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  859.                 this.lastPlayedAd_.startTime >= interstitial.startTime) {
  860.               isValid = false;
  861.             } else {
  862.               isValid = true;
  863.             }
  864.           }
  865.         }
  866.         if (isValid && (!this.lastPlayedAd_ ||
  867.             interstitial.startTime >= this.lastPlayedAd_.startTime)) {
  868.           if (skipped == (numberToSkip || 0)) {
  869.             currentInterstitial = interstitial;
  870.           } else if (currentInterstitial && !interstitial.canJump) {
  871.             const currentStartTime =
  872.                 roundDecimals(currentInterstitial.startTime);
  873.             const newStartTime =
  874.                 roundDecimals(interstitial.startTime);
  875.             if (newStartTime - currentStartTime > 0.001) {
  876.               currentInterstitial = interstitial;
  877.               skipped = 0;
  878.             }
  879.           }
  880.           skipped++;
  881.         }
  882.       }
  883.     }
  884.     return currentInterstitial;
  885.   }
  888.   /**
  889.    * @param {shaka.extern.AdInterstitial} interstitial
  890.    * @param {number} sequenceLength
  891.    * @param {number} adPosition
  892.    * @param {number} initialTime the clock time the ad started at
  893.    * @param {number=} oncePlayed
  894.    * @private
  895.    */
  896.   setupAd_(interstitial, sequenceLength, adPosition, initialTime,
  897.       oncePlayed = 0) {
  898.     shaka.log.info('Starting interstitial',
  899.         interstitial.startTime, 'at', this.lastTime_);
  901.     this.lastPlayedAd_ = interstitial;
  903.     this.determineIfUsingBaseVideo_();
  904.     goog.asserts.assert(this.video_, 'Must have video');
  906.     if (!this.usingBaseVideo_ && this.adContainer_ &&
  907.         !this.video_.parentElement) {
  908.       this.adContainer_.appendChild(this.video_);
  909.     }
  911.     if (adPosition == 1 && sequenceLength == 1) {
  912.       sequenceLength = Array.from(this.interstitials_).filter((i) => {
  913.         if (interstitial.pre) {
  914.           return i.pre == interstitial.pre;
  915.         } else if (interstitial.post) {
  916.           return i.post == interstitial.post;
  917.         }
  918.         return Math.abs(i.startTime - interstitial.startTime) < 0.001;
  919.       }).length;
  920.     }
  922.     if (interstitial.once) {
  923.       oncePlayed++;
  924.       this.interstitials_.delete(interstitial);
  925.       this.removeEventListeners_();
  926.       if (!interstitial.overlay) {
  927.         this.cuepointsChanged_();
  928.       }
  929.     }
  931.     if (interstitial.mimeType) {
  932.       if (interstitial.mimeType.startsWith('image/') ||
  933.           interstitial.mimeType === 'text/html') {
  934.         if (!interstitial.overlay) {
  935.           shaka.log.alwaysWarn('Unsupported interstitial', interstitial);
  936.           return;
  937.         }
  938.         this.setupStaticAd_(interstitial, sequenceLength, adPosition,
  939.             oncePlayed);
  940.         return;
  941.       }
  942.     }
  943.     if (this.usingBaseVideo_ && interstitial.overlay) {
  944.       shaka.log.alwaysWarn('Unsupported interstitial', interstitial);
  945.       return;
  946.     }
  947.     this.setupVideoAd_(interstitial, sequenceLength, adPosition, initialTime,
  948.         oncePlayed);
  949.   }
  952.   /**
  953.    * @param {shaka.extern.AdInterstitial} interstitial
  954.    * @param {number} sequenceLength
  955.    * @param {number} adPosition
  956.    * @param {number} oncePlayed
  957.    * @private
  958.    */
  959.   setupStaticAd_(interstitial, sequenceLength, adPosition, oncePlayed) {
  960.     this.playingAd_ = true;
  962.     const overlay = interstitial.overlay;
  963.     goog.asserts.assert(overlay, 'Must have overlay');
  965.     const tagName = interstitial.mimeType == 'text/html' ? 'iframe' : 'img';
  967.     const htmlElement = /** @type {!(HTMLImageElement|HTMLIFrameElement)} */ (
  968.       document.createElement(tagName));
  969.     htmlElement.style.objectFit = 'contain';
  970.     htmlElement.style.position = 'absolute';
  971.     htmlElement.style.border = 'none';
  973.     this.setBaseStyles_(interstitial);
  975.     const basicTask = () => {
  976.       if (this.playoutLimitTimer_) {
  977.         this.playoutLimitTimer_.stop();
  978.         this.playoutLimitTimer_ = null;
  979.       }
  980.       this.adContainer_.removeChild(htmlElement);
  981.       this.removeBaseStyles_(interstitial);
  982.       this.onEvent_(
  983.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  984.       this.adEventManager_.removeAll();
  985.       const nextCurrentInterstitial = this.getCurrentInterstitial_(
  986.           interstitial.pre, adPosition - oncePlayed);
  987.       if (nextCurrentInterstitial) {
  988.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  989.             ++adPosition, /* initialTime= */ Date.now(), oncePlayed);
  990.       } else {
  991.         this.playingAd_ = false;
  992.       }
  993.     };
  995.     const ad = new shaka.ads.InterstitialStaticAd(
  996.         interstitial, sequenceLength, adPosition);
  998.     this.onEvent_(
  999.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  1000.             (new Map()).set('ad', ad)));
  1002.     if (tagName == 'iframe') {
  1003.       htmlElement.src = interstitial.uri;
  1004.     } else {
  1005.       htmlElement.src = interstitial.uri;
  1006.       htmlElement.onerror = (e) => {
  1007.         this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  1008.             (new Map()).set('originalEvent', e)));
  1009.         basicTask();
  1010.       };
  1011.     }
  1013.     const viewport = overlay.viewport;
  1014.     const topLeft = overlay.topLeft;
  1015.     const size = overlay.size;
  1016.     // Special case for VAST non-linear ads
  1017.     if (viewport.x == 0 && viewport.y == 0) {
  1018.       htmlElement.width = interstitial.overlay.size.x;
  1019.       htmlElement.height = interstitial.overlay.size.y;
  1020.       htmlElement.style.bottom = '10%';
  1021.       htmlElement.style.left = '0';
  1022.       htmlElement.style.right = '0';
  1023.       htmlElement.style.width = '100%';
  1024.       if (!interstitial.overlay.size.y && tagName == 'iframe') {
  1025.         htmlElement.style.height = 'auto';
  1026.       }
  1027.     } else {
  1028.       htmlElement.style.height = (size.y / viewport.y * 100) + '%';
  1029.       htmlElement.style.left = (topLeft.x / viewport.x * 100) + '%';
  1030.       htmlElement.style.top = (topLeft.y / viewport.y * 100) + '%';
  1031.       htmlElement.style.width = (size.x / viewport.x * 100) + '%';
  1032.     }
  1033.     this.adContainer_.appendChild(htmlElement);
  1035.     const startTime = Date.now();
  1036.     if (this.playoutLimitTimer_) {
  1037.       this.playoutLimitTimer_.stop();
  1038.     }
  1039.     this.playoutLimitTimer_ = new shaka.util.Timer(() => {
  1040.       if (interstitial.playoutLimit &&
  1041.           (Date.now() - startTime) / 1000 > interstitial.playoutLimit) {
  1042.         this.onEvent_(
  1043.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  1044.         basicTask();
  1045.       } else if (interstitial.endTime &&
  1046.           this.baseVideo_.currentTime > interstitial.endTime) {
  1047.         this.onEvent_(
  1048.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  1049.         basicTask();
  1050.       } else if (this.baseVideo_.currentTime < interstitial.startTime) {
  1051.         this.onEvent_(
  1052.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  1053.         basicTask();
  1054.       }
  1055.     });
  1056.     if (interstitial.playoutLimit && !interstitial.endTime) {
  1057.       this.playoutLimitTimer_.tickAfter(interstitial.playoutLimit);
  1058.     } else if (interstitial.endTime) {
  1059.       this.playoutLimitTimer_.tickEvery(/* seconds= */ 0.025);
  1060.     }
  1061.     this.adEventManager_.listen(this.baseVideo_, 'seeked', () => {
  1062.       const currentTime = this.baseVideo_.currentTime;
  1063.       if (currentTime < interstitial.startTime ||
  1064.           (interstitial.endTime && currentTime > interstitial.endTime)) {
  1065.         if (this.playoutLimitTimer_) {
  1066.           this.playoutLimitTimer_.stop();
  1067.         }
  1068.         this.onEvent_(
  1069.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  1070.         basicTask();
  1071.       }
  1072.     });
  1073.   }
  1076.   /**
  1077.    * @param {shaka.extern.AdInterstitial} interstitial
  1078.    * @param {number} sequenceLength
  1079.    * @param {number} adPosition
  1080.    * @param {number} initialTime the clock time the ad started at
  1081.    * @param {number} oncePlayed
  1082.    * @private
  1083.    */
  1084.   async setupVideoAd_(interstitial, sequenceLength, adPosition, initialTime,
  1085.       oncePlayed) {
  1086.     goog.asserts.assert(this.video_, 'Must have video');
  1087.     const startTime = Date.now();
  1089.     this.playingAd_ = true;
  1091.     let unloadingInterstitial = false;
  1093.     const updateBaseVideoTime = () => {
  1094.       if (!this.usingBaseVideo_ && !interstitial.overlay) {
  1095.         if (interstitial.resumeOffset == null) {
  1096.           if (interstitial.timelineRange && interstitial.endTime &&
  1097.               interstitial.endTime != Infinity) {
  1098.             if (this.baseVideo_.currentTime != interstitial.endTime) {
  1099.               this.baseVideo_.currentTime = interstitial.endTime;
  1100.             }
  1101.           } else {
  1102.             const now = Date.now();
  1103.             this.baseVideo_.currentTime += (now - initialTime) / 1000;
  1104.             initialTime = now;
  1105.           }
  1106.         }
  1107.       }
  1108.     };
  1110.     const basicTask = async (isSkip) => {
  1111.       updateBaseVideoTime();
  1112.       // Optimization to avoid returning to main content when there is another
  1113.       // interstitial below.
  1114.       let nextCurrentInterstitial = this.getCurrentInterstitial_(
  1115.           interstitial.pre, adPosition - oncePlayed);
  1116.       if (isSkip && interstitial.groupId) {
  1117.         while (nextCurrentInterstitial &&
  1118.             nextCurrentInterstitial.groupId == interstitial.groupId) {
  1119.           adPosition++;
  1120.           nextCurrentInterstitial = this.getCurrentInterstitial_(
  1121.               interstitial.pre, adPosition - oncePlayed);
  1122.         }
  1123.       }
  1124.       if (this.playoutLimitTimer_ && (!interstitial.groupId ||
  1125.           (nextCurrentInterstitial &&
  1126.             nextCurrentInterstitial.groupId != interstitial.groupId))) {
  1127.         this.playoutLimitTimer_.stop();
  1128.         this.playoutLimitTimer_ = null;
  1129.       }
  1130.       this.removeBaseStyles_(interstitial);
  1131.       if (!nextCurrentInterstitial || nextCurrentInterstitial.overlay) {
  1132.         if (interstitial.post) {
  1133.           this.lastTime_ = null;
  1134.           this.lastPlayedAd_ = null;
  1135.         }
  1136.         if (this.usingBaseVideo_) {
  1137.           await this.player_.detach();
  1138.         } else {
  1139.           await this.player_.unload();
  1140.         }
  1141.         if (this.usingBaseVideo_) {
  1142.           let offset = interstitial.resumeOffset;
  1143.           if (offset == null) {
  1144.             if (interstitial.timelineRange && interstitial.endTime &&
  1145.                 interstitial.endTime != Infinity) {
  1146.               offset = interstitial.endTime - (this.lastTime_ || 0);
  1147.             } else {
  1148.               offset = (Date.now() - initialTime) / 1000;
  1149.             }
  1150.           }
  1151.           this.onEvent_(new shaka.util.FakeEvent(
  1152.               shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED,
  1153.               (new Map()).set('offset', offset)));
  1154.         }
  1155.         this.onEvent_(
  1156.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  1157.         this.adEventManager_.removeAll();
  1158.         this.playingAd_ = false;
  1159.         if (!this.usingBaseVideo_) {
  1160.           this.video_.style.display = 'none';
  1161.           updateBaseVideoTime();
  1162.           if (!this.baseVideo_.ended) {
  1163.             this.baseVideo_.play();
  1164.           }
  1165.         } else {
  1166.           this.cuepointsChanged_();
  1167.         }
  1168.       }
  1169.       this.determineIfUsingBaseVideo_();
  1170.       if (nextCurrentInterstitial) {
  1171.         this.onEvent_(
  1172.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  1173.         this.adEventManager_.removeAll();
  1174.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  1175.             ++adPosition, initialTime, oncePlayed);
  1176.       }
  1177.     };
  1178.     const error = async (e) => {
  1179.       if (unloadingInterstitial) {
  1180.         return;
  1181.       }
  1182.       unloadingInterstitial = true;
  1183.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  1184.           (new Map()).set('originalEvent', e)));
  1185.       await basicTask(/* isSkip= */ false);
  1186.     };
  1187.     const complete = async () => {
  1188.       if (unloadingInterstitial) {
  1189.         return;
  1190.       }
  1191.       unloadingInterstitial = true;
  1192.       await basicTask(/* isSkip= */ false);
  1193.       this.onEvent_(
  1194.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  1195.     };
  1196.     this.lastOnSkip_ = async () => {
  1197.       if (unloadingInterstitial) {
  1198.         return;
  1199.       }
  1200.       unloadingInterstitial = true;
  1201.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  1202.       await basicTask(/* isSkip= */ true);
  1203.     };
  1205.     const ad = new shaka.ads.InterstitialAd(this.video_,
  1206.         interstitial, this.lastOnSkip_, sequenceLength, adPosition,
  1207.         !this.usingBaseVideo_);
  1208.     if (!this.usingBaseVideo_) {
  1209.       ad.setMuted(this.baseVideo_.muted);
  1210.       ad.setVolume(this.baseVideo_.volume);
  1211.     }
  1213.     this.onEvent_(
  1214.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  1215.             (new Map()).set('ad', ad)));
  1217.     let prevCanSkipNow = ad.canSkipNow();
  1218.     if (prevCanSkipNow) {
  1219.       this.onEvent_(new shaka.util.FakeEvent(
  1220.           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  1221.     }
  1222.     this.adEventManager_.listenOnce(this.player_, 'error', error);
  1223.     this.adEventManager_.listen(this.video_, 'timeupdate', () => {
  1224.       const duration = this.video_.duration;
  1225.       if (!duration) {
  1226.         return;
  1227.       }
  1228.       const currentCanSkipNow = ad.canSkipNow();
  1229.       if (prevCanSkipNow != currentCanSkipNow &&
  1230.           ad.getRemainingTime() > 0 && ad.getDuration() > 0) {
  1231.         this.onEvent_(
  1232.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  1233.       }
  1234.       prevCanSkipNow = currentCanSkipNow;
  1235.     });
  1236.     this.adEventManager_.listenOnce(this.player_, 'firstquartile', () => {
  1237.       updateBaseVideoTime();
  1238.       this.onEvent_(
  1239.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  1240.     });
  1241.     this.adEventManager_.listenOnce(this.player_, 'midpoint', () => {
  1242.       updateBaseVideoTime();
  1243.       this.onEvent_(
  1244.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  1245.     });
  1246.     this.adEventManager_.listenOnce(this.player_, 'thirdquartile', () => {
  1247.       updateBaseVideoTime();
  1248.       this.onEvent_(
  1249.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  1250.     });
  1251.     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
  1252.     this.adEventManager_.listen(this.video_, 'play', () => {
  1253.       this.onEvent_(
  1254.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  1255.     });
  1256.     this.adEventManager_.listen(this.video_, 'pause', () => {
  1257.       // playRangeEnd in src= causes the ended event not to be fired when that
  1258.       // position is reached, instead pause event is fired.
  1259.       const currentConfig = this.player_.getConfiguration();
  1260.       if (this.video_.currentTime >= currentConfig.playRangeEnd) {
  1261.         complete();
  1262.         return;
  1263.       }
  1264.       this.onEvent_(
  1265.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  1266.     });
  1267.     this.adEventManager_.listen(this.video_, 'volumechange', () => {
  1268.       if (this.video_.muted) {
  1269.         this.onEvent_(
  1270.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  1271.       } else {
  1272.         this.onEvent_(
  1273.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  1274.       }
  1275.     });
  1277.     if (this.usingBaseVideo_ && adPosition == 1) {
  1278.       this.onEvent_(new shaka.util.FakeEvent(
  1279.           shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED,
  1280.           (new Map()).set('saveLivePosition', true)));
  1281.       const detachBasePlayerPromise = new shaka.util.PublicPromise();
  1282.       const checkState = async (e) => {
  1283.         if (e['state'] == 'detach') {
  1284.           if (this.isSmartTV_()) {
  1285.             await new Promise(
  1286.                 (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  1287.           }
  1288.           detachBasePlayerPromise.resolve();
  1289.           this.adEventManager_.unlisten(
  1290.               this.basePlayer_, 'onstatechange', checkState);
  1291.         }
  1292.       };
  1293.       this.adEventManager_.listen(
  1294.           this.basePlayer_, 'onstatechange', checkState);
  1295.       await detachBasePlayerPromise;
  1296.     }
  1297.     this.setBaseStyles_(interstitial);
  1298.     if (!this.usingBaseVideo_) {
  1299.       this.video_.style.display = '';
  1300.       if (interstitial.overlay) {
  1301.         this.video_.loop = interstitial.loop;
  1302.         const viewport = interstitial.overlay.viewport;
  1303.         const topLeft = interstitial.overlay.topLeft;
  1304.         const size = interstitial.overlay.size;
  1305.         this.video_.style.height = (size.y / viewport.y * 100) + '%';
  1306.         this.video_.style.left = (topLeft.x / viewport.x * 100) + '%';
  1307.         this.video_.style.top = (topLeft.y / viewport.y * 100) + '%';
  1308.         this.video_.style.width = (size.x / viewport.x * 100) + '%';
  1309.       } else {
  1310.         this.baseVideo_.pause();
  1311.         if (interstitial.resumeOffset != null &&
  1312.             interstitial.resumeOffset != 0) {
  1313.           this.baseVideo_.currentTime += interstitial.resumeOffset;
  1314.         }
  1315.         this.video_.loop = false;
  1316.         this.video_.style.height = '100%';
  1317.         this.video_.style.left = '0';
  1318.         this.video_.style.top = '0';
  1319.         this.video_.style.width = '100%';
  1320.       }
  1321.     }
  1323.     try {
  1324.       this.updatePlayerConfig_();
  1325.       if (interstitial.startTime && interstitial.endTime &&
  1326.           interstitial.endTime != Infinity &&
  1327.           interstitial.startTime != interstitial.endTime) {
  1328.         const duration = interstitial.endTime - interstitial.startTime;
  1329.         if (duration > 0) {
  1330.           this.player_.configure('playRangeEnd', duration);
  1331.         }
  1332.       }
  1333.       if (interstitial.playoutLimit && !this.playoutLimitTimer_) {
  1334.         this.playoutLimitTimer_ = new shaka.util.Timer(() => {
  1335.           this.lastOnSkip_();
  1336.         }).tickAfter(interstitial.playoutLimit);
  1337.         this.player_.configure('playRangeEnd', interstitial.playoutLimit);
  1338.       }
  1339.       await this.player_.attach(this.video_);
  1340.       let playerStartTime = null;
  1341.       if (this.config_.allowStartInMiddleOfInterstitial &&
  1342.           this.lastTime_ != null) {
  1343.         const newPosition = this.lastTime_ - interstitial.startTime;
  1344.         if (Math.abs(newPosition) > 0.25) {
  1345.           playerStartTime = newPosition;
  1346.         }
  1347.       }
  1348.       if (this.preloadManagerInterstitials_.has(interstitial)) {
  1349.         const preloadManager =
  1350.             await this.preloadManagerInterstitials_.get(interstitial);
  1351.         this.preloadManagerInterstitials_.delete(interstitial);
  1352.         if (preloadManager) {
  1353.           await this.player_.load(preloadManager);
  1354.         } else {
  1355.           await this.player_.load(
  1356.               interstitial.uri,
  1357.               playerStartTime,
  1358.               interstitial.mimeType || undefined);
  1359.         }
  1360.       } else {
  1361.         await this.player_.load(
  1362.             interstitial.uri,
  1363.             playerStartTime,
  1364.             interstitial.mimeType || undefined);
  1365.       }
  1366.       this.video_.play();
  1367.       const loadTime = (Date.now() - startTime) / 1000;
  1368.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  1369.           (new Map()).set('loadTime', loadTime)));
  1370.       if (this.usingBaseVideo_) {
  1371.         this.baseVideo_.play();
  1372.       }
  1373.       if (interstitial.overlay) {
  1374.         const setPosition = () => {
  1375.           const newPosition =
  1376.               this.baseVideo_.currentTime - interstitial.startTime;
  1377.           if (Math.abs(newPosition - this.video_.currentTime) > 0.1) {
  1378.             this.video_.currentTime = newPosition;
  1379.           }
  1380.         };
  1381.         this.adEventManager_.listenOnce(this.video_, 'playing', setPosition);
  1382.         this.adEventManager_.listen(this.baseVideo_, 'seeking', setPosition);
  1383.         this.adEventManager_.listen(this.baseVideo_, 'seeked', () => {
  1384.           const currentTime = this.baseVideo_.currentTime;
  1385.           if (currentTime < interstitial.startTime ||
  1386.               (interstitial.endTime && currentTime > interstitial.endTime)) {
  1387.             this.lastOnSkip_();
  1388.           }
  1389.         });
  1390.       }
  1391.     } catch (e) {
  1392.       if (!this.playingAd_) {
  1393.         return;
  1394.       }
  1395.       error(e);
  1396.     }
  1397.   }
  1399.   /**
  1400.    * @param {shaka.extern.AdInterstitial} interstitial
  1401.    * @private
  1402.    */
  1403.   setBaseStyles_(interstitial) {
  1404.     if (interstitial.displayOnBackground) {
  1405.       this.baseVideo_.style.zIndex = '1';
  1406.     }
  1407.     if (interstitial.currentVideo != null) {
  1408.       const currentVideo = interstitial.currentVideo;
  1409.       this.baseVideo_.style.transformOrigin = 'top left';
  1410.       let addTransition = true;
  1411.       const transforms = [];
  1412.       const translateX = currentVideo.topLeft.x / currentVideo.viewport.x * 100;
  1413.       if (translateX > 0 && translateX <= 100) {
  1414.         transforms.push(`translateX(${translateX}%)`);
  1415.         // In the case of double box ads we do not want transitions.
  1416.         addTransition = false;
  1417.       }
  1418.       const translateY = currentVideo.topLeft.y / currentVideo.viewport.y * 100;
  1419.       if (translateY > 0 && translateY <= 100) {
  1420.         transforms.push(`translateY(${translateY}%)`);
  1421.         // In the case of double box ads we do not want transitions.
  1422.         addTransition = false;
  1423.       }
  1424.       const scaleX = currentVideo.size.x / currentVideo.viewport.x;
  1425.       if (scaleX < 1) {
  1426.         transforms.push(`scaleX(${scaleX})`);
  1427.       }
  1428.       const scaleY = currentVideo.size.y / currentVideo.viewport.y;
  1429.       if (scaleX < 1) {
  1430.         transforms.push(`scaleY(${scaleY})`);
  1431.       }
  1432.       if (transforms.length) {
  1433.         this.baseVideo_.style.transform = transforms.join(' ');
  1434.       }
  1435.       if (addTransition) {
  1436.         this.baseVideo_.style.transition = 'transform 250ms';
  1437.       }
  1438.     }
  1439.     if (this.adContainer_) {
  1440.       this.adContainer_.style.pointerEvents = 'none';
  1441.       if (interstitial.background) {
  1442.         this.adContainer_.style.background = interstitial.background;
  1443.       }
  1444.     }
  1445.     if (this.adVideo_) {
  1446.       if (interstitial.overlay) {
  1447.         this.adVideo_.style.background = '';
  1448.       } else {
  1449.         this.adVideo_.style.background = 'rgb(0, 0, 0)';
  1450.       }
  1451.     }
  1452.   }
  1454.   /**
  1455.    * @param {?shaka.extern.AdInterstitial=} interstitial
  1456.    * @private
  1457.    */
  1458.   removeBaseStyles_(interstitial) {
  1459.     if (!interstitial || interstitial.displayOnBackground) {
  1460.       this.baseVideo_.style.zIndex = '';
  1461.     }
  1462.     if (!interstitial || interstitial.currentVideo != null) {
  1463.       this.baseVideo_.style.transformOrigin = '';
  1464.       this.baseVideo_.style.transition = '';
  1465.       this.baseVideo_.style.transform = '';
  1466.     }
  1467.     if (this.adContainer_) {
  1468.       this.adContainer_.style.pointerEvents = '';
  1469.       if (!interstitial || interstitial.background) {
  1470.         this.adContainer_.style.background = '';
  1471.       }
  1472.     }
  1473.     if (this.adVideo_) {
  1474.       this.adVideo_.style.background = '';
  1475.     }
  1476.   }
  1478.   /**
  1479.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  1480.    * @return {!Promise<!Array<shaka.extern.AdInterstitial>>}
  1481.    * @private
  1482.    */
  1483.   async getInterstitialsInfo_(hlsInterstitial) {
  1484.     const interstitialsAd = [];
  1485.     if (!hlsInterstitial) {
  1486.       return interstitialsAd;
  1487.     }
  1488.     const assetUri = hlsInterstitial.values.find((v) => v.key == 'X-ASSET-URI');
  1489.     const assetList =
  1490.         hlsInterstitial.values.find((v) => v.key == 'X-ASSET-LIST');
  1491.     if (!assetUri && !assetList) {
  1492.       return interstitialsAd;
  1493.     }
  1494.     let id = null;
  1495.     const hlsInterstitialId = hlsInterstitial.values.find((v) => v.key == 'ID');
  1496.     if (hlsInterstitialId) {
  1497.       id = /** @type {string} */(hlsInterstitialId.data);
  1498.     }
  1499.     const startTime = id == null ?
  1500.         Math.floor(hlsInterstitial.startTime * 10) / 10:
  1501.         hlsInterstitial.startTime;
  1502.     let endTime = hlsInterstitial.endTime;
  1503.     if (hlsInterstitial.endTime && hlsInterstitial.endTime != Infinity &&
  1504.         typeof(hlsInterstitial.endTime) == 'number') {
  1505.       endTime = id == null ?
  1506.           Math.floor(hlsInterstitial.endTime * 10) / 10:
  1507.           hlsInterstitial.endTime;
  1508.     }
  1509.     const restrict = hlsInterstitial.values.find((v) => v.key == 'X-RESTRICT');
  1510.     let isSkippable = true;
  1511.     let canJump = true;
  1512.     if (restrict && restrict.data) {
  1513.       const data = /** @type {string} */(restrict.data);
  1514.       isSkippable = !data.includes('SKIP');
  1515.       canJump = !data.includes('JUMP');
  1516.     }
  1517.     let skipOffset = isSkippable ? 0 : null;
  1518.     const enableSkipAfter =
  1519.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-AFTER');
  1520.     if (enableSkipAfter) {
  1521.       const enableSkipAfterString = /** @type {string} */(enableSkipAfter.data);
  1522.       skipOffset = parseFloat(enableSkipAfterString);
  1523.       if (isNaN(skipOffset)) {
  1524.         skipOffset = isSkippable ? 0 : null;
  1525.       }
  1526.     }
  1527.     let skipFor = null;
  1528.     const enableSkipFor =
  1529.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-FOR');
  1530.     if (enableSkipFor) {
  1531.       const enableSkipForString = /** @type {string} */(enableSkipFor.data);
  1532.       skipFor = parseFloat(enableSkipForString);
  1533.       if (isNaN(skipOffset)) {
  1534.         skipFor = null;
  1535.       }
  1536.     }
  1537.     let resumeOffset = null;
  1538.     const resume =
  1539.         hlsInterstitial.values.find((v) => v.key == 'X-RESUME-OFFSET');
  1540.     if (resume) {
  1541.       const resumeOffsetString = /** @type {string} */(resume.data);
  1542.       resumeOffset = parseFloat(resumeOffsetString);
  1543.       if (isNaN(resumeOffset)) {
  1544.         resumeOffset = null;
  1545.       }
  1546.     }
  1547.     let playoutLimit = null;
  1548.     const playout =
  1549.         hlsInterstitial.values.find((v) => v.key == 'X-PLAYOUT-LIMIT');
  1550.     if (playout) {
  1551.       const playoutLimitString = /** @type {string} */(playout.data);
  1552.       playoutLimit = parseFloat(playoutLimitString);
  1553.       if (isNaN(playoutLimit)) {
  1554.         playoutLimit = null;
  1555.       }
  1556.     }
  1557.     let once = false;
  1558.     let pre = false;
  1559.     let post = false;
  1560.     const cue = hlsInterstitial.values.find((v) => v.key == 'CUE');
  1561.     if (cue) {
  1562.       const data = /** @type {string} */(cue.data);
  1563.       once = data.includes('ONCE');
  1564.       pre = data.includes('PRE');
  1565.       post = data.includes('POST');
  1566.     }
  1567.     let timelineRange = false;
  1568.     const timelineOccupies =
  1569.         hlsInterstitial.values.find((v) => v.key == 'X-TIMELINE-OCCUPIES');
  1570.     if (timelineOccupies) {
  1571.       const data = /** @type {string} */(timelineOccupies.data);
  1572.       timelineRange = data.includes('RANGE');
  1573.     } else if (!resume && this.basePlayer_.isLive()) {
  1574.       timelineRange = !pre && !post;
  1575.     }
  1576.     if (assetUri) {
  1577.       const uri = /** @type {string} */(assetUri.data);
  1578.       if (!uri) {
  1579.         return interstitialsAd;
  1580.       }
  1581.       interstitialsAd.push({
  1582.         id,
  1583.         groupId: null,
  1584.         startTime,
  1585.         endTime,
  1586.         uri,
  1587.         mimeType: null,
  1588.         isSkippable,
  1589.         skipOffset,
  1590.         skipFor,
  1591.         canJump,
  1592.         resumeOffset,
  1593.         playoutLimit,
  1594.         once,
  1595.         pre,
  1596.         post,
  1597.         timelineRange,
  1598.         loop: false,
  1599.         overlay: null,
  1600.         displayOnBackground: false,
  1601.         currentVideo: null,
  1602.         background: null,
  1603.       });
  1604.     } else if (assetList) {
  1605.       const uri = /** @type {string} */(assetList.data);
  1606.       if (!uri) {
  1607.         return interstitialsAd;
  1608.       }
  1609.       try {
  1610.         const NetworkingEngine = shaka.net.NetworkingEngine;
  1611.         const context = {
  1612.           type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_ASSET_LIST,
  1613.         };
  1614.         const responseData = await this.makeAdRequest_(uri, context);
  1615.         const data = shaka.util.StringUtils.fromUTF8(responseData);
  1616.         const dataAsJson =
  1617.         /** @type {!shaka.ads.InterstitialAdManager.AssetsList} */ (
  1618.             JSON.parse(data));
  1619.         const skipControl = dataAsJson['SKIP-CONTROL'];
  1620.         if (skipControl) {
  1621.           const enableSkipAfterValue = skipControl['ENABLE-SKIP-AFTER'];
  1622.           if ((typeof enableSkipAfterValue) == 'number') {
  1623.             skipOffset = parseFloat(enableSkipAfterValue);
  1624.             if (isNaN(enableSkipAfterValue)) {
  1625.               skipOffset = isSkippable ? 0 : null;
  1626.             }
  1627.           }
  1628.           const enableSkipForValue = skipControl['ENABLE-SKIP-FOR'];
  1629.           if ((typeof enableSkipForValue) == 'number') {
  1630.             skipFor = parseFloat(enableSkipForValue);
  1631.             if (isNaN(enableSkipForValue)) {
  1632.               skipFor = null;
  1633.             }
  1634.           }
  1635.         }
  1636.         for (let i = 0; i < dataAsJson['ASSETS'].length; i++) {
  1637.           const asset = dataAsJson['ASSETS'][i];
  1638.           if (asset['URI']) {
  1639.             interstitialsAd.push({
  1640.               id: id + '_shaka_asset_' + i,
  1641.               groupId: id,
  1642.               startTime,
  1643.               endTime,
  1644.               uri: asset['URI'],
  1645.               mimeType: null,
  1646.               isSkippable,
  1647.               skipOffset,
  1648.               skipFor,
  1649.               canJump,
  1650.               resumeOffset,
  1651.               playoutLimit,
  1652.               once,
  1653.               pre,
  1654.               post,
  1655.               timelineRange,
  1656.               loop: false,
  1657.               overlay: null,
  1658.               displayOnBackground: false,
  1659.               currentVideo: null,
  1660.               background: null,
  1661.             });
  1662.           }
  1663.         }
  1664.       } catch (e) {
  1665.         // Ignore errors
  1666.       }
  1667.     }
  1668.     return interstitialsAd;
  1669.   }
  1672.   /**
  1673.    * @private
  1674.    */
  1675.   cuepointsChanged_() {
  1676.     /** @type {!Array<!shaka.extern.AdCuePoint>} */
  1677.     const cuePoints = [];
  1678.     for (const interstitial of this.interstitials_) {
  1679.       if (interstitial.overlay) {
  1680.         continue;
  1681.       }
  1682.       /** @type {shaka.extern.AdCuePoint} */
  1683.       const shakaCuePoint = {
  1684.         start: interstitial.startTime,
  1685.         end: null,
  1686.       };
  1687.       if (interstitial.pre) {
  1688.         shakaCuePoint.start = 0;
  1689.         shakaCuePoint.end = null;
  1690.       } else if (interstitial.post) {
  1691.         shakaCuePoint.start = -1;
  1692.         shakaCuePoint.end = null;
  1693.       } else if (interstitial.timelineRange) {
  1694.         shakaCuePoint.end = interstitial.endTime;
  1695.       }
  1696.       const isValid = !cuePoints.find((c) => {
  1697.         return shakaCuePoint.start == c.start && shakaCuePoint.end == c.end;
  1698.       });
  1699.       if (isValid) {
  1700.         cuePoints.push(shakaCuePoint);
  1701.       }
  1702.     }
  1704.     this.onEvent_(new shaka.util.FakeEvent(
  1705.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  1706.         (new Map()).set('cuepoints', cuePoints)));
  1707.   }
  1710.   /**
  1711.    * @private
  1712.    */
  1713.   updatePlayerConfig_() {
  1714.     goog.asserts.assert(this.player_, 'Must have player');
  1715.     goog.asserts.assert(this.basePlayer_, 'Must have base player');
  1716.     this.player_.configure(this.basePlayer_.getNonDefaultConfiguration());
  1717.     this.player_.configure('ads.disableHLSInterstitial', true);
  1718.     this.player_.configure('ads.disableDASHInterstitial', true);
  1719.     this.player_.configure('playRangeEnd', Infinity);
  1720.     const netEngine = this.player_.getNetworkingEngine();
  1721.     goog.asserts.assert(netEngine, 'Need networking engine');
  1722.     this.basePlayer_.getNetworkingEngine().copyFiltersInto(netEngine);
  1723.   }
  1725.   /**
  1726.    * @param {string} url
  1727.    * @param {shaka.extern.RequestContext=} context
  1728.    * @return {!Promise<BufferSource>}
  1729.    * @private
  1730.    */
  1731.   async makeAdRequest_(url, context) {
  1732.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  1733.     const request = shaka.net.NetworkingEngine.makeRequest(
  1734.         [url],
  1735.         shaka.net.NetworkingEngine.defaultRetryParameters());
  1736.     const op = this.basePlayer_.getNetworkingEngine()
  1737.         .request(type, request, context);
  1738.     const response = await op.promise;
  1739.     return response.data;
  1740.   }
  1742.   /**
  1743.    * @param {!shaka.extern.AdInterstitial} interstitial
  1744.    * @return {boolean}
  1745.    * @private
  1746.    */
  1747.   isPreloadAllowed_(interstitial) {
  1748.     const interstitialMimeType = interstitial.mimeType;
  1749.     if (!interstitialMimeType) {
  1750.       return true;
  1751.     }
  1752.     return !interstitialMimeType.startsWith('image/') &&
  1753.         interstitialMimeType !== 'text/html';
  1754.   }
  1757.   /**
  1758.    * Only for testing
  1759.    *
  1760.    * @return {!Array<shaka.extern.AdInterstitial>}
  1761.    */
  1762.   getInterstitials() {
  1763.     return Array.from(this.interstitials_);
  1764.   }
  1766.   /**
  1767.    * @return {boolean}
  1768.    * @private
  1769.    */
  1770.   isSmartTV_() {
  1771.     const device = shaka.device.DeviceFactory.getDevice();
  1772.     const deviceType = device.getDeviceType();
  1773.     if (deviceType == shaka.device.IDevice.DeviceType.TV ||
  1774.         deviceType == shaka.device.IDevice.DeviceType.CONSOLE ||
  1775.         deviceType == shaka.device.IDevice.DeviceType.CAST) {
  1776.       return true;
  1777.     }
  1778.     return false;
  1779.   }
  1781.   /**
  1782.    * @param {!shaka.extern.AdInterstitial} interstitial
  1783.    * @private
  1784.    */
  1785.   checkPreloadOnDomElements_(interstitial) {
  1786.     if (this.preloadOnDomElements_.has(interstitial) ||
  1787.         (this.config_ && !this.config_.allowPreloadOnDomElements)) {
  1788.       return;
  1789.     }
  1790.     const createAndAddLink = (url) => {
  1791.       const link = /** @type {HTMLLinkElement} */(
  1792.         document.createElement('link'));
  1793.       link.rel = 'preload';
  1794.       link.href = url;
  1795.       link.as = 'image';
  1796.       document.head.appendChild(link);
  1797.       return link;
  1798.     };
  1799.     const links = [];
  1800.     if (interstitial.background) {
  1801.       const urlRegExp = /url\(('|")?([^'"()]+)('|")\)?/;
  1802.       const match = interstitial.background.match(urlRegExp);
  1803.       if (match) {
  1804.         links.push(createAndAddLink(match[2]));
  1805.       }
  1806.     }
  1807.     if (interstitial.mimeType.startsWith('image/')) {
  1808.       links.push(createAndAddLink(interstitial.uri));
  1809.     }
  1810.     this.preloadOnDomElements_.set(interstitial, links);
  1811.   }
  1814.   /**
  1815.    * @param {!shaka.extern.AdInterstitial} interstitial
  1816.    * @private
  1817.    */
  1818.   removePreloadOnDomElements_(interstitial) {
  1819.     if (!this.preloadOnDomElements_.has(interstitial)) {
  1820.       return;
  1821.     }
  1822.     const links = this.preloadOnDomElements_.get(interstitial);
  1823.     for (const link of links) {
  1824.       link.parentNode.removeChild(link);
  1825.     }
  1826.     this.preloadOnDomElements_.delete(interstitial);
  1827.   }
  1828. };
  1831. /**
  1832.  * @typedef {{
  1833.  *   ASSETS: !Array<shaka.ads.InterstitialAdManager.Asset>,
  1834.  *   SKIP-CONTROL: ?shaka.ads.InterstitialAdManager.SkipControl,
  1835.  * }}
  1836.  *
  1837.  * @property {!Array<shaka.ads.InterstitialAdManager.Asset>} ASSETS
  1838.  * @property {shaka.ads.InterstitialAdManager.SkipControl} SKIP-CONTROL
  1839.  */
  1840. shaka.ads.InterstitialAdManager.AssetsList;
  1843. /**
  1844.  * @typedef {{
  1845.  *   URI: string,
  1846.  * }}
  1847.  *
  1848.  * @property {string} URI
  1849.  */
  1850. shaka.ads.InterstitialAdManager.Asset;
  1853. /**
  1854.  * @typedef {{
  1855.  *   ENABLE-SKIP-AFTER: number,
  1856.  *   ENABLE-SKIP-FOR: number,
  1857.  * }}
  1858.  *
  1859.  * @property {number} ENABLE-SKIP-AFTER
  1860.  * @property {number} ENABLE-SKIP-FOR
  1861.  */
  1862. shaka.ads.InterstitialAdManager.SkipControl;