Source: lib/ads/media_tailor_ad_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. /**
  8.  * @fileoverview
  9.  * @suppress {missingRequire} TODO(b/152540451): this shouldn't be needed
  10.  */
  12. goog.provide('shaka.ads.MediaTailorAdManager');
  14. goog.require('goog.asserts');
  15. goog.require('shaka.ads.MediaTailorAd');
  16. goog.require('shaka.log');
  17. goog.require('shaka.net.NetworkingEngine');
  18. goog.require('goog.Uri');
  19. goog.require('shaka.util.EventManager');
  20. goog.require('shaka.util.Error');
  21. goog.require('shaka.util.FakeEvent');
  22. goog.require('shaka.util.IReleasable');
  23. goog.require('shaka.util.PublicPromise');
  24. goog.require('shaka.util.StringUtils');
  27. /**
  28.  * A class responsible for MediaTailor ad interactions.
  29.  *
  30.  * @implements {shaka.util.IReleasable}
  31.  */
  32. shaka.ads.MediaTailorAdManager = class {
  33.   /**
  34.    * @param {HTMLElement} adContainer
  35.    * @param {shaka.net.NetworkingEngine} networkingEngine
  36.    * @param {HTMLMediaElement} video
  37.    * @param {function(!shaka.util.FakeEvent)} onEvent
  38.    */
  39.   constructor(adContainer, networkingEngine, video, onEvent) {
  40.     /** @private {HTMLElement} */
  41.     this.adContainer_ = adContainer;
  43.     /** @private {shaka.net.NetworkingEngine} */
  44.     this.networkingEngine_ = networkingEngine;
  46.     /** @private {HTMLMediaElement} */
  47.     this.video_ = video;
  49.     /** @private {?shaka.util.PublicPromise.<string>} */
  50.     this.streamPromise_ = null;
  52.     /** @private {number} */
  53.     this.streamRequestStartTime_ = NaN;
  55.     /** @private {function(!shaka.util.FakeEvent)} */
  56.     this.onEvent_ = onEvent;
  58.     /** @private {boolean} */
  59.     this.isLive_ = false;
  61.     /**
  62.      * Time to seek to after an ad if that ad was played as the result of
  63.      * snapback.
  64.      * @private {?number}
  65.      */
  66.     this.snapForwardTime_ = null;
  68.     /** @private {!Array.<!mediaTailor.AdBreak>} */
  69.     this.adBreaks_ = [];
  71.     /** @private {!Array.<string>} */
  72.     this.playedAds_ = [];
  74.     /** @private {?shaka.ads.MediaTailorAd} */
  75.     this.ad_ = null;
  77.     /** @private {?mediaTailor.Ad} */
  78.     this.mediaTailorAd_ = null;
  80.     /** @private {?mediaTailor.AdBreak} */
  81.     this.mediaTailorAdBreak_ = null;
  83.     /** @private {!Map.<string,!Array.<mediaTailorExternalResource.App>>} */
  84.     this.staticResources_ = new Map();
  86.     /** @private {!Array.<{target: EventTarget, type: string,
  87.      *           listener: shaka.util.EventManager.ListenerType}>}
  88.      */
  89.     this.adListeners_ = [];
  91.     /** @private {!Array.<string>} */
  92.     this.eventsSent = [];
  94.     /** @private {string} */
  95.     this.trackingUrl_ = '';
  97.     /** @private {boolean} */
  98.     this.firstTrackingRequest_ = true;
  100.     /** @private {string} */
  101.     this.backupUrl_ = '';
  103.     /** @private {!Array.<!shaka.extern.AdCuePoint>} */
  104.     this.currentCuePoints_ = [];
  106.     /** @private {shaka.util.EventManager} */
  107.     this.eventManager_ = new shaka.util.EventManager();
  108.   }
  110.   /**
  111.    * @param {string} url
  112.    * @param {Object} adsParams
  113.    * @param {string} backupUrl
  114.    * @return {!Promise.<string>}
  115.    */
  116.   streamRequest(url, adsParams, backupUrl) {
  117.     if (this.streamPromise_) {
  118.       return Promise.reject(new shaka.util.Error(
  119.           shaka.util.Error.Severity.RECOVERABLE,
  120.           shaka.util.Error.Category.ADS,
  121.           shaka.util.Error.Code.CURRENT_DAI_REQUEST_NOT_FINISHED));
  122.     }
  124.     this.streamPromise_ = new shaka.util.PublicPromise();
  125.     this.requestSessionInfo_(url, adsParams);
  126.     this.backupUrl_ = backupUrl || '';
  128.     this.streamRequestStartTime_ = Date.now() / 1000;
  130.     return this.streamPromise_;
  131.   }
  133.   /**
  134.    * @param {string} url
  135.    */
  136.   addTrackingUrl(url) {
  137.     this.trackingUrl_ = url;
  138.     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
  139.         (new Map()).set('loadTime', 0)));
  140.   }
  142.   /**
  143.    * Resets the MediaTailor manager and removes any continuous polling.
  144.    */
  145.   stop() {
  146.     for (const listener of this.adListeners_) {
  147.       this.eventManager_.unlisten(
  148.           listener.target, listener.type, listener.listener);
  149.     }
  150.     this.onEnded_();
  151.     this.adListeners_ = [];
  152.     this.eventsSent = [];
  153.     this.trackingUrl_ = '';
  154.     this.firstTrackingRequest_ = true;
  155.     this.backupUrl_ = '';
  156.     this.snapForwardTime_ = null;
  157.     this.adBreaks_ = [];
  158.     this.playedAds_ = [];
  159.     this.staticResources_.clear();
  160.   }
  162.   /** @override */
  163.   release() {
  164.     this.stop();
  165.     if (this.eventManager_) {
  166.       this.eventManager_.release();
  167.     }
  168.   }
  170.   /**
  171.    * Fired when the manifest is updated
  172.    *
  173.    * @param {boolean} isLive
  174.    */
  175.   onManifestUpdated(isLive) {
  176.     this.isLive_ = isLive;
  177.     if (this.trackingUrl_ != '') {
  178.       this.requestTrackingInfo_(
  179.           this.trackingUrl_, this.firstTrackingRequest_);
  180.       this.firstTrackingRequest_ = false;
  181.     }
  182.   }
  184.   /**
  185.    * @return {!Array.<!shaka.extern.AdCuePoint>}
  186.    */
  187.   getCuePoints() {
  188.     const cuePoints = [];
  189.     for (const adbreak of this.adBreaks_) {
  190.       for (const ad of adbreak.ads) {
  191.         /** @type {!shaka.extern.AdCuePoint} */
  192.         const cuePoint = {
  193.           start: ad.startTimeInSeconds,
  194.           end: ad.startTimeInSeconds + ad.durationInSeconds,
  195.         };
  196.         cuePoints.push(cuePoint);
  197.       }
  198.     }
  199.     return cuePoints;
  200.   }
  202.   /**
  203.    * @param {string} url
  204.    * @param {Object} adsParams
  205.    * @private
  206.    */
  207.   async requestSessionInfo_(url, adsParams) {
  208.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  209.     const request = shaka.net.NetworkingEngine.makeRequest(
  210.         [url],
  211.         shaka.net.NetworkingEngine.defaultRetryParameters());
  212.     request.method = 'POST';
  213.     if (adsParams) {
  214.       const body = JSON.stringify(adsParams);
  215.       request.body = shaka.util.StringUtils.toUTF8(body);
  216.     }
  218.     const op = this.networkingEngine_.request(type, request);
  219.     try {
  220.       const response = await op.promise;
  221.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  222.       const dataAsJson =
  223.         /** @type {!mediaTailor.SessionResponse} */ (JSON.parse(data));
  224.       if (dataAsJson.manifestUrl && dataAsJson.trackingUrl) {
  225.         const baseUri = new goog.Uri(url);
  226.         const relativeTrackingUri = new goog.Uri(dataAsJson.trackingUrl);
  227.         this.trackingUrl_ = baseUri.resolve(relativeTrackingUri).toString();
  228.         const now = Date.now() / 1000;
  229.         const loadTime = now - this.streamRequestStartTime_;
  230.         this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
  231.             (new Map()).set('loadTime', loadTime)));
  232.         const relativeManifestUri = new goog.Uri(dataAsJson.manifestUrl);
  233.         this.streamPromise_.resolve(
  234.             baseUri.resolve(relativeManifestUri).toString());
  235.         this.streamPromise_ = null;
  236.       } else {
  237.         throw new Error('Insufficient data from MediaTailor.');
  238.       }
  239.     } catch (e) {
  240.       if (!this.backupUrl_.length) {
  241.         this.streamPromise_.reject('MediaTailor request returned an error ' +
  242.             'and there was no backup asset uri provided.');
  243.         this.streamPromise_ = null;
  244.         return;
  245.       }
  247.       shaka.log.warning('MediaTailor request returned an error. ' +
  248.           'Falling back to the backup asset uri.');
  249.       this.streamPromise_.resolve(this.backupUrl_);
  250.       this.streamPromise_ = null;
  251.     }
  252.   }
  254.   /**
  255.    * @param {string} trackingUrl
  256.    * @param {boolean} firstRequest
  257.    * @private
  258.    */
  259.   async requestTrackingInfo_(trackingUrl, firstRequest) {
  260.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  261.     const request = shaka.net.NetworkingEngine.makeRequest(
  262.         [trackingUrl],
  263.         shaka.net.NetworkingEngine.defaultRetryParameters());
  265.     const op = this.networkingEngine_.request(type, request);
  266.     try {
  267.       const response = await op.promise;
  268.       let cuepoints = [];
  269.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  270.       const dataAsJson =
  271.         /** @type {!mediaTailor.TrackingResponse} */ (JSON.parse(data));
  272.       if (dataAsJson.avails.length > 0) {
  273.         if (JSON.stringify(this.adBreaks_) !=
  274.             JSON.stringify(dataAsJson.avails)) {
  275.           this.adBreaks_ = dataAsJson.avails;
  276.           for (const adbreak of this.adBreaks_) {
  277.             for (const nonLinearAd of adbreak.nonLinearAdsList) {
  278.               for (const nonLinearAdResource of nonLinearAd.nonLinearAdList) {
  279.                 this.requestStaticResource_(nonLinearAdResource);
  280.               }
  281.             }
  282.           }
  283.           cuepoints = this.getCuePoints();
  284.           this.onEvent_(new shaka.util.FakeEvent(
  285.               shaka.ads.AdManager.CUEPOINTS_CHANGED,
  286.               (new Map()).set('cuepoints', cuepoints)));
  287.         }
  288.       } else {
  289.         if (this.adBreaks_.length) {
  290.           this.onEvent_(new shaka.util.FakeEvent(
  291.               shaka.ads.AdManager.CUEPOINTS_CHANGED,
  292.               (new Map()).set('cuepoints', cuepoints)));
  293.         }
  294.         this.onEnded_();
  295.         this.adBreaks_ = [];
  296.       }
  297.       if (firstRequest && (this.isLive_ || cuepoints.length > 0)) {
  298.         this.setupAdBreakListeners_();
  299.       }
  300.     } catch (e) {}
  301.   }
  303.   /**
  304.    * @param {mediaTailor.NonLinearAd} nonLinearAd
  305.    * @private
  306.    */
  307.   async requestStaticResource_(nonLinearAd) {
  308.     if (!nonLinearAd.staticResource) {
  309.       return;
  310.     }
  311.     const cacheKey = this.getCacheKeyForNonLinear_(nonLinearAd);
  312.     const staticResource = this.staticResources_.get(cacheKey);
  313.     if (staticResource) {
  314.       return;
  315.     }
  317.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  318.     const request = shaka.net.NetworkingEngine.makeRequest(
  319.         [nonLinearAd.staticResource],
  320.         shaka.net.NetworkingEngine.defaultRetryParameters());
  322.     const op = this.networkingEngine_.request(type, request);
  323.     try {
  324.       this.staticResources_.set(cacheKey, []);
  325.       const response = await op.promise;
  326.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  327.       const dataAsJson =
  328.         /** @type {!mediaTailorExternalResource.Response} */ (JSON.parse(data));
  329.       const apps = dataAsJson.apps;
  330.       this.staticResources_.set(cacheKey, apps);
  331.     } catch (e) {
  332.       this.staticResources_.delete(cacheKey);
  333.     }
  334.   }
  336.   /**
  337.    * @param {mediaTailor.NonLinearAd} nonLinearAd
  338.    * @return {string}
  339.    * @private
  340.    */
  341.   getCacheKeyForNonLinear_(nonLinearAd) {
  342.     return [
  343.       nonLinearAd.adId,
  344.       nonLinearAd.adParameters,
  345.       nonLinearAd.adSystem,
  346.       nonLinearAd.adTitle,
  347.       nonLinearAd.creativeAdId,
  348.       nonLinearAd.creativeId,
  349.       nonLinearAd.creativeSequence,
  350.       nonLinearAd.height,
  351.       nonLinearAd.width,
  352.       nonLinearAd.staticResource,
  353.     ].join('');
  354.   }
  356.   /**
  357.    * Setup Ad Break listeners
  358.    *
  359.    * @private
  360.    */
  361.   setupAdBreakListeners_() {
  362.     this.onTimeupdate_();
  363.     if (!this.isLive_) {
  364.       this.checkForSnapback_();
  365.       this.eventManager_.listen(this.video_, 'seeked', () => {
  366.         this.checkForSnapback_();
  367.       });
  368.       this.eventManager_.listen(this.video_, 'ended', () => {
  369.         this.onEnded_();
  370.       });
  371.     }
  372.     this.eventManager_.listen(this.video_, 'timeupdate', () => {
  373.       this.onTimeupdate_();
  374.     });
  375.   }
  377.   /**
  378.    * If a seek jumped over the ad break, return to the start of the
  379.    * ad break, then complete the seek after the ad played through.
  380.    *
  381.    * @private
  382.    */
  383.   checkForSnapback_() {
  384.     const currentTime = this.video_.currentTime;
  385.     if (currentTime == 0 || this.snapForwardTime_ != null) {
  386.       return;
  387.     }
  389.     let previousAdBreak;
  390.     let previousAd;
  391.     for (const adbreak of this.adBreaks_) {
  392.       for (const ad of adbreak.ads) {
  393.         if (!previousAd) {
  394.           if (ad.startTimeInSeconds < currentTime) {
  395.             previousAd = ad;
  396.             previousAdBreak = adbreak;
  397.           }
  398.         } else if (ad.startTimeInSeconds < currentTime &&
  399.             ad.startTimeInSeconds >
  400.             (previousAd.startTimeInSeconds + previousAd.durationInSeconds)) {
  401.           previousAd = ad;
  402.           previousAdBreak = adbreak;
  403.           break;
  404.         }
  405.       }
  406.     }
  408.     // The cue point gets marked as 'played' as soon as the playhead hits it
  409.     // (at the start of an ad), so when we come back to this method as a result
  410.     // of seeking back to the user-selected time, the 'played' flag will be set.
  411.     if (previousAdBreak && previousAd &&
  412.         !this.playedAds_.includes(previousAd.adId)) {
  413.       shaka.log.info('Seeking back to the start of the ad break at ' +
  414.           previousAdBreak.startTimeInSeconds +
  415.           ' and will return to ' + currentTime);
  416.       this.snapForwardTime_ = currentTime;
  417.       this.video_.currentTime = previousAdBreak.startTimeInSeconds;
  418.     }
  419.   }
  421.   /**
  422.    * @private
  423.    */
  424.   onAdBreakEnded_() {
  425.     const currentTime = this.video_.currentTime;
  426.     // If the ad break was a result of snapping back (a user seeked over
  427.     // an ad break and was returned to it), seek forward to the point,
  428.     // originally chosen by the user.
  429.     if (this.snapForwardTime_ && this.snapForwardTime_ > currentTime) {
  430.       this.video_.currentTime = this.snapForwardTime_;
  431.     }
  432.     this.snapForwardTime_ = null;
  433.   }
  435.   /**
  436.    * @private
  437.    */
  438.   onTimeupdate_() {
  439.     if (!this.video_.duration) {
  440.       // Can't play yet.  Ignore.
  441.       return;
  442.     }
  443.     if (!this.ad_ && !this.adBreaks_.length) {
  444.       // No ads
  445.       return;
  446.     }
  447.     const currentTime = this.video_.currentTime;
  448.     let previousAd = false;
  449.     if (this.ad_) {
  450.       previousAd = true;
  451.       goog.asserts.assert(this.mediaTailorAd_, 'Ad should be defined');
  452.       this.sendInProgressEvents_(currentTime, this.mediaTailorAd_);
  453.       const remainingTime = this.ad_.getRemainingTime();
  454.       const duration = this.ad_.getDuration();
  455.       if (this.ad_.canSkipNow() && remainingTime > 0 && duration > 0) {
  456.         this.sendTrackingEvent_(
  457.             shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_);
  458.       }
  459.       if (duration > 0 && (remainingTime <= 0 || remainingTime > duration)) {
  460.         this.onEnded_();
  461.       }
  462.     }
  463.     if (!this.ad_ || !this.ad_.isLinear()) {
  464.       this.checkLinearAds_(currentTime);
  465.       if (!this.ad_) {
  466.         this.checkNonLinearAds_(currentTime);
  467.       }
  468.       if (previousAd && !this.ad_) {
  469.         this.onAdBreakEnded_();
  470.       }
  471.     }
  472.   }
  474.   /**
  475.    * @param {number} currentTime
  476.    * @param {mediaTailor.Ad} ad
  477.    * @private
  478.    */
  479.   sendInProgressEvents_(currentTime, ad) {
  480.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  481.     const firstQuartileTime = ad.startTimeInSeconds +
  482.         0.25 * ad.durationInSeconds;
  483.     const midpointTime = ad.startTimeInSeconds +
  484.         0.5 * ad.durationInSeconds;
  485.     const thirdQuartileTime = ad.startTimeInSeconds +
  486.         0.75 * ad.durationInSeconds;
  487.     if (currentTime >= firstQuartileTime &&
  488.         !this.eventsSent.includes(MediaTailorAdManager.FIRSTQUARTILE_)) {
  489.       this.eventsSent.push(MediaTailorAdManager.FIRSTQUARTILE_);
  490.       this.sendTrackingEvent_(MediaTailorAdManager.FIRSTQUARTILE_);
  491.     } else if (currentTime >= midpointTime &&
  492.         !this.eventsSent.includes(MediaTailorAdManager.MIDPOINT_)) {
  493.       this.eventsSent.push(MediaTailorAdManager.MIDPOINT_);
  494.       this.sendTrackingEvent_(MediaTailorAdManager.MIDPOINT_);
  495.     } else if (currentTime >= thirdQuartileTime &&
  496.         !this.eventsSent.includes(MediaTailorAdManager.THIRDQUARTILE_)) {
  497.       this.eventsSent.push(MediaTailorAdManager.THIRDQUARTILE_);
  498.       this.sendTrackingEvent_(MediaTailorAdManager.THIRDQUARTILE_);
  499.     }
  500.   }
  502.   /**
  503.    * @param {number} currentTime
  504.    * @private
  505.    */
  506.   checkLinearAds_(currentTime) {
  507.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  508.     for (const adbreak of this.adBreaks_) {
  509.       if (this.ad_ && this.ad_.isLinear()) {
  510.         break;
  511.       }
  512.       for (let i = 0; i < adbreak.ads.length; i++) {
  513.         const ad = adbreak.ads[i];
  514.         const startTime = ad.startTimeInSeconds;
  515.         const endTime = ad.startTimeInSeconds + ad.durationInSeconds;
  516.         if (startTime <= currentTime && endTime > currentTime) {
  517.           if (this.playedAds_.includes(ad.adId)) {
  518.             if (this.video_.ended) {
  519.               continue;
  520.             }
  521.             this.video_.currentTime = endTime;
  522.             return;
  523.           }
  524.           this.onEnded_();
  525.           this.mediaTailorAdBreak_ = adbreak;
  526.           this.ad_ = new shaka.ads.MediaTailorAd(
  527.               ad,
  528.               /* adPosition= */ i + 1,
  529.               /* totalAds= */ adbreak.ads.length,
  530.               /* isLinear= */ true,
  531.               this.video_);
  532.           this.mediaTailorAd_ = ad;
  533.           if (i === 0) {
  534.             this.sendTrackingEvent_(MediaTailorAdManager.BREAKSTART_);
  535.           }
  536.           this.setupCurrentAdListeners_();
  537.           break;
  538.         }
  539.       }
  540.     }
  541.   }
  543.   /**
  544.    * @param {number} currentTime
  545.    * @private
  546.    */
  547.   checkNonLinearAds_(currentTime) {
  548.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  549.     for (const adbreak of this.adBreaks_) {
  550.       if (this.ad_) {
  551.         break;
  552.       }
  553.       for (let i = 0; i < adbreak.nonLinearAdsList.length; i++) {
  554.         const ad = adbreak.nonLinearAdsList[i];
  555.         if (!ad.nonLinearAdList.length) {
  556.           continue;
  557.         }
  558.         const startTime = adbreak.startTimeInSeconds;
  559.         const cacheKey = this.getCacheKeyForNonLinear_(ad.nonLinearAdList[0]);
  560.         const staticResource = this.staticResources_.get(cacheKey);
  561.         if (startTime <= currentTime &&
  562.             staticResource && staticResource.length) {
  563.           this.onEnded_();
  564.           this.displayNonLinearAd_(staticResource);
  565.           this.mediaTailorAdBreak_ = adbreak;
  566.           this.ad_ = new shaka.ads.MediaTailorAd(
  567.               ad,
  568.               /* adPosition= */ i + 1,
  569.               /* totalAds= */ adbreak.ads.length,
  570.               /* isLinear= */ false,
  571.               this.video_);
  572.           this.mediaTailorAd_ = ad;
  573.           if (i === 0) {
  574.             this.sendTrackingEvent_(MediaTailorAdManager.BREAKSTART_);
  575.           }
  576.           this.setupCurrentAdListeners_();
  577.           break;
  578.         }
  579.       }
  580.     }
  581.   }
  583.   /**
  584.    * @param {!Array.<mediaTailorExternalResource.App>} apps
  585.    * @private
  586.    */
  587.   displayNonLinearAd_(apps) {
  588.     for (const app of apps) {
  589.       if (!app.data.source.length) {
  590.         continue;
  591.       }
  592.       const imageElement = /** @type {!HTMLImageElement} */ (
  593.         document.createElement('img'));
  594.       imageElement.src = app.data.source[0].url;
  595.       imageElement.style.top = (app.placeholder.top || 0) + '%';
  596.       imageElement.style.height = (100 - (app.placeholder.top || 0)) + '%';
  597.       imageElement.style.left = (app.placeholder.left || 0) + '%';
  598.       imageElement.style.maxWidth = (100 - (app.placeholder.left || 0)) + '%';
  599.       imageElement.style.objectFit = 'contain';
  600.       imageElement.style.position = 'absolute';
  601.       this.adContainer_.appendChild(imageElement);
  602.     }
  603.   }
  605.   /**
  606.    * @private
  607.    */
  608.   onEnded_() {
  609.     if (this.ad_) {
  610.       // Remove all child nodes
  611.       while (this.adContainer_.lastChild) {
  612.         this.adContainer_.removeChild(this.adContainer_.firstChild);
  613.       }
  614.       if (!this.isLive_) {
  615.         this.playedAds_.push(this.mediaTailorAd_.adId);
  616.       }
  617.       this.removeCurrentAdListeners_(this.ad_.isSkipped());
  618.       const position = this.ad_.getPositionInSequence();
  619.       const totalAdsInBreak = this.ad_.getSequenceLength();
  620.       if (position === totalAdsInBreak) {
  621.         this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.BREAKEND_);
  622.       }
  623.       this.ad_ = null;
  624.       this.mediaTailorAd_ = null;
  625.       this.mediaTailorAdBreak_ = null;
  626.     }
  627.   }
  629.   /**
  630.    * @private
  631.    */
  632.   setupCurrentAdListeners_() {
  633.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  634.     let needFirstEvents = false;
  635.     if (!this.video_.paused) {
  636.       this.sendTrackingEvent_(MediaTailorAdManager.IMPRESSION_);
  637.       this.sendTrackingEvent_(MediaTailorAdManager.START_);
  638.     } else {
  639.       needFirstEvents = true;
  640.     }
  641.     this.adListeners_.push({
  642.       target: this.video_,
  643.       type: 'volumechange',
  644.       listener: () => {
  645.         if (this.video_.muted) {
  646.           this.sendTrackingEvent_(MediaTailorAdManager.MUTE_);
  647.         }
  648.       },
  649.     });
  650.     this.adListeners_.push({
  651.       target: this.video_,
  652.       type: 'volumechange',
  653.       listener: () => {
  654.         if (!this.video_.muted) {
  655.           this.sendTrackingEvent_(MediaTailorAdManager.UNMUTE_);
  656.         }
  657.       },
  658.     });
  659.     this.adListeners_.push({
  660.       target: this.video_,
  661.       type: 'play',
  662.       listener: () => {
  663.         if (needFirstEvents) {
  664.           this.sendTrackingEvent_(MediaTailorAdManager.IMPRESSION_);
  665.           this.sendTrackingEvent_(MediaTailorAdManager.START_);
  666.           needFirstEvents = false;
  667.         } else {
  668.           this.sendTrackingEvent_(MediaTailorAdManager.RESUME_);
  669.         }
  670.       },
  671.     });
  672.     this.adListeners_.push({
  673.       target: this.video_,
  674.       type: 'pause',
  675.       listener: () => {
  676.         this.sendTrackingEvent_(MediaTailorAdManager.PAUSE_);
  677.       },
  678.     });
  679.     for (const listener of this.adListeners_) {
  680.       this.eventManager_.listen(
  681.           listener.target, listener.type, listener.listener);
  682.     }
  683.   }
  685.   /**
  686.    * @param {boolean=} skipped
  687.    * @private
  688.    */
  689.   removeCurrentAdListeners_(skipped = false) {
  690.     if (skipped) {
  691.       this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.SKIPPED_);
  692.     } else {
  693.       this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.COMPLETE_);
  694.     }
  695.     for (const listener of this.adListeners_) {
  696.       this.eventManager_.unlisten(
  697.           listener.target, listener.type, listener.listener);
  698.     }
  699.     this.adListeners_ = [];
  700.     this.eventsSent = [];
  701.   }
  703.   /**
  704.    * @param {string} eventType
  705.    * @private
  706.    */
  707.   sendTrackingEvent_(eventType) {
  708.     let trackingEvent = this.mediaTailorAd_.trackingEvents.find(
  709.         (event) => event.eventType == eventType);
  710.     if (!trackingEvent) {
  711.       trackingEvent = this.mediaTailorAdBreak_.adBreakTrackingEvents.find(
  712.           (event) => event.eventType == eventType);
  713.     }
  714.     if (trackingEvent) {
  715.       const type = shaka.net.NetworkingEngine.RequestType.ADS;
  716.       for (const beaconUrl of trackingEvent.beaconUrls) {
  717.         if (!beaconUrl || beaconUrl == '') {
  718.           continue;
  719.         }
  720.         const request = shaka.net.NetworkingEngine.makeRequest(
  721.             [beaconUrl],
  722.             shaka.net.NetworkingEngine.defaultRetryParameters());
  723.         request.method = 'POST';
  724.         this.networkingEngine_.request(type, request);
  725.       }
  726.     }
  727.     switch (eventType) {
  728.       case shaka.ads.MediaTailorAdManager.IMPRESSION_:
  729.         this.onEvent_(
  730.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_IMPRESSION));
  731.         break;
  732.       case shaka.ads.MediaTailorAdManager.START_:
  733.         this.onEvent_(
  734.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
  735.                 (new Map()).set('ad', this.ad_)));
  736.         break;
  737.       case shaka.ads.MediaTailorAdManager.MUTE_:
  738.         this.onEvent_(
  739.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MUTED));
  740.         break;
  741.       case shaka.ads.MediaTailorAdManager.UNMUTE_:
  742.         this.onEvent_(
  743.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_VOLUME_CHANGED));
  744.         break;
  745.       case shaka.ads.MediaTailorAdManager.RESUME_:
  746.         this.onEvent_(
  747.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_RESUMED));
  748.         break;
  749.       case shaka.ads.MediaTailorAdManager.PAUSE_:
  750.         this.onEvent_(
  751.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_PAUSED));
  752.         break;
  753.       case shaka.ads.MediaTailorAdManager.FIRSTQUARTILE_:
  754.         this.onEvent_(
  755.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_FIRST_QUARTILE));
  756.         break;
  757.       case shaka.ads.MediaTailorAdManager.MIDPOINT_:
  758.         this.onEvent_(
  759.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MIDPOINT));
  760.         break;
  761.       case shaka.ads.MediaTailorAdManager.THIRDQUARTILE_:
  762.         this.onEvent_(
  763.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_THIRD_QUARTILE));
  764.         break;
  765.       case shaka.ads.MediaTailorAdManager.COMPLETE_:
  766.         this.onEvent_(
  767.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_COMPLETE));
  768.         this.onEvent_(
  769.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED));
  770.         break;
  771.       case shaka.ads.MediaTailorAdManager.SKIPPED_:
  772.         this.onEvent_(
  773.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_SKIPPED));
  774.         this.onEvent_(
  775.             new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED));
  776.         break;
  777.       case shaka.ads.MediaTailorAdManager.BREAKSTART_:
  778.         this.adContainer_.setAttribute('ad-active', 'true');
  779.         break;
  780.       case shaka.ads.MediaTailorAdManager.BREAKEND_:
  781.         this.adContainer_.removeAttribute('ad-active');
  782.         break;
  783.       case shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_:
  784.         this.onEvent_(
  785.             new shaka.util.FakeEvent(
  786.                 shaka.ads.AdManager.AD_SKIP_STATE_CHANGED));
  787.         break;
  788.     }
  789.   }
  790. };
  793. /**
  794.  * @const {string}
  795.  * @private
  796.  */
  797. shaka.ads.MediaTailorAdManager.IMPRESSION_ = 'impression';
  800. /**
  801.  * @const {string}
  802.  * @private
  803.  */
  804. shaka.ads.MediaTailorAdManager.START_ = 'start';
  807. /**
  808.  * @const {string}
  809.  * @private
  810.  */
  811. shaka.ads.MediaTailorAdManager.MUTE_ = 'mute';
  814. /**
  815.  * @const {string}
  816.  * @private
  817.  */
  818. shaka.ads.MediaTailorAdManager.UNMUTE_ = 'unmute';
  821. /**
  822.  * @const {string}
  823.  * @private
  824.  */
  825. shaka.ads.MediaTailorAdManager.RESUME_ = 'resume';
  828. /**
  829.  * @const {string}
  830.  * @private
  831.  */
  832. shaka.ads.MediaTailorAdManager.PAUSE_ = 'pause';
  835. /**
  836.  * @const {string}
  837.  * @private
  838.  */
  839. shaka.ads.MediaTailorAdManager.FIRSTQUARTILE_ = 'firstQuartile';
  842. /**
  843.  * @const {string}
  844.  * @private
  845.  */
  846. shaka.ads.MediaTailorAdManager.MIDPOINT_ = 'midpoint';
  849. /**
  850.  * @const {string}
  851.  * @private
  852.  */
  853. shaka.ads.MediaTailorAdManager.THIRDQUARTILE_ = 'thirdQuartile';
  856. /**
  857.  * @const {string}
  858.  * @private
  859.  */
  860. shaka.ads.MediaTailorAdManager.COMPLETE_ = 'complete';
  863. /**
  864.  * @const {string}
  865.  * @private
  866.  */
  867. shaka.ads.MediaTailorAdManager.SKIPPED_ = 'skip';
  870. /**
  871.  * @const {string}
  872.  * @private
  873.  */
  874. shaka.ads.MediaTailorAdManager.BREAKSTART_ = 'breakStart';
  877. /**
  878.  * @const {string}
  879.  * @private
  880.  */
  881. shaka.ads.MediaTailorAdManager.BREAKEND_ = 'breakEnd';
  884. /**
  885.  * @const {string}
  886.  * @private
  887.  */
  888. shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_ = 'skipStateChanged';