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.log');
  16. goog.require('shaka.media.PreloadManager');
  17. goog.require('shaka.net.NetworkingEngine');
  18. goog.require('shaka.net.NetworkingUtils');
  19. goog.require('shaka.util.Dom');
  20. goog.require('shaka.util.Error');
  21. goog.require('shaka.util.EventManager');
  22. goog.require('shaka.util.FakeEvent');
  23. goog.require('shaka.util.IReleasable');
  24. goog.require('shaka.util.Platform');
  25. goog.require('shaka.util.PublicPromise');
  26. goog.require('shaka.util.StringUtils');
  27. goog.require('shaka.util.Timer');
  28. goog.require('shaka.util.TXml');
  31. /**
  32.  * A class responsible for Interstitial ad interactions.
  33.  *
  34.  * @implements {shaka.util.IReleasable}
  35.  */
  36. shaka.ads.InterstitialAdManager = class {
  37.   /**
  38.    * @param {HTMLElement} adContainer
  39.    * @param {shaka.Player} basePlayer
  40.    * @param {HTMLMediaElement} baseVideo
  41.    * @param {function(!shaka.util.FakeEvent)} onEvent
  42.    */
  43.   constructor(adContainer, basePlayer, baseVideo, onEvent) {
  44.     /** @private {?shaka.extern.AdsConfiguration} */
  45.     this.config_ = null;
  47.     /** @private {HTMLElement} */
  48.     this.adContainer_ = adContainer;
  50.     /** @private {shaka.Player} */
  51.     this.basePlayer_ = basePlayer;
  53.     /** @private {HTMLMediaElement} */
  54.     this.baseVideo_ = baseVideo;
  56.     /** @private {?HTMLMediaElement} */
  57.     this.adVideo_ = null;
  59.     /** @private {boolean} */
  60.     this.usingBaseVideo_ = true;
  62.     /** @private {HTMLMediaElement} */
  63.     this.video_ = this.baseVideo_;
  65.     /** @private {function(!shaka.util.FakeEvent)} */
  66.     this.onEvent_ = onEvent;
  68.     /** @private {!Set<string>} */
  69.     this.interstitialIds_ = new Set();
  71.     /** @private {!Set<shaka.extern.AdInterstitial>} */
  72.     this.interstitials_ = new Set();
  74.     /**
  75.      * @private {!Map<shaka.extern.AdInterstitial,
  76.      *                 Promise<?shaka.media.PreloadManager>>}
  77.      */
  78.     this.preloadManagerInterstitials_ = new Map();
  80.     /** @private {shaka.Player} */
  81.     this.player_ = new shaka.Player();
  83.     this.updatePlayerConfig_();
  85.     /** @private {shaka.util.EventManager} */
  86.     this.eventManager_ = new shaka.util.EventManager();
  88.     /** @private {shaka.util.EventManager} */
  89.     this.adEventManager_ = new shaka.util.EventManager();
  91.     /** @private {boolean} */
  92.     this.playingAd_ = false;
  94.     /** @private {?number} */
  95.     this.lastTime_ = null;
  97.     /** @private {?shaka.extern.AdInterstitial} */
  98.     this.lastPlayedAd_ = null;
  100.     /** @private {?shaka.util.Timer} */
  101.     this.playoutLimitTimer_ = null;
  103.     /** @private {?function()} */
  104.     this.lastOnSkip_ = null;
  106.     this.eventManager_.listen(this.baseVideo_, 'timeupdate', () => {
  107.       if (this.playingAd_ || this.lastTime_ ||
  108.           this.basePlayer_.isRemotePlayback()) {
  109.         return;
  110.       }
  111.       this.lastTime_ = this.baseVideo_.currentTime;
  112.       const currentInterstitial = this.getCurrentInterstitial_(
  113.           /* needPreRoll= */ true);
  114.       if (currentInterstitial) {
  115.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  116.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  117.       }
  118.     });
  120.     const checkForInterstitials = () => {
  121.       if (this.playingAd_ || !this.lastTime_ ||
  122.           this.basePlayer_.isRemotePlayback()) {
  123.         return;
  124.       }
  125.       this.lastTime_ = this.baseVideo_.currentTime;
  126.       // Remove last played add when the new time is before to the ad time.
  127.       if (this.lastPlayedAd_ &&
  128.           !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  129.           this.lastTime_ < this.lastPlayedAd_.startTime) {
  130.         this.lastPlayedAd_ = null;
  131.       }
  132.       const currentInterstitial = this.getCurrentInterstitial_();
  133.       if (currentInterstitial) {
  134.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  135.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  136.       }
  137.     };
  139.     this.eventManager_.listen(this.baseVideo_, 'ended', () => {
  140.       checkForInterstitials();
  141.     });
  143.     /** @private {shaka.util.Timer} */
  144.     this.timeUpdateTimer_ = new shaka.util.Timer(checkForInterstitials);
  146.     if ('requestVideoFrameCallback' in this.baseVideo_ &&
  147.         !shaka.util.Platform.isSmartTV()) {
  148.       const baseVideo = /** @type {!HTMLVideoElement} */ (this.baseVideo_);
  149.       const videoFrameCallback = () => {
  150.         checkForInterstitials();
  151.         baseVideo.requestVideoFrameCallback(videoFrameCallback);
  152.       };
  153.       baseVideo.requestVideoFrameCallback(videoFrameCallback);
  154.     } else {
  155.       this.timeUpdateTimer_.tickEvery(/* seconds= */ 0.025);
  156.     }
  158.     /** @private {shaka.util.Timer} */
  159.     this.pollTimer_ = new shaka.util.Timer(async () => {
  160.       if (this.interstitials_.size && this.lastTime_ != null) {
  161.         const currentLoadMode = this.basePlayer_.getLoadMode();
  162.         if (currentLoadMode == shaka.Player.LoadMode.DESTROYED ||
  163.             currentLoadMode == shaka.Player.LoadMode.NOT_LOADED) {
  164.           return;
  165.         }
  166.         let cuepointsChanged = false;
  167.         const interstitials = Array.from(this.interstitials_);
  168.         const seekRange = this.basePlayer_.seekRange();
  169.         for (const interstitial of interstitials) {
  170.           if (interstitial == this.lastPlayedAd_) {
  171.             continue;
  172.           }
  173.           const comparisonTime = interstitial.endTime || interstitial.startTime;
  174.           if ((seekRange.start - comparisonTime) >= 1) {
  175.             if (this.preloadManagerInterstitials_.has(interstitial)) {
  176.               const preloadManager =
  177.                   // eslint-disable-next-line no-await-in-loop
  178.                   await this.preloadManagerInterstitials_.get(interstitial);
  179.               if (preloadManager) {
  180.                 preloadManager.destroy();
  181.               }
  182.               this.preloadManagerInterstitials_.delete(interstitial);
  183.             }
  184.             const interstitialId = JSON.stringify(interstitial);
  185.             if (this.interstitialIds_.has(interstitialId)) {
  186.               this.interstitialIds_.delete(interstitialId);
  187.             }
  188.             this.interstitials_.delete(interstitial);
  189.             if (!interstitial.overlay) {
  190.               cuepointsChanged = true;
  191.             }
  192.           } else {
  193.             const difference = interstitial.startTime - this.lastTime_;
  194.             if (difference > 0 && difference <= 10) {
  195.               if (!this.preloadManagerInterstitials_.has(interstitial) &&
  196.                   this.isPreloadAllowed_(interstitial)) {
  197.                 this.preloadManagerInterstitials_.set(
  198.                     interstitial, this.player_.preload(
  199.                         interstitial.uri,
  200.                         /* startTime= */ null,
  201.                         interstitial.mimeType || undefined));
  202.               }
  203.             }
  204.           }
  205.         }
  206.         if (cuepointsChanged) {
  207.           this.cuepointsChanged_();
  208.         }
  209.       }
  210.     }).tickEvery(/* seconds= */ 1);
  211.   }
  213.   /**
  214.    * Called by the AdManager to provide an updated configuration any time it
  215.    * changes.
  216.    *
  217.    * @param {shaka.extern.AdsConfiguration} config
  218.    */
  219.   configure(config) {
  220.     this.config_ = config;
  221.     this.determineIfUsingBaseVideo_();
  222.   }
  224.   /**
  225.    * @private
  226.    */
  227.   determineIfUsingBaseVideo_() {
  228.     if (!this.adContainer_ || !this.config_ || this.playingAd_) {
  229.       return;
  230.     }
  231.     let supportsMultipleMediaElements =
  232.         this.config_.supportsMultipleMediaElements;
  233.     const video = /** @type {HTMLVideoElement} */(this.baseVideo_);
  234.     if (video.webkitSupportsFullscreen && video.webkitDisplayingFullscreen) {
  235.       supportsMultipleMediaElements = false;
  236.     }
  237.     if (this.usingBaseVideo_ != supportsMultipleMediaElements) {
  238.       return;
  239.     }
  240.     this.usingBaseVideo_ = !supportsMultipleMediaElements;
  241.     if (this.usingBaseVideo_) {
  242.       this.video_ = this.baseVideo_;
  243.       if (this.adVideo_) {
  244.         if (this.adVideo_.parentElement) {
  245.           this.adContainer_.removeChild(this.adVideo_);
  246.         }
  247.         this.adVideo_ = null;
  248.       }
  249.     } else {
  250.       if (!this.adVideo_) {
  251.         this.adVideo_ = this.createMediaElement_();
  252.       }
  253.       this.video_ = this.adVideo_;
  254.     }
  255.   }
  258.   /**
  259.    * Resets the Interstitial manager and removes any continuous polling.
  260.    */
  261.   stop() {
  262.     if (this.adEventManager_) {
  263.       this.adEventManager_.removeAll();
  264.     }
  265.     this.interstitialIds_.clear();
  266.     this.interstitials_.clear();
  267.     this.player_.destroyAllPreloads();
  268.     this.preloadManagerInterstitials_.clear();
  269.     this.player_.detach();
  270.     this.playingAd_ = false;
  271.     this.lastTime_ = null;
  272.     this.lastPlayedAd_ = null;
  273.     this.usingBaseVideo_ = true;
  274.     this.video_ = this.baseVideo_;
  275.     this.adVideo_ = null;
  276.     if (this.adContainer_) {
  277.       shaka.util.Dom.removeAllChildren(this.adContainer_);
  278.     }
  279.     if (this.playoutLimitTimer_) {
  280.       this.playoutLimitTimer_.stop();
  281.       this.playoutLimitTimer_ = null;
  282.     }
  283.   }
  285.   /** @override */
  286.   release() {
  287.     this.stop();
  288.     if (this.eventManager_) {
  289.       this.eventManager_.release();
  290.     }
  291.     if (this.adEventManager_) {
  292.       this.adEventManager_.release();
  293.     }
  294.     if (this.timeUpdateTimer_) {
  295.       this.timeUpdateTimer_.stop();
  296.       this.timeUpdateTimer_ = null;
  297.     }
  298.     if (this.pollTimer_) {
  299.       this.pollTimer_.stop();
  300.       this.pollTimer_ = null;
  301.     }
  302.     this.player_.destroy();
  303.   }
  305.   /**
  306.    * @return {shaka.Player}
  307.    */
  308.   getPlayer() {
  309.     return this.player_;
  310.   }
  312.   /**
  313.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  314.    */
  315.   async addMetadata(hlsInterstitial) {
  316.     this.updatePlayerConfig_();
  317.     const adInterstitials = await this.getInterstitialsInfo_(hlsInterstitial);
  318.     if (adInterstitials.length) {
  319.       this.addInterstitials(adInterstitials);
  320.     } else {
  321.       shaka.log.alwaysWarn('Unsupported HLS interstitial', hlsInterstitial);
  322.     }
  323.   }
  325.   /**
  326.    * @param {shaka.extern.TimelineRegionInfo} region
  327.    */
  328.   addRegion(region) {
  329.     let alternativeMPDUri;
  330.     for (const node of region.eventNode.children) {
  331.       if (node.tagName == 'AlternativeMPD') {
  332.         const uri = node.attributes['uri'];
  333.         if (uri) {
  334.           alternativeMPDUri = uri;
  335.           break;
  336.         }
  337.       }
  338.     }
  339.     if (!alternativeMPDUri) {
  340.       shaka.log.alwaysWarn('Unsupported MPD alternate', region);
  341.       return;
  342.     }
  343.     const isReplace =
  344.         region.schemeIdUri == 'urn:mpeg:dash:event:alternativeMPD:replace:2025';
  345.     const isInsert =
  346.         region.schemeIdUri == 'urn:mpeg:dash:event:alternativeMPD:insert:2025';
  347.     if (!isReplace && !isInsert) {
  348.       shaka.log.warning('Unsupported MPD alternate', region);
  349.       return;
  350.     }
  352.     /** @type {!shaka.extern.AdInterstitial} */
  353.     const interstitial = {
  354.       id: region.id,
  355.       groupId: null,
  356.       startTime: region.startTime,
  357.       endTime: region.endTime,
  358.       uri: alternativeMPDUri,
  359.       mimeType: null,
  360.       isSkippable: false,
  361.       skipOffset: null,
  362.       skipFor: null,
  363.       canJump: true,
  364.       resumeOffset: isInsert ? 0 : null,
  365.       playoutLimit: null,
  366.       once: false,
  367.       pre: false,
  368.       post: false,
  369.       timelineRange: isReplace && !isInsert,
  370.       loop: false,
  371.       overlay: null,
  372.     };
  373.     this.addInterstitials([interstitial]);
  374.   }
  376.   /**
  377.    * @param {shaka.extern.TimelineRegionInfo} region
  378.    */
  379.   addOverlayRegion(region) {
  380.     const TXml = shaka.util.TXml;
  382.     goog.asserts.assert(region.eventNode, 'Need a region eventNode');
  383.     const overlayEvent = TXml.findChild(region.eventNode, 'OverlayEvent');
  384.     const uri = overlayEvent.attributes['uri'];
  385.     const mimeType = overlayEvent.attributes['mimeType'];
  386.     const loop = overlayEvent.attributes['loop'] == 'true';
  387.     if (!uri || !mimeType) {
  388.       shaka.log.warning('Unsupported OverlayEvent', region);
  389.       return;
  390.     }
  392.     /** @type {!shaka.extern.AdInterstitialOverlay} */
  393.     let overlay = {
  394.       viewport: {
  395.         x: 1920,
  396.         y: 1080,
  397.       },
  398.       topLeft: {
  399.         x: 0,
  400.         y: 0,
  401.       },
  402.       size: {
  403.         x: 1920,
  404.         y: 1080,
  405.       },
  406.     };
  408.     const viewport = TXml.findChild(overlayEvent, 'Viewport');
  409.     const topLeft = TXml.findChild(overlayEvent, 'TopLeft');
  410.     const size = TXml.findChild(overlayEvent, 'Size');
  411.     if (viewport && topLeft && size) {
  412.       const viewportX = TXml.parseAttr(viewport, 'x', TXml.parseInt);
  413.       if (viewportX == null) {
  414.         shaka.log.warning('Unsupported OverlayEvent', region);
  415.         return;
  416.       }
  417.       const viewportY = TXml.parseAttr(viewport, 'y', TXml.parseInt);
  418.       if (viewportY == null) {
  419.         shaka.log.warning('Unsupported OverlayEvent', region);
  420.         return;
  421.       }
  422.       const topLeftX = TXml.parseAttr(topLeft, 'x', TXml.parseInt);
  423.       if (topLeftX == null) {
  424.         shaka.log.warning('Unsupported OverlayEvent', region);
  425.         return;
  426.       }
  427.       const topLeftY = TXml.parseAttr(topLeft, 'y', TXml.parseInt);
  428.       if (topLeftY == null) {
  429.         shaka.log.warning('Unsupported OverlayEvent', region);
  430.         return;
  431.       }
  432.       const sizeX = TXml.parseAttr(size, 'x', TXml.parseInt);
  433.       if (sizeX == null) {
  434.         shaka.log.warning('Unsupported OverlayEvent', region);
  435.         return;
  436.       }
  437.       const sizeY = TXml.parseAttr(size, 'y', TXml.parseInt);
  438.       if (sizeY == null) {
  439.         shaka.log.warning('Unsupported OverlayEvent', region);
  440.         return;
  441.       }
  442.       overlay = {
  443.         viewport: {
  444.           x: viewportX,
  445.           y: viewportY,
  446.         },
  447.         topLeft: {
  448.           x: topLeftX,
  449.           y: topLeftY,
  450.         },
  451.         size: {
  452.           x: sizeX,
  453.           y: sizeY,
  454.         },
  455.       };
  456.     }
  458.     /** @type {!shaka.extern.AdInterstitial} */
  459.     const interstitial = {
  460.       id: region.id,
  461.       groupId: null,
  462.       startTime: region.startTime,
  463.       endTime: region.endTime,
  464.       uri,
  465.       mimeType,
  466.       isSkippable: false,
  467.       skipOffset: null,
  468.       skipFor: null,
  469.       canJump: true,
  470.       resumeOffset: null,
  471.       playoutLimit: null,
  472.       once: false,
  473.       pre: false,
  474.       post: false,
  475.       timelineRange: true,
  476.       loop,
  477.       overlay,
  478.     };
  479.     this.addInterstitials([interstitial]);
  480.   }
  482.   /**
  483.    * @param {string} url
  484.    * @return {!Promise}
  485.    */
  486.   async addAdUrlInterstitial(url) {
  487.     const NetworkingEngine = shaka.net.NetworkingEngine;
  488.     const context = {
  489.       type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_AD_URL,
  490.     };
  491.     const responseData = await this.makeAdRequest_(url, context);
  492.     const data = shaka.util.TXml.parseXml(responseData, 'VAST,vmap:VMAP');
  493.     if (!data) {
  494.       throw new shaka.util.Error(
  495.           shaka.util.Error.Severity.CRITICAL,
  496.           shaka.util.Error.Category.ADS,
  497.           shaka.util.Error.Code.VAST_INVALID_XML);
  498.     }
  499.     let interstitials = [];
  500.     if (data.tagName == 'VAST') {
  501.       interstitials = shaka.ads.Utils.parseVastToInterstitials(
  502.           data, this.lastTime_);
  503.     } else if (data.tagName == 'vmap:VMAP') {
  504.       for (const ad of shaka.ads.Utils.parseVMAP(data)) {
  505.         // eslint-disable-next-line no-await-in-loop
  506.         const vastResponseData = await this.makeAdRequest_(ad.uri, context);
  507.         const vast = shaka.util.TXml.parseXml(vastResponseData, 'VAST');
  508.         if (!vast) {
  509.           throw new shaka.util.Error(
  510.               shaka.util.Error.Severity.CRITICAL,
  511.               shaka.util.Error.Category.ADS,
  512.               shaka.util.Error.Code.VAST_INVALID_XML);
  513.         }
  514.         interstitials.push(...shaka.ads.Utils.parseVastToInterstitials(
  515.             vast, ad.time));
  516.       }
  517.     }
  518.     this.addInterstitials(interstitials);
  519.   }
  522.   /**
  523.    * @param {!Array<shaka.extern.AdInterstitial>} interstitials
  524.    */
  525.   async addInterstitials(interstitials) {
  526.     let cuepointsChanged = false;
  527.     for (const interstitial of interstitials) {
  528.       if (!interstitial.uri) {
  529.         shaka.log.alwaysWarn('Missing URL in interstitial', interstitial);
  530.         continue;
  531.       }
  532.       if (!interstitial.mimeType) {
  533.         try {
  534.           const netEngine = this.player_.getNetworkingEngine();
  535.           goog.asserts.assert(netEngine, 'Need networking engine');
  536.           // eslint-disable-next-line no-await-in-loop
  537.           interstitial.mimeType = await shaka.net.NetworkingUtils.getMimeType(
  538.               interstitial.uri, netEngine,
  539.               this.basePlayer_.getConfiguration().streaming.retryParameters);
  540.         } catch (error) {}
  541.       }
  542.       const interstitialId = interstitial.id || JSON.stringify(interstitial);
  543.       if (this.interstitialIds_.has(interstitialId)) {
  544.         continue;
  545.       }
  546.       if (interstitial.loop && !interstitial.overlay) {
  547.         shaka.log.alwaysWarn('Loop is only supported in overlay interstitials',
  548.             interstitial);
  549.       }
  550.       if (!interstitial.overlay) {
  551.         cuepointsChanged = true;
  552.       }
  553.       this.interstitialIds_.add(interstitialId);
  554.       this.interstitials_.add(interstitial);
  555.       let shouldPreload = false;
  556.       if (interstitial.pre && this.lastTime_ == null) {
  557.         shouldPreload = true;
  558.       } else if (interstitial.startTime == 0 && !interstitial.canJump) {
  559.         shouldPreload = true;
  560.       } else if (this.lastTime_ != null) {
  561.         const difference = interstitial.startTime - this.lastTime_;
  562.         if (difference > 0 && difference <= 10) {
  563.           shouldPreload = true;
  564.         }
  565.       }
  566.       if (shouldPreload) {
  567.         if (!this.preloadManagerInterstitials_.has(interstitial) &&
  568.             this.isPreloadAllowed_(interstitial)) {
  569.           this.preloadManagerInterstitials_.set(
  570.               interstitial, this.player_.preload(
  571.                   interstitial.uri,
  572.                   /* startTime= */ null,
  573.                   interstitial.mimeType || undefined));
  574.         }
  575.       }
  576.     }
  577.     if (cuepointsChanged) {
  578.       this.cuepointsChanged_();
  579.     }
  580.   }
  582.   /**
  583.    * @return {!HTMLMediaElement}
  584.    * @private
  585.    */
  586.   createMediaElement_() {
  587.     const video = /** @type {!HTMLMediaElement} */(
  588.       document.createElement(this.baseVideo_.tagName));
  589.     video.autoplay = true;
  590.     video.style.position = 'absolute';
  591.     video.style.top = '0';
  592.     video.style.left = '0';
  593.     video.style.width = '100%';
  594.     video.style.height = '100%';
  595.     video.style.display = 'none';
  596.     video.setAttribute('playsinline', '');
  597.     return video;
  598.   }
  601.   /**
  602.    * @param {boolean=} needPreRoll
  603.    * @param {?number=} numberToSkip
  604.    * @return {?shaka.extern.AdInterstitial}
  605.    * @private
  606.    */
  607.   getCurrentInterstitial_(needPreRoll = false, numberToSkip = null) {
  608.     let skipped = 0;
  609.     let currentInterstitial = null;
  610.     if (this.interstitials_.size && this.lastTime_ != null) {
  611.       const isEnded = this.baseVideo_.ended;
  612.       const interstitials = Array.from(this.interstitials_).sort((a, b) => {
  613.         return b.startTime - a.startTime;
  614.       });
  615.       const roundDecimals = (number) => {
  616.         return Math.round(number * 1000) / 1000;
  617.       };
  618.       let interstitialsToCheck = interstitials;
  619.       if (needPreRoll) {
  620.         interstitialsToCheck = interstitials.filter((i) => i.pre);
  621.       } else if (isEnded) {
  622.         interstitialsToCheck = interstitials.filter((i) => i.post);
  623.       } else {
  624.         interstitialsToCheck = interstitials.filter((i) => !i.pre && !i.post);
  625.       }
  626.       for (const interstitial of interstitialsToCheck) {
  627.         let isValid = false;
  628.         if (needPreRoll) {
  629.           isValid = interstitial.pre;
  630.         } else if (isEnded) {
  631.           isValid = interstitial.post;
  632.         } else if (!interstitial.pre && !interstitial.post) {
  633.           const difference =
  634.               this.lastTime_ - roundDecimals(interstitial.startTime);
  635.           if (difference > 0 &&
  636.               (difference <= 1 || !interstitial.canJump)) {
  637.             if (numberToSkip == null && this.lastPlayedAd_ &&
  638.                 !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  639.                 this.lastPlayedAd_.startTime >= interstitial.startTime) {
  640.               isValid = false;
  641.             } else {
  642.               isValid = true;
  643.             }
  644.           }
  645.         }
  646.         if (isValid && (!this.lastPlayedAd_ ||
  647.             interstitial.startTime >= this.lastPlayedAd_.startTime)) {
  648.           if (skipped == (numberToSkip || 0)) {
  649.             currentInterstitial = interstitial;
  650.           } else if (currentInterstitial && !interstitial.canJump) {
  651.             const currentStartTime =
  652.                 roundDecimals(currentInterstitial.startTime);
  653.             const newStartTime =
  654.                 roundDecimals(interstitial.startTime);
  655.             if (newStartTime - currentStartTime > 0.001) {
  656.               currentInterstitial = interstitial;
  657.               skipped = 0;
  658.             }
  659.           }
  660.           skipped++;
  661.         }
  662.       }
  663.     }
  664.     return currentInterstitial;
  665.   }
  668.   /**
  669.    * @param {shaka.extern.AdInterstitial} interstitial
  670.    * @param {number} sequenceLength
  671.    * @param {number} adPosition
  672.    * @param {number} initialTime the clock time the ad started at
  673.    * @param {number=} oncePlayed
  674.    * @private
  675.    */
  676.   setupAd_(interstitial, sequenceLength, adPosition, initialTime,
  677.       oncePlayed = 0) {
  678.     shaka.log.info('Starting interstitial',
  679.         interstitial.startTime, 'at', this.lastTime_);
  681.     this.lastPlayedAd_ = interstitial;
  683.     this.determineIfUsingBaseVideo_();
  684.     goog.asserts.assert(this.video_, 'Must have video');
  686.     if (!this.video_.parentElement && this.adContainer_) {
  687.       this.adContainer_.appendChild(this.video_);
  688.     }
  690.     if (adPosition == 1 && sequenceLength == 1) {
  691.       sequenceLength = Array.from(this.interstitials_).filter((i) => {
  692.         if (interstitial.pre) {
  693.           return i.pre == interstitial.pre;
  694.         } else if (interstitial.post) {
  695.           return i.post == interstitial.post;
  696.         }
  697.         return Math.abs(i.startTime - interstitial.startTime) < 0.001;
  698.       }).length;
  699.     }
  701.     if (interstitial.once) {
  702.       oncePlayed++;
  703.       this.interstitials_.delete(interstitial);
  704.       if (!interstitial.overlay) {
  705.         this.cuepointsChanged_();
  706.       }
  707.     }
  709.     if (interstitial.mimeType) {
  710.       if (interstitial.mimeType.startsWith('image/') ||
  711.           interstitial.mimeType === 'text/html') {
  712.         if (!interstitial.overlay) {
  713.           shaka.log.alwaysWarn('Unsupported interstitial', interstitial);
  714.           return;
  715.         }
  716.         this.setupStaticAd_(interstitial, sequenceLength, adPosition,
  717.             oncePlayed);
  718.         return;
  719.       }
  720.     }
  721.     if (this.usingBaseVideo_ && interstitial.overlay) {
  722.       shaka.log.alwaysWarn('Unsupported interstitial', interstitial);
  723.       return;
  724.     }
  725.     this.setupVideoAd_(interstitial, sequenceLength, adPosition, initialTime,
  726.         oncePlayed);
  727.   }
  730.   /**
  731.    * @param {shaka.extern.AdInterstitial} interstitial
  732.    * @param {number} sequenceLength
  733.    * @param {number} adPosition
  734.    * @param {number} oncePlayed
  735.    * @private
  736.    */
  737.   setupStaticAd_(interstitial, sequenceLength, adPosition, oncePlayed) {
  738.     const overlay = interstitial.overlay;
  739.     goog.asserts.assert(overlay, 'Must have overlay');
  741.     const tagName = interstitial.mimeType == 'text/html' ? 'iframe' : 'img';
  743.     const htmlElement = /** @type {!(HTMLImageElement|HTMLIFrameElement)} */ (
  744.       document.createElement(tagName));
  745.     htmlElement.style.objectFit = 'contain';
  746.     htmlElement.style.position = 'absolute';
  747.     htmlElement.style.border = 'none';
  749.     const basicTask = () => {
  750.       if (this.playoutLimitTimer_) {
  751.         this.playoutLimitTimer_.stop();
  752.         this.playoutLimitTimer_ = null;
  753.       }
  754.       this.adContainer_.removeChild(htmlElement);
  755.       this.onEvent_(
  756.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  757.       const nextCurrentInterstitial = this.getCurrentInterstitial_(
  758.           interstitial.pre, adPosition - oncePlayed);
  759.       if (nextCurrentInterstitial) {
  760.         this.adEventManager_.removeAll();
  761.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  762.             ++adPosition, /* initialTime= */ Date.now(), oncePlayed);
  763.       } else {
  764.         this.playingAd_ = false;
  765.       }
  766.     };
  768.     const ad = new shaka.ads.InterstitialStaticAd(
  769.         interstitial, sequenceLength, adPosition);
  771.     this.onEvent_(
  772.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  773.             (new Map()).set('ad', ad)));
  775.     if (tagName == 'iframe') {
  776.       htmlElement.src = interstitial.uri;
  777.     } else {
  778.       htmlElement.src = interstitial.uri;
  779.       htmlElement.onerror = (e) => {
  780.         this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  781.             (new Map()).set('originalEvent', e)));
  782.         basicTask();
  783.       };
  784.     }
  786.     const viewport = overlay.viewport;
  787.     const topLeft = overlay.topLeft;
  788.     const size = overlay.size;
  789.     // Special case for VAST non-linear ads
  790.     if (viewport.x == 0 && viewport.y == 0) {
  791.       htmlElement.width = interstitial.overlay.size.x;
  792.       htmlElement.height = interstitial.overlay.size.y;
  793.       htmlElement.style.bottom = '10%';
  794.       htmlElement.style.left = '0';
  795.       htmlElement.style.right = '0';
  796.       htmlElement.style.width = '100%';
  797.       if (!interstitial.overlay.size.y && tagName == 'iframe') {
  798.         htmlElement.style.height = 'auto';
  799.       }
  800.     } else {
  801.       htmlElement.style.height = (size.y / viewport.y * 100) + '%';
  802.       htmlElement.style.left = (topLeft.x / viewport.x * 100) + '%';
  803.       htmlElement.style.top = (topLeft.y / viewport.y * 100) + '%';
  804.       htmlElement.style.width = (size.x / viewport.x * 100) + '%';
  805.     }
  806.     this.adContainer_.appendChild(htmlElement);
  808.     const startTime = Date.now();
  809.     if (this.playoutLimitTimer_) {
  810.       this.playoutLimitTimer_.stop();
  811.     }
  812.     this.playoutLimitTimer_ = new shaka.util.Timer(() => {
  813.       if (interstitial.playoutLimit &&
  814.           (Date.now() - startTime) / 1000 > interstitial.playoutLimit) {
  815.         this.onEvent_(
  816.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  817.         basicTask();
  818.       } else if (interstitial.endTime &&
  819.           this.baseVideo_.currentTime > interstitial.endTime) {
  820.         this.onEvent_(
  821.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  822.         basicTask();
  823.       } else if (this.baseVideo_.currentTime < interstitial.startTime) {
  824.         this.onEvent_(
  825.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  826.         basicTask();
  827.       }
  828.     });
  829.     if (interstitial.playoutLimit && !interstitial.endTime) {
  830.       this.playoutLimitTimer_.tickAfter(interstitial.playoutLimit);
  831.     } else if (interstitial.endTime) {
  832.       this.playoutLimitTimer_.tickEvery(/* seconds= */ 0.025);
  833.     }
  834.   }
  837.   /**
  838.    * @param {shaka.extern.AdInterstitial} interstitial
  839.    * @param {number} sequenceLength
  840.    * @param {number} adPosition
  841.    * @param {number} initialTime the clock time the ad started at
  842.    * @param {number} oncePlayed
  843.    * @private
  844.    */
  845.   async setupVideoAd_(interstitial, sequenceLength, adPosition, initialTime,
  846.       oncePlayed) {
  847.     goog.asserts.assert(this.video_, 'Must have video');
  848.     const startTime = Date.now();
  850.     this.playingAd_ = true;
  852.     if (this.usingBaseVideo_ && adPosition == 1) {
  853.       this.onEvent_(new shaka.util.FakeEvent(
  854.           shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED,
  855.           (new Map()).set('saveLivePosition', true)));
  856.       const detachBasePlayerPromise = new shaka.util.PublicPromise();
  857.       const checkState = async (e) => {
  858.         if (e['state'] == 'detach') {
  859.           if (shaka.util.Platform.isSmartTV()) {
  860.             await new Promise(
  861.                 (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  862.           }
  863.           detachBasePlayerPromise.resolve();
  864.           this.adEventManager_.unlisten(
  865.               this.basePlayer_, 'onstatechange', checkState);
  866.         }
  867.       };
  868.       this.adEventManager_.listen(
  869.           this.basePlayer_, 'onstatechange', checkState);
  870.       await detachBasePlayerPromise;
  871.     }
  872.     if (!this.usingBaseVideo_) {
  873.       this.video_.style.display = '';
  874.       if (interstitial.overlay) {
  875.         this.video_.loop = interstitial.loop;
  876.         const viewport = interstitial.overlay.viewport;
  877.         const topLeft = interstitial.overlay.topLeft;
  878.         const size = interstitial.overlay.size;
  879.         this.video_.style.height = (size.y / viewport.y * 100) + '%';
  880.         this.video_.style.left = (topLeft.x / viewport.x * 100) + '%';
  881.         this.video_.style.top = (topLeft.y / viewport.y * 100) + '%';
  882.         this.video_.style.width = (size.x / viewport.x * 100) + '%';
  883.       } else {
  884.         this.baseVideo_.pause();
  885.         if (interstitial.resumeOffset != null &&
  886.             interstitial.resumeOffset != 0) {
  887.           this.baseVideo_.currentTime += interstitial.resumeOffset;
  888.         }
  889.         this.video_.loop = false;
  890.         this.video_.style.height = '100%';
  891.         this.video_.style.left = '0';
  892.         this.video_.style.top = '0';
  893.         this.video_.style.width = '100%';
  894.       }
  895.     }
  897.     let unloadingInterstitial = false;
  899.     const updateBaseVideoTime = () => {
  900.       if (!this.usingBaseVideo_ && !interstitial.overlay) {
  901.         if (interstitial.resumeOffset == null) {
  902.           if (interstitial.timelineRange && interstitial.endTime &&
  903.               interstitial.endTime != Infinity) {
  904.             if (this.baseVideo_.currentTime != interstitial.endTime) {
  905.               this.baseVideo_.currentTime = interstitial.endTime;
  906.             }
  907.           } else {
  908.             const now = Date.now();
  909.             this.baseVideo_.currentTime += (now - initialTime) / 1000;
  910.             initialTime = now;
  911.           }
  912.         }
  913.       }
  914.     };
  916.     const basicTask = async (isSkip) => {
  917.       updateBaseVideoTime();
  918.       // Optimization to avoid returning to main content when there is another
  919.       // interstitial below.
  920.       let nextCurrentInterstitial = this.getCurrentInterstitial_(
  921.           interstitial.pre, adPosition - oncePlayed);
  922.       if (isSkip && interstitial.groupId) {
  923.         while (nextCurrentInterstitial &&
  924.             nextCurrentInterstitial.groupId == interstitial.groupId) {
  925.           adPosition++;
  926.           nextCurrentInterstitial = this.getCurrentInterstitial_(
  927.               interstitial.pre, adPosition - oncePlayed);
  928.         }
  929.       }
  930.       if (this.playoutLimitTimer_ && (!interstitial.groupId ||
  931.           (nextCurrentInterstitial &&
  932.             nextCurrentInterstitial.groupId != interstitial.groupId))) {
  933.         this.playoutLimitTimer_.stop();
  934.         this.playoutLimitTimer_ = null;
  935.       }
  936.       if (!nextCurrentInterstitial || nextCurrentInterstitial.overlay) {
  937.         if (interstitial.post) {
  938.           this.lastTime_ = null;
  939.           this.lastPlayedAd_ = null;
  940.         }
  941.         if (this.usingBaseVideo_) {
  942.           await this.player_.detach();
  943.         } else {
  944.           await this.player_.unload();
  945.         }
  946.         if (this.usingBaseVideo_) {
  947.           let offset = interstitial.resumeOffset;
  948.           if (offset == null) {
  949.             if (interstitial.timelineRange && interstitial.endTime &&
  950.                 interstitial.endTime != Infinity) {
  951.               offset = interstitial.endTime - (this.lastTime_ || 0);
  952.             } else {
  953.               offset = (Date.now() - initialTime) / 1000;
  954.             }
  955.           }
  956.           this.onEvent_(new shaka.util.FakeEvent(
  957.               shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED,
  958.               (new Map()).set('offset', offset)));
  959.         }
  960.         this.onEvent_(
  961.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  962.         this.adEventManager_.removeAll();
  963.         this.playingAd_ = false;
  964.         if (!this.usingBaseVideo_) {
  965.           this.video_.style.display = 'none';
  966.           updateBaseVideoTime();
  967.           if (!this.baseVideo_.ended) {
  968.             this.baseVideo_.play();
  969.           }
  970.         } else {
  971.           this.cuepointsChanged_();
  972.         }
  973.       }
  974.       this.determineIfUsingBaseVideo_();
  975.       if (nextCurrentInterstitial) {
  976.         this.onEvent_(
  977.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  978.         this.adEventManager_.removeAll();
  979.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  980.             ++adPosition, initialTime, oncePlayed);
  981.       }
  982.     };
  983.     const error = async (e) => {
  984.       if (unloadingInterstitial) {
  985.         return;
  986.       }
  987.       unloadingInterstitial = true;
  988.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  989.           (new Map()).set('originalEvent', e)));
  990.       await basicTask(/* isSkip= */ false);
  991.     };
  992.     const complete = async () => {
  993.       if (unloadingInterstitial) {
  994.         return;
  995.       }
  996.       unloadingInterstitial = true;
  997.       await basicTask(/* isSkip= */ false);
  998.       this.onEvent_(
  999.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  1000.     };
  1001.     this.lastOnSkip_ = async () => {
  1002.       if (unloadingInterstitial) {
  1003.         return;
  1004.       }
  1005.       unloadingInterstitial = true;
  1006.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  1007.       await basicTask(/* isSkip= */ true);
  1008.     };
  1010.     const ad = new shaka.ads.InterstitialAd(this.video_,
  1011.         interstitial, this.lastOnSkip_, sequenceLength, adPosition,
  1012.         !this.usingBaseVideo_);
  1013.     if (!this.usingBaseVideo_) {
  1014.       ad.setMuted(this.baseVideo_.muted);
  1015.       ad.setVolume(this.baseVideo_.volume);
  1016.     }
  1018.     this.onEvent_(
  1019.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  1020.             (new Map()).set('ad', ad)));
  1022.     let prevCanSkipNow = ad.canSkipNow();
  1023.     if (prevCanSkipNow) {
  1024.       this.onEvent_(new shaka.util.FakeEvent(
  1025.           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  1026.     }
  1027.     this.adEventManager_.listenOnce(this.player_, 'error', error);
  1028.     this.adEventManager_.listen(this.video_, 'timeupdate', () => {
  1029.       const duration = this.video_.duration;
  1030.       if (!duration) {
  1031.         return;
  1032.       }
  1033.       const currentCanSkipNow = ad.canSkipNow();
  1034.       if (prevCanSkipNow != currentCanSkipNow &&
  1035.           ad.getRemainingTime() > 0 && ad.getDuration() > 0) {
  1036.         this.onEvent_(
  1037.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  1038.       }
  1039.       prevCanSkipNow = currentCanSkipNow;
  1040.     });
  1041.     this.adEventManager_.listenOnce(this.player_, 'firstquartile', () => {
  1042.       updateBaseVideoTime();
  1043.       this.onEvent_(
  1044.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  1045.     });
  1046.     this.adEventManager_.listenOnce(this.player_, 'midpoint', () => {
  1047.       updateBaseVideoTime();
  1048.       this.onEvent_(
  1049.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  1050.     });
  1051.     this.adEventManager_.listenOnce(this.player_, 'thirdquartile', () => {
  1052.       updateBaseVideoTime();
  1053.       this.onEvent_(
  1054.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  1055.     });
  1056.     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
  1057.     this.adEventManager_.listen(this.video_, 'play', () => {
  1058.       this.onEvent_(
  1059.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  1060.     });
  1061.     this.adEventManager_.listen(this.video_, 'pause', () => {
  1062.       // playRangeEnd in src= causes the ended event not to be fired when that
  1063.       // position is reached, instead pause event is fired.
  1064.       const currentConfig = this.player_.getConfiguration();
  1065.       if (this.video_.currentTime >= currentConfig.playRangeEnd) {
  1066.         complete();
  1067.         return;
  1068.       }
  1069.       this.onEvent_(
  1070.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  1071.     });
  1072.     this.adEventManager_.listen(this.video_, 'volumechange', () => {
  1073.       if (this.video_.muted) {
  1074.         this.onEvent_(
  1075.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  1076.       } else {
  1077.         this.onEvent_(
  1078.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  1079.       }
  1080.     });
  1081.     try {
  1082.       this.updatePlayerConfig_();
  1083.       if (interstitial.startTime && interstitial.endTime &&
  1084.           interstitial.endTime != Infinity &&
  1085.           interstitial.startTime != interstitial.endTime) {
  1086.         const duration = interstitial.endTime - interstitial.startTime;
  1087.         if (duration > 0) {
  1088.           this.player_.configure('playRangeEnd', duration);
  1089.         }
  1090.       }
  1091.       if (interstitial.playoutLimit && !this.playoutLimitTimer_) {
  1092.         this.playoutLimitTimer_ = new shaka.util.Timer(() => {
  1093.           this.lastOnSkip_();
  1094.         }).tickAfter(interstitial.playoutLimit);
  1095.         this.player_.configure('playRangeEnd', interstitial.playoutLimit);
  1096.       }
  1097.       await this.player_.attach(this.video_);
  1098.       if (this.preloadManagerInterstitials_.has(interstitial)) {
  1099.         const preloadManager =
  1100.             await this.preloadManagerInterstitials_.get(interstitial);
  1101.         this.preloadManagerInterstitials_.delete(interstitial);
  1102.         if (preloadManager) {
  1103.           await this.player_.load(preloadManager);
  1104.         } else {
  1105.           await this.player_.load(
  1106.               interstitial.uri,
  1107.               /* startTime= */ null,
  1108.               interstitial.mimeType || undefined);
  1109.         }
  1110.       } else {
  1111.         await this.player_.load(
  1112.             interstitial.uri,
  1113.             /* startTime= */ null,
  1114.             interstitial.mimeType || undefined);
  1115.       }
  1116.       const loadTime = (Date.now() - startTime) / 1000;
  1117.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  1118.           (new Map()).set('loadTime', loadTime)));
  1119.       if (this.usingBaseVideo_) {
  1120.         this.baseVideo_.play();
  1121.       }
  1122.     } catch (e) {
  1123.       if (!this.playingAd_) {
  1124.         return;
  1125.       }
  1126.       error(e);
  1127.     }
  1128.   }
  1131.   /**
  1132.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  1133.    * @return {!Promise<!Array<shaka.extern.AdInterstitial>>}
  1134.    * @private
  1135.    */
  1136.   async getInterstitialsInfo_(hlsInterstitial) {
  1137.     const interstitialsAd = [];
  1138.     if (!hlsInterstitial) {
  1139.       return interstitialsAd;
  1140.     }
  1141.     const assetUri = hlsInterstitial.values.find((v) => v.key == 'X-ASSET-URI');
  1142.     const assetList =
  1143.         hlsInterstitial.values.find((v) => v.key == 'X-ASSET-LIST');
  1144.     if (!assetUri && !assetList) {
  1145.       return interstitialsAd;
  1146.     }
  1147.     let id = null;
  1148.     const hlsInterstitialId = hlsInterstitial.values.find((v) => v.key == 'ID');
  1149.     if (hlsInterstitialId) {
  1150.       id = /** @type {string} */(hlsInterstitialId.data);
  1151.     }
  1152.     const startTime = id == null ?
  1153.         Math.floor(hlsInterstitial.startTime * 10) / 10:
  1154.         hlsInterstitial.startTime;
  1155.     let endTime = hlsInterstitial.endTime;
  1156.     if (hlsInterstitial.endTime && hlsInterstitial.endTime != Infinity &&
  1157.         typeof(hlsInterstitial.endTime) == 'number') {
  1158.       endTime = id == null ?
  1159.           Math.floor(hlsInterstitial.endTime * 10) / 10:
  1160.           hlsInterstitial.endTime;
  1161.     }
  1162.     const restrict = hlsInterstitial.values.find((v) => v.key == 'X-RESTRICT');
  1163.     let isSkippable = true;
  1164.     let canJump = true;
  1165.     if (restrict && restrict.data) {
  1166.       const data = /** @type {string} */(restrict.data);
  1167.       isSkippable = !data.includes('SKIP');
  1168.       canJump = !data.includes('JUMP');
  1169.     }
  1170.     let skipOffset = isSkippable ? 0 : null;
  1171.     const enableSkipAfter =
  1172.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-AFTER');
  1173.     if (enableSkipAfter) {
  1174.       const enableSkipAfterString = /** @type {string} */(enableSkipAfter.data);
  1175.       skipOffset = parseFloat(enableSkipAfterString);
  1176.       if (isNaN(skipOffset)) {
  1177.         skipOffset = isSkippable ? 0 : null;
  1178.       }
  1179.     }
  1180.     let skipFor = null;
  1181.     const enableSkipFor =
  1182.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-FOR');
  1183.     if (enableSkipFor) {
  1184.       const enableSkipForString = /** @type {string} */(enableSkipFor.data);
  1185.       skipFor = parseFloat(enableSkipForString);
  1186.       if (isNaN(skipOffset)) {
  1187.         skipFor = null;
  1188.       }
  1189.     }
  1190.     let resumeOffset = null;
  1191.     const resume =
  1192.         hlsInterstitial.values.find((v) => v.key == 'X-RESUME-OFFSET');
  1193.     if (resume) {
  1194.       const resumeOffsetString = /** @type {string} */(resume.data);
  1195.       resumeOffset = parseFloat(resumeOffsetString);
  1196.       if (isNaN(resumeOffset)) {
  1197.         resumeOffset = null;
  1198.       }
  1199.     }
  1200.     let playoutLimit = null;
  1201.     const playout =
  1202.         hlsInterstitial.values.find((v) => v.key == 'X-PLAYOUT-LIMIT');
  1203.     if (playout) {
  1204.       const playoutLimitString = /** @type {string} */(playout.data);
  1205.       playoutLimit = parseFloat(playoutLimitString);
  1206.       if (isNaN(playoutLimit)) {
  1207.         playoutLimit = null;
  1208.       }
  1209.     }
  1210.     let once = false;
  1211.     let pre = false;
  1212.     let post = false;
  1213.     const cue = hlsInterstitial.values.find((v) => v.key == 'CUE');
  1214.     if (cue) {
  1215.       const data = /** @type {string} */(cue.data);
  1216.       once = data.includes('ONCE');
  1217.       pre = data.includes('PRE');
  1218.       post = data.includes('POST');
  1219.     }
  1220.     let timelineRange = false;
  1221.     const timelineOccupies =
  1222.         hlsInterstitial.values.find((v) => v.key == 'X-TIMELINE-OCCUPIES');
  1223.     if (timelineOccupies) {
  1224.       const data = /** @type {string} */(timelineOccupies.data);
  1225.       timelineRange = data.includes('RANGE');
  1226.     } else if (!resume && this.basePlayer_.isLive()) {
  1227.       timelineRange = !pre && !post;
  1228.     }
  1229.     if (assetUri) {
  1230.       const uri = /** @type {string} */(assetUri.data);
  1231.       if (!uri) {
  1232.         return interstitialsAd;
  1233.       }
  1234.       interstitialsAd.push({
  1235.         id,
  1236.         groupId: null,
  1237.         startTime,
  1238.         endTime,
  1239.         uri,
  1240.         mimeType: null,
  1241.         isSkippable,
  1242.         skipOffset,
  1243.         skipFor,
  1244.         canJump,
  1245.         resumeOffset,
  1246.         playoutLimit,
  1247.         once,
  1248.         pre,
  1249.         post,
  1250.         timelineRange,
  1251.         loop: false,
  1252.         overlay: null,
  1253.       });
  1254.     } else if (assetList) {
  1255.       const uri = /** @type {string} */(assetList.data);
  1256.       if (!uri) {
  1257.         return interstitialsAd;
  1258.       }
  1259.       try {
  1260.         const NetworkingEngine = shaka.net.NetworkingEngine;
  1261.         const context = {
  1262.           type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_ASSET_LIST,
  1263.         };
  1264.         const responseData = await this.makeAdRequest_(uri, context);
  1265.         const data = shaka.util.StringUtils.fromUTF8(responseData);
  1266.         const dataAsJson =
  1267.         /** @type {!shaka.ads.InterstitialAdManager.AssetsList} */ (
  1268.             JSON.parse(data));
  1269.         const skipControl = dataAsJson['SKIP-CONTROL'];
  1270.         if (skipControl) {
  1271.           const enableSkipAfterValue = skipControl['ENABLE-SKIP-AFTER'];
  1272.           if ((typeof enableSkipAfterValue) == 'number') {
  1273.             skipOffset = parseFloat(enableSkipAfterValue);
  1274.             if (isNaN(enableSkipAfterValue)) {
  1275.               skipOffset = isSkippable ? 0 : null;
  1276.             }
  1277.           }
  1278.           const enableSkipForValue = skipControl['ENABLE-SKIP-FOR'];
  1279.           if ((typeof enableSkipForValue) == 'number') {
  1280.             skipFor = parseFloat(enableSkipForValue);
  1281.             if (isNaN(enableSkipForValue)) {
  1282.               skipFor = null;
  1283.             }
  1284.           }
  1285.         }
  1286.         for (let i = 0; i < dataAsJson['ASSETS'].length; i++) {
  1287.           const asset = dataAsJson['ASSETS'][i];
  1288.           if (asset['URI']) {
  1289.             interstitialsAd.push({
  1290.               id: id + '_shaka_asset_' + i,
  1291.               groupId: id,
  1292.               startTime,
  1293.               endTime,
  1294.               uri: asset['URI'],
  1295.               mimeType: null,
  1296.               isSkippable,
  1297.               skipOffset,
  1298.               skipFor,
  1299.               canJump,
  1300.               resumeOffset,
  1301.               playoutLimit,
  1302.               once,
  1303.               pre,
  1304.               post,
  1305.               timelineRange,
  1306.               loop: false,
  1307.               overlay: null,
  1308.             });
  1309.           }
  1310.         }
  1311.       } catch (e) {
  1312.         // Ignore errors
  1313.       }
  1314.     }
  1315.     return interstitialsAd;
  1316.   }
  1319.   /**
  1320.    * @private
  1321.    */
  1322.   cuepointsChanged_() {
  1323.     /** @type {!Array<!shaka.extern.AdCuePoint>} */
  1324.     const cuePoints = [];
  1325.     for (const interstitial of this.interstitials_) {
  1326.       if (interstitial.overlay) {
  1327.         continue;
  1328.       }
  1329.       /** @type {shaka.extern.AdCuePoint} */
  1330.       const shakaCuePoint = {
  1331.         start: interstitial.startTime,
  1332.         end: null,
  1333.       };
  1334.       if (interstitial.pre) {
  1335.         shakaCuePoint.start = 0;
  1336.         shakaCuePoint.end = null;
  1337.       } else if (interstitial.post) {
  1338.         shakaCuePoint.start = -1;
  1339.         shakaCuePoint.end = null;
  1340.       } else if (interstitial.timelineRange) {
  1341.         shakaCuePoint.end = interstitial.endTime;
  1342.       }
  1343.       const isValid = !cuePoints.find((c) => {
  1344.         return shakaCuePoint.start == c.start && shakaCuePoint.end == c.end;
  1345.       });
  1346.       if (isValid) {
  1347.         cuePoints.push(shakaCuePoint);
  1348.       }
  1349.     }
  1351.     this.onEvent_(new shaka.util.FakeEvent(
  1352.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  1353.         (new Map()).set('cuepoints', cuePoints)));
  1354.   }
  1357.   /**
  1358.    * @private
  1359.    */
  1360.   updatePlayerConfig_() {
  1361.     goog.asserts.assert(this.player_, 'Must have player');
  1362.     goog.asserts.assert(this.basePlayer_, 'Must have base player');
  1363.     this.player_.configure(this.basePlayer_.getNonDefaultConfiguration());
  1364.     this.player_.configure('ads.disableHLSInterstitial', true);
  1365.     this.player_.configure('ads.disableDASHInterstitial', true);
  1366.     this.player_.configure('playRangeEnd', Infinity);
  1367.     const netEngine = this.player_.getNetworkingEngine();
  1368.     goog.asserts.assert(netEngine, 'Need networking engine');
  1369.     this.basePlayer_.getNetworkingEngine().copyFiltersInto(netEngine);
  1370.   }
  1372.   /**
  1373.    * @param {string} url
  1374.    * @param {shaka.extern.RequestContext=} context
  1375.    * @return {!Promise<BufferSource>}
  1376.    * @private
  1377.    */
  1378.   async makeAdRequest_(url, context) {
  1379.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  1380.     const request = shaka.net.NetworkingEngine.makeRequest(
  1381.         [url],
  1382.         shaka.net.NetworkingEngine.defaultRetryParameters());
  1383.     const op = this.basePlayer_.getNetworkingEngine()
  1384.         .request(type, request, context);
  1385.     const response = await op.promise;
  1386.     return response.data;
  1387.   }
  1389.   /**
  1390.    * @param {!shaka.extern.AdInterstitial} interstitial
  1391.    * @return {boolean}
  1392.    * @private
  1393.    */
  1394.   isPreloadAllowed_(interstitial) {
  1395.     const interstitialMimeType = interstitial.mimeType;
  1396.     if (!interstitialMimeType) {
  1397.       return true;
  1398.     }
  1399.     return !interstitialMimeType.startsWith('image/') &&
  1400.         interstitialMimeType !== 'text/html';
  1401.   }
  1404.   /**
  1405.    * Only for testing
  1406.    *
  1407.    * @return {!Array<shaka.extern.AdInterstitial>}
  1408.    */
  1409.   getInterstitials() {
  1410.     return Array.from(this.interstitials_);
  1411.   }
  1412. };
  1415. /**
  1416.  * @typedef {{
  1417.  *   ASSETS: !Array<shaka.ads.InterstitialAdManager.Asset>,
  1418.  *   SKIP-CONTROL: ?shaka.ads.InterstitialAdManager.SkipControl
  1419.  * }}
  1420.  *
  1421.  * @property {!Array<shaka.ads.InterstitialAdManager.Asset>} ASSETS
  1422.  * @property {shaka.ads.InterstitialAdManager.SkipControl} SKIP-CONTROL
  1423.  */
  1424. shaka.ads.InterstitialAdManager.AssetsList;
  1427. /**
  1428.  * @typedef {{
  1429.  *   URI: string
  1430.  * }}
  1431.  *
  1432.  * @property {string} URI
  1433.  */
  1434. shaka.ads.InterstitialAdManager.Asset;
  1437. /**
  1438.  * @typedef {{
  1439.  *   ENABLE-SKIP-AFTER: number,
  1440.  *   ENABLE-SKIP-FOR: number
  1441.  * }}
  1442.  *
  1443.  * @property {number} ENABLE-SKIP-AFTER
  1444.  * @property {number} ENABLE-SKIP-FOR
  1445.  */
  1446. shaka.ads.InterstitialAdManager.SkipControl;