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(
  188.                         interstitial.uri,
  189.                         /* startTime= */ null,
  190.                         interstitial.mimeType || undefined));
  191.               }
  192.             }
  193.           }
  194.         }
  195.         if (cuepointsChanged) {
  196.           this.cuepointsChanged_();
  197.         }
  198.       }
  199.     }).tickEvery(/* seconds= */ 1);
  200.   }
  202.   /**
  203.    * Called by the AdManager to provide an updated configuration any time it
  204.    * changes.
  205.    *
  206.    * @param {shaka.extern.AdsConfiguration} config
  207.    */
  208.   configure(config) {
  209.     this.config_ = config;
  210.     this.determineIfUsingBaseVideo_();
  211.   }
  213.   /**
  214.    * @private
  215.    */
  216.   determineIfUsingBaseVideo_() {
  217.     if (!this.adContainer_ || !this.config_ || this.playingAd_) {
  218.       return;
  219.     }
  220.     let supportsMultipleMediaElements =
  221.         this.config_.supportsMultipleMediaElements;
  222.     const video = /** @type {HTMLVideoElement} */(this.baseVideo_);
  223.     if (video.webkitSupportsFullscreen && video.webkitDisplayingFullscreen) {
  224.       supportsMultipleMediaElements = false;
  225.     }
  226.     if (this.usingBaseVideo_ != supportsMultipleMediaElements) {
  227.       return;
  228.     }
  229.     this.usingBaseVideo_ = !supportsMultipleMediaElements;
  230.     if (this.usingBaseVideo_) {
  231.       this.video_ = this.baseVideo_;
  232.       if (this.adVideo_) {
  233.         if (this.adVideo_.parentElement) {
  234.           this.adContainer_.removeChild(this.adVideo_);
  235.         }
  236.         this.adVideo_ = null;
  237.       }
  238.     } else {
  239.       if (!this.adVideo_) {
  240.         this.adVideo_ = this.createMediaElement_();
  241.       }
  242.       this.video_ = this.adVideo_;
  243.     }
  244.   }
  247.   /**
  248.    * Resets the Interstitial manager and removes any continuous polling.
  249.    */
  250.   stop() {
  251.     if (this.adEventManager_) {
  252.       this.adEventManager_.removeAll();
  253.     }
  254.     this.interstitialIds_.clear();
  255.     this.interstitials_.clear();
  256.     this.player_.destroyAllPreloads();
  257.     this.preloadManagerInterstitials_.clear();
  258.     this.player_.detach();
  259.     this.playingAd_ = false;
  260.     this.lastTime_ = null;
  261.     this.lastPlayedAd_ = null;
  262.   }
  264.   /** @override */
  265.   release() {
  266.     this.stop();
  267.     if (this.eventManager_) {
  268.       this.eventManager_.release();
  269.     }
  270.     if (this.adEventManager_) {
  271.       this.adEventManager_.release();
  272.     }
  273.     if (this.adContainer_) {
  274.       shaka.util.Dom.removeAllChildren(this.adContainer_);
  275.     }
  276.     if (this.timeUpdateTimer_) {
  277.       this.timeUpdateTimer_.stop();
  278.       this.timeUpdateTimer_ = null;
  279.     }
  280.     if (this.pollTimer_) {
  281.       this.pollTimer_.stop();
  282.       this.pollTimer_ = null;
  283.     }
  284.     this.player_.destroy();
  285.   }
  288.   /**
  289.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  290.    */
  291.   async addMetadata(hlsInterstitial) {
  292.     this.updatePlayerConfig_();
  293.     const adInterstitials = await this.getInterstitialsInfo_(hlsInterstitial);
  294.     if (adInterstitials.length) {
  295.       this.addInterstitials(adInterstitials);
  296.     } else {
  297.       shaka.log.alwaysWarn('Unsupported HLS interstitial', hlsInterstitial);
  298.     }
  299.   }
  301.   /**
  302.    * @param {shaka.extern.TimelineRegionInfo} region
  303.    */
  304.   addRegion(region) {
  305.     let alternativeMPDUri;
  306.     let alternativeMPDmode;
  307.     for (const node of region.eventNode.children) {
  308.       if (node.tagName == 'AlternativeMPD') {
  309.         const uri = node.attributes['uri'];
  310.         const mode = node.attributes['mode'];
  311.         if (uri) {
  312.           alternativeMPDUri = uri;
  313.           alternativeMPDmode = mode;
  314.           break;
  315.         }
  316.       }
  317.     }
  318.     if (!alternativeMPDUri) {
  319.       shaka.log.alwaysWarn('Unsupported MPD alternate', region);
  320.       return;
  321.     }
  322.     const isReplace = alternativeMPDmode == 'replace';
  323.     const isInsert = alternativeMPDmode == 'insert';
  324.     if (!isReplace && !isInsert) {
  325.       shaka.log.warning('Unsupported MPD alternate', region);
  326.       return;
  327.     }
  329.     /** @type {!shaka.extern.AdInterstitial} */
  330.     const interstitial = {
  331.       id: region.id,
  332.       startTime: region.startTime,
  333.       endTime: region.endTime,
  334.       uri: alternativeMPDUri,
  335.       mimeType: null,
  336.       isSkippable: false,
  337.       skipOffset: null,
  338.       skipFor: null,
  339.       canJump: true,
  340.       resumeOffset: isInsert ? 0 : null,
  341.       playoutLimit: null,
  342.       once: false,
  343.       pre: false,
  344.       post: false,
  345.       timelineRange: isReplace && !isInsert,
  346.     };
  347.     this.addInterstitials([interstitial]);
  348.   }
  350.   /**
  351.    * @param {string} url
  352.    * @return {!Promise}
  353.    */
  354.   async addAdUrlInterstitial(url) {
  355.     const NetworkingEngine = shaka.net.NetworkingEngine;
  356.     const context = {
  357.       type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_AD_URL,
  358.     };
  359.     const responseData = await this.makeAdRequest_(url, context);
  360.     const data = shaka.util.TXml.parseXml(responseData, 'VAST,vmap:VMAP');
  361.     if (!data) {
  362.       throw new shaka.util.Error(
  363.           shaka.util.Error.Severity.CRITICAL,
  364.           shaka.util.Error.Category.ADS,
  365.           shaka.util.Error.Code.VAST_INVALID_XML);
  366.     }
  367.     let interstitials = [];
  368.     if (data.tagName == 'VAST') {
  369.       interstitials = shaka.ads.Utils.parseVastToInterstitials(
  370.           data, this.lastTime_);
  371.     } else if (data.tagName == 'vmap:VMAP') {
  372.       for (const ad of shaka.ads.Utils.parseVMAP(data)) {
  373.         // eslint-disable-next-line no-await-in-loop
  374.         const vastResponseData = await this.makeAdRequest_(ad.uri, context);
  375.         const vast = shaka.util.TXml.parseXml(vastResponseData, 'VAST');
  376.         if (!vast) {
  377.           throw new shaka.util.Error(
  378.               shaka.util.Error.Severity.CRITICAL,
  379.               shaka.util.Error.Category.ADS,
  380.               shaka.util.Error.Code.VAST_INVALID_XML);
  381.         }
  382.         interstitials.push(...shaka.ads.Utils.parseVastToInterstitials(
  383.             vast, ad.time));
  384.       }
  385.     }
  386.     this.addInterstitials(interstitials);
  387.   }
  390.   /**
  391.    * @param {!Array.<shaka.extern.AdInterstitial>} interstitials
  392.    */
  393.   addInterstitials(interstitials) {
  394.     let cuepointsChanged = false;
  395.     for (const interstitial of interstitials) {
  396.       const interstitialId = interstitial.id || JSON.stringify(interstitial);
  397.       if (this.interstitialIds_.has(interstitialId)) {
  398.         continue;
  399.       }
  400.       cuepointsChanged = true;
  401.       this.interstitialIds_.add(interstitialId);
  402.       this.interstitials_.add(interstitial);
  403.       let shouldPreload = false;
  404.       if (interstitial.pre && this.lastTime_ == null) {
  405.         shouldPreload = true;
  406.       } else if (interstitial.startTime == 0 && !interstitial.canJump) {
  407.         shouldPreload = true;
  408.       } else if (this.lastTime_ != null) {
  409.         const difference = interstitial.startTime - this.lastTime_;
  410.         if (difference > 0 && difference <= 10) {
  411.           shouldPreload = true;
  412.         }
  413.       }
  414.       if (shouldPreload) {
  415.         if (!this.preloadManagerInterstitials_.has(interstitial)) {
  416.           this.preloadManagerInterstitials_.set(
  417.               interstitial, this.player_.preload(
  418.                   interstitial.uri,
  419.                   /* startTime= */ null,
  420.                   interstitial.mimeType || undefined));
  421.         }
  422.       }
  423.     }
  424.     if (cuepointsChanged) {
  425.       this.cuepointsChanged_();
  426.     }
  427.   }
  429.   /**
  430.    * @return {!HTMLMediaElement}
  431.    * @private
  432.    */
  433.   createMediaElement_() {
  434.     const video = /** @type {!HTMLMediaElement} */(
  435.       document.createElement(this.baseVideo_.tagName));
  436.     video.autoplay = true;
  437.     video.style.position = 'absolute';
  438.     video.style.top = '0';
  439.     video.style.left = '0';
  440.     video.style.width = '100%';
  441.     video.style.height = '100%';
  442.     video.style.backgroundColor = 'rgb(0, 0, 0)';
  443.     video.setAttribute('playsinline', '');
  444.     return video;
  445.   }
  448.   /**
  449.    * @param {boolean=} needPreRoll
  450.    * @param {?number=} numberToSkip
  451.    * @return {?shaka.extern.AdInterstitial}
  452.    * @private
  453.    */
  454.   getCurrentInterstitial_(needPreRoll = false, numberToSkip = null) {
  455.     let skipped = 0;
  456.     let currentInterstitial = null;
  457.     if (this.interstitials_.size && this.lastTime_ != null) {
  458.       const isEnded = this.baseVideo_.ended;
  459.       const interstitials = Array.from(this.interstitials_).sort((a, b) => {
  460.         return b.startTime - a.startTime;
  461.       });
  462.       const roundDecimals = (number) => {
  463.         return Math.round(number * 1000) / 1000;
  464.       };
  465.       let interstitialsToCheck = interstitials;
  466.       if (needPreRoll) {
  467.         interstitialsToCheck = interstitials.filter((i) => i.pre);
  468.       } else if (isEnded) {
  469.         interstitialsToCheck = interstitials.filter((i) => i.post);
  470.       } else {
  471.         interstitialsToCheck = interstitials.filter((i) => !i.pre && !i.post);
  472.       }
  473.       for (const interstitial of interstitialsToCheck) {
  474.         let isValid = false;
  475.         if (needPreRoll) {
  476.           isValid = interstitial.pre;
  477.         } else if (isEnded) {
  478.           isValid = interstitial.post;
  479.         } else if (!interstitial.pre && !interstitial.post) {
  480.           const difference =
  481.               this.lastTime_ - roundDecimals(interstitial.startTime);
  482.           if (difference > 0 &&
  483.               (difference <= 1 || !interstitial.canJump)) {
  484.             if (numberToSkip == null && this.lastPlayedAd_ &&
  485.                 !this.lastPlayedAd_.pre && !this.lastPlayedAd_.post &&
  486.                 this.lastPlayedAd_.startTime >= interstitial.startTime) {
  487.               isValid = false;
  488.             } else {
  489.               isValid = true;
  490.             }
  491.           }
  492.         }
  493.         if (isValid && (!this.lastPlayedAd_ ||
  494.             interstitial.startTime >= this.lastPlayedAd_.startTime)) {
  495.           if (skipped == (numberToSkip || 0)) {
  496.             currentInterstitial = interstitial;
  497.           } else if (currentInterstitial && !interstitial.canJump) {
  498.             const currentStartTime =
  499.                 roundDecimals(currentInterstitial.startTime);
  500.             const newStartTime =
  501.                 roundDecimals(interstitial.startTime);
  502.             if (newStartTime - currentStartTime > 0.001) {
  503.               currentInterstitial = interstitial;
  504.               skipped = 0;
  505.             }
  506.           }
  507.           skipped++;
  508.         }
  509.       }
  510.     }
  511.     return currentInterstitial;
  512.   }
  515.   /**
  516.    * @param {shaka.extern.AdInterstitial} interstitial
  517.    * @param {number} sequenceLength
  518.    * @param {number} adPosition
  519.    * @param {number} initialTime the clock time the ad started at
  520.    * @param {number=} oncePlayed
  521.    * @private
  522.    */
  523.   async setupAd_(interstitial, sequenceLength, adPosition, initialTime,
  524.       oncePlayed = 0) {
  525.     this.determineIfUsingBaseVideo_();
  526.     goog.asserts.assert(this.video_, 'Must have video');
  528.     this.lastPlayedAd_ = interstitial;
  530.     shaka.log.info('Starting interstitial',
  531.         interstitial.startTime, 'at', this.lastTime_);
  533.     const startTime = Date.now();
  535.     if (!this.video_.parentElement && this.adContainer_) {
  536.       this.adContainer_.appendChild(this.video_);
  537.     }
  539.     if (adPosition == 1 && sequenceLength == 1) {
  540.       sequenceLength = Array.from(this.interstitials_).filter((i) => {
  541.         if (interstitial.pre) {
  542.           return i.pre == interstitial.pre;
  543.         } else if (interstitial.post) {
  544.           return i.post == interstitial.post;
  545.         }
  546.         return Math.abs(i.startTime - interstitial.startTime) < 0.001;
  547.       }).length;
  548.     }
  550.     if (interstitial.once) {
  551.       oncePlayed++;
  552.       this.interstitials_.delete(interstitial);
  553.       this.cuepointsChanged_();
  554.     }
  555.     this.playingAd_ = true;
  557.     if (this.usingBaseVideo_ && adPosition == 1) {
  558.       this.onEvent_(new shaka.util.FakeEvent(
  559.           shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED,
  560.           (new Map()).set('saveLivePosition', true)));
  561.       const detachBasePlayerPromise = new shaka.util.PublicPromise();
  562.       const checkState = async (e) => {
  563.         if (e['state'] == 'detach') {
  564.           if (shaka.util.Platform.isSmartTV()) {
  565.             await new Promise(
  566.                 (resolve) => new shaka.util.Timer(resolve).tickAfter(0.1));
  567.           }
  568.           detachBasePlayerPromise.resolve();
  569.           this.adEventManager_.unlisten(
  570.               this.basePlayer_, 'onstatechange', checkState);
  571.         }
  572.       };
  573.       this.adEventManager_.listen(
  574.           this.basePlayer_, 'onstatechange', checkState);
  575.       await detachBasePlayerPromise;
  576.     }
  577.     if (!this.usingBaseVideo_) {
  578.       this.baseVideo_.pause();
  579.       if (interstitial.resumeOffset != null &&
  580.           interstitial.resumeOffset != 0) {
  581.         this.baseVideo_.currentTime += interstitial.resumeOffset;
  582.       }
  583.     }
  585.     let unloadingInterstitial = false;
  586.     /** @type {?shaka.util.Timer} */
  587.     let playoutLimitTimer = null;
  589.     const updateBaseVideoTime = () => {
  590.       if (!this.usingBaseVideo_) {
  591.         if (interstitial.resumeOffset == null) {
  592.           if (interstitial.timelineRange && interstitial.endTime &&
  593.               interstitial.endTime != Infinity) {
  594.             if (this.baseVideo_.currentTime != interstitial.endTime) {
  595.               this.baseVideo_.currentTime = interstitial.endTime;
  596.             }
  597.           } else {
  598.             const now = Date.now();
  599.             this.baseVideo_.currentTime += (now - initialTime) / 1000;
  600.             initialTime = now;
  601.           }
  602.         }
  603.       }
  604.     };
  606.     const basicTask = async () => {
  607.       updateBaseVideoTime();
  608.       if (playoutLimitTimer) {
  609.         playoutLimitTimer.stop();
  610.       }
  611.       goog.asserts.assert(typeof(oncePlayed) == 'number',
  612.           'Should be an number!');
  613.       // Optimization to avoid returning to main content when there is another
  614.       // interstitial below.
  615.       const nextCurrentInterstitial = this.getCurrentInterstitial_(
  616.           interstitial.pre, adPosition - oncePlayed);
  617.       if (nextCurrentInterstitial) {
  618.         this.onEvent_(
  619.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  620.         this.adEventManager_.removeAll();
  621.         this.setupAd_(nextCurrentInterstitial, sequenceLength,
  622.             ++adPosition, initialTime, oncePlayed);
  623.       } else {
  624.         if (interstitial.post) {
  625.           this.lastTime_ = null;
  626.           this.lastPlayedAd_ = null;
  627.         }
  628.         if (this.usingBaseVideo_) {
  629.           await this.player_.detach();
  630.         } else {
  631.           await this.player_.unload();
  632.         }
  633.         if (this.usingBaseVideo_) {
  634.           let offset = interstitial.resumeOffset;
  635.           if (offset == null) {
  636.             if (interstitial.timelineRange && interstitial.endTime &&
  637.                 interstitial.endTime != Infinity) {
  638.               offset = interstitial.endTime - (this.lastTime_ || 0);
  639.             } else {
  640.               offset = (Date.now() - initialTime) / 1000;
  641.             }
  642.           }
  643.           this.onEvent_(new shaka.util.FakeEvent(
  644.               shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED,
  645.               (new Map()).set('offset', offset)));
  646.         }
  647.         this.onEvent_(
  648.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  649.         this.adEventManager_.removeAll();
  650.         this.playingAd_ = false;
  651.         if (!this.usingBaseVideo_) {
  652.           updateBaseVideoTime();
  653.           if (!this.baseVideo_.ended) {
  654.             this.baseVideo_.play();
  655.           }
  656.         } else {
  657.           this.cuepointsChanged_();
  658.         }
  659.         this.determineIfUsingBaseVideo_();
  660.       }
  661.     };
  662.     const error = async (e) => {
  663.       if (unloadingInterstitial) {
  664.         return;
  665.       }
  666.       unloadingInterstitial = true;
  667.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_ERROR,
  668.           (new Map()).set('originalEvent', e)));
  669.       await basicTask();
  670.     };
  671.     const complete = async () => {
  672.       if (unloadingInterstitial) {
  673.         return;
  674.       }
  675.       unloadingInterstitial = true;
  676.       await basicTask();
  677.       this.onEvent_(
  678.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  679.     };
  680.     const onSkip = async () => {
  681.       if (unloadingInterstitial) {
  682.         return;
  683.       }
  684.       unloadingInterstitial = true;
  685.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  686.       await basicTask();
  687.     };
  689.     const ad = new shaka.ads.InterstitialAd(this.video_,
  690.         interstitial.isSkippable, interstitial.skipOffset,
  691.         interstitial.skipFor, onSkip, sequenceLength, adPosition,
  692.         !this.usingBaseVideo_);
  693.     if (!this.usingBaseVideo_) {
  694.       ad.setMuted(this.baseVideo_.muted);
  695.       ad.setVolume(this.baseVideo_.volume);
  696.     }
  698.     this.onEvent_(
  699.         new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  700.             (new Map()).set('ad', ad)));
  702.     let prevCanSkipNow = ad.canSkipNow();
  703.     if (prevCanSkipNow) {
  704.       this.onEvent_(new shaka.util.FakeEvent(
  705.           shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  706.     }
  707.     this.adEventManager_.listenOnce(this.player_, 'error', error);
  708.     this.adEventManager_.listen(this.video_, 'timeupdate', () => {
  709.       const duration = this.video_.duration;
  710.       if (!duration) {
  711.         return;
  712.       }
  713.       const currentCanSkipNow = ad.canSkipNow();
  714.       if (prevCanSkipNow != currentCanSkipNow &&
  715.           ad.getRemainingTime() > 0 && ad.getDuration() > 0) {
  716.         this.onEvent_(
  717.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  718.       }
  719.       prevCanSkipNow = currentCanSkipNow;
  720.     });
  721.     this.adEventManager_.listenOnce(this.player_, 'firstquartile', () => {
  722.       updateBaseVideoTime();
  723.       this.onEvent_(
  724.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  725.     });
  726.     this.adEventManager_.listenOnce(this.player_, 'midpoint', () => {
  727.       updateBaseVideoTime();
  728.       this.onEvent_(
  729.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  730.     });
  731.     this.adEventManager_.listenOnce(this.player_, 'thirdquartile', () => {
  732.       updateBaseVideoTime();
  733.       this.onEvent_(
  734.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  735.     });
  736.     this.adEventManager_.listenOnce(this.player_, 'complete', complete);
  737.     this.adEventManager_.listen(this.video_, 'play', () => {
  738.       this.onEvent_(
  739.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  740.     });
  741.     this.adEventManager_.listen(this.video_, 'pause', () => {
  742.       // playRangeEnd in src= causes the ended event not to be fired when that
  743.       // position is reached, instead pause event is fired.
  744.       const currentConfig = this.player_.getConfiguration();
  745.       if (this.video_.currentTime >= currentConfig.playRangeEnd) {
  746.         complete();
  747.         return;
  748.       }
  749.       this.onEvent_(
  750.           new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  751.     });
  752.     this.adEventManager_.listen(this.video_, 'volumechange', () => {
  753.       if (this.video_.muted) {
  754.         this.onEvent_(
  755.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  756.       } else {
  757.         this.onEvent_(
  758.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  759.       }
  760.     });
  761.     try {
  762.       this.updatePlayerConfig_();
  763.       if (interstitial.startTime && interstitial.endTime &&
  764.           interstitial.endTime != Infinity &&
  765.           interstitial.startTime != interstitial.endTime) {
  766.         const duration = interstitial.endTime - interstitial.startTime;
  767.         if (duration > 0) {
  768.           this.player_.configure('playRangeEnd', duration);
  769.         }
  770.       }
  771.       if (interstitial.playoutLimit) {
  772.         playoutLimitTimer = new shaka.util.Timer(() => {
  773.           ad.skip();
  774.         }).tickAfter(interstitial.playoutLimit);
  775.         this.player_.configure('playRangeEnd', interstitial.playoutLimit);
  776.       }
  777.       await this.player_.attach(this.video_);
  778.       if (this.preloadManagerInterstitials_.has(interstitial)) {
  779.         const preloadManager =
  780.             await this.preloadManagerInterstitials_.get(interstitial);
  781.         this.preloadManagerInterstitials_.delete(interstitial);
  782.         if (preloadManager) {
  783.           await this.player_.load(preloadManager);
  784.         } else {
  785.           await this.player_.load(
  786.               interstitial.uri,
  787.               /* startTime= */ null,
  788.               interstitial.mimeType || undefined);
  789.         }
  790.       } else {
  791.         await this.player_.load(
  792.             interstitial.uri,
  793.             /* startTime= */ null,
  794.             interstitial.mimeType || undefined);
  795.       }
  796.       if (interstitial.playoutLimit) {
  797.         if (playoutLimitTimer) {
  798.           playoutLimitTimer.stop();
  799.         }
  800.         playoutLimitTimer = new shaka.util.Timer(() => {
  801.           ad.skip();
  802.         }).tickAfter(interstitial.playoutLimit);
  803.       }
  804.       const loadTime = (Date.now() - startTime) / 1000;
  805.       this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  806.           (new Map()).set('loadTime', loadTime)));
  807.       if (this.usingBaseVideo_) {
  808.         this.baseVideo_.play();
  809.       }
  810.     } catch (e) {
  811.       error(e);
  812.     }
  813.   }
  816.   /**
  817.    * @param {shaka.extern.HLSInterstitial} hlsInterstitial
  818.    * @return {!Promise.<!Array.<shaka.extern.AdInterstitial>>}
  819.    * @private
  820.    */
  821.   async getInterstitialsInfo_(hlsInterstitial) {
  822.     const interstitialsAd = [];
  823.     if (!hlsInterstitial) {
  824.       return interstitialsAd;
  825.     }
  826.     const assetUri = hlsInterstitial.values.find((v) => v.key == 'X-ASSET-URI');
  827.     const assetList =
  828.         hlsInterstitial.values.find((v) => v.key == 'X-ASSET-LIST');
  829.     if (!assetUri && !assetList) {
  830.       return interstitialsAd;
  831.     }
  832.     let id = null;
  833.     const hlsInterstitialId = hlsInterstitial.values.find((v) => v.key == 'ID');
  834.     if (hlsInterstitialId) {
  835.       id = /** @type {string} */(hlsInterstitialId.data);
  836.     }
  837.     const startTime = id == null ?
  838.         Math.floor(hlsInterstitial.startTime * 10) / 10:
  839.         hlsInterstitial.startTime;
  840.     let endTime = hlsInterstitial.endTime;
  841.     if (hlsInterstitial.endTime && hlsInterstitial.endTime != Infinity &&
  842.         typeof(hlsInterstitial.endTime) == 'number') {
  843.       endTime = id == null ?
  844.           Math.floor(hlsInterstitial.endTime * 10) / 10:
  845.           hlsInterstitial.endTime;
  846.     }
  847.     const restrict = hlsInterstitial.values.find((v) => v.key == 'X-RESTRICT');
  848.     let isSkippable = true;
  849.     let canJump = true;
  850.     if (restrict && restrict.data) {
  851.       const data = /** @type {string} */(restrict.data);
  852.       isSkippable = !data.includes('SKIP');
  853.       canJump = !data.includes('JUMP');
  854.     }
  855.     let skipOffset = isSkippable ? 0 : null;
  856.     const enableSkipAfter =
  857.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-AFTER');
  858.     if (enableSkipAfter) {
  859.       const enableSkipAfterString = /** @type {string} */(enableSkipAfter.data);
  860.       skipOffset = parseFloat(enableSkipAfterString);
  861.       if (isNaN(skipOffset)) {
  862.         skipOffset = isSkippable ? 0 : null;
  863.       }
  864.     }
  865.     let skipFor = null;
  866.     const enableSkipFor =
  867.         hlsInterstitial.values.find((v) => v.key == 'X-ENABLE-SKIP-FOR');
  868.     if (enableSkipFor) {
  869.       const enableSkipForString = /** @type {string} */(enableSkipFor.data);
  870.       skipFor = parseFloat(enableSkipForString);
  871.       if (isNaN(skipOffset)) {
  872.         skipFor = null;
  873.       }
  874.     }
  875.     let resumeOffset = null;
  876.     const resume =
  877.         hlsInterstitial.values.find((v) => v.key == 'X-RESUME-OFFSET');
  878.     if (resume) {
  879.       const resumeOffsetString = /** @type {string} */(resume.data);
  880.       resumeOffset = parseFloat(resumeOffsetString);
  881.       if (isNaN(resumeOffset)) {
  882.         resumeOffset = null;
  883.       }
  884.     }
  885.     let playoutLimit = null;
  886.     const playout =
  887.         hlsInterstitial.values.find((v) => v.key == 'X-PLAYOUT-LIMIT');
  888.     if (playout) {
  889.       const playoutLimitString = /** @type {string} */(playout.data);
  890.       playoutLimit = parseFloat(playoutLimitString);
  891.       if (isNaN(playoutLimit)) {
  892.         playoutLimit = null;
  893.       }
  894.     }
  895.     let once = false;
  896.     let pre = false;
  897.     let post = false;
  898.     const cue = hlsInterstitial.values.find((v) => v.key == 'CUE');
  899.     if (cue) {
  900.       const data = /** @type {string} */(cue.data);
  901.       once = data.includes('ONCE');
  902.       pre = data.includes('PRE');
  903.       post = data.includes('POST');
  904.     }
  905.     let timelineRange = false;
  906.     const timelineOccupies =
  907.         hlsInterstitial.values.find((v) => v.key == 'X-TIMELINE-OCCUPIES');
  908.     if (timelineOccupies) {
  909.       const data = /** @type {string} */(timelineOccupies.data);
  910.       timelineRange = data.includes('RANGE');
  911.     } else if (!resume && this.basePlayer_.isLive()) {
  912.       timelineRange = !pre && !post;
  913.     }
  914.     if (assetUri) {
  915.       const uri = /** @type {string} */(assetUri.data);
  916.       if (!uri) {
  917.         return interstitialsAd;
  918.       }
  919.       interstitialsAd.push({
  920.         id,
  921.         startTime,
  922.         endTime,
  923.         uri,
  924.         mimeType: null,
  925.         isSkippable,
  926.         skipOffset,
  927.         skipFor,
  928.         canJump,
  929.         resumeOffset,
  930.         playoutLimit,
  931.         once,
  932.         pre,
  933.         post,
  934.         timelineRange,
  935.       });
  936.     } else if (assetList) {
  937.       const uri = /** @type {string} */(assetList.data);
  938.       if (!uri) {
  939.         return interstitialsAd;
  940.       }
  941.       try {
  942.         const NetworkingEngine = shaka.net.NetworkingEngine;
  943.         const context = {
  944.           type: NetworkingEngine.AdvancedRequestType.INTERSTITIAL_ASSET_LIST,
  945.         };
  946.         const responseData = await this.makeAdRequest_(uri, context);
  947.         const data = shaka.util.StringUtils.fromUTF8(responseData);
  948.         const dataAsJson =
  949.         /** @type {!shaka.ads.InterstitialAdManager.AssetsList} */ (
  950.             JSON.parse(data));
  951.         const skipControl = dataAsJson['SKIP-CONTROL'];
  952.         if (skipControl) {
  953.           const enableSkipAfterValue = skipControl['ENABLE-SKIP-AFTER'];
  954.           if ((typeof enableSkipAfterValue) == 'number') {
  955.             skipOffset = parseFloat(enableSkipAfterValue);
  956.             if (isNaN(enableSkipAfterValue)) {
  957.               skipOffset = isSkippable ? 0 : null;
  958.             }
  959.           }
  960.           const enableSkipForValue = skipControl['ENABLE-SKIP-FOR'];
  961.           if ((typeof enableSkipForValue) == 'number') {
  962.             skipFor = parseFloat(enableSkipForValue);
  963.             if (isNaN(enableSkipForValue)) {
  964.               skipFor = null;
  965.             }
  966.           }
  967.         }
  968.         for (let i = 0; i < dataAsJson['ASSETS'].length; i++) {
  969.           const asset = dataAsJson['ASSETS'][i];
  970.           if (asset['URI']) {
  971.             interstitialsAd.push({
  972.               id: id + '_asset_' + i,
  973.               startTime,
  974.               endTime,
  975.               uri: asset['URI'],
  976.               mimeType: null,
  977.               isSkippable,
  978.               skipOffset,
  979.               skipFor,
  980.               canJump,
  981.               resumeOffset,
  982.               playoutLimit,
  983.               once,
  984.               pre,
  985.               post,
  986.               timelineRange,
  987.             });
  988.           }
  989.         }
  990.       } catch (e) {
  991.         // Ignore errors
  992.       }
  993.     }
  994.     return interstitialsAd;
  995.   }
  998.   /**
  999.    * @private
  1000.    */
  1001.   cuepointsChanged_() {
  1002.     /** @type {!Array.<!shaka.extern.AdCuePoint>} */
  1003.     const cuePoints = [];
  1004.     for (const interstitial of this.interstitials_) {
  1005.       /** @type {shaka.extern.AdCuePoint} */
  1006.       const shakaCuePoint = {
  1007.         start: interstitial.startTime,
  1008.         end: null,
  1009.       };
  1010.       if (interstitial.pre) {
  1011.         shakaCuePoint.start = 0;
  1012.         shakaCuePoint.end = null;
  1013.       } else if (interstitial.post) {
  1014.         shakaCuePoint.start = -1;
  1015.         shakaCuePoint.end = null;
  1016.       } else if (interstitial.timelineRange) {
  1017.         shakaCuePoint.end = interstitial.endTime;
  1018.       }
  1019.       const isValid = !cuePoints.find((c) => {
  1020.         return shakaCuePoint.start == c.start && shakaCuePoint.end == c.end;
  1021.       });
  1022.       if (isValid) {
  1023.         cuePoints.push(shakaCuePoint);
  1024.       }
  1025.     }
  1027.     this.onEvent_(new shaka.util.FakeEvent(
  1028.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  1029.         (new Map()).set('cuepoints', cuePoints)));
  1030.   }
  1033.   /**
  1034.    * @private
  1035.    */
  1036.   updatePlayerConfig_() {
  1037.     goog.asserts.assert(this.player_, 'Must have player');
  1038.     goog.asserts.assert(this.basePlayer_, 'Must have base player');
  1039.     this.player_.configure(this.basePlayer_.getNonDefaultConfiguration());
  1040.     this.player_.configure('ads.disableHLSInterstitial', true);
  1041.     this.player_.configure('ads.disableDASHInterstitial', true);
  1042.     this.player_.configure('playRangeEnd', Infinity);
  1043.     const netEngine = this.player_.getNetworkingEngine();
  1044.     goog.asserts.assert(netEngine, 'Need networking engine');
  1045.     netEngine.clearAllRequestFilters();
  1046.     netEngine.clearAllResponseFilters();
  1047.     this.basePlayer_.getNetworkingEngine().copyFiltersInto(netEngine);
  1048.   }
  1050.   /**
  1051.    * @param {string} url
  1052.    * @param {shaka.extern.RequestContext=} context
  1053.    * @return {!Promise.<BufferSource>}
  1054.    * @private
  1055.    */
  1056.   async makeAdRequest_(url, context) {
  1057.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  1058.     const request = shaka.net.NetworkingEngine.makeRequest(
  1059.         [url],
  1060.         shaka.net.NetworkingEngine.defaultRetryParameters());
  1061.     const op = this.basePlayer_.getNetworkingEngine()
  1062.         .request(type, request, context);
  1063.     const response = await op.promise;
  1064.     return response.data;
  1065.   }
  1066. };
  1069. /**
  1070.  * @typedef {{
  1071.  *   ASSETS: !Array.<shaka.ads.InterstitialAdManager.Asset>,
  1072.  *   SKIP-CONTROL: ?shaka.ads.InterstitialAdManager.SkipControl
  1073.  * }}
  1074.  *
  1075.  * @property {!Array.<shaka.ads.InterstitialAdManager.Asset>} ASSETS
  1076.  * @property {shaka.ads.InterstitialAdManager.SkipControl} SKIP-CONTROL
  1077.  */
  1078. shaka.ads.InterstitialAdManager.AssetsList;
  1081. /**
  1082.  * @typedef {{
  1083.  *   URI: string
  1084.  * }}
  1085.  *
  1086.  * @property {string} URI
  1087.  */
  1088. shaka.ads.InterstitialAdManager.Asset;
  1091. /**
  1092.  * @typedef {{
  1093.  *   ENABLE-SKIP-AFTER: number,
  1094.  *   ENABLE-SKIP-FOR: number
  1095.  * }}
  1096.  *
  1097.  * @property {number} ENABLE-SKIP-AFTER
  1098.  * @property {number} ENABLE-SKIP-FOR
  1099.  */
  1100. shaka.ads.InterstitialAdManager.SkipControl;