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