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 {!Array<?>} */
  81.     this.addThumbnailsTrackCalls_ = [];
  83.     /** @private {!Array<?>} */
  84.     this.addTextTrackAsyncCalls_ = [];
  86.     /** @private {!Array<?>} */
  87.     this.addChaptersTrackCalls_ = [];
  89.     /** @private {!Map} */
  90.     this.compiledToExternNames_ = new Map();
  92.     /** @private {shaka.cast.CastSender} */
  93.     this.sender_ = null;
  95.     if (window.chrome) {
  96.       this.sender_ = new shaka.cast.CastSender(
  97.           receiverAppId,
  98.           () => this.onCastStatusChanged_(),
  99.           () => this.onFirstCastStateUpdate_(),
  100.           (targetName, event) => this.onRemoteEvent_(targetName, event),
  101.           () => this.onResumeLocal_(),
  102.           () => this.getInitState_(),
  103.           androidReceiverCompatible);
  104.       this.init_();
  105.     } else {
  106.       this.initWithoutSender_();
  107.     }
  108.   }
  110.   /**
  111.    * Destroys the proxy and the underlying local Player.
  112.    *
  113.    * @param {boolean=} forceDisconnect If true, force the receiver app to shut
  114.    *   down by disconnecting.  Does nothing if not connected.
  115.    * @override
  116.    * @export
  117.    */
  118.   destroy(forceDisconnect = false) {
  119.     if (this.sender_ && forceDisconnect) {
  120.       this.sender_.forceDisconnect();
  121.     }
  123.     if (this.eventManager_) {
  124.       this.eventManager_.release();
  125.       this.eventManager_ = null;
  126.     }
  128.     const waitFor = [];
  129.     if (this.localPlayer_) {
  130.       waitFor.push(this.localPlayer_.destroy());
  131.       this.localPlayer_ = null;
  132.     }
  134.     if (this.sender_) {
  135.       waitFor.push(this.sender_.destroy());
  136.       this.sender_ = null;
  137.     }
  139.     this.localVideo_ = null;
  140.     this.videoProxy_ = null;
  141.     this.playerProxy_ = null;
  143.     // FakeEventTarget implements IReleasable
  144.     super.release();
  146.     return Promise.all(waitFor);
  147.   }
  149.   /**
  150.    * Get a proxy for the video element that delegates to local and remote video
  151.    * elements as appropriate.
  152.    *
  153.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  154.    * @return {!HTMLMediaElement}
  155.    * @export
  156.    */
  157.   getVideo() {
  158.     return /** @type {!HTMLMediaElement} */(this.videoProxy_);
  159.   }
  161.   /**
  162.    * Get a proxy for the Player that delegates to local and remote Player
  163.    * objects as appropriate.
  164.    *
  165.    * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  166.    * @return {!shaka.Player}
  167.    * @export
  168.    */
  169.   getPlayer() {
  170.     return /** @type {!shaka.Player} */(this.playerProxy_);
  171.   }
  173.   /**
  174.    * @return {boolean} True if the cast API is available and there are
  175.    *   receivers.
  176.    * @export
  177.    */
  178.   canCast() {
  179.     if (!this.sender_) {
  180.       return false;
  181.     }
  182.     return this.sender_.apiReady() && this.sender_.hasReceivers();
  183.   }
  185.   /**
  186.    * @return {boolean} True if we are currently casting.
  187.    * @export
  188.    */
  189.   isCasting() {
  190.     if (!this.sender_) {
  191.       return false;
  192.     }
  193.     return this.sender_.isCasting();
  194.   }
  196.   /**
  197.    * @return {string} The name of the Cast receiver device, if isCasting().
  198.    * @export
  199.    */
  200.   receiverName() {
  201.     if (!this.sender_) {
  202.       return '';
  203.     }
  204.     return this.sender_.receiverName();
  205.   }
  207.   /**
  208.    * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  209.    *   connection fails or is canceled by the user.
  210.    * @export
  211.    */
  212.   async cast() {
  213.     if (!this.sender_) {
  214.       return;
  215.     }
  216.     // TODO: transfer manually-selected tracks?
  218.     await this.sender_.cast();
  219.     if (!this.localPlayer_) {
  220.       // We've already been destroyed.
  221.       return;
  222.     }
  224.     // Unload the local manifest when casting succeeds.
  225.     await this.localPlayer_.unload();
  226.   }
  228.   /**
  229.    * Set application-specific data.
  230.    *
  231.    * @param {Object} appData Application-specific data to relay to the receiver.
  232.    * @export
  233.    */
  234.   setAppData(appData) {
  235.     if (!this.sender_) {
  236.       return;
  237.     }
  238.     this.sender_.setAppData(appData);
  239.   }
  241.   /**
  242.    * Show a dialog where user can choose to disconnect from the cast connection.
  243.    * @export
  244.    */
  245.   suggestDisconnect() {
  246.     if (!this.sender_) {
  247.       return;
  248.     }
  249.     this.sender_.showDisconnectDialog();
  250.   }
  252.   /**
  253.    * Force the receiver app to shut down by disconnecting.
  254.    * @export
  255.    */
  256.   forceDisconnect() {
  257.     if (!this.sender_) {
  258.       return;
  259.     }
  260.     this.sender_.forceDisconnect();
  261.   }
  264.   /**
  265.    * @param {string} newAppId
  266.    * @param {boolean=} newCastAndroidReceiver
  267.    * @export
  268.    */
  269.   async changeReceiverId(newAppId, newCastAndroidReceiver = false) {
  270.     if (newAppId == this.receiverAppId_ &&
  271.         newCastAndroidReceiver == this.androidReceiverCompatible_) {
  272.       // Nothing to change
  273.       return;
  274.     }
  276.     this.receiverAppId_ = newAppId;
  277.     this.androidReceiverCompatible_ = newCastAndroidReceiver;
  279.     if (!this.sender_) {
  280.       return;
  281.     }
  283.     // Destroy the old sender
  284.     this.sender_.forceDisconnect();
  285.     await this.sender_.destroy();
  286.     this.sender_ = null;
  289.     // Create the new one
  290.     this.sender_ = new shaka.cast.CastSender(
  291.         newAppId,
  292.         () => this.onCastStatusChanged_(),
  293.         () => this.onFirstCastStateUpdate_(),
  294.         (targetName, event) => this.onRemoteEvent_(targetName, event),
  295.         () => this.onResumeLocal_(),
  296.         () => this.getInitState_(),
  297.         newCastAndroidReceiver);
  299.     this.sender_.init();
  300.   }
  302.   /**
  303.    * Initialize the Proxies without Cast sender.
  304.    * @private
  305.    */
  306.   initWithoutSender_() {
  307.     this.videoProxy_ = /** @type {Object} */(this.localVideo_);
  308.     this.playerProxy_ = /** @type {Object} */(this.localPlayer_);
  309.   }
  311.   /**
  312.    * Initialize the Proxies and the Cast sender.
  313.    * @private
  314.    */
  315.   init_() {
  316.     this.sender_.init();
  318.     this.eventManager_ = new shaka.util.EventManager();
  320.     for (const name of shaka.cast.CastUtils.VideoEvents) {
  321.       this.eventManager_.listen(this.localVideo_, name,
  322.           (event) => this.videoProxyLocalEvent_(event));
  323.     }
  325.     for (const key in shaka.util.FakeEvent.EventName) {
  326.       const name = shaka.util.FakeEvent.EventName[key];
  327.       this.eventManager_.listen(this.localPlayer_, name,
  328.           (event) => this.playerProxyLocalEvent_(event));
  329.     }
  331.     // We would like to use Proxy here, but it is not supported on Safari.
  332.     this.videoProxy_ = {};
  333.     for (const k in this.localVideo_) {
  334.       Object.defineProperty(this.videoProxy_, k, {
  335.         configurable: false,
  336.         enumerable: true,
  337.         get: () => this.videoProxyGet_(k),
  338.         set: (value) => { this.videoProxySet_(k, value); },
  339.       });
  340.     }
  342.     this.playerProxy_ = {};
  343.     this.iterateOverPlayerMethods_((name, method) => {
  344.       goog.asserts.assert(this.playerProxy_, 'Must have player proxy!');
  345.       Object.defineProperty(this.playerProxy_, name, {
  346.         configurable: false,
  347.         enumerable: true,
  348.         get: () => this.playerProxyGet_(name),
  349.       });
  350.     });
  352.     if (COMPILED) {
  353.       this.mapCompiledToUncompiledPlayerMethodNames_();
  354.     }
  356.     this.videoEventTarget_ = new shaka.util.FakeEventTarget();
  357.     this.videoEventTarget_.dispatchTarget =
  358.       /** @type {EventTarget} */(this.videoProxy_);
  360.     this.playerEventTarget_ = new shaka.util.FakeEventTarget();
  361.     this.playerEventTarget_.dispatchTarget =
  362.       /** @type {EventTarget} */(this.playerProxy_);
  364.     this.eventManager_.listen(this.localPlayer_,
  365.         shaka.util.FakeEvent.EventName.Unloading, () => {
  366.           if (this.sender_ && this.sender_.isCasting()) {
  367.             return;
  368.           }
  369.           this.resetExternalTracks();
  370.         });
  371.   }
  374.   /**
  375.    * Maps compiled to uncompiled player names so we can figure out
  376.    * which method to call in compiled build, while casting.
  377.    * @private
  378.    */
  379.   mapCompiledToUncompiledPlayerMethodNames_() {
  380.     // In compiled mode, UI tries to access player methods by their internal
  381.     // renamed names, but the proxy object doesn't know about those.  See
  382.     // https://github.com/shaka-project/shaka-player/issues/2130 for details.
  383.     const methodsToNames = new Map();
  384.     this.iterateOverPlayerMethods_((name, method) => {
  385.       if (methodsToNames.has(method)) {
  386.         // If two method names, point to the same method, add them to the
  387.         // map as aliases of each other.
  388.         const name2 = methodsToNames.get(method);
  389.         // Assumes that the compiled name is shorter
  390.         if (name.length < name2.length) {
  391.           this.compiledToExternNames_.set(name, name2);
  392.         } else {
  393.           this.compiledToExternNames_.set(name2, name);
  394.         }
  395.       } else {
  396.         methodsToNames.set(method, name);
  397.       }
  398.     });
  399.   }
  401.   /**
  402.    * Iterates over all of the methods of the player, including inherited methods
  403.    * from FakeEventTarget.
  404.    * @param {function(string, function())} operation
  405.    * @private
  406.    */
  407.   iterateOverPlayerMethods_(operation) {
  408.     goog.asserts.assert(this.localPlayer_, 'Must have player!');
  409.     const player = /** @type {!Object} */ (this.localPlayer_);
  410.     // Avoid accessing any over-written methods in the prototype chain.
  411.     const seenNames = new Set();
  413.     /**
  414.      * @param {string} name
  415.      * @return {boolean}
  416.      */
  417.     function shouldAddToTheMap(name) {
  418.       if (name == 'constructor') {
  419.         // Don't proxy the constructor.
  420.         return false;
  421.       }
  423.       const method = /** @type {Object} */(player)[name];
  424.       if (typeof method != 'function') {
  425.         // Don't proxy non-methods.
  426.         return false;
  427.       }
  429.       // Add if the map does not already have it
  430.       return !seenNames.has(name);
  431.     }
  433.     // First, look at the methods on the object itself, so this can properly
  434.     // proxy any methods not on the prototype (for example, in the mock player).
  435.     for (const key in player) {
  436.       if (shouldAddToTheMap(key)) {
  437.         seenNames.add(key);
  438.         operation(key, player[key]);
  439.       }
  440.     }
  442.     // The exact length of the prototype chain might vary; for resiliency, this
  443.     // will just look at the entire chain, rather than assuming a set length.
  444.     let proto = /** @type {!Object} */ (Object.getPrototypeOf(player));
  445.     const objProto = /** @type {!Object} */ (Object.getPrototypeOf({}));
  446.     while (proto && proto != objProto) { // Don't proxy Object methods.
  447.       for (const name of Object.getOwnPropertyNames(proto)) {
  448.         if (shouldAddToTheMap(name)) {
  449.           seenNames.add(name);
  450.           operation(name, (player)[name]);
  451.         }
  452.       }
  453.       proto = /** @type {!Object} */ (Object.getPrototypeOf(proto));
  454.     }
  455.   }
  457.   /**
  458.    * @return {shaka.cast.CastUtils.InitStateType} initState Video and player
  459.    *   state to be sent to the receiver.
  460.    * @private
  461.    */
  462.   getInitState_() {
  463.     const initState = {
  464.       'video': {},
  465.       'player': {},
  466.       'playerAfterLoad': {},
  467.       'manifest': this.localPlayer_.getAssetUri(),
  468.       'startTime': null,
  469.       'addThumbnailsTrackCalls': this.addThumbnailsTrackCalls_,
  470.       'addTextTrackAsyncCalls': this.addTextTrackAsyncCalls_,
  471.       'addChaptersTrackCalls': this.addChaptersTrackCalls_,
  472.     };
  474.     // Pause local playback before capturing state.
  475.     this.localVideo_.pause();
  477.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  478.       initState['video'][name] = this.localVideo_[name];
  479.     }
  481.     // If the video is still playing, set the startTime.
  482.     // Has no effect if nothing is loaded.
  483.     if (!this.localVideo_.ended) {
  484.       initState['startTime'] = this.localVideo_.currentTime;
  485.     }
  487.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  488.       const getter = pair[0];
  489.       const setter = pair[1];
  490.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  492.       initState['player'][setter] = value;
  493.     }
  495.     for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  496.       const getter = pair[0];
  497.       const setter = pair[1];
  498.       const value = /** @type {Object} */(this.localPlayer_)[getter]();
  500.       initState['playerAfterLoad'][setter] = value;
  501.     }
  503.     return initState;
  504.   }
  506.   /**
  507.    * Dispatch an event to notify the app that the status has changed.
  508.    * @private
  509.    */
  510.   onCastStatusChanged_() {
  511.     const event = new shaka.util.FakeEvent('caststatuschanged');
  512.     this.dispatchEvent(event);
  513.   }
  515.   /**
  516.    * Dispatch a synthetic play or pause event to ensure that the app correctly
  517.    * knows that the player is playing, if joining an existing receiver.
  518.    * @private
  519.    */
  520.   onFirstCastStateUpdate_() {
  521.     const type = this.videoProxy_['paused'] ? 'pause' : 'play';
  522.     const fakeEvent = new shaka.util.FakeEvent(type);
  523.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  524.   }
  526.   /**
  527.    * Transfer remote state back and resume local playback.
  528.    * @private
  529.    */
  530.   onResumeLocal_() {
  531.     // Transfer back the player state.
  532.     for (const pair of shaka.cast.CastUtils.PlayerInitState) {
  533.       const getter = pair[0];
  534.       const setter = pair[1];
  535.       const value = this.sender_.get('player', getter)();
  536.       /** @type {Object} */(this.localPlayer_)[setter](value);
  537.     }
  539.     const addThumbnailsTrackCalls = this.addThumbnailsTrackCalls_;
  540.     const addTextTrackAsyncCalls = this.addTextTrackAsyncCalls_;
  541.     const addChaptersTrackCalls = this.addChaptersTrackCalls_;
  543.     this.resetExternalTracks();
  545.     // Get the most recent manifest URI and ended state.
  546.     const assetUri = this.sender_.get('player', 'getAssetUri')();
  547.     const ended = this.sender_.get('video', 'ended');
  549.     let manifestReady = Promise.resolve();
  550.     const autoplay = this.localVideo_.autoplay;
  552.     let startTime = null;
  554.     // If the video is still playing, set the startTime.
  555.     // Has no effect if nothing is loaded.
  556.     if (!ended) {
  557.       startTime = this.sender_.get('video', 'currentTime');
  558.     }
  560.     let activeTextTrack;
  561.     const textTracks = this.sender_.get('player', 'getTextTracks')();
  563.     if (textTracks && textTracks.length) {
  564.       activeTextTrack = textTracks.find((t) => t.active);
  565.     }
  567.     const isTextTrackVisible =
  568.         this.sender_.get('player', 'isTextTrackVisible')();
  570.     // Now load the manifest, if present.
  571.     if (assetUri) {
  572.       // Don't autoplay the content until we finish setting up initial state.
  573.       this.localVideo_.autoplay = false;
  574.       manifestReady = this.localPlayer_.load(assetUri, startTime);
  575.     }
  577.     // Get the video state into a temp variable since we will apply it async.
  578.     const videoState = {};
  579.     for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  580.       videoState[name] = this.sender_.get('video', name);
  581.     }
  583.     // Finally, take on video state and player's "after load" state.
  584.     manifestReady.then(() => {
  585.       if (!this.localVideo_) {
  586.         // We've already been destroyed.
  587.         return;
  588.       }
  590.       for (const args of addThumbnailsTrackCalls) {
  591.         this.getPlayer().addThumbnailsTrack(...args);
  592.       }
  593.       for (const args of addTextTrackAsyncCalls) {
  594.         this.getPlayer().addTextTrackAsync(...args);
  595.       }
  596.       for (const args of addChaptersTrackCalls) {
  597.         this.getPlayer().addChaptersTrack(...args);
  598.       }
  600.       for (const name of shaka.cast.CastUtils.VideoInitStateAttributes) {
  601.         this.localVideo_[name] = videoState[name];
  602.       }
  604.       for (const pair of shaka.cast.CastUtils.PlayerInitAfterLoadState) {
  605.         const getter = pair[0];
  606.         const setter = pair[1];
  607.         const value = this.sender_.get('player', getter)();
  608.         /** @type {Object} */(this.localPlayer_)[setter](value);
  609.       }
  611.       this.localPlayer_.setTextTrackVisibility(isTextTrackVisible);
  612.       if (activeTextTrack) {
  613.         this.localPlayer_.selectTextLanguage(
  614.             activeTextTrack.language,
  615.             activeTextTrack.roles,
  616.             activeTextTrack.forced);
  617.       }
  619.       // Restore the original autoplay setting.
  620.       this.localVideo_.autoplay = autoplay;
  621.       if (assetUri) {
  622.         // Resume playback with transferred state.
  623.         this.localVideo_.play();
  624.       }
  625.     }, (error) => {
  626.       // Pass any errors through to the app.
  627.       goog.asserts.assert(error instanceof shaka.util.Error,
  628.           'Wrong error type!');
  629.       const eventType = shaka.util.FakeEvent.EventName.Error;
  630.       const data = (new Map()).set('detail', error);
  631.       const event = new shaka.util.FakeEvent(eventType, data);
  632.       this.localPlayer_.dispatchEvent(event);
  633.     });
  634.   }
  636.   /**
  637.    * @param {string} name
  638.    * @return {?}
  639.    * @private
  640.    */
  641.   videoProxyGet_(name) {
  642.     if (name == 'addEventListener') {
  643.       return (type, listener, options) => {
  644.         return this.videoEventTarget_.addEventListener(type, listener, options);
  645.       };
  646.     }
  647.     if (name == 'removeEventListener') {
  648.       return (type, listener, options) => {
  649.         return this.videoEventTarget_.removeEventListener(
  650.             type, listener, options);
  651.       };
  652.     }
  654.     // If we are casting, but the first update has not come in yet, use local
  655.     // values, but not local methods.
  656.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  657.       const value = this.localVideo_[name];
  658.       if (typeof value != 'function') {
  659.         return value;
  660.       }
  661.     }
  663.     // Use local values and methods if we are not casting.
  664.     if (!this.sender_.isCasting()) {
  665.       let value = this.localVideo_[name];
  666.       if (typeof value == 'function') {
  667.         // eslint-disable-next-line no-restricted-syntax
  668.         value = value.bind(this.localVideo_);
  669.       }
  670.       return value;
  671.     }
  673.     return this.sender_.get('video', name);
  674.   }
  676.   /**
  677.    * @param {string} name
  678.    * @param {?} value
  679.    * @private
  680.    */
  681.   videoProxySet_(name, value) {
  682.     if (!this.sender_.isCasting()) {
  683.       this.localVideo_[name] = value;
  684.       return;
  685.     }
  687.     this.sender_.set('video', name, value);
  688.   }
  690.   /**
  691.    * @param {!Event} event
  692.    * @private
  693.    */
  694.   videoProxyLocalEvent_(event) {
  695.     if (this.sender_.isCasting()) {
  696.       // Ignore any unexpected local events while casting.  Events can still be
  697.       // fired by the local video and Player when we unload() after the Cast
  698.       // connection is complete.
  699.       return;
  700.     }
  702.     // Convert this real Event into a FakeEvent for dispatch from our
  703.     // FakeEventListener.
  704.     const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
  705.     this.videoEventTarget_.dispatchEvent(fakeEvent);
  706.   }
  708.   /**
  709.    * @param {string} name
  710.    * @param {boolean} dontRecordCalls
  711.    * @return {?}
  712.    * @private
  713.    */
  714.   playerProxyGet_(name, dontRecordCalls = false) {
  715.     // If name is a shortened compiled name, get the original version
  716.     // from our map.
  717.     if (this.compiledToExternNames_.has(name)) {
  718.       name = this.compiledToExternNames_.get(name);
  719.     }
  721.     if (name == 'addEventListener') {
  722.       return (type, listener, options) => {
  723.         return this.playerEventTarget_.addEventListener(
  724.             type, listener, options);
  725.       };
  726.     }
  727.     if (name == 'removeEventListener') {
  728.       return (type, listener, options) => {
  729.         return this.playerEventTarget_.removeEventListener(
  730.             type, listener, options);
  731.       };
  732.     }
  734.     if (name == 'getMediaElement') {
  735.       return () => this.videoProxy_;
  736.     }
  738.     if (name == 'getSharedConfiguration') {
  739.       shaka.log.warning(
  740.           'Can\'t share configuration across a network. Returning copy.');
  741.       return this.sender_.get('player', 'getConfiguration');
  742.     }
  744.     if (name == 'getNetworkingEngine') {
  745.       // Always returns a local instance, in case you need to make a request.
  746.       // Issues a warning, in case you think you are making a remote request
  747.       // or affecting remote filters.
  748.       if (this.sender_.isCasting()) {
  749.         shaka.log.warning('NOTE: getNetworkingEngine() is always local!');
  750.       }
  751.       return () => this.localPlayer_.getNetworkingEngine();
  752.     }
  754.     if (name == 'getDrmEngine') {
  755.       // Always returns a local instance.
  756.       if (this.sender_.isCasting()) {
  757.         shaka.log.warning('NOTE: getDrmEngine() is always local!');
  758.       }
  759.       return () => this.localPlayer_.getDrmEngine();
  760.     }
  762.     if (name == 'getAdManager') {
  763.       // Always returns a local instance.
  764.       if (this.sender_.isCasting()) {
  765.         shaka.log.warning('NOTE: getAdManager() is always local!');
  766.       }
  767.       return () => this.localPlayer_.getAdManager();
  768.     }
  770.     if (name == 'getQueueManager') {
  771.       // Always returns a local instance.
  772.       return () => this.localPlayer_.getQueueManager();
  773.     }
  775.     if (name == 'setVideoContainer') {
  776.       // Always returns a local instance.
  777.       if (this.sender_.isCasting()) {
  778.         shaka.log.warning('NOTE: setVideoContainer() is always local!');
  779.       }
  780.       return (container) => this.localPlayer_.setVideoContainer(container);
  781.     }
  783.     if (!dontRecordCalls) {
  784.       if (name == 'addThumbnailsTrack') {
  785.         return (...args) => {
  786.           this.addThumbnailsTrackCalls_.push(args);
  787.           return this.playerProxyGet_(
  788.               name, /* dontRecordCalls= */ true)(...args);
  789.         };
  790.       }
  791.       if (name == 'addTextTrackAsync') {
  792.         return (...args) => {
  793.           this.addTextTrackAsyncCalls_.push(args);
  794.           return this.playerProxyGet_(
  795.               name, /* dontRecordCalls= */ true)(...args);
  796.         };
  797.       }
  798.       if (name == 'addChaptersTrack') {
  799.         return (...args) => {
  800.           this.addChaptersTrackCalls_.push(args);
  801.           return this.playerProxyGet_(
  802.               name, /* dontRecordCalls= */ true)(...args);
  803.         };
  804.       }
  805.     }
  807.     if (this.sender_.isCasting()) {
  808.       // These methods are unavailable or otherwise stubbed during casting.
  809.       if (name == 'getManifest' || name == 'drmInfo') {
  810.         return () => {
  811.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  812.           return null;
  813.         };
  814.       }
  816.       if (name == 'attach' || name == 'detach') {
  817.         return () => {
  818.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  819.           return Promise.resolve();
  820.         };
  821.       }
  823.       if (name == 'getChapters') {
  824.         // This does not follow our standard pattern (takes an arguments), and
  825.         // therefore can't be proactively proxied and cached the way other
  826.         // synchronous getters can.
  827.         return () => {
  828.           shaka.log.alwaysWarn(name + '() does not work while casting!');
  829.           return [];
  830.         };
  831.       }
  832.     }  // if (this.sender_.isCasting())
  834.     // If we are casting, but the first update has not come in yet, use local
  835.     // getters, but not local methods.
  836.     if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  837.       if (shaka.cast.CastUtils.PlayerGetterMethods.has(name) ||
  838.           shaka.cast.CastUtils.LargePlayerGetterMethods.has(name)) {
  839.         const value = /** @type {Object} */(this.localPlayer_)[name];
  840.         goog.asserts.assert(typeof value == 'function',
  841.             'only methods on Player');
  842.         // eslint-disable-next-line no-restricted-syntax
  843.         return value.bind(this.localPlayer_);
  844.       }
  845.     }
  847.     // Use local getters and methods if we are not casting.
  848.     if (!this.sender_.isCasting()) {
  849.       const value = /** @type {Object} */(this.localPlayer_)[name];
  850.       goog.asserts.assert(typeof value == 'function',
  851.           'only methods on Player');
  852.       // eslint-disable-next-line no-restricted-syntax
  853.       return value.bind(this.localPlayer_);
  854.     }
  856.     return this.sender_.get('player', name);
  857.   }
  859.   /**
  860.    * @param {!Event} event
  861.    * @private
  862.    */
  863.   playerProxyLocalEvent_(event) {
  864.     if (this.sender_.isCasting()) {
  865.       // Ignore any unexpected local events while casting.
  866.       return;
  867.     }
  869.     this.playerEventTarget_.dispatchEvent(event);
  870.   }
  872.   /**
  873.    * @param {string} targetName
  874.    * @param {!shaka.util.FakeEvent} event
  875.    * @private
  876.    */
  877.   onRemoteEvent_(targetName, event) {
  878.     goog.asserts.assert(this.sender_.isCasting(),
  879.         'Should only receive remote events while casting');
  880.     if (!this.sender_.isCasting()) {
  881.       // Ignore any unexpected remote events.
  882.       return;
  883.     }
  885.     if (targetName == 'video') {
  886.       this.videoEventTarget_.dispatchEvent(event);
  887.     } else if (targetName == 'player') {
  888.       if (event.type == shaka.util.FakeEvent.EventName.Unloading) {
  889.         this.resetExternalTracks();
  890.       }
  891.       this.playerEventTarget_.dispatchEvent(event);
  892.     }
  893.   }
  895.   /**
  896.    * Reset external tracks
  897.    */
  898.   resetExternalTracks() {
  899.     this.addThumbnailsTrackCalls_ = [];
  900.     this.addTextTrackAsyncCalls_ = [];
  901.     this.addChaptersTrackCalls_ = [];
  902.   }
  903. };