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 type = shaka.net.NetworkingEngine.RequestType.ADS;
  206.     const request = shaka.net.NetworkingEngine.makeRequest(
  207.         [url],
  208.         shaka.net.NetworkingEngine.defaultRetryParameters());
  209.     request.method = 'POST';
  210.     if (adsParams) {
  211.       const body = JSON.stringify(adsParams);
  212.       request.body = shaka.util.StringUtils.toUTF8(body);
  213.     }
  215.     const op = this.networkingEngine_.request(type, request);
  216.     try {
  217.       const response = await op.promise;
  218.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  219.       const dataAsJson =
  220.         /** @type {!mediaTailor.SessionResponse} */ (JSON.parse(data));
  221.       if (dataAsJson.manifestUrl && dataAsJson.trackingUrl) {
  222.         const baseUri = new goog.Uri(url);
  223.         const relativeTrackingUri = new goog.Uri(dataAsJson.trackingUrl);
  224.         this.trackingUrl_ = baseUri.resolve(relativeTrackingUri).toString();
  225.         const now = Date.now() / 1000;
  226.         const loadTime = now - this.streamRequestStartTime_;
  227.         this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  228.             (new Map()).set('loadTime', loadTime)));
  229.         const relativeManifestUri = new goog.Uri(dataAsJson.manifestUrl);
  230.         this.streamPromise_.resolve(
  231.             baseUri.resolve(relativeManifestUri).toString());
  232.         this.streamPromise_ = null;
  233.       } else {
  234.         throw new Error('Insufficient data from MediaTailor.');
  235.       }
  236.     } catch (e) {
  237.       if (!this.backupUrl_.length) {
  238.         this.streamPromise_.reject('MediaTailor request returned an error ' +
  239.             'and there was no backup asset uri provided.');
  240.         this.streamPromise_ = null;
  241.         return;
  242.       }
  244.       shaka.log.warning('MediaTailor request returned an error. ' +
  245.           'Falling back to the backup asset uri.');
  246.       this.streamPromise_.resolve(this.backupUrl_);
  247.       this.streamPromise_ = null;
  248.     }
  249.   }
  251.   /**
  252.    * @param {string} trackingUrl
  253.    * @param {boolean} firstRequest
  254.    * @private
  255.    */
  256.   async requestTrackingInfo_(trackingUrl, firstRequest) {
  257.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  258.     const request = shaka.net.NetworkingEngine.makeRequest(
  259.         [trackingUrl],
  260.         shaka.net.NetworkingEngine.defaultRetryParameters());
  262.     const op = this.networkingEngine_.request(type, request);
  263.     try {
  264.       const response = await op.promise;
  265.       let cuepoints = [];
  266.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  267.       const dataAsJson =
  268.         /** @type {!mediaTailor.TrackingResponse} */ (JSON.parse(data));
  269.       if (dataAsJson.avails.length > 0) {
  270.         if (JSON.stringify(this.adBreaks_) !=
  271.             JSON.stringify(dataAsJson.avails)) {
  272.           this.adBreaks_ = dataAsJson.avails;
  273.           for (const adbreak of this.adBreaks_) {
  274.             for (const nonLinearAd of adbreak.nonLinearAdsList) {
  275.               for (const nonLinearAdResource of nonLinearAd.nonLinearAdList) {
  276.                 this.requestStaticResource_(nonLinearAdResource);
  277.               }
  278.             }
  279.           }
  280.           cuepoints = this.getCuePoints();
  281.           this.onEvent_(new shaka.util.FakeEvent(
  282.               shaka.ads.Utils.CUEPOINTS_CHANGED,
  283.               (new Map()).set('cuepoints', cuepoints)));
  284.         }
  285.       } else {
  286.         if (this.adBreaks_.length) {
  287.           this.onEvent_(new shaka.util.FakeEvent(
  288.               shaka.ads.Utils.CUEPOINTS_CHANGED,
  289.               (new Map()).set('cuepoints', cuepoints)));
  290.         }
  291.         this.onEnded_();
  292.         this.adBreaks_ = [];
  293.       }
  294.       if (firstRequest && (this.isLive_ || cuepoints.length > 0)) {
  295.         this.setupAdBreakListeners_();
  296.       }
  297.     } catch (e) {}
  298.   }
  300.   /**
  301.    * @param {mediaTailor.NonLinearAd} nonLinearAd
  302.    * @private
  303.    */
  304.   async requestStaticResource_(nonLinearAd) {
  305.     if (!nonLinearAd.staticResource) {
  306.       return;
  307.     }
  308.     const cacheKey = this.getCacheKeyForNonLinear_(nonLinearAd);
  309.     const staticResource = this.staticResources_.get(cacheKey);
  310.     if (staticResource) {
  311.       return;
  312.     }
  314.     const type = shaka.net.NetworkingEngine.RequestType.ADS;
  315.     const request = shaka.net.NetworkingEngine.makeRequest(
  316.         [nonLinearAd.staticResource],
  317.         shaka.net.NetworkingEngine.defaultRetryParameters());
  319.     const op = this.networkingEngine_.request(type, request);
  320.     try {
  321.       this.staticResources_.set(cacheKey, []);
  322.       const response = await op.promise;
  323.       const data = shaka.util.StringUtils.fromUTF8(response.data);
  324.       const dataAsJson =
  325.         /** @type {!mediaTailorExternalResource.Response} */ (JSON.parse(data));
  326.       const apps = dataAsJson.apps;
  327.       this.staticResources_.set(cacheKey, apps);
  328.     } catch (e) {
  329.       this.staticResources_.delete(cacheKey);
  330.     }
  331.   }
  333.   /**
  334.    * @param {mediaTailor.NonLinearAd} nonLinearAd
  335.    * @return {string}
  336.    * @private
  337.    */
  338.   getCacheKeyForNonLinear_(nonLinearAd) {
  339.     return [
  340.       nonLinearAd.adId,
  341.       nonLinearAd.adParameters,
  342.       nonLinearAd.adSystem,
  343.       nonLinearAd.adTitle,
  344.       nonLinearAd.creativeAdId,
  345.       nonLinearAd.creativeId,
  346.       nonLinearAd.creativeSequence,
  347.       nonLinearAd.height,
  348.       nonLinearAd.width,
  349.       nonLinearAd.staticResource,
  350.     ].join('');
  351.   }
  353.   /**
  354.    * Setup Ad Break listeners
  355.    *
  356.    * @private
  357.    */
  358.   setupAdBreakListeners_() {
  359.     this.onTimeupdate_();
  360.     if (!this.isLive_) {
  361.       this.checkForSnapback_();
  362.       this.eventManager_.listen(this.video_, 'seeked', () => {
  363.         this.checkForSnapback_();
  364.       });
  365.       this.eventManager_.listen(this.video_, 'ended', () => {
  366.         this.onEnded_();
  367.       });
  368.     }
  369.     this.eventManager_.listen(this.video_, 'timeupdate', () => {
  370.       this.onTimeupdate_();
  371.     });
  372.   }
  374.   /**
  375.    * If a seek jumped over the ad break, return to the start of the
  376.    * ad break, then complete the seek after the ad played through.
  377.    *
  378.    * @private
  379.    */
  380.   checkForSnapback_() {
  381.     const currentTime = this.video_.currentTime;
  382.     if (currentTime == 0 || this.snapForwardTime_ != null) {
  383.       return;
  384.     }
  386.     let previousAdBreak;
  387.     let previousAd;
  388.     for (const adbreak of this.adBreaks_) {
  389.       for (const ad of adbreak.ads) {
  390.         if (!previousAd) {
  391.           if (ad.startTimeInSeconds < currentTime) {
  392.             previousAd = ad;
  393.             previousAdBreak = adbreak;
  394.           }
  395.         } else if (ad.startTimeInSeconds < currentTime &&
  396.             ad.startTimeInSeconds >
  397.             (previousAd.startTimeInSeconds + previousAd.durationInSeconds)) {
  398.           previousAd = ad;
  399.           previousAdBreak = adbreak;
  400.           break;
  401.         }
  402.       }
  403.     }
  405.     // The cue point gets marked as 'played' as soon as the playhead hits it
  406.     // (at the start of an ad), so when we come back to this method as a result
  407.     // of seeking back to the user-selected time, the 'played' flag will be set.
  408.     if (previousAdBreak && previousAd &&
  409.         !this.playedAds_.includes(previousAd.adId)) {
  410.       shaka.log.info('Seeking back to the start of the ad break at ' +
  411.           previousAdBreak.startTimeInSeconds +
  412.           ' and will return to ' + currentTime);
  413.       this.snapForwardTime_ = currentTime;
  414.       this.video_.currentTime = previousAdBreak.startTimeInSeconds;
  415.     }
  416.   }
  418.   /**
  419.    * @private
  420.    */
  421.   onAdBreakEnded_() {
  422.     const currentTime = this.video_.currentTime;
  423.     // If the ad break was a result of snapping back (a user seeked over
  424.     // an ad break and was returned to it), seek forward to the point,
  425.     // originally chosen by the user.
  426.     if (this.snapForwardTime_ && this.snapForwardTime_ > currentTime) {
  427.       this.video_.currentTime = this.snapForwardTime_;
  428.     }
  429.     this.snapForwardTime_ = null;
  430.   }
  432.   /**
  433.    * @private
  434.    */
  435.   onTimeupdate_() {
  436.     if (!this.video_.duration) {
  437.       // Can't play yet.  Ignore.
  438.       return;
  439.     }
  440.     if (!this.ad_ && !this.adBreaks_.length) {
  441.       // No ads
  442.       return;
  443.     }
  444.     const currentTime = this.video_.currentTime;
  445.     let previousAd = false;
  446.     if (this.ad_) {
  447.       previousAd = true;
  448.       goog.asserts.assert(this.mediaTailorAd_, 'Ad should be defined');
  449.       this.sendInProgressEvents_(currentTime, this.mediaTailorAd_);
  450.       const remainingTime = this.ad_.getRemainingTime();
  451.       const duration = this.ad_.getDuration();
  452.       if (this.ad_.canSkipNow() && remainingTime > 0 && duration > 0) {
  453.         this.sendTrackingEvent_(
  454.             shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_);
  455.       }
  456.       if (duration > 0 && (remainingTime <= 0 || remainingTime > duration)) {
  457.         this.onEnded_();
  458.       }
  459.     }
  460.     if (!this.ad_ || !this.ad_.isLinear()) {
  461.       this.checkLinearAds_(currentTime);
  462.       if (!this.ad_) {
  463.         this.checkNonLinearAds_(currentTime);
  464.       }
  465.       if (previousAd && !this.ad_) {
  466.         this.onAdBreakEnded_();
  467.       }
  468.     }
  469.   }
  471.   /**
  472.    * @param {number} currentTime
  473.    * @param {mediaTailor.Ad} ad
  474.    * @private
  475.    */
  476.   sendInProgressEvents_(currentTime, ad) {
  477.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  478.     const firstQuartileTime = ad.startTimeInSeconds +
  479.         0.25 * ad.durationInSeconds;
  480.     const midpointTime = ad.startTimeInSeconds +
  481.         0.5 * ad.durationInSeconds;
  482.     const thirdQuartileTime = ad.startTimeInSeconds +
  483.         0.75 * ad.durationInSeconds;
  484.     if (currentTime >= firstQuartileTime &&
  485.         !this.eventsSent.includes(MediaTailorAdManager.FIRSTQUARTILE_)) {
  486.       this.eventsSent.push(MediaTailorAdManager.FIRSTQUARTILE_);
  487.       this.sendTrackingEvent_(MediaTailorAdManager.FIRSTQUARTILE_);
  488.     } else if (currentTime >= midpointTime &&
  489.         !this.eventsSent.includes(MediaTailorAdManager.MIDPOINT_)) {
  490.       this.eventsSent.push(MediaTailorAdManager.MIDPOINT_);
  491.       this.sendTrackingEvent_(MediaTailorAdManager.MIDPOINT_);
  492.     } else if (currentTime >= thirdQuartileTime &&
  493.         !this.eventsSent.includes(MediaTailorAdManager.THIRDQUARTILE_)) {
  494.       this.eventsSent.push(MediaTailorAdManager.THIRDQUARTILE_);
  495.       this.sendTrackingEvent_(MediaTailorAdManager.THIRDQUARTILE_);
  496.     }
  497.   }
  499.   /**
  500.    * @param {number} currentTime
  501.    * @private
  502.    */
  503.   checkLinearAds_(currentTime) {
  504.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  505.     for (const adbreak of this.adBreaks_) {
  506.       if (this.ad_ && this.ad_.isLinear()) {
  507.         break;
  508.       }
  509.       for (let i = 0; i < adbreak.ads.length; i++) {
  510.         const ad = adbreak.ads[i];
  511.         const startTime = ad.startTimeInSeconds;
  512.         const endTime = ad.startTimeInSeconds + ad.durationInSeconds;
  513.         if (startTime <= currentTime && endTime > currentTime) {
  514.           if (this.playedAds_.includes(ad.adId)) {
  515.             if (this.video_.ended) {
  516.               continue;
  517.             }
  518.             this.video_.currentTime = endTime;
  519.             return;
  520.           }
  521.           this.onEnded_();
  522.           this.mediaTailorAdBreak_ = adbreak;
  523.           this.ad_ = new shaka.ads.MediaTailorAd(
  524.               ad,
  525.               /* adPosition= */ i + 1,
  526.               /* totalAds= */ adbreak.ads.length,
  527.               /* isLinear= */ true,
  528.               this.video_);
  529.           this.mediaTailorAd_ = ad;
  530.           if (i === 0) {
  531.             this.sendTrackingEvent_(MediaTailorAdManager.BREAKSTART_);
  532.           }
  533.           this.setupCurrentAdListeners_();
  534.           break;
  535.         }
  536.       }
  537.     }
  538.   }
  540.   /**
  541.    * @param {number} currentTime
  542.    * @private
  543.    */
  544.   checkNonLinearAds_(currentTime) {
  545.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  546.     for (const adbreak of this.adBreaks_) {
  547.       if (this.ad_) {
  548.         break;
  549.       }
  550.       for (let i = 0; i < adbreak.nonLinearAdsList.length; i++) {
  551.         const ad = adbreak.nonLinearAdsList[i];
  552.         if (!ad.nonLinearAdList.length) {
  553.           continue;
  554.         }
  555.         const startTime = adbreak.startTimeInSeconds;
  556.         const cacheKey = this.getCacheKeyForNonLinear_(ad.nonLinearAdList[0]);
  557.         const staticResource = this.staticResources_.get(cacheKey);
  558.         if (startTime <= currentTime &&
  559.             staticResource && staticResource.length) {
  560.           this.onEnded_();
  561.           this.displayNonLinearAd_(staticResource);
  562.           this.mediaTailorAdBreak_ = adbreak;
  563.           this.ad_ = new shaka.ads.MediaTailorAd(
  564.               ad,
  565.               /* adPosition= */ i + 1,
  566.               /* totalAds= */ adbreak.ads.length,
  567.               /* isLinear= */ false,
  568.               this.video_);
  569.           this.mediaTailorAd_ = ad;
  570.           if (i === 0) {
  571.             this.sendTrackingEvent_(MediaTailorAdManager.BREAKSTART_);
  572.           }
  573.           this.setupCurrentAdListeners_();
  574.           break;
  575.         }
  576.       }
  577.     }
  578.   }
  580.   /**
  581.    * @param {!Array.<mediaTailorExternalResource.App>} apps
  582.    * @private
  583.    */
  584.   displayNonLinearAd_(apps) {
  585.     for (const app of apps) {
  586.       if (!app.data.source.length) {
  587.         continue;
  588.       }
  589.       const imageElement = /** @type {!HTMLImageElement} */ (
  590.         document.createElement('img'));
  591.       imageElement.src = app.data.source[0].url;
  592.       imageElement.style.top = (app.placeholder.top || 0) + '%';
  593.       imageElement.style.height = (100 - (app.placeholder.top || 0)) + '%';
  594.       imageElement.style.left = (app.placeholder.left || 0) + '%';
  595.       imageElement.style.maxWidth = (100 - (app.placeholder.left || 0)) + '%';
  596.       imageElement.style.objectFit = 'contain';
  597.       imageElement.style.position = 'absolute';
  598.       this.adContainer_.appendChild(imageElement);
  599.     }
  600.   }
  602.   /**
  603.    * @private
  604.    */
  605.   onEnded_() {
  606.     if (this.ad_) {
  607.       // Remove all child nodes
  608.       while (this.adContainer_.lastChild) {
  609.         this.adContainer_.removeChild(this.adContainer_.firstChild);
  610.       }
  611.       if (!this.isLive_) {
  612.         this.playedAds_.push(this.mediaTailorAd_.adId);
  613.       }
  614.       this.removeCurrentAdListeners_(this.ad_.isSkipped());
  615.       const position = this.ad_.getPositionInSequence();
  616.       const totalAdsInBreak = this.ad_.getSequenceLength();
  617.       if (position === totalAdsInBreak) {
  618.         this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.BREAKEND_);
  619.       }
  620.       this.ad_ = null;
  621.       this.mediaTailorAd_ = null;
  622.       this.mediaTailorAdBreak_ = null;
  623.     }
  624.   }
  626.   /**
  627.    * @private
  628.    */
  629.   setupCurrentAdListeners_() {
  630.     const MediaTailorAdManager = shaka.ads.MediaTailorAdManager;
  631.     let needFirstEvents = false;
  632.     if (!this.video_.paused) {
  633.       this.sendTrackingEvent_(MediaTailorAdManager.IMPRESSION_);
  634.       this.sendTrackingEvent_(MediaTailorAdManager.START_);
  635.     } else {
  636.       needFirstEvents = true;
  637.     }
  638.     this.adListeners_.push({
  639.       target: this.video_,
  640.       type: 'volumechange',
  641.       listener: () => {
  642.         if (this.video_.muted) {
  643.           this.sendTrackingEvent_(MediaTailorAdManager.MUTE_);
  644.         }
  645.       },
  646.     });
  647.     this.adListeners_.push({
  648.       target: this.video_,
  649.       type: 'volumechange',
  650.       listener: () => {
  651.         if (!this.video_.muted) {
  652.           this.sendTrackingEvent_(MediaTailorAdManager.UNMUTE_);
  653.         }
  654.       },
  655.     });
  656.     this.adListeners_.push({
  657.       target: this.video_,
  658.       type: 'play',
  659.       listener: () => {
  660.         if (needFirstEvents) {
  661.           this.sendTrackingEvent_(MediaTailorAdManager.IMPRESSION_);
  662.           this.sendTrackingEvent_(MediaTailorAdManager.START_);
  663.           needFirstEvents = false;
  664.         } else {
  665.           this.sendTrackingEvent_(MediaTailorAdManager.RESUME_);
  666.         }
  667.       },
  668.     });
  669.     this.adListeners_.push({
  670.       target: this.video_,
  671.       type: 'pause',
  672.       listener: () => {
  673.         this.sendTrackingEvent_(MediaTailorAdManager.PAUSE_);
  674.       },
  675.     });
  676.     for (const listener of this.adListeners_) {
  677.       this.eventManager_.listen(
  678.           listener.target, listener.type, listener.listener);
  679.     }
  680.   }
  682.   /**
  683.    * @param {boolean=} skipped
  684.    * @private
  685.    */
  686.   removeCurrentAdListeners_(skipped = false) {
  687.     if (skipped) {
  688.       this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.SKIPPED_);
  689.     } else {
  690.       this.sendTrackingEvent_(shaka.ads.MediaTailorAdManager.COMPLETE_);
  691.     }
  692.     for (const listener of this.adListeners_) {
  693.       this.eventManager_.unlisten(
  694.           listener.target, listener.type, listener.listener);
  695.     }
  696.     this.adListeners_ = [];
  697.     this.eventsSent = [];
  698.   }
  700.   /**
  701.    * @param {string} eventType
  702.    * @private
  703.    */
  704.   sendTrackingEvent_(eventType) {
  705.     let trackingEvent = this.mediaTailorAd_.trackingEvents.find(
  706.         (event) => event.eventType == eventType);
  707.     if (!trackingEvent) {
  708.       trackingEvent = this.mediaTailorAdBreak_.adBreakTrackingEvents.find(
  709.           (event) => event.eventType == eventType);
  710.     }
  711.     if (trackingEvent) {
  712.       const type = shaka.net.NetworkingEngine.RequestType.ADS;
  713.       for (const beaconUrl of trackingEvent.beaconUrls) {
  714.         if (!beaconUrl || beaconUrl == '') {
  715.           continue;
  716.         }
  717.         const request = shaka.net.NetworkingEngine.makeRequest(
  718.             [beaconUrl],
  719.             shaka.net.NetworkingEngine.defaultRetryParameters());
  720.         request.method = 'POST';
  721.         this.networkingEngine_.request(type, request);
  722.       }
  723.     }
  724.     switch (eventType) {
  725.       case shaka.ads.MediaTailorAdManager.IMPRESSION_:
  726.         this.onEvent_(
  727.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_IMPRESSION));
  728.         break;
  729.       case shaka.ads.MediaTailorAdManager.START_:
  730.         this.onEvent_(
  731.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  732.                 (new Map()).set('ad', this.ad_)));
  733.         break;
  734.       case shaka.ads.MediaTailorAdManager.MUTE_:
  735.         this.onEvent_(
  736.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MUTED));
  737.         break;
  738.       case shaka.ads.MediaTailorAdManager.UNMUTE_:
  739.         this.onEvent_(
  740.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_VOLUME_CHANGED));
  741.         break;
  742.       case shaka.ads.MediaTailorAdManager.RESUME_:
  743.         this.onEvent_(
  744.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_RESUMED));
  745.         break;
  746.       case shaka.ads.MediaTailorAdManager.PAUSE_:
  747.         this.onEvent_(
  748.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_PAUSED));
  749.         break;
  750.       case shaka.ads.MediaTailorAdManager.FIRSTQUARTILE_:
  751.         this.onEvent_(
  752.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  753.         break;
  754.       case shaka.ads.MediaTailorAdManager.MIDPOINT_:
  755.         this.onEvent_(
  756.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  757.         break;
  758.       case shaka.ads.MediaTailorAdManager.THIRDQUARTILE_:
  759.         this.onEvent_(
  760.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  761.         break;
  762.       case shaka.ads.MediaTailorAdManager.COMPLETE_:
  763.         this.onEvent_(
  764.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  765.         this.onEvent_(
  766.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  767.         break;
  768.       case shaka.ads.MediaTailorAdManager.SKIPPED_:
  769.         this.onEvent_(
  770.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  771.         this.onEvent_(
  772.             new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  773.         break;
  774.       case shaka.ads.MediaTailorAdManager.BREAKSTART_:
  775.         this.adContainer_.setAttribute('ad-active', 'true');
  776.         break;
  777.       case shaka.ads.MediaTailorAdManager.BREAKEND_:
  778.         this.adContainer_.removeAttribute('ad-active');
  779.         break;
  780.       case shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_:
  781.         this.onEvent_(
  782.             new shaka.util.FakeEvent(
  783.                 shaka.ads.Utils.AD_SKIP_STATE_CHANGED));
  784.         break;
  785.     }
  786.   }
  787. };
  790. /**
  791.  * @const {string}
  792.  * @private
  793.  */
  794. shaka.ads.MediaTailorAdManager.IMPRESSION_ = 'impression';
  797. /**
  798.  * @const {string}
  799.  * @private
  800.  */
  801. shaka.ads.MediaTailorAdManager.START_ = 'start';
  804. /**
  805.  * @const {string}
  806.  * @private
  807.  */
  808. shaka.ads.MediaTailorAdManager.MUTE_ = 'mute';
  811. /**
  812.  * @const {string}
  813.  * @private
  814.  */
  815. shaka.ads.MediaTailorAdManager.UNMUTE_ = 'unmute';
  818. /**
  819.  * @const {string}
  820.  * @private
  821.  */
  822. shaka.ads.MediaTailorAdManager.RESUME_ = 'resume';
  825. /**
  826.  * @const {string}
  827.  * @private
  828.  */
  829. shaka.ads.MediaTailorAdManager.PAUSE_ = 'pause';
  832. /**
  833.  * @const {string}
  834.  * @private
  835.  */
  836. shaka.ads.MediaTailorAdManager.FIRSTQUARTILE_ = 'firstQuartile';
  839. /**
  840.  * @const {string}
  841.  * @private
  842.  */
  843. shaka.ads.MediaTailorAdManager.MIDPOINT_ = 'midpoint';
  846. /**
  847.  * @const {string}
  848.  * @private
  849.  */
  850. shaka.ads.MediaTailorAdManager.THIRDQUARTILE_ = 'thirdQuartile';
  853. /**
  854.  * @const {string}
  855.  * @private
  856.  */
  857. shaka.ads.MediaTailorAdManager.COMPLETE_ = 'complete';
  860. /**
  861.  * @const {string}
  862.  * @private
  863.  */
  864. shaka.ads.MediaTailorAdManager.SKIPPED_ = 'skip';
  867. /**
  868.  * @const {string}
  869.  * @private
  870.  */
  871. shaka.ads.MediaTailorAdManager.BREAKSTART_ = 'breakStart';
  874. /**
  875.  * @const {string}
  876.  * @private
  877.  */
  878. shaka.ads.MediaTailorAdManager.BREAKEND_ = 'breakEnd';
  881. /**
  882.  * @const {string}
  883.  * @private
  884.  */
  885. shaka.ads.MediaTailorAdManager.SKIP_STATE_CHANGED_ = 'skipStateChanged';