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_ = new shaka.cast.CastSender(
  85.         receiverAppId,
  86.         () => this.onCastStatusChanged_(),
  87.         () => this.onFirstCastStateUpdate_(),
  88.         (targetName, event) => this.onRemoteEvent_(targetName, event),
  89.         () => this.onResumeLocal_(),
  90.         () => this.getInitState_(),
  91.         androidReceiverCompatible);
  94.     this.init_();
  95.   }
  97.   /**
  98.    * Destroys the proxy and the underlying local Player.
  99.    *
  100.    * @param {boolean=} forceDisconnect If true, force the receiver app to shut
  101.    *   down by disconnecting.  Does nothing if not connected.
  102.    * @override
  103.    * @export
  104.    */
  105.   destroy(forceDisconnect) {
  106.     if (forceDisconnect) {
  107.       this.sender_.forceDisconnect();
  108.     }
  110.     if (this.eventManager_) {
  111.       this.eventManager_.release();
  112.       this.eventManager_ = null;
  113.     }
  115.     const waitFor = [];
  116.     if (this.localPlayer_) {
  117.       waitFor.push(this.localPlayer_.destroy());
  118.       this.localPlayer_ = null;
  119.     }
  121.     if (this.sender_) {
  122.       waitFor.push(this.sender_.destroy());
  123.       this.sender_ = null;
  124.     }
  126.     this.localVideo_ = null;
  127.     this.videoProxy_ = null;
  128.     this.playerProxy_ = null;
  130.     // FakeEventTarget implements IReleasable
  131.     super.release();
  133.     return Promise.all(waitFor);
  134.   }
  136.   /**
  137.    * Get a proxy for the video element that delegates to local and remote video
  138.    * elements as appropriate.
  139.    *
  140.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  141.    * @return {!HTMLMediaElement}
  142.    * @export
  143.    */
  144.   getVideo() {
  145.     return /** @type {!HTMLMediaElement} */(this.videoProxy_);
  146.   }
  148.   /**
  149.    * Get a proxy for the Player that delegates to local and remote Player
  150.    * objects as appropriate.
  151.    *
  152.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  153.    * @return {!shaka.Player}
  154.    * @export
  155.    */
  156.   getPlayer() {
  157.     return /** @type {!shaka.Player} */(this.playerProxy_);
  158.   }
  160.   /**
  161.    * @return {boolean} True if the cast API is available and there are
  162.    *   receivers.
  163.    * @export
  164.    */
  165.   canCast() {
  166.     return this.sender_.apiReady() && this.sender_.hasReceivers();
  167.   }
  169.   /**
  170.    * @return {boolean} True if we are currently casting.
  171.    * @export
  172.    */
  173.   isCasting() {
  174.     return this.sender_.isCasting();
  175.   }
  177.   /**
  178.    * @return {string} The name of the Cast receiver device, if isCasting().
  179.    * @export
  180.    */
  181.   receiverName() {
  182.     return this.sender_.receiverName();
  183.   }
  185.   /**
  186.    * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  187.    *   connection fails or is canceled by the user.
  188.    * @export
  189.    */
  190.   async cast() {
  191.     // TODO: transfer manually-selected tracks?
  192.     // TODO: transfer side-loaded text tracks?
  194.     await this.sender_.cast();
  195.     if (!this.localPlayer_) {
  196.       // We've already been destroyed.
  197.       return;
  198.     }
  200.     // Unload the local manifest when casting succeeds.
  201.     await this.localPlayer_.unload();
  202.   }
  204.   /**
  205.    * Set application-specific data.
  206.    *
  207.    * @param {Object} appData Application-specific data to relay to the receiver.
  208.    * @export
  209.    */
  210.   setAppData(appData) {
  211.     this.sender_.setAppData(appData);
  212.   }
  214.   /**
  215.    * Show a dialog where user can choose to disconnect from the cast connection.
  216.    * @export
  217.    */
  218.   suggestDisconnect() {
  219.     this.sender_.showDisconnectDialog();
  220.   }
  222.   /**
  223.    * Force the receiver app to shut down by disconnecting.
  224.    * @export
  225.    */
  226.   forceDisconnect() {
  227.     this.sender_.forceDisconnect();
  228.   }
  231.   /**
  232.    * @param {string} newAppId
  233.    * @param {boolean=} newCastAndroidReceiver
  234.    * @export
  235.    */
  236.   async changeReceiverId(newAppId, newCastAndroidReceiver = false) {
  237.     if (newAppId == this.receiverAppId_ &&
  238.         newCastAndroidReceiver == this.androidReceiverCompatible_) {
  239.       // Nothing to change
  240.       return;
  241.     }
  243.     this.receiverAppId_ = newAppId;
  244.     this.androidReceiverCompatible_ = newCastAndroidReceiver;
  246.     // Destroy the old sender
  247.     this.sender_.forceDisconnect();
  248.     await this.sender_.destroy();
  249.     this.sender_ = null;
  252.     // Create the new one
  253.     this.sender_ = new shaka.cast.CastSender(
  254.         newAppId,
  255.         () => this.onCastStatusChanged_(),
  256.         () => this.onFirstCastStateUpdate_(),
  257.         (targetName, event) => this.onRemoteEvent_(targetName, event),
  258.         () => this.onResumeLocal_(),
  259.         () => this.getInitState_(),
  260.         newCastAndroidReceiver);
  262.     this.sender_.init();
  263.   }
  265.   /**
  266.    * Initialize the Proxies and the Cast sender.
  267.    * @private
  268.    */
  269.   init_() {
  270.     this.sender_.init();
  272.     this.eventManager_ = new shaka.util.EventManager();
  274.     for (const name of shaka.cast.CastUtils.VideoEvents) {
  275.       this.eventManager_.listen(this.localVideo_, name,
  276.           (event) => this.videoProxyLocalEvent_(event));
  277.     }
  279.     for (const key in shaka.util.FakeEvent.EventName) {
  280.       const name = shaka.util.FakeEvent.EventName[key];
  281.       this.eventManager_.listen(this.localPlayer_, name,
  282.           (event) => this.playerProxyLocalEvent_(event));
  283.     }
  285.     // We would like to use Proxy here, but it is not supported on Safari.
  286.     this.videoProxy_ = {};
  287.     for (const k in this.localVideo_) {
  288.       Object.defineProperty(this.videoProxy_, k, {
  289.         configurable: false,
  290.         enumerable: true,
  291.         get: () => this.videoProxyGet_(k),
  292.         set: (value) => { this.videoProxySet_(k, value); },
  293.       });
  294.     }
  296.     this.playerProxy_ = {};
  297.     this.iterateOverPlayerMethods_((name, method) => {
  298.       goog.asserts.assert(this.playerProxy_, 'Must have player proxy!');
  299.       Object.defineProperty(this.playerProxy_, name, {
  300.         configurable: false,
  301.         enumerable: true,
  302.         get: () => this.playerProxyGet_(name),
  303.       });
  304.     });
  306.     if (COMPILED) {
  307.       this.mapCompiledToUncompiledPlayerMethodNames_();
  308.     }
  310.     this.videoEventTarget_ = new shaka.util.FakeEventTarget();
  311.     this.videoEventTarget_.dispatchTarget =
  312.       /** @type {EventTarget} */(this.videoProxy_);
  314.     this.playerEventTarget_ = new shaka.util.FakeEventTarget();
  315.     this.playerEventTarget_.dispatchTarget =
  316.       /** @type {EventTarget} */(this.playerProxy_);
  317.   }
  320.   /**
  321.    * Maps compiled to uncompiled player names so we can figure out
  322.    * which method to call in compiled build, while casting.
  323.    * @private
  324.    */
  325.   mapCompiledToUncompiledPlayerMethodNames_() {
  326.     // In compiled mode, UI tries to access player methods by their internal
  327.     // renamed names, but the proxy object doesn't know about those.  See
  328.     // https://github.com/shaka-project/shaka-player/issues/2130 for details.
  329.     const methodsToNames = new Map();
  330.     this.iterateOverPlayerMethods_((name, method) => {
  331.       if (methodsToNames.has(method)) {
  332.         // If two method names, point to the same method, add them to the
  333.         // map as aliases of each other.
  334.         const name2 = methodsToNames.get(method);
  335.         // Assumes that the compiled name is shorter
  336.         if (name.length < name2.length) {
  337.           this.compiledToExternNames_.set(name, name2);
  338.         } else {
  339.           this.compiledToExternNames_.set(name2, name);
  340.         }
  341.       } else {
  342.         methodsToNames.set(method, name);
  343.       }
  344.     });
  345.   }
  347.   /**
  348.    * Iterates over all of the methods of the player, including inherited methods
  349.    * from FakeEventTarget.
  350.    * @param {function(string, function())} operation
  351.    * @private
  352.    */
  353.   iterateOverPlayerMethods_(operation) {
  354.     goog.asserts.assert(this.localPlayer_, 'Must have player!');
  355.     const player = /** @type {!Object} */ (this.localPlayer_);
  356.     // Avoid accessing any over-written methods in the prototype chain.
  357.     const seenNames = new Set();
  359.     /**
  360.      * @param {string} name
  361.      * @return {boolean}
  362.      */
  363.     function shouldAddToTheMap(name) {
  364.       if (name == 'constructor') {
  365.         // Don't proxy the constructor.
  366.         return false;
  367.       }
  369.       const method = /** @type {Object} */(player)[name];
  370.       if (typeof method != 'function') {
  371.         // Don't proxy non-methods.
  372.         return false;
  373.       }
  375.       // Add if the map does not already have it
  376.       return !seenNames.has(name);
  377.     }
  379.     // First, look at the methods on the object itself, so this can properly
  380.     // proxy any methods not on the prototype (for example, in the mock player).
  381.     for (const key in player) {
  382.       if (shouldAddToTheMap(key)) {
  383.         seenNames.add(key);
  384.         operation(key, player[key]);
  385.       }
  386.     }
  388.     // The exact length of the prototype chain might vary; for resiliency, this
  389.     // will just look at the entire chain, rather than assuming a set length.
  390.     let proto = /** @type {!Object} */ (Object.getPrototypeOf(player));
  391.     const objProto = /** @type {!Object} */ (Object.getPrototypeOf({}));
  392.     while (proto && proto != objProto) { // Don't proxy Object methods.
  393.       for (const name of Object.getOwnPropertyNames(proto)) {
  394.         if (shouldAddToTheMap(name)) {
  395.           seenNames.add(name);
  396.           operation(name, (player)[name]);
  397.         }
  398.       }
  399.       proto = /** @type {!Object} */ (Object.getPrototypeOf(proto));
  400.     }
  401.   }
  403.   /**
  404.    * @return {shaka.cast.CastUtils.InitStateType} initState Video and player
  405.    *   state to be sent to the receiver.
  406.    * @private
  407.    */
  408.   getInitState_() {
  409.     const initState = {
  410.       'video': {},
  411.       'player': {},
  412.       'playerAfterLoad': {},
  413.       'manifest': this.localPlayer_.getAssetUri(),
  414.       'startTime': null,
  415.     };
  417.     // Pause local playback before capturing state.
  418.     this.localVideo_.pause();
  420.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  421.       initState['video'][name] = this.localVideo_[name];
  422.     }
  424.     // If the video is still playing, set the startTime.
  425.     // Has no effect if nothing is loaded.
  426.     if (!this.localVideo_.ended) {
  427.       initState['startTime'] = this.localVideo_.currentTime;
  428.     }
  430.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  431.       const getter = pair[0];
  432.       const setter = pair[1];
  433.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  435.       initState['player'][setter] = value;
  436.     }
  438.     for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  439.       const getter = pair[0];
  440.       const setter = pair[1];
  441.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  443.       initState['playerAfterLoad'][setter] = value;
  444.     }
  446.     return initState;
  447.   }
  449.   /**
  450.    * Dispatch an event to notify the app that the status has changed.
  451.    * @private
  452.    */
  453.   onCastStatusChanged_() {
  454.     const event = new shaka.util.FakeEvent('caststatuschanged');
  455.     this.dispatchEvent(event);
  456.   }
  458.   /**
  459.    * Dispatch a synthetic play or pause event to ensure that the app correctly
  460.    * knows that the player is playing, if joining an existing receiver.
  461.    * @private
  462.    */
  463.   onFirstCastStateUpdate_() {
  464.     const type = this.videoProxy_['paused'] ? 'pause' : 'play';
  465.     const fakeEvent = new shaka.util.FakeEvent(type);
  466.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  467.   }
  469.   /**
  470.    * Transfer remote state back and resume local playback.
  471.    * @private
  472.    */
  473.   onResumeLocal_() {
  474.     // Transfer back the player state.
  475.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  476.       const getter = pair[0];
  477.       const setter = pair[1];
  478.       const value = this.sender_.get('player', getter)();
  479.       /** @type {Object} */(this.localPlayer_)[setter](value);
  480.     }
  482.     // Get the most recent manifest URI and ended state.
  483.     const assetUri = this.sender_.get('player', 'getAssetUri')();
  484.     const ended = this.sender_.get('video', 'ended');
  486.     let manifestReady = Promise.resolve();
  487.     const autoplay = this.localVideo_.autoplay;
  489.     let startTime = null;
  491.     // If the video is still playing, set the startTime.
  492.     // Has no effect if nothing is loaded.
  493.     if (!ended) {
  494.       startTime = this.sender_.get('video', 'currentTime');
  495.     }
  497.     let activeTextTrack;
  498.     const textTracks = this.sender_.get('player', 'getTextTracks')();
  500.     if (textTracks && textTracks.length) {
  501.       activeTextTrack = textTracks.find((t) => t.active);
  502.     }
  504.     const isTextTrackVisible =
  505.         this.sender_.get('player', 'isTextTrackVisible')();
  507.     // Now load the manifest, if present.
  508.     if (assetUri) {
  509.       // Don't autoplay the content until we finish setting up initial state.
  510.       this.localVideo_.autoplay = false;
  511.       manifestReady = this.localPlayer_.load(assetUri, startTime);
  512.     }
  514.     // Get the video state into a temp variable since we will apply it async.
  515.     const videoState = {};
  516.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  517.       videoState[name] = this.sender_.get('video', name);
  518.     }
  520.     // Finally, take on video state and player's "after load" state.
  521.     manifestReady.then(() => {
  522.       if (!this.localVideo_) {
  523.         // We've already been destroyed.
  524.         return;
  525.       }
  527.       for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  528.         this.localVideo_[name] = videoState[name];
  529.       }
  531.       for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  532.         const getter = pair[0];
  533.         const setter = pair[1];
  534.         const value = this.sender_.get('player', getter)();
  535.         /** @type {Object} */(this.localPlayer_)[setter](value);
  536.       }
  538.       this.localPlayer_.setTextTrackVisibility(isTextTrackVisible);
  539.       if (activeTextTrack) {
  540.         this.localPlayer_.selectTextLanguage(
  541.             activeTextTrack.language,
  542.             activeTextTrack.roles,
  543.             activeTextTrack.forced);
  544.       }
  546.       // Restore the original autoplay setting.
  547.       this.localVideo_.autoplay = autoplay;
  548.       if (assetUri) {
  549.         // Resume playback with transferred state.
  550.         this.localVideo_.play();
  551.       }
  552.     }, (error) => {
  553.       // Pass any errors through to the app.
  554.       goog.asserts.assert(error instanceof shaka.util.Error,
  555.           'Wrong error type!');
  556.       const eventType = shaka.util.FakeEvent.EventName.Error;
  557.       const data = (new Map()).set('detail', error);
  558.       const event = new shaka.util.FakeEvent(eventType, data);
  559.       this.localPlayer_.dispatchEvent(event);
  560.     });
  561.   }
  563.   /**
  564.    * @param {string} name
  565.    * @return {?}
  566.    * @private
  567.    */
  568.   videoProxyGet_(name) {
  569.     if (name == 'addEventListener') {
  570.       return (type, listener, options) => {
  571.         return this.videoEventTarget_.addEventListener(type, listener, options);
  572.       };
  573.     }
  574.     if (name == 'removeEventListener') {
  575.       return (type, listener, options) => {
  576.         return this.videoEventTarget_.removeEventListener(
  577.             type, listener, options);
  578.       };
  579.     }
  581.     // If we are casting, but the first update has not come in yet, use local
  582.     // values, but not local methods.
  583.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  584.       const value = this.localVideo_[name];
  585.       if (typeof value != 'function') {
  586.         return value;
  587.       }
  588.     }
  590.     // Use local values and methods if we are not casting.
  591.     if (!this.sender_.isCasting()) {
  592.       let value = this.localVideo_[name];
  593.       if (typeof value == 'function') {
  594.         // eslint-disable-next-line no-restricted-syntax
  595.         value = value.bind(this.localVideo_);
  596.       }
  597.       return value;
  598.     }
  600.     return this.sender_.get('video', name);
  601.   }
  603.   /**
  604.    * @param {string} name
  605.    * @param {?} value
  606.    * @private
  607.    */
  608.   videoProxySet_(name, value) {
  609.     if (!this.sender_.isCasting()) {
  610.       this.localVideo_[name] = value;
  611.       return;
  612.     }
  614.     this.sender_.set('video', name, value);
  615.   }
  617.   /**
  618.    * @param {!Event} event
  619.    * @private
  620.    */
  621.   videoProxyLocalEvent_(event) {
  622.     if (this.sender_.isCasting()) {
  623.       // Ignore any unexpected local events while casting.  Events can still be
  624.       // fired by the local video and Player when we unload() after the Cast
  625.       // connection is complete.
  626.       return;
  627.     }
  629.     // Convert this real Event into a FakeEvent for dispatch from our
  630.     // FakeEventListener.
  631.     const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
  632.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  633.   }
  635.   /**
  636.    * @param {string} name
  637.    * @return {?}
  638.    * @private
  639.    */
  640.   playerProxyGet_(name) {
  641.     // If name is a shortened compiled name, get the original version
  642.     // from our map.
  643.     if (this.compiledToExternNames_.has(name)) {
  644.       name = this.compiledToExternNames_.get(name);
  645.     }
  647.     if (name == 'addEventListener') {
  648.       return (type, listener, options) => {
  649.         return this.playerEventTarget_.addEventListener(
  650.             type, listener, options);
  651.       };
  652.     }
  653.     if (name == 'removeEventListener') {
  654.       return (type, listener, options) => {
  655.         return this.playerEventTarget_.removeEventListener(
  656.             type, listener, options);
  657.       };
  658.     }
  660.     if (name == 'getMediaElement') {
  661.       return () => this.videoProxy_;
  662.     }
  664.     if (name == 'getSharedConfiguration') {
  665.       shaka.log.warning(
  666.           'Can\'t share configuration across a network. Returning copy.');
  667.       return this.sender_.get('player', 'getConfiguration');
  668.     }
  670.     if (name == 'getNetworkingEngine') {
  671.       // Always returns a local instance, in case you need to make a request.
  672.       // Issues a warning, in case you think you are making a remote request
  673.       // or affecting remote filters.
  674.       if (this.sender_.isCasting()) {
  675.         shaka.log.warning('NOTE: getNetworkingEngine() is always local!');
  676.       }
  677.       return () => this.localPlayer_.getNetworkingEngine();
  678.     }
  680.     if (name == 'getDrmEngine') {
  681.       // Always returns a local instance.
  682.       if (this.sender_.isCasting()) {
  683.         shaka.log.warning('NOTE: getDrmEngine() is always local!');
  684.       }
  685.       return () => this.localPlayer_.getDrmEngine();
  686.     }
  688.     if (name == 'getAdManager') {
  689.       // Always returns a local instance.
  690.       if (this.sender_.isCasting()) {
  691.         shaka.log.warning('NOTE: getAdManager() is always local!');
  692.       }
  693.       return () => this.localPlayer_.getAdManager();
  694.     }
  696.     if (name == 'setVideoContainer') {
  697.       // Always returns a local instance.
  698.       if (this.sender_.isCasting()) {
  699.         shaka.log.warning('NOTE: setVideoContainer() is always local!');
  700.       }
  701.       return (container) => this.localPlayer_.setVideoContainer(container);
  702.     }
  704.     if (this.sender_.isCasting()) {
  705.       // These methods are unavailable or otherwise stubbed during casting.
  706.       if (name == 'getManifest' || name == 'drmInfo') {
  707.         return () => {
  708.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  709.           return null;
  710.         };
  711.       }
  713.       if (name == 'attach' || name == 'detach') {
  714.         return () => {
  715.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  716.           return Promise.resolve();
  717.         };
  718.       }
  719.     }  // if (this.sender_.isCasting())
  721.     // If we are casting, but the first update has not come in yet, use local
  722.     // getters, but not local methods.
  723.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  724.       if (shaka.cast.CastUtils.PlayerGetterMethods[name] ||
  725.           shaka.cast.CastUtils.LargePlayerGetterMethods[name]) {
  726.         const value = /** @type {Object} */(this.localPlayer_)[name];
  727.         goog.asserts.assert(typeof value == 'function',
  728.             'only methods on Player');
  729.         // eslint-disable-next-line no-restricted-syntax
  730.         return value.bind(this.localPlayer_);
  731.       }
  732.     }
  734.     // Use local getters and methods if we are not casting.
  735.     if (!this.sender_.isCasting()) {
  736.       const value = /** @type {Object} */(this.localPlayer_)[name];
  737.       goog.asserts.assert(typeof value == 'function',
  738.           'only methods on Player');
  739.       // eslint-disable-next-line no-restricted-syntax
  740.       return value.bind(this.localPlayer_);
  741.     }
  743.     return this.sender_.get('player', name);
  744.   }
  746.   /**
  747.    * @param {!Event} event
  748.    * @private
  749.    */
  750.   playerProxyLocalEvent_(event) {
  751.     if (this.sender_.isCasting()) {
  752.       // Ignore any unexpected local events while casting.
  753.       return;
  754.     }
  756.     this.playerEventTarget_.dispatchEvent(event);
  757.   }
  759.   /**
  760.    * @param {string} targetName
  761.    * @param {!shaka.util.FakeEvent} event
  762.    * @private
  763.    */
  764.   onRemoteEvent_(targetName, event) {
  765.     goog.asserts.assert(this.sender_.isCasting(),
  766.         'Should only receive remote events while casting');
  767.     if (!this.sender_.isCasting()) {
  768.       // Ignore any unexpected remote events.
  769.       return;
  770.     }
  772.     if (targetName == 'video') {
  773.       this.videoEventTarget_.dispatchEvent(event);
  774.     } else if (targetName == 'player') {
  775.       this.playerEventTarget_.dispatchEvent(event);
  776.     }
  777.   }
  778. };