hap-nodejs 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/lib/util/eventedhttp.js

@@ -12,26 +12,32 @@ var os_1 = tslib_1.__importDefault(require("os"));
 var hapCrypto = tslib_1.__importStar(require("./hapCrypto"));
 var net_utils_1 = require("./net-utils");
 var uuid = tslib_1.__importStar(require("./uuid"));
-var debug = debug_1.default('HAP-NodeJS:EventedHTTPServer');
-var debugCon = debug_1.default("HAP-NodeJS:EventedHTTPServer:Connection");
+var debug = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer");
+var debugCon = (0, debug_1.default)("HAP-NodeJS:EventedHTTPServer:Connection");
+var debugEvents = (0, debug_1.default)("HAP-NodeJS:EventEmitter");
 /**
  * Simple struct to hold vars needed to support HAP encryption.
+ *
+ * @group Cryptography
  */
 var HAPEncryption = /** @class */ (function () {
     function HAPEncryption(clientPublicKey, secretKey, publicKey, sharedSecret, hkdfPairEncryptionKey) {
         this.accessoryToControllerCount = 0;
         this.controllerToAccessoryCount = 0;
-        this.accessoryToControllerKey = Buffer.alloc(0);
-        this.controllerToAccessoryKey = Buffer.alloc(0);
         this.clientPublicKey = clientPublicKey;
         this.secretKey = secretKey;
         this.publicKey = publicKey;
         this.sharedSecret = sharedSecret;
         this.hkdfPairEncryptionKey = hkdfPairEncryptionKey;
+        this.accessoryToControllerKey = Buffer.alloc(0);
+        this.controllerToAccessoryKey = Buffer.alloc(0);
     }
     return HAPEncryption;
 }());
 exports.HAPEncryption = HAPEncryption;
+/**
+ * @group HAP Accessory Server
+ */
 var EventedHTTPServerEvent;
 (function (EventedHTTPServerEvent) {
     EventedHTTPServerEvent["LISTENING"] = "listening";
@@ -45,7 +51,7 @@ var EventedHTTPServerEvent;
  * Implementation
  * --------------
  * In order to implement the "custom HTTP" server required by the HAP protocol (see HAPServer.js) without completely
- * reinventing the wheel, we create both a generic TCP socket server as well as a standard Node HTTP server.
+ * reinventing the wheel, we create both a generic TCP socket server and a standard Node HTTP server.
  * The TCP socket server acts as a proxy, allowing users of this class to transform data (for encryption) as necessary
  * and passing through bytes directly to the HTTP server for processing. This way we get Node to do all
  * the "heavy lifting" of HTTP like parsing headers and formatting responses.
@@ -55,6 +61,8 @@ var EventedHTTPServerEvent;
  *
  * Each connection to the main TCP server gets its own internal HTTP server, so we can track ongoing requests/responses
  * for safe event insertion.
+ *
+ * @group HAP Accessory Server
  */
 var EventedHTTPServer = /** @class */ (function (_super) {
     tslib_1.__extends(EventedHTTPServer, _super);
@@ -70,32 +78,10 @@ var EventedHTTPServer = /** @class */ (function (_super) {
          */
         _this.connectionsByUsername = new Map();
         _this.tcpServer = net_1.default.createServer();
-        var interval = setInterval(function () {
-            var e_1, _a;
-            var connectionString = "";
-            try {
-                for (var _b = tslib_1.__values(_this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var connection = _c.value;
-                    if (connectionString) {
-                        connectionString += ", ";
-                    }
-                    connectionString += connection.remoteAddress + ":" + connection.remotePort;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            debug("Currently " + _this.connections.size + " hap connections open: " + connectionString);
-        }, 60000);
-        interval.unref();
         return _this;
     }
     EventedHTTPServer.prototype.scheduleNextConnectionIdleTimeout = function () {
-        var e_2, _a;
+        var e_1, _a;
         this.connectionIdleTimeout = undefined;
         if (!this.tcpServer.listening) {
             return;
@@ -116,28 +102,45 @@ var EventedHTTPServer = /** @class */ (function (_super) {
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_1) throw e_1.error; }
         }
         if (this.connections.size >= EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT) {
             this.connectionIdleTimeout = setTimeout(this.scheduleNextConnectionIdleTimeout.bind(this), nextTimeout);
         }
     };
+    EventedHTTPServer.prototype.address = function () {
+        return this.tcpServer.address();
+    };
     EventedHTTPServer.prototype.listen = function (targetPort, hostname) {
         var _this = this;
         this.tcpServer.listen(targetPort, hostname, function () {
             var address = _this.tcpServer.address(); // address() is only a string when listening to unix domain sockets
-            debug("Server listening on %s:%s", address.family === "IPv6" ? "[" + address.address + "]" : address.address, address.port);
-            _this.emit("listening" /* LISTENING */, address.port, address.address);
+            debug("Server listening on %s:%s", address.family === "IPv6" ? "[".concat(address.address, "]") : address.address, address.port);
+            _this.connectionLoggingInterval = setInterval(function () {
+                var connectionInformation = tslib_1.__spreadArray([], tslib_1.__read(_this.connections), false).map(function (connection) { return "".concat(connection.remoteAddress, ":").concat(connection.remotePort); })
+                    .join(", ");
+                debug("Currently %d hap connections open: %s", _this.connections.size, connectionInformation);
+            }, 60000);
+            _this.connectionLoggingInterval.unref();
+            _this.emit("listening" /* EventedHTTPServerEvent.LISTENING */, address.port, address.address);
         });
         this.tcpServer.on("connection", this.onConnection.bind(this));
     };
     EventedHTTPServer.prototype.stop = function () {
-        var e_3, _a;
+        var e_2, _a;
+        if (this.connectionLoggingInterval != null) {
+            clearInterval(this.connectionLoggingInterval);
+            this.connectionLoggingInterval = undefined;
+        }
+        if (this.connectionIdleTimeout != null) {
+            clearTimeout(this.connectionIdleTimeout);
+            this.connectionIdleTimeout = undefined;
+        }
         this.tcpServer.close();
         try {
             for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -145,12 +148,12 @@ var EventedHTTPServer = /** @class */ (function (_super) {
                 connection.close();
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_2) throw e_2.error; }
         }
     };
     EventedHTTPServer.prototype.destroy = function () {
@@ -158,18 +161,18 @@ var EventedHTTPServer = /** @class */ (function (_super) {
         this.removeAllListeners();
     };
     /**
-     * Send a even notification for given characteristic and changed value to all connected clients.
-     * If {@param originator} is specified, the given {@link HAPConnection} will be excluded from the broadcast.
+     * Send an event notification for given characteristic and changed value to all connected clients.
+     * If `originator` is specified, the given {@link HAPConnection} will be excluded from the broadcast.
      *
      * @param aid - The accessory id of the updated characteristic.
      * @param iid - The instance id of the updated characteristic.
      * @param value - The newly set value of the characteristic.
-     * @param originator - If specified, the connection will not get a event message.
+     * @param originator - If specified, the connection will not get an event message.
      * @param immediateDelivery - The HAP spec requires some characteristics to be delivery immediately.
-     *   Namely for the {@link ButtonEvent} and the {@link ProgrammableSwitchEvent} characteristics.
+     *   Namely, for the {@link Characteristic.ButtonEvent} and the {@link Characteristic.ProgrammableSwitchEvent} characteristics.
      */
     EventedHTTPServer.prototype.broadcastEvent = function (aid, iid, value, originator, immediateDelivery) {
-        var e_4, _a;
+        var e_3, _a;
         try {
             for (var _b = tslib_1.__values(this.connections), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var connection = _c.value;
@@ -180,25 +183,26 @@ var EventedHTTPServer = /** @class */ (function (_super) {
                 connection.sendEvent(aid, iid, value, immediateDelivery);
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_3) throw e_3.error; }
         }
     };
     EventedHTTPServer.prototype.onConnection = function (socket) {
         var _this = this;
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
         var connection = new HAPConnection(this, socket);
-        connection.on("request" /* REQUEST */, function (request, response) {
-            _this.emit("request" /* REQUEST */, connection, request, response);
+        connection.on("request" /* HAPConnectionEvent.REQUEST */, function (request, response) {
+            _this.emit("request" /* EventedHTTPServerEvent.REQUEST */, connection, request, response);
         });
-        connection.on("authenticated" /* AUTHENTICATED */, this.handleConnectionAuthenticated.bind(this, connection));
-        connection.on("closed" /* CLOSED */, this.handleConnectionClose.bind(this, connection));
+        connection.on("authenticated" /* HAPConnectionEvent.AUTHENTICATED */, this.handleConnectionAuthenticated.bind(this, connection));
+        connection.on("closed" /* HAPConnectionEvent.CLOSED */, this.handleConnectionClose.bind(this, connection));
         this.connections.add(connection);
         debug("[%s] New connection from client on interface %s (%s)", connection.remoteAddress, connection.networkInterface, connection.localAddress);
-        this.emit("connection-opened" /* CONNECTION_OPENED */, connection);
+        this.emit("connection-opened" /* EventedHTTPServerEvent.CONNECTION_OPENED */, connection);
         if (this.connections.size >= EventedHTTPServer.CONNECTION_TIMEOUT_LIMIT && !this.connectionIdleTimeout) {
             this.scheduleNextConnectionIdleTimeout();
         }
@@ -213,7 +217,7 @@ var EventedHTTPServer = /** @class */ (function (_super) {
         }
     };
     EventedHTTPServer.prototype.handleConnectionClose = function (connection) {
-        this.emit("connection-closed" /* CONNECTION_CLOSED */, connection);
+        this.emit("connection-closed" /* EventedHTTPServerEvent.CONNECTION_CLOSED */, connection);
         this.connections.delete(connection);
         if (connection.username) { // aka connection was authenticated
             var connections = this.connectionsByUsername.get(connection.username);
@@ -228,8 +232,18 @@ var EventedHTTPServer = /** @class */ (function (_super) {
             }
         }
     };
+    /**
+     * This method is to be called when a given {@link HAPConnection} performs a request that should result in the disconnection
+     * of all other {@link HAPConnection} with the same {@link HAPUsername}.
+     *
+     * The initiator MUST be in the middle of a http request were the response was not served yet.
+     * Otherwise, the initiator connection might reside in a state where it isn't disconnected and can't make any further requests.
+     *
+     * @param initiator - The connection that requested to disconnect all connections of the same username.
+     * @param username - The username for which all connections shall be closed.
+     */
     EventedHTTPServer.destroyExistingConnectionsAfterUnpair = function (initiator, username) {
-        var e_5, _a;
+        var e_4, _a;
         var connections = initiator.server.connectionsByUsername.get(username);
         if (connections) {
             try {
@@ -238,12 +252,12 @@ var EventedHTTPServer = /** @class */ (function (_super) {
                     connection.closeConnectionAsOfUnpair(initiator);
                 }
             }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (connections_1_1 && !connections_1_1.done && (_a = connections_1.return)) _a.call(connections_1);
                 }
-                finally { if (e_5) throw e_5.error; }
+                finally { if (e_4) throw e_4.error; }
             }
         }
     };
@@ -254,18 +268,22 @@ var EventedHTTPServer = /** @class */ (function (_super) {
 exports.EventedHTTPServer = EventedHTTPServer;
 /**
  * @private
+ * @group HAP Accessory Server
  */
 var HAPConnectionState;
 (function (HAPConnectionState) {
     HAPConnectionState[HAPConnectionState["CONNECTING"] = 0] = "CONNECTING";
     HAPConnectionState[HAPConnectionState["FULLY_SET_UP"] = 1] = "FULLY_SET_UP";
     HAPConnectionState[HAPConnectionState["AUTHENTICATED"] = 2] = "AUTHENTICATED";
-    // above signals are represent a alive connection
+    // above signals represent an alive connection
     // below states are considered "closed or soon closed"
     HAPConnectionState[HAPConnectionState["TO_BE_TEARED_DOWN"] = 3] = "TO_BE_TEARED_DOWN";
     HAPConnectionState[HAPConnectionState["CLOSING"] = 4] = "CLOSING";
     HAPConnectionState[HAPConnectionState["CLOSED"] = 5] = "CLOSED";
 })(HAPConnectionState = exports.HAPConnectionState || (exports.HAPConnectionState = {}));
+/**
+ * @group HAP Accessory Server
+ */
 var HAPConnectionEvent;
 (function (HAPConnectionEvent) {
     HAPConnectionEvent["REQUEST"] = "request";
@@ -274,51 +292,84 @@ var HAPConnectionEvent;
 })(HAPConnectionEvent = exports.HAPConnectionEvent || (exports.HAPConnectionEvent = {}));
 /**
  * Manages a single iOS-initiated HTTP connection during its lifetime.
- * @private
+ * @group HAP Accessory Server
  */
 var HAPConnection = /** @class */ (function (_super) {
     tslib_1.__extends(HAPConnection, _super);
     function HAPConnection(server, clientSocket) {
         var _this = _super.call(this) || this;
-        _this.state = 0 /* CONNECTING */;
+        _this.state = 0 /* HAPConnectionState.CONNECTING */;
         _this.lastSocketOperation = new Date().getTime();
         _this.pendingClientSocketData = Buffer.alloc(0); // data received from client before HTTP proxy is fully setup
         _this.handlingRequest = false; // true while we are composing an HTTP response (so events can wait)
         _this.registeredEvents = new Set();
-        _this.queuedEvents = new Map();
-        _this.pendingEventData = []; // queue of unencrypted event data waiting to be sent until after an in-progress HTTP response is being written
+        _this.queuedEvents = [];
+        /**
+         * If true, the above {@link queuedEvents} contains events which are set to be delivered immediately!
+         */
+        _this.eventsQueuedForImmediateDelivery = false;
         _this.server = server;
-        _this.sessionID = uuid.generate(clientSocket.remoteAddress + ':' + clientSocket.remotePort);
+        _this.sessionID = uuid.generate(clientSocket.remoteAddress + ":" + clientSocket.remotePort);
         _this.localAddress = clientSocket.localAddress;
         _this.remoteAddress = clientSocket.remoteAddress; // cache because it becomes undefined in 'onClientSocketClose'
         _this.remotePort = clientSocket.remotePort;
         _this.networkInterface = HAPConnection.getLocalNetworkInterface(clientSocket);
         // clientSocket is the socket connected to the actual iOS device
         _this.tcpSocket = clientSocket;
-        _this.tcpSocket.on('data', _this.onTCPSocketData.bind(_this));
-        _this.tcpSocket.on('close', _this.onTCPSocketClose.bind(_this));
-        _this.tcpSocket.on('error', _this.onTCPSocketError.bind(_this)); // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
+        _this.tcpSocket.on("data", _this.onTCPSocketData.bind(_this));
+        _this.tcpSocket.on("close", _this.onTCPSocketClose.bind(_this));
+        // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
+        _this.tcpSocket.on("error", _this.onTCPSocketError.bind(_this));
         _this.tcpSocket.setNoDelay(true); // disable Nagle algorithm
         // "HAP accessory servers must not use keepalive messages, which periodically wake up iOS devices".
-        // Thus we don't configure any tcp keepalive
+        // Thus, we don't configure any tcp keepalive
         // create our internal HTTP server for this connection that we will proxy data to and from
         _this.internalHttpServer = http_1.default.createServer();
         _this.internalHttpServer.timeout = 0; // clients expect to hold connections open as long as they want
         _this.internalHttpServer.keepAliveTimeout = 0; // workaround for https://github.com/nodejs/node/issues/13391
         _this.internalHttpServer.on("listening", _this.onHttpServerListening.bind(_this));
-        _this.internalHttpServer.on('request', _this.handleHttpServerRequest.bind(_this));
-        _this.internalHttpServer.on('error', _this.onHttpServerError.bind(_this));
+        _this.internalHttpServer.on("request", _this.handleHttpServerRequest.bind(_this));
+        _this.internalHttpServer.on("error", _this.onHttpServerError.bind(_this));
         // close event is added later on the "connect" event as possible listen retries would throw unnecessary close events
-        _this.internalHttpServer.listen(0, _this.internalHttpServerAddress = net_utils_1.getOSLoopbackAddressIfAvailable());
+        _this.internalHttpServer.listen(0, _this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
         return _this;
     }
-    Object.defineProperty(HAPConnection.prototype, "connected", {
-        get: function () {
-            return this.state !== 0 /* CONNECTING */ && this.state !== 5 /* CLOSED */;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    HAPConnection.prototype.debugListenerRegistration = function (event, registration, beforeCount) {
+        if (registration === void 0) { registration = true; }
+        if (beforeCount === void 0) { beforeCount = -1; }
+        var stackTrace = new Error().stack.split("\n")[3];
+        var eventCount = this.listeners(event).length;
+        var tabs1 = event === "authenticated" /* HAPConnectionEvent.AUTHENTICATED */ ? "\t" : "\t\t";
+        var tabs2 = !registration ? "\t" : "\t\t";
+        // eslint-disable-next-line max-len
+        debugEvents("[".concat(this.remoteAddress, "] ").concat(registration ? "Registered" : "Unregistered", " event '").concat(String(event).toUpperCase(), "' ").concat(tabs1, "(total: ").concat(eventCount).concat(!registration ? " Before: " + beforeCount : "", ") ").concat(tabs2).concat(stackTrace));
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    HAPConnection.prototype.on = function (event, listener) {
+        var result = _super.prototype.on.call(this, event, listener);
+        this.debugListenerRegistration(event);
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    HAPConnection.prototype.addListener = function (event, listener) {
+        var result = _super.prototype.addListener.call(this, event, listener);
+        this.debugListenerRegistration(event);
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    HAPConnection.prototype.removeListener = function (event, listener) {
+        var beforeCount = this.listeners(event).length;
+        var result = _super.prototype.removeListener.call(this, event, listener);
+        this.debugListenerRegistration(event, false, beforeCount);
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    HAPConnection.prototype.off = function (event, listener) {
+        var result = _super.prototype.off.call(this, event, listener);
+        var beforeCount = this.listeners(event).length;
+        this.debugListenerRegistration(event, false, beforeCount);
+        return result;
+    };
     /**
      * This method is called once the connection has gone through pair-verify.
      * As any HomeKit controller will initiate a pair-verify after the pair-setup procedure, this method gets
@@ -327,25 +378,25 @@ var HAPConnection = /** @class */ (function (_super) {
      * Once this method has been called, the connection is authenticated and encryption is turned on.
      */
     HAPConnection.prototype.connectionAuthenticated = function (username) {
-        this.state = 2 /* AUTHENTICATED */;
+        this.state = 2 /* HAPConnectionState.AUTHENTICATED */;
         this.username = username;
-        this.emit("authenticated" /* AUTHENTICATED */, username);
+        this.emit("authenticated" /* HAPConnectionEvent.AUTHENTICATED */, username);
     };
     HAPConnection.prototype.isAuthenticated = function () {
-        return this.state === 2 /* AUTHENTICATED */;
+        return this.state === 2 /* HAPConnectionState.AUTHENTICATED */;
     };
     HAPConnection.prototype.close = function () {
-        if (this.state >= 4 /* CLOSING */) {
+        if (this.state >= 4 /* HAPConnectionState.CLOSING */) {
             return; // already closed/closing
         }
-        this.state = 4 /* CLOSING */;
+        this.state = 4 /* HAPConnectionState.CLOSING */;
         this.tcpSocket.destroy();
     };
     HAPConnection.prototype.closeConnectionAsOfUnpair = function (initiator) {
         if (this === initiator) {
             // the initiator of the unpair request is this connection, meaning it unpaired itself.
             // we still need to send the response packet to the unpair request.
-            this.state = 3 /* TO_BE_TEARED_DOWN */;
+            this.state = 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */;
         }
         else {
             // as HomeKit requires it, destroy any active session which got unpaired
@@ -353,110 +404,110 @@ var HAPConnection = /** @class */ (function (_super) {
         }
     };
     HAPConnection.prototype.sendEvent = function (aid, iid, value, immediateDelivery) {
-        assert_1.default(aid != undefined, "HAPConnection.sendEvent: aid must be defined!");
-        assert_1.default(iid != undefined, "HAPConnection.sendEvent: iid must be defined!");
+        (0, assert_1.default)(aid != null, "HAPConnection.sendEvent: aid must be defined!");
+        (0, assert_1.default)(iid != null, "HAPConnection.sendEvent: iid must be defined!");
         var eventName = aid + "." + iid;
         if (!this.registeredEvents.has(eventName)) {
+            // non verified connections can't register events, so this case is covered!
             return;
         }
+        var event = {
+            aid: aid,
+            iid: iid,
+            value: value,
+        };
         if (immediateDelivery) {
             // some characteristics are required to deliver notifications immediately
-            this.writeEventNotification({
-                characteristics: [{
-                        aid: aid,
-                        iid: iid,
-                        value: value,
-                    }],
-            });
+            // we will flush all other events too, on that occasion.
+            this.queuedEvents.push(event);
+            this.eventsQueuedForImmediateDelivery = true;
+            if (this.eventsTimer) {
+                clearTimeout(this.eventsTimer);
+                this.eventsTimer = undefined;
+            }
+            this.handleEventsTimeout();
+            return;
         }
-        else {
-            // TODO should a new event not remove a previous event (to support censor open -> censor closed :thinking:)
-            //   any only remove previous events if the same value was set?
-            this.queuedEvents.set(eventName, {
-                aid: aid,
-                iid: iid,
-                value: value,
-            });
-            if (!this.handlingRequest && !this.eventsTimer) { // if we are handling a request or there is already a timer running we just add it in the queue
-                this.eventsTimer = setTimeout(this.handleEventsTimeout.bind(this), 250);
-                this.eventsTimer.unref();
+        // we search the list of queued events in reverse order.
+        // if the last element with the same aid and iid has the same value we don't want to send the event notification twice.
+        // BUT, we do not want to override previous event notifications which have a different value. Automations must be executed!
+        for (var i = this.queuedEvents.length - 1; i >= 0; i--) {
+            var queuedEvent = this.queuedEvents[i];
+            if (queuedEvent.aid === aid && queuedEvent.iid === iid) {
+                if (queuedEvent.value === value) {
+                    return; // the same event was already queued. do not add it again!
+                }
+                break; // we break in any case
             }
         }
+        this.queuedEvents.push(event);
+        // if there is already a timer running we just add it in the queue.
+        if (!this.eventsTimer) {
+            this.eventsTimer = setTimeout(this.handleEventsTimeout.bind(this), 250);
+            this.eventsTimer.unref();
+        }
     };
     HAPConnection.prototype.handleEventsTimeout = function () {
         this.eventsTimer = undefined;
-        if (this.state > 2 /* AUTHENTICATED */ || this.handlingRequest) {
+        if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // connection is closed or about to be closed. no need to send any further events
-            // OR we are currently sending a response
             return;
         }
         this.writeQueuedEventNotifications();
     };
-    HAPConnection.prototype.writePendingEventNotifications = function () {
-        var e_6, _a;
-        try {
-            for (var _b = tslib_1.__values(this.pendingEventData), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var buffer = _c.value;
-                this.tcpSocket.write(this.encrypt(buffer));
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_6) throw e_6.error; }
-        }
-        this.pendingEventData.splice(0, this.pendingEventData.length);
-    };
     HAPConnection.prototype.writeQueuedEventNotifications = function () {
-        var e_7, _a;
-        if (this.queuedEvents.size === 0 || this.eventsTimer) {
-            return; // don't send empty event notifications or if there is a timeout running
+        var e_5, _a;
+        if (this.queuedEvents.length === 0 || this.handlingRequest) {
+            return; // don't send empty event notifications or if we are currently handling a request
+        }
+        if (this.eventsTimer) {
+            // this method might be called when we have enqueued data AND data that is queued for immediate delivery!
+            clearTimeout(this.eventsTimer);
+            this.eventsTimer = undefined;
         }
-        var eventData = { characteristics: [] };
+        var eventData = {
+            characteristics: [],
+        };
         try {
             for (var _b = tslib_1.__values(this.queuedEvents), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var _d = tslib_1.__read(_c.value, 2), eventName = _d[0], characteristic = _d[1];
-                if (!this.registeredEvents.has(eventName)) { // client unregistered events in the mean time
-                    continue;
+                var queuedEvent = _c.value;
+                if (!this.registeredEvents.has(queuedEvent.aid + "." + queuedEvent.iid)) {
+                    continue; // client unregistered that event in the meantime
                 }
-                eventData.characteristics.push(characteristic);
+                eventData.characteristics.push(queuedEvent);
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_5) throw e_5.error; }
         }
-        this.queuedEvents.clear();
+        this.queuedEvents.splice(0, this.queuedEvents.length);
+        this.eventsQueuedForImmediateDelivery = false;
         this.writeEventNotification(eventData);
     };
     /**
      * This will create an EVENT/1.0 notification header with the provided event notification.
-     * If currently a HTTP request is in progress the assembled packet will be
+     * If currently an HTTP request is in progress the assembled packet will be
      * added to the pending events list.
      *
      * @param notification - The event which should be sent out
      */
     HAPConnection.prototype.writeEventNotification = function (notification) {
         debugCon("[%s] Sending HAP event notifications %o", this.remoteAddress, notification.characteristics);
+        (0, assert_1.default)(!this.handlingRequest, "Can't write event notifications while handling a request!");
+        // Apple backend processes events in reverse order, so we need to reverse the array
+        // so that events are processed in chronological order.
+        notification.characteristics.reverse();
         var dataBuffer = Buffer.from(JSON.stringify(notification), "utf8");
         var header = Buffer.from("EVENT/1.0 200 OK\r\n" +
             "Content-Type: application/hap+json\r\n" +
             "Content-Length: " + dataBuffer.length + "\r\n" +
-            "\r\n", "utf8" // buffer encoding
-        );
+            "\r\n", "utf8");
         var buffer = Buffer.concat([header, dataBuffer]);
-        if (this.handlingRequest) {
-            // it is important that we not encrypt the pending event data. This would increment the nonce used in encryption
-            this.pendingEventData.push(buffer);
-        }
-        else {
-            this.tcpSocket.write(this.encrypt(buffer), this.handleTCPSocketWriteFulfilled.bind(this));
-        }
+        this.tcpSocket.write(this.encrypt(buffer), this.handleTCPSocketWriteFulfilled.bind(this));
     };
     HAPConnection.prototype.enableEventNotifications = function (aid, iid) {
         this.registeredEvents.add(aid + "." + iid);
@@ -481,34 +532,35 @@ var HAPConnection = /** @class */ (function (_super) {
         if (this.encryption && this.encryption.accessoryToControllerKey.length > 0 && this.encryption.controllerToAccessoryCount > 0) {
             return hapCrypto.layerEncrypt(data, this.encryption);
         }
-        return data; // otherwise we don't encrypt and return plaintext
+        return data; // otherwise, we don't encrypt and return plaintext
     };
     HAPConnection.prototype.decrypt = function (data) {
         if (this.encryption && this.encryption.controllerToAccessoryKey.length > 0) {
             // below call may throw an error if decryption failed
             return hapCrypto.layerDecrypt(data, this.encryption);
         }
-        return data; // otherwise we don't decrypt and return plaintext
+        return data; // otherwise, we don't decrypt and return plaintext
     };
     HAPConnection.prototype.onHttpServerListening = function () {
         var _this = this;
         var addressInfo = this.internalHttpServer.address(); // address() is only a string when listening to unix domain sockets
-        var addressString = addressInfo.family === "IPv6" ? "[" + addressInfo.address + "]" : addressInfo.address;
+        var addressString = addressInfo.family === "IPv6" ? "[".concat(addressInfo.address, "]") : addressInfo.address;
         this.internalHttpServerPort = addressInfo.port;
         debugCon("[%s] Internal HTTP server listening on %s:%s", this.remoteAddress, addressString, addressInfo.port);
-        this.internalHttpServer.on('close', this.onHttpServerClose.bind(this));
+        this.internalHttpServer.on("close", this.onHttpServerClose.bind(this));
         // now we can establish a connection to this running HTTP server for proxying data
         this.httpSocket = net_1.default.createConnection(this.internalHttpServerPort, this.internalHttpServerAddress); // previously we used addressInfo.address
         this.httpSocket.setNoDelay(true); // disable Nagle algorithm
-        this.httpSocket.on('data', this.handleHttpServerResponse.bind(this));
-        this.httpSocket.on('error', this.onHttpSocketError.bind(this)); // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
-        this.httpSocket.on('close', this.onHttpSocketClose.bind(this));
-        this.httpSocket.on('connect', function () {
+        this.httpSocket.on("data", this.handleHttpServerResponse.bind(this));
+        // we MUST register for this event, otherwise the error will bubble up to the top and crash the node process entirely.
+        this.httpSocket.on("error", this.onHttpSocketError.bind(this));
+        this.httpSocket.on("close", this.onHttpSocketClose.bind(this));
+        this.httpSocket.on("connect", function () {
             // we are now fully set up:
             //  - clientSocket is connected to the iOS device
             //  - serverSocket is connected to the httpServer
             //  - ready to proxy data!
-            _this.state = 1 /* FULLY_SET_UP */;
+            _this.state = 1 /* HAPConnectionState.FULLY_SET_UP */;
             debugCon("[%s] Internal HTTP socket connected. HAPConnection now fully set up!", _this.remoteAddress);
             // start by flushing any pending buffered data received from the client while we were setting up
             if (_this.pendingClientSocketData && _this.pendingClientSocketData.length > 0) {
@@ -522,7 +574,7 @@ var HAPConnection = /** @class */ (function (_super) {
      * We store the data if the internal http server is not read yet, or forward it to the http server.
      */
     HAPConnection.prototype.onTCPSocketData = function (data) {
-        if (this.state > 2 /* AUTHENTICATED */) {
+        if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // don't accept data of a connection which is about to be closed or already closed
             return;
         }
@@ -536,7 +588,7 @@ var HAPConnection = /** @class */ (function (_super) {
             this.close();
             return;
         }
-        if (this.state < 1 /* FULLY_SET_UP */) { // we're not setup yet, so add this data to our intermediate buffer
+        if (this.state < 1 /* HAPConnectionState.FULLY_SET_UP */) { // we're not setup yet, so add this data to our intermediate buffer
             this.pendingClientSocketData = Buffer.concat([this.pendingClientSocketData, data]);
         }
         else {
@@ -549,14 +601,13 @@ var HAPConnection = /** @class */ (function (_super) {
      * data unencrypted to the internal http server. And now it landed here, fully parsed as a http request.
      */
     HAPConnection.prototype.handleHttpServerRequest = function (request, response) {
-        if (this.state > 2 /* AUTHENTICATED */) {
+        if (this.state > 2 /* HAPConnectionState.AUTHENTICATED */) {
             // don't accept data of a connection which is about to be closed or already closed
             return;
         }
-        request.socket.setNoDelay(true);
-        response.connection.setNoDelay(true); // deprecated since 13.0.0
         debugCon("[%s] HTTP request: %s", this.remoteAddress, request.url);
-        this.emit("request" /* REQUEST */, request, response);
+        request.socket.setNoDelay(true);
+        this.emit("request" /* HAPConnectionEvent.REQUEST */, request, response);
     };
     /**
      * This event handler is called by the socket which is connected to our internal http server.
@@ -569,12 +620,15 @@ var HAPConnection = /** @class */ (function (_super) {
         this.tcpSocket.write(data, this.handleTCPSocketWriteFulfilled.bind(this));
         debugCon("[%s] HTTP Response is finished", this.remoteAddress);
         this.handlingRequest = false;
-        if (this.state === 3 /* TO_BE_TEARED_DOWN */) {
+        if (this.state === 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */) {
             setTimeout(function () { return _this.close(); }, 10);
         }
-        else if (this.state < 3 /* TO_BE_TEARED_DOWN */) {
-            this.writePendingEventNotifications();
-            this.writeQueuedEventNotifications();
+        else if (this.state < 3 /* HAPConnectionState.TO_BE_TEARED_DOWN */) {
+            if (!this.eventsTimer || this.eventsQueuedForImmediateDelivery) {
+                // we deliver events if there is no eventsTimer (meaning it ran out in the meantime)
+                // or when the queue contains events set to be delivered immediately
+                this.writeQueuedEventNotifications();
+            }
         }
     };
     HAPConnection.prototype.handleTCPSocketWriteFulfilled = function () {
@@ -585,21 +639,21 @@ var HAPConnection = /** @class */ (function (_super) {
         // onTCPSocketClose will be called next
     };
     HAPConnection.prototype.onTCPSocketClose = function () {
-        this.state = 5 /* CLOSED */;
+        this.state = 5 /* HAPConnectionState.CLOSED */;
         debugCon("[%s] Client connection closed", this.remoteAddress);
         if (this.httpSocket) {
             this.httpSocket.destroy();
         }
         this.internalHttpServer.close();
-        this.emit("closed" /* CLOSED */); // sending final closed event
+        this.emit("closed" /* HAPConnectionEvent.CLOSED */); // sending final closed event
         this.removeAllListeners(); // cleanup listeners, we are officially dead now
     };
     HAPConnection.prototype.onHttpServerError = function (err) {
         debugCon("[%s] HTTP server error: %s", this.remoteAddress, err.message);
-        if (err.code === 'EADDRINUSE') {
+        if (err.code === "EADDRINUSE") {
             this.internalHttpServerPort = undefined;
             this.internalHttpServer.close();
-            this.internalHttpServer.listen(0, this.internalHttpServerAddress = net_utils_1.getOSLoopbackAddressIfAvailable());
+            this.internalHttpServer.listen(0, this.internalHttpServerAddress = (0, net_utils_1.getOSLoopbackAddressIfAvailable)());
         }
     };
     HAPConnection.prototype.onHttpServerClose = function () {
@@ -618,23 +672,25 @@ var HAPConnection = /** @class */ (function (_super) {
         this.internalHttpServer.close();
     };
     HAPConnection.prototype.getLocalAddress = function (ipVersion) {
-        var e_8, _a, e_9, _b;
-        var infos = os_1.default.networkInterfaces()[this.networkInterface];
+        var e_6, _a, e_7, _b;
+        var _c;
+        var infos = (_c = os_1.default.networkInterfaces()[this.networkInterface]) !== null && _c !== void 0 ? _c : [];
         if (ipVersion === "ipv4") {
             try {
                 for (var infos_1 = tslib_1.__values(infos), infos_1_1 = infos_1.next(); !infos_1_1.done; infos_1_1 = infos_1.next()) {
                     var info = infos_1_1.value;
-                    if (info.family === "IPv4") {
+                    // @ts-expect-error Nodejs 18+ uses the number 4 the string "IPv4"
+                    if (info.family === "IPv4" || info.family === 4) {
                         return info.address;
                     }
                 }
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
             finally {
                 try {
                     if (infos_1_1 && !infos_1_1.done && (_a = infos_1.return)) _a.call(infos_1);
                 }
-                finally { if (e_8) throw e_8.error; }
+                finally { if (e_6) throw e_6.error; }
             }
             throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
         }
@@ -643,7 +699,8 @@ var HAPConnection = /** @class */ (function (_super) {
             try {
                 for (var infos_2 = tslib_1.__values(infos), infos_2_1 = infos_2.next(); !infos_2_1.done; infos_2_1 = infos_2.next()) {
                     var info = infos_2_1.value;
-                    if (info.family === "IPv6") {
+                    // @ts-expect-error Nodejs 18+ uses the number 6 instead of the string "IPv6"
+                    if (info.family === "IPv6" || info.family === 6) {
                         if (!info.scopeid) {
                             return info.address;
                         }
@@ -653,12 +710,12 @@ var HAPConnection = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
             finally {
                 try {
                     if (infos_2_1 && !infos_2_1.done && (_b = infos_2.return)) _b.call(infos_2);
                 }
-                finally { if (e_9) throw e_9.error; }
+                finally { if (e_7) throw e_7.error; }
             }
             if (!localUniqueAddress) {
                 throw new Error("Could not find " + ipVersion + " address for interface " + this.networkInterface);
@@ -667,7 +724,7 @@ var HAPConnection = /** @class */ (function (_super) {
         }
     };
     HAPConnection.getLocalNetworkInterface = function (socket) {
-        var e_10, _a, e_11, _b, e_12, _c, e_13, _d;
+        var e_8, _a, e_9, _b, e_10, _c, e_11, _d;
         var localAddress = socket.localAddress;
         if (localAddress.startsWith("::ffff:")) { // IPv4-Mapped IPv6 Address https://tools.ietf.org/html/rfc4291#section-2.5.5.2
             localAddress = localAddress.substring(7);
@@ -683,63 +740,63 @@ var HAPConnection = /** @class */ (function (_super) {
             for (var _e = tslib_1.__values(Object.entries(interfaces)), _f = _e.next(); !_f.done; _f = _e.next()) {
                 var _g = tslib_1.__read(_f.value, 2), name = _g[0], infos = _g[1];
                 try {
-                    for (var infos_3 = (e_11 = void 0, tslib_1.__values(infos)), infos_3_1 = infos_3.next(); !infos_3_1.done; infos_3_1 = infos_3.next()) {
-                        var info = infos_3_1.value;
+                    for (var _h = (e_9 = void 0, tslib_1.__values(infos !== null && infos !== void 0 ? infos : [])), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var info = _j.value;
                         if (info.address === localAddress) {
                             return name;
                         }
                     }
                 }
-                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
                 finally {
                     try {
-                        if (infos_3_1 && !infos_3_1.done && (_b = infos_3.return)) _b.call(infos_3);
+                        if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
                     }
-                    finally { if (e_11) throw e_11.error; }
+                    finally { if (e_9) throw e_9.error; }
                 }
             }
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
             }
-            finally { if (e_10) throw e_10.error; }
+            finally { if (e_8) throw e_8.error; }
         }
         // we couldn't map the address from above, we try now to match subnets (see https://github.com/homebridge/HAP-NodeJS/issues/847)
         var family = net_1.default.isIPv4(localAddress) ? "IPv4" : "IPv6";
         try {
-            for (var _h = tslib_1.__values(Object.entries(interfaces)), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var _k = tslib_1.__read(_j.value, 2), name = _k[0], infos = _k[1];
+            for (var _k = tslib_1.__values(Object.entries(interfaces)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                var _m = tslib_1.__read(_l.value, 2), name = _m[0], infos = _m[1];
                 try {
-                    for (var infos_4 = (e_13 = void 0, tslib_1.__values(infos)), infos_4_1 = infos_4.next(); !infos_4_1.done; infos_4_1 = infos_4.next()) {
-                        var info = infos_4_1.value;
+                    for (var _o = (e_11 = void 0, tslib_1.__values(infos !== null && infos !== void 0 ? infos : [])), _p = _o.next(); !_p.done; _p = _o.next()) {
+                        var info = _p.value;
                         if (info.family !== family) {
                             continue;
                         }
                         // check if the localAddress is in the same subnet
-                        if (domain_formatter_1.getNetAddress(localAddress, info.netmask) === domain_formatter_1.getNetAddress(info.address, info.netmask)) {
+                        if ((0, domain_formatter_1.getNetAddress)(localAddress, info.netmask) === (0, domain_formatter_1.getNetAddress)(info.address, info.netmask)) {
                             return name;
                         }
                     }
                 }
-                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
                 finally {
                     try {
-                        if (infos_4_1 && !infos_4_1.done && (_d = infos_4.return)) _d.call(infos_4);
+                        if (_p && !_p.done && (_d = _o.return)) _d.call(_o);
                     }
-                    finally { if (e_13) throw e_13.error; }
+                    finally { if (e_11) throw e_11.error; }
                 }
             }
         }
-        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
-                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
             }
-            finally { if (e_12) throw e_12.error; }
+            finally { if (e_10) throw e_10.error; }
         }
-        console.log("WARNING couldn't map socket coming from remote address " + socket.remoteAddress + ":" + socket.remotePort + " at local address " + socket.localAddress + " to a interface!");
+        console.log("WARNING couldn't map socket coming from remote address ".concat(socket.remoteAddress, ":").concat(socket.remotePort, "     at local address ").concat(socket.localAddress, " to a interface!"));
         return Object.keys(interfaces)[1]; // just use the first interface after the loopback interface as fallback
     };
     return HAPConnection;