Source: lib/ads/server_side_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.ServerSideAdManager');
  10. goog.require('goog.asserts');
  11. goog.require('shaka.ads.Utils');
  12. goog.require('shaka.ads.ServerSideAd');
  13. goog.require('shaka.log');
  14. goog.require('shaka.util.EventManager');
  15. goog.require('shaka.util.Error');
  16. goog.require('shaka.util.FakeEvent');
  17. goog.require('shaka.util.IReleasable');
  18. goog.require('shaka.util.PublicPromise');
  21. /**
  22.  * A class responsible for server-side ad interactions.
  23.  * @implements {shaka.util.IReleasable}
  24.  */
  25. shaka.ads.ServerSideAdManager = class {
  26.   /**
  27.    * @param {HTMLElement} adContainer
  28.    * @param {HTMLMediaElement} video
  29.    * @param {string} locale
  30.    * @param {function(!shaka.util.FakeEvent)} onEvent
  31.    */
  32.   constructor(adContainer, video, locale, onEvent) {
  33.     /** @private {HTMLElement} */
  34.     this.adContainer_ = adContainer;
  36.     /** @private {HTMLMediaElement} */
  37.     this.video_ = video;
  39.     /** @private {?shaka.extern.AdsConfiguration} */
  40.     this.config_ = null;
  42.     /** @private
  43.         {?shaka.util.PublicPromise.<string>} */
  44.     this.streamPromise_ = null;
  46.     /** @private {number} */
  47.     this.streamRequestStartTime_ = NaN;
  49.     /** @private {function(!shaka.util.FakeEvent)} */
  50.     this.onEvent_ = onEvent;
  52.     /** @private {boolean} */
  53.     this.isLiveContent_ = false;
  55.     /**
  56.      * Time to seek to after an ad if that ad was played as the result of
  57.      * snapback.
  58.      * @private {?number}
  59.      */
  60.     this.snapForwardTime_ = null;
  62.     /** @private {shaka.ads.ServerSideAd} */
  63.     this.ad_ = null;
  65.     /** @private {?google.ima.dai.api.AdProgressData} */
  66.     this.adProgressData_ = null;
  68.     /** @private {string} */
  69.     this.backupUrl_ = '';
  71.     /** @private {!Array.<!shaka.extern.AdCuePoint>} */
  72.     this.currentCuePoints_ = [];
  74.     /** @private {shaka.util.EventManager} */
  75.     this.eventManager_ = new shaka.util.EventManager();
  77.     /** @private {google.ima.dai.api.UiSettings} */
  78.     const uiSettings = new google.ima.dai.api.UiSettings();
  79.     uiSettings.setLocale(locale);
  81.     /** @private {google.ima.dai.api.StreamManager} */
  82.     this.streamManager_ = new google.ima.dai.api.StreamManager(
  83.         this.video_, this.adContainer_, uiSettings);
  85.     this.onEvent_(new shaka.util.FakeEvent(
  86.         shaka.ads.Utils.IMA_STREAM_MANAGER_LOADED,
  87.         (new Map()).set('imaStreamManager', this.streamManager_)));
  89.     // Events
  90.     this.eventManager_.listen(this.streamManager_,
  91.         google.ima.dai.api.StreamEvent.Type.LOADED, (e) => {
  92.           shaka.log.info('Ad SS Loaded');
  93.           this.onLoaded_(
  94.               /** @type {!google.ima.dai.api.StreamEvent} */ (e));
  95.         });
  97.     this.eventManager_.listen(this.streamManager_,
  98.         google.ima.dai.api.StreamEvent.Type.ERROR, () => {
  99.           shaka.log.info('Ad SS Error');
  100.           this.onError_();
  101.         });
  103.     this.eventManager_.listen(this.streamManager_,
  104.         google.ima.dai.api.StreamEvent.Type.AD_BREAK_STARTED, () => {
  105.           shaka.log.info('Ad Break Started');
  106.         });
  108.     this.eventManager_.listen(this.streamManager_,
  109.         google.ima.dai.api.StreamEvent.Type.STARTED, (e) => {
  110.           shaka.log.info('Ad Started');
  111.           this.onAdStart_(/** @type {!google.ima.dai.api.StreamEvent} */ (e));
  112.         });
  114.     this.eventManager_.listen(this.streamManager_,
  115.         google.ima.dai.api.StreamEvent.Type.AD_BREAK_ENDED, () => {
  116.           shaka.log.info('Ad Break Ended');
  117.           this.onAdBreakEnded_();
  118.         });
  120.     this.eventManager_.listen(this.streamManager_,
  121.         google.ima.dai.api.StreamEvent.Type.AD_PROGRESS, (e) => {
  122.           this.onAdProgress_(
  123.               /** @type {!google.ima.dai.api.StreamEvent} */ (e));
  124.         });
  126.     this.eventManager_.listen(this.streamManager_,
  127.         google.ima.dai.api.StreamEvent.Type.FIRST_QUARTILE, () => {
  128.           shaka.log.info('Ad event: First Quartile');
  129.           this.onEvent_(
  130.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_FIRST_QUARTILE));
  131.         });
  133.     this.eventManager_.listen(this.streamManager_,
  134.         google.ima.dai.api.StreamEvent.Type.MIDPOINT, () => {
  135.           shaka.log.info('Ad event: Midpoint');
  136.           this.onEvent_(
  137.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_MIDPOINT));
  138.         });
  140.     this.eventManager_.listen(this.streamManager_,
  141.         google.ima.dai.api.StreamEvent.Type.THIRD_QUARTILE, () => {
  142.           shaka.log.info('Ad event: Third Quartile');
  143.           this.onEvent_(
  144.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_THIRD_QUARTILE));
  145.         });
  147.     this.eventManager_.listen(this.streamManager_,
  148.         google.ima.dai.api.StreamEvent.Type.COMPLETE, () => {
  149.           shaka.log.info('Ad event: Complete');
  150.           this.onEvent_(
  151.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_COMPLETE));
  152.           this.onEvent_(
  153.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  154.           this.adContainer_.removeAttribute('ad-active');
  155.           this.ad_ = null;
  156.         });
  158.     this.eventManager_.listen(this.streamManager_,
  159.         google.ima.dai.api.StreamEvent.Type.SKIPPED, () => {
  160.           shaka.log.info('Ad event: Skipped');
  161.           this.onEvent_(
  162.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_SKIPPED));
  163.           this.onEvent_(
  164.               new shaka.util.FakeEvent(shaka.ads.Utils.AD_STOPPED));
  165.         });
  167.     this.eventManager_.listen(this.streamManager_,
  168.         google.ima.dai.api.StreamEvent.Type.CUEPOINTS_CHANGED, (e) => {
  169.           shaka.log.info('Ad event: Cue points changed');
  170.           this.onCuePointsChanged_(
  171.               /** @type {!google.ima.dai.api.StreamEvent} */ (e));
  172.         });
  173.   }
  175.   /**
  176.    * Called by the AdManager to provide an updated configuration any time it
  177.    * changes.
  178.    *
  179.    * @param {shaka.extern.AdsConfiguration} config
  180.    */
  181.   configure(config) {
  182.     this.config_ = config;
  183.   }
  185.   /**
  186.    * @param {!google.ima.dai.api.StreamRequest} streamRequest
  187.    * @param {string=} backupUrl
  188.    * @return {!Promise.<string>}
  189.    */
  190.   streamRequest(streamRequest, backupUrl) {
  191.     if (this.streamPromise_) {
  192.       return Promise.reject(new shaka.util.Error(
  193.           shaka.util.Error.Severity.RECOVERABLE,
  194.           shaka.util.Error.Category.ADS,
  195.           shaka.util.Error.Code.CURRENT_DAI_REQUEST_NOT_FINISHED));
  196.     }
  197.     if (streamRequest instanceof google.ima.dai.api.LiveStreamRequest) {
  198.       this.isLiveContent_ = true;
  199.     }
  201.     this.streamPromise_ = new shaka.util.PublicPromise();
  202.     this.streamManager_.requestStream(streamRequest);
  203.     this.backupUrl_ = backupUrl || '';
  205.     this.streamRequestStartTime_ = Date.now() / 1000;
  207.     return this.streamPromise_;
  208.   }
  210.   /**
  211.    * @param {Object} adTagParameters
  212.    */
  213.   replaceAdTagParameters(adTagParameters) {
  214.     this.streamManager_.replaceAdTagParameters(adTagParameters);
  215.   }
  217.   /**
  218.    * Resets the stream manager and removes any continuous polling.
  219.    */
  220.   stop() {
  221.     // TODO:
  222.     // For SS DAI streams, if a different asset gets unloaded as
  223.     // part of the process
  224.     // of loading a DAI asset, stream manager state gets reset and we
  225.     // don't get any ad events.
  226.     // We need to figure out if it makes sense to stop the SS
  227.     // manager on unload, and, if it does, find
  228.     // a way to do it safely.
  229.     // this.streamManager_.reset();
  230.     this.backupUrl_ = '';
  231.     this.snapForwardTime_ = null;
  232.     this.currentCuePoints_ = [];
  233.   }
  235.   /** @override */
  236.   release() {
  237.     this.stop();
  238.     if (this.eventManager_) {
  239.       this.eventManager_.release();
  240.     }
  241.   }
  243.   /**
  244.    * @param {string} type
  245.    * @param {Uint8Array|string} data
  246.    *   Comes as string in DASH and as Uint8Array in HLS.
  247.    * @param {number} timestamp (in seconds)
  248.    */
  249.   onTimedMetadata(type, data, timestamp) {
  250.     this.streamManager_.processMetadata(type, data, timestamp);
  251.   }
  253.   /**
  254.    * @param {shaka.extern.MetadataFrame} value
  255.    */
  256.   onCueMetadataChange(value) {
  257.     // Native HLS over Safari/iOS/iPadOS
  258.     // For live event streams, the stream needs some way of informing the SDK
  259.     // that an ad break is coming up or ending. In the IMA DAI SDK, this is
  260.     // done through timed metadata. Timed metadata is carried as part of the
  261.     // DAI stream content and carries ad break timing information used by the
  262.     // SDK to track ad breaks.
  263.     if (value.key && value.data) {
  264.       const metadata = {};
  265.       metadata[value.key] = value.data;
  266.       this.streamManager_.onTimedMetadata(metadata);
  267.     }
  268.   }
  270.   /**
  271.    * @return {!Array.<!shaka.extern.AdCuePoint>}
  272.    */
  273.   getCuePoints() {
  274.     return this.currentCuePoints_;
  275.   }
  277.   /**
  278.    * If a seek jumped over the ad break, return to the start of the
  279.    * ad break, then complete the seek after the ad played through.
  280.    * @private
  281.    */
  282.   checkForSnapback_() {
  283.     const currentTime = this.video_.currentTime;
  284.     if (currentTime == 0) {
  285.       return;
  286.     }
  288.     this.streamManager_.streamTimeForContentTime(currentTime);
  289.     const previousCuePoint =
  290.         this.streamManager_.previousCuePointForStreamTime(currentTime);
  291.     // The cue point gets marked as 'played' as soon as the playhead hits it
  292.     // (at the start of an ad), so when we come back to this method as a result
  293.     // of seeking back to the user-selected time, the 'played' flag will be set.
  294.     if (previousCuePoint && !previousCuePoint.played) {
  295.       shaka.log.info('Seeking back to the start of the ad break at ' +
  296.           previousCuePoint.start + ' and will return to ' + currentTime);
  297.       this.snapForwardTime_ = currentTime;
  298.       this.video_.currentTime = previousCuePoint.start;
  299.     }
  300.   }
  302.   /**
  303.    * @param {!google.ima.dai.api.StreamEvent} e
  304.    * @private
  305.    */
  306.   onAdStart_(e) {
  307.     goog.asserts.assert(this.streamManager_,
  308.         'Should have a stream manager at this point!');
  310.     const imaAd = e.getAd();
  311.     this.ad_ = new shaka.ads.ServerSideAd(imaAd, this.video_);
  313.     // Ad object and ad progress data come from two different IMA events.
  314.     // It's a race, and we don't know, which one will fire first - the
  315.     // event that contains an ad object (AD_STARTED) or the one that
  316.     // contains ad progress info (AD_PROGRESS).
  317.     // If the progress event fired first, we must've saved the progress
  318.     // info and can now add it to the ad object.
  319.     if (this.adProgressData_) {
  320.       this.ad_.setProgressData(this.adProgressData_);
  321.     }
  323.     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.AD_STARTED,
  324.         (new Map()).set('ad', this.ad_)));
  325.     this.adContainer_.setAttribute('ad-active', 'true');
  326.   }
  328.   /**
  329.    * @private
  330.    */
  331.   onAdBreakEnded_() {
  332.     this.adContainer_.removeAttribute('ad-active');
  333.     const currentTime = this.video_.currentTime;
  334.     // If the ad break was a result of snapping back (a user seeked over
  335.     // an ad break and was returned to it), seek forward to the point,
  336.     // originally chosen by the user.
  337.     if (this.snapForwardTime_ && this.snapForwardTime_ > currentTime) {
  338.       this.video_.currentTime = this.snapForwardTime_;
  339.       this.snapForwardTime_ = null;
  340.     }
  341.   }
  343.   /**
  344.    * @param {!google.ima.dai.api.StreamEvent} e
  345.    * @private
  346.    */
  347.   onLoaded_(e) {
  348.     const now = Date.now() / 1000;
  349.     const loadTime = now - this.streamRequestStartTime_;
  350.     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.Utils.ADS_LOADED,
  351.         (new Map()).set('loadTime', loadTime)));
  353.     const streamData = e.getStreamData();
  354.     const url = streamData.url;
  355.     this.streamPromise_.resolve(url);
  356.     this.streamPromise_ = null;
  358.     if (!this.isLiveContent_) {
  359.       this.eventManager_.listen(this.video_, 'seeked', () => {
  360.         this.checkForSnapback_();
  361.       });
  362.     }
  363.   }
  365.   /**
  366.    * @private
  367.    */
  368.   onError_() {
  369.     if (!this.backupUrl_.length) {
  370.       this.streamPromise_.reject('IMA Stream request returned an error ' +
  371.           'and there was no backup asset uri provided.');
  372.       this.streamPromise_ = null;
  373.       return;
  374.     }
  376.     shaka.log.warning('IMA stream request returned an error. ' +
  377.         'Falling back to the backup asset uri.');
  378.     this.streamPromise_.resolve(this.backupUrl_);
  379.     this.streamPromise_ = null;
  380.   }
  383.   /**
  384.    * @param {!google.ima.dai.api.StreamEvent} e
  385.    * @private
  386.    */
  387.   onAdProgress_(e) {
  388.     const streamData = e.getStreamData();
  389.     const adProgressData = streamData.adProgressData;
  390.     this.adProgressData_ = adProgressData;
  391.     if (this.ad_) {
  392.       this.ad_.setProgressData(this.adProgressData_);
  393.     }
  394.   }
  397.   /**
  398.    * @param {!google.ima.dai.api.StreamEvent} e
  399.    * @private
  400.    */
  401.   onCuePointsChanged_(e) {
  402.     const streamData = e.getStreamData();
  404.     /** @type {!Array.<!shaka.extern.AdCuePoint>} */
  405.     const cuePoints = [];
  406.     for (const point of streamData.cuepoints) {
  407.       /** @type {shaka.extern.AdCuePoint} */
  408.       const shakaCuePoint = {
  409.         start: point.start,
  410.         end: point.end,
  411.       };
  412.       cuePoints.push(shakaCuePoint);
  413.     }
  415.     this.currentCuePoints_ = cuePoints;
  417.     this.onEvent_(new shaka.util.FakeEvent(
  418.         shaka.ads.Utils.CUEPOINTS_CHANGED,
  419.         (new Map()).set('cuepoints', cuePoints)));
  420.   }
  421. };