remoting/webapp/crd/js/desktop_connected_view.js

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview
   7  * Class handling user-facing aspects of the client session.
   8  */
   9
  10 'use strict';
  11
  12 /** @suppress {duplicate} */
  13 var remoting = remoting || {};
  14
  15 /**
  16  * @param {HTMLElement} container
  17  * @param {remoting.ConnectionInfo} connectionInfo
  18  * @constructor
  19  * @extends {base.EventSourceImpl}
  20  * @implements {base.Disposable}
  21  */
  22 remoting.DesktopConnectedView = function(container, connectionInfo) {
  23
  24   /** @private {HTMLElement} */
  25   this.container_ = container;
  26
  27   /** @private {remoting.ClientPlugin} */
  28   this.plugin_ = connectionInfo.plugin();
  29
  30   /** @private {remoting.ClientSession} */
  31   this.session_ = connectionInfo.session();
  32
  33   /** @private */
  34   this.host_ = connectionInfo.host();
  35
  36   /** @private {remoting.DesktopViewport} */
  37   this.viewport_ = null;
  38
  39   /** private {remoting.ConnectedView} */
  40   this.view_ = null;
  41
  42   /** @private {remoting.VideoFrameRecorder} */
  43   this.videoFrameRecorder_ = null;
  44
  45   /** private {base.Disposable} */
  46   this.eventHooks_ = null;
  47
  48   /** @private */
  49   this.stats_ = new remoting.ConnectionStats(
  50       document.getElementById('statistics'), connectionInfo.plugin());
  51
  52   this.initPlugin_();
  53   this.initUI_();
  54 };
  55
  56 /** @return {void} Nothing. */
  57 remoting.DesktopConnectedView.prototype.dispose = function() {
  58   if (remoting.windowFrame) {
  59     remoting.windowFrame.setDesktopConnectedView(null);
  60   }
  61   if (remoting.toolbar) {
  62     remoting.toolbar.setDesktopConnectedView(null);
  63   }
  64   if (remoting.optionsMenu) {
  65     remoting.optionsMenu.setDesktopConnectedView(null);
  66   }
  67
  68   document.body.classList.remove('connected');
  69
  70   base.dispose(this.eventHooks_);
  71   this.eventHooks_ = null;
  72
  73   base.dispose(this.viewport_);
  74   this.viewport_ = null;
  75
  76   base.dispose(this.stats_);
  77   this.stats = null;
  78 };
  79
  80 /**
  81  * Get host display name.
  82  *
  83  * @return {string}
  84  */
  85 remoting.DesktopConnectedView.prototype.getHostDisplayName = function() {
  86   return this.host_.hostName;
  87 };
  88
  89 /**
  90  * @return {boolean} True if shrink-to-fit is enabled; false otherwise.
  91  */
  92 remoting.DesktopConnectedView.prototype.getShrinkToFit = function() {
  93   if (this.viewport_) {
  94     return this.viewport_.getShrinkToFit();
  95   }
  96   return false;
  97 };
  98
  99 /**
 100  * @return {boolean} True if resize-to-client is enabled; false otherwise.
 101  */
 102 remoting.DesktopConnectedView.prototype.getResizeToClient = function() {
 103   if (this.viewport_) {
 104     return this.viewport_.getResizeToClient();
 105   }
 106   return false;
 107 };
 108
 109 /**
 110  * @return {boolean} True if the right-hand Ctrl key is mapped to the Meta
 111  *     (Windows, Command) key.
 112  */
 113 remoting.DesktopConnectedView.prototype.getMapRightCtrl = function() {
 114   return this.host_.options.remapKeys[0x0700e4] === 0x0700e7;
 115 };
 116
 117 remoting.DesktopConnectedView.prototype.toggleStats = function() {
 118   this.stats_.toggle();
 119 };
 120
 121 /**
 122  * @return {boolean} True if the connection stats is visible; false otherwise.
 123  */
 124 remoting.DesktopConnectedView.prototype.isStatsVisible = function() {
 125   return this.stats_.isVisible();
 126 };
 127
 128 /**
 129  * @return {Element} The element that should host the plugin.
 130  * @private
 131  */
 132 remoting.DesktopConnectedView.prototype.getPluginContainer_ = function() {
 133   return this.container_.querySelector('.client-plugin-container');
 134 };
 135
 136 /** @return {remoting.DesktopViewport} */
 137 remoting.DesktopConnectedView.prototype.getViewportForTesting = function() {
 138   return this.viewport_;
 139 };
 140
 141 /** @return {remoting.ConnectedView} */
 142 remoting.DesktopConnectedView.prototype.getConnectedViewForTesting =
 143     function() {
 144   return this.view_;
 145 };
 146
 147 /** @private */
 148 remoting.DesktopConnectedView.prototype.initPlugin_ = function() {
 149   console.assert(remoting.app instanceof remoting.DesktopRemoting,
 150                 '|remoting.app| is not an instance of DesktopRemoting.');
 151   var drApp = /** @type {remoting.DesktopRemoting} */ (remoting.app);
 152   var mode = drApp.getConnectionMode();
 153
 154   // Show the Send Keys menu only if the plugin has the injectKeyEvent feature,
 155   // and the Ctrl-Alt-Del button only in Me2Me mode.
 156   if (!this.plugin_.hasFeature(
 157           remoting.ClientPlugin.Feature.INJECT_KEY_EVENT)) {
 158     var sendKeysElement = document.getElementById('send-keys-menu');
 159     sendKeysElement.hidden = true;
 160   } else if (mode == remoting.DesktopRemoting.Mode.IT2ME) {
 161     var sendCadElement = document.getElementById('send-ctrl-alt-del');
 162     sendCadElement.hidden = true;
 163   }
 164 };
 165
 166 /**
 167  * This is a callback that gets called when the window is resized.
 168  *
 169  * @return {void} Nothing.
 170  * @private.
 171  */
 172 remoting.DesktopConnectedView.prototype.onResize_ = function() {
 173   if (this.viewport_) {
 174     this.viewport_.onResize();
 175   }
 176 };
 177
 178 /** @private */
 179 remoting.DesktopConnectedView.prototype.initUI_ = function() {
 180   document.body.classList.add('connected');
 181
 182   this.view_ = new remoting.ConnectedView(
 183       this.plugin_, this.container_,
 184       this.container_.querySelector('.mouse-cursor-overlay'));
 185
 186   var scrollerElement = document.getElementById('scroller');
 187   this.viewport_ = new remoting.DesktopViewport(
 188       scrollerElement || document.body,
 189       this.plugin_.hostDesktop(),
 190       this.host_.options);
 191
 192   if (remoting.windowFrame) {
 193     remoting.windowFrame.setDesktopConnectedView(this);
 194   }
 195   if (remoting.toolbar) {
 196     remoting.toolbar.setDesktopConnectedView(this);
 197   }
 198   if (remoting.optionsMenu) {
 199     remoting.optionsMenu.setDesktopConnectedView(this);
 200   }
 201
 202   // Activate full-screen related UX.
 203   this.eventHooks_ = new base.Disposables(
 204     this.view_,
 205     new base.EventHook(this.session_,
 206                        remoting.ClientSession.Events.videoChannelStateChanged,
 207                        this.view_.onConnectionReady.bind(this.view_)),
 208     new base.DomEventHook(window, 'resize', this.onResize_.bind(this), false),
 209     new remoting.Fullscreen.EventHook(this.onFullScreenChanged_.bind(this)));
 210   this.onFullScreenChanged_(remoting.fullscreen.isActive());
 211 };
 212
 213 /**
 214  * Set the shrink-to-fit and resize-to-client flags and save them if this is
 215  * a Me2Me connection.
 216  *
 217  * @param {boolean} shrinkToFit True if the remote desktop should be scaled
 218  *     down if it is larger than the client window; false if scroll-bars
 219  *     should be added in this case.
 220  * @param {boolean} resizeToClient True if window resizes should cause the
 221  *     host to attempt to resize its desktop to match the client window size;
 222  *     false to disable this behaviour for subsequent window resizes--the
 223  *     current host desktop size is not restored in this case.
 224  * @return {void} Nothing.
 225  */
 226 remoting.DesktopConnectedView.prototype.setScreenMode =
 227     function(shrinkToFit, resizeToClient) {
 228   this.viewport_.setScreenMode(shrinkToFit, resizeToClient);
 229 };
 230
 231 /**
 232  * Called when the full-screen status has changed, either via the
 233  * remoting.Fullscreen class, or via a system event such as the Escape key
 234  *
 235  * @param {boolean=} fullscreen True if the app is entering full-screen mode;
 236  *     false if it is leaving it.
 237  * @private
 238  */
 239 remoting.DesktopConnectedView.prototype.onFullScreenChanged_ = function (
 240     fullscreen) {
 241   if (this.viewport_) {
 242     // When a window goes full-screen, a resize event is triggered, but the
 243     // Fullscreen.isActive call is not guaranteed to return true until the
 244     // full-screen event is triggered. In apps v2, the size of the window's
 245     // client area is calculated differently in full-screen mode, so register
 246     // for both events.
 247     this.viewport_.onResize();
 248     this.viewport_.enableBumpScroll(Boolean(fullscreen));
 249   }
 250 };
 251
 252 /**
 253  * Set whether or not the right-hand Ctrl key should send the Meta (Windows,
 254  * Command) key-code.
 255  *
 256  * @param {boolean} enable True to enable the mapping; false to disable.
 257  */
 258 remoting.DesktopConnectedView.prototype.setMapRightCtrl = function(enable) {
 259   if (enable === this.getMapRightCtrl()) {
 260     return;  // In case right Ctrl is mapped, but not to right Meta.
 261   }
 262
 263   if (enable) {
 264     this.host_.options.remapKeys[0x0700e4] = 0x0700e7;
 265   } else {
 266     delete this.host_.options.remapKeys[0x0700e4]
 267   }
 268   this.setRemapKeys(this.host_.options.remapKeys);
 269 };
 270
 271 /**
 272  * Sends a Ctrl-Alt-Del sequence to the remoting client.
 273  *
 274  * @return {void} Nothing.
 275  */
 276 remoting.DesktopConnectedView.prototype.sendCtrlAltDel = function() {
 277   console.log('Sending Ctrl-Alt-Del.');
 278   this.plugin_.injectKeyCombination([0x0700e0, 0x0700e2, 0x07004c]);
 279 };
 280
 281 /**
 282  * Sends a Print Screen keypress to the remoting client.
 283  *
 284  * @return {void} Nothing.
 285  */
 286 remoting.DesktopConnectedView.prototype.sendPrintScreen = function() {
 287   console.log('Sending Print Screen.');
 288   this.plugin_.injectKeyCombination([0x070046]);
 289 };
 290
 291 /**
 292  * Sets and stores the key remapping setting for the current host. If set,
 293  * these mappings override the defaults for the client platform.
 294  *
 295  * @param {!Object} remappings
 296  */
 297 remoting.DesktopConnectedView.prototype.setRemapKeys = function(remappings) {
 298   this.plugin_.setRemapKeys(remappings);
 299   // Save the new remapping setting.
 300   this.host_.options.remapKeys =
 301       /** @type {!Object} */ (base.deepCopy(remappings));
 302   this.host_.options.save();
 303 };
 304
 305 /** @param {remoting.VideoFrameRecorder} recorder */
 306 remoting.DesktopConnectedView.prototype.setVideoFrameRecorder =
 307     function(recorder) {
 308   this.videoFrameRecorder_ = recorder;
 309 };
 310
 311 /**
 312  * Returns true if the ClientSession can record video frames to a file.
 313  * @return {boolean}
 314  */
 315 remoting.DesktopConnectedView.prototype.canRecordVideo = function() {
 316   return !!this.videoFrameRecorder_;
 317 };
 318
 319 /**
 320  * Returns true if the ClientSession is currently recording video frames.
 321  * @return {boolean}
 322  */
 323 remoting.DesktopConnectedView.prototype.isRecordingVideo = function() {
 324   if (!this.videoFrameRecorder_) {
 325     return false;
 326   }
 327   return this.videoFrameRecorder_.isRecording();
 328 };
 329
 330 /**
 331  * Starts or stops recording of video frames.
 332  */
 333 remoting.DesktopConnectedView.prototype.startStopRecording = function() {
 334   if (this.videoFrameRecorder_) {
 335     this.videoFrameRecorder_.startStopRecording();
 336   }
 337 };