iobroker.zigbee2mqtt 3.0.21 → 3.1.5

package/lib/statesController.js

@@ -1,18 +1,20 @@
+'use strict';
+
 const utils = require('./utils');
-const incStatsQueue = [];
-const timeOutCache = {};
 
 /**
- *
+ * Verwaltet das Schreiben von Zigbee2MQTT-Gerätedaten in ioBroker-States.
+ * Puffert eingehende Nachrichten für noch nicht erstellte Geräte in einer Queue.
  */
 class StatesController {
     /**
+     * Erstellt eine neue StatesController-Instanz.
      *
-     * @param adapter
-     * @param deviceCache
-     * @param groupCache
-     * @param logCustomizations
-     * @param createCache
+     * @param {object}  adapter            Die ioBroker-Adapter-Instanz
+     * @param {Array}   deviceCache        Gemeinsamer Cache aller bekannten Geräte
+     * @param {Array}   groupCache         Gemeinsamer Cache aller bekannten Gruppen
+     * @param {object}  logCustomizations  Debug/Filter-Einstellungen (debugDevices, logfilter)
+     * @param {object}  createCache        Cache bereits erstellter ioBroker-Objekte
      */
     constructor(adapter, deviceCache, groupCache, logCustomizations, createCache) {
         this.adapter = adapter;
@@ -20,45 +22,99 @@ class StatesController {
         this.deviceCache = deviceCache;
         this.logCustomizations = logCustomizations;
         this.createCache = createCache;
+        this.incStatsQueue = [];
+        this.timeOutCache = {};
+        // Einmalig berechnen – wird nur bei Konfigurationsänderung ungültig
+        this._debugDeviceList = logCustomizations.debugDevices
+            ? String(logCustomizations.debugDevices).split(',').map((s) => s.trim()).filter(Boolean)
+            : [];
     }
 
     /**
+     * Verarbeitet eine eingehende Gerätenachricht von Zigbee2MQTT.
+     * Ist das Gerät noch nicht im Cache bekannt, wird die Nachricht in der incStatsQueue
+     * gepuffert und später über processQueue() erneut versucht.
      *
-     * @param messageObj
+     * @param {{ topic: string, payload: any }} messageObj Die zu verarbeitende Nachricht
      */
-    processDeviceMessage(messageObj) {
-        // Is payload present?
-        if (messageObj.payload == ''|| messageObj.payload == undefined || messageObj.payload == null) {
+    async processDeviceMessage(messageObj) {
+        if (!messageObj || typeof messageObj !== 'object') {
+            return;
+        }
+        if (messageObj.payload === '' || messageObj.payload === undefined || messageObj.payload === null) {
             return;
         }
 
-        const device = this.groupCache.concat(this.deviceCache).find((x) => x.id == messageObj.topic);
+        const device = this.groupCache.concat(this.deviceCache).find((x) => x.id === messageObj.topic);
         if (device) {
             try {
-                this.setDeviceStateSafely(messageObj, device);
+                await this.setDeviceStateSafely(messageObj, device);
             } catch (error) {
-                this.adapter.log.error(error);
+                this.adapter.log.error(`setDeviceStateSafely error for ${messageObj.topic}: ${error}`);
             }
         } else {
-          //  incStatsQueue[incStatsQueue.length] = messageObj;
-            if (!incStatsQueue.some((x) => x && x.topic === messageObj.topic)) {
-                incStatsQueue.push(messageObj);
+            // Wenn das Gerät (noch) nicht bekannt ist: Message in Queue stellen.
+            // Existiert für dieses Topic bereits ein Eintrag, wird er mit den aktuellen
+            // Payload-Daten überschrieben, damit wir stets den neuesten Stand verarbeiten.
+            const existingIdx = this.incStatsQueue.findIndex((x) => x && x.topic === messageObj.topic);
+            if (existingIdx !== -1) {
+                const ttl = (this.incStatsQueue[existingIdx]._ttl || 0) + 1;
+                if (ttl > 10) {
+                    this.adapter.log.warn(`incStatsQueue: dropping message for unknown device ${messageObj.topic} after ${ttl} retries`);
+                    this.incStatsQueue.splice(existingIdx, 1);
+                    return;
+                }
+                this.incStatsQueue[existingIdx] = { ...messageObj, _ttl: ttl };
+            } else {
+                if (this.incStatsQueue.length < 500) {
+                    this.incStatsQueue.push({ ...messageObj, _ttl: 1 });
+                } else {
+                    this.adapter.log.warn(`incStatsQueue is full (500), dropping message for ${messageObj.topic}`);
+                }
             }
             this.adapter.log.debug(`Device: ${messageObj.topic} not found, queue state in incStatsQueue!`);
         }
     }
 
     /**
+     * Schreibt alle State-Werte einer Nachricht in die zugehörigen ioBroker-States.
+     * Action-States werden gesammelt und am Ende gesondert behandelt.
      *
-     * @param messageObj
-     * @param device
+     * @param {{ topic: string, payload: object }} messageObj Die zu verarbeitende Nachricht
+     * @param {object} device                                 Das zugehörige Geräteobjekt aus dem Cache
      */
     async setDeviceStateSafely(messageObj, device) {
-        if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
+        if (this._debugDeviceList.includes(device.ieee_address)) {
             this.adapter.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
         }
 
         const actionStates = [];
+        // Fix 1: Flag damit messageObj nur EINMAL in die Queue kommt, egal wie viele
+        //         States noch nicht im createCache sind (verhindert N-faches Requeue)
+        let queuedThisRound = false;
+
+        const pushToQueue = (msg) => {
+            if (queuedThisRound) {return;}
+            const existingIdx = this.incStatsQueue.findIndex((x) => x && x.topic === msg.topic);
+            if (existingIdx !== -1) {
+                const ttl = (this.incStatsQueue[existingIdx]._ttl || 0) + 1;
+                if (ttl > 10) {
+                    this.adapter.log.warn(`incStatsQueue: dropping message for ${msg.topic} after ${ttl} retries (state not yet created)`);
+                    this.incStatsQueue.splice(existingIdx, 1);
+                    return;
+                }
+                this.incStatsQueue[existingIdx] = { ...msg, _ttl: ttl };
+            } else if (this.incStatsQueue.length < 500) {
+                this.incStatsQueue.push({ ...msg, _ttl: 1 });
+            } else {
+                this.adapter.log.warn(`incStatsQueue is full, dropping message for ${msg.topic}`);
+            }
+            queuedThisRound = true;
+        };
+
+        if (!messageObj.payload || typeof messageObj.payload !== 'object' || Array.isArray(messageObj.payload)) {
+            return;
+        }
 
         for (let [key, value] of Object.entries(messageObj.payload)) {
             if (value === undefined || value === null) {
@@ -69,12 +125,12 @@ class StatesController {
                 return state.prop && state.prop === key;
             });
 
-            if (states.length == 0) {
-                states = device.states.filter((x) => x.id == key);
+            if (states.length === 0) {
+                states = device.states.filter((x) => x.id === key);
             }
 
-            if (states.length == 0) {
-                if (key == 'device' || device.ieee_address.includes('group')) {
+            if (states.length === 0) {
+                if (key === 'device' || device.ieee_address.includes('group')) {
                     // do nothing
                 } else {
                     // some devices has addition information in payload
@@ -92,16 +148,16 @@ class StatesController {
                         common: {
                             name: key,
                             role: 'state',
-                            type: value !== null ? typeof value : 'mixed',
+                            type: typeof value,
                             write: false,
                             read: true,
                         },
                         native: {},
                     });
-                    if (typeof value == 'object') {
+                    if (typeof value === 'object') {
                         value = JSON.stringify(value);
                     }
-                    this.adapter.setState(`${fullPath}.${key}`, value, true);
+                    await this.adapter.setStateAsync(`${fullPath}.${key}`, value, true);
                 }
                 continue;
             }
@@ -114,26 +170,22 @@ class StatesController {
                     await this.setStateSafelyAsync(`${device.ieee_address}.available`, true);
                 }
 
-                // It may be that the state has not yet been created!
+                // State noch nicht erstellt? → einmal in Queue legen und weiter
                 if (!this.createCache[device.ieee_address]
-				||	!this.createCache[device.ieee_address][state.id]
-				||	!this.createCache[device.ieee_address][state.id].created == true) {
-                    incStatsQueue[incStatsQueue.length] = messageObj;
+                ||  !this.createCache[device.ieee_address][state.id]
+                ||  this.createCache[device.ieee_address][state.id].created !== true) {
+                    pushToQueue(messageObj);
                     continue;
                 }
 
                 try {
                     //  Is an action
-                    if (state.prop && state.prop == 'action') {
+                    if (state.prop && state.prop === 'action') {
                         actionStates.push(state);
                     }
-                    // Is not an action
-                    // check if its a motion sensor (occupancy state) and if configuration is set to update state every time
-                    // if yes, use setStateSafelyAsync instead of setStateChangedSafelyAsync
-                    else if (this.adapter.config.allwaysUpdateOccupancyState === true && state.id === 'occupancy' &&	value === true) {
+                    else if (this.adapter.config.allwaysUpdateOccupancyState === true && state.id === 'occupancy' && value === true) {
                         await this.setStateSafelyAsync(stateName, value);
                     }
-                    // end section for motion sensor update
                     else {
                         if (state.getter) {
                             await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
@@ -142,22 +194,21 @@ class StatesController {
                         }
                     }
                 } catch (err) {
-                    incStatsQueue[incStatsQueue.length] = messageObj;
-                    this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
+                    this.adapter.log.warn(`Cannot set state ${stateName}: ${err}`);
                 }
             }
         }
 
+
         for (const state of actionStates) {
             const stateName = `${device.ieee_address}.${state.id}`;
 
             try {
                 const getterPayload = state.getter(messageObj.payload);
-                if (getterPayload != undefined) {
-                    if (state.isEvent && state.isEvent == true) {
-                        if (state.type == 'boolean') {
+                if (getterPayload !== undefined) {
+                    if (state.isEvent && state.isEvent === true) {
+                        if (state.type === 'boolean') {
                             await this.setStateWithTimeoutAsync(stateName, getterPayload, 250);
-
                         } else {
                             await this.setStateSafelyAsync(stateName, getterPayload);
                         }
@@ -166,16 +217,17 @@ class StatesController {
                     }
                 }
             } catch (err) {
-                incStatsQueue[incStatsQueue.length] = messageObj;
-                this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
+                this.adapter.log.warn(`Cannot set action state ${stateName}: ${err}`);
             }
         }
     }
 
     /**
+     * Setzt einen ioBroker-State (immer, ohne Changed-Prüfung).
+     * Ignoriert null/undefined-Werte sicher.
      *
-     * @param stateName
-     * @param value
+     * @param {string} stateName Vollständiger State-Pfad (z.B. "0xAABB.state")
+     * @param {*}      value     Der zu setzende Wert
      */
     async setStateSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
@@ -185,9 +237,11 @@ class StatesController {
     }
 
     /**
+     * Setzt einen ioBroker-State nur wenn sich der Wert geändert hat.
+     * Ignoriert null/undefined-Werte sicher.
      *
-     * @param stateName
-     * @param value
+     * @param {string} stateName Vollständiger State-Pfad (z.B. "0xAABB.brightness")
+     * @param {*}      value     Der zu setzende Wert
      */
     async setStateChangedSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
@@ -197,10 +251,13 @@ class StatesController {
     }
 
     /**
+     * Setzt einen State sofort auf den angegebenen Wert und – nur bei value=true –
+     * nach Ablauf des Timeouts automatisch zurück auf false (Button/Event-Reset).
+     * Bei value=false wird kein Auto-Reset ausgelöst (z.B. brightness_stop-Signal).
      *
-     * @param stateName
-     * @param value
-     * @param timeout
+     * @param {string}  stateName Vollständiger State-Pfad
+     * @param {boolean} value     Der sofort zu setzende Wert
+     * @param {number}  timeout   Millisekunden bis zum Auto-Reset (nur bei value=true)
      */
     async setStateWithTimeoutAsync(stateName, value, timeout) {
         if (value === undefined || value === null) {
@@ -208,33 +265,50 @@ class StatesController {
         }
 
         await this.adapter.setStateAsync(stateName, value, true);
-        if (timeOutCache[stateName]) {
-            clearTimeout(timeOutCache[stateName]);
+
+        // Auto-Reset (false → nichts tun, true → nach timeout zurücksetzen)
+        // Wenn value=false (z.B. Stop-Aktion im simpleMoveStopState-Modus),
+        // soll der State dauerhaft false bleiben und NICHT nach timeout auf true springen.
+        if (this.timeOutCache[stateName]) {
+            this.adapter.clearTimeout(this.timeOutCache[stateName]);
+            delete this.timeOutCache[stateName];
+        }
+        if (value === true) {
+            this.timeOutCache[stateName] = this.adapter.setTimeout(() => {
+                delete this.timeOutCache[stateName];
+                this.adapter.setStateAsync(stateName, false, true).catch((err) => {
+                    this.adapter.log.debug(`setStateWithTimeout reset error for ${stateName}: ${err}`);
+                });
+            }, timeout);
         }
-        timeOutCache[stateName] = setTimeout(() => {
-            this.adapter.setStateAsync(stateName, !value, true);
-        }, timeout);
     }
 
     /**
-     *
+     * Verarbeitet alle in der incStatsQueue gepufferten Nachrichten erneut.
+     * Wird nach dem Aufbau des Geräte-/Gruppen-Caches aufgerufen.
      */
-    processQueue() {
+    async processQueue() {
         const oldIncStatsQueue = [];
-        utils.moveArray(incStatsQueue, oldIncStatsQueue);
+        utils.moveArray(this.incStatsQueue, oldIncStatsQueue);
         while (oldIncStatsQueue.length > 0) {
-            this.processDeviceMessage(oldIncStatsQueue.shift());
+            // seriell abarbeiten – nicht parallel feuern
+            await this.processDeviceMessage(oldIncStatsQueue.shift());
         }
     }
 
     /**
-     *
+     * Meldet alle bisherigen State-Subscriptions ab und subscribt neu
+     * nur auf beschreibbare States aller bekannten Geräte und Gruppen.
      */
-    async subscribeWritableStates() {
-        await this.adapter.unsubscribeObjectsAsync('*');
+    subscribeWritableStates() {
+        // Alle bestehenden State-Subscriptions zuerst abmelden
+        this.adapter.unsubscribeStates('*');
         for (const device of this.groupCache.concat(this.deviceCache)) {
+            if (!device || !Array.isArray(device.states)) {
+                continue;
+            }
             for (const state of device.states) {
-                if (state.write == true) {
+                if (state && state.write === true) {
                     this.adapter.subscribeStates(`${device.ieee_address}.${state.id}`);
                 }
             }
@@ -245,22 +319,28 @@ class StatesController {
     }
 
     /**
-     *
+     * Setzt alle "*.available"-States im Adapter auf false.
+     * Wird beim Verbindungsverlust zu Zigbee2MQTT aufgerufen.
      */
     async setAllAvailableToFalse() {
         const availableStates = await this.adapter.getStatesAsync('*.available');
-        for (const availableState in availableStates) {
+        if (!availableStates) {
+            return;
+        }
+        for (const availableState of Object.keys(availableStates)) {
             await this.adapter.setStateChangedAsync(availableState, false, true);
         }
     }
 
     /**
-     *
+     * Bricht alle laufenden Auto-Reset-Timer ab und leert den Timer-Cache.
+     * Wird beim Adapter-Stop aufgerufen.
      */
-    async allTimerClear() {
-        for (const timer in timeOutCache) {
-            clearTimeout(timeOutCache[timer]);
+    allTimerClear() {
+        for (const timer of Object.keys(this.timeOutCache)) {
+            this.adapter.clearTimeout(this.timeOutCache[timer]);
         }
+        this.timeOutCache = {};
     }
 }
 

package/lib/utils.js

@@ -1,68 +1,43 @@
 /**
- * Converts a bulb level of range [0...254] to an adapter level of range [0...100]
+ * Konvertiert einen Lampen-Helligkeitswert [0..254] in einen Adapter-Prozentwert [0..100].
  *
- * @param bulbLevel
+ * @param {number} bulbLevel Helligkeitswert der Lampe (0–254)
+ * @returns {number}         Prozentwert (0–100)
  */
 function bulbLevelToAdapterLevel(bulbLevel) {
-    // Convert from bulb levels [0...254] to adapter levels [0...100]:
-    // - Bulb level 0 is a forbidden value according to the ZigBee spec "ZigBee Cluster Library
-    //   (for ZigBee 3.0) User Guide", but some bulbs (HUE) accept this value and interpret this
-    //   value as "switch the bulb off".
-    // - A bulb level of "1" is the "minimum possible level" which should mean "bulb off",
-    //   but there are bulbs that do not switch off (they need "0", some IKEA bulbs are affected).
-    // - No visible difference was seen between bulb level 1 and 2 on HUE LCT012 bulbs.
-    //
-    // Conclusion:
-    // - We map adapter level "0" to the (forbidden) bulb level "0" that seems to switch all
-    //   known bulbs.
-    // - Bulb level "1" is not used, but if received nevertheless, it is converted to
-    //   adapter level "0" (off).
-    // - Bulb level range [2...254] is linearly mapped to adapter level range [1...100].
     if (bulbLevel >= 2) {
         // Perform linear mapping of range [2...254] to [1...100]
         return Math.round(((bulbLevel - 2) * 99) / 252) + 1;
-    } 
-        // The bulb is considered off. Even a bulb level of "1" is considered as off.
-        return 0;
-     // else
+    }
+    // The bulb is considered off. Even a bulb level of "1" is considered as off.
+    return 0;
 }
 
 /**
- * Converts an adapter level of range [0...100] to a bulb level of range [0...254]
+ * Konvertiert einen Adapter-Prozentwert [0..100] in einen Lampen-Helligkeitswert [0..254].
  *
- * @param adapterLevel
+ * @param {number} adapterLevel Prozentwert (0–100)
+ * @returns {number}            Helligkeitswert der Lampe (0–254)
  */
 function adapterLevelToBulbLevel(adapterLevel) {
-    // Convert from adapter levels [0...100] to bulb levels [0...254].
-    // This is the inverse of function bulbLevelToAdapterLevel().
-    // Please read the comments there regarding the rules applied here for mapping the values.
-    if (adapterLevel) {
+    if (adapterLevel != null && adapterLevel > 0) {
         // Perform linear mapping of range [1...100] to [2...254]
         return Math.round(((adapterLevel - 1) * 252) / 99) + 2;
-    } 
-        // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
-        // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
-        return 0;
-     // else
-}
-
-/**
- *
- * @param ba
- */
-function bytesArrayToWordArray(ba) {
-    const wa = [];
-    for (let i = 0; i < ba.length; i++) {
-        wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
     }
-    return wa;
+    // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
+    // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
+    return 0;
 }
 
+
 // If the value is greater than 1000, kelvin is assumed.
 // If smaller, it is assumed to be mired.
 /**
+ * Konvertiert einen Kelvin- oder Mired-Wert immer in Mired.
+ * Werte > 1000 werden als Kelvin interpretiert und umgerechnet.
  *
- * @param t
+ * @param {number} t Farbtemperatur in Kelvin (>1000) oder Mired (≤1000)
+ * @returns {number} Farbtemperatur in Mired
  */
 function toMired(t) {
     let miredValue = t;
@@ -73,22 +48,25 @@ function toMired(t) {
 }
 
 /**
+ * Konvertiert zwischen Mired und Kelvin (die Formel ist in beide Richtungen gleich: 1.000.000 / t).
  *
- * @param t
+ * @param {number} t Farbtemperatur in Mired oder Kelvin
+ * @returns {number} Umgerechneter Wert (gerundet)
  */
 function miredKelvinConversion(t) {
     return Math.round(1000000 / t);
 }
 
 /**
- * Converts a decimal number to a hex string with zero-padding
+ * Konvertiert eine Dezimalzahl in einen hex-String mit führenden Nullen.
  *
- * @param decimal
- * @param padding
+ * @param {number} decimal  Die umzuwandelnde Zahl
+ * @param {number} [padding] Mindestlänge des hex-Strings (wird mit '0' aufgefüllt)
+ * @returns {string}        Hex-String in Kleinbuchstaben
  */
 function decimalToHex(decimal, padding) {
     let hex = Number(decimal).toString(16);
-    padding = typeof padding === 'undefined' || padding === null ? (padding = 2) : padding;
+    padding = typeof padding === 'undefined' || padding === null ? 2 : padding;
 
     while (hex.length < padding) {
         hex = `0${hex}`;
@@ -98,81 +76,43 @@ function decimalToHex(decimal, padding) {
 }
 
 /**
+ * Leert ein Array in-place (O(1)).
  *
- * @param adapterDevId
- */
-function getZbId(adapterDevId) {
-    const idx = adapterDevId.indexOf('group');
-    if (idx > 0) {
-return adapterDevId.substr(idx + 6);
-}
-    return `0x${  adapterDevId.split('.')[2]}`;
-}
-
-/**
- *
- * @param adapter
- * @param id
- */
-function getAdId(adapter, id) {
-    return `${adapter.namespace  }.${  id.split('.')[2]}`; // iobroker device id
-}
-
-/**
- *
- * @param array
+ * @param {Array} array Das zu leerende Array
  */
 function clearArray(array) {
-    while (array.length > 0) {
-        array.pop();
-    }
+    array.length = 0;
 }
 
 /**
+ * Verschiebt alle Einträge von source nach target und leert source dabei.
  *
- * @param source
- * @param target
+ * @param {Array} source Quell-Array (wird nach dem Aufruf leer sein)
+ * @param {Array} target Ziel-Array (bekommt alle Einträge aus source angehängt)
  */
 function moveArray(source, target) {
-    while (source.length > 0) {
-        target.push(source.shift());
-    }
+    target.push(...source);
+    source.length = 0;
 }
 
 /**
+ * Prüft ob ein Wert ein einfaches Objekt ist (kein Array, kein null).
  *
- * @param item
+ * @param {*} item Der zu prüfende Wert
+ * @returns {boolean} true wenn item ein Objekt ist, sonst false
  */
 function isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;
 }
 
-/**
- *
- * @param item
- */
-function isJson(item) {
-    let value = typeof item !== 'string' ? JSON.stringify(item) : item;
-    try {
-        value = JSON.parse(value);
-    } catch (e) {
-        return false;
-    }
-
-    return typeof value === 'object' && value !== null;
-}
 
 module.exports = {
     bulbLevelToAdapterLevel,
     adapterLevelToBulbLevel,
-    bytesArrayToWordArray,
     toMired,
     miredKelvinConversion,
     decimalToHex,
-    getZbId,
-    getAdId,
     clearArray,
     moveArray,
     isObject,
-    isJson,
 };