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