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