remoting/webapp/base/js/client_plugin.js

   1 // Copyright 2014 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  * Interface abstracting the ClientPlugin functionality.
   8  */
   9
  10 'use strict';
  11
  12 /** @suppress {duplicate} */
  13 var remoting = remoting || {};
  14
  15 /**
  16  * @interface
  17  * @extends {base.Disposable}
  18  */
  19 remoting.ClientPlugin = function() {};
  20
  21 /**
  22  * @return {remoting.HostDesktop}
  23  */
  24 remoting.ClientPlugin.prototype.hostDesktop = function() {};
  25
  26 /**
  27  * @return {remoting.ProtocolExtensionManager}
  28  */
  29 remoting.ClientPlugin.prototype.extensions = function() {};
  30
  31 /**
  32  * @return {HTMLElement} The DOM element representing the remote session.
  33  */
  34 remoting.ClientPlugin.prototype.element = function() {};
  35
  36 /**
  37  * @param {function(boolean):void} onDone Completion callback.
  38  */
  39 remoting.ClientPlugin.prototype.initialize = function(onDone) {};
  40
  41 /**
  42  * @param {remoting.Host} host The host to connect to.
  43  * @param {string} localJid Local jid.
  44  * @param {remoting.CredentialsProvider} credentialsProvider
  45  */
  46 remoting.ClientPlugin.prototype.connect =
  47     function(host, localJid, credentialsProvider) {};
  48
  49 /**
  50  * @param {number} key The keycode to inject.
  51  * @param {boolean} down True for press; false for a release.
  52  */
  53 remoting.ClientPlugin.prototype.injectKeyEvent =
  54     function(key, down) {};
  55
  56 /**
  57  * Sends a key combination to the host, by sending down events for
  58  * the given keys, followed by up events in reverse order.
  59  *
  60  * @param {Array<number>} keys Key codes to be sent.
  61  * @return {void} Nothing.
  62  */
  63 remoting.ClientPlugin.prototype.injectKeyCombination = function(keys) {};
  64
  65 /**
  66  * Sets and stores the key remapping setting for the current host.
  67  *
  68  * @param {!Object} remappings Key mappings, specified as {from: to}, where
  69  *     |from| and |to| are both USB keycodes, |from| is a decimal representation
  70  *     (because object keys must be strings) and |to| is a number.
  71  */
  72 remoting.ClientPlugin.prototype.setRemapKeys = function(remappings) {};
  73
  74 /**
  75  * @param {number} from
  76  * @param {number} to
  77  */
  78 remoting.ClientPlugin.prototype.remapKey = function(from, to) {};
  79
  80 /**
  81  * Release all keys currently being pressed.
  82  */
  83 remoting.ClientPlugin.prototype.releaseAllKeys = function() {};
  84
  85 /**
  86  * @param {string} iq
  87  */
  88 remoting.ClientPlugin.prototype.onIncomingIq = function(iq) {};
  89
  90 /**
  91  * @return {boolean} True if the web-app and plugin are compatible.
  92  */
  93 remoting.ClientPlugin.prototype.isSupportedVersion = function() {};
  94
  95 /**
  96  * @param {remoting.ClientPlugin.Feature} feature
  97  * @return {boolean} True if the plugin supports the specified feature.
  98  */
  99 remoting.ClientPlugin.prototype.hasFeature = function(feature) {};
 100
 101
 102 /**
 103  * @param {remoting.ClientSession.Capability} capability
 104  * @return {boolean} True if the capability has been negotiated between
 105  *     the client and host.
 106  */
 107 remoting.ClientPlugin.prototype.hasCapability = function(capability) {};
 108
 109 /**
 110  * Sends a clipboard item to the host.
 111  *
 112  * @param {string} mimeType The MIME type of the clipboard item.
 113  * @param {string} item The clipboard item.
 114  */
 115 remoting.ClientPlugin.prototype.sendClipboardItem =
 116     function(mimeType, item) {};
 117
 118 /**
 119  * Notifies the plugin whether to send touch events to the host.
 120  *
 121  * @param {boolean} enable True if touch events should be sent.
 122  */
 123 remoting.ClientPlugin.prototype.enableTouchEvents = function(enable) {};
 124
 125 /**
 126  * Request that this client be paired with the current host.
 127  *
 128  * @param {string} clientName The human-readable name of the client.
 129  * @param {function(string, string):void} onDone Callback to receive the
 130  *     client id and shared secret when they are available.
 131  */
 132 remoting.ClientPlugin.prototype.requestPairing =
 133     function(clientName, onDone) {};
 134
 135 /**
 136  * Allows automatic mouse-lock.
 137  */
 138 remoting.ClientPlugin.prototype.allowMouseLock = function() {};
 139
 140 /**
 141  * @param {boolean} pause True to pause the audio stream; false to resume it.
 142  */
 143 remoting.ClientPlugin.prototype.pauseAudio = function(pause) {};
 144
 145 /**
 146  * @param {boolean} pause True to pause the video stream; false to resume it.
 147  */
 148 remoting.ClientPlugin.prototype.pauseVideo = function(pause) {};
 149
 150 /**
 151  * @return {remoting.ClientSession.PerfStats} A summary of the connection
 152  *     performance.
 153  */
 154 remoting.ClientPlugin.prototype.getPerfStats = function() {};
 155
 156 /**
 157  * @param {remoting.ClientPlugin.ConnectionEventHandler} handler
 158  */
 159 remoting.ClientPlugin.prototype.setConnectionEventHandler =
 160     function(handler) {};
 161
 162 /**
 163  * @param {function(string, number, number):void} handler Callback for
 164  *     processing large mouse cursor images. The first parameter is a data:
 165  *     URL encoding the mouse cursor; the second and third parameters are
 166  *     the cursor hotspot's x- and y-coordinates, respectively.
 167  */
 168 remoting.ClientPlugin.prototype.setMouseCursorHandler = function(handler) {};
 169
 170 /**
 171  * @param {function(string, string):void} handler Callback for processing
 172  *    clipboard data injected from the host. The first parameter is the mime
 173  *    type and the second parameter is the actual data.
 174  */
 175 remoting.ClientPlugin.prototype.setClipboardHandler = function(handler) {};
 176
 177 /**
 178  * @param {function({rects:Array<Array<number>>}):void|null} handler Callback
 179  *     to receive dirty region information for each video frame, for debugging.
 180  */
 181 remoting.ClientPlugin.prototype.setDebugDirtyRegionHandler =
 182     function(handler) {};
 183
 184
 185 /**
 186  * Set of features for which hasFeature() can be used to test.
 187  *
 188  * @enum {string}
 189  */
 190 remoting.ClientPlugin.Feature = {
 191   INJECT_KEY_EVENT: 'injectKeyEvent',
 192   NOTIFY_CLIENT_RESOLUTION: 'notifyClientResolution',
 193   ASYNC_PIN: 'asyncPin',
 194   PAUSE_VIDEO: 'pauseVideo',
 195   PAUSE_AUDIO: 'pauseAudio',
 196   REMAP_KEY: 'remapKey',
 197   SEND_CLIPBOARD_ITEM: 'sendClipboardItem',
 198   THIRD_PARTY_AUTH: 'thirdPartyAuth',
 199   TRAP_KEY: 'trapKey',
 200   PINLESS_AUTH: 'pinlessAuth',
 201   ALLOW_MOUSE_LOCK: 'allowMouseLock',
 202   EXTENSION_MESSAGE: 'extensionMessage',
 203   VIDEO_CONTROL: 'videoControl'
 204 };
 205
 206
 207 /**
 208  * @interface
 209  */
 210 remoting.ClientPlugin.ConnectionEventHandler = function() {};
 211
 212 /**
 213  * @param {string} iq
 214  */
 215 remoting.ClientPlugin.ConnectionEventHandler.prototype.onOutgoingIq =
 216     function(iq) {};
 217
 218 /**
 219  * @param {string} msg
 220  */
 221 remoting.ClientPlugin.ConnectionEventHandler.prototype.onDebugMessage =
 222     function(msg) {};
 223
 224 /**
 225  * @param {remoting.ClientSession.State} status The plugin's status.
 226  * @param {remoting.ClientSession.ConnectionError} error The plugin's error
 227  *        state, if any.
 228  */
 229 remoting.ClientPlugin.ConnectionEventHandler.prototype.
 230     onConnectionStatusUpdate = function(status, error) {};
 231
 232 /**
 233  * @param {string} channel The channel name.
 234  * @param {string} connectionType The new connection type.
 235  */
 236 remoting.ClientPlugin.ConnectionEventHandler.prototype.onRouteChanged =
 237     function(channel, connectionType) {};
 238
 239 /**
 240  * @param {boolean} ready True if the connection is ready.
 241  */
 242 remoting.ClientPlugin.ConnectionEventHandler.prototype.onConnectionReady =
 243     function(ready) {};
 244
 245 /** Called when the first video frame is received */
 246 remoting.ClientPlugin.ConnectionEventHandler.prototype.onFirstFrameReceived =
 247     function() {};
 248
 249 /**
 250  * @interface
 251  */
 252 remoting.ClientPluginFactory = function() {};
 253
 254 /**
 255  * @param {Element} container The container for the embed element.
 256  * @param {Array<string>} requiredCapabilities
 257  * @return {remoting.ClientPlugin} A new client plugin instance.
 258  */
 259 remoting.ClientPluginFactory.prototype.createPlugin =
 260     function(container, requiredCapabilities) {};
 261
 262 /**
 263  * Preload the plugin to make instantiation faster when the user tries
 264  * to connect.
 265  */
 266 remoting.ClientPluginFactory.prototype.preloadPlugin = function() {};
 267
 268 /**
 269  * @type {remoting.ClientPluginFactory}
 270  */
 271 remoting.ClientPlugin.factory = null;