Source: lib/cast/cast_utils.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.  */
  18. goog.provide('shaka.cast.CastUtils');
  20. goog.require('shaka.util.FakeEvent');
  23. /**
  24.  * @namespace shaka.cast.CastUtils
  25.  * @summary A set of cast utility functions and variables shared between sender
  26.  *   and receiver.
  27.  */
  30. /**
  31.  * HTMLMediaElement events that are proxied while casting.
  32.  * @const {!Array.<string>}
  33.  */
  34. shaka.cast.CastUtils.VideoEvents = [
  35.   'ended',
  36.   'play',
  37.   'playing',
  38.   'pause',
  39.   'pausing',
  40.   'ratechange',
  41.   'seeked',
  42.   'seeking',
  43.   'timeupdate',
  44.   'volumechange'
  45. ];
  48. /**
  49.  * HTMLMediaElement attributes that are proxied while casting.
  50.  * @const {!Array.<string>}
  51.  */
  52. shaka.cast.CastUtils.VideoAttributes = [
  53.   'buffered',
  54.   'currentTime',
  55.   'duration',
  56.   'ended',
  57.   'loop',
  58.   'muted',
  59.   'paused',
  60.   'playbackRate',
  61.   'seeking',
  62.   'videoHeight',
  63.   'videoWidth',
  64.   'volume'
  65. ];
  68. /**
  69.  * HTMLMediaElement attributes that are transferred when casting begins.
  70.  * @const {!Array.<string>}
  71.  */
  72. shaka.cast.CastUtils.VideoInitStateAttributes = [
  73.   'loop',
  74.   'playbackRate'
  75. ];
  78. /**
  79.  * HTMLMediaElement methods with no return value that are proxied while casting.
  80.  * @const {!Array.<string>}
  81.  */
  82. shaka.cast.CastUtils.VideoVoidMethods = [
  83.   'pause',
  84.   'play'
  85. ];
  88. /**
  89.  * Player events that are proxied while casting.
  90.  * @const {!Array.<string>}
  91.  */
  92. shaka.cast.CastUtils.PlayerEvents = [
  93.   'adaptation',
  94.   'buffering',
  95.   'emsg',
  96.   'error',
  97.   'loading',
  98.   'streaming',
  99.   'texttrackvisibility',
  100.   'timelineregionadded',
  101.   'timelineregionenter',
  102.   'timelineregionexit',
  103.   'trackschanged',
  104.   'unloading'
  105. ];
  108. /**
  109.  * Player getter methods that are proxied while casting.
  110.  * The key is the method, the value is the frequency of updates.
  111.  * Frequency 1 translates to every update; frequency 2 to every 2 updates, etc.
  112.  * @const {!Object.<string, number>}
  113.  */
  114. shaka.cast.CastUtils.PlayerGetterMethods = {
  115.   // NOTE: The 'drmInfo' property is not proxied, as it is very large.
  116.   'getAudioLanguages': 2,
  117.   'getAudioLanguagesAndRoles': 2,
  118.   'getBufferedInfo': 2,
  119.   'getConfiguration': 2,
  120.   'getExpiration': 2,
  121.   // Note that the 'getManifest' property is not proxied, as it is very large.
  122.   'getManifestUri': 2,
  123.   'getPlaybackRate': 2,
  124.   'getTextLanguages': 2,
  125.   'getTextLanguagesAndRoles': 2,
  126.   'getTextTracks': 2,
  127.   'getStats': 5,
  128.   'usingEmbeddedTextTrack': 2,
  129.   'getVariantTracks': 2,
  130.   'isAudioOnly': 10,
  131.   'isBuffering': 1,
  132.   'isInProgress': 1,
  133.   'isLive': 10,
  134.   'isTextTrackVisible': 1,
  135.   'keySystem': 10,
  136.   'seekRange': 1
  137. };
  140. /**
  141.  * Player getter methods that are proxied while casting, but only when casting
  142.  * a livestream.
  143.  * The key is the method, the value is the frequency of updates.
  144.  * Frequency 1 translates to every update; frequency 2 to every 2 updates, etc.
  145.  * @const {!Object.<string, number>}
  146.  */
  147. shaka.cast.CastUtils.PlayerGetterMethodsThatRequireLive = {
  148.   'getPlayheadTimeAsDate': 1,
  149.   'getPresentationStartTimeAsDate': 20
  150. };
  153. /**
  154.  * Player getter and setter methods that are used to transfer state when casting
  155.  * begins.
  156.  * @const {!Array.<!Array.<string>>}
  157.  */
  158. shaka.cast.CastUtils.PlayerInitState = [
  159.   ['getConfiguration', 'configure']
  160. ];
  163. /**
  164.  * Player getter and setter methods that are used to transfer state after
  165.  * load() is resolved.
  166.  * @const {!Array.<!Array.<string>>}
  167.  */
  168. shaka.cast.CastUtils.PlayerInitAfterLoadState = [
  169.   ['isTextTrackVisible', 'setTextTrackVisibility']
  170. ];
  173. /**
  174.  * Player methods with no return value that are proxied while casting.
  175.  * @const {!Array.<string>}
  176.  */
  177. shaka.cast.CastUtils.PlayerVoidMethods = [
  178.   'addTextTrack',
  179.   'cancelTrickPlay',
  180.   'configure',
  181.   'resetConfiguration',
  182.   'retryStreaming',
  183.   'selectAudioLanguage',
  184.   'selectEmbeddedTextTrack',
  185.   'selectTextLanguage',
  186.   'selectTextTrack',
  187.   'selectVariantTrack',
  188.   'setTextTrackVisibility',
  189.   'trickPlay'
  190. ];
  193. /**
  194.  * Player methods returning a Promise that are proxied while casting.
  195.  * @const {!Array.<string>}
  196.  */
  197. shaka.cast.CastUtils.PlayerPromiseMethods = [
  198.   'attach',
  199.   'detach',
  200.   // The opt_manifestFactory parameter of load is not supported.
  201.   'load',
  202.   'unload'
  203. ];
  206. /**
  207.  * @typedef {{
  208.  *   video: Object,
  209.  *   player: Object,
  210.  *   manifest: ?string,
  211.  *   startTime: ?number
  212.  * }}
  213.  * @property {Object} video
  214.  *   Dictionary of video properties to be set.
  215.  * @property {Object} player
  216.  *   Dictionary of player setters to be called.
  217.  * @property {?string} manifest
  218.  *   The currently-selected manifest, if present.
  219.  * @property {?number} startTime
  220.  *   The playback start time, if currently playing.
  221.  */
  222. shaka.cast.CastUtils.InitStateType;
  225. /**
  226.  * The namespace for Shaka messages on the cast bus.
  227.  * @const {string}
  228.  */
  229. shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE = 'urn:x-cast:com.google.shaka.v2';
  232. /**
  233.  * The namespace for generic messages on the cast bus.
  234.  * @const {string}
  235.  */
  236. shaka.cast.CastUtils.GENERIC_MESSAGE_NAMESPACE =
  237.     'urn:x-cast:com.google.cast.media';
  240. /**
  241.  * Serialize as JSON, but specially encode things JSON will not otherwise
  242.  * represent.
  243.  * @param {?} thing
  244.  * @return {string}
  245.  */
  246. shaka.cast.CastUtils.serialize = function(thing) {
  247.   return JSON.stringify(thing, function(key, value) {
  248.     if (typeof value == 'function') {
  249.       // Functions can't be (safely) serialized.
  250.       return undefined;
  251.     }
  253.     if (value instanceof Event || value instanceof shaka.util.FakeEvent) {
  254.       // Events don't serialize to JSON well because of the DOM objects
  255.       // and other complex objects they contain, so we strip these out.
  256.       // Note that using Object.keys or JSON.stringify directly on the event
  257.       // will not capture its properties.  We must use a for loop.
  258.       let simpleEvent = {};
  259.       for (let eventKey in value) {
  260.         let eventValue = value[eventKey];
  261.         if (eventValue && typeof eventValue == 'object') {
  262.           if (eventKey == 'detail') {
  263.             // Keep the detail value, because it contains important information
  264.             // for diagnosing errors.
  265.             simpleEvent[eventKey] = eventValue;
  266.           }
  267.           // Strip out non-null object types because they are complex and we
  268.           // don't need them.
  269.         } else if (eventKey in Event) {
  270.           // Strip out keys that are found on Event itself because they are
  271.           // class-level constants we don't need, like Event.MOUSEMOVE == 16.
  272.         } else {
  273.           simpleEvent[eventKey] = eventValue;
  274.         }
  275.       }
  276.       return simpleEvent;
  277.     }
  279.     if (value instanceof TimeRanges) {
  280.       // TimeRanges must be unpacked into plain data for serialization.
  281.       return shaka.cast.CastUtils.unpackTimeRanges_(value);
  282.     }
  284.     if (value instanceof Uint8Array) {
  285.       // Some of our code cares about Uint8Arrays actually being Uint8Arrays,
  286.       // so this gives them special treatment.
  287.       return shaka.cast.CastUtils.unpackUint8Array_(value);
  288.     }
  290.     if (typeof value == 'number') {
  291.       // NaN and infinity cannot be represented directly in JSON.
  292.       if (isNaN(value)) return 'NaN';
  293.       if (isFinite(value)) return value;
  294.       if (value < 0) return '-Infinity';
  295.       return 'Infinity';
  296.     }
  298.     return value;
  299.   });
  300. };
  303. /**
  304.  * Deserialize JSON using our special encodings.
  305.  * @param {string} str
  306.  * @return {?}
  307.  */
  308. shaka.cast.CastUtils.deserialize = function(str) {
  309.   return JSON.parse(str, function(key, value) {
  310.     if (value == 'NaN') {
  311.       return NaN;
  312.     } else if (value == '-Infinity') {
  313.       return -Infinity;
  314.     } else if (value == 'Infinity') {
  315.       return Infinity;
  316.     } else if (value && typeof value == 'object' &&
  317.                value['__type__'] == 'TimeRanges') {
  318.       // TimeRanges objects have been unpacked and sent as plain data.
  319.       // Simulate the original TimeRanges object.
  320.       return shaka.cast.CastUtils.simulateTimeRanges_(value);
  321.     } else if (value && typeof value == 'object' &&
  322.                value['__type__'] == 'Uint8Array') {
  323.       return shaka.cast.CastUtils.makeUint8Array_(value);
  324.     }
  325.     return value;
  326.   });
  327. };
  330. /**
  331.  * @param {!TimeRanges} ranges
  332.  * @return {Object}
  333.  * @private
  334.  */
  335. shaka.cast.CastUtils.unpackTimeRanges_ = function(ranges) {
  336.   let obj = {
  337.     '__type__': 'TimeRanges',  // a signal to deserialize
  338.     'length': ranges.length,
  339.     'start': [],
  340.     'end': []
  341.   };
  343.   for (let i = 0; i < ranges.length; ++i) {
  344.     obj['start'].push(ranges.start(i));
  345.     obj['end'].push(ranges.end(i));
  346.   }
  348.   return obj;
  349. };
  352. /**
  353.  * Creates a simulated TimeRanges object from data sent by the cast receiver.
  354.  * @param {?} obj
  355.  * @return {{
  356.  *   length: number,
  357.  *   start: function(number): number,
  358.  *   end: function(number): number
  359.  * }}
  360.  * @private
  361.  */
  362. shaka.cast.CastUtils.simulateTimeRanges_ = function(obj) {
  363.   return {
  364.     length: obj.length,
  365.     // NOTE: a more complete simulation would throw when |i| was out of range,
  366.     // but for simplicity we will assume a well-behaved application that uses
  367.     // length instead of catch to stop iterating.
  368.     start: function(i) { return obj.start[i]; },
  369.     end: function(i) { return obj.end[i]; }
  370.   };
  371. };
  374. /**
  375.  * @param {!Uint8Array} array
  376.  * @return {Object}
  377.  * @private
  378.  */
  379. shaka.cast.CastUtils.unpackUint8Array_ = function(array) {
  380.   return {
  381.     '__type__': 'Uint8Array',  // a signal to deserialize
  382.     'entries': Array.from(array),
  383.   };
  384. };
  387. /**
  388.  * Creates a Uint8Array object from data sent by the cast receiver.
  389.  * @param {?} obj
  390.  * @return {Uint8Array}
  391.  * @private
  392.  */
  393. shaka.cast.CastUtils.makeUint8Array_ = function(obj) {
  394.   return new Uint8Array(obj['entries']);
  395. };