Source: lib/cast/cast_sender.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.cast.CastSender');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.cast.CastUtils');
  22. goog.require('shaka.log');
  23. goog.require('shaka.util.Error');
  24. goog.require('shaka.util.FakeEvent');
  25. goog.require('shaka.util.IDestroyable');
  26. goog.require('shaka.util.PublicPromise');
  30. /**
  31.  * @constructor
  32.  * @struct
  33.  * @param {string} receiverAppId The ID of the cast receiver application.
  34.  * @param {function()} onStatusChanged A callback invoked when the cast status
  35.  *   changes.
  36.  * @param {function()} onFirstCastStateUpdate A callback invoked when an
  37.  *   "update" event has been received for the first time.
  38.  * @param {function(string, !shaka.util.FakeEvent)} onRemoteEvent A callback
  39.  *   invoked with target name and event when a remote event is received.
  40.  * @param {function()} onResumeLocal A callback invoked when the local player
  41.  *   should resume playback.  Called before the cached remote state is wiped.
  42.  * @param {function()} onInitStateRequired A callback to get local player's.
  43.  *   state.  Invoked when casting is initiated from Chrome's cast button.
  44.  * @implements {shaka.util.IDestroyable}
  45.  */
  46. shaka.cast.CastSender =
  47.     function(receiverAppId, onStatusChanged, onFirstCastStateUpdate,
  48.              onRemoteEvent, onResumeLocal, onInitStateRequired) {
  50.   /** @private {string} */
  51.   this.receiverAppId_ = receiverAppId;
  53.   /** @private {?function()} */
  54.   this.onStatusChanged_ = onStatusChanged;
  56.   /** @private {?function()} */
  57.   this.onFirstCastStateUpdate_ = onFirstCastStateUpdate;
  59.   /** @private {boolean} */
  60.   this.hasJoinedExistingSession_ = false;
  62.   /** @private {?function(string, !shaka.util.FakeEvent)} */
  63.   this.onRemoteEvent_ = onRemoteEvent;
  65.   /** @private {?function()} */
  66.   this.onResumeLocal_ = onResumeLocal;
  68.   /** @private {?function()} */
  69.   this.onInitStateRequired_ = onInitStateRequired;
  71.   /** @private {boolean} */
  72.   this.apiReady_ = false;
  74.   /** @private {boolean} */
  75.   this.isCasting_ = false;
  77.   /** @private {string} */
  78.   this.receiverName_ = '';
  80.   /** @private {Object} */
  81.   this.appData_ = null;
  83.   /** @private {?function()} */
  84.   this.onConnectionStatusChangedBound_ =
  85.       this.onConnectionStatusChanged_.bind(this);
  87.   /** @private {?function(string, string)} */
  88.   this.onMessageReceivedBound_ = this.onMessageReceived_.bind(this);
  90.   /** @private {Object} */
  91.   this.cachedProperties_ = {
  92.     'video': {},
  93.     'player': {}
  94.   };
  96.   /** @private {number} */
  97.   this.nextAsyncCallId_ = 0;
  99.   /** @private {Object.<string, !shaka.util.PublicPromise>} */
  100.   this.asyncCallPromises_ = {};
  102.   /** @private {shaka.util.PublicPromise} */
  103.   this.castPromise_ = null;
  104. };
  107. /** @private {boolean} */
  108. shaka.cast.CastSender.hasReceivers_ = false;
  111. /** @private {chrome.cast.Session} */
  112. shaka.cast.CastSender.session_ = null;
  115. /** @override */
  116. shaka.cast.CastSender.prototype.destroy = function() {
  117.   this.rejectAllPromises_();
  118.   if (shaka.cast.CastSender.session_) {
  119.     this.removeListeners_();
  120.     // Don't leave the session, so that this session can be re-used later if
  121.     // necessary.
  122.   }
  124.   this.onStatusChanged_ = null;
  125.   this.onRemoteEvent_ = null;
  126.   this.onResumeLocal_ = null;
  127.   this.apiReady_ = false;
  128.   this.isCasting_ = false;
  129.   this.appData_ = null;
  130.   this.cachedProperties_ = null;
  131.   this.asyncCallPromises_ = null;
  132.   this.castPromise_ = null;
  133.   this.onConnectionStatusChangedBound_ = null;
  134.   this.onMessageReceivedBound_ = null;
  136.   return Promise.resolve();
  137. };
  140. /**
  141.  * @return {boolean} True if the cast API is available.
  142.  */
  143. shaka.cast.CastSender.prototype.apiReady = function() {
  144.   return this.apiReady_;
  145. };
  148. /**
  149.  * @return {boolean} True if there are receivers.
  150.  */
  151. shaka.cast.CastSender.prototype.hasReceivers = function() {
  152.   return shaka.cast.CastSender.hasReceivers_;
  153. };
  156. /**
  157.  * @return {boolean} True if we are currently casting.
  158.  */
  159. shaka.cast.CastSender.prototype.isCasting = function() {
  160.   return this.isCasting_;
  161. };
  164. /**
  165.  * @return {string} The name of the Cast receiver device, if isCasting().
  166.  */
  167. shaka.cast.CastSender.prototype.receiverName = function() {
  168.   return this.receiverName_;
  169. };
  172. /**
  173.  * @return {boolean} True if we have a cache of remote properties from the
  174.  *   receiver.
  175.  */
  176. shaka.cast.CastSender.prototype.hasRemoteProperties = function() {
  177.   return Object.keys(this.cachedProperties_['video']).length != 0;
  178. };
  181. /** Initialize the Cast API. */
  182. shaka.cast.CastSender.prototype.init = function() {
  183.   // Check for the cast extension.
  184.   if (!window.chrome || !chrome.cast || !chrome.cast.isAvailable) {
  185.     // Not available yet, so wait to be notified if/when it is available.
  186.     window.__onGCastApiAvailable = (function(loaded) {
  187.       if (loaded) {
  188.         this.init();
  189.       }
  190.     }).bind(this);
  191.     return;
  192.   }
  194.   // The API is now available.
  195.   delete window.__onGCastApiAvailable;
  196.   this.apiReady_ = true;
  197.   this.onStatusChanged_();
  199.   let sessionRequest = new chrome.cast.SessionRequest(this.receiverAppId_);
  200.   let apiConfig = new chrome.cast.ApiConfig(sessionRequest,
  201.       this.onExistingSessionJoined_.bind(this),
  202.       this.onReceiverStatusChanged_.bind(this),
  203.       'origin_scoped');
  205.   // TODO: Have never seen this fail.  When would it and how should we react?
  206.   chrome.cast.initialize(apiConfig,
  207.       function() { shaka.log.debug('CastSender: init'); },
  208.       function(error) { shaka.log.error('CastSender: init error', error); });
  209.   if (shaka.cast.CastSender.hasReceivers_) {
  210.     // Fire a fake cast status change, to simulate the update that
  211.     // would be fired normally.
  212.     // This is after a brief delay, to give users a chance to add event
  213.     // listeners.
  214.     setTimeout(this.onStatusChanged_.bind(this), 20);
  215.   }
  217.   let oldSession = shaka.cast.CastSender.session_;
  218.   if (oldSession && oldSession.status != chrome.cast.SessionStatus.STOPPED) {
  219.     // The old session still exists, so re-use it.
  220.     shaka.log.debug('CastSender: re-using existing connection');
  221.     this.onExistingSessionJoined_(oldSession);
  222.   } else {
  223.     // The session has been canceled in the meantime, so ignore it.
  224.     shaka.cast.CastSender.session_ = null;
  225.   }
  226. };
  229. /**
  230.  * Set application-specific data.
  231.  *
  232.  * @param {Object} appData Application-specific data to relay to the receiver.
  233.  */
  234. shaka.cast.CastSender.prototype.setAppData = function(appData) {
  235.   this.appData_ = appData;
  236.   if (this.isCasting_) {
  237.     this.sendMessage_({
  238.       'type': 'appData',
  239.       'appData': this.appData_
  240.     });
  241.   }
  242. };
  245. /**
  246.  * @param {shaka.cast.CastUtils.InitStateType} initState Video and player state
  247.  *   to be sent to the receiver.
  248.  * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  249.  *   connection fails or is canceled by the user.
  250.  */
  251. shaka.cast.CastSender.prototype.cast = function(initState) {
  252.   if (!this.apiReady_) {
  253.     return Promise.reject(new shaka.util.Error(
  254.         shaka.util.Error.Severity.RECOVERABLE,
  255.         shaka.util.Error.Category.CAST,
  256.         shaka.util.Error.Code.CAST_API_UNAVAILABLE));
  257.   }
  258.   if (!shaka.cast.CastSender.hasReceivers_) {
  259.     return Promise.reject(new shaka.util.Error(
  260.         shaka.util.Error.Severity.RECOVERABLE,
  261.         shaka.util.Error.Category.CAST,
  262.         shaka.util.Error.Code.NO_CAST_RECEIVERS));
  263.   }
  264.   if (this.isCasting_) {
  265.     return Promise.reject(new shaka.util.Error(
  266.         shaka.util.Error.Severity.RECOVERABLE,
  267.         shaka.util.Error.Category.CAST,
  268.         shaka.util.Error.Code.ALREADY_CASTING));
  269.   }
  271.   this.castPromise_ = new shaka.util.PublicPromise();
  272.   chrome.cast.requestSession(
  273.       this.onSessionInitiated_.bind(this, initState),
  274.       this.onConnectionError_.bind(this));
  275.   return this.castPromise_;
  276. };
  279. /**
  280.  * Shows user a cast dialog where they can choose to stop
  281.  * casting.  Relies on Chrome to perform disconnect if they do.
  282.  * Doesn't do anything if not connected.
  283.  */
  284. shaka.cast.CastSender.prototype.showDisconnectDialog = function() {
  285.   if (!this.isCasting_) {
  286.     return;
  287.   }
  288.   let initState = this.onInitStateRequired_();
  290.   chrome.cast.requestSession(
  291.       this.onSessionInitiated_.bind(this, initState),
  292.       this.onConnectionError_.bind(this));
  293. };
  296. /**
  297.  * Forces the receiver app to shut down by disconnecting.  Does nothing if not
  298.  * connected.
  299.  */
  300. shaka.cast.CastSender.prototype.forceDisconnect = function() {
  301.   if (!this.isCasting_) {
  302.     return;
  303.   }
  305.   this.rejectAllPromises_();
  306.   if (shaka.cast.CastSender.session_) {
  307.     this.removeListeners_();
  308.     shaka.cast.CastSender.session_.stop(function() {}, function() {});
  309.     shaka.cast.CastSender.session_ = null;
  310.   }
  311. };
  314. /**
  315.  * Getter for properties of remote objects.
  316.  * @param {string} targetName
  317.  * @param {string} property
  318.  * @return {?}
  319.  */
  320. shaka.cast.CastSender.prototype.get = function(targetName, property) {
  321.   goog.asserts.assert(targetName == 'video' || targetName == 'player',
  322.                       'Unexpected target name');
  323.   const CastUtils = shaka.cast.CastUtils;
  324.   if (targetName == 'video') {
  325.     if (CastUtils.VideoVoidMethods.indexOf(property) >= 0) {
  326.       return this.remoteCall_.bind(this, targetName, property);
  327.     }
  328.   } else if (targetName == 'player') {
  329.     if (CastUtils.PlayerGetterMethodsThatRequireLive[property]) {
  330.       let isLive = this.get('player', 'isLive')();
  331.       goog.asserts.assert(isLive,
  332.           property + ' should be called on a live stream!');
  333.       // If the property shouldn't exist, return a fake function so that the
  334.       // user doesn't call an undefined function and get a second error.
  335.       if (!isLive) {
  336.         return () => undefined;
  337.       }
  338.     }
  339.     if (CastUtils.PlayerVoidMethods.indexOf(property) >= 0) {
  340.       return this.remoteCall_.bind(this, targetName, property);
  341.     }
  342.     if (CastUtils.PlayerPromiseMethods.indexOf(property) >= 0) {
  343.       return this.remoteAsyncCall_.bind(this, targetName, property);
  344.     }
  345.     if (CastUtils.PlayerGetterMethods[property]) {
  346.       return this.propertyGetter_.bind(this, targetName, property);
  347.     }
  348.   }
  350.   return this.propertyGetter_(targetName, property);
  351. };
  354. /**
  355.  * Setter for properties of remote objects.
  356.  * @param {string} targetName
  357.  * @param {string} property
  358.  * @param {?} value
  359.  */
  360. shaka.cast.CastSender.prototype.set = function(targetName, property, value) {
  361.   goog.asserts.assert(targetName == 'video' || targetName == 'player',
  362.                       'Unexpected target name');
  364.   this.cachedProperties_[targetName][property] = value;
  365.   this.sendMessage_({
  366.     'type': 'set',
  367.     'targetName': targetName,
  368.     'property': property,
  369.     'value': value
  370.   });
  371. };
  374. /**
  375.  * @param {shaka.cast.CastUtils.InitStateType} initState
  376.  * @param {chrome.cast.Session} session
  377.  * @private
  378.  */
  379. shaka.cast.CastSender.prototype.onSessionInitiated_ =
  380.     function(initState, session) {
  381.   shaka.log.debug('CastSender: onSessionInitiated');
  382.   this.onSessionCreated_(session);
  384.   this.sendMessage_({
  385.     'type': 'init',
  386.     'initState': initState,
  387.     'appData': this.appData_
  388.   });
  390.   this.castPromise_.resolve();
  391. };
  394. /**
  395.  * @param {chrome.cast.Error} error
  396.  * @private
  397.  */
  398. shaka.cast.CastSender.prototype.onConnectionError_ = function(error) {
  399.   // Default error code:
  400.   let code = shaka.util.Error.Code.UNEXPECTED_CAST_ERROR;
  402.   switch (error.code) {
  403.     case 'cancel':
  404.       code = shaka.util.Error.Code.CAST_CANCELED_BY_USER;
  405.       break;
  406.     case 'timeout':
  407.       code = shaka.util.Error.Code.CAST_CONNECTION_TIMED_OUT;
  408.       break;
  409.     case 'receiver_unavailable':
  410.       code = shaka.util.Error.Code.CAST_RECEIVER_APP_UNAVAILABLE;
  411.       break;
  412.   }
  414.   this.castPromise_.reject(new shaka.util.Error(
  415.       shaka.util.Error.Severity.CRITICAL,
  416.       shaka.util.Error.Category.CAST,
  417.       code,
  418.       error));
  419. };
  422. /**
  423.  * @param {string} targetName
  424.  * @param {string} property
  425.  * @return {?}
  426.  * @private
  427.  */
  428. shaka.cast.CastSender.prototype.propertyGetter_ =
  429.     function(targetName, property) {
  430.   goog.asserts.assert(targetName == 'video' || targetName == 'player',
  431.                       'Unexpected target name');
  432.   return this.cachedProperties_[targetName][property];
  433. };
  436. /**
  437.  * @param {string} targetName
  438.  * @param {string} methodName
  439.  * @private
  440.  */
  441. shaka.cast.CastSender.prototype.remoteCall_ =
  442.     function(targetName, methodName) {
  443.   goog.asserts.assert(targetName == 'video' || targetName == 'player',
  444.                       'Unexpected target name');
  445.   let args = Array.prototype.slice.call(arguments, 2);
  446.   this.sendMessage_({
  447.     'type': 'call',
  448.     'targetName': targetName,
  449.     'methodName': methodName,
  450.     'args': args
  451.   });
  452. };
  455. /**
  456.  * @param {string} targetName
  457.  * @param {string} methodName
  458.  * @return {!Promise}
  459.  * @private
  460.  */
  461. shaka.cast.CastSender.prototype.remoteAsyncCall_ =
  462.     function(targetName, methodName) {
  463.   goog.asserts.assert(targetName == 'video' || targetName == 'player',
  464.                       'Unexpected target name');
  465.   let args = Array.prototype.slice.call(arguments, 2);
  467.   let p = new shaka.util.PublicPromise();
  468.   let id = this.nextAsyncCallId_.toString();
  469.   this.nextAsyncCallId_++;
  470.   this.asyncCallPromises_[id] = p;
  472.   this.sendMessage_({
  473.     'type': 'asyncCall',
  474.     'targetName': targetName,
  475.     'methodName': methodName,
  476.     'args': args,
  477.     'id': id
  478.   });
  479.   return p;
  480. };
  483. /**
  484.  * @param {chrome.cast.Session} session
  485.  * @private
  486.  */
  487. shaka.cast.CastSender.prototype.onExistingSessionJoined_ = function(session) {
  488.   shaka.log.debug('CastSender: onExistingSessionJoined');
  490.   let initState = this.onInitStateRequired_();
  492.   this.castPromise_ = new shaka.util.PublicPromise();
  493.   this.hasJoinedExistingSession_ = true;
  495.   this.onSessionInitiated_(initState, session);
  496. };
  499. /**
  500.  * @param {string} availability
  501.  * @private
  502.  */
  503. shaka.cast.CastSender.prototype.onReceiverStatusChanged_ =
  504.     function(availability) {
  505.   // The cast extension is telling us whether there are any cast receiver
  506.   // devices available.
  507.   shaka.log.debug('CastSender: receiver status', availability);
  508.   shaka.cast.CastSender.hasReceivers_ = availability == 'available';
  509.   this.onStatusChanged_();
  510. };
  513. /**
  514.  * @param {chrome.cast.Session} session
  515.  * @private
  516.  */
  517. shaka.cast.CastSender.prototype.onSessionCreated_ = function(session) {
  518.   shaka.cast.CastSender.session_ = session;
  519.   session.addUpdateListener(this.onConnectionStatusChangedBound_);
  520.   session.addMessageListener(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  521.       this.onMessageReceivedBound_);
  522.   this.onConnectionStatusChanged_();
  523. };
  526. /**
  527.  * @private
  528.  */
  529. shaka.cast.CastSender.prototype.removeListeners_ = function() {
  530.   let session = shaka.cast.CastSender.session_;
  531.   session.removeUpdateListener(this.onConnectionStatusChangedBound_);
  532.   session.removeMessageListener(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  533.       this.onMessageReceivedBound_);
  534. };
  537. /**
  538.  * @private
  539.  */
  540. shaka.cast.CastSender.prototype.onConnectionStatusChanged_ = function() {
  541.   let connected = shaka.cast.CastSender.session_ ?
  542.       shaka.cast.CastSender.session_.status == 'connected' :
  543.       false;
  544.   shaka.log.debug('CastSender: connection status', connected);
  545.   if (this.isCasting_ && !connected) {
  546.     // Tell CastProxy to transfer state back to local player.
  547.     this.onResumeLocal_();
  549.     // Clear whatever we have cached.
  550.     for (let targetName in this.cachedProperties_) {
  551.       this.cachedProperties_[targetName] = {};
  552.     }
  554.     this.rejectAllPromises_();
  555.   }
  557.   this.isCasting_ = connected;
  558.   this.receiverName_ = connected ?
  559.       shaka.cast.CastSender.session_.receiver.friendlyName :
  560.       '';
  561.   this.onStatusChanged_();
  562. };
  565. /**
  566.  * Reject any async call promises that are still pending.
  567.  * @private
  568.  */
  569. shaka.cast.CastSender.prototype.rejectAllPromises_ = function() {
  570.   for (let id in this.asyncCallPromises_) {
  571.     let p = this.asyncCallPromises_[id];
  572.     delete this.asyncCallPromises_[id];
  574.     // Reject pending async operations as if they were interrupted.
  575.     // At the moment, load() is the only async operation we are worried about.
  576.     p.reject(new shaka.util.Error(
  577.         shaka.util.Error.Severity.RECOVERABLE,
  578.         shaka.util.Error.Category.PLAYER,
  579.         shaka.util.Error.Code.LOAD_INTERRUPTED));
  580.   }
  581. };
  584. /**
  585.  * @param {string} namespace
  586.  * @param {string} serialized
  587.  * @private
  588.  */
  589. shaka.cast.CastSender.prototype.onMessageReceived_ =
  590.     function(namespace, serialized) {
  591.   // Since this method is in the compiled library, make sure all messages passed
  592.   // in here were created with quoted property names.
  594.   let message = shaka.cast.CastUtils.deserialize(serialized);
  595.   shaka.log.v2('CastSender: message', message);
  597.   switch (message['type']) {
  598.     case 'event': {
  599.       let targetName = message['targetName'];
  600.       let event = message['event'];
  601.       let fakeEvent = new shaka.util.FakeEvent(event['type'], event);
  602.       this.onRemoteEvent_(targetName, fakeEvent);
  603.       break;
  604.     }
  605.     case 'update': {
  606.       let update = message['update'];
  607.       for (let targetName in update) {
  608.         let target = this.cachedProperties_[targetName] || {};
  609.         for (let property in update[targetName]) {
  610.           target[property] = update[targetName][property];
  611.         }
  612.       }
  613.       if (this.hasJoinedExistingSession_) {
  614.         this.onFirstCastStateUpdate_();
  615.         this.hasJoinedExistingSession_ = false;
  616.       }
  617.       break;
  618.     }
  619.     case 'asyncComplete': {
  620.       let id = message['id'];
  621.       let error = message['error'];
  622.       let p = this.asyncCallPromises_[id];
  623.       delete this.asyncCallPromises_[id];
  625.       goog.asserts.assert(p, 'Unexpected async id');
  626.       if (!p) break;
  628.       if (error) {
  629.         // This is a hacky way to reconstruct the serialized error.
  630.         let reconstructedError = new shaka.util.Error(
  631.             error.severity, error.category, error.code);
  632.         for (let k in error) {
  633.           (/** @type {Object} */(reconstructedError))[k] = error[k];
  634.         }
  635.         p.reject(reconstructedError);
  636.       } else {
  637.         p.resolve();
  638.       }
  639.       break;
  640.     }
  641.   }
  642. };
  645. /**
  646.  * @param {!Object} message
  647.  * @private
  648.  */
  649. shaka.cast.CastSender.prototype.sendMessage_ = function(message) {
  650.   // Since this method is in the compiled library, make sure all messages passed
  651.   // in here were created with quoted property names.
  653.   let serialized = shaka.cast.CastUtils.serialize(message);
  654.   // TODO: have never seen this fail.  When would it and how should we react?
  655.   let session = shaka.cast.CastSender.session_;
  656.   session.sendMessage(shaka.cast.CastUtils.SHAKA_MESSAGE_NAMESPACE,
  657.                       serialized,
  658.                       function() {},  // success callback
  659.                       shaka.log.error);  // error callback
  660. };