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.     for (const ad of TXml.findChildren(vast, 'Ad')) {
  30.       const inline = TXml.findChild(ad, 'InLine');
  31.       if (!inline) {
  32.         continue;
  33.       }
  34.       const creatives = TXml.findChild(inline, 'Creatives');
  35.       if (!creatives) {
  36.         continue;
  37.       }
  38.       for (const creative of TXml.findChildren(creatives, 'Creative')) {
  39.         const linear = TXml.findChild(creative, 'Linear');
  40.         if (linear) {
  41.           shaka.ads.Utils.processLinearAd_(
  42.               interstitials, currentTime, linear);
  43.         }
  44.         const nonLinearAds = TXml.findChild(creative, 'NonLinearAds');
  45.         if (nonLinearAds) {
  46.           const nonLinears = TXml.findChildren(nonLinearAds, 'NonLinear');
  47.           for (const nonLinear of nonLinears) {
  48.             shaka.ads.Utils.processNonLinearAd_(
  49.                 interstitials, currentTime, nonLinear);
  50.           }
  51.         }
  52.       }
  53.     }
  54.     return interstitials;
  55.   }
  57.   /**
  58.    * @param {!Array<shaka.extern.AdInterstitial>} interstitials
  59.    * @param {?number} currentTime
  60.    * @param {!shaka.extern.xml.Node} linear
  61.    * @private
  62.    */
  63.   static processLinearAd_(interstitials, currentTime, linear) {
  64.     const TXml = shaka.util.TXml;
  65.     let startTime = 0;
  66.     if (currentTime != null) {
  67.       startTime = currentTime;
  68.     }
  69.     let skipOffset = null;
  70.     if (linear.attributes['skipoffset']) {
  71.       skipOffset = shaka.util.TextParser.parseTime(
  72.           linear.attributes['skipoffset']);
  73.       if (isNaN(skipOffset)) {
  74.         skipOffset = null;
  75.       }
  76.     }
  77.     const mediaFiles = TXml.findChild(linear, 'MediaFiles');
  78.     if (!mediaFiles) {
  79.       return;
  80.     }
  81.     const medias = TXml.findChildren(mediaFiles, 'MediaFile');
  82.     let checkMedias = medias;
  83.     const streamingMedias = medias.filter((media) => {
  84.       return media.attributes['delivery'] == 'streaming';
  85.     });
  86.     if (streamingMedias.length) {
  87.       checkMedias = streamingMedias;
  88.     }
  89.     const sortedMedias = checkMedias.sort((a, b) => {
  90.       const aHeight = parseInt(a.attributes['height'], 10) || 0;
  91.       const bHeight = parseInt(b.attributes['height'], 10) || 0;
  92.       return bHeight - aHeight;
  93.     });
  94.     for (const media of sortedMedias) {
  95.       if (media.attributes['apiFramework']) {
  96.         continue;
  97.       }
  98.       const adUrl = TXml.getContents(media);
  99.       if (!adUrl) {
  100.         continue;
  101.       }
  102.       interstitials.push({
  103.         id: null,
  104.         groupId: null,
  105.         startTime: startTime,
  106.         endTime: null,
  107.         uri: adUrl,
  108.         mimeType: media.attributes['type'] || null,
  109.         isSkippable: skipOffset != null,
  110.         skipOffset,
  111.         skipFor: null,
  112.         canJump: false,
  113.         resumeOffset: 0,
  114.         playoutLimit: null,
  115.         once: true,
  116.         pre: currentTime == null,
  117.         post: currentTime == Infinity,
  118.         timelineRange: false,
  119.         loop: false,
  120.         overlay: null,
  121.         displayOnBackground: false,
  122.         currentVideo: null,
  123.         background: null,
  124.       });
  125.       break;
  126.     }
  127.   }
  129.   /**
  130.    * @param {!Array<shaka.extern.AdInterstitial>} interstitials
  131.    * @param {?number} currentTime
  132.    * @param {!shaka.extern.xml.Node} nonLinear
  133.    * @private
  134.    */
  135.   static processNonLinearAd_(interstitials, currentTime, nonLinear) {
  136.     const TXml = shaka.util.TXml;
  137.     let mimeType = null;
  138.     let resource = TXml.findChild(nonLinear, 'StaticResource');
  139.     if (resource) {
  140.       mimeType = resource.attributes['creativeType'];
  141.     } else {
  142.       resource = TXml.findChild(nonLinear, 'HTMLResource');
  143.       if (!resource) {
  144.         return;
  145.       }
  146.       mimeType = 'text/html';
  147.     }
  148.     let adUrl = TXml.getContents(resource);
  149.     if (!adUrl) {
  150.       return;
  151.     }
  152.     if (mimeType === 'text/html') {
  153.       adUrl = 'data:text/html;charset=UTF-8,' + encodeURIComponent(adUrl);
  154.     }
  155.     const width = TXml.parseAttr(nonLinear, 'width', TXml.parseInt) ||
  156.         TXml.parseAttr(nonLinear, 'expandedWidth', TXml.parseInt);
  157.     const height = TXml.parseAttr(nonLinear, 'height', TXml.parseInt) ||
  158.         TXml.parseAttr(nonLinear, 'expandedHeight', TXml.parseInt);
  159.     if (!width && !height) {
  160.       return;
  161.     }
  162.     let playoutLimit = null;
  163.     const minSuggestedDuration =
  164.         nonLinear.attributes['minSuggestedDuration'];
  165.     if (minSuggestedDuration) {
  166.       playoutLimit = shaka.util.TextParser.parseTime(minSuggestedDuration);
  167.     }
  168.     let startTime = 0;
  169.     if (currentTime != null) {
  170.       startTime = currentTime;
  171.     }
  172.     interstitials.push({
  173.       id: null,
  174.       groupId: null,
  175.       startTime: startTime,
  176.       endTime: null,
  177.       uri: adUrl,
  178.       mimeType,
  179.       isSkippable: false,
  180.       skipOffset: null,
  181.       skipFor: null,
  182.       canJump: false,
  183.       resumeOffset: 0,
  184.       playoutLimit,
  185.       once: true,
  186.       pre: currentTime == null,
  187.       post: currentTime == Infinity,
  188.       timelineRange: false,
  189.       loop: false,
  190.       overlay: {
  191.         viewport: {
  192.           x: 0,
  193.           y: 0,
  194.         },
  195.         topLeft: {
  196.           x: 0,
  197.           y: 0,
  198.         },
  199.         size: {
  200.           x: width || 0,
  201.           y: height || 0,
  202.         },
  203.       },
  204.       displayOnBackground: false,
  205.       currentVideo: null,
  206.       background: null,
  207.     });
  208.   }
  210.   /**
  211.    * @param {!shaka.extern.xml.Node} vmap
  212.    * @return {!Array<{time: ?number, uri: string}>}
  213.    */
  214.   static parseVMAP(vmap) {
  215.     const TXml = shaka.util.TXml;
  216.     /** @type {!Array<{time: ?number, uri: string}>} */
  217.     const ads = [];
  218.     for (const adBreak of TXml.findChildren(vmap, 'vmap:AdBreak')) {
  219.       const timeOffset = adBreak.attributes['timeOffset'];
  220.       if (!timeOffset) {
  221.         continue;
  222.       }
  223.       let time = null;
  224.       if (timeOffset == 'start') {
  225.         time = 0;
  226.       } else if (timeOffset == 'end') {
  227.         time = Infinity;
  228.       } else {
  229.         time = shaka.util.TextParser.parseTime(timeOffset);
  230.       }
  231.       const adSource = TXml.findChild(adBreak, 'vmap:AdSource');
  232.       if (!adSource) {
  233.         continue;
  234.       }
  235.       const adTagURI = TXml.findChild(adSource, 'vmap:AdTagURI');
  236.       if (!adTagURI) {
  237.         continue;
  238.       }
  239.       const uri = TXml.getTextContents(adTagURI);
  240.       if (!uri) {
  241.         continue;
  242.       }
  243.       ads.push({
  244.         time,
  245.         uri,
  246.       });
  247.     }
  248.     return ads;
  249.   }
  250. };
  252. /**
  253.  * The event name for when a sequence of ads has been loaded.
  254.  *
  255.  * @const {string}
  256.  * @export
  257.  */
  258. shaka.ads.Utils.ADS_LOADED = 'ads-loaded';
  260. /**
  261.  * The event name for when an ad has started playing.
  262.  *
  263.  * @const {string}
  264.  * @export
  265.  */
  266. shaka.ads.Utils.AD_STARTED = 'ad-started';
  269. /**
  270.  * The event name for when an ad playhead crosses first quartile.
  271.  *
  272.  * @const {string}
  273.  * @export
  274.  */
  275. shaka.ads.Utils.AD_FIRST_QUARTILE = 'ad-first-quartile';
  278. /**
  279.  * The event name for when an ad playhead crosses midpoint.
  280.  *
  281.  * @const {string}
  282.  * @export
  283.  */
  284. shaka.ads.Utils.AD_MIDPOINT = 'ad-midpoint';
  287. /**
  288.  * The event name for when an ad playhead crosses third quartile.
  289.  *
  290.  * @const {string}
  291.  * @export
  292.  */
  293. shaka.ads.Utils.AD_THIRD_QUARTILE = 'ad-third-quartile';
  296. /**
  297.  * The event name for when an ad has completed playing.
  298.  *
  299.  * @const {string}
  300.  * @export
  301.  */
  302. shaka.ads.Utils.AD_COMPLETE = 'ad-complete';
  305. /**
  306.  * The event name for when an ad has finished playing
  307.  * (played all the way through, was skipped, or was unable to proceed
  308.  * due to an error).
  309.  *
  310.  * @const {string}
  311.  * @export
  312.  */
  313. shaka.ads.Utils.AD_STOPPED = 'ad-stopped';
  316. /**
  317.  * The event name for when an ad is skipped by the user..
  318.  *
  319.  * @const {string}
  320.  * @export
  321.  */
  322. shaka.ads.Utils.AD_SKIPPED = 'ad-skipped';
  325. /**
  326.  * The event name for when the ad volume has changed.
  327.  *
  328.  * @const {string}
  329.  * @export
  330.  */
  331. shaka.ads.Utils.AD_VOLUME_CHANGED = 'ad-volume-changed';
  334. /**
  335.  * The event name for when the ad was muted.
  336.  *
  337.  * @const {string}
  338.  * @export
  339.  */
  340. shaka.ads.Utils.AD_MUTED = 'ad-muted';
  343. /**
  344.  * The event name for when the ad was paused.
  345.  *
  346.  * @const {string}
  347.  * @export
  348.  */
  349. shaka.ads.Utils.AD_PAUSED = 'ad-paused';
  352. /**
  353.  * The event name for when the ad was resumed after a pause.
  354.  *
  355.  * @const {string}
  356.  * @export
  357.  */
  358. shaka.ads.Utils.AD_RESUMED = 'ad-resumed';
  361. /**
  362.  * The event name for when the ad's skip status changes
  363.  * (usually it becomes skippable when it wasn't before).
  364.  *
  365.  * @const {string}
  366.  * @export
  367.  */
  368. shaka.ads.Utils.AD_SKIP_STATE_CHANGED = 'ad-skip-state-changed';
  371. /**
  372.  * The event name for when the ad's cue points (start/end markers)
  373.  * have changed.
  374.  *
  375.  * @const {string}
  376.  * @export
  377.  */
  378. shaka.ads.Utils.CUEPOINTS_CHANGED = 'ad-cue-points-changed';
  381. /**
  382.  * The event name for when the native IMA ad manager object has
  383.  * loaded and become available.
  384.  *
  385.  * @const {string}
  386.  * @export
  387.  */
  388. shaka.ads.Utils.IMA_AD_MANAGER_LOADED = 'ima-ad-manager-loaded';
  391. /**
  392.  * The event name for when the native IMA stream manager object has
  393.  * loaded and become available.
  394.  *
  395.  * @const {string}
  396.  * @export
  397.  */
  398. shaka.ads.Utils.IMA_STREAM_MANAGER_LOADED = 'ima-stream-manager-loaded';
  401. /**
  402.  * The event name for when the ad was clicked.
  403.  *
  404.  * @const {string}
  405.  * @export
  406.  */
  407. shaka.ads.Utils.AD_CLICKED = 'ad-clicked';
  410. /**
  411.  * The event name for when there is an update to the current ad's progress.
  412.  *
  413.  * @const {string}
  414.  * @export
  415.  */
  416. shaka.ads.Utils.AD_PROGRESS = 'ad-progress';
  419. /**
  420.  * The event name for when the ad is buffering.
  421.  *
  422.  * @const {string}
  423.  * @export
  424.  */
  425. shaka.ads.Utils.AD_BUFFERING = 'ad-buffering';
  428. /**
  429.  * The event name for when the ad's URL was hit.
  430.  *
  431.  * @const {string}
  432.  * @export
  433.  */
  434. shaka.ads.Utils.AD_IMPRESSION = 'ad-impression';
  437. /**
  438.  * The event name for when the ad's duration changed.
  439.  *
  440.  * @const {string}
  441.  * @export
  442.  */
  443. shaka.ads.Utils.AD_DURATION_CHANGED = 'ad-duration-changed';
  446. /**
  447.  * The event name for when the ad was closed by the user.
  448.  *
  449.  * @const {string}
  450.  * @export
  451.  */
  452. shaka.ads.Utils.AD_CLOSED = 'ad-closed';
  455. /**
  456.  * The event name for when the ad data becomes available.
  457.  *
  458.  * @const {string}
  459.  * @export
  460.  */
  461. shaka.ads.Utils.AD_LOADED = 'ad-loaded';
  464. /**
  465.  * The event name for when all the ads were completed.
  466.  *
  467.  * @const {string}
  468.  * @export
  469.  */
  470. shaka.ads.Utils.ALL_ADS_COMPLETED = 'all-ads-completed';
  473. /**
  474.  * The event name for when the ad changes from or to linear.
  475.  *
  476.  * @const {string}
  477.  * @export
  478.  */
  479. shaka.ads.Utils.AD_LINEAR_CHANGED = 'ad-linear-changed';
  482. /**
  483.  * The event name for when the ad's metadata becomes available.
  484.  *
  485.  * @const {string}
  486.  * @export
  487.  */
  488. shaka.ads.Utils.AD_METADATA = 'ad-metadata';
  491. /**
  492.  * The event name for when the ad display encountered a recoverable
  493.  * error.
  494.  *
  495.  * @const {string}
  496.  * @export
  497.  */
  498. shaka.ads.Utils.AD_RECOVERABLE_ERROR = 'ad-recoverable-error';
  500. /**
  501.  * The event name for when the ad manager dispatch errors.
  502.  *
  503.  * @const {string}
  504.  * @export
  505.  */
  506. shaka.ads.Utils.AD_ERROR = 'ad-error';
  508. /**
  509.  * The event name for when the client side SDK signalled its readiness
  510.  * to play a VPAID ad or an ad rule.
  511.  *
  512.  * @const {string}
  513.  * @export
  514.  */
  515. shaka.ads.Utils.AD_BREAK_READY = 'ad-break-ready';
  518. /**
  519.  * The event name for when the interaction callback for the ad was
  520.  * triggered.
  521.  *
  522.  * @const {string}
  523.  * @export
  524.  */
  525. shaka.ads.Utils.AD_INTERACTION = 'ad-interaction';
  528. /**
  529.  * The name of the event for when an ad requires the main content to be paused.
  530.  * Fired when the platform does not support multiple media elements.
  531.  *
  532.  * @const {string}
  533.  * @export
  534.  */
  535. shaka.ads.Utils.AD_CONTENT_PAUSE_REQUESTED = 'ad-content-pause-requested';
  538. /**
  539.  * The name of the event for when an ad requires the main content to be resumed.
  540.  * Fired when the platform does not support multiple media elements.
  541.  *
  542.  * @const {string}
  543.  * @export
  544.  */
  545. shaka.ads.Utils.AD_CONTENT_RESUME_REQUESTED = 'ad-content-resume-requested';
  548. /**
  549.  * The name of the event for when an ad requires the video of the main content
  550.  * to be attached.
  551.  *
  552.  * @const {string}
  553.  * @export
  554.  */
  555. shaka.ads.Utils.AD_CONTENT_ATTACH_REQUESTED = 'ad-content-attach-requested';