Source: lib/cast/cast_receiver.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cast.CastReceiver');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.Player');
  11. goog.require('shaka.cast.CastUtils');
  12. goog.require('shaka.log');
  13. goog.require('shaka.util.Error');
  14. goog.require('shaka.util.EventManager');
  15. goog.require('shaka.util.FakeEvent');
  16. goog.require('shaka.util.FakeEventTarget');
  17. goog.require('shaka.util.IDestroyable');
  18. goog.require('shaka.util.Platform');
  19. goog.require('shaka.util.Timer');
  22. /**
  23.  * A receiver to communicate between the Chromecast-hosted player and the
  24.  * sender application.
  25.  *
  26.  * @implements {shaka.util.IDestroyable}
  27.  * @export
  28.  */
  29. shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
  30.   /**
  31.    * @param {!HTMLMediaElement} video The local video element associated with
  32.    *   the local Player instance.
  33.    * @param {!shaka.Player} player A local Player instance.
  34.    * @param {function(Object)=} appDataCallback A callback to handle
  35.    *   application-specific data passed from the sender.  This can come either
  36.    *   from a Shaka-based sender through CastProxy.setAppData, or from a
  37.    *   sender using the customData field of the LOAD message of the standard
  38.    *   Cast message namespace.  It can also be null if no such data is sent.
  39.    * @param {function(string):string=} contentIdCallback A callback to
  40.    *   retrieve manifest URI from the provided content id.
  41.    */
  42.   constructor(video, player, appDataCallback, contentIdCallback) {
  43.     super();
  45.     /** @private {HTMLMediaElement} */
  46.     this.video_ = video;
  48.     /** @private {shaka.Player} */
  49.     this.player_ = player;
  51.     /** @private {shaka.util.EventManager} */
  52.     this.eventManager_ = new shaka.util.EventManager();
  54.     /** @private {Object} */
  55.     this.targets_ = {
  56.       'video': video,
  57.       'player': player,
  58.     };
  60.     /** @private {?function(Object)} */
  61.     this.appDataCallback_ = appDataCallback || (() => {});
  63.     /** @private {?function(string):string} */
  64.     this.contentIdCallback_ = contentIdCallback ||
  65.                           /** @param {string} contentId
  66.                               @return {string} */
  67.                           ((contentId) => contentId);
  69.     /**
  70.      * A Cast metadata object, one of:
  71.      *  - https://developers.google.com/cast/docs/reference/messages#GenericMediaMetadata
  72.      *  - https://developers.google.com/cast/docs/reference/messages#MovieMediaMetadata
  73.      *  - https://developers.google.com/cast/docs/reference/messages#TvShowMediaMetadata
  74.      *  - https://developers.google.com/cast/docs/reference/messages#MusicTrackMediaMetadata
  75.      * @private {Object}
  76.      */
  77.     this.metadata_ = null;
  79.     /** @private {boolean} */
  80.     this.isConnected_ = false;
  82.     /** @private {boolean} */
  83.     this.isIdle_ = true;
  85.     /** @private {number} */
  86.     this.updateNumber_ = 0;
  88.     /** @private {boolean} */
  89.     this.startUpdatingUpdateNumber_ = false;
  91.     /** @private {boolean} */
  92.     this.initialStatusUpdatePending_ = true;
  94.     /** @private {cast.receiver.CastMessageBus} */
  95.     this.shakaBus_ = null;
  97.     /** @private {cast.receiver.CastMessageBus} */
  98.     this.genericBus_ = null;
  100.     /** @private {shaka.util.Timer} */
  101.     this.pollTimer_ = new shaka.util.Timer(() => {
  102.       this.pollAttributes_();
  103.     });
  105.     this.init_();
  106.   }
  108.   /**
  109.    * @return {boolean} True if the cast API is available and there are
  110.    *   receivers.
  111.    * @export
  112.    */
  113.   isConnected() {
  114.     return this.isConnected_;
  115.   }
  117.   /**
  118.    * @return {boolean} True if the receiver is not currently doing loading or
  119.    *   playing anything.
  120.    * @export
  121.    */
  122.   isIdle() {
  123.     return this.isIdle_;
  124.   }
  126.   /**
  127.    * Set all Cast content metadata, as defined by the Cast SDK.
  128.    * Should be called from an appDataCallback.
  129.    *
  130.    * For a simpler way to set basic metadata, see:
  131.    *  - setContentTitle()
  132.    *  - setContentImage()
  133.    *  - setContentArtist()
  134.    *
  135.    * @param {Object} metadata
  136.    *   A Cast metadata object, one of:
  137.    *    - https://developers.google.com/cast/docs/reference/messages#GenericMediaMetadata
  138.    *    - https://developers.google.com/cast/docs/reference/messages#MovieMediaMetadata
  139.    *    - https://developers.google.com/cast/docs/reference/messages#TvShowMediaMetadata
  140.    *    - https://developers.google.com/cast/docs/reference/messages#MusicTrackMediaMetadata
  141.    * @export
  142.    */
  143.   setContentMetadata(metadata) {
  144.     this.metadata_ = metadata;
  145.   }
  147.   /**
  148.    * Clear all Cast content metadata.
  149.    * Should be called from an appDataCallback.
  150.    *
  151.    * @export
  152.    */
  153.   clearContentMetadata() {
  154.     this.metadata_ = null;
  155.   }
  157.   /**
  158.    * Set the Cast content's title.
  159.    * Should be called from an appDataCallback.
  160.    *
  161.    * @param {string} title
  162.    * @export
  163.    */
  164.   setContentTitle(title) {
  165.     if (!this.metadata_) {
  166.       this.metadata_ = {
  167.         'metadataType': cast.receiver.media.MetadataType.GENERIC,
  168.       };
  169.     }
  170.     this.metadata_['title'] = title;
  171.   }
  173.   /**
  174.    * Set the Cast content's thumbnail image.
  175.    * Should be called from an appDataCallback.
  176.    *
  177.    * @param {string} imageUrl
  178.    * @export
  179.    */
  180.   setContentImage(imageUrl) {
  181.     if (!this.metadata_) {
  182.       this.metadata_ = {
  183.         'metadataType': cast.receiver.media.MetadataType.GENERIC,
  184.       };
  185.     }
  186.     this.metadata_['images'] = [
  187.       {
  188.         'url': imageUrl,
  189.       },
  190.     ];
  191.   }
  193.   /**
  194.    * Set the Cast content's artist.
  195.    * Also sets the metadata type to music.
  196.    * Should be called from an appDataCallback.
  197.    *
  198.    * @param {string} artist
  199.    * @export
  200.    */
  201.   setContentArtist(artist) {
  202.     if (!this.metadata_) {
  203.       this.metadata_ = {};
  204.     }
  205.     this.metadata_['artist'] = artist;
  206.     this.metadata_['metadataType'] =
  207.         cast.receiver.media.MetadataType.MUSIC_TRACK;
  208.   }
  210.   /**
  211.    * Destroys the underlying Player, then terminates the cast receiver app.
  212.    *
  213.    * @override
  214.    * @export
  215.    */
  216.   async destroy() {
  217.     if (this.eventManager_) {
  218.       this.eventManager_.release();
  219.       this.eventManager_ = null;
  220.     }
  222.     const waitFor = [];
  223.     if (this.player_) {
  224.       waitFor.push(this.player_.destroy());
  225.       this.player_ = null;
  226.     }
  228.     if (this.pollTimer_) {
  229.       this.pollTimer_.stop();
  230.       this.pollTimer_ = null;
  231.     }
  233.     this.video_ = null;
  234.     this.targets_ = null;
  235.     this.appDataCallback_ = null;
  236.     this.isConnected_ = false;
  237.     this.isIdle_ = true;
  238.     this.shakaBus_ = null;
  239.     this.genericBus_ = null;
  241.     // FakeEventTarget implements IReleasable
  242.     super.release();
  244.     await Promise.all(waitFor);
  246.     const manager = cast.receiver.CastReceiverManager.getInstance();
  247.     manager.stop();
  248.   }
  250.   /** @private */
  251.   init_() {
  252.     const manager = cast.receiver.CastReceiverManager.getInstance();
  253.     manager.onSenderConnected = () => this.onSendersChanged_();
  254.     manager.onSenderDisconnected = () => this.onSendersChanged_();
  255.     manager.onSystemVolumeChanged = () => this.fakeVolumeChangeEvent_();
  257.     this.genericBus_ = manager.getCastMessageBus(
  258.         shaka.cast.CastUtils.GENERIC_MESSAGE_NAMESPACE);
  259.     this.genericBus_.onMessage = (event) => this.onGenericMessage_(event);
  261.     this.shakaBus_ = manager.getCastMessageBus(
  262.         shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE);
  263.     this.shakaBus_.onMessage = (event) => this.onShakaMessage_(event);
  265.     if (goog.DEBUG) {
  266.       // Sometimes it is useful to load the receiver app in Chrome to work on
  267.       // the UI.  To avoid log spam caused by the SDK trying to connect to web
  268.       // sockets that don't exist, in uncompiled mode we check if the hosting
  269.       // browser is a Chromecast before starting the receiver manager.  We
  270.       // wouldn't do browser detection except for debugging, so only do this in
  271.       // uncompiled mode.
  272.       if (shaka.util.Platform.isChromecast()) {
  273.         manager.start();
  274.       }
  275.     } else {
  276.       manager.start();
  277.     }
  279.     for (const name of shaka.cast.CastUtils.VideoEvents) {
  280.       this.eventManager_.listen(
  281.           this.video_, name, (event) => this.proxyEvent_('video', event));
  282.     }
  284.     for (const key in shaka.Player.EventName) {
  285.       const name = shaka.Player.EventName[key];
  286.       this.eventManager_.listen(
  287.           this.player_, name, (event) => this.proxyEvent_('player', event));
  288.     }
  290.     // In our tests, the original Chromecast seems to have trouble decoding
  291.     // above 1080p.  It would be a waste to select a higher res anyway, given
  292.     // that the device only outputs 1080p to begin with.
  294.     // Chromecast has an extension to query the device/display's resolution.
  295.     if (cast.__platform__ && cast.__platform__.canDisplayType(
  296.         'video/mp4; codecs="avc1.640028"; width=3840; height=2160')) {
  297.       // The device and display can both do 4k.  Assume a 4k limit.
  298.       this.player_.setMaxHardwareResolution(3840, 2160);
  299.     } else {
  300.       // Chromecast has always been able to do 1080p.  Assume a 1080p limit.
  301.       this.player_.setMaxHardwareResolution(1920, 1080);
  302.     }
  304.     // Do not start excluding values from update messages until the video is
  305.     // fully loaded.
  306.     this.eventManager_.listen(this.video_, 'loadeddata', () => {
  307.       this.startUpdatingUpdateNumber_ = true;
  308.     });
  310.     // Maintain idle state.
  311.     this.eventManager_.listen(this.player_, 'loading', () => {
  312.       // No longer idle once loading.  This allows us to show the spinner during
  313.       // the initial buffering phase.
  314.       this.isIdle_ = false;
  315.       this.onCastStatusChanged_();
  316.     });
  317.     this.eventManager_.listen(this.video_, 'playing', () => {
  318.       // No longer idle once playing.  This allows us to replay a video without
  319.       // reloading.
  320.       this.isIdle_ = false;
  321.       this.onCastStatusChanged_();
  322.     });
  323.     this.eventManager_.listen(this.video_, 'pause', () => {
  324.       this.onCastStatusChanged_();
  325.     });
  326.     this.eventManager_.listen(this.player_, 'unloading', () => {
  327.       // Go idle when unloading content.
  328.       this.isIdle_ = true;
  329.       this.onCastStatusChanged_();
  330.     });
  331.     this.eventManager_.listen(this.video_, 'ended', () => {
  332.       // Go idle 5 seconds after 'ended', assuming we haven't started again or
  333.       // been destroyed.
  334.       const timer = new shaka.util.Timer(() => {
  335.         if (this.video_ && this.video_.ended) {
  336.           this.isIdle_ = true;
  337.           this.onCastStatusChanged_();
  338.         }
  339.       });
  341.       timer.tickAfter(shaka.cast.CastReceiver.IDLE_INTERVAL);
  342.     });
  344.     // Do not start polling until after the sender's 'init' message is handled.
  345.   }
  347.   /** @private */
  348.   onSendersChanged_() {
  349.     // Reset update message frequency values, to make sure whomever joined
  350.     // will get a full update message.
  351.     this.updateNumber_ = 0;
  352.     // Don't reset startUpdatingUpdateNumber_, because this operation does not
  353.     // result in new data being loaded.
  354.     this.initialStatusUpdatePending_ = true;
  356.     const manager = cast.receiver.CastReceiverManager.getInstance();
  357.     this.isConnected_ = manager.getSenders().length != 0;
  358.     this.onCastStatusChanged_();
  359.   }
  361.   /**
  362.    * Dispatch an event to notify the receiver app that the status has changed.
  363.    * @private
  364.    */
  365.   async onCastStatusChanged_() {
  366.     // Do this asynchronously so that synchronous changes to idle state (such as
  367.     // Player calling unload() as part of load()) are coalesced before the event
  368.     // goes out.
  369.     await Promise.resolve();
  370.     if (!this.player_) {
  371.       // We've already been destroyed.
  372.       return;
  373.     }
  375.     const event = new shaka.util.FakeEvent('caststatuschanged');
  376.     this.dispatchEvent(event);
  377.     // Send a media status message, with a media info message if appropriate.
  378.     if (!this.maybeSendMediaInfoMessage_()) {
  379.       this.sendMediaStatus_();
  380.     }
  381.   }
  383.   /**
  384.    * Take on initial state from the sender.
  385.    * @param {shaka.cast.CastUtils.InitStateType} initState
  386.    * @param {Object} appData
  387.    * @private
  388.    */
  389.   async initState_(initState, appData) {
  390.     // Take on player state first.
  391.     for (const k in initState['player']) {
  392.       const v = initState['player'][k];
  393.       // All player state vars are setters to be called.
  394.       /** @type {Object} */(this.player_)[k](v);
  395.     }
  397.     // Now process custom app data, which may add additional player configs:
  398.     this.appDataCallback_(appData);
  400.     const autoplay = this.video_.autoplay;
  402.     // Now load the manifest, if present.
  403.     if (initState['manifest']) {
  404.       // Don't autoplay the content until we finish setting up initial state.
  405.       this.video_.autoplay = false;
  406.       try {
  407.         await this.player_.load(initState['manifest'], initState['startTime']);
  408.       } catch (error) {
  409.         // Pass any errors through to the app.
  410.         goog.asserts.assert(error instanceof shaka.util.Error,
  411.             'Wrong error type!');
  412.         const eventType = shaka.Player.EventName.Error;
  413.         const data = (new Map()).set('detail', error);
  414.         const event = new shaka.util.FakeEvent(eventType, data);
  415.         // Only dispatch the event if the player still exists.
  416.         if (this.player_) {
  417.           this.player_.dispatchEvent(event);
  418.         }
  419.         return;
  420.       }
  421.     } else {
  422.       // Ensure the below happens async.
  423.       await Promise.resolve();
  424.     }
  426.     if (!this.player_) {
  427.       // We've already been destroyed.
  428.       return;
  429.     }
  431.     // Finally, take on video state and player's "after load" state.
  432.     for (const k in initState['video']) {
  433.       const v = initState['video'][k];
  434.       this.video_[k] = v;
  435.     }
  437.     for (const k in initState['playerAfterLoad']) {
  438.       const v = initState['playerAfterLoad'][k];
  439.       // All player state vars are setters to be called.
  440.       /** @type {Object} */(this.player_)[k](v);
  441.     }
  443.     // Restore original autoplay setting.
  444.     this.video_.autoplay = autoplay;
  445.     if (initState['manifest']) {
  446.       // Resume playback with transferred state.
  447.       this.video_.play();
  448.       // Notify generic controllers of the state change.
  449.       this.sendMediaStatus_();
  450.     }
  451.   }
  453.   /**
  454.    * @param {string} targetName
  455.    * @param {!Event} event
  456.    * @private
  457.    */
  458.   proxyEvent_(targetName, event) {
  459.     if (!this.player_) {
  460.       // The receiver is destroyed, so it should ignore further events.
  461.       return;
  462.     }
  464.     // Poll and send an update right before we send the event.  Some events
  465.     // indicate an attribute change, so that change should be visible when the
  466.     // event is handled.
  467.     this.pollAttributes_();
  469.     this.sendMessage_({
  470.       'type': 'event',
  471.       'targetName': targetName,
  472.       'event': event,
  473.     }, this.shakaBus_);
  474.   }
  476.   /** @private */
  477.   pollAttributes_() {
  478.     // The poll timer may have been pre-empted by an event (e.g. timeupdate).
  479.     // Calling |start| will cancel any pending calls and therefore will avoid us
  480.     // polling too often.
  481.     this.pollTimer_.tickAfter(shaka.cast.CastReceiver.POLL_INTERVAL);
  483.     const update = {
  484.       'video': {},
  485.       'player': {},
  486.     };
  488.     for (const name of shaka.cast.CastUtils.VideoAttributes) {
  489.       update['video'][name] = this.video_[name];
  490.     }
  492.     // TODO: Instead of this variable frequency update system, instead cache the
  493.     // previous player state and only send over changed values, with complete
  494.     // updates every ~20 updates to account for dropped messages.
  496.     if (this.player_.isLive()) {
  497.       const PlayerGetterMethodsThatRequireLive =
  498.           shaka.cast.CastUtils.PlayerGetterMethodsThatRequireLive;
  499.       for (const name in PlayerGetterMethodsThatRequireLive) {
  500.         const frequency = PlayerGetterMethodsThatRequireLive[name];
  501.         if (this.updateNumber_ % frequency == 0) {
  502.           update['player'][name] = /** @type {Object} */ (this.player_)[name]();
  503.         }
  504.       }
  505.     }
  506.     for (const name in shaka.cast.CastUtils.PlayerGetterMethods) {
  507.       const frequency = shaka.cast.CastUtils.PlayerGetterMethods[name];
  508.       if (this.updateNumber_ % frequency == 0) {
  509.         update['player'][name] = /** @type {Object} */ (this.player_)[name]();
  510.       }
  511.     }
  513.     // Volume attributes are tied to the system volume.
  514.     const manager = cast.receiver.CastReceiverManager.getInstance();
  515.     const systemVolume = manager.getSystemVolume();
  516.     if (systemVolume) {
  517.       update['video']['volume'] = systemVolume.level;
  518.       update['video']['muted'] = systemVolume.muted;
  519.     }
  521.     // Only start progressing the update number once data is loaded,
  522.     // just in case any of the "rarely changing" properties with less frequent
  523.     // update messages changes significantly during the loading process.
  524.     if (this.startUpdatingUpdateNumber_) {
  525.       this.updateNumber_ += 1;
  526.     }
  528.     this.sendMessage_({
  529.       'type': 'update',
  530.       'update': update,
  531.     }, this.shakaBus_);
  533.     this.maybeSendMediaInfoMessage_();
  534.   }
  536.   /**
  537.    * Composes and sends a mediaStatus message if appropriate.
  538.    * @return {boolean}
  539.    * @private
  540.    */
  541.   maybeSendMediaInfoMessage_() {
  542.     if (this.initialStatusUpdatePending_ &&
  543.         (this.video_.duration || this.player_.isLive())) {
  544.       // Send over a media status message to set the duration of the cast
  545.       // dialogue.
  546.       this.sendMediaInfoMessage_();
  547.       this.initialStatusUpdatePending_ = false;
  548.       return true;
  549.     }
  550.     return false;
  551.   }
  553.   /**
  554.    * Composes and sends a mediaStatus message with a mediaInfo component.
  555.    *
  556.    * @param {number=} requestId
  557.    * @private
  558.    */
  559.   sendMediaInfoMessage_(requestId = 0) {
  560.     const media = {
  561.       'contentId': this.player_.getAssetUri(),
  562.       'streamType': this.player_.isLive() ? 'LIVE' : 'BUFFERED',
  563.       // Sending an empty string for now since it's a mandatory field.
  564.       // We don't have this info, and it doesn't seem to be useful, anyway.
  565.       'contentType': '',
  566.     };
  567.     if (!this.player_.isLive()) {
  568.       // Optional, and only sent when the duration is known.
  569.       media['duration'] = this.video_.duration;
  570.     }
  571.     if (this.metadata_) {
  572.       media['metadata'] = this.metadata_;
  573.     }
  574.     this.sendMediaStatus_(requestId, media);
  575.   }
  577.   /**
  578.    * Dispatch a fake 'volumechange' event to mimic the video element, since
  579.    * volume changes are routed to the system volume on the receiver.
  580.    * @private
  581.    */
  582.   fakeVolumeChangeEvent_() {
  583.     // Volume attributes are tied to the system volume.
  584.     const manager = cast.receiver.CastReceiverManager.getInstance();
  585.     const systemVolume = manager.getSystemVolume();
  586.     goog.asserts.assert(systemVolume, 'System volume should not be null!');
  588.     if (systemVolume) {
  589.       // Send an update message with just the latest volume level and muted
  590.       // state.
  591.       this.sendMessage_({
  592.         'type': 'update',
  593.         'update': {
  594.           'video': {
  595.             'volume': systemVolume.level,
  596.             'muted': systemVolume.muted,
  597.           },
  598.         },
  599.       }, this.shakaBus_);
  600.     }
  602.     // Send another message with a 'volumechange' event to update the sender's
  603.     // UI.
  604.     this.sendMessage_({
  605.       'type': 'event',
  606.       'targetName': 'video',
  607.       'event': {'type': 'volumechange'},
  608.     }, this.shakaBus_);
  609.   }
  611.   /**
  612.    * Since this method is in the compiled library, make sure all messages are
  613.    * read with quoted properties.
  614.    * @param {!cast.receiver.CastMessageBus.Event} event
  615.    * @private
  616.    */
  617.   onShakaMessage_(event) {
  618.     const message = shaka.cast.CastUtils.deserialize(event.data);
  619.     shaka.log.debug('CastReceiver: message', message);
  621.     switch (message['type']) {
  622.       case 'init':
  623.         // Reset update message frequency values after initialization.
  624.         this.updateNumber_ = 0;
  625.         this.startUpdatingUpdateNumber_ = false;
  626.         this.initialStatusUpdatePending_ = true;
  628.         this.initState_(message['initState'], message['appData']);
  629.         // The sender is supposed to reflect the cast system volume after
  630.         // connecting.  Using fakeVolumeChangeEvent_() would create a race on
  631.         // the sender side, since it would have volume properties, but no
  632.         // others.
  633.         // This would lead to hasRemoteProperties() being true, even though a
  634.         // complete set had never been sent.
  635.         // Now that we have init state, this is a good time for the first update
  636.         // message anyway.
  637.         this.pollAttributes_();
  638.         break;
  639.       case 'appData':
  640.         this.appDataCallback_(message['appData']);
  641.         break;
  642.       case 'set': {
  643.         const targetName = message['targetName'];
  644.         const property = message['property'];
  645.         const value = message['value'];
  647.         if (targetName == 'video') {
  648.           // Volume attributes must be rerouted to the system.
  649.           const manager = cast.receiver.CastReceiverManager.getInstance();
  650.           if (property == 'volume') {
  651.             manager.setSystemVolumeLevel(value);
  652.             break;
  653.           } else if (property == 'muted') {
  654.             manager.setSystemVolumeMuted(value);
  655.             break;
  656.           }
  657.         }
  659.         this.targets_[targetName][property] = value;
  660.         break;
  661.       }
  662.       case 'call': {
  663.         const targetName = message['targetName'];
  664.         const methodName = message['methodName'];
  665.         const args = message['args'];
  666.         const target = this.targets_[targetName];
  667.         // eslint-disable-next-line prefer-spread
  668.         target[methodName].apply(target, args);
  669.         break;
  670.       }
  671.       case 'asyncCall': {
  672.         const targetName = message['targetName'];
  673.         const methodName = message['methodName'];
  674.         if (targetName == 'player' && methodName == 'load') {
  675.           // Reset update message frequency values after a load.
  676.           this.updateNumber_ = 0;
  677.           this.startUpdatingUpdateNumber_ = false;
  678.         }
  679.         const args = message['args'];
  680.         const id = message['id'];
  681.         const senderId = event.senderId;
  682.         const target = this.targets_[targetName];
  683.         // eslint-disable-next-line prefer-spread
  684.         let p = target[methodName].apply(target, args);
  685.         if (targetName == 'player' && methodName == 'load') {
  686.           // Wait until the manifest has actually loaded to send another media
  687.           // info message, so on a new load it doesn't send the old info over.
  688.           p = p.then(() => {
  689.             this.initialStatusUpdatePending_ = true;
  690.           });
  691.         }
  692.         // Replies must go back to the specific sender who initiated, so that we
  693.         // don't have to deal with conflicting IDs between senders.
  694.         p.then(
  695.             () => this.sendAsyncComplete_(senderId, id, /* error= */ null),
  696.             (error) => this.sendAsyncComplete_(senderId, id, error));
  697.         break;
  698.       }
  699.     }
  700.   }
  702.   /**
  703.    * @param {!cast.receiver.CastMessageBus.Event} event
  704.    * @private
  705.    */
  706.   onGenericMessage_(event) {
  707.     const message = shaka.cast.CastUtils.deserialize(event.data);
  708.     shaka.log.debug('CastReceiver: message', message);
  709.     // TODO(ismena): error message on duplicate request id from the same sender
  710.     switch (message['type']) {
  711.       case 'PLAY':
  712.         this.video_.play();
  713.         // Notify generic controllers that the player state changed.
  714.         // requestId=0 (the parameter) means that the message was not
  715.         // triggered by a GET_STATUS request.
  716.         this.sendMediaStatus_();
  717.         break;
  718.       case 'PAUSE':
  719.         this.video_.pause();
  720.         this.sendMediaStatus_();
  721.         break;
  722.       case 'SEEK': {
  723.         const currentTime = message['currentTime'];
  724.         const resumeState = message['resumeState'];
  725.         if (currentTime != null) {
  726.           this.video_.currentTime = Number(currentTime);
  727.         }
  728.         if (resumeState && resumeState == 'PLAYBACK_START') {
  729.           this.video_.play();
  730.           this.sendMediaStatus_();
  731.         } else if (resumeState && resumeState == 'PLAYBACK_PAUSE') {
  732.           this.video_.pause();
  733.           this.sendMediaStatus_();
  734.         }
  735.         break;
  736.       }
  737.       case 'STOP':
  738.         this.player_.unload().then(() => {
  739.           if (!this.player_) {
  740.             // We've already been destroyed.
  741.             return;
  742.           }
  744.           this.sendMediaStatus_();
  745.         });
  746.         break;
  747.       case 'GET_STATUS':
  748.         // TODO(ismena): According to the SDK this is supposed to be a
  749.         // unicast message to the sender that requested the status,
  750.         // but it doesn't appear to be working.
  751.         // Look into what's going on there and change this to be a
  752.         // unicast.
  753.         this.sendMediaInfoMessage_(Number(message['requestId']));
  754.         break;
  755.       case 'VOLUME': {
  756.         const volumeObject = message['volume'];
  757.         const level = volumeObject['level'];
  758.         const muted = volumeObject['muted'];
  759.         const oldVolumeLevel = this.video_.volume;
  760.         const oldVolumeMuted = this.video_.muted;
  761.         if (level != null) {
  762.           this.video_.volume = Number(level);
  763.         }
  764.         if (muted != null) {
  765.           this.video_.muted = muted;
  766.         }
  767.         // Notify generic controllers if the volume changed.
  768.         if (oldVolumeLevel != this.video_.volume ||
  769.             oldVolumeMuted != this.video_.muted) {
  770.           this.sendMediaStatus_();
  771.         }
  772.         break;
  773.       }
  774.       case 'LOAD': {
  775.         // Reset update message frequency values after a load.
  776.         this.updateNumber_ = 0;
  777.         this.startUpdatingUpdateNumber_ = false;
  778.         // This already sends an update.
  779.         this.initialStatusUpdatePending_ = false;
  781.         const mediaInfo = message['media'];
  782.         const contentId = mediaInfo['contentId'];
  783.         const currentTime = message['currentTime'];
  784.         const assetUri = this.contentIdCallback_(contentId);
  785.         const autoplay = message['autoplay'] || true;
  786.         const customData = mediaInfo['customData'];
  788.         this.appDataCallback_(customData);
  790.         if (autoplay) {
  791.           this.video_.autoplay = true;
  792.         }
  793.         this.player_.load(assetUri, currentTime).then(() => {
  794.           if (!this.player_) {
  795.             // We've already been destroyed.
  796.             return;
  797.           }
  799.           // Notify generic controllers that the media has changed.
  800.           this.sendMediaInfoMessage_();
  801.         }).catch((error) => {
  802.           goog.asserts.assert(error instanceof shaka.util.Error,
  803.               'Wrong error type!');
  805.           // Load failed.  Dispatch the error message to the sender.
  806.           let type = 'LOAD_FAILED';
  807.           if (error.category == shaka.util.Error.Category.PLAYER &&
  808.               error.code == shaka.util.Error.Code.LOAD_INTERRUPTED) {
  809.             type = 'LOAD_CANCELLED';
  810.           }
  812.           this.sendMessage_({
  813.             'requestId': Number(message['requestId']),
  814.             'type': type,
  815.           }, this.genericBus_);
  816.         });
  817.         break;
  818.       }
  819.       default:
  820.         shaka.log.warning(
  821.             'Unrecognized message type from the generic Chromecast controller!',
  822.             message['type']);
  823.         // Dispatch an error to the sender.
  824.         this.sendMessage_({
  825.           'requestId': Number(message['requestId']),
  826.           'type': 'INVALID_REQUEST',
  827.           'reason': 'INVALID_COMMAND',
  828.         }, this.genericBus_);
  829.         break;
  830.     }
  831.   }
  833.   /**
  834.    * Tell the sender that the async operation is complete.
  835.    * @param {string} senderId
  836.    * @param {string} id
  837.    * @param {shaka.util.Error} error
  838.    * @private
  839.    */
  840.   sendAsyncComplete_(senderId, id, error) {
  841.     if (!this.player_) {
  842.       // We've already been destroyed.
  843.       return;
  844.     }
  846.     this.sendMessage_({
  847.       'type': 'asyncComplete',
  848.       'id': id,
  849.       'error': error,
  850.     }, this.shakaBus_, senderId);
  851.   }
  853.   /**
  854.    * Since this method is in the compiled library, make sure all messages passed
  855.    * in here were created with quoted property names.
  856.    * @param {!Object} message
  857.    * @param {cast.receiver.CastMessageBus} bus
  858.    * @param {string=} senderId
  859.    * @private
  860.    */
  861.   sendMessage_(message, bus, senderId) {
  862.     // Cuts log spam when debugging the receiver UI in Chrome.
  863.     if (!this.isConnected_) {
  864.       return;
  865.     }
  867.     const serialized = shaka.cast.CastUtils.serialize(message);
  868.     if (senderId) {
  869.       bus.getCastChannel(senderId).send(serialized);
  870.     } else {
  871.       bus.broadcast(serialized);
  872.     }
  873.   }
  875.   /**
  876.    * @return {string}
  877.    * @private
  878.    */
  879.   getPlayState_() {
  880.     const playState = shaka.cast.CastReceiver.PLAY_STATE;
  881.     if (this.isIdle_) {
  882.       return playState.IDLE;
  883.     } else if (this.player_.isBuffering()) {
  884.       return playState.BUFFERING;
  885.     } else if (this.video_.paused) {
  886.       return playState.PAUSED;
  887.     } else {
  888.       return playState.PLAYING;
  889.     }
  890.   }
  892.   /**
  893.    * @param {number=} requestId
  894.    * @param {Object=} media
  895.    * @private
  896.    */
  897.   sendMediaStatus_(requestId = 0, media = null) {
  898.     const mediaStatus = {
  899.       // mediaSessionId is a unique ID for the playback of this specific
  900.       // session.
  901.       // It's used to identify a specific instance of a playback.
  902.       // We don't support multiple playbacks, so just return 0.
  903.       'mediaSessionId': 0,
  904.       'playbackRate': this.video_.playbackRate,
  905.       'playerState': this.getPlayState_(),
  906.       'currentTime': this.video_.currentTime,
  907.       // supportedMediaCommands is a sum of all the flags of commands that the
  908.       // player supports.
  909.       // The list of comands with respective flags is:
  910.       // 1 - Pause
  911.       // 2 - Seek
  912.       // 4 - Stream volume
  913.       // 8 - Stream mute
  914.       // 16 - Skip forward
  915.       // 32 - Skip backward
  916.       // We support all of them, and their sum is 63.
  917.       'supportedMediaCommands': 63,
  918.       'volume': {
  919.         'level': this.video_.volume,
  920.         'muted': this.video_.muted,
  921.       },
  922.     };
  924.     if (media) {
  925.       mediaStatus['media'] = media;
  926.     }
  928.     const ret = {
  929.       'requestId': requestId,
  930.       'type': 'MEDIA_STATUS',
  931.       'status': [mediaStatus],
  932.     };
  934.     this.sendMessage_(ret, this.genericBus_);
  935.   }
  936. };
  938. /** @type {number} The interval, in seconds, to poll for changes. */
  939. shaka.cast.CastReceiver.POLL_INTERVAL = 0.5;
  941. /** @type {number} The interval, in seconds, to go "idle". */
  942. shaka.cast.CastReceiver.IDLE_INTERVAL = 5;
  944. /**
  945.  * @enum {string}
  946.  */
  947. shaka.cast.CastReceiver.PLAY_STATE = {
  948.   IDLE: 'IDLE',
  949.   PLAYING: 'PLAYING',
  950.   BUFFERING: 'BUFFERING',
  951.   PAUSED: 'PAUSED',
  952. };