Source: lib/cast/cast_proxy.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cast.CastProxy');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.Player');
  11. goog.require('shaka.cast.CastSender');
  12. goog.require('shaka.cast.CastUtils');
  13. goog.require('shaka.log');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.EventManager');
  16. goog.require('shaka.util.FakeEvent');
  17. goog.require('shaka.util.FakeEventTarget');
  18. goog.require('shaka.util.IDestroyable');
  21. /**
  22.  * @event shaka.cast.CastProxy.CastStatusChangedEvent
  23.  * @description Fired when cast status changes.  The status change will be
  24.  *   reflected in canCast() and isCasting().
  25.  * @property {string} type
  26.  *   'caststatuschanged'
  27.  * @exportDoc
  28.  */
  31. /**
  32.  * @summary A proxy to switch between local and remote playback for Chromecast
  33.  * in a way that is transparent to the app's controls.
  34.  *
  35.  * @implements {shaka.util.IDestroyable}
  36.  * @export
  37.  */
  38. shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
  39.   /**
  40.    * @param {!HTMLMediaElement} video The local video element associated with
  41.    *   the local Player instance.
  42.    * @param {!shaka.Player} player A local Player instance.
  43.    * @param {string} receiverAppId The ID of the cast receiver application.
  44.    *   If blank, casting will not be available, but the proxy will still
  45.    *   function otherwise.
  46.    * @param {boolean} androidReceiverCompatible Indicates if the app is
  47.    *   compatible with an Android Receiver.
  48.    */
  49.   constructor(video, player, receiverAppId,
  50.       androidReceiverCompatible = false) {
  51.     super();
  53.     /** @private {HTMLMediaElement} */
  54.     this.localVideo_ = video;
  56.     /** @private {shaka.Player} */
  57.     this.localPlayer_ = player;
  59.     /** @private {Object} */
  60.     this.videoProxy_ = null;
  62.     /** @private {Object} */
  63.     this.playerProxy_ = null;
  65.     /** @private {shaka.util.FakeEventTarget} */
  66.     this.videoEventTarget_ = null;
  68.     /** @private {shaka.util.FakeEventTarget} */
  69.     this.playerEventTarget_ = null;
  71.     /** @private {shaka.util.EventManager} */
  72.     this.eventManager_ = null;
  74.     /** @private {string} */
  75.     this.receiverAppId_ = receiverAppId;
  77.     /** @private {boolean} */
  78.     this.androidReceiverCompatible_ = androidReceiverCompatible;
  80.     /** @private {!Map} */
  81.     this.compiledToExternNames_ = new Map();
  83.     /** @private {shaka.cast.CastSender} */
  84.     this.sender_ = null;
  86.     if (window.chrome) {
  87.       this.sender_ = new shaka.cast.CastSender(
  88.           receiverAppId,
  89.           () => this.onCastStatusChanged_(),
  90.           () => this.onFirstCastStateUpdate_(),
  91.           (targetName, event) => this.onRemoteEvent_(targetName, event),
  92.           () => this.onResumeLocal_(),
  93.           () => this.getInitState_(),
  94.           androidReceiverCompatible);
  95.       this.init_();
  96.     } else {
  97.       this.initWithoutSender_();
  98.     }
  99.   }
  101.   /**
  102.    * Destroys the proxy and the underlying local Player.
  103.    *
  104.    * @param {boolean=} forceDisconnect If true, force the receiver app to shut
  105.    *   down by disconnecting.  Does nothing if not connected.
  106.    * @override
  107.    * @export
  108.    */
  109.   destroy(forceDisconnect) {
  110.     if (this.sender_ && forceDisconnect) {
  111.       this.sender_.forceDisconnect();
  112.     }
  114.     if (this.eventManager_) {
  115.       this.eventManager_.release();
  116.       this.eventManager_ = null;
  117.     }
  119.     const waitFor = [];
  120.     if (this.localPlayer_) {
  121.       waitFor.push(this.localPlayer_.destroy());
  122.       this.localPlayer_ = null;
  123.     }
  125.     if (this.sender_) {
  126.       waitFor.push(this.sender_.destroy());
  127.       this.sender_ = null;
  128.     }
  130.     this.localVideo_ = null;
  131.     this.videoProxy_ = null;
  132.     this.playerProxy_ = null;
  134.     // FakeEventTarget implements IReleasable
  135.     super.release();
  137.     return Promise.all(waitFor);
  138.   }
  140.   /**
  141.    * Get a proxy for the video element that delegates to local and remote video
  142.    * elements as appropriate.
  143.    *
  144.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  145.    * @return {!HTMLMediaElement}
  146.    * @export
  147.    */
  148.   getVideo() {
  149.     return /** @type {!HTMLMediaElement} */(this.videoProxy_);
  150.   }
  152.   /**
  153.    * Get a proxy for the Player that delegates to local and remote Player
  154.    * objects as appropriate.
  155.    *
  156.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  157.    * @return {!shaka.Player}
  158.    * @export
  159.    */
  160.   getPlayer() {
  161.     return /** @type {!shaka.Player} */(this.playerProxy_);
  162.   }
  164.   /**
  165.    * @return {boolean} True if the cast API is available and there are
  166.    *   receivers.
  167.    * @export
  168.    */
  169.   canCast() {
  170.     if (!this.sender_) {
  171.       return false;
  172.     }
  173.     return this.sender_.apiReady() && this.sender_.hasReceivers();
  174.   }
  176.   /**
  177.    * @return {boolean} True if we are currently casting.
  178.    * @export
  179.    */
  180.   isCasting() {
  181.     if (!this.sender_) {
  182.       return false;
  183.     }
  184.     return this.sender_.isCasting();
  185.   }
  187.   /**
  188.    * @return {string} The name of the Cast receiver device, if isCasting().
  189.    * @export
  190.    */
  191.   receiverName() {
  192.     if (!this.sender_) {
  193.       return '';
  194.     }
  195.     return this.sender_.receiverName();
  196.   }
  198.   /**
  199.    * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  200.    *   connection fails or is canceled by the user.
  201.    * @export
  202.    */
  203.   async cast() {
  204.     if (!this.sender_) {
  205.       return;
  206.     }
  207.     // TODO: transfer manually-selected tracks?
  208.     // TODO: transfer side-loaded text tracks?
  210.     await this.sender_.cast();
  211.     if (!this.localPlayer_) {
  212.       // We've already been destroyed.
  213.       return;
  214.     }
  216.     // Unload the local manifest when casting succeeds.
  217.     await this.localPlayer_.unload();
  218.   }
  220.   /**
  221.    * Set application-specific data.
  222.    *
  223.    * @param {Object} appData Application-specific data to relay to the receiver.
  224.    * @export
  225.    */
  226.   setAppData(appData) {
  227.     if (!this.sender_) {
  228.       return;
  229.     }
  230.     this.sender_.setAppData(appData);
  231.   }
  233.   /**
  234.    * Show a dialog where user can choose to disconnect from the cast connection.
  235.    * @export
  236.    */
  237.   suggestDisconnect() {
  238.     if (!this.sender_) {
  239.       return;
  240.     }
  241.     this.sender_.showDisconnectDialog();
  242.   }
  244.   /**
  245.    * Force the receiver app to shut down by disconnecting.
  246.    * @export
  247.    */
  248.   forceDisconnect() {
  249.     if (!this.sender_) {
  250.       return;
  251.     }
  252.     this.sender_.forceDisconnect();
  253.   }
  256.   /**
  257.    * @param {string} newAppId
  258.    * @param {boolean=} newCastAndroidReceiver
  259.    * @export
  260.    */
  261.   async changeReceiverId(newAppId, newCastAndroidReceiver = false) {
  262.     if (newAppId == this.receiverAppId_ &&
  263.         newCastAndroidReceiver == this.androidReceiverCompatible_) {
  264.       // Nothing to change
  265.       return;
  266.     }
  268.     this.receiverAppId_ = newAppId;
  269.     this.androidReceiverCompatible_ = newCastAndroidReceiver;
  271.     if (!this.sender_) {
  272.       return;
  273.     }
  275.     // Destroy the old sender
  276.     this.sender_.forceDisconnect();
  277.     await this.sender_.destroy();
  278.     this.sender_ = null;
  281.     // Create the new one
  282.     this.sender_ = new shaka.cast.CastSender(
  283.         newAppId,
  284.         () => this.onCastStatusChanged_(),
  285.         () => this.onFirstCastStateUpdate_(),
  286.         (targetName, event) => this.onRemoteEvent_(targetName, event),
  287.         () => this.onResumeLocal_(),
  288.         () => this.getInitState_(),
  289.         newCastAndroidReceiver);
  291.     this.sender_.init();
  292.   }
  294.   /**
  295.    * Initialize the Proxies without Cast sender.
  296.    * @private
  297.    */
  298.   initWithoutSender_() {
  299.     this.videoProxy_ = /** @type {Object} */(this.localVideo_);
  300.     this.playerProxy_ = /** @type {Object} */(this.localPlayer_);
  301.   }
  303.   /**
  304.    * Initialize the Proxies and the Cast sender.
  305.    * @private
  306.    */
  307.   init_() {
  308.     this.sender_.init();
  310.     this.eventManager_ = new shaka.util.EventManager();
  312.     for (const name of shaka.cast.CastUtils.VideoEvents) {
  313.       this.eventManager_.listen(this.localVideo_, name,
  314.           (event) => this.videoProxyLocalEvent_(event));
  315.     }
  317.     for (const key in shaka.util.FakeEvent.EventName) {
  318.       const name = shaka.util.FakeEvent.EventName[key];
  319.       this.eventManager_.listen(this.localPlayer_, name,
  320.           (event) => this.playerProxyLocalEvent_(event));
  321.     }
  323.     // We would like to use Proxy here, but it is not supported on Safari.
  324.     this.videoProxy_ = {};
  325.     for (const k in this.localVideo_) {
  326.       Object.defineProperty(this.videoProxy_, k, {
  327.         configurable: false,
  328.         enumerable: true,
  329.         get: () => this.videoProxyGet_(k),
  330.         set: (value) => { this.videoProxySet_(k, value); },
  331.       });
  332.     }
  334.     this.playerProxy_ = {};
  335.     this.iterateOverPlayerMethods_((name, method) => {
  336.       goog.asserts.assert(this.playerProxy_, 'Must have player proxy!');
  337.       Object.defineProperty(this.playerProxy_, name, {
  338.         configurable: false,
  339.         enumerable: true,
  340.         get: () => this.playerProxyGet_(name),
  341.       });
  342.     });
  344.     if (COMPILED) {
  345.       this.mapCompiledToUncompiledPlayerMethodNames_();
  346.     }
  348.     this.videoEventTarget_ = new shaka.util.FakeEventTarget();
  349.     this.videoEventTarget_.dispatchTarget =
  350.       /** @type {EventTarget} */(this.videoProxy_);
  352.     this.playerEventTarget_ = new shaka.util.FakeEventTarget();
  353.     this.playerEventTarget_.dispatchTarget =
  354.       /** @type {EventTarget} */(this.playerProxy_);
  355.   }
  358.   /**
  359.    * Maps compiled to uncompiled player names so we can figure out
  360.    * which method to call in compiled build, while casting.
  361.    * @private
  362.    */
  363.   mapCompiledToUncompiledPlayerMethodNames_() {
  364.     // In compiled mode, UI tries to access player methods by their internal
  365.     // renamed names, but the proxy object doesn't know about those.  See
  366.     // https://github.com/shaka-project/shaka-player/issues/2130 for details.
  367.     const methodsToNames = new Map();
  368.     this.iterateOverPlayerMethods_((name, method) => {
  369.       if (methodsToNames.has(method)) {
  370.         // If two method names, point to the same method, add them to the
  371.         // map as aliases of each other.
  372.         const name2 = methodsToNames.get(method);
  373.         // Assumes that the compiled name is shorter
  374.         if (name.length < name2.length) {
  375.           this.compiledToExternNames_.set(name, name2);
  376.         } else {
  377.           this.compiledToExternNames_.set(name2, name);
  378.         }
  379.       } else {
  380.         methodsToNames.set(method, name);
  381.       }
  382.     });
  383.   }
  385.   /**
  386.    * Iterates over all of the methods of the player, including inherited methods
  387.    * from FakeEventTarget.
  388.    * @param {function(string, function())} operation
  389.    * @private
  390.    */
  391.   iterateOverPlayerMethods_(operation) {
  392.     goog.asserts.assert(this.localPlayer_, 'Must have player!');
  393.     const player = /** @type {!Object} */ (this.localPlayer_);
  394.     // Avoid accessing any over-written methods in the prototype chain.
  395.     const seenNames = new Set();
  397.     /**
  398.      * @param {string} name
  399.      * @return {boolean}
  400.      */
  401.     function shouldAddToTheMap(name) {
  402.       if (name == 'constructor') {
  403.         // Don't proxy the constructor.
  404.         return false;
  405.       }
  407.       const method = /** @type {Object} */(player)[name];
  408.       if (typeof method != 'function') {
  409.         // Don't proxy non-methods.
  410.         return false;
  411.       }
  413.       // Add if the map does not already have it
  414.       return !seenNames.has(name);
  415.     }
  417.     // First, look at the methods on the object itself, so this can properly
  418.     // proxy any methods not on the prototype (for example, in the mock player).
  419.     for (const key in player) {
  420.       if (shouldAddToTheMap(key)) {
  421.         seenNames.add(key);
  422.         operation(key, player[key]);
  423.       }
  424.     }
  426.     // The exact length of the prototype chain might vary; for resiliency, this
  427.     // will just look at the entire chain, rather than assuming a set length.
  428.     let proto = /** @type {!Object} */ (Object.getPrototypeOf(player));
  429.     const objProto = /** @type {!Object} */ (Object.getPrototypeOf({}));
  430.     while (proto && proto != objProto) { // Don't proxy Object methods.
  431.       for (const name of Object.getOwnPropertyNames(proto)) {
  432.         if (shouldAddToTheMap(name)) {
  433.           seenNames.add(name);
  434.           operation(name, (player)[name]);
  435.         }
  436.       }
  437.       proto = /** @type {!Object} */ (Object.getPrototypeOf(proto));
  438.     }
  439.   }
  441.   /**
  442.    * @return {shaka.cast.CastUtils.InitStateType} initState Video and player
  443.    *   state to be sent to the receiver.
  444.    * @private
  445.    */
  446.   getInitState_() {
  447.     const initState = {
  448.       'video': {},
  449.       'player': {},
  450.       'playerAfterLoad': {},
  451.       'manifest': this.localPlayer_.getAssetUri(),
  452.       'startTime': null,
  453.     };
  455.     // Pause local playback before capturing state.
  456.     this.localVideo_.pause();
  458.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  459.       initState['video'][name] = this.localVideo_[name];
  460.     }
  462.     // If the video is still playing, set the startTime.
  463.     // Has no effect if nothing is loaded.
  464.     if (!this.localVideo_.ended) {
  465.       initState['startTime'] = this.localVideo_.currentTime;
  466.     }
  468.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  469.       const getter = pair[0];
  470.       const setter = pair[1];
  471.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  473.       initState['player'][setter] = value;
  474.     }
  476.     for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  477.       const getter = pair[0];
  478.       const setter = pair[1];
  479.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  481.       initState['playerAfterLoad'][setter] = value;
  482.     }
  484.     return initState;
  485.   }
  487.   /**
  488.    * Dispatch an event to notify the app that the status has changed.
  489.    * @private
  490.    */
  491.   onCastStatusChanged_() {
  492.     const event = new shaka.util.FakeEvent('caststatuschanged');
  493.     this.dispatchEvent(event);
  494.   }
  496.   /**
  497.    * Dispatch a synthetic play or pause event to ensure that the app correctly
  498.    * knows that the player is playing, if joining an existing receiver.
  499.    * @private
  500.    */
  501.   onFirstCastStateUpdate_() {
  502.     const type = this.videoProxy_['paused'] ? 'pause' : 'play';
  503.     const fakeEvent = new shaka.util.FakeEvent(type);
  504.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  505.   }
  507.   /**
  508.    * Transfer remote state back and resume local playback.
  509.    * @private
  510.    */
  511.   onResumeLocal_() {
  512.     // Transfer back the player state.
  513.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  514.       const getter = pair[0];
  515.       const setter = pair[1];
  516.       const value = this.sender_.get('player', getter)();
  517.       /** @type {Object} */(this.localPlayer_)[setter](value);
  518.     }
  520.     // Get the most recent manifest URI and ended state.
  521.     const assetUri = this.sender_.get('player', 'getAssetUri')();
  522.     const ended = this.sender_.get('video', 'ended');
  524.     let manifestReady = Promise.resolve();
  525.     const autoplay = this.localVideo_.autoplay;
  527.     let startTime = null;
  529.     // If the video is still playing, set the startTime.
  530.     // Has no effect if nothing is loaded.
  531.     if (!ended) {
  532.       startTime = this.sender_.get('video', 'currentTime');
  533.     }
  535.     let activeTextTrack;
  536.     const textTracks = this.sender_.get('player', 'getTextTracks')();
  538.     if (textTracks && textTracks.length) {
  539.       activeTextTrack = textTracks.find((t) => t.active);
  540.     }
  542.     const isTextTrackVisible =
  543.         this.sender_.get('player', 'isTextTrackVisible')();
  545.     // Now load the manifest, if present.
  546.     if (assetUri) {
  547.       // Don't autoplay the content until we finish setting up initial state.
  548.       this.localVideo_.autoplay = false;
  549.       manifestReady = this.localPlayer_.load(assetUri, startTime);
  550.     }
  552.     // Get the video state into a temp variable since we will apply it async.
  553.     const videoState = {};
  554.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  555.       videoState[name] = this.sender_.get('video', name);
  556.     }
  558.     // Finally, take on video state and player's "after load" state.
  559.     manifestReady.then(() => {
  560.       if (!this.localVideo_) {
  561.         // We've already been destroyed.
  562.         return;
  563.       }
  565.       for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  566.         this.localVideo_[name] = videoState[name];
  567.       }
  569.       for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  570.         const getter = pair[0];
  571.         const setter = pair[1];
  572.         const value = this.sender_.get('player', getter)();
  573.         /** @type {Object} */(this.localPlayer_)[setter](value);
  574.       }
  576.       this.localPlayer_.setTextTrackVisibility(isTextTrackVisible);
  577.       if (activeTextTrack) {
  578.         this.localPlayer_.selectTextLanguage(
  579.             activeTextTrack.language,
  580.             activeTextTrack.roles,
  581.             activeTextTrack.forced);
  582.       }
  584.       // Restore the original autoplay setting.
  585.       this.localVideo_.autoplay = autoplay;
  586.       if (assetUri) {
  587.         // Resume playback with transferred state.
  588.         this.localVideo_.play();
  589.       }
  590.     }, (error) => {
  591.       // Pass any errors through to the app.
  592.       goog.asserts.assert(error instanceof shaka.util.Error,
  593.           'Wrong error type!');
  594.       const eventType = shaka.util.FakeEvent.EventName.Error;
  595.       const data = (new Map()).set('detail', error);
  596.       const event = new shaka.util.FakeEvent(eventType, data);
  597.       this.localPlayer_.dispatchEvent(event);
  598.     });
  599.   }
  601.   /**
  602.    * @param {string} name
  603.    * @return {?}
  604.    * @private
  605.    */
  606.   videoProxyGet_(name) {
  607.     if (name == 'addEventListener') {
  608.       return (type, listener, options) => {
  609.         return this.videoEventTarget_.addEventListener(type, listener, options);
  610.       };
  611.     }
  612.     if (name == 'removeEventListener') {
  613.       return (type, listener, options) => {
  614.         return this.videoEventTarget_.removeEventListener(
  615.             type, listener, options);
  616.       };
  617.     }
  619.     // If we are casting, but the first update has not come in yet, use local
  620.     // values, but not local methods.
  621.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  622.       const value = this.localVideo_[name];
  623.       if (typeof value != 'function') {
  624.         return value;
  625.       }
  626.     }
  628.     // Use local values and methods if we are not casting.
  629.     if (!this.sender_.isCasting()) {
  630.       let value = this.localVideo_[name];
  631.       if (typeof value == 'function') {
  632.         // eslint-disable-next-line no-restricted-syntax
  633.         value = value.bind(this.localVideo_);
  634.       }
  635.       return value;
  636.     }
  638.     return this.sender_.get('video', name);
  639.   }
  641.   /**
  642.    * @param {string} name
  643.    * @param {?} value
  644.    * @private
  645.    */
  646.   videoProxySet_(name, value) {
  647.     if (!this.sender_.isCasting()) {
  648.       this.localVideo_[name] = value;
  649.       return;
  650.     }
  652.     this.sender_.set('video', name, value);
  653.   }
  655.   /**
  656.    * @param {!Event} event
  657.    * @private
  658.    */
  659.   videoProxyLocalEvent_(event) {
  660.     if (this.sender_.isCasting()) {
  661.       // Ignore any unexpected local events while casting.  Events can still be
  662.       // fired by the local video and Player when we unload() after the Cast
  663.       // connection is complete.
  664.       return;
  665.     }
  667.     // Convert this real Event into a FakeEvent for dispatch from our
  668.     // FakeEventListener.
  669.     const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
  670.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  671.   }
  673.   /**
  674.    * @param {string} name
  675.    * @return {?}
  676.    * @private
  677.    */
  678.   playerProxyGet_(name) {
  679.     // If name is a shortened compiled name, get the original version
  680.     // from our map.
  681.     if (this.compiledToExternNames_.has(name)) {
  682.       name = this.compiledToExternNames_.get(name);
  683.     }
  685.     if (name == 'addEventListener') {
  686.       return (type, listener, options) => {
  687.         return this.playerEventTarget_.addEventListener(
  688.             type, listener, options);
  689.       };
  690.     }
  691.     if (name == 'removeEventListener') {
  692.       return (type, listener, options) => {
  693.         return this.playerEventTarget_.removeEventListener(
  694.             type, listener, options);
  695.       };
  696.     }
  698.     if (name == 'getMediaElement') {
  699.       return () => this.videoProxy_;
  700.     }
  702.     if (name == 'getSharedConfiguration') {
  703.       shaka.log.warning(
  704.           'Can\'t share configuration across a network. Returning copy.');
  705.       return this.sender_.get('player', 'getConfiguration');
  706.     }
  708.     if (name == 'getNetworkingEngine') {
  709.       // Always returns a local instance, in case you need to make a request.
  710.       // Issues a warning, in case you think you are making a remote request
  711.       // or affecting remote filters.
  712.       if (this.sender_.isCasting()) {
  713.         shaka.log.warning('NOTE: getNetworkingEngine() is always local!');
  714.       }
  715.       return () => this.localPlayer_.getNetworkingEngine();
  716.     }
  718.     if (name == 'getDrmEngine') {
  719.       // Always returns a local instance.
  720.       if (this.sender_.isCasting()) {
  721.         shaka.log.warning('NOTE: getDrmEngine() is always local!');
  722.       }
  723.       return () => this.localPlayer_.getDrmEngine();
  724.     }
  726.     if (name == 'getAdManager') {
  727.       // Always returns a local instance.
  728.       if (this.sender_.isCasting()) {
  729.         shaka.log.warning('NOTE: getAdManager() is always local!');
  730.       }
  731.       return () => this.localPlayer_.getAdManager();
  732.     }
  734.     if (name == 'setVideoContainer') {
  735.       // Always returns a local instance.
  736.       if (this.sender_.isCasting()) {
  737.         shaka.log.warning('NOTE: setVideoContainer() is always local!');
  738.       }
  739.       return (container) => this.localPlayer_.setVideoContainer(container);
  740.     }
  742.     if (this.sender_.isCasting()) {
  743.       // These methods are unavailable or otherwise stubbed during casting.
  744.       if (name == 'getManifest' || name == 'drmInfo') {
  745.         return () => {
  746.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  747.           return null;
  748.         };
  749.       }
  751.       if (name == 'attach' || name == 'detach') {
  752.         return () => {
  753.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  754.           return Promise.resolve();
  755.         };
  756.       }
  757.     }  // if (this.sender_.isCasting())
  759.     // If we are casting, but the first update has not come in yet, use local
  760.     // getters, but not local methods.
  761.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  762.       if (shaka.cast.CastUtils.PlayerGetterMethods.has(name) ||
  763.           shaka.cast.CastUtils.LargePlayerGetterMethods.has(name)) {
  764.         const value = /** @type {Object} */(this.localPlayer_)[name];
  765.         goog.asserts.assert(typeof value == 'function',
  766.             'only methods on Player');
  767.         // eslint-disable-next-line no-restricted-syntax
  768.         return value.bind(this.localPlayer_);
  769.       }
  770.     }
  772.     // Use local getters and methods if we are not casting.
  773.     if (!this.sender_.isCasting()) {
  774.       const value = /** @type {Object} */(this.localPlayer_)[name];
  775.       goog.asserts.assert(typeof value == 'function',
  776.           'only methods on Player');
  777.       // eslint-disable-next-line no-restricted-syntax
  778.       return value.bind(this.localPlayer_);
  779.     }
  781.     return this.sender_.get('player', name);
  782.   }
  784.   /**
  785.    * @param {!Event} event
  786.    * @private
  787.    */
  788.   playerProxyLocalEvent_(event) {
  789.     if (this.sender_.isCasting()) {
  790.       // Ignore any unexpected local events while casting.
  791.       return;
  792.     }
  794.     this.playerEventTarget_.dispatchEvent(event);
  795.   }
  797.   /**
  798.    * @param {string} targetName
  799.    * @param {!shaka.util.FakeEvent} event
  800.    * @private
  801.    */
  802.   onRemoteEvent_(targetName, event) {
  803.     goog.asserts.assert(this.sender_.isCasting(),
  804.         'Should only receive remote events while casting');
  805.     if (!this.sender_.isCasting()) {
  806.       // Ignore any unexpected remote events.
  807.       return;
  808.     }
  810.     if (targetName == 'video') {
  811.       this.videoEventTarget_.dispatchEvent(event);
  812.     } else if (targetName == 'player') {
  813.       this.playerEventTarget_.dispatchEvent(event);
  814.     }
  815.   }
  816. };