Source: main/webapp/modules/ArrayBufferWriter.js

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *   http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing,
  13.  * software distributed under the License is distributed on an
  14.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15.  * KIND, either express or implied.  See the License for the
  16.  * specific language governing permissions and limitations
  17.  * under the License.
  18.  */
  20. var Guacamole = Guacamole || {};
  22. /**
  23.  * A writer which automatically writes to the given output stream with arbitrary
  24.  * binary data, supplied as ArrayBuffers.
  25.  * 
  26.  * @constructor
  27.  * @param {!Guacamole.OutputStream} stream
  28.  *     The stream that data will be written to.
  29.  */
  30. Guacamole.ArrayBufferWriter = function(stream) {
  32.     /**
  33.      * Reference to this Guacamole.StringWriter.
  34.      *
  35.      * @private
  36.      * @type {!Guacamole.ArrayBufferWriter}
  37.      */
  38.     var guac_writer = this;
  40.     // Simply call onack for acknowledgements
  41.     stream.onack = function(status) {
  42.         if (guac_writer.onack)
  43.             guac_writer.onack(status);
  44.     };
  46.     /**
  47.      * Encodes the given data as base64, sending it as a blob. The data must
  48.      * be small enough to fit into a single blob instruction.
  49.      * 
  50.      * @private
  51.      * @param {!Uint8Array} bytes
  52.      *     The data to send.
  53.      */
  54.     function __send_blob(bytes) {
  56.         var binary = "";
  58.         // Produce binary string from bytes in buffer
  59.         for (var i=0; i<bytes.byteLength; i++)
  60.             binary += String.fromCharCode(bytes[i]);
  62.         // Send as base64
  63.         stream.sendBlob(window.btoa(binary));
  65.     }
  67.     /**
  68.      * The maximum length of any blob sent by this Guacamole.ArrayBufferWriter,
  69.      * in bytes. Data sent via
  70.      * [sendData()]{@link Guacamole.ArrayBufferWriter#sendData} which exceeds
  71.      * this length will be split into multiple blobs. As the Guacamole protocol
  72.      * limits the maximum size of any instruction or instruction element to
  73.      * 8192 bytes, and the contents of blobs will be base64-encoded, this value
  74.      * should only be increased with extreme caution.
  75.      *
  76.      * @type {!number}
  77.      * @default {@link Guacamole.ArrayBufferWriter.DEFAULT_BLOB_LENGTH}
  78.      */
  79.     this.blobLength = Guacamole.ArrayBufferWriter.DEFAULT_BLOB_LENGTH;
  81.     /**
  82.      * Sends the given data.
  83.      * 
  84.      * @param {!(ArrayBuffer|TypedArray)} data
  85.      *     The data to send.
  86.      */
  87.     this.sendData = function(data) {
  89.         var bytes = new Uint8Array(data);
  91.         // If small enough to fit into single instruction, send as-is
  92.         if (bytes.length <= guac_writer.blobLength)
  93.             __send_blob(bytes);
  95.         // Otherwise, send as multiple instructions
  96.         else {
  97.             for (var offset=0; offset<bytes.length; offset += guac_writer.blobLength)
  98.                 __send_blob(bytes.subarray(offset, offset + guac_writer.blobLength));
  99.         }
  101.     };
  103.     /**
  104.      * Signals that no further text will be sent, effectively closing the
  105.      * stream.
  106.      */
  107.     this.sendEnd = function() {
  108.         stream.sendEnd();
  109.     };
  111.     /**
  112.      * Fired for received data, if acknowledged by the server.
  113.      * @event
  114.      * @param {!Guacamole.Status} status
  115.      *     The status of the operation.
  116.      */
  117.     this.onack = null;
  119. };
  121. /**
  122.  * The default maximum blob length for new Guacamole.ArrayBufferWriter
  123.  * instances.
  124.  *
  125.  * @constant
  126.  * @type {!number}
  127.  */
  128. Guacamole.ArrayBufferWriter.DEFAULT_BLOB_LENGTH = 6048;