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