Source: lib/ads/ad_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  8. goog.provide('shaka.ads.Utils');
  10. goog.require('shaka.util.TextParser');
  11. goog.require('shaka.util.TXml');
  14. /**
  15.  * A class responsible for ad utils.
  16.  * @export
  17.  */
  18. shaka.ads.Utils = class {
  19.   /**
  20.    * @param {!shaka.extern.xml.Node} vast
  21.    * @param {?number} currentTime
  22.    * @return {!Array.<shaka.extern.AdInterstitial>}
  23.    */
  24.   static parseVastToInterstitials(vast, currentTime) {
  25.     const TXml = shaka.util.TXml;
  26.     /** @type {!Array.<shaka.extern.AdInterstitial>} */
  27.     const interstitials = [];
  29.     let startTime = 0;
  30.     if (currentTime != null) {
  31.       startTime = currentTime;
  32.     }
  34.     for (const ad of TXml.findChildren(vast, 'Ad')) {
  35.       const inline = TXml.findChild(ad, 'InLine');
  36.       if (!inline) {
  37.         continue;
  38.       }
  39.       const creatives = TXml.findChild(inline, 'Creatives');
  40.       if (!creatives) {
  41.         continue;
  42.       }
  43.       for (const creative of TXml.findChildren(creatives, 'Creative')) {
  44.         const linear = TXml.findChild(creative, 'Linear');
  45.         if (!linear) {
  46.           continue;
  47.         }
  48.         let skipOffset = null;
  49.         if (linear.attributes['skipoffset']) {
  50.           skipOffset = shaka.util.TextParser.parseTime(
  51.               linear.attributes['skipoffset']);
  52.           if (isNaN(skipOffset)) {
  53.             skipOffset = null;
  54.           }
  55.         }
  56.         const mediaFiles = TXml.findChild(linear, 'MediaFiles');
  57.         if (!mediaFiles) {
  58.           continue;
  59.         }
  60.         const medias = TXml.findChildren(mediaFiles, 'MediaFile');
  61.         let checkMedias = medias;
  62.         const streamingMedias = medias.filter((media) => {
  63.           return media.attributes['delivery'] == 'streaming';
  64.         });
  65.         if (streamingMedias.length) {
  66.           checkMedias = streamingMedias;
  67.         }
  68.         const sortedMedias = checkMedias.sort((a, b) => {
  69.           const aHeight = parseInt(a.attributes['height'], 10) || 0;
  70.           const bHeight = parseInt(b.attributes['height'], 10) || 0;
  71.           return bHeight - aHeight;
  72.         });
  73.         for (const media of sortedMedias) {
  74.           const adUrl = TXml.getTextContents(media);
  75.           if (!adUrl) {
  76.             continue;
  77.           }
  78.           interstitials.push({
  79.             id: null,
  80.             startTime: startTime,
  81.             endTime: null,
  82.             uri: adUrl,
  83.             isSkippable: skipOffset != null,
  84.             skipOffset,
  85.             canJump: false,
  86.             resumeOffset: 0,
  87.             playoutLimit: null,
  88.             once: true,
  89.             pre: currentTime == null,
  90.             post: currentTime == Infinity,
  91.             timelineRange: false,
  92.           });
  93.           break;
  94.         }
  95.       }
  96.     }
  97.     return interstitials;
  98.   }
  100.   /**
  101.    * @param {!shaka.extern.xml.Node} vmap
  102.    * @return {!Array.<{time: ?number, uri: string}>}
  103.    */
  104.   static parseVMAP(vmap) {
  105.     const TXml = shaka.util.TXml;
  106.     /** @type {!Array.<{time: ?number, uri: string}>} */
  107.     const ads = [];
  108.     for (const adBreak of TXml.findChildren(vmap, 'vmap:AdBreak')) {
  109.       const timeOffset = adBreak.attributes['timeOffset'];
  110.       if (!timeOffset) {
  111.         continue;
  112.       }
  113.       let time = null;
  114.       if (timeOffset == 'start') {
  115.         time = 0;
  116.       } else if (timeOffset == 'end') {
  117.         time = Infinity;
  118.       } else {
  119.         time = shaka.util.TextParser.parseTime(timeOffset);
  120.       }
  121.       const adSource = TXml.findChild(adBreak, 'vmap:AdSource');
  122.       if (!adSource) {
  123.         continue;
  124.       }
  125.       const adTagURI = TXml.findChild(adSource, 'vmap:AdTagURI');
  126.       if (!adTagURI) {
  127.         continue;
  128.       }
  129.       const uri = TXml.getTextContents(adTagURI);
  130.       if (!uri) {
  131.         continue;
  132.       }
  133.       ads.push({
  134.         time,
  135.         uri,
  136.       });
  137.     }
  138.     return ads;
  139.   }
  140. };
  142. /**
  143.  * The event name for when a sequence of ads has been loaded.
  144.  *
  145.  * @const {string}
  146.  * @export
  147.  */
  148. shaka.ads.Utils.ADS_LOADED = 'ads-loaded';
  150. /**
  151.  * The event name for when an ad has started playing.
  152.  *
  153.  * @const {string}
  154.  * @export
  155.  */
  156. shaka.ads.Utils.AD_STARTED = 'ad-started';
  159. /**
  160.  * The event name for when an ad playhead crosses first quartile.
  161.  *
  162.  * @const {string}
  163.  * @export
  164.  */
  165. shaka.ads.Utils.AD_FIRST_QUARTILE = 'ad-first-quartile';
  168. /**
  169.  * The event name for when an ad playhead crosses midpoint.
  170.  *
  171.  * @const {string}
  172.  * @export
  173.  */
  174. shaka.ads.Utils.AD_MIDPOINT = 'ad-midpoint';
  177. /**
  178.  * The event name for when an ad playhead crosses third quartile.
  179.  *
  180.  * @const {string}
  181.  * @export
  182.  */
  183. shaka.ads.Utils.AD_THIRD_QUARTILE = 'ad-third-quartile';
  186. /**
  187.  * The event name for when an ad has completed playing.
  188.  *
  189.  * @const {string}
  190.  * @export
  191.  */
  192. shaka.ads.Utils.AD_COMPLETE = 'ad-complete';
  195. /**
  196.  * The event name for when an ad has finished playing
  197.  * (played all the way through, was skipped, or was unable to proceed
  198.  * due to an error).
  199.  *
  200.  * @const {string}
  201.  * @export
  202.  */
  203. shaka.ads.Utils.AD_STOPPED = 'ad-stopped';
  206. /**
  207.  * The event name for when an ad is skipped by the user..
  208.  *
  209.  * @const {string}
  210.  * @export
  211.  */
  212. shaka.ads.Utils.AD_SKIPPED = 'ad-skipped';
  215. /**
  216.  * The event name for when the ad volume has changed.
  217.  *
  218.  * @const {string}
  219.  * @export
  220.  */
  221. shaka.ads.Utils.AD_VOLUME_CHANGED = 'ad-volume-changed';
  224. /**
  225.  * The event name for when the ad was muted.
  226.  *
  227.  * @const {string}
  228.  * @export
  229.  */
  230. shaka.ads.Utils.AD_MUTED = 'ad-muted';
  233. /**
  234.  * The event name for when the ad was paused.
  235.  *
  236.  * @const {string}
  237.  * @export
  238.  */
  239. shaka.ads.Utils.AD_PAUSED = 'ad-paused';
  242. /**
  243.  * The event name for when the ad was resumed after a pause.
  244.  *
  245.  * @const {string}
  246.  * @export
  247.  */
  248. shaka.ads.Utils.AD_RESUMED = 'ad-resumed';
  251. /**
  252.  * The event name for when the ad's skip status changes
  253.  * (usually it becomes skippable when it wasn't before).
  254.  *
  255.  * @const {string}
  256.  * @export
  257.  */
  258. shaka.ads.Utils.AD_SKIP_STATE_CHANGED = 'ad-skip-state-changed';
  261. /**
  262.  * The event name for when the ad's cue points (start/end markers)
  263.  * have changed.
  264.  *
  265.  * @const {string}
  266.  * @export
  267.  */
  268. shaka.ads.Utils.CUEPOINTS_CHANGED = 'ad-cue-points-changed';
  271. /**
  272.  * The event name for when the native IMA ad manager object has
  273.  * loaded and become available.
  274.  *
  275.  * @const {string}
  276.  * @export
  277.  */
  278. shaka.ads.Utils.IMA_AD_MANAGER_LOADED = 'ima-ad-manager-loaded';
  281. /**
  282.  * The event name for when the native IMA stream manager object has
  283.  * loaded and become available.
  284.  *
  285.  * @const {string}
  286.  * @export
  287.  */
  288. shaka.ads.Utils.IMA_STREAM_MANAGER_LOADED = 'ima-stream-manager-loaded';
  291. /**
  292.  * The event name for when the ad was clicked.
  293.  *
  294.  * @const {string}
  295.  * @export
  296.  */
  297. shaka.ads.Utils.AD_CLICKED = 'ad-clicked';
  300. /**
  301.  * The event name for when there is an update to the current ad's progress.
  302.  *
  303.  * @const {string}
  304.  * @export
  305.  */
  306. shaka.ads.Utils.AD_PROGRESS = 'ad-progress';
  309. /**
  310.  * The event name for when the ad is buffering.
  311.  *
  312.  * @const {string}
  313.  * @export
  314.  */
  315. shaka.ads.Utils.AD_BUFFERING = 'ad-buffering';
  318. /**
  319.  * The event name for when the ad's URL was hit.
  320.  *
  321.  * @const {string}
  322.  * @export
  323.  */
  324. shaka.ads.Utils.AD_IMPRESSION = 'ad-impression';
  327. /**
  328.  * The event name for when the ad's duration changed.
  329.  *
  330.  * @const {string}
  331.  * @export
  332.  */
  333. shaka.ads.Utils.AD_DURATION_CHANGED = 'ad-duration-changed';
  336. /**
  337.  * The event name for when the ad was closed by the user.
  338.  *
  339.  * @const {string}
  340.  * @export
  341.  */
  342. shaka.ads.Utils.AD_CLOSED = 'ad-closed';
  345. /**
  346.  * The event name for when the ad data becomes available.
  347.  *
  348.  * @const {string}
  349.  * @export
  350.  */
  351. shaka.ads.Utils.AD_LOADED = 'ad-loaded';
  354. /**
  355.  * The event name for when all the ads were completed.
  356.  *
  357.  * @const {string}
  358.  * @export
  359.  */
  360. shaka.ads.Utils.ALL_ADS_COMPLETED = 'all-ads-completed';
  363. /**
  364.  * The event name for when the ad changes from or to linear.
  365.  *
  366.  * @const {string}
  367.  * @export
  368.  */
  369. shaka.ads.Utils.AD_LINEAR_CHANGED = 'ad-linear-changed';
  372. /**
  373.  * The event name for when the ad's metadata becomes available.
  374.  *
  375.  * @const {string}
  376.  * @export
  377.  */
  378. shaka.ads.Utils.AD_METADATA = 'ad-metadata';
  381. /**
  382.  * The event name for when the ad display encountered a recoverable
  383.  * error.
  384.  *
  385.  * @const {string}
  386.  * @export
  387.  */
  388. shaka.ads.Utils.AD_RECOVERABLE_ERROR = 'ad-recoverable-error';
  390. /**
  391.  * The event name for when the ad manager dispatch errors.
  392.  *
  393.  * @const {string}
  394.  * @export
  395.  */
  396. shaka.ads.Utils.AD_ERROR = 'ad-error';
  398. /**
  399.  * The event name for when the client side SDK signalled its readiness
  400.  * to play a VPAID ad or an ad rule.
  401.  *
  402.  * @const {string}
  403.  * @export
  404.  */
  405. shaka.ads.Utils.AD_BREAK_READY = 'ad-break-ready';
  408. /**
  409.  * The event name for when the interaction callback for the ad was
  410.  * triggered.
  411.  *
  412.  * @const {string}
  413.  * @export
  414.  */
  415. shaka.ads.Utils.AD_INTERACTION = 'ad-interaction';
  418. /**
  419.  * The name of the event for when an ad requires the main content to be paused.
  420.  * Fired when the platform does not support multiple media elements.
  421.  *
  422.  * @const {string}
  423.  * @export
  424.  */
  425. shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED = 'ad-content-pause-requested';
  428. /**
  429.  * The name of the event for when an ad requires the main content to be resumed.
  430.  * Fired when the platform does not support multiple media elements.
  431.  *
  432.  * @const {string}
  433.  * @export
  434.  */
  435. shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED = 'ad-content-resume-requested';
  438. /**
  439.  * The name of the event for when an ad requires the video of the main content
  440.  * to be attached.
  441.  *
  442.  * @const {string}
  443.  * @export
  444.  */
  445. shaka.ads.Utils.AD_CONTENT_ATTACH_REQUESTED = 'ad-content-attach-requested';