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.Utils');
  14. goog.require('shaka.log');
  15. goog.require('shaka.media.PreloadManager');
  16. goog.require('shaka.net.NetworkingEngine');
  17. goog.require('shaka.util.Dom');
  18. goog.require('shaka.util.EventManager');
  19. goog.require('shaka.util.FakeEvent');
  20. goog.require('shaka.util.IReleasable');
  21. goog.require('shaka.util.Platform');
  22. goog.require('shaka.util.PublicPromise');
  23. goog.require('shaka.util.StringUtils');
  24. goog.require('shaka.util.Timer');
  27. /**
  28.  * A class responsible for Interstitial ad interactions.
  29.  *
  30.  * @implements {shaka.util.IReleasable}
  31.  */
  32. shaka.ads.InterstitialAdManager = class {
  33.   /**
  34.    * @param {HTMLElement} adContainer
  35.    * @param {shaka.Player} basePlayer
  36.    * @param {HTMLMediaElement} baseVideo
  37.    * @param {function(!shaka.util.FakeEvent)} onEvent
  38.    */
  39.   constructor(adContainer, basePlayer, baseVideo, onEvent) {
  40.     /** @private {HTMLElement} */
  41.     this.adContainer_ = adContainer;
  43.     /** @private {shaka.Player} */
  44.     this.basePlayer_ = basePlayer;
  46.     /** @private {HTMLMediaElement} */
  47.     this.baseVideo_ = baseVideo;
  49.     /** @private {?HTMLMediaElement} */
  50.     this.adVideo_ = null;
  52.     /** @private {boolean} */
  53.     this.usingBaseVideo_ = true;
  55.     /** @private {HTMLMediaElement} */
  56.     this.video_ = this.baseVideo_;
  58.     /** @private {function(!shaka.util.FakeEvent)} */
  59.     this.onEvent_ = onEvent;
  61.     /** @private {!Set.<string>} */
  62.     this.interstitialIds_ = new Set();
  64.     /** @private {!Set.<shaka.ads.InterstitialAdManager.Interstitial>} */
  65.     this.interstitials_ = new Set();
  67.     /**
  68.      * @private {!Map.<shaka.ads.InterstitialAdManager.Interstitial,
  69.      *                 Promise<?shaka.media.PreloadManager>>}
  70.      */
  71.     this.preloadManagerInterstitials_ = new Map();
  73.     /** @private {shaka.Player} */
  74.     this.player_ = new shaka.Player();
  76.     this.updatePlayerConfig_();
  78.     /** @private {shaka.util.EventManager} */
  79.     this.eventManager_ = new shaka.util.EventManager();
  81.     /** @private {shaka.util.EventManager} */
  82.     this.adEventManager_ = new shaka.util.EventManager();
  84.     /** @private {boolean} */
  85.     this.playingAd_ = false;
  87.     /** @private {?number} */
  88.     this.lastTime_ = null;
  90.     this.eventManager_.listen(this.baseVideo_, 'timeupdate', () => {
  91.       if (this.playingAd_) {
  92.         return;
  93.       }
  94.       const needPreRoll = this.lastTime_ == null || this.lastTime_ == 0;
  95.       this.lastTime_ = this.baseVideo_.currentTime;
  96.       const currentInterstitial = this.getCurrentInterstitial_(needPreRoll);
  97.       if (currentInterstitial) {
  98.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  99.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  100.       }
  101.     });
  103.     /** @private {shaka.util.Timer} */
  104.     this.pollTimer_ = new shaka.util.Timer(async () => {
  105.       if (this.interstitials_.size && !this.playingAd_ &&
  106.           this.lastTime_ != null) {
  107.         let cuepointsChanged = false;
  108.         const interstitials = Array.from(this.interstitials_);
  109.         const seekRange = this.basePlayer_.seekRange();
  110.         for (const interstitial of interstitials) {
  111.           const comparisonTime = interstitial.endTime || interstitial.startTime;
  112.           if ((seekRange.start - comparisonTime) >= 1) {
  113.             if (this.preloadManagerInterstitials_.has(interstitial)) {
  114.               const preloadManager =
  115.                   // eslint-disable-next-line no-await-in-loop
  116.                   await this.preloadManagerInterstitials_.get(interstitial);
  117.               if (preloadManager) {
  118.                 preloadManager.destroy();
  119.               }
  120.               this.preloadManagerInterstitials_.delete(interstitial);
  121.             }
  122.             const interstitialId = JSON.stringify(interstitial);
  123.             if (this.interstitialIds_.has(interstitialId)) {
  124.               this.interstitialIds_.delete(interstitialId);
  125.             }
  126.             this.interstitials_.delete(interstitial);
  127.             cuepointsChanged = true;
  128.           } else {
  129.             const difference = interstitial.startTime - this.lastTime_;
  130.             if (difference > 0 && difference <= 10) {
  131.               if (!this.preloadManagerInterstitials_.has(interstitial)) {
  132.                 this.preloadManagerInterstitials_.set(
  133.                     interstitial, this.player_.preload(interstitial.uri));
  134.               }
  135.             }
  136.           }
  137.         }
  138.         if (cuepointsChanged) {
  139.           this.cuepointsChanged_();
  140.         }
  141.       }
  142.     }).tickEvery(/* seconds= */ 1);
  143.   }
  145.   /**
  146.    * Called by the AdManager to provide an updated configuration any time it
  147.    * changes.
  148.    *
  149.    * @param {shaka.extern.AdsConfiguration} config
  150.    */
  151.   configure(config) {
  152.     if (!this.adContainer_ ||
  153.         this.usingBaseVideo_ != config.supportsMultipleMediaElements) {
  154.       return;
  155.     }
  156.     this.usingBaseVideo_ = !config.supportsMultipleMediaElements;
  157.     if (this.usingBaseVideo_) {
  158.       this.video_ = this.baseVideo_;
  159.       if (this.adVideo_) {
  160.         if (this.adVideo_.parentElement) {
  161.           this.adContainer_.removeChild(this.adVideo_);
  162.         }
  163.         this.adVideo_ = null;
  164.       }
  165.     } else {
  166.       if (!this.adVideo_) {
  167.         this.adVideo_ = this.createMediaElement_();
  168.       }
  169.       this.video_ = this.adVideo_;
  170.     }
  171.   }
  174.   /**
  175.    * Resets the Interstitial manager and removes any continuous polling.
  176.    */
  177.   stop() {
  178.     if (this.adEventManager_) {
  179.       this.adEventManager_.removeAll();
  180.     }
  181.     this.interstitialIds_.clear();
  182.     this.interstitials_.clear();
  183.     this.player_.destroyAllPreloads();
  184.     this.preloadManagerInterstitials_.clear();
  185.     this.player_.detach();
  186.     this.playingAd_ = false;
  187.     this.lastTime_ = null;
  188.   }
  190.   /** @override */
  191.   release() {
  192.     this.stop();
  193.     if (this.eventManager_) {
  194.       this.eventManager_.release();
  195.     }
  196.     if (this.adEventManager_) {
  197.       this.adEventManager_.release();
  198.     }
  199.     if (this.adContainer_) {
  200.       shaka.util.Dom.removeAllChildren(this.adContainer_);
  201.     }
  202.     if (this.pollTimer_) {
  203.       this.pollTimer_.stop();
  204.       this.pollTimer_ = null;
  205.     }
  206.     this.player_.destroy();
  207.   }
  210.   /**
  211.    * @param {shaka.extern.Interstitial} interstitial
  212.    */
  213.   async addMetadata(interstitial) {
  214.     if (this.basePlayer_.getLoadMode() == shaka.Player.LoadMode.SRC_EQUALS &&
  215.         this.usingBaseVideo_) {
  216.       shaka.log.alwaysWarn(
  217.           'Unsupported interstitial when using single media element',
  218.           interstitial);
  219.       return;
  220.     }
  221.     this.updatePlayerConfig_();
  222.     let cuepointsChanged = false;
  223.     const interstitialsAd = await this.getInterstitialsInfo_(interstitial);
  224.     if (interstitialsAd.length) {
  225.       for (const interstitialAd of interstitialsAd) {
  226.         const interstitialId = JSON.stringify(interstitialAd);
  227.         if (this.interstitialIds_.has(interstitialId)) {
  228.           continue;
  229.         }
  230.         cuepointsChanged = true;
  231.         this.interstitialIds_.add(interstitialId);
  232.         this.interstitials_.add(interstitialAd);
  233.         let shouldPreload = false;
  234.         if (interstitial.pre && this.lastTime_ == null) {
  235.           shouldPreload = true;
  236.         } else if (interstitialAd.startTime == 0 && !interstitialAd.canJump) {
  237.           shouldPreload = true;
  238.         } else if (this.lastTime_ != null) {
  239.           const difference = interstitial.startTime - this.lastTime_;
  240.           if (difference > 0 && difference <= 10) {
  241.             shouldPreload = true;
  242.           }
  243.         }
  244.         if (shouldPreload) {
  245.           if (!this.preloadManagerInterstitials_.has(interstitialAd)) {
  246.             this.preloadManagerInterstitials_.set(
  247.                 interstitialAd, this.player_.preload(interstitialAd.uri));
  248.           }
  249.         }
  250.       }
  251.     } else {
  252.       shaka.log.alwaysWarn('Unsupported interstitial', interstitial);
  253.     }
  254.     if (cuepointsChanged) {
  255.       this.cuepointsChanged_();
  256.     }
  257.   }
  259.   /**
  260.    * @return {!HTMLMediaElement}
  261.    * @private
  262.    */
  263.   createMediaElement_() {
  264.     const video = /** @type {!HTMLMediaElement} */(
  265.       document.createElement(this.baseVideo_.tagName));
  266.     video.autoplay = true;
  267.     video.style.position = 'absolute';
  268.     video.style.top = '0';
  269.     video.style.left = '0';
  270.     video.style.width = '100%';
  271.     video.style.height = '100%';
  272.     video.style.backgroundColor = 'rgb(0, 0, 0)';
  273.     video.setAttribute('playsinline', '');
  274.     return video;
  275.   }
  278.   /**
  279.    * @param {boolean} needPreRoll
  280.    * @param {number=} numberToSkip
  281.    * @return {?shaka.ads.InterstitialAdManager.Interstitial}
  282.    * @private
  283.    */
  284.   getCurrentInterstitial_(needPreRoll, numberToSkip = 0) {
  285.     let skipped = 0;
  286.     let currentInterstitial = null;
  287.     if (this.interstitials_.size && this.lastTime_ != null) {
  288.       const isEnded = this.baseVideo_.ended;
  289.       const interstitials = Array.from(this.interstitials_).sort((a, b) => {
  290.         return b.startTime - a.startTime;
  291.       });
  292.       const roundDecimals = (number) => {
  293.         return Math.round(number * 1000) / 1000;
  294.       };
  295.       for (const interstitial of interstitials) {
  296.         let isValid = false;
  297.         if (needPreRoll) {
  298.           isValid = interstitial.pre;
  299.         } else if (isEnded) {
  300.           isValid = interstitial.post;
  301.         } else if (!interstitial.pre && !interstitial.post) {
  302.           const difference =
  303.               this.lastTime_ - roundDecimals(interstitial.startTime);
  304.           isValid = difference > 0 &&
  305.               (difference <= 1 || !interstitial.canJump);
  306.         }
  307.         if (isValid) {
  308.           if (skipped == numberToSkip) {
  309.             currentInterstitial = interstitial;
  310.             break;
  311.           }
  312.           skipped++;
  313.         }
  314.       }
  315.     }
  316.     return currentInterstitial;
  317.   }
  320.   /**
  321.    * @param {shaka.ads.InterstitialAdManager.Interstitial} interstitial
  322.    * @param {number} sequenceLength
  323.    * @param {number} adPosition
  324.    * @param {number} initialTime the clock time the ad started at
  325.    * @param {number=} oncePlayed
  326.    * @private
  327.    */
  328.   async setupAd_(interstitial, sequenceLength, adPosition, initialTime,
  329.       oncePlayed = 0) {
  330.     goog.asserts.assert(this.video_, 'Must have video');
  332.     const startTime = Date.now();
  334.     if (!this.video_.parentElement && this.adContainer_) {
  335.       this.adContainer_.appendChild(this.video_);
  336.     }
  338.     if (adPosition == 1 && sequenceLength == 1) {
  339.       sequenceLength = Array.from(this.interstitials_).filter((i) => {
  340.         if (interstitial.pre) {
  341.           return i.pre == interstitial.pre;
  342.         } else if (interstitial.post) {
  343.           return i.post == interstitial.post;
  344.         }
  345.         return Math.abs(i.startTime - interstitial.startTime) < 0.001;
  346.       }).length;
  347.     }
  349.     if (interstitial.once || interstitial.pre) {
  350.       oncePlayed++;
  351.       this.interstitials_.delete(interstitial);
  352.       this.cuepointsChanged_();
  353.     }
  354.     this.playingAd_ = true;
  356.     if (this.usingBaseVideo_ && adPosition == 1) {
  357.       this.onEvent_(new shaka.util.FakeEvent(
  358.           shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED,
  359.           (new Map()).set('saveLivePosition', true)));
  360.       const detachBasePlayerPromise = new shaka.util.PublicPromise();
  361.       const checkState = async (e) => {
  362.         if (e['state'] == 'detach') {
  363.           if (shaka.util.Platform.isSmartTV()) {
  364.             await new Promise(
  365.                 (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  366.           }
  367.           detachBasePlayerPromise.resolve();
  368.           this.adEventManager_.unlisten(
  369.               this.basePlayer_, 'onstatechange', checkState);
  370.         }
  371.       };
  372.       this.adEventManager_.listen(
  373.           this.basePlayer_, 'onstatechange', checkState);
  374.       await detachBasePlayerPromise;
  375.     }
  376.     if (!this.usingBaseVideo_) {
  377.       this.baseVideo_.pause();
  378.       if (interstitial.resumeOffset != null &&
  379.           interstitial.resumeOffset != 0) {
  380.         this.baseVideo_.currentTime += interstitial.resumeOffset;
  381.       }
  382.     }
  384.     let unloadingInterstitial = false;
  385.     /** @type {?shaka.util.Timer} */
  386.     let playoutLimitTimer = null;
  388.     const updateBaseVideoTime = () => {
  389.       if (!this.usingBaseVideo_) {
  390.         if (interstitial.resumeOffset == null) {
  391.           if (interstitial.timelineRange && interstitial.endTime &&
  392.               interstitial.endTime != Infinity) {
  393.             if (this.baseVideo_.currentTime != interstitial.endTime) {
  394.               this.baseVideo_.currentTime = interstitial.endTime;
  395.             }
  396.           } else {
  397.             const now = Date.now();
  398.             this.baseVideo_.currentTime += (now - initialTime) / 1000;
  399.             initialTime = now;
  400.           }
  401.         }
  402.       }
  403.     };
  405.     const basicTask = async () => {
  406.       updateBaseVideoTime();
  407.       if (playoutLimitTimer) {
  408.         playoutLimitTimer.stop();
  409.       }
  410.       goog.asserts.assert(typeof(oncePlayed) == 'number',
  411.           'Should be an number!');
  412.       // Optimization to avoid returning to main content when there is another
  413.       // interstitial below.
  414.       const nextCurrentInterstitial = this.getCurrentInterstitial_(
  415.           interstitial.pre, adPosition - oncePlayed);
  416.       if (nextCurrentInterstitial) {
  417.         this.onEvent_(
  418.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  419.         this.adEventManager_.removeAll();
  420.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  421.             ++adPosition, initialTime, oncePlayed);
  422.       } else {
  423.         if (this.usingBaseVideo_) {
  424.           await this.player_.detach();
  425.         } else {
  426.           await this.player_.unload();
  427.         }
  428.         if (this.usingBaseVideo_) {
  429.           let offset = interstitial.resumeOffset;
  430.           if (offset == null) {
  431.             if (interstitial.timelineRange && interstitial.endTime &&
  432.                 interstitial.endTime != Infinity) {
  433.               offset = interstitial.endTime - (this.lastTime_ || 0);
  434.             } else {
  435.               offset = (Date.now() - initialTime) / 1000;
  436.             }
  437.           }
  438.           this.onEvent_(new shaka.util.FakeEvent(
  439.               shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED,
  440.               (new Map()).set('offset', offset)));
  441.         }
  442.         this.onEvent_(
  443.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  444.         this.adEventManager_.removeAll();
  445.         this.playingAd_ = false;
  446.         if (!this.usingBaseVideo_) {
  447.           updateBaseVideoTime();
  448.           if (!this.baseVideo_.ended) {
  449.             this.baseVideo_.play();
  450.           }
  451.         }
  452.       }
  453.     };
  454.     const error = async (e) => {
  455.       if (unloadingInterstitial) {
  456.         return;
  457.       }
  458.       unloadingInterstitial = true;
  459.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  460.           (new Map()).set('originalEvent', e)));
  461.       await basicTask();
  462.     };
  463.     const complete = async () => {
  464.       if (unloadingInterstitial) {
  465.         return;
  466.       }
  467.       unloadingInterstitial = true;
  468.       await basicTask();
  469.       this.onEvent_(
  470.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  471.     };
  472.     const onSkip = async () => {
  473.       if (unloadingInterstitial) {
  474.         return;
  475.       }
  476.       unloadingInterstitial = true;
  477.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  478.       await basicTask();
  479.     };
  481.     const ad = new shaka.ads.InterstitialAd(this.video_,
  482.         interstitial.isSkippable, onSkip, sequenceLength, adPosition);
  483.     if (!this.usingBaseVideo_) {
  484.       ad.setMuted(this.baseVideo_.muted);
  485.       ad.setVolume(this.baseVideo_.volume);
  486.     }
  488.     this.onEvent_(
  489.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  490.             (new Map()).set('ad', ad)));
  492.     if (ad.canSkipNow()) {
  493.       this.onEvent_(new shaka.util.FakeEvent(
  494.           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  495.     }
  496.     this.adEventManager_.listenOnce(this.player_, 'error', error);
  497.     this.adEventManager_.listenOnce(this.player_, 'firstquartile', () => {
  498.       updateBaseVideoTime();
  499.       this.onEvent_(
  500.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  501.     });
  502.     this.adEventManager_.listenOnce(this.player_, 'midpoint', () => {
  503.       updateBaseVideoTime();
  504.       this.onEvent_(
  505.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  506.     });
  507.     this.adEventManager_.listenOnce(this.player_, 'thirdquartile', () => {
  508.       updateBaseVideoTime();
  509.       this.onEvent_(
  510.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  511.     });
  512.     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
  513.     this.adEventManager_.listen(this.video_, 'play', () => {
  514.       this.onEvent_(
  515.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  516.     });
  517.     this.adEventManager_.listen(this.video_, 'pause', () => {
  518.       this.onEvent_(
  519.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  520.     });
  521.     this.adEventManager_.listen(this.video_, 'volumechange', () => {
  522.       if (this.video_.muted) {
  523.         this.onEvent_(
  524.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  525.       } else {
  526.         this.onEvent_(
  527.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  528.       }
  529.     });
  530.     try {
  531.       if (interstitial.playoutLimit) {
  532.         playoutLimitTimer = new shaka.util.Timer(() => {
  533.           ad.skip();
  534.         }).tickAfter(interstitial.playoutLimit);
  535.       }
  536.       this.updatePlayerConfig_();
  537.       await this.player_.attach(this.video_);
  538.       if (this.preloadManagerInterstitials_.has(interstitial)) {
  539.         const preloadManager =
  540.             await this.preloadManagerInterstitials_.get(interstitial);
  541.         this.preloadManagerInterstitials_.delete(interstitial);
  542.         if (preloadManager) {
  543.           await this.player_.load(preloadManager);
  544.         } else {
  545.           await this.player_.load(interstitial.uri);
  546.         }
  547.       } else {
  548.         await this.player_.load(interstitial.uri);
  549.       }
  550.       const loadTime = (Date.now() - startTime) / 1000;
  551.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  552.           (new Map()).set('loadTime', loadTime)));
  553.       if (this.usingBaseVideo_) {
  554.         this.baseVideo_.play();
  555.       }
  556.     } catch (e) {
  557.       error(e);
  558.     }
  559.   }
  562.   /**
  563.    * @param {shaka.extern.Interstitial} interstitial
  564.    * @return {!Promise.<!Array.<shaka.ads.InterstitialAdManager.Interstitial>>}
  565.    * @private
  566.    */
  567.   async getInterstitialsInfo_(interstitial) {
  568.     const interstitialsAd = [];
  569.     if (!interstitial) {
  570.       return interstitialsAd;
  571.     }
  572.     const assetUri = interstitial.values.find((v) => v.key == 'X-ASSET-URI');
  573.     const assetList = interstitial.values.find((v) => v.key == 'X-ASSET-LIST');
  574.     if (!assetUri && !assetList) {
  575.       return interstitialsAd;
  576.     }
  577.     const restrict = interstitial.values.find((v) => v.key == 'X-RESTRICT');
  578.     let isSkippable = true;
  579.     let canJump = true;
  580.     if (restrict && restrict.data) {
  581.       const data = /** @type {string} */(restrict.data);
  582.       isSkippable = !data.includes('SKIP');
  583.       canJump = !data.includes('JUMP');
  584.     }
  585.     let resumeOffset = null;
  586.     const resume = interstitial.values.find((v) => v.key == 'X-RESUME-OFFSET');
  587.     if (resume) {
  588.       const resumeOffsetString = /** @type {string} */(resume.data);
  589.       resumeOffset = parseFloat(resumeOffsetString);
  590.       if (isNaN(resumeOffset)) {
  591.         resumeOffset = null;
  592.       }
  593.     }
  594.     let playoutLimit = null;
  595.     const playout = interstitial.values.find((v) => v.key == 'X-PLAYOUT-LIMIT');
  596.     if (playout) {
  597.       const playoutLimitString = /** @type {string} */(playout.data);
  598.       playoutLimit = parseFloat(playoutLimitString);
  599.       if (isNaN(playoutLimit)) {
  600.         playoutLimit = null;
  601.       }
  602.     }
  603.     let once = false;
  604.     let pre = false;
  605.     let post = false;
  606.     const cue = interstitial.values.find((v) => v.key == 'CUE');
  607.     if (cue) {
  608.       const data = /** @type {string} */(cue.data);
  609.       once = data.includes('ONCE');
  610.       pre = data.includes('PRE');
  611.       post = data.includes('POST');
  612.     }
  613.     let timelineRange = false;
  614.     const timelineOccupies =
  615.         interstitial.values.find((v) => v.key == 'X-TIMELINE-OCCUPIES');
  616.     if (timelineOccupies) {
  617.       const data = /** @type {string} */(timelineOccupies.data);
  618.       timelineRange = data.includes('RANGE');
  619.     } else if (!resume && this.basePlayer_.isLive()) {
  620.       timelineRange = !pre && !post;
  621.     }
  622.     if (assetUri) {
  623.       const uri = /** @type {string} */(assetUri.data);
  624.       if (!uri) {
  625.         return interstitialsAd;
  626.       }
  627.       interstitialsAd.push({
  628.         startTime: interstitial.startTime,
  629.         endTime: interstitial.endTime,
  630.         uri,
  631.         isSkippable,
  632.         canJump,
  633.         resumeOffset,
  634.         playoutLimit,
  635.         once,
  636.         pre,
  637.         post,
  638.         timelineRange,
  639.       });
  640.     } else if (assetList) {
  641.       const uri = /** @type {string} */(assetList.data);
  642.       if (!uri) {
  643.         return interstitialsAd;
  644.       }
  645.       const type = shaka.net.NetworkingEngine.RequestType.ADS;
  646.       const request = shaka.net.NetworkingEngine.makeRequest(
  647.           [uri],
  648.           shaka.net.NetworkingEngine.defaultRetryParameters());
  649.       const op = this.basePlayer_.getNetworkingEngine().request(type, request);
  650.       try {
  651.         const response = await op.promise;
  652.         const data = shaka.util.StringUtils.fromUTF8(response.data);
  653.         const dataAsJson =
  654.         /** @type {!shaka.ads.InterstitialAdManager.AssetsList} */ (
  655.             JSON.parse(data));
  656.         for (const asset of dataAsJson['ASSETS']) {
  657.           if (asset['URI']) {
  658.             interstitialsAd.push({
  659.               startTime: interstitial.startTime,
  660.               endTime: interstitial.endTime,
  661.               uri: asset['URI'],
  662.               isSkippable,
  663.               canJump,
  664.               resumeOffset,
  665.               playoutLimit,
  666.               once,
  667.               pre,
  668.               post,
  669.               timelineRange,
  670.             });
  671.           }
  672.         }
  673.       } catch (e) {
  674.         // Ignore errors
  675.       }
  676.     }
  677.     return interstitialsAd;
  678.   }
  681.   /**
  682.    * @private
  683.    */
  684.   cuepointsChanged_() {
  685.     /** @type {!Array.<!shaka.extern.AdCuePoint>} */
  686.     const cuePoints = [];
  687.     for (const interstitial of this.interstitials_) {
  688.       /** @type {shaka.extern.AdCuePoint} */
  689.       const shakaCuePoint = {
  690.         start: interstitial.startTime,
  691.         end: null,
  692.       };
  693.       if (interstitial.pre) {
  694.         shakaCuePoint.start = 0;
  695.         shakaCuePoint.end = null;
  696.       } else if (interstitial.post) {
  697.         shakaCuePoint.start = -1;
  698.         shakaCuePoint.end = null;
  699.       } else if (interstitial.timelineRange) {
  700.         shakaCuePoint.end = interstitial.endTime;
  701.       }
  702.       const isValid = !cuePoints.find((c) => {
  703.         return shakaCuePoint.start == c.start && shakaCuePoint.end == c.end;
  704.       });
  705.       if (isValid) {
  706.         cuePoints.push(shakaCuePoint);
  707.       }
  708.     }
  710.     this.onEvent_(new shaka.util.FakeEvent(
  711.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  712.         (new Map()).set('cuepoints', cuePoints)));
  713.   }
  716.   /**
  717.    * @private
  718.    */
  719.   updatePlayerConfig_() {
  720.     goog.asserts.assert(this.player_, 'Must have player');
  721.     goog.asserts.assert(this.basePlayer_, 'Must have base player');
  722.     this.player_.configure(this.basePlayer_.getNonDefaultConfiguration());
  723.     const netEngine = this.player_.getNetworkingEngine();
  724.     goog.asserts.assert(netEngine, 'Need networking engine');
  725.     netEngine.clearAllRequestFilters();
  726.     netEngine.clearAllResponseFilters();
  727.     this.basePlayer_.getNetworkingEngine().copyFiltersInto(netEngine);
  728.   }
  729. };
  732. /**
  733.  * @typedef {{
  734.  *   ASSETS: !Array.<shaka.ads.InterstitialAdManager.Asset>
  735.  * }}
  736.  *
  737.  * @property {!Array.<shaka.ads.InterstitialAdManager.Asset>} ASSETS
  738.  */
  739. shaka.ads.InterstitialAdManager.AssetsList;
  742. /**
  743.  * @typedef {{
  744.  *   URI: string
  745.  * }}
  746.  *
  747.  * @property {string} URI
  748.  */
  749. shaka.ads.InterstitialAdManager.Asset;
  752. /**
  753.  * @typedef {{
  754.  *   startTime: number,
  755.  *   endTime: ?number,
  756.  *   uri: string,
  757.  *   isSkippable: boolean,
  758.  *   canJump: boolean,
  759.  *   resumeOffset: ?number,
  760.  *   playoutLimit: ?number,
  761.  *   once: boolean,
  762.  *   pre: boolean,
  763.  *   post: boolean,
  764.  *   timelineRange: boolean
  765.  * }}
  766.  *
  767.  * @property {number} startTime
  768.  * @property {?number} endTime
  769.  * @property {string} uri
  770.  * @property {boolean} isSkippable
  771.  * @property {boolean} canJump
  772.  * @property {?number} resumeOffset
  773.  * @property {?number} playoutLimit
  774.  * @property {boolean} once
  775.  * @property {boolean} pre
  776.  * @property {boolean} post
  777.  * @property {boolean} timelineRange
  778.  */
  779. shaka.ads.InterstitialAdManager.Interstitial;