Source: lib/cast/cast_sender.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cast.CastSender');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.cast.CastUtils');
  11. goog.require('shaka.log');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.FakeEvent');
  14. goog.require('shaka.util.IDestroyable');
  15. goog.require('shaka.util.PublicPromise');
  16. goog.require('shaka.util.Timer');
  19. /**
  20.  * @implements {shaka.util.IDestroyable}
  21.  */
  22. shaka.cast.CastSender = class {
  23.   /**
  24.    * @param {string} receiverAppId The ID of the cast receiver application.
  25.    * @param {function()} onStatusChanged A callback invoked when the cast status
  26.    *   changes.
  27.    * @param {function()} onFirstCastStateUpdate A callback invoked when an
  28.    *   "update" event has been received for the first time.
  29.    * @param {function(string, !shaka.util.FakeEvent)} onRemoteEvent A callback
  30.    *   invoked with target name and event when a remote event is received.
  31.    * @param {function()} onResumeLocal A callback invoked when the local player
  32.    *   should resume playback.  Called before the cached remote state is wiped.
  33.    * @param {function()} onInitStateRequired A callback to get local player's.
  34.    *   state.  Invoked when casting is initiated from Chrome's cast button.
  35.    */
  36.   constructor(receiverAppId, onStatusChanged, onFirstCastStateUpdate,
  37.       onRemoteEvent, onResumeLocal, onInitStateRequired) {
  38.     /** @private {string} */
  39.     this.receiverAppId_ = receiverAppId;
  41.     /** @private {shaka.util.Timer} */
  42.     this.statusChangeTimer_ = new shaka.util.Timer(onStatusChanged);
  44.     /** @private {?function()} */
  45.     this.onFirstCastStateUpdate_ = onFirstCastStateUpdate;
  47.     /** @private {boolean} */
  48.     this.hasJoinedExistingSession_ = false;
  50.     /** @private {?function(string, !shaka.util.FakeEvent)} */
  51.     this.onRemoteEvent_ = onRemoteEvent;
  53.     /** @private {?function()} */
  54.     this.onResumeLocal_ = onResumeLocal;
  56.     /** @private {?function()} */
  57.     this.onInitStateRequired_ = onInitStateRequired;
  59.     /** @private {boolean} */
  60.     this.apiReady_ = false;
  62.     /** @private {boolean} */
  63.     this.isCasting_ = false;
  65.     /** @private {string} */
  66.     this.receiverName_ = '';
  68.     /** @private {Object} */
  69.     this.appData_ = null;
  71.     /** @private {?function()} */
  72.     this.onConnectionStatusChangedBound_ =
  73.         () => this.onConnectionStatusChanged_();
  75.     /** @private {?function(string, string)} */
  76.     this.onMessageReceivedBound_ = (namespace, serialized) =>
  77.       this.onMessageReceived_(namespace, serialized);
  79.     /** @private {Object} */
  80.     this.cachedProperties_ = {
  81.       'video': {},
  82.       'player': {},
  83.     };
  85.     /** @private {number} */
  86.     this.nextAsyncCallId_ = 0;
  88.     /** @private {Object.<string, !shaka.util.PublicPromise>} */
  89.     this.asyncCallPromises_ = {};
  91.     /** @private {shaka.util.PublicPromise} */
  92.     this.castPromise_ = null;
  94.     shaka.cast.CastSender.instances_.add(this);
  95.   }
  98.   /** @override */
  99.   destroy() {
  100.     shaka.cast.CastSender.instances_.delete(this);
  102.     this.rejectAllPromises_();
  103.     if (shaka.cast.CastSender.session_) {
  104.       this.removeListeners_();
  105.       // Don't leave the session, so that this session can be re-used later if
  106.       // necessary.
  107.     }
  109.     if (this.statusChangeTimer_) {
  110.       this.statusChangeTimer_.stop();
  111.       this.statusChangeTimer_ = null;
  112.     }
  114.     this.onRemoteEvent_ = null;
  115.     this.onResumeLocal_ = null;
  116.     this.apiReady_ = false;
  117.     this.isCasting_ = false;
  118.     this.appData_ = null;
  119.     this.cachedProperties_ = null;
  120.     this.asyncCallPromises_ = null;
  121.     this.castPromise_ = null;
  122.     this.onConnectionStatusChangedBound_ = null;
  123.     this.onMessageReceivedBound_ = null;
  125.     return Promise.resolve();
  126.   }
  129.   /**
  130.    * @return {boolean} True if the cast API is available.
  131.    */
  132.   apiReady() {
  133.     return this.apiReady_;
  134.   }
  137.   /**
  138.    * @return {boolean} True if there are receivers.
  139.    */
  140.   hasReceivers() {
  141.     return shaka.cast.CastSender.hasReceivers_;
  142.   }
  145.   /**
  146.    * @return {boolean} True if we are currently casting.
  147.    */
  148.   isCasting() {
  149.     return this.isCasting_;
  150.   }
  153.   /**
  154.    * @return {string} The name of the Cast receiver device, if isCasting().
  155.    */
  156.   receiverName() {
  157.     return this.receiverName_;
  158.   }
  161.   /**
  162.    * @return {boolean} True if we have a cache of remote properties from the
  163.    *   receiver.
  164.    */
  165.   hasRemoteProperties() {
  166.     return Object.keys(this.cachedProperties_['video']).length != 0;
  167.   }
  170.   /** Initialize the Cast API. */
  171.   init() {
  172.     const CastSender = shaka.cast.CastSender;
  174.     if (!this.receiverAppId_.length) {
  175.       // Return if no cast receiver id has been provided.
  176.       // Nothing will be initialized, no global hooks will be installed.
  177.       // If the receiver ID changes before this instance dies, init will be
  178.       // called again.
  179.       return;
  180.     }
  182.     // Check for the cast API.
  183.     if (!window.chrome || !chrome.cast || !chrome.cast.isAvailable) {
  184.       // If the API is not available on this platform or is not ready yet,
  185.       // install a hook to be notified when it becomes available.
  186.       // If the API becomes available before this instance dies, init will be
  187.       // called again.
  189.       // A note about this value: In our testing environment, we load both
  190.       // uncompiled and compiled code.  This global callback in uncompiled mode
  191.       // can be overwritten by the same in compiled mode.  The two versions will
  192.       // each have their own instances_ map.  Therefore the callback must have a
  193.       // name, as opposed to being anonymous.  This way, the CastSender tests
  194.       // can invoke the named static method instead of using a global that could
  195.       // be overwritten.
  196.       if (!window.__onGCastApiAvailable) {
  197.         window.__onGCastApiAvailable = shaka.cast.CastSender.onSdkLoaded_;
  198.       }
  199.       if (window.__onGCastApiAvailable != shaka.cast.CastSender.onSdkLoaded_) {
  200.         shaka.log.alwaysWarn('A global Cast SDK hook is already installed! ' +
  201.           'Shaka Player will be unable to receive a notification when the ' +
  202.           'Cast SDK is ready.');
  203.       }
  204.       return;
  205.     }
  207.     // The API is now available.
  208.     this.apiReady_ = true;
  209.     this.statusChangeTimer_.tickNow();
  211.     // Use static versions of the API callbacks, since the ChromeCast API is
  212.     // static. If we used local versions, we might end up retaining references
  213.     // to destroyed players here.
  214.     const sessionRequest = new chrome.cast.SessionRequest(this.receiverAppId_);
  215.     const apiConfig = new chrome.cast.ApiConfig(sessionRequest,
  216.         (session) => CastSender.onExistingSessionJoined_(session),
  217.         (availability) => CastSender.onReceiverStatusChanged_(availability),
  218.         'origin_scoped');
  220.     // TODO: Have never seen this fail.  When would it and how should we react?
  221.     chrome.cast.initialize(apiConfig,
  222.         () => { shaka.log.debug('CastSender: init'); },
  223.         (error) => { shaka.log.error('CastSender: init error', error); });
  224.     if (shaka.cast.CastSender.hasReceivers_) {
  225.       // Fire a fake cast status change, to simulate the update that
  226.       // would be fired normally.
  227.       // This is after a brief delay, to give users a chance to add event
  228.       // listeners.
  229.       this.statusChangeTimer_.tickAfter(shaka.cast.CastSender.STATUS_DELAY);
  230.     }
  232.     const oldSession = shaka.cast.CastSender.session_;
  233.     if (oldSession && oldSession.status != chrome.cast.SessionStatus.STOPPED) {
  234.       // The old session still exists, so re-use it.
  235.       shaka.log.debug('CastSender: re-using existing connection');
  236.       this.onExistingSessionJoined_(oldSession);
  237.     } else {
  238.       // The session has been canceled in the meantime, so ignore it.
  239.       shaka.cast.CastSender.session_ = null;
  240.     }
  241.   }
  244.   /**
  245.    * Set application-specific data.
  246.    *
  247.    * @param {Object} appData Application-specific data to relay to the receiver.
  248.    */
  249.   setAppData(appData) {
  250.     this.appData_ = appData;
  251.     if (this.isCasting_) {
  252.       this.sendMessage_({
  253.         'type': 'appData',
  254.         'appData': this.appData_,
  255.       });
  256.     }
  257.   }
  260.   /**
  261.    * @param {shaka.cast.CastUtils.InitStateType} initState Video and player
  262.    *   state to be sent to the receiver.
  263.    * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  264.    *   connection fails or is canceled by the user.
  265.    */
  266.   async cast(initState) {
  267.     if (!this.apiReady_) {
  268.       throw new shaka.util.Error(
  269.           shaka.util.Error.Severity.RECOVERABLE,
  270.           shaka.util.Error.Category.CAST,
  271.           shaka.util.Error.Code.CAST_API_UNAVAILABLE);
  272.     }
  273.     if (!shaka.cast.CastSender.hasReceivers_) {
  274.       throw new shaka.util.Error(
  275.           shaka.util.Error.Severity.RECOVERABLE,
  276.           shaka.util.Error.Category.CAST,
  277.           shaka.util.Error.Code.NO_CAST_RECEIVERS);
  278.     }
  279.     if (this.isCasting_) {
  280.       throw new shaka.util.Error(
  281.           shaka.util.Error.Severity.RECOVERABLE,
  282.           shaka.util.Error.Category.CAST,
  283.           shaka.util.Error.Code.ALREADY_CASTING);
  284.     }
  286.     this.castPromise_ = new shaka.util.PublicPromise();
  287.     chrome.cast.requestSession(
  288.         (session) => this.onSessionInitiated_(initState, session),
  289.         (error) => this.onConnectionError_(error));
  290.     await this.castPromise_;
  291.   }
  294.   /**
  295.    * Shows user a cast dialog where they can choose to stop
  296.    * casting.  Relies on Chrome to perform disconnect if they do.
  297.    * Doesn't do anything if not connected.
  298.    */
  299.   showDisconnectDialog() {
  300.     if (!this.isCasting_) {
  301.       return;
  302.     }
  303.     const initState = this.onInitStateRequired_();
  305.     chrome.cast.requestSession(
  306.         (session) => this.onSessionInitiated_(initState, session),
  307.         (error) => this.onConnectionError_(error));
  308.   }
  311.   /**
  312.    * Forces the receiver app to shut down by disconnecting.  Does nothing if not
  313.    * connected.
  314.    */
  315.   forceDisconnect() {
  316.     if (!this.isCasting_) {
  317.       return;
  318.     }
  320.     this.rejectAllPromises_();
  322.     if (shaka.cast.CastSender.session_) {
  323.       this.removeListeners_();
  325.       // This can throw if we've already been disconnected somehow.
  326.       try {
  327.         shaka.cast.CastSender.session_.stop(() => {}, () => {});
  328.       } catch (error) {}
  330.       shaka.cast.CastSender.session_ = null;
  331.     }
  333.     // Update casting status.
  334.     this.onConnectionStatusChanged_();
  335.   }
  338.   /**
  339.    * Getter for properties of remote objects.
  340.    * @param {string} targetName
  341.    * @param {string} property
  342.    * @return {?}
  343.    */
  344.   get(targetName, property) {
  345.     goog.asserts.assert(targetName == 'video' || targetName == 'player',
  346.         'Unexpected target name');
  347.     const CastUtils = shaka.cast.CastUtils;
  348.     if (targetName == 'video') {
  349.       if (CastUtils.VideoVoidMethods.includes(property)) {
  350.         return (...args) => this.remoteCall_(targetName, property, ...args);
  351.       }
  352.     } else if (targetName == 'player') {
  353.       if (CastUtils.PlayerGetterMethodsThatRequireLive[property]) {
  354.         const isLive = this.get('player', 'isLive')();
  355.         goog.asserts.assert(isLive,
  356.             property + ' should be called on a live stream!');
  357.         // If the property shouldn't exist, return a fake function so that the
  358.         // user doesn't call an undefined function and get a second error.
  359.         if (!isLive) {
  360.           return () => undefined;
  361.         }
  362.       }
  363.       if (CastUtils.PlayerVoidMethods.includes(property)) {
  364.         return (...args) => this.remoteCall_(targetName, property, ...args);
  365.       }
  366.       if (CastUtils.PlayerPromiseMethods.includes(property)) {
  367.         return (...args) =>
  368.           this.remoteAsyncCall_(targetName, property, ...args);
  369.       }
  370.       if (CastUtils.PlayerGetterMethods[property]) {
  371.         return () => this.propertyGetter_(targetName, property);
  372.       }
  373.     }
  375.     return this.propertyGetter_(targetName, property);
  376.   }
  379.   /**
  380.    * Setter for properties of remote objects.
  381.    * @param {string} targetName
  382.    * @param {string} property
  383.    * @param {?} value
  384.    */
  385.   set(targetName, property, value) {
  386.     goog.asserts.assert(targetName == 'video' || targetName == 'player',
  387.         'Unexpected target name');
  389.     this.cachedProperties_[targetName][property] = value;
  390.     this.sendMessage_({
  391.       'type': 'set',
  392.       'targetName': targetName,
  393.       'property': property,
  394.       'value': value,
  395.     });
  396.   }
  399.   /**
  400.    * @param {shaka.cast.CastUtils.InitStateType} initState
  401.    * @param {chrome.cast.Session} session
  402.    * @private
  403.    */
  404.   onSessionInitiated_(initState, session) {
  405.     shaka.log.debug('CastSender: onSessionInitiated');
  406.     this.onSessionCreated_(session);
  408.     this.sendMessage_({
  409.       'type': 'init',
  410.       'initState': initState,
  411.       'appData': this.appData_,
  412.     });
  414.     this.castPromise_.resolve();
  415.   }
  418.   /**
  419.    * @param {chrome.cast.Error} error
  420.    * @private
  421.    */
  422.   onConnectionError_(error) {
  423.     // Default error code:
  424.     let code = shaka.util.Error.Code.UNEXPECTED_CAST_ERROR;
  426.     switch (error.code) {
  427.       case 'cancel':
  428.         code = shaka.util.Error.Code.CAST_CANCELED_BY_USER;
  429.         break;
  430.       case 'timeout':
  431.         code = shaka.util.Error.Code.CAST_CONNECTION_TIMED_OUT;
  432.         break;
  433.       case 'receiver_unavailable':
  434.         code = shaka.util.Error.Code.CAST_RECEIVER_APP_UNAVAILABLE;
  435.         break;
  436.     }
  438.     this.castPromise_.reject(new shaka.util.Error(
  439.         shaka.util.Error.Severity.CRITICAL,
  440.         shaka.util.Error.Category.CAST,
  441.         code,
  442.         error));
  443.   }
  446.   /**
  447.    * @param {string} targetName
  448.    * @param {string} property
  449.    * @return {?}
  450.    * @private
  451.    */
  452.   propertyGetter_(targetName, property) {
  453.     goog.asserts.assert(targetName == 'video' || targetName == 'player',
  454.         'Unexpected target name');
  455.     return this.cachedProperties_[targetName][property];
  456.   }
  459.   /**
  460.    * @param {string} targetName
  461.    * @param {string} methodName
  462.    * @param {...*} varArgs
  463.    * @private
  464.    */
  465.   remoteCall_(targetName, methodName, ...varArgs) {
  466.     goog.asserts.assert(targetName == 'video' || targetName == 'player',
  467.         'Unexpected target name');
  468.     this.sendMessage_({
  469.       'type': 'call',
  470.       'targetName': targetName,
  471.       'methodName': methodName,
  472.       'args': varArgs,
  473.     });
  474.   }
  477.   /**
  478.    * @param {string} targetName
  479.    * @param {string} methodName
  480.    * @param {...*} varArgs
  481.    * @return {!Promise}
  482.    * @private
  483.    */
  484.   remoteAsyncCall_(targetName, methodName, ...varArgs) {
  485.     goog.asserts.assert(targetName == 'video' || targetName == 'player',
  486.         'Unexpected target name');
  488.     const p = new shaka.util.PublicPromise();
  489.     const id = this.nextAsyncCallId_.toString();
  490.     this.nextAsyncCallId_++;
  491.     this.asyncCallPromises_[id] = p;
  493.     try {
  494.       this.sendMessage_({
  495.         'type': 'asyncCall',
  496.         'targetName': targetName,
  497.         'methodName': methodName,
  498.         'args': varArgs,
  499.         'id': id,
  500.       });
  501.     } catch (error) {
  502.       p.reject(error);
  503.     }
  504.     return p;
  505.   }
  508.   /**
  509.    * A static version of onExistingSessionJoined_, that calls that method for
  510.    * each known instance.
  511.    * @param {chrome.cast.Session} session
  512.    * @private
  513.    */
  514.   static onExistingSessionJoined_(session) {
  515.     for (const instance of shaka.cast.CastSender.instances_) {
  516.       instance.onExistingSessionJoined_(session);
  517.     }
  518.   }
  521.   /**
  522.    * @param {chrome.cast.Session} session
  523.    * @private
  524.    */
  525.   onExistingSessionJoined_(session) {
  526.     shaka.log.debug('CastSender: onExistingSessionJoined');
  528.     const initState = this.onInitStateRequired_();
  530.     this.castPromise_ = new shaka.util.PublicPromise();
  531.     this.hasJoinedExistingSession_ = true;
  533.     this.onSessionInitiated_(initState, session);
  534.   }
  537.   /**
  538.    * A static version of onReceiverStatusChanged_, that calls that method for
  539.    * each known instance.
  540.    * @param {string} availability
  541.    * @private
  542.    */
  543.   static onReceiverStatusChanged_(availability) {
  544.     for (const instance of shaka.cast.CastSender.instances_) {
  545.       instance.onReceiverStatusChanged_(availability);
  546.     }
  547.   }
  550.   /**
  551.    * @param {string} availability
  552.    * @private
  553.    */
  554.   onReceiverStatusChanged_(availability) {
  555.     // The cast API is telling us whether there are any cast receiver devices
  556.     // available.
  557.     shaka.log.debug('CastSender: receiver status', availability);
  558.     shaka.cast.CastSender.hasReceivers_ = availability == 'available';
  559.     this.statusChangeTimer_.tickNow();
  560.   }
  563.   /**
  564.    * @param {chrome.cast.Session} session
  565.    * @private
  566.    */
  567.   onSessionCreated_(session) {
  568.     shaka.cast.CastSender.session_ = session;
  569.     session.addUpdateListener(this.onConnectionStatusChangedBound_);
  570.     session.addMessageListener(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  571.         this.onMessageReceivedBound_);
  572.     this.onConnectionStatusChanged_();
  573.   }
  576.   /**
  577.    * @private
  578.    */
  579.   removeListeners_() {
  580.     const session = shaka.cast.CastSender.session_;
  581.     session.removeUpdateListener(this.onConnectionStatusChangedBound_);
  582.     session.removeMessageListener(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  583.         this.onMessageReceivedBound_);
  584.   }
  587.   /**
  588.    * @private
  589.    */
  590.   onConnectionStatusChanged_() {
  591.     const connected = shaka.cast.CastSender.session_ ?
  592.         shaka.cast.CastSender.session_.status == 'connected' :
  593.         false;
  594.     shaka.log.debug('CastSender: connection status', connected);
  595.     if (this.isCasting_ && !connected) {
  596.       // Tell CastProxy to transfer state back to local player.
  597.       this.onResumeLocal_();
  599.       // Clear whatever we have cached.
  600.       for (const targetName in this.cachedProperties_) {
  601.         this.cachedProperties_[targetName] = {};
  602.       }
  604.       this.rejectAllPromises_();
  605.     }
  607.     this.isCasting_ = connected;
  608.     this.receiverName_ = connected ?
  609.         shaka.cast.CastSender.session_.receiver.friendlyName :
  610.         '';
  611.     this.statusChangeTimer_.tickNow();
  612.   }
  615.   /**
  616.    * Reject any async call promises that are still pending.
  617.    * @private
  618.    */
  619.   rejectAllPromises_() {
  620.     for (const id in this.asyncCallPromises_) {
  621.       const p = this.asyncCallPromises_[id];
  622.       delete this.asyncCallPromises_[id];
  624.       // Reject pending async operations as if they were interrupted.
  625.       // At the moment, load() is the only async operation we are worried about.
  626.       p.reject(new shaka.util.Error(
  627.           shaka.util.Error.Severity.RECOVERABLE,
  628.           shaka.util.Error.Category.PLAYER,
  629.           shaka.util.Error.Code.LOAD_INTERRUPTED));
  630.     }
  631.   }
  634.   /**
  635.    * @param {string} namespace
  636.    * @param {string} serialized
  637.    * @private
  638.    */
  639.   onMessageReceived_(namespace, serialized) {
  640.     // Since this method is in the compiled library, make sure all messages
  641.     // passed in here were created with quoted property names.
  643.     const message = shaka.cast.CastUtils.deserialize(serialized);
  644.     shaka.log.v2('CastSender: message', message);
  646.     switch (message['type']) {
  647.       case 'event': {
  648.         const targetName = message['targetName'];
  649.         const event = message['event'];
  650.         const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
  651.         this.onRemoteEvent_(targetName, fakeEvent);
  652.         break;
  653.       }
  654.       case 'update': {
  655.         const update = message['update'];
  656.         for (const targetName in update) {
  657.           const target = this.cachedProperties_[targetName] || {};
  658.           for (const property in update[targetName]) {
  659.             target[property] = update[targetName][property];
  660.           }
  661.         }
  662.         if (this.hasJoinedExistingSession_) {
  663.           this.onFirstCastStateUpdate_();
  664.           this.hasJoinedExistingSession_ = false;
  665.         }
  666.         break;
  667.       }
  668.       case 'asyncComplete': {
  669.         const id = message['id'];
  670.         const error = message['error'];
  671.         const p = this.asyncCallPromises_[id];
  672.         delete this.asyncCallPromises_[id];
  674.         goog.asserts.assert(p, 'Unexpected async id');
  675.         if (!p) {
  676.           break;
  677.         }
  679.         if (error) {
  680.           // This is a hacky way to reconstruct the serialized error.
  681.           const reconstructedError = new shaka.util.Error(
  682.               error.severity, error.category, error.code);
  683.           for (const k in error) {
  684.             (/** @type {Object} */(reconstructedError))[k] = error[k];
  685.           }
  686.           p.reject(reconstructedError);
  687.         } else {
  688.           p.resolve();
  689.         }
  690.         break;
  691.       }
  692.     }
  693.   }
  696.   /**
  697.    * @param {!Object} message
  698.    * @private
  699.    */
  700.   sendMessage_(message) {
  701.     // Since this method is in the compiled library, make sure all messages
  702.     // passed in here were created with quoted property names.
  704.     const serialized = shaka.cast.CastUtils.serialize(message);
  705.     const session = shaka.cast.CastSender.session_;
  707.     // NOTE: This takes an error callback that we have not seen fire.  We don't
  708.     // know if it would fire synchronously or asynchronously.  Until we know how
  709.     // it works, we just log from that callback.  But we _have_ seen
  710.     // sendMessage() throw synchronously, so we handle that.
  711.     try {
  712.       session.sendMessage(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  713.           serialized,
  714.           () => {},  // success callback
  715.           shaka.log.error);  // error callback
  716.     } catch (error) {
  717.       shaka.log.error('Cast session sendMessage threw', error);
  719.       // Translate the error
  720.       const shakaError = new shaka.util.Error(
  721.           shaka.util.Error.Severity.CRITICAL,
  722.           shaka.util.Error.Category.CAST,
  723.           shaka.util.Error.Code.CAST_CONNECTION_TIMED_OUT,
  724.           error);
  726.       // Dispatch it through the Player proxy
  727.       const fakeEvent = new shaka.util.FakeEvent(
  728.           'error', (new Map()).set('detail', shakaError));
  729.       this.onRemoteEvent_('player', fakeEvent);
  731.       // Force this session to disconnect and transfer playback to the local
  732.       // device
  733.       this.forceDisconnect();
  735.       // Throw the translated error from this getter/setter/method to the UI/app
  736.       throw shakaError;
  737.     }
  738.   }
  739. };
  741. /** @type {number} */
  742. shaka.cast.CastSender.STATUS_DELAY = 0.02;
  744. /** @private {boolean} */
  745. shaka.cast.CastSender.hasReceivers_ = false;
  747. /** @private {chrome.cast.Session} */
  748. shaka.cast.CastSender.session_ = null;
  750. /**
  751.  * A set of all living CastSender instances.  The constructor and destroy
  752.  * methods will add and remove instances from this set.
  753.  *
  754.  * This is used to deal with delayed initialization of the Cast SDK.  When the
  755.  * SDK becomes available, instances will be reinitialized.
  756.  *
  757.  * @private {!Set.<shaka.cast.CastSender>}
  758.  */
  759. shaka.cast.CastSender.instances_ = new Set();
  761. /**
  762.  * If the cast SDK is not available yet, it will invoke this callback once it
  763.  * becomes available.
  764.  *
  765.  * @param {boolean} loaded
  766.  * @private
  767.  */
  768. shaka.cast.CastSender.onSdkLoaded_ = (loaded) => {
  769.   if (loaded) {
  770.     // Any living instances of CastSender should have their init methods called
  771.     // again now that the API is available.
  772.     for (const sender of shaka.cast.CastSender.instances_) {
  773.       sender.init();
  774.     }
  775.   }
  776. };