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.Error');
  19. goog.require('shaka.util.EventManager');
  20. goog.require('shaka.util.FakeEvent');
  21. goog.require('shaka.util.IReleasable');
  22. goog.require('shaka.util.Platform');
  23. goog.require('shaka.util.PublicPromise');
  24. goog.require('shaka.util.StringUtils');
  25. goog.require('shaka.util.Timer');
  26. goog.require('shaka.util.TXml');
  29. /**
  30.  * A class responsible for Interstitial ad interactions.
  31.  *
  32.  * @implements {shaka.util.IReleasable}
  33.  */
  34. shaka.ads.InterstitialAdManager = class {
  35.   /**
  36.    * @param {HTMLElement} adContainer
  37.    * @param {shaka.Player} basePlayer
  38.    * @param {HTMLMediaElement} baseVideo
  39.    * @param {function(!shaka.util.FakeEvent)} onEvent
  40.    */
  41.   constructor(adContainer, basePlayer, baseVideo, onEvent) {
  42.     /** @private {?shaka.extern.AdsConfiguration} */
  43.     this.config_ = null;
  45.     /** @private {HTMLElement} */
  46.     this.adContainer_ = adContainer;
  48.     /** @private {shaka.Player} */
  49.     this.basePlayer_ = basePlayer;
  51.     /** @private {HTMLMediaElement} */
  52.     this.baseVideo_ = baseVideo;
  54.     /** @private {?HTMLMediaElement} */
  55.     this.adVideo_ = null;
  57.     /** @private {boolean} */
  58.     this.usingBaseVideo_ = true;
  60.     /** @private {HTMLMediaElement} */
  61.     this.video_ = this.baseVideo_;
  63.     /** @private {function(!shaka.util.FakeEvent)} */
  64.     this.onEvent_ = onEvent;
  66.     /** @private {!Set.<string>} */
  67.     this.interstitialIds_ = new Set();
  69.     /** @private {!Set.<shaka.extern.AdInterstitial>} */
  70.     this.interstitials_ = new Set();
  72.     /**
  73.      * @private {!Map.<shaka.extern.AdInterstitial,
  74.      *                 Promise<?shaka.media.PreloadManager>>}
  75.      */
  76.     this.preloadManagerInterstitials_ = new Map();
  78.     /** @private {shaka.Player} */
  79.     this.player_ = new shaka.Player();
  81.     this.updatePlayerConfig_();
  83.     /** @private {shaka.util.EventManager} */
  84.     this.eventManager_ = new shaka.util.EventManager();
  86.     /** @private {shaka.util.EventManager} */
  87.     this.adEventManager_ = new shaka.util.EventManager();
  89.     /** @private {boolean} */
  90.     this.playingAd_ = false;
  92.     /** @private {?number} */
  93.     this.lastTime_ = null;
  95.     /** @private {?shaka.extern.AdInterstitial} */
  96.     this.lastPlayedAd_ = null;
  98.     this.eventManager_.listen(this.baseVideo_, 'timeupdate', () => {
  99.       if (this.playingAd_ || this.lastTime_ ||
  100.           this.basePlayer_.isRemotePlayback()) {
  101.         return;
  102.       }
  103.       this.lastTime_ = this.baseVideo_.currentTime;
  104.       const currentInterstitial = this.getCurrentInterstitial_(
  105.           /* needPreRoll= */ true);
  106.       if (currentInterstitial) {
  107.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  108.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  109.       }
  110.     });
  112.     const checkForInterstitials = () => {
  113.       if (this.playingAd_ || !this.lastTime_ ||
  114.           this.basePlayer_.isRemotePlayback()) {
  115.         return;
  116.       }
  117.       this.lastTime_ = this.baseVideo_.currentTime;
  118.       // Remove last played add when the new time is before to the ad time.
  119.       if (this.lastPlayedAd_ &&
  120.           !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  121.           this.lastTime_ < this.lastPlayedAd_.startTime) {
  122.         this.lastPlayedAd_ = null;
  123.       }
  124.       const currentInterstitial = this.getCurrentInterstitial_();
  125.       if (currentInterstitial) {
  126.         this.setupAd_(currentInterstitial, /* sequenceLength= */ 1,
  127.             /* adPosition= */ 1, /* initialTime= */ Date.now());
  128.       }
  129.     };
  131.     this.eventManager_.listen(this.baseVideo_, 'ended', () => {
  132.       checkForInterstitials();
  133.     });
  135.     /** @private {shaka.util.Timer} */
  136.     this.timeUpdateTimer_ = new shaka.util.Timer(checkForInterstitials);
  138.     if ('requestVideoFrameCallback' in this.baseVideo_ &&
  139.         !shaka.util.Platform.isSmartTV()) {
  140.       const baseVideo = /** @type {!HTMLVideoElement} */ (this.baseVideo_);
  141.       const videoFrameCallback = () => {
  142.         checkForInterstitials();
  143.         baseVideo.requestVideoFrameCallback(videoFrameCallback);
  144.       };
  145.       baseVideo.requestVideoFrameCallback(videoFrameCallback);
  146.     } else {
  147.       this.timeUpdateTimer_.tickEvery(/* seconds= */ 0.025);
  148.     }
  150.     /** @private {shaka.util.Timer} */
  151.     this.pollTimer_ = new shaka.util.Timer(async () => {
  152.       if (this.interstitials_.size && this.lastTime_ != null) {
  153.         const currentLoadMode = this.basePlayer_.getLoadMode();
  154.         if (currentLoadMode == shaka.Player.LoadMode.DESTROYED ||
  155.             currentLoadMode == shaka.Player.LoadMode.NOT_LOADED) {
  156.           return;
  157.         }
  158.         let cuepointsChanged = false;
  159.         const interstitials = Array.from(this.interstitials_);
  160.         const seekRange = this.basePlayer_.seekRange();
  161.         for (const interstitial of interstitials) {
  162.           if (interstitial == this.lastPlayedAd_) {
  163.             continue;
  164.           }
  165.           const comparisonTime = interstitial.endTime || interstitial.startTime;
  166.           if ((seekRange.start - comparisonTime) >= 1) {
  167.             if (this.preloadManagerInterstitials_.has(interstitial)) {
  168.               const preloadManager =
  169.                   // eslint-disable-next-line no-await-in-loop
  170.                   await this.preloadManagerInterstitials_.get(interstitial);
  171.               if (preloadManager) {
  172.                 preloadManager.destroy();
  173.               }
  174.               this.preloadManagerInterstitials_.delete(interstitial);
  175.             }
  176.             const interstitialId = JSON.stringify(interstitial);
  177.             if (this.interstitialIds_.has(interstitialId)) {
  178.               this.interstitialIds_.delete(interstitialId);
  179.             }
  180.             this.interstitials_.delete(interstitial);
  181.             cuepointsChanged = true;
  182.           } else {
  183.             const difference = interstitial.startTime - this.lastTime_;
  184.             if (difference > 0 && difference <= 10) {
  185.               if (!this.preloadManagerInterstitials_.has(interstitial)) {
  186.                 this.preloadManagerInterstitials_.set(
  187.                     interstitial, this.player_.preload(interstitial.uri));
  188.               }
  189.             }
  190.           }
  191.         }
  192.         if (cuepointsChanged) {
  193.           this.cuepointsChanged_();
  194.         }
  195.       }
  196.     }).tickEvery(/* seconds= */ 1);
  197.   }
  199.   /**
  200.    * Called by the AdManager to provide an updated configuration any time it
  201.    * changes.
  202.    *
  203.    * @param {shaka.extern.AdsConfiguration} config
  204.    */
  205.   configure(config) {
  206.     this.config_ = config;
  207.     this.determineIfUsingBaseVideo_();
  208.   }
  210.   /**
  211.    * @private
  212.    */
  213.   determineIfUsingBaseVideo_() {
  214.     if (!this.adContainer_ || !this.config_ || this.playingAd_) {
  215.       return;
  216.     }
  217.     let supportsMultipleMediaElements =
  218.         this.config_.supportsMultipleMediaElements;
  219.     const video = /** @type {HTMLVideoElement} */(this.baseVideo_);
  220.     if (video.webkitSupportsFullscreen && video.webkitDisplayingFullscreen) {
  221.       supportsMultipleMediaElements = false;
  222.     }
  223.     if (this.usingBaseVideo_ != supportsMultipleMediaElements) {
  224.       return;
  225.     }
  226.     this.usingBaseVideo_ = !supportsMultipleMediaElements;
  227.     if (this.usingBaseVideo_) {
  228.       this.video_ = this.baseVideo_;
  229.       if (this.adVideo_) {
  230.         if (this.adVideo_.parentElement) {
  231.           this.adContainer_.removeChild(this.adVideo_);
  232.         }
  233.         this.adVideo_ = null;
  234.       }
  235.     } else {
  236.       if (!this.adVideo_) {
  237.         this.adVideo_ = this.createMediaElement_();
  238.       }
  239.       this.video_ = this.adVideo_;
  240.     }
  241.   }
  244.   /**
  245.    * Resets the Interstitial manager and removes any continuous polling.
  246.    */
  247.   stop() {
  248.     if (this.adEventManager_) {
  249.       this.adEventManager_.removeAll();
  250.     }
  251.     this.interstitialIds_.clear();
  252.     this.interstitials_.clear();
  253.     this.player_.destroyAllPreloads();
  254.     this.preloadManagerInterstitials_.clear();
  255.     this.player_.detach();
  256.     this.playingAd_ = false;
  257.     this.lastTime_ = null;
  258.     this.lastPlayedAd_ = null;
  259.   }
  261.   /** @override */
  262.   release() {
  263.     this.stop();
  264.     if (this.eventManager_) {
  265.       this.eventManager_.release();
  266.     }
  267.     if (this.adEventManager_) {
  268.       this.adEventManager_.release();
  269.     }
  270.     if (this.adContainer_) {
  271.       shaka.util.Dom.removeAllChildren(this.adContainer_);
  272.     }
  273.     if (this.timeUpdateTimer_) {
  274.       this.timeUpdateTimer_.stop();
  275.       this.timeUpdateTimer_ = null;
  276.     }
  277.     if (this.pollTimer_) {
  278.       this.pollTimer_.stop();
  279.       this.pollTimer_ = null;
  280.     }
  281.     this.player_.destroy();
  282.   }
  285.   /**
  286.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  287.    */
  288.   async addMetadata(hlsInterstitial) {
  289.     this.updatePlayerConfig_();
  290.     const adInterstitials = await this.getInterstitialsInfo_(hlsInterstitial);
  291.     if (adInterstitials.length) {
  292.       this.addInterstitials(adInterstitials);
  293.     } else {
  294.       shaka.log.alwaysWarn('Unsupported HLS interstitial', hlsInterstitial);
  295.     }
  296.   }
  298.   /**
  299.    * @param {shaka.extern.TimelineRegionInfo} region
  300.    */
  301.   addRegion(region) {
  302.     let alternativeMPDUri;
  303.     let alternativeMPDmode;
  304.     for (const node of region.eventNode.children) {
  305.       if (node.tagName == 'AlternativeMPD') {
  306.         const uri = node.attributes['uri'];
  307.         const mode = node.attributes['mode'];
  308.         if (uri) {
  309.           alternativeMPDUri = uri;
  310.           alternativeMPDmode = mode;
  311.           break;
  312.         }
  313.       }
  314.     }
  315.     if (!alternativeMPDUri) {
  316.       shaka.log.alwaysWarn('Unsupported MPD alternate', region);
  317.       return;
  318.     }
  319.     const isReplace = alternativeMPDmode == 'replace';
  320.     const isInsert = alternativeMPDmode == 'insert';
  321.     if (!isReplace && !isInsert) {
  322.       shaka.log.warning('Unsupported MPD alternate', region);
  323.       return;
  324.     }
  325.     const interstitial = {
  326.       id: region.id,
  327.       startTime: region.startTime,
  328.       endTime: region.endTime,
  329.       uri: alternativeMPDUri,
  330.       isSkippable: false,
  331.       skipOffset: null,
  332.       canJump: true,
  333.       resumeOffset: isInsert ? 0 : null,
  334.       playoutLimit: null,
  335.       once: false,
  336.       pre: false,
  337.       post: false,
  338.       timelineRange: isReplace && !isInsert,
  339.     };
  340.     this.addInterstitials([interstitial]);
  341.   }
  343.   /**
  344.    * @param {string} url
  345.    * @return {!Promise}
  346.    */
  347.   async addAdUrlInterstitial(url) {
  348.     const NetworkingEngine = shaka.net.NetworkingEngine;
  349.     const context = {
  350.       type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_AD_URL,
  351.     };
  352.     const responseData = await this.makeAdRequest_(url, context);
  353.     const data = shaka.util.TXml.parseXml(responseData, 'VAST,vmap:VMAP');
  354.     if (!data) {
  355.       throw new shaka.util.Error(
  356.           shaka.util.Error.Severity.CRITICAL,
  357.           shaka.util.Error.Category.ADS,
  358.           shaka.util.Error.Code.VAST_INVALID_XML);
  359.     }
  360.     let interstitials = [];
  361.     if (data.tagName == 'VAST') {
  362.       interstitials = shaka.ads.Utils.parseVastToInterstitials(
  363.           data, this.lastTime_);
  364.     } else if (data.tagName == 'vmap:VMAP') {
  365.       for (const ad of shaka.ads.Utils.parseVMAP(data)) {
  366.         // eslint-disable-next-line no-await-in-loop
  367.         const vastResponseData = await this.makeAdRequest_(ad.uri, context);
  368.         const vast = shaka.util.TXml.parseXml(vastResponseData, 'VAST');
  369.         if (!vast) {
  370.           throw new shaka.util.Error(
  371.               shaka.util.Error.Severity.CRITICAL,
  372.               shaka.util.Error.Category.ADS,
  373.               shaka.util.Error.Code.VAST_INVALID_XML);
  374.         }
  375.         interstitials.push(...shaka.ads.Utils.parseVastToInterstitials(
  376.             vast, ad.time));
  377.       }
  378.     }
  379.     this.addInterstitials(interstitials);
  380.   }
  383.   /**
  384.    * @param {!Array.<shaka.extern.AdInterstitial>} interstitials
  385.    */
  386.   addInterstitials(interstitials) {
  387.     let cuepointsChanged = false;
  388.     for (const interstitial of interstitials) {
  389.       const interstitialId = interstitial.id || JSON.stringify(interstitial);
  390.       if (this.interstitialIds_.has(interstitialId)) {
  391.         continue;
  392.       }
  393.       cuepointsChanged = true;
  394.       this.interstitialIds_.add(interstitialId);
  395.       this.interstitials_.add(interstitial);
  396.       let shouldPreload = false;
  397.       if (interstitial.pre && this.lastTime_ == null) {
  398.         shouldPreload = true;
  399.       } else if (interstitial.startTime == 0 && !interstitial.canJump) {
  400.         shouldPreload = true;
  401.       } else if (this.lastTime_ != null) {
  402.         const difference = interstitial.startTime - this.lastTime_;
  403.         if (difference > 0 && difference <= 10) {
  404.           shouldPreload = true;
  405.         }
  406.       }
  407.       if (shouldPreload) {
  408.         if (!this.preloadManagerInterstitials_.has(interstitial)) {
  409.           this.preloadManagerInterstitials_.set(
  410.               interstitial, this.player_.preload(interstitial.uri));
  411.         }
  412.       }
  413.     }
  414.     if (cuepointsChanged) {
  415.       this.cuepointsChanged_();
  416.     }
  417.   }
  419.   /**
  420.    * @return {!HTMLMediaElement}
  421.    * @private
  422.    */
  423.   createMediaElement_() {
  424.     const video = /** @type {!HTMLMediaElement} */(
  425.       document.createElement(this.baseVideo_.tagName));
  426.     video.autoplay = true;
  427.     video.style.position = 'absolute';
  428.     video.style.top = '0';
  429.     video.style.left = '0';
  430.     video.style.width = '100%';
  431.     video.style.height = '100%';
  432.     video.style.backgroundColor = 'rgb(0, 0, 0)';
  433.     video.setAttribute('playsinline', '');
  434.     return video;
  435.   }
  438.   /**
  439.    * @param {boolean=} needPreRoll
  440.    * @param {?number=} numberToSkip
  441.    * @return {?shaka.extern.AdInterstitial}
  442.    * @private
  443.    */
  444.   getCurrentInterstitial_(needPreRoll = false, numberToSkip = null) {
  445.     let skipped = 0;
  446.     let currentInterstitial = null;
  447.     if (this.interstitials_.size && this.lastTime_ != null) {
  448.       const isEnded = this.baseVideo_.ended;
  449.       const interstitials = Array.from(this.interstitials_).sort((a, b) => {
  450.         return b.startTime - a.startTime;
  451.       });
  452.       const roundDecimals = (number) => {
  453.         return Math.round(number * 1000) / 1000;
  454.       };
  455.       let interstitialsToCheck = interstitials;
  456.       if (needPreRoll) {
  457.         interstitialsToCheck = interstitials.filter((i) => i.pre);
  458.       } else if (isEnded) {
  459.         interstitialsToCheck = interstitials.filter((i) => i.post);
  460.       } else {
  461.         interstitialsToCheck = interstitials.filter((i) => !i.pre && !i.post);
  462.       }
  463.       for (const interstitial of interstitialsToCheck) {
  464.         let isValid = false;
  465.         if (needPreRoll) {
  466.           isValid = interstitial.pre;
  467.         } else if (isEnded) {
  468.           isValid = interstitial.post;
  469.         } else if (!interstitial.pre && !interstitial.post) {
  470.           const difference =
  471.               this.lastTime_ - roundDecimals(interstitial.startTime);
  472.           if (difference > 0 &&
  473.               (difference <= 1 || !interstitial.canJump)) {
  474.             if (numberToSkip == null && this.lastPlayedAd_ &&
  475.                 !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  476.                 this.lastPlayedAd_.startTime >= interstitial.startTime) {
  477.               isValid = false;
  478.             } else {
  479.               isValid = true;
  480.             }
  481.           }
  482.         }
  483.         if (isValid && (!this.lastPlayedAd_ ||
  484.             interstitial.startTime >= this.lastPlayedAd_.startTime)) {
  485.           if (skipped == (numberToSkip || 0)) {
  486.             currentInterstitial = interstitial;
  487.           } else if (currentInterstitial && !interstitial.canJump) {
  488.             const currentStartTime =
  489.                 roundDecimals(currentInterstitial.startTime);
  490.             const newStartTime =
  491.                 roundDecimals(interstitial.startTime);
  492.             if (newStartTime - currentStartTime > 0.001) {
  493.               currentInterstitial = interstitial;
  494.               skipped = 0;
  495.             }
  496.           }
  497.           skipped++;
  498.         }
  499.       }
  500.     }
  501.     return currentInterstitial;
  502.   }
  505.   /**
  506.    * @param {shaka.extern.AdInterstitial} interstitial
  507.    * @param {number} sequenceLength
  508.    * @param {number} adPosition
  509.    * @param {number} initialTime the clock time the ad started at
  510.    * @param {number=} oncePlayed
  511.    * @private
  512.    */
  513.   async setupAd_(interstitial, sequenceLength, adPosition, initialTime,
  514.       oncePlayed = 0) {
  515.     this.determineIfUsingBaseVideo_();
  516.     goog.asserts.assert(this.video_, 'Must have video');
  518.     this.lastPlayedAd_ = interstitial;
  520.     shaka.log.info('Starting interstitial',
  521.         interstitial.startTime, 'at', this.lastTime_);
  523.     const startTime = Date.now();
  525.     if (!this.video_.parentElement && this.adContainer_) {
  526.       this.adContainer_.appendChild(this.video_);
  527.     }
  529.     if (adPosition == 1 && sequenceLength == 1) {
  530.       sequenceLength = Array.from(this.interstitials_).filter((i) => {
  531.         if (interstitial.pre) {
  532.           return i.pre == interstitial.pre;
  533.         } else if (interstitial.post) {
  534.           return i.post == interstitial.post;
  535.         }
  536.         return Math.abs(i.startTime - interstitial.startTime) < 0.001;
  537.       }).length;
  538.     }
  540.     if (interstitial.once) {
  541.       oncePlayed++;
  542.       this.interstitials_.delete(interstitial);
  543.       this.cuepointsChanged_();
  544.     }
  545.     this.playingAd_ = true;
  547.     if (this.usingBaseVideo_ && adPosition == 1) {
  548.       this.onEvent_(new shaka.util.FakeEvent(
  549.           shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED,
  550.           (new Map()).set('saveLivePosition', true)));
  551.       const detachBasePlayerPromise = new shaka.util.PublicPromise();
  552.       const checkState = async (e) => {
  553.         if (e['state'] == 'detach') {
  554.           if (shaka.util.Platform.isSmartTV()) {
  555.             await new Promise(
  556.                 (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  557.           }
  558.           detachBasePlayerPromise.resolve();
  559.           this.adEventManager_.unlisten(
  560.               this.basePlayer_, 'onstatechange', checkState);
  561.         }
  562.       };
  563.       this.adEventManager_.listen(
  564.           this.basePlayer_, 'onstatechange', checkState);
  565.       await detachBasePlayerPromise;
  566.     }
  567.     if (!this.usingBaseVideo_) {
  568.       this.baseVideo_.pause();
  569.       if (interstitial.resumeOffset != null &&
  570.           interstitial.resumeOffset != 0) {
  571.         this.baseVideo_.currentTime += interstitial.resumeOffset;
  572.       }
  573.     }
  575.     let unloadingInterstitial = false;
  576.     /** @type {?shaka.util.Timer} */
  577.     let playoutLimitTimer = null;
  579.     const updateBaseVideoTime = () => {
  580.       if (!this.usingBaseVideo_) {
  581.         if (interstitial.resumeOffset == null) {
  582.           if (interstitial.timelineRange && interstitial.endTime &&
  583.               interstitial.endTime != Infinity) {
  584.             if (this.baseVideo_.currentTime != interstitial.endTime) {
  585.               this.baseVideo_.currentTime = interstitial.endTime;
  586.             }
  587.           } else {
  588.             const now = Date.now();
  589.             this.baseVideo_.currentTime += (now - initialTime) / 1000;
  590.             initialTime = now;
  591.           }
  592.         }
  593.       }
  594.     };
  596.     const basicTask = async () => {
  597.       updateBaseVideoTime();
  598.       if (playoutLimitTimer) {
  599.         playoutLimitTimer.stop();
  600.       }
  601.       goog.asserts.assert(typeof(oncePlayed) == 'number',
  602.           'Should be an number!');
  603.       // Optimization to avoid returning to main content when there is another
  604.       // interstitial below.
  605.       const nextCurrentInterstitial = this.getCurrentInterstitial_(
  606.           interstitial.pre, adPosition - oncePlayed);
  607.       if (nextCurrentInterstitial) {
  608.         this.onEvent_(
  609.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  610.         this.adEventManager_.removeAll();
  611.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  612.             ++adPosition, initialTime, oncePlayed);
  613.       } else {
  614.         if (interstitial.post) {
  615.           this.lastTime_ = null;
  616.           this.lastPlayedAd_ = null;
  617.         }
  618.         if (this.usingBaseVideo_) {
  619.           await this.player_.detach();
  620.         } else {
  621.           await this.player_.unload();
  622.         }
  623.         if (this.usingBaseVideo_) {
  624.           let offset = interstitial.resumeOffset;
  625.           if (offset == null) {
  626.             if (interstitial.timelineRange && interstitial.endTime &&
  627.                 interstitial.endTime != Infinity) {
  628.               offset = interstitial.endTime - (this.lastTime_ || 0);
  629.             } else {
  630.               offset = (Date.now() - initialTime) / 1000;
  631.             }
  632.           }
  633.           this.onEvent_(new shaka.util.FakeEvent(
  634.               shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED,
  635.               (new Map()).set('offset', offset)));
  636.         }
  637.         this.onEvent_(
  638.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  639.         this.adEventManager_.removeAll();
  640.         this.playingAd_ = false;
  641.         if (!this.usingBaseVideo_) {
  642.           updateBaseVideoTime();
  643.           if (!this.baseVideo_.ended) {
  644.             this.baseVideo_.play();
  645.           }
  646.         } else {
  647.           this.cuepointsChanged_();
  648.         }
  649.         this.determineIfUsingBaseVideo_();
  650.       }
  651.     };
  652.     const error = async (e) => {
  653.       if (unloadingInterstitial) {
  654.         return;
  655.       }
  656.       unloadingInterstitial = true;
  657.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  658.           (new Map()).set('originalEvent', e)));
  659.       await basicTask();
  660.     };
  661.     const complete = async () => {
  662.       if (unloadingInterstitial) {
  663.         return;
  664.       }
  665.       unloadingInterstitial = true;
  666.       await basicTask();
  667.       this.onEvent_(
  668.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  669.     };
  670.     const onSkip = async () => {
  671.       if (unloadingInterstitial) {
  672.         return;
  673.       }
  674.       unloadingInterstitial = true;
  675.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  676.       await basicTask();
  677.     };
  679.     const ad = new shaka.ads.InterstitialAd(this.video_,
  680.         interstitial.isSkippable, interstitial.skipOffset,
  681.         onSkip, sequenceLength, adPosition);
  682.     if (!this.usingBaseVideo_) {
  683.       ad.setMuted(this.baseVideo_.muted);
  684.       ad.setVolume(this.baseVideo_.volume);
  685.     }
  687.     this.onEvent_(
  688.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  689.             (new Map()).set('ad', ad)));
  691.     if (ad.canSkipNow()) {
  692.       this.onEvent_(new shaka.util.FakeEvent(
  693.           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  694.     }
  695.     const eventsSent = new Set();
  696.     this.adEventManager_.listenOnce(this.player_, 'error', error);
  697.     this.adEventManager_.listen(this.video_, 'timeupdate', () => {
  698.       const duration = this.video_.duration;
  699.       if (!duration) {
  700.         return;
  701.       }
  702.       if (interstitial.isSkippable && interstitial.skipOffset &&
  703.           ad.canSkipNow() && ad.getRemainingTime() > 0 &&
  704.           ad.getDuration() > 0) {
  705.         this.onEvent_(
  706.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  707.       }
  708.       const currentPercent = 100 * this.video_.currentTime / duration;
  709.       if (currentPercent >= 25 && !eventsSent.has('firstquartile')) {
  710.         updateBaseVideoTime();
  711.         this.onEvent_(
  712.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  713.         eventsSent.add('firstquartile');
  714.       } else if (currentPercent >= 50 && !eventsSent.has('midpoint')) {
  715.         updateBaseVideoTime();
  716.         this.onEvent_(
  717.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  718.         eventsSent.add('midpoint');
  719.       } else if (currentPercent >= 75 && !eventsSent.has('thirdquartile')) {
  720.         updateBaseVideoTime();
  721.         this.onEvent_(
  722.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  723.         eventsSent.add('thirdquartile');
  724.       }
  725.     });
  726.     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
  727.     this.adEventManager_.listen(this.video_, 'play', () => {
  728.       this.onEvent_(
  729.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  730.     });
  731.     this.adEventManager_.listen(this.video_, 'pause', () => {
  732.       // playRangeEnd in src= causes the ended event not to be fired when that
  733.       // position is reached, instead pause event is fired.
  734.       const currentConfig = this.player_.getConfiguration();
  735.       if (this.video_.currentTime >= currentConfig.playRangeEnd) {
  736.         complete();
  737.         return;
  738.       }
  739.       this.onEvent_(
  740.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  741.     });
  742.     this.adEventManager_.listen(this.video_, 'volumechange', () => {
  743.       if (this.video_.muted) {
  744.         this.onEvent_(
  745.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  746.       } else {
  747.         this.onEvent_(
  748.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  749.       }
  750.     });
  751.     try {
  752.       this.updatePlayerConfig_();
  753.       if (interstitial.startTime && interstitial.endTime &&
  754.           interstitial.endTime != Infinity &&
  755.           interstitial.startTime != interstitial.endTime) {
  756.         const duration = interstitial.endTime - interstitial.startTime;
  757.         if (duration > 0) {
  758.           this.player_.configure('playRangeEnd', duration);
  759.         }
  760.       }
  761.       if (interstitial.playoutLimit) {
  762.         playoutLimitTimer = new shaka.util.Timer(() => {
  763.           ad.skip();
  764.         }).tickAfter(interstitial.playoutLimit);
  765.         this.player_.configure('playRangeEnd', interstitial.playoutLimit);
  766.       }
  767.       await this.player_.attach(this.video_);
  768.       if (this.preloadManagerInterstitials_.has(interstitial)) {
  769.         const preloadManager =
  770.             await this.preloadManagerInterstitials_.get(interstitial);
  771.         this.preloadManagerInterstitials_.delete(interstitial);
  772.         if (preloadManager) {
  773.           await this.player_.load(preloadManager);
  774.         } else {
  775.           await this.player_.load(interstitial.uri);
  776.         }
  777.       } else {
  778.         await this.player_.load(interstitial.uri);
  779.       }
  780.       if (interstitial.playoutLimit) {
  781.         if (playoutLimitTimer) {
  782.           playoutLimitTimer.stop();
  783.         }
  784.         playoutLimitTimer = new shaka.util.Timer(() => {
  785.           ad.skip();
  786.         }).tickAfter(interstitial.playoutLimit);
  787.       }
  788.       const loadTime = (Date.now() - startTime) / 1000;
  789.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  790.           (new Map()).set('loadTime', loadTime)));
  791.       if (this.usingBaseVideo_) {
  792.         this.baseVideo_.play();
  793.       }
  794.     } catch (e) {
  795.       error(e);
  796.     }
  797.   }
  800.   /**
  801.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  802.    * @return {!Promise.<!Array.<shaka.extern.AdInterstitial>>}
  803.    * @private
  804.    */
  805.   async getInterstitialsInfo_(hlsInterstitial) {
  806.     const interstitialsAd = [];
  807.     if (!hlsInterstitial) {
  808.       return interstitialsAd;
  809.     }
  810.     const assetUri = hlsInterstitial.values.find((v) => v.key == 'X-ASSET-URI');
  811.     const assetList =
  812.         hlsInterstitial.values.find((v) => v.key == 'X-ASSET-LIST');
  813.     if (!assetUri && !assetList) {
  814.       return interstitialsAd;
  815.     }
  816.     let id = null;
  817.     const hlsInterstitialId = hlsInterstitial.values.find((v) => v.key == 'ID');
  818.     if (hlsInterstitialId) {
  819.       id = /** @type {string} */(hlsInterstitialId.data);
  820.     }
  821.     const startTime = id == null ?
  822.         Math.floor(hlsInterstitial.startTime * 10) / 10:
  823.         hlsInterstitial.startTime;
  824.     let endTime = hlsInterstitial.endTime;
  825.     if (hlsInterstitial.endTime && hlsInterstitial.endTime != Infinity &&
  826.         typeof(hlsInterstitial.endTime) == 'number') {
  827.       endTime = id == null ?
  828.           Math.floor(hlsInterstitial.endTime * 10) / 10:
  829.           hlsInterstitial.endTime;
  830.     }
  831.     const restrict = hlsInterstitial.values.find((v) => v.key == 'X-RESTRICT');
  832.     let isSkippable = true;
  833.     let canJump = true;
  834.     if (restrict && restrict.data) {
  835.       const data = /** @type {string} */(restrict.data);
  836.       isSkippable = !data.includes('SKIP');
  837.       canJump = !data.includes('JUMP');
  838.     }
  839.     let resumeOffset = null;
  840.     const resume =
  841.         hlsInterstitial.values.find((v) => v.key == 'X-RESUME-OFFSET');
  842.     if (resume) {
  843.       const resumeOffsetString = /** @type {string} */(resume.data);
  844.       resumeOffset = parseFloat(resumeOffsetString);
  845.       if (isNaN(resumeOffset)) {
  846.         resumeOffset = null;
  847.       }
  848.     }
  849.     let playoutLimit = null;
  850.     const playout =
  851.         hlsInterstitial.values.find((v) => v.key == 'X-PLAYOUT-LIMIT');
  852.     if (playout) {
  853.       const playoutLimitString = /** @type {string} */(playout.data);
  854.       playoutLimit = parseFloat(playoutLimitString);
  855.       if (isNaN(playoutLimit)) {
  856.         playoutLimit = null;
  857.       }
  858.     }
  859.     let once = false;
  860.     let pre = false;
  861.     let post = false;
  862.     const cue = hlsInterstitial.values.find((v) => v.key == 'CUE');
  863.     if (cue) {
  864.       const data = /** @type {string} */(cue.data);
  865.       once = data.includes('ONCE');
  866.       pre = data.includes('PRE');
  867.       post = data.includes('POST');
  868.     }
  869.     let timelineRange = false;
  870.     const timelineOccupies =
  871.         hlsInterstitial.values.find((v) => v.key == 'X-TIMELINE-OCCUPIES');
  872.     if (timelineOccupies) {
  873.       const data = /** @type {string} */(timelineOccupies.data);
  874.       timelineRange = data.includes('RANGE');
  875.     } else if (!resume && this.basePlayer_.isLive()) {
  876.       timelineRange = !pre && !post;
  877.     }
  878.     if (assetUri) {
  879.       const uri = /** @type {string} */(assetUri.data);
  880.       if (!uri) {
  881.         return interstitialsAd;
  882.       }
  883.       interstitialsAd.push({
  884.         id,
  885.         startTime,
  886.         endTime,
  887.         uri,
  888.         isSkippable,
  889.         skipOffset: isSkippable ? 0 : null,
  890.         canJump,
  891.         resumeOffset,
  892.         playoutLimit,
  893.         once,
  894.         pre,
  895.         post,
  896.         timelineRange,
  897.       });
  898.     } else if (assetList) {
  899.       const uri = /** @type {string} */(assetList.data);
  900.       if (!uri) {
  901.         return interstitialsAd;
  902.       }
  903.       try {
  904.         const NetworkingEngine = shaka.net.NetworkingEngine;
  905.         const context = {
  906.           type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_ASSET_LIST,
  907.         };
  908.         const responseData = await this.makeAdRequest_(uri, context);
  909.         const data = shaka.util.StringUtils.fromUTF8(responseData);
  910.         const dataAsJson =
  911.         /** @type {!shaka.ads.InterstitialAdManager.AssetsList} */ (
  912.             JSON.parse(data));
  913.         for (const asset of dataAsJson['ASSETS']) {
  914.           if (asset['URI']) {
  915.             interstitialsAd.push({
  916.               id,
  917.               startTime,
  918.               endTime,
  919.               uri: asset['URI'],
  920.               isSkippable,
  921.               skipOffset: isSkippable ? 0 : null,
  922.               canJump,
  923.               resumeOffset,
  924.               playoutLimit,
  925.               once,
  926.               pre,
  927.               post,
  928.               timelineRange,
  929.             });
  930.           }
  931.         }
  932.       } catch (e) {
  933.         // Ignore errors
  934.       }
  935.     }
  936.     return interstitialsAd;
  937.   }
  940.   /**
  941.    * @private
  942.    */
  943.   cuepointsChanged_() {
  944.     /** @type {!Array.<!shaka.extern.AdCuePoint>} */
  945.     const cuePoints = [];
  946.     for (const interstitial of this.interstitials_) {
  947.       /** @type {shaka.extern.AdCuePoint} */
  948.       const shakaCuePoint = {
  949.         start: interstitial.startTime,
  950.         end: null,
  951.       };
  952.       if (interstitial.pre) {
  953.         shakaCuePoint.start = 0;
  954.         shakaCuePoint.end = null;
  955.       } else if (interstitial.post) {
  956.         shakaCuePoint.start = -1;
  957.         shakaCuePoint.end = null;
  958.       } else if (interstitial.timelineRange) {
  959.         shakaCuePoint.end = interstitial.endTime;
  960.       }
  961.       const isValid = !cuePoints.find((c) => {
  962.         return shakaCuePoint.start == c.start && shakaCuePoint.end == c.end;
  963.       });
  964.       if (isValid) {
  965.         cuePoints.push(shakaCuePoint);
  966.       }
  967.     }
  969.     this.onEvent_(new shaka.util.FakeEvent(
  970.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  971.         (new Map()).set('cuepoints', cuePoints)));
  972.   }
  975.   /**
  976.    * @private
  977.    */
  978.   updatePlayerConfig_() {
  979.     goog.asserts.assert(this.player_, 'Must have player');
  980.     goog.asserts.assert(this.basePlayer_, 'Must have base player');
  981.     this.player_.configure(this.basePlayer_.getNonDefaultConfiguration());
  982.     this.player_.configure('ads.disableHLSInterstitial', true);
  983.     this.player_.configure('ads.disableDASHInterstitial', true);
  984.     const netEngine = this.player_.getNetworkingEngine();
  985.     goog.asserts.assert(netEngine, 'Need networking engine');
  986.     netEngine.clearAllRequestFilters();
  987.     netEngine.clearAllResponseFilters();
  988.     this.basePlayer_.getNetworkingEngine().copyFiltersInto(netEngine);
  989.   }
  991.   /**
  992.    * @param {string} url
  993.    * @param {shaka.extern.RequestContext=} context
  994.    * @return {!Promise.<BufferSource>}
  995.    * @private
  996.    */
  997.   async makeAdRequest_(url, context) {
  998.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  999.     const request = shaka.net.NetworkingEngine.makeRequest(
  1000.         [url],
  1001.         shaka.net.NetworkingEngine.defaultRetryParameters());
  1002.     const op = this.basePlayer_.getNetworkingEngine()
  1003.         .request(type, request, context);
  1004.     const response = await op.promise;
  1005.     return response.data;
  1006.   }
  1007. };
  1010. /**
  1011.  * @typedef {{
  1012.  *   ASSETS: !Array.<shaka.ads.InterstitialAdManager.Asset>
  1013.  * }}
  1014.  *
  1015.  * @property {!Array.<shaka.ads.InterstitialAdManager.Asset>} ASSETS
  1016.  */
  1017. shaka.ads.InterstitialAdManager.AssetsList;
  1020. /**
  1021.  * @typedef {{
  1022.  *   URI: string
  1023.  * }}
  1024.  *
  1025.  * @property {string} URI
  1026.  */
  1027. shaka.ads.InterstitialAdManager.Asset;