Source: lib/cast/cast_proxy.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.CastProxy');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.cast.CastSender');
  22. goog.require('shaka.cast.CastUtils');
  23. goog.require('shaka.log');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.EventManager');
  26. goog.require('shaka.util.FakeEvent');
  27. goog.require('shaka.util.FakeEventTarget');
  28. goog.require('shaka.util.IDestroyable');
  32. /**
  33.  * A proxy to switch between local and remote playback for Chromecast in a way
  34.  * that is transparent to the app's controls.
  35.  *
  36.  * @constructor
  37.  * @struct
  38.  * @param {!HTMLMediaElement} video The local video element associated with the
  39.  *   local Player instance.
  40.  * @param {!shaka.Player} player A local Player instance.
  41.  * @param {string} receiverAppId The ID of the cast receiver application.
  42.  *   If blank, casting will not be available, but the proxy will still function
  43.  *   otherwise.
  44.  * @implements {shaka.util.IDestroyable}
  45.  * @extends {shaka.util.FakeEventTarget}
  46.  * @export
  47.  */
  48. shaka.cast.CastProxy = function(video, player, receiverAppId) {
  49.   shaka.util.FakeEventTarget.call(this);
  51.   /** @private {HTMLMediaElement} */
  52.   this.localVideo_ = video;
  54.   /** @private {shaka.Player} */
  55.   this.localPlayer_ = player;
  57.   /** @private {Object} */
  58.   this.videoProxy_ = null;
  60.   /** @private {Object} */
  61.   this.playerProxy_ = null;
  63.   /** @private {shaka.util.FakeEventTarget} */
  64.   this.videoEventTarget_ = null;
  66.   /** @private {shaka.util.FakeEventTarget} */
  67.   this.playerEventTarget_ = null;
  69.   /** @private {shaka.util.EventManager} */
  70.   this.eventManager_ = null;
  72.   /** @private {shaka.cast.CastSender} */
  73.   this.sender_ = new shaka.cast.CastSender(
  74.       receiverAppId,
  75.       this.onCastStatusChanged_.bind(this),
  76.       this.onFirstCastStateUpdate_.bind(this),
  77.       this.onRemoteEvent_.bind(this),
  78.       this.onResumeLocal_.bind(this),
  79.       this.getInitState_.bind(this));
  81.   this.init_();
  82. };
  83. goog.inherits(shaka.cast.CastProxy, shaka.util.FakeEventTarget);
  86. /**
  87.  * Destroys the proxy and the underlying local Player.
  88.  *
  89.  * @param {boolean=} opt_forceDisconnect If true, force the receiver app to shut
  90.  *   down by disconnecting.  Does nothing if not connected.
  91.  * @override
  92.  * @export
  93.  */
  94. shaka.cast.CastProxy.prototype.destroy = function(opt_forceDisconnect) {
  95.   if (opt_forceDisconnect && this.sender_) {
  96.     this.sender_.forceDisconnect();
  97.   }
  99.   let async = [
  100.     this.eventManager_ ? this.eventManager_.destroy() : null,
  101.     this.localPlayer_ ? this.localPlayer_.destroy() : null,
  102.     this.sender_ ? this.sender_.destroy() : null
  103.   ];
  105.   this.localVideo_ = null;
  106.   this.localPlayer_ = null;
  107.   this.videoProxy_ = null;
  108.   this.playerProxy_ = null;
  109.   this.eventManager_ = null;
  110.   this.sender_ = null;
  112.   return Promise.all(async);
  113. };
  116. /**
  117.  * @event shaka.cast.CastProxy.CastStatusChangedEvent
  118.  * @description Fired when cast status changes.  The status change will be
  119.  *   reflected in canCast() and isCasting().
  120.  * @property {string} type
  121.  *   'caststatuschanged'
  122.  * @exportDoc
  123.  */
  126. /**
  127.  * Get a proxy for the video element that delegates to local and remote video
  128.  * elements as appropriate.
  129.  *
  130.  * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  131.  * @return {HTMLMediaElement}
  132.  * @export
  133.  */
  134. shaka.cast.CastProxy.prototype.getVideo = function() {
  135.   return /** @type {HTMLMediaElement} */(this.videoProxy_);
  136. };
  139. /**
  140.  * Get a proxy for the Player that delegates to local and remote Player objects
  141.  * as appropriate.
  142.  *
  143.  * @suppress {invalidCasts} to cast proxy Objects to unrelated types
  144.  * @return {shaka.Player}
  145.  * @export
  146.  */
  147. shaka.cast.CastProxy.prototype.getPlayer = function() {
  148.   return /** @type {shaka.Player} */(this.playerProxy_);
  149. };
  152. /**
  153.  * @return {boolean} True if the cast API is available and there are receivers.
  154.  * @export
  155.  */
  156. shaka.cast.CastProxy.prototype.canCast = function() {
  157.   return this.sender_ ?
  158.       this.sender_.apiReady() && this.sender_.hasReceivers() :
  159.       false;
  160. };
  163. /**
  164.  * @return {boolean} True if we are currently casting.
  165.  * @export
  166.  */
  167. shaka.cast.CastProxy.prototype.isCasting = function() {
  168.   return this.sender_ ? this.sender_.isCasting() : false;
  169. };
  172. /**
  173.  * @return {string} The name of the Cast receiver device, if isCasting().
  174.  * @export
  175.  */
  176. shaka.cast.CastProxy.prototype.receiverName = function() {
  177.   return this.sender_ ? this.sender_.receiverName() : '';
  178. };
  181. /**
  182.  * @return {!Promise} Resolved when connected to a receiver.  Rejected if the
  183.  *   connection fails or is canceled by the user.
  184.  * @export
  185.  */
  186. shaka.cast.CastProxy.prototype.cast = function() {
  187.   let initState = this.getInitState_();
  189.   // TODO: transfer manually-selected tracks?
  190.   // TODO: transfer side-loaded text tracks?
  192.   return this.sender_.cast(initState).then(function() {
  193.     if (!this.localPlayer_) {
  194.       // We've already been destroyed.
  195.       return;
  196.     }
  198.     // Unload the local manifest when casting succeeds.
  199.     return this.localPlayer_.unload();
  200.   }.bind(this));
  201. };
  204. /**
  205.  * Set application-specific data.
  206.  *
  207.  * @param {Object} appData Application-specific data to relay to the receiver.
  208.  * @export
  209.  */
  210. shaka.cast.CastProxy.prototype.setAppData = function(appData) {
  211.   this.sender_.setAppData(appData);
  212. };
  215. /**
  216.  * Show a dialog where user can choose to disconnect from the cast connection.
  217.  * @export
  218.  */
  219. shaka.cast.CastProxy.prototype.suggestDisconnect = function() {
  220.   this.sender_.showDisconnectDialog();
  221. };
  224. /**
  225.  * Force the receiver app to shut down by disconnecting.
  226.  * @export
  227.  */
  228. shaka.cast.CastProxy.prototype.forceDisconnect = function() {
  229.   this.sender_.forceDisconnect();
  230. };
  233. /**
  234.  * Initialize the Proxies and the Cast sender.
  235.  * @private
  236.  */
  237. shaka.cast.CastProxy.prototype.init_ = function() {
  238.   this.sender_.init();
  240.   this.eventManager_ = new shaka.util.EventManager();
  242.   shaka.cast.CastUtils.VideoEvents.forEach(function(name) {
  243.     this.eventManager_.listen(this.localVideo_, name,
  244.         this.videoProxyLocalEvent_.bind(this));
  245.   }.bind(this));
  247.   shaka.cast.CastUtils.PlayerEvents.forEach(function(name) {
  248.     this.eventManager_.listen(this.localPlayer_, name,
  249.         this.playerProxyLocalEvent_.bind(this));
  250.   }.bind(this));
  252.   // We would like to use Proxy here, but it is not supported on IE11 or Safari.
  253.   this.videoProxy_ = {};
  254.   for (let k in this.localVideo_) {
  255.     Object.defineProperty(this.videoProxy_, k, {
  256.       configurable: false,
  257.       enumerable: true,
  258.       get: this.videoProxyGet_.bind(this, k),
  259.       set: this.videoProxySet_.bind(this, k)
  260.     });
  261.   }
  263.   this.playerProxy_ = {};
  264.   for (let k in /** @type {Object} */(this.localPlayer_)) {
  265.     Object.defineProperty(this.playerProxy_, k, {
  266.       configurable: false,
  267.       enumerable: true,
  268.       get: this.playerProxyGet_.bind(this, k)
  269.     });
  270.   }
  272.   this.videoEventTarget_ = new shaka.util.FakeEventTarget();
  273.   this.videoEventTarget_.dispatchTarget =
  274.       /** @type {EventTarget} */(this.videoProxy_);
  276.   this.playerEventTarget_ = new shaka.util.FakeEventTarget();
  277.   this.playerEventTarget_.dispatchTarget =
  278.       /** @type {EventTarget} */(this.playerProxy_);
  279. };
  282. /**
  283.  * @return {shaka.cast.CastUtils.InitStateType} initState Video and player state
  284.  *   to be sent to the receiver.
  285.  * @private
  286.  */
  287. shaka.cast.CastProxy.prototype.getInitState_ = function() {
  288.   let initState = {
  289.     'video': {},
  290.     'player': {},
  291.     'playerAfterLoad': {},
  292.     'manifest': this.localPlayer_.getManifestUri(),
  293.     'startTime': null
  294.   };
  296.   // Pause local playback before capturing state.
  297.   this.localVideo_.pause();
  299.   shaka.cast.CastUtils.VideoInitStateAttributes.forEach(function(name) {
  300.     initState['video'][name] = this.localVideo_[name];
  301.   }.bind(this));
  303.   // If the video is still playing, set the startTime.
  304.   // Has no effect if nothing is loaded.
  305.   if (!this.localVideo_.ended) {
  306.     initState['startTime'] = this.localVideo_.currentTime;
  307.   }
  309.   shaka.cast.CastUtils.PlayerInitState.forEach(function(pair) {
  310.     let getter = pair[0];
  311.     let setter = pair[1];
  312.     let value = /** @type {Object} */(this.localPlayer_)[getter]();
  314.     initState['player'][setter] = value;
  315.   }.bind(this));
  317.   shaka.cast.CastUtils.PlayerInitAfterLoadState.forEach(function(pair) {
  318.     let getter = pair[0];
  319.     let setter = pair[1];
  320.     let value = /** @type {Object} */(this.localPlayer_)[getter]();
  322.     initState['playerAfterLoad'][setter] = value;
  323.   }.bind(this));
  325.   return initState;
  326. };
  329. /**
  330.  * Dispatch an event to notify the app that the status has changed.
  331.  * @private
  332.  */
  333. shaka.cast.CastProxy.prototype.onCastStatusChanged_ = function() {
  334.   let event = new shaka.util.FakeEvent('caststatuschanged');
  335.   this.dispatchEvent(event);
  336. };
  339. /**
  340.  * Dispatch a synthetic play or pause event to ensure that the app correctly
  341.  * knows that the player is playing, if joining an existing receiver.
  342.  * @private
  343.  */
  344. shaka.cast.CastProxy.prototype.onFirstCastStateUpdate_ = function() {
  345.   let type = this.videoProxy_.paused ? 'pause' : 'play';
  346.   let fakeEvent = new shaka.util.FakeEvent(type);
  347.   this.videoEventTarget_.dispatchEvent(fakeEvent);
  348. };
  351. /**
  352.  * Transfer remote state back and resume local playback.
  353.  * @private
  354.  */
  355. shaka.cast.CastProxy.prototype.onResumeLocal_ = function() {
  356.   // Transfer back the player state.
  357.   shaka.cast.CastUtils.PlayerInitState.forEach(function(pair) {
  358.     let getter = pair[0];
  359.     let setter = pair[1];
  360.     let value = this.sender_.get('player', getter)();
  361.     /** @type {Object} */(this.localPlayer_)[setter](value);
  362.   }.bind(this));
  364.   // Get the most recent manifest URI and ended state.
  365.   let manifestUri = this.sender_.get('player', 'getManifestUri')();
  366.   let ended = this.sender_.get('video', 'ended');
  368.   let manifestReady = Promise.resolve();
  369.   let autoplay = this.localVideo_.autoplay;
  371.   let startTime = null;
  373.   // If the video is still playing, set the startTime.
  374.   // Has no effect if nothing is loaded.
  375.   if (!ended) {
  376.     startTime = this.sender_.get('video', 'currentTime');
  377.   }
  379.   // Now load the manifest, if present.
  380.   if (manifestUri) {
  381.     // Don't autoplay the content until we finish setting up initial state.
  382.     this.localVideo_.autoplay = false;
  383.     manifestReady = this.localPlayer_.load(manifestUri, startTime);
  384.   }
  386.   // Get the video state into a temp variable since we will apply it async.
  387.   let videoState = {};
  388.   shaka.cast.CastUtils.VideoInitStateAttributes.forEach(function(name) {
  389.     videoState[name] = this.sender_.get('video', name);
  390.   }.bind(this));
  392.   // Finally, take on video state and player's "after load" state.
  393.   manifestReady.then(() => {
  394.     if (!this.localVideo_) {
  395.       // We've already been destroyed.
  396.       return;
  397.     }
  399.     shaka.cast.CastUtils.VideoInitStateAttributes.forEach(function(name) {
  400.       this.localVideo_[name] = videoState[name];
  401.     }.bind(this));
  403.     shaka.cast.CastUtils.PlayerInitAfterLoadState.forEach(function(pair) {
  404.       let getter = pair[0];
  405.       let setter = pair[1];
  406.       let value = this.sender_.get('player', getter)();
  407.       /** @type {Object} */(this.localPlayer_)[setter](value);
  408.     }.bind(this));
  410.     // Restore the original autoplay setting.
  411.     this.localVideo_.autoplay = autoplay;
  412.     if (manifestUri) {
  413.       // Resume playback with transferred state.
  414.       this.localVideo_.play();
  415.     }
  416.   }, (error) => {
  417.     // Pass any errors through to the app.
  418.     goog.asserts.assert(error instanceof shaka.util.Error,
  419.                         'Wrong error type!');
  420.     let event = new shaka.util.FakeEvent('error', {'detail': error});
  421.     this.localPlayer_.dispatchEvent(event);
  422.   });
  423. };
  426. /**
  427.  * @param {string} name
  428.  * @return {?}
  429.  * @private
  430.  */
  431. shaka.cast.CastProxy.prototype.videoProxyGet_ = function(name) {
  432.   if (name == 'addEventListener') {
  433.     return this.videoEventTarget_.addEventListener.bind(
  434.         this.videoEventTarget_);
  435.   }
  436.   if (name == 'removeEventListener') {
  437.     return this.videoEventTarget_.removeEventListener.bind(
  438.         this.videoEventTarget_);
  439.   }
  441.   // If we are casting, but the first update has not come in yet, use local
  442.   // values, but not local methods.
  443.   if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  444.     let value = this.localVideo_[name];
  445.     if (typeof value != 'function') {
  446.       return value;
  447.     }
  448.   }
  450.   // Use local values and methods if we are not casting.
  451.   if (!this.sender_.isCasting()) {
  452.     let value = this.localVideo_[name];
  453.     if (typeof value == 'function') {
  454.       value = value.bind(this.localVideo_);
  455.     }
  456.     return value;
  457.   }
  459.   return this.sender_.get('video', name);
  460. };
  463. /**
  464.  * @param {string} name
  465.  * @param {?} value
  466.  * @private
  467.  */
  468. shaka.cast.CastProxy.prototype.videoProxySet_ = function(name, value) {
  469.   if (!this.sender_.isCasting()) {
  470.     this.localVideo_[name] = value;
  471.     return;
  472.   }
  474.   this.sender_.set('video', name, value);
  475. };
  478. /**
  479.  * @param {!Event} event
  480.  * @private
  481.  */
  482. shaka.cast.CastProxy.prototype.videoProxyLocalEvent_ = function(event) {
  483.   if (this.sender_.isCasting()) {
  484.     // Ignore any unexpected local events while casting.  Events can still be
  485.     // fired by the local video and Player when we unload() after the Cast
  486.     // connection is complete.
  487.     return;
  488.   }
  490.   // Convert this real Event into a FakeEvent for dispatch from our
  491.   // FakeEventListener.
  492.   let fakeEvent = new shaka.util.FakeEvent(event.type, event);
  493.   this.videoEventTarget_.dispatchEvent(fakeEvent);
  494. };
  497. /**
  498.  * @param {string} name
  499.  * @return {?}
  500.  * @private
  501.  */
  502. shaka.cast.CastProxy.prototype.playerProxyGet_ = function(name) {
  503.   if (name == 'addEventListener') {
  504.     return this.playerEventTarget_.addEventListener.bind(
  505.         this.playerEventTarget_);
  506.   }
  507.   if (name == 'removeEventListener') {
  508.     return this.playerEventTarget_.removeEventListener.bind(
  509.         this.playerEventTarget_);
  510.   }
  512.   if (name == 'getMediaElement') {
  513.     return function() { return this.videoProxy_; }.bind(this);
  514.   }
  516.   if (name == 'getNetworkingEngine') {
  517.     // Always returns a local instance, in case you need to make a request.
  518.     // Issues a warning, in case you think you are making a remote request
  519.     // or affecting remote filters.
  520.     if (this.sender_.isCasting()) {
  521.       shaka.log.warning('NOTE: getNetworkingEngine() is always local!');
  522.     }
  523.     return this.localPlayer_.getNetworkingEngine.bind(this.localPlayer_);
  524.   }
  526.   if (this.sender_.isCasting()) {
  527.     // These methods are unavailable or otherwise stubbed during casting.
  528.     if (name == 'getManifest' || name == 'drmInfo') {
  529.       return function() {
  530.         shaka.log.alwaysWarn(name + '() does not work while casting!');
  531.         return null;
  532.       };
  533.     }
  535.     if (name == 'attach' || name == 'detach') {
  536.       return function() {
  537.         shaka.log.alwaysWarn(name + '() does not work while casting!');
  538.         return Promise.resolve();
  539.       };
  540.     }
  541.   }  // if (this.sender_.isCasting())
  543.   // If we are casting, but the first update has not come in yet, use local
  544.   // getters, but not local methods.
  545.   if (this.sender_.isCasting() && !this.sender_.hasRemoteProperties()) {
  546.     if (shaka.cast.CastUtils.PlayerGetterMethods[name]) {
  547.       let value = /** @type {Object} */(this.localPlayer_)[name];
  548.       goog.asserts.assert(typeof value == 'function', 'only methods on Player');
  549.       return value.bind(this.localPlayer_);
  550.     }
  551.   }
  553.   // Use local getters and methods if we are not casting.
  554.   if (!this.sender_.isCasting()) {
  555.     let value = /** @type {Object} */(this.localPlayer_)[name];
  556.     goog.asserts.assert(typeof value == 'function', 'only methods on Player');
  557.     return value.bind(this.localPlayer_);
  558.   }
  560.   return this.sender_.get('player', name);
  561. };
  564. /**
  565.  * @param {!Event} event
  566.  * @private
  567.  */
  568. shaka.cast.CastProxy.prototype.playerProxyLocalEvent_ = function(event) {
  569.   if (this.sender_.isCasting()) {
  570.     // Ignore any unexpected local events while casting.
  571.     return;
  572.   }
  574.   this.playerEventTarget_.dispatchEvent(event);
  575. };
  578. /**
  579.  * @param {string} targetName
  580.  * @param {!shaka.util.FakeEvent} event
  581.  * @private
  582.  */
  583. shaka.cast.CastProxy.prototype.onRemoteEvent_ = function(targetName, event) {
  584.   goog.asserts.assert(this.sender_.isCasting(),
  585.                       'Should only receive remote events while casting');
  586.   if (!this.sender_.isCasting()) {
  587.     // Ignore any unexpected remote events.
  588.     return;
  589.   }
  591.   if (targetName == 'video') {
  592.     this.videoEventTarget_.dispatchEvent(event);
  593.   } else if (targetName == 'player') {
  594.     this.playerEventTarget_.dispatchEvent(event);
  595.   }
  596. };