Source: lib/cast/cast_receiver.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.CastReceiver');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.cast.CastUtils');
  22. goog.require('shaka.log');
  23. goog.require('shaka.util.Error');
  24. goog.require('shaka.util.EventManager');
  25. goog.require('shaka.util.FakeEvent');
  26. goog.require('shaka.util.FakeEventTarget');
  27. goog.require('shaka.util.IDestroyable');
  31. /**
  32.  * A receiver to communicate between the Chromecast-hosted player and the
  33.  * sender application.
  34.  *
  35.  * @constructor
  36.  * @struct
  37.  * @param {!HTMLMediaElement} video The local video element associated with the
  38.  *   local Player instance.
  39.  * @param {!shaka.Player} player A local Player instance.
  40.  * @param {function(Object)=} opt_appDataCallback A callback to handle
  41.  *   application-specific data passed from the sender.
  42.   * @param {function(string):string=} opt_contentIdCallback A callback to
  43.  *   retrieve manifest URI from the provided content id.
  44.  * @implements {shaka.util.IDestroyable}
  45.  * @extends {shaka.util.FakeEventTarget}
  46.  * @export
  47.  */
  48. shaka.cast.CastReceiver =
  49.     function(video, player, opt_appDataCallback, opt_contentIdCallback) {
  50.   shaka.util.FakeEventTarget.call(this);
  52.   /** @private {HTMLMediaElement} */
  53.   this.video_ = video;
  55.   /** @private {shaka.Player} */
  56.   this.player_ = player;
  58.   /** @private {shaka.util.EventManager} */
  59.   this.eventManager_ = new shaka.util.EventManager();
  61.   /** @private {Object} */
  62.   this.targets_ = {
  63.     'video': video,
  64.     'player': player
  65.   };
  67.   /** @private {?function(Object)} */
  68.   this.appDataCallback_ = opt_appDataCallback || function() {};
  70.   /** @private {?function(string):string} */
  71.   this.opt_contentIdCallback_ = opt_contentIdCallback ||
  72.                             /** @param {string} contentId
  73.                                 @return {string} */
  74.                             function(contentId) { return contentId; };
  76.   /** @private {boolean} */
  77.   this.isConnected_ = false;
  79.   /** @private {boolean} */
  80.   this.isIdle_ = true;
  82.   /** @private {number} */
  83.   this.updateNumber_ = 0;
  85.   /** @private {boolean} */
  86.   this.startUpdatingUpdateNumber_ = false;
  88.   /** @private {boolean} */
  89.   this.initialStatusUpdatePending_ = true;
  91.   /** @private {cast.receiver.CastMessageBus} */
  92.   this.shakaBus_ = null;
  94.   /** @private {cast.receiver.CastMessageBus} */
  95.   this.genericBus_ = null;
  97.   /** @private {?number} */
  98.   this.pollTimerId_ = null;
  100.   this.init_();
  101. };
  102. goog.inherits(shaka.cast.CastReceiver, shaka.util.FakeEventTarget);
  105. /**
  106.  * @return {boolean} True if the cast API is available and there are receivers.
  107.  * @export
  108.  */
  109. shaka.cast.CastReceiver.prototype.isConnected = function() {
  110.   return this.isConnected_;
  111. };
  114. /**
  115.  * @return {boolean} True if the receiver is not currently doing loading or
  116.  *   playing anything.
  117.  * @export
  118.  */
  119. shaka.cast.CastReceiver.prototype.isIdle = function() {
  120.   return this.isIdle_;
  121. };
  124. /**
  125.  * Destroys the underlying Player, then terminates the cast receiver app.
  126.  *
  127.  * @override
  128.  * @export
  129.  */
  130. shaka.cast.CastReceiver.prototype.destroy = function() {
  131.   const async = [
  132.     this.eventManager_ ? this.eventManager_.destroy() : null,
  133.     this.player_ ? this.player_.destroy() : null,
  134.   ];
  136.   if (this.pollTimerId_ != null) {
  137.     window.clearTimeout(this.pollTimerId_);
  138.   }
  140.   this.video_ = null;
  141.   this.player_ = null;
  142.   this.eventManager_ = null;
  143.   this.targets_ = null;
  144.   this.appDataCallback_ = null;
  145.   this.isConnected_ = false;
  146.   this.isIdle_ = true;
  147.   this.shakaBus_ = null;
  148.   this.genericBus_ = null;
  149.   this.pollTimerId_ = null;
  151.   return Promise.all(async).then(function() {
  152.     let manager = cast.receiver.CastReceiverManager.getInstance();
  153.     manager.stop();
  154.   });
  155. };
  158. /** @private */
  159. shaka.cast.CastReceiver.prototype.init_ = function() {
  160.   let manager = cast.receiver.CastReceiverManager.getInstance();
  161.   manager.onSenderConnected = this.onSendersChanged_.bind(this);
  162.   manager.onSenderDisconnected = this.onSendersChanged_.bind(this);
  163.   manager.onSystemVolumeChanged = this.fakeVolumeChangeEvent_.bind(this);
  165.   this.genericBus_ = manager.getCastMessageBus(
  166.       shaka.cast.CastUtils.GENERIC_MESSAGE_NAMESPACE);
  167.   this.genericBus_.onMessage = this.onGenericMessage_.bind(this);
  169.   this.shakaBus_ = manager.getCastMessageBus(
  170.       shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE);
  171.   this.shakaBus_.onMessage = this.onShakaMessage_.bind(this);
  173.   if (goog.DEBUG) {
  174.     // Sometimes it is useful to load the receiver app in Chrome to work on the
  175.     // UI.  To avoid log spam caused by the SDK trying to connect to web sockets
  176.     // that don't exist, in uncompiled mode we check if the hosting browser is a
  177.     // Chromecast before starting the receiver manager.  We wouldn't do browser
  178.     // detection except for debugging, so only do this in uncompiled mode.
  179.     let isChromecast = navigator.userAgent.indexOf('CrKey') >= 0;
  180.     if (isChromecast) {
  181.       manager.start();
  182.     }
  183.   } else {
  184.     manager.start();
  185.   }
  187.   shaka.cast.CastUtils.VideoEvents.forEach(function(name) {
  188.     this.eventManager_.listen(
  189.         this.video_, name, this.proxyEvent_.bind(this, 'video'));
  190.   }.bind(this));
  192.   shaka.cast.CastUtils.PlayerEvents.forEach(function(name) {
  193.     this.eventManager_.listen(
  194.         this.player_, name, this.proxyEvent_.bind(this, 'player'));
  195.   }.bind(this));
  197.   // In our tests, the original Chromecast seems to have trouble decoding above
  198.   // 1080p.  It would be a waste to select a higher res anyway, given that the
  199.   // device only outputs 1080p to begin with.
  201.   // Chromecast has an extension to query the device/display's resolution.
  202.   if (cast.__platform__ && cast.__platform__.canDisplayType(
  203.       'video/mp4; codecs="avc1.640028"; width=3840; height=2160')) {
  204.     // The device and display can both do 4k.  Assume a 4k limit.
  205.     this.player_.setMaxHardwareResolution(3840, 2160);
  206.   } else {
  207.     // Chromecast has always been able to do 1080p.  Assume a 1080p limit.
  208.     this.player_.setMaxHardwareResolution(1920, 1080);
  209.   }
  211.   // Do not start excluding values from update messages until the video is
  212.   // fully loaded.
  213.   this.eventManager_.listen(this.video_, 'loadeddata', function() {
  214.     this.startUpdatingUpdateNumber_ = true;
  215.   }.bind(this));
  217.   // Maintain idle state.
  218.   this.eventManager_.listen(this.player_, 'loading', function() {
  219.     // No longer idle once loading.  This allows us to show the spinner during
  220.     // the initial buffering phase.
  221.     this.isIdle_ = false;
  222.     this.onCastStatusChanged_();
  223.   }.bind(this));
  224.   this.eventManager_.listen(this.video_, 'playing', function() {
  225.     // No longer idle once playing.  This allows us to replay a video without
  226.     // reloading.
  227.     this.isIdle_ = false;
  228.     this.onCastStatusChanged_();
  229.   }.bind(this));
  230.   this.eventManager_.listen(this.video_, 'pause', function() {
  231.     this.onCastStatusChanged_();
  232.   }.bind(this));
  233.   this.eventManager_.listen(this.player_, 'unloading', function() {
  234.     // Go idle when unloading content.
  235.     this.isIdle_ = true;
  236.     this.onCastStatusChanged_();
  237.   }.bind(this));
  238.   this.eventManager_.listen(this.video_, 'ended', function() {
  239.     // Go idle 5 seconds after 'ended', assuming we haven't started again or
  240.     // been destroyed.
  241.     window.setTimeout(function() {
  242.       if (this.video_ && this.video_.ended) {
  243.         this.isIdle_ = true;
  244.         this.onCastStatusChanged_();
  245.       }
  246.     }.bind(this), 5000);
  247.   }.bind(this));
  249.   // Do not start polling until after the sender's 'init' message is handled.
  250. };
  253. /** @private */
  254. shaka.cast.CastReceiver.prototype.onSendersChanged_ = function() {
  255.   // Reset update message frequency values, to make sure whomever joined
  256.   // will get a full update message.
  257.   this.updateNumber_ = 0;
  258.   // Don't reset startUpdatingUpdateNumber_, because this operation does not
  259.   // result in new data being loaded.
  260.   this.initialStatusUpdatePending_ = true;
  262.   let manager = cast.receiver.CastReceiverManager.getInstance();
  263.   this.isConnected_ = manager.getSenders().length != 0;
  264.   this.onCastStatusChanged_();
  265. };
  268. /**
  269.  * Dispatch an event to notify the receiver app that the status has changed.
  270.  * @private
  271.  */
  272. shaka.cast.CastReceiver.prototype.onCastStatusChanged_ = function() {
  273.   // Do this asynchronously so that synchronous changes to idle state (such as
  274.   // Player calling unload() as part of load()) are coalesced before the event
  275.   // goes out.
  276.   Promise.resolve().then(function() {
  277.     if (!this.player_) {
  278.       // We've already been destroyed.
  279.       return;
  280.     }
  282.     let event = new shaka.util.FakeEvent('caststatuschanged');
  283.     this.dispatchEvent(event);
  284.     // Send a media status message, with a media info message if appropriate.
  285.     if (!this.maybeSendMediaInfoMessage_()) {
  286.       this.sendMediaStatus_(0);
  287.     }
  288.   }.bind(this));
  289. };
  292. /**
  293.  * Take on initial state from the sender.
  294.  * @param {shaka.cast.CastUtils.InitStateType} initState
  295.  * @param {Object} appData
  296.  * @private
  297.  */
  298. shaka.cast.CastReceiver.prototype.initState_ = function(initState, appData) {
  299.   // Take on player state first.
  300.   for (let k in initState['player']) {
  301.     let v = initState['player'][k];
  302.     // All player state vars are setters to be called.
  303.     /** @type {Object} */(this.player_)[k](v);
  304.   }
  306.   // Now process custom app data, which may add additional player configs:
  307.   this.appDataCallback_(appData);
  309.   let manifestReady = Promise.resolve();
  310.   let autoplay = this.video_.autoplay;
  312.   // Now load the manifest, if present.
  313.   if (initState['manifest']) {
  314.     // Don't autoplay the content until we finish setting up initial state.
  315.     this.video_.autoplay = false;
  316.     manifestReady = this.player_.load(
  317.         initState['manifest'], initState['startTime']);
  318.   }
  320.   // Finally, take on video state and player's "after load" state.
  321.   manifestReady.then(() => {
  322.     if (!this.player_) {
  323.       // We've already been destroyed.
  324.       return;
  325.     }
  327.     for (let k in initState['video']) {
  328.       let v = initState['video'][k];
  329.       this.video_[k] = v;
  330.     }
  332.     for (let k in initState['playerAfterLoad']) {
  333.       let v = initState['playerAfterLoad'][k];
  334.       // All player state vars are setters to be called.
  335.       /** @type {Object} */(this.player_)[k](v);
  336.     }
  338.     // Restore original autoplay setting.
  339.     this.video_.autoplay = autoplay;
  340.     if (initState['manifest']) {
  341.       // Resume playback with transferred state.
  342.       this.video_.play();
  343.       // Notify generic controllers of the state change.
  344.       this.sendMediaStatus_(0);
  345.     }
  346.   }, (error) => {
  347.     // Pass any errors through to the app.
  348.     goog.asserts.assert(error instanceof shaka.util.Error,
  349.                         'Wrong error type!');
  350.     let event = new shaka.util.FakeEvent('error', {'detail': error});
  351.     this.player_.dispatchEvent(event);
  352.   });
  353. };
  356. /**
  357.  * @param {string} targetName
  358.  * @param {!Event} event
  359.  * @private
  360.  */
  361. shaka.cast.CastReceiver.prototype.proxyEvent_ = function(targetName, event) {
  362.   if (!this.player_) {
  363.     // The receiver is destroyed, so it should ignore further events.
  364.     return;
  365.   }
  367.   // Poll and send an update right before we send the event.  Some events
  368.   // indicate an attribute change, so that change should be visible when the
  369.   // event is handled.
  370.   this.pollAttributes_();
  372.   this.sendMessage_({
  373.     'type': 'event',
  374.     'targetName': targetName,
  375.     'event': event
  376.   }, this.shakaBus_);
  377. };
  380. /** @private */
  381. shaka.cast.CastReceiver.prototype.pollAttributes_ = function() {
  382.   // The poll timer may have been pre-empted by an event.
  383.   // To avoid polling too often, we clear it here.
  384.   if (this.pollTimerId_ != null) {
  385.     window.clearTimeout(this.pollTimerId_);
  386.   }
  387.   // Since we know the timer has been cleared, start a new one now.
  388.   // This will be preempted by events, including 'timeupdate'.
  389.   this.pollTimerId_ = window.setTimeout(this.pollAttributes_.bind(this), 500);
  391.   let update = {
  392.     'video': {},
  393.     'player': {}
  394.   };
  396.   shaka.cast.CastUtils.VideoAttributes.forEach(function(name) {
  397.     update['video'][name] = this.video_[name];
  398.   }.bind(this));
  400.   // TODO: Instead of this variable frequency update system, instead cache the
  401.   // previous player state and only send over changed values, with complete
  402.   // updates every ~20 updates to account for dropped messages.
  404.   if (this.player_.isLive()) {
  405.     for (let name in shaka.cast.CastUtils.PlayerGetterMethodsThatRequireLive) {
  406.       let frequency =
  407.           shaka.cast.CastUtils.PlayerGetterMethodsThatRequireLive[name];
  408.       if (this.updateNumber_ % frequency == 0) {
  409.         update['player'][name] = /** @type {Object} */ (this.player_)[name]();
  410.       }
  411.     }
  412.   }
  413.   for (let name in shaka.cast.CastUtils.PlayerGetterMethods) {
  414.     let frequency = shaka.cast.CastUtils.PlayerGetterMethods[name];
  415.     if (this.updateNumber_ % frequency == 0) {
  416.       update['player'][name] = /** @type {Object} */ (this.player_)[name]();
  417.     }
  418.   }
  420.   // Volume attributes are tied to the system volume.
  421.   let manager = cast.receiver.CastReceiverManager.getInstance();
  422.   let systemVolume = manager.getSystemVolume();
  423.   if (systemVolume) {
  424.     update['video']['volume'] = systemVolume.level;
  425.     update['video']['muted'] = systemVolume.muted;
  426.   }
  428.   // Only start progressing the update number once data is loaded,
  429.   // just in case any of the "rarely changing" properties with less frequent
  430.   // update messages changes significantly during the loading process.
  431.   if (this.startUpdatingUpdateNumber_) {
  432.     this.updateNumber_ += 1;
  433.   }
  435.   this.sendMessage_({
  436.     'type': 'update',
  437.     'update': update
  438.   }, this.shakaBus_);
  440.   this.maybeSendMediaInfoMessage_();
  441. };
  444. /**
  445.  * Composes and sends a mediaStatus message if appropriate.
  446.  * @return {boolean}
  447.  * @private
  448.  */
  449. shaka.cast.CastReceiver.prototype.maybeSendMediaInfoMessage_ = function() {
  450.   if (this.initialStatusUpdatePending_ &&
  451.       (this.video_.duration || this.player_.isLive())) {
  452.     // Send over a media status message to set the duration of the cast
  453.     // dialogue.
  454.     this.sendMediaInfoMessage_();
  455.     this.initialStatusUpdatePending_ = false;
  456.     return true;
  457.   }
  458.   return false;
  459. };
  462. /**
  463.  * Composes and sends a mediaStatus message with a mediaInfo component.
  464.  * @private
  465.  */
  466. shaka.cast.CastReceiver.prototype.sendMediaInfoMessage_ = function() {
  467.   let media = {
  468.     'contentId': this.player_.getManifestUri(),
  469.     'streamType': this.player_.isLive() ? 'LIVE' : 'BUFFERED',
  470.     'duration': this.video_.duration,
  471.     // TODO: Is there a use case when this would be required?
  472.     // Sending an empty string for now since it's a mandatory
  473.     // field.
  474.     'contentType': ''
  475.   };
  476.   this.sendMediaStatus_(0, media);
  477. };
  480. /**
  481.  * Dispatch a fake 'volumechange' event to mimic the video element, since volume
  482.  * changes are routed to the system volume on the receiver.
  483.  * @private
  484.  */
  485. shaka.cast.CastReceiver.prototype.fakeVolumeChangeEvent_ = function() {
  486.   // Volume attributes are tied to the system volume.
  487.   let manager = cast.receiver.CastReceiverManager.getInstance();
  488.   let systemVolume = manager.getSystemVolume();
  489.   goog.asserts.assert(systemVolume, 'System volume should not be null!');
  491.   if (systemVolume) {
  492.     // Send an update message with just the latest volume level and muted state.
  493.     this.sendMessage_({
  494.       'type': 'update',
  495.       'update': {
  496.         'video': {
  497.           'volume': systemVolume.level,
  498.           'muted': systemVolume.muted
  499.         }
  500.       }
  501.     }, this.shakaBus_);
  502.   }
  504.   // Send another message with a 'volumechange' event to update the sender's UI.
  505.   this.sendMessage_({
  506.     'type': 'event',
  507.     'targetName': 'video',
  508.     'event': {'type': 'volumechange'}
  509.   }, this.shakaBus_);
  510. };
  513. /**
  514.  * Since this method is in the compiled library, make sure all messages are
  515.  * read with quoted properties.
  516.  * @param {!cast.receiver.CastMessageBus.Event} event
  517.  * @private
  518.  */
  519. shaka.cast.CastReceiver.prototype.onShakaMessage_ = function(event) {
  520.   let message = shaka.cast.CastUtils.deserialize(event.data);
  521.   shaka.log.debug('CastReceiver: message', message);
  523.   switch (message['type']) {
  524.     case 'init':
  525.       // Reset update message frequency values after initialization.
  526.       this.updateNumber_ = 0;
  527.       this.startUpdatingUpdateNumber_ = false;
  528.       this.initialStatusUpdatePending_ = true;
  530.       this.initState_(message['initState'], message['appData']);
  531.       // The sender is supposed to reflect the cast system volume after
  532.       // connecting.  Using fakeVolumeChangeEvent_() would create a race on the
  533.       // sender side, since it would have volume properties, but no others.
  534.       // This would lead to hasRemoteProperties() being true, even though a
  535.       // complete set had never been sent.
  536.       // Now that we have init state, this is a good time for the first update
  537.       // message anyway.
  538.       this.pollAttributes_();
  539.       break;
  540.     case 'appData':
  541.       this.appDataCallback_(message['appData']);
  542.       break;
  543.     case 'set': {
  544.       let targetName = message['targetName'];
  545.       let property = message['property'];
  546.       let value = message['value'];
  548.       if (targetName == 'video') {
  549.         // Volume attributes must be rerouted to the system.
  550.         let manager = cast.receiver.CastReceiverManager.getInstance();
  551.         if (property == 'volume') {
  552.           manager.setSystemVolumeLevel(value);
  553.           break;
  554.         } else if (property == 'muted') {
  555.           manager.setSystemVolumeMuted(value);
  556.           break;
  557.         }
  558.       }
  560.       this.targets_[targetName][property] = value;
  561.       break;
  562.     }
  563.     case 'call': {
  564.       let targetName = message['targetName'];
  565.       let methodName = message['methodName'];
  566.       let args = message['args'];
  567.       let target = this.targets_[targetName];
  568.       target[methodName].apply(target, args);
  569.       break;
  570.     }
  571.     case 'asyncCall': {
  572.       let targetName = message['targetName'];
  573.       let methodName = message['methodName'];
  574.       if (targetName == 'player' && methodName == 'load') {
  575.         // Reset update message frequency values after a load.
  576.         this.updateNumber_ = 0;
  577.         this.startUpdatingUpdateNumber_ = false;
  578.       }
  579.       let args = message['args'];
  580.       let id = message['id'];
  581.       let senderId = event.senderId;
  582.       let target = this.targets_[targetName];
  583.       let p = target[methodName].apply(target, args);
  584.       if (targetName == 'player' && methodName == 'load') {
  585.         // Wait until the manifest has actually loaded to send another media
  586.         // info message, so on a new load it doesn't send the old info over.
  587.         p = p.then(function() {
  588.           this.initialStatusUpdatePending_ = true;
  589.         }.bind(this));
  590.       }
  591.       // Replies must go back to the specific sender who initiated, so that we
  592.       // don't have to deal with conflicting IDs between senders.
  593.       p.then(this.sendAsyncComplete_.bind(this, senderId, id, /* error */ null),
  594.              this.sendAsyncComplete_.bind(this, senderId, id));
  595.       break;
  596.     }
  597.   }
  598. };
  601. /**
  602.  * @param {!cast.receiver.CastMessageBus.Event} event
  603.  * @private
  604.  */
  605. shaka.cast.CastReceiver.prototype.onGenericMessage_ = function(event) {
  606.   let message = shaka.cast.CastUtils.deserialize(event.data);
  607.   shaka.log.debug('CastReceiver: message', message);
  608.   // TODO(ismena): error message on duplicate request id from the same sender
  609.   switch (message['type']) {
  610.     case 'PLAY':
  611.       this.video_.play();
  612.       // Notify generic controllers that the player state changed.
  613.       // requestId=0 (the parameter) means that the message was not
  614.       // triggered by a GET_STATUS request.
  615.       this.sendMediaStatus_(0);
  616.       break;
  617.     case 'PAUSE':
  618.       this.video_.pause();
  619.       this.sendMediaStatus_(0);
  620.       break;
  621.     case 'SEEK': {
  622.       let currentTime = message['currentTime'];
  623.       let resumeState = message['resumeState'];
  624.       if (currentTime != null) {
  625.         this.video_.currentTime = Number(currentTime);
  626.       }
  627.       if (resumeState && resumeState == 'PLAYBACK_START') {
  628.         this.video_.play();
  629.         this.sendMediaStatus_(0);
  630.       } else if (resumeState && resumeState == 'PLAYBACK_PAUSE') {
  631.         this.video_.pause();
  632.         this.sendMediaStatus_(0);
  633.       }
  634.       break;
  635.     }
  636.     case 'STOP':
  637.       this.player_.unload().then(function() {
  638.         if (!this.player_) {
  639.           // We've already been destroyed.
  640.           return;
  641.         }
  643.         this.sendMediaStatus_(0);
  644.       }.bind(this));
  645.       break;
  646.     case 'GET_STATUS':
  647.       // TODO(ismena): According to the SDK this is supposed to be a
  648.       // unicast message to the sender that requested the status,
  649.       // but it doesn't appear to be working.
  650.       // Look into what's going on there and change this to be a
  651.       // unicast.
  652.       this.sendMediaStatus_(Number(message['requestId']));
  653.       break;
  654.     case 'VOLUME': {
  655.       let volumeObject = message['volume'];
  656.       let level = volumeObject['level'];
  657.       let muted = volumeObject['muted'];
  658.       let oldVolumeLevel = this.video_.volume;
  659.       let oldVolumeMuted = this.video_.muted;
  660.       if (level != null) {
  661.         this.video_.volume = Number(level);
  662.       }
  663.       if (muted != null) {
  664.         this.video_.muted = muted;
  665.       }
  666.       // Notify generic controllers if the volume changed.
  667.       if (oldVolumeLevel != this.video_.volume ||
  668.           oldVolumeMuted != this.video_.muted) {
  669.         this.sendMediaStatus_(0);
  670.       }
  671.       break;
  672.     }
  673.     case 'LOAD': {
  674.       // Reset update message frequency values after a load.
  675.       this.updateNumber_ = 0;
  676.       this.startUpdatingUpdateNumber_ = false;
  677.       this.initialStatusUpdatePending_ = false; // This already sends an update.
  679.       let mediaInfo = message['media'];
  680.       let contentId = mediaInfo['contentId'];
  681.       let currentTime = message['currentTime'];
  682.       let manifestUri = this.opt_contentIdCallback_(contentId);
  683.       let autoplay = message['autoplay'] || true;
  684.       if (autoplay) {
  685.         this.video_.autoplay = true;
  686.       }
  687.       this.player_.load(manifestUri, currentTime).then(function() {
  688.         if (!this.player_) {
  689.           // We've already been destroyed.
  690.           return;
  691.         }
  693.         // Notify generic controllers that the media has changed.
  694.         this.sendMediaInfoMessage_();
  695.       }.bind(this)).catch(function(error) {
  696.         // Load failed.  Dispatch the error message to the sender.
  697.         let type = 'LOAD_FAILED';
  698.         if (error.category == shaka.util.Error.Category.PLAYER &&
  699.             error.code == shaka.util.Error.Code.LOAD_INTERRUPTED) {
  700.           type = 'LOAD_CANCELLED';
  701.         }
  703.         this.sendMessage_({
  704.           'requestId': Number(message['requestId']),
  705.           'type': type
  706.         }, this.genericBus_);
  707.       }.bind(this));
  708.       break;
  709.     }
  710.     default:
  711.       shaka.log.warning(
  712.           'Unrecognized message type from the generic Chromecast controller!',
  713.           message['type']);
  714.       // Dispatch an error to the sender.
  715.       this.sendMessage_({
  716.         'requestId': Number(message['requestId']),
  717.         'type': 'INVALID_REQUEST',
  718.         'reason': 'INVALID_COMMAND'
  719.       }, this.genericBus_);
  720.       break;
  721.   }
  722. };
  725. /**
  726.  * Tell the sender that the async operation is complete.
  727.  * @param {string} senderId
  728.  * @param {string} id
  729.  * @param {shaka.util.Error} error
  730.  * @private
  731.  */
  732. shaka.cast.CastReceiver.prototype.sendAsyncComplete_ =
  733.     function(senderId, id, error) {
  734.   if (!this.player_) {
  735.     // We've already been destroyed.
  736.     return;
  737.   }
  739.   this.sendMessage_({
  740.     'type': 'asyncComplete',
  741.     'id': id,
  742.     'error': error
  743.   }, this.shakaBus_, senderId);
  744. };
  747. /**
  748.  * Since this method is in the compiled library, make sure all messages passed
  749.  * in here were created with quoted property names.
  750.  * @param {!Object} message
  751.  * @param {cast.receiver.CastMessageBus} bus
  752.  * @param {string=} opt_senderId
  753.  * @private
  754.  */
  755. shaka.cast.CastReceiver.prototype.sendMessage_ =
  756.     function(message, bus, opt_senderId) {
  757.   // Cuts log spam when debugging the receiver UI in Chrome.
  758.   if (!this.isConnected_) return;
  760.   let serialized = shaka.cast.CastUtils.serialize(message);
  761.   if (opt_senderId) {
  762.     bus.getCastChannel(opt_senderId).send(serialized);
  763.   } else {
  764.     bus.broadcast(serialized);
  765.   }
  766. };
  769. /**
  770.  * @return {string}
  771.  * @private
  772.  */
  773. shaka.cast.CastReceiver.prototype.getPlayState_ = function() {
  774.   let playState = shaka.cast.CastReceiver.PLAY_STATE;
  775.   if (this.isIdle_) {
  776.     return playState.IDLE;
  777.   } else if (this.player_.isBuffering()) {
  778.     return playState.BUFFERING;
  779.   } else if (this.video_.paused) {
  780.     return playState.PAUSED;
  781.   } else {
  782.     return playState.PLAYING;
  783.   }
  784. };
  787. /**
  788.  * @param {number} requestId
  789.  * @param {Object=} opt_media
  790.  * @private
  791.  */
  792. shaka.cast.CastReceiver.prototype.sendMediaStatus_ =
  793.     function(requestId, opt_media) {
  794.   let mediaStatus = {
  795.     // mediaSessionId is a unique ID for the playback of this specific session.
  796.     // It's used to identify a specific instance of a playback.
  797.     // We don't support multiple playbacks, so just return 0.
  798.     'mediaSessionId': 0,
  799.     'playbackRate': this.video_.playbackRate,
  800.     'playerState': this.getPlayState_(),
  801.     'currentTime': this.video_.currentTime,
  802.     // supportedMediaCommands is a sum of all the flags of commands that the
  803.     // player supports.
  804.     // The list of comands with respective flags is:
  805.     // 1 - Pause
  806.     // 2 - Seek
  807.     // 4 - Stream volume
  808.     // 8 - Stream mute
  809.     // 16 - Skip forward
  810.     // 32 - Skip backward
  811.     // We support pause, seek, volume and mute which gives a value of
  812.     // 1+2+4+8=15
  813.     'supportedMediaCommands': 15,
  814.     'volume': {
  815.       'level': this.video_.volume,
  816.       'muted': this.video_.muted
  817.     }
  818.   };
  820.   if (opt_media) {
  821.     mediaStatus['media'] = opt_media;
  822.   }
  824.   let ret = {
  825.     'requestId': requestId,
  826.     'type': 'MEDIA_STATUS',
  827.     'status': [mediaStatus]
  828.   };
  830.   this.sendMessage_(ret, this.genericBus_);
  831. };
  834. /**
  835.  * @enum {string}
  836.  */
  837. shaka.cast.CastReceiver.PLAY_STATE = {
  838.   IDLE: 'IDLE',
  839.   PLAYING: 'PLAYING',
  840.   BUFFERING: 'BUFFERING',
  841.   PAUSED: 'PAUSED'
  842. };