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