Source: externs/shaka/manifest_parser.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  19. /** @externs */
  23. /**
  24.  * Parses media manifests and handles manifest updates.
  25.  *
  26.  * Given a URI where the initial manifest is found, a parser will request the
  27.  * manifest, parse it, and return the resulting Manifest object.
  28.  *
  29.  * If the manifest requires updates (e.g. for live media), the parser will use
  30.  * background timers to update the same Manifest object.
  31.  *
  32.  * @interface
  33.  * @exportDoc
  34.  */
  35. shakaExtern.ManifestParser = function() {};
  38. /**
  39.  * @typedef {{
  40.  *   networkingEngine: !shaka.net.NetworkingEngine,
  41.  *   filterNewPeriod: function(shakaExtern.Period),
  42.  *   filterAllPeriods: function(!Array.<!shakaExtern.Period>),
  43.  *   onTimelineRegionAdded: function(shakaExtern.TimelineRegionInfo),
  44.  *   onEvent: function(!Event),
  45.  *   onError: function(!shaka.util.Error)
  46.  * }}
  47.  *
  48.  * @description
  49.  * Defines the interface of the Player to the manifest parser.  This defines
  50.  * fields and callback methods that the parser will use to interact with the
  51.  * Player.  The callback methods do not to be called as member functions (i.e.
  52.  * they can be called as "free" functions).
  53.  *
  54.  * @property {!shaka.net.NetworkingEngine} networkingEngine
  55.  *   The networking engine to use for network requests.
  56.  * @property {function(shakaExtern.Period)} filterNewPeriod
  57.  *   Should be called on a new Period so that it can be filtered.
  58.  * @property {function(!Array.<!shakaExtern.Period>)} filterAllPeriods
  59.  *   Should be called on all Periods so that they can be filtered.
  60.  * @property {function(shakaExtern.TimelineRegionInfo)} onTimelineRegionAdded
  61.  *   Should be called when a new timeline region is added.
  62.  * @property {function(!Event)} onEvent
  63.  *   Should be called to raise events.
  64.  * @property {function(!shaka.util.Error)} onError
  65.  *   Should be called when an error occurs.
  66.  * @exportDoc
  67.  */
  68. shakaExtern.ManifestParser.PlayerInterface;
  71. /**
  72.  * A factory for creating the manifest parser.  This will be called with 'new'.
  73.  * This function is registered with shaka.media.ManifestParser to create parser
  74.  * instances.
  75.  *
  76.  * @typedef {function(new:shakaExtern.ManifestParser)}
  77.  * @exportDoc
  78.  */
  79. shakaExtern.ManifestParser.Factory;
  82. /**
  83.  * Called by the Player to provide an updated configuration any time the
  84.  * configuration changes.  Will be called at least once before start().
  85.  *
  86.  * @param {shakaExtern.ManifestConfiguration} config
  87.  * @exportDoc
  88.  */
  89. shakaExtern.ManifestParser.prototype.configure = function(config) {};
  92. /**
  93.  * Parses the given manifest data into a Manifest object and starts any
  94.  * background timers that are needed.  This will only be called once.
  95.  *
  96.  * @param {string} uri The URI of the manifest.
  97.  * @param {shakaExtern.ManifestParser.PlayerInterface} playerInterface Contains
  98.  *   the interface to the Player.
  99.  * @return {!Promise.<shakaExtern.Manifest>}
  100.  * @exportDoc
  101.  */
  102. shakaExtern.ManifestParser.prototype.start = function(uri, playerInterface) {};
  105. /**
  106.  * Stops any background timers and frees any objects held by this instance.
  107.  * This will only be called after a successful call to start.  This will only
  108.  * be called once.
  109.  *
  110.  * @return {!Promise}
  111.  * @exportDoc
  112.  */
  113. shakaExtern.ManifestParser.prototype.stop = function() {};
  116. /**
  117.  * Tells the parser to do a manual manifest update.  Implementing this is
  118.  * optional and is only called when 'emsg' boxes are present.
  119.  * @exportDoc
  120.  */
  121. shakaExtern.ManifestParser.prototype.update = function() {};
  124. /**
  125.  * Tells the parser that the expiration time of an EME session has changed.
  126.  * Implementing this is optional.
  127.  *
  128.  * @param {string} sessionId
  129.  * @param {number} expiration
  130.  * @exportDoc
  131.  */
  132. shakaExtern.ManifestParser.prototype.onExpirationUpdated = function(
  133.     sessionId, expiration) {};