--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/www/js/reconnecting-websocket.js Mon May 18 11:00:59 2020 +0200
@@ -0,0 +1,365 @@
+// MIT License:
+//
+// Copyright (c) 2010-2012, Joe Walnes
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * This behaves like a WebSocket in every way, except if it fails to connect,
+ * or it gets disconnected, it will repeatedly poll until it successfully connects
+ * again.
+ *
+ * It is API compatible, so when you have:
+ * ws = new WebSocket('ws://....');
+ * you can replace with:
+ * ws = new ReconnectingWebSocket('ws://....');
+ *
+ * The event stream will typically look like:
+ * onconnecting
+ * onopen
+ * onmessage
+ * onmessage
+ * onclose // lost connection
+ * onconnecting
+ * onopen // sometime later...
+ * onmessage
+ * onmessage
+ * etc...
+ *
+ * It is API compatible with the standard WebSocket API, apart from the following members:
+ *
+ * - `bufferedAmount`
+ * - `extensions`
+ * - `binaryType`
+ *
+ * Latest version: https://github.com/joewalnes/reconnecting-websocket/
+ * - Joe Walnes
+ *
+ * Syntax
+ * ======
+ * var socket = new ReconnectingWebSocket(url, protocols, options);
+ *
+ * Parameters
+ * ==========
+ * url - The url you are connecting to.
+ * protocols - Optional string or array of protocols.
+ * options - See below
+ *
+ * Options
+ * =======
+ * Options can either be passed upon instantiation or set after instantiation:
+ *
+ * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });
+ *
+ * or
+ *
+ * var socket = new ReconnectingWebSocket(url);
+ * socket.debug = true;
+ * socket.reconnectInterval = 4000;
+ *
+ * debug
+ * - Whether this instance should log debug messages. Accepts true or false. Default: false.
+ *
+ * automaticOpen
+ * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().
+ *
+ * reconnectInterval
+ * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
+ *
+ * maxReconnectInterval
+ * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
+ *
+ * reconnectDecay
+ * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
+ *
+ * timeoutInterval
+ * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
+ *
+ */
+(function (global, factory) {
+ if (typeof define === 'function' && define.amd) {
+ define([], factory);
+ } else if (typeof module !== 'undefined' && module.exports){
+ module.exports = factory();
+ } else {
+ global.ReconnectingWebSocket = factory();
+ }
+})(this, function () {
+
+ if (!('WebSocket' in window)) {
+ return;
+ }
+
+ function ReconnectingWebSocket(url, protocols, options) {
+
+ // Default settings
+ var settings = {
+
+ /** Whether this instance should log debug messages. */
+ debug: false,
+
+ /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
+ automaticOpen: true,
+
+ /** The number of milliseconds to delay before attempting to reconnect. */
+ reconnectInterval: 1000,
+ /** The maximum number of milliseconds to delay a reconnection attempt. */
+ maxReconnectInterval: 30000,
+ /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
+ reconnectDecay: 1.5,
+
+ /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
+ timeoutInterval: 2000,
+
+ /** The maximum number of reconnection attempts to make. Unlimited if null. */
+ maxReconnectAttempts: null,
+
+ /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
+ binaryType: 'blob'
+ }
+ if (!options) { options = {}; }
+
+ // Overwrite and define settings with options if they exist.
+ for (var key in settings) {
+ if (typeof options[key] !== 'undefined') {
+ this[key] = options[key];
+ } else {
+ this[key] = settings[key];
+ }
+ }
+
+ // These should be treated as read-only properties
+
+ /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
+ this.url = url;
+
+ /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
+ this.reconnectAttempts = 0;
+
+ /**
+ * The current state of the connection.
+ * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
+ * Read only.
+ */
+ this.readyState = WebSocket.CONNECTING;
+
+ /**
+ * A string indicating the name of the sub-protocol the server selected; this will be one of
+ * the strings specified in the protocols parameter when creating the WebSocket object.
+ * Read only.
+ */
+ this.protocol = null;
+
+ // Private state variables
+
+ var self = this;
+ var ws;
+ var forcedClose = false;
+ var timedOut = false;
+ var eventTarget = document.createElement('div');
+
+ // Wire up "on*" properties as event handlers
+
+ eventTarget.addEventListener('open', function(event) { self.onopen(event); });
+ eventTarget.addEventListener('close', function(event) { self.onclose(event); });
+ eventTarget.addEventListener('connecting', function(event) { self.onconnecting(event); });
+ eventTarget.addEventListener('message', function(event) { self.onmessage(event); });
+ eventTarget.addEventListener('error', function(event) { self.onerror(event); });
+
+ // Expose the API required by EventTarget
+
+ this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+ this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+ this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+
+ /**
+ * This function generates an event that is compatible with standard
+ * compliant browsers and IE9 - IE11
+ *
+ * This will prevent the error:
+ * Object doesn't support this action
+ *
+ * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
+ * @param s String The name that the event should use
+ * @param args Object an optional object that the event will use
+ */
+ function generateEvent(s, args) {
+ var evt = document.createEvent("CustomEvent");
+ evt.initCustomEvent(s, false, false, args);
+ return evt;
+ };
+
+ this.open = function (reconnectAttempt) {
+ ws = new WebSocket(self.url, protocols || []);
+ ws.binaryType = this.binaryType;
+
+ if (reconnectAttempt) {
+ if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
+ return;
+ }
+ } else {
+ eventTarget.dispatchEvent(generateEvent('connecting'));
+ this.reconnectAttempts = 0;
+ }
+
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'attempt-connect', self.url);
+ }
+
+ var localWs = ws;
+ var timeout = setTimeout(function() {
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'connection-timeout', self.url);
+ }
+ timedOut = true;
+ localWs.close();
+ timedOut = false;
+ }, self.timeoutInterval);
+
+ ws.onopen = function(event) {
+ clearTimeout(timeout);
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'onopen', self.url);
+ }
+ self.protocol = ws.protocol;
+ self.readyState = WebSocket.OPEN;
+ self.reconnectAttempts = 0;
+ var e = generateEvent('open');
+ e.isReconnect = reconnectAttempt;
+ reconnectAttempt = false;
+ eventTarget.dispatchEvent(e);
+ };
+
+ ws.onclose = function(event) {
+ clearTimeout(timeout);
+ ws = null;
+ if (forcedClose) {
+ self.readyState = WebSocket.CLOSED;
+ eventTarget.dispatchEvent(generateEvent('close'));
+ } else {
+ self.readyState = WebSocket.CONNECTING;
+ var e = generateEvent('connecting');
+ e.code = event.code;
+ e.reason = event.reason;
+ e.wasClean = event.wasClean;
+ eventTarget.dispatchEvent(e);
+ if (!reconnectAttempt && !timedOut) {
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'onclose', self.url);
+ }
+ eventTarget.dispatchEvent(generateEvent('close'));
+ }
+
+ var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
+ setTimeout(function() {
+ self.reconnectAttempts++;
+ self.open(true);
+ }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
+ }
+ };
+ ws.onmessage = function(event) {
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data);
+ }
+ var e = generateEvent('message');
+ e.data = event.data;
+ eventTarget.dispatchEvent(e);
+ };
+ ws.onerror = function(event) {
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'onerror', self.url, event);
+ }
+ eventTarget.dispatchEvent(generateEvent('error'));
+ };
+ }
+
+ // Whether or not to create a websocket upon instantiation
+ if (this.automaticOpen == true) {
+ this.open(false);
+ }
+
+ /**
+ * Transmits data to the server over the WebSocket connection.
+ *
+ * @param data a text string, ArrayBuffer or Blob to send to the server.
+ */
+ this.send = function(data) {
+ if (ws) {
+ if (self.debug || ReconnectingWebSocket.debugAll) {
+ console.debug('ReconnectingWebSocket', 'send', self.url, data);
+ }
+ return ws.send(data);
+ } else {
+ throw 'INVALID_STATE_ERR : Pausing to reconnect websocket';
+ }
+ };
+
+ /**
+ * Closes the WebSocket connection or connection attempt, if any.
+ * If the connection is already CLOSED, this method does nothing.
+ */
+ this.close = function(code, reason) {
+ // Default CLOSE_NORMAL code
+ if (typeof code == 'undefined') {
+ code = 1000;
+ }
+ forcedClose = true;
+ if (ws) {
+ ws.close(code, reason);
+ }
+ };
+
+ /**
+ * Additional public API method to refresh the connection if still open (close, re-open).
+ * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
+ */
+ this.refresh = function() {
+ if (ws) {
+ ws.close();
+ }
+ };
+ }
+
+ /**
+ * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+ * this indicates that the connection is ready to send and receive data.
+ */
+ ReconnectingWebSocket.prototype.onopen = function(event) {};
+ /** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
+ ReconnectingWebSocket.prototype.onclose = function(event) {};
+ /** An event listener to be called when a connection begins being attempted. */
+ ReconnectingWebSocket.prototype.onconnecting = function(event) {};
+ /** An event listener to be called when a message is received from the server. */
+ ReconnectingWebSocket.prototype.onmessage = function(event) {};
+ /** An event listener to be called when an error occurs. */
+ ReconnectingWebSocket.prototype.onerror = function(event) {};
+
+ /**
+ * Whether all instances of ReconnectingWebSocket should log debug messages.
+ * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
+ */
+ ReconnectingWebSocket.debugAll = false;
+
+ ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+ ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+ ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+ ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+
+ return ReconnectingWebSocket;
+});