iobroker.zigbee 3.1.2 → 3.1.4

package/lib/statescontroller.js

@@ -5,19 +5,11 @@ const { EventEmitter } = require('events');
 const statesMapping = require('./devices');
 const { getAdId, getZbId } = require('./utils');
 const fs = require('fs');
-const axios = require('axios');
 const localConfig = require('./localConfig');
-//const { deviceAddCustomCluster } = require('zigbee-herdsman-converters/lib/modernExtend');
-//const { setDefaultAutoSelectFamilyAttemptTimeout } = require('net');
-//const { runInThisContext } = require('vm');
-//const { time } = require('console');
-const { exec } = require('child_process');
-const { tmpdir } = require('os');
 const path = require('path');
-const { throwDeprecation } = require('process');
+const axios = require('axios');
 const zigbeeHerdsmanConvertersUtils = require('zigbee-herdsman-converters/lib/utils');
 
-
 class StatesController extends EventEmitter {
     constructor(adapter) {
         super();
@@ -84,7 +76,6 @@ class StatesController extends EventEmitter {
     async AddModelFromHerdsman(device, model) {
         const namespace = `${this.adapter.name}.admin`;
 
-        // this.warn('addModelFromHerdsman ' + JSON.stringify(model) + ' ' + JSON.stringify(this.localConfig.getOverrideWithKey(model, 'legacy', true)));
         if (this.localConfig.getOverrideWithTargetAndKey(model, 'legacy', true)) {
             this.debug('Applying legacy definition for ' + model);
             await this.addLegacyDevice(model);
@@ -213,7 +204,7 @@ class StatesController extends EventEmitter {
     async toggleDeviceDebug(id) {
         const arr = /zigbee.[0-9].([^.]+)/gm.exec(id);
         if (!arr) {
-            this.warn(`unable to toggle debug for device ${id}: there was no mat (${JSON.stringify(arr)}) `);
+            this.warn(`unable to toggle debug for device ${id}: there was no matc (${JSON.stringify(arr)}) `);
             return this.debugDevices;
         }
         if (arr[1] === undefined) {
@@ -278,10 +269,9 @@ class StatesController extends EventEmitter {
                 this.emit('device_debug', { ID:debugId, data: { ID: deviceId, flag:'01' }, message:message});
             } else
                 if (this.debugActive) this.debug(`User stateChange ${id} ${JSON.stringify(state)}`);
-            // const stateKey = id.split('.')[3];
             const arr = /zigbee.[0-9].[^.]+.(\S+)/gm.exec(id);
             if (arr[1] === undefined) {
-                //this.warn(`unable to extract id from state ${id}`);
+                this.debug(`unable to extract id from state ${id}`);
                 return;
             }
             const stateKey = arr[1];
@@ -295,16 +285,7 @@ class StatesController extends EventEmitter {
                         if (this.debugActive) this.debug('State Change detected on deactivated Device - ignored');
                         return;
                     }
-                    // check for group (model is group, deviceId is numerical, and not Nan or 0)
-                    /*
-                    if (model === 'group' && typeof deviceId == 'number' && Boolean(deviceId)) {
-                        const options = this.localConfig.getOptions(`group_${deviceId}`);
-                        options.isActive == (obj.common !== null);
-                        this.publishFromState(deviceId, model, stateKey, state, options, debugId);
-                        return;
-                    }
-                    */
-                    // handle send_payload here
+
                     if (model && model.id === 'device_query') {
                         if (this.query_device_block.indexOf(deviceId) > -1 && !state.source.includes('.admin.')) {
                             this.info(`Device query for '${deviceId}' blocked - device query timeout has not elapsed yet.`);
@@ -480,7 +461,7 @@ class StatesController extends EventEmitter {
                 const payload = {device: deviceId.replace('0x', ''), payload: json_value, model:model, stateModel:stateModel};
                 if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { flag: '04' ,payload:value ,states:[{id:stateDesc.id, value:json_value, payload:'none'}], IO:false }});
 
-                this.emit('send_payload', payload, debugID);
+                this.emit('send_payload', payload, debugID, has_elevated_debug);
             } catch (error) {
                 const message = `send_payload: ${value} does not parse as JSON Object : ${error.message}`;
                 if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { error: 'EXSEND' ,states:[{id:stateDesc.id, value:value, payload:error.message}], IO:false }, message:message});
@@ -571,8 +552,8 @@ class StatesController extends EventEmitter {
     }
 
 
-    setDeviceActivated(id, active) {
-        this.adapter.extendObject(id, {common: {deactivated: active}});
+    setDeviceActivated(id, inActive) {
+        this.adapter.extendObject(id, {common: {deactivated: inActive, color:inActive ? '#888888' : null, statusStates: inActive ? null : {onlineId:`${id}.available`} }});
     }
 
     storeDeviceName(id, name) {
@@ -804,13 +785,10 @@ class StatesController extends EventEmitter {
     async applyLegacyDevices() {
         const legacyModels = await this.localConfig.getLegacyModels();
         const modelarr1 = [];
-        //this.warn('devices are' + modelarr1.join(','));
         statesMapping.devices.forEach(item => modelarr1.push(item.models));
-        //this.warn('legacy models are ' + JSON.stringify(legacyModels));
         statesMapping.setLegacyDevices(legacyModels);
         const modelarr2 = [];
         statesMapping.devices.forEach(item => modelarr2.push(item.models));
-        //this.warn('devices are' + modelarr2.join(','));
     }
 
     async addLegacyDevice(model) {
@@ -856,7 +834,6 @@ class StatesController extends EventEmitter {
         } else {
             const model_modif = model.replace(/\//g, '-');
             const pathToAdminIcon = `img/${model_modif}.png`;
-//            await this.fetchIcon(icon, '')
 
 
             if (icon.startsWith('http')) {
@@ -869,31 +846,82 @@ class StatesController extends EventEmitter {
             }
         }
 
-        this.adapter.setObjectNotExists(id, {
-            type: 'device',
-            // actually this is an error, so device.common has no attribute type. It must be in native part
-            common: {
-                name: __dev_name,
-                type: model,
-                icon,
-                modelIcon: modelIcon,
-                color: null,
-                statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-            },
-            native: {id: dev_id}
-        }, () => {
-            // update type and icon
+        const obj = await this.adapter.getObjectAsync(id);
+
+        const myCommon = {
+            name: __dev_name,
+            type: model,
+            icon,
+            modelIcon: modelIcon,
+            color: (obj && obj.common && obj.common.deactivated) ? `#888888` : null,
+            statusStates: (obj && obj.common && obj.common.deactivated) ? null : {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
+        }
+        if (obj) {
             this.adapter.extendObject(id, {
-                common: {
-                    name: __dev_name,
-                    type: model,
-                    icon,
-                    modelIcon: modelIcon,
-                    color: null,
-                    statusStates: {onlineId: `${this.adapter.namespace}.${dev_id}.available`}
-                }
+                common: myCommon
             }, callback);
-        });
+        } else {
+            this.adapter.setObjectNotExists(id, {
+                type: 'device',
+                // actually this is an error, so device.common has no attribute type. It must be in native part
+                common: myCommon,
+                native: {id: dev_id}
+            }, callback);
+        }
+    }
+
+    async streamToBufferFetch(readableStream) {
+        const reader = readableStream.getReader();
+        const chunks = [];
+        let done, value;
+        try {
+            while (true) {
+                const result = await reader.read();
+                done = result.done;
+                value = result.value;
+                if (done) break;
+                if (value) chunks.push(Buffer.from(value));
+            }
+            return Buffer.concat(chunks);
+        } catch (err) {
+            this.error(`error getting buffer from stream: ${err && err.message ? err.message : 'no reason given'}`);
+            throw err;
+        }
+    }
+
+    async fetchIcon(url, image_path) {
+        const namespace = `${this.adapter.name}.admin`;
+        try {
+            return new Promise((resolve, reject) => {
+                fetch(url)
+                    .then(async response => {
+                        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+                        const data = await this.streamToBufferFetch(response.body);
+                        this.adapter.writeFile(namespace, image_path, data, (err) => {
+                            if (err) {
+                                this.error(`error writing ${image_path} to admin: ${err.message ? err.message : 'no message given'}`);
+                                reject(err);
+                                return;
+                            }
+                            this.info(`downloaded ${url} to ${image_path}.`);
+                            resolve();
+                        });
+                    })
+                    .catch(err => {
+                        this.warn(`error downloading icon ${err && err.message ? err.message : 'no message given'}`);
+                        reject(err);
+                    })
+                    .finally(() => {
+                        const idx = this.ImagesToDownload.indexOf(url);
+                        if (idx > -1) {
+                            this.ImagesToDownload.splice(idx, 1);
+                        }
+                    });
+            });
+        }
+        catch (error) {
+            this.warn(`error fetching ${url} : ${error && error.message ? error.message : 'no reason given'}`)
+        }
     }
 
     async streamToBuffer(readableStream) {
@@ -921,12 +949,6 @@ class StatesController extends EventEmitter {
         });
     }
 
-    async fetchIcon(url, image_path) {
-        const response = await fetch(url);
-        const data = await this.streamToBuffer(response.body);
-        fs.writeFileSync('/opt/iobroker/iobroker-data/zigbee_0/test.png', response.data);
-    }
-
     async downloadIcon(url, image_path) {
         try {
             const namespace = `${this.adapter.name}.admin`;
@@ -971,7 +993,6 @@ class StatesController extends EventEmitter {
             }
         });
     }
-
     CleanupRequired(set) {
         try {
             if (typeof set === 'boolean') this.cleanupRequired = set;
@@ -1060,8 +1081,10 @@ class StatesController extends EventEmitter {
             const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
 
             const message = `message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`;
-            if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { deviceID: devId, flag:'01', IO:true }, message:message});
-            else if (this.debugActive) this.debug(message);
+            if (has_elevated_debug)
+                this.emit('device_debug', { ID:debugId, data: { deviceID: devId, flag:'03', IO:true }, message:message});
+            else
+                if (this.debugActive) this.debug(message);
             if (!devStates) {
                 const message = `no device states for device ${devId} type '${model}'`;
                 if (has_elevated_debug)this.emit('device_debug', { ID:debugId, data: { error:'NOSTATE',states:[{ id:'--', value:'--', payload:payload}], IO:true }, message:message});
@@ -1092,7 +1115,7 @@ class StatesController extends EventEmitter {
                         let stateID = statedesc.id;
 
                         const message = `value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`;
-                        if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { states:[{id:stateID, value:value, payload:payload }],flag:'02', IO:true }, message});
+                        if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { states:[{id:stateID, value:value, payload:payload }],flag:'04', IO:true }, message});
                         else if (this.debugActive) this.debug(message);
 
                         const common = {
@@ -1179,35 +1202,57 @@ class StatesController extends EventEmitter {
         }
     }
 
-    async processConverters(converters, devId, model, mappedModel, message, meta, debugId) {
-        for (const converter of converters) {
-            const publish = (payload, dID) => {
-                if (typeof payload === 'object') {
-                    this.publishToState(devId, model, payload,dID);
-                }
-            };
-
-            const options = await new Promise((resolve, reject) => {
-                this.collectOptions(devId, model, false, (options) => {
-                    resolve(options);
-                });
+    async processConverters(converters, devId, model, mappedModel, message, meta, debugId, has_elevated_debug) {
+        let cnt = 0;
+        const publish = (payload, dID) => {
+            if (typeof payload === 'object' && Object.keys(payload).length > 0) {
+                this.publishToState(devId, model, payload,dID);
+            }
+            else if (has_elevated_debug)
+                this.emit('device_debug', {ID:debugId,data: { error:`NOVAL`, IO:true }, message:` payload ${JSON.stringify(payload)} is empty`})
+        };
+        const options = await new Promise((resolve, reject) => {
+            this.collectOptions(devId, model, false, (options) => {
+                resolve(options);
             });
+        });
 
-            const payload = await new Promise((resolve, reject) => {
+        const chain = [];
+        for (const converter of converters) {
+            const idx = cnt++;
+            chain.push(new Promise((resolve) => {
+                if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}a`, IO:true }, message:`converter ${cnt} : Cluster ${converter.cluster}`})
                 const payloadConv = converter.convert(mappedModel, message, publish, options, meta);
+                const metapost = meta ? {
+                    deviceIEEE: meta.device ? meta.device.ieeeAddr : 'no device',
+                    deviceModelId: meta.device ? meta.device.ModelId : 'no device',
+                    logger: meta.logger ? (meta.logger.constructor ? meta.logger.constructor.name : 'not a class') : 'undefined',
+                    state : meta.state
+                } : 'undefined';
+                if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${idx}b`, IO:true }, message:` data: ${safeJsonStringify(message.data)} options: ${safeJsonStringify(options)} meta:${safeJsonStringify(metapost)} result:${safeJsonStringify(payloadConv)}`})
                 if (typeof payloadConv === 'object') {
                     resolve(payloadConv);
                 }
-            });
+                else resolve({});
+            }));
+        }
+        const candidates = await Promise.all(chain);
+        const payload = {};
 
-            if (Object.keys(payload).length > 0 && Object.keys(options).length > 0) {
-                this.postProcessConvertedFromZigbeeMessage(mappedModel, payload, options, null);
-            }
+        for (const candidate of candidates) {
+            for (const key in candidate)
+                payload[key] = candidate[key];
+        }
 
-            publish(payload, debugId);
+        if (Object.keys(payload).length > 0 && Object.keys(options).length > 0) {
+            const premsg = `candidates: ${JSON.stringify(candidates)} => payload ${JSON.stringify(payload)}`
+            this.postProcessConvertedFromZigbeeMessage(mappedModel, payload, options, null);
+            if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}d`, IO:true }, message:`${premsg} => processed payload : ${JSON.stringify(payload)}`})
         }
-    }
+        else if (has_elevated_debug) this.emit('device_debug', {ID:debugId,data: { flag:`02.${cnt}c`, IO:true }, message:`candidates: ${JSON.stringify(candidates)} => payload ${JSON.stringify(payload)}`})
 
+        publish(payload, debugId);
+    }
 
     async onZigbeeEvent(type, entity, message) {
         if (this.debugActive) this.debug(`Type ${type} device ${safeJsonStringify(entity)} incoming event: ${safeJsonStringify(message)}`);
@@ -1293,9 +1338,6 @@ class StatesController extends EventEmitter {
             }
         }
 
-        // publish raw event to "from_zigbee"
-        // some cleanup
-
         this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)}, -1);
 
         if (!entity.mapped) {
@@ -1311,6 +1353,11 @@ class StatesController extends EventEmitter {
                 Array.isArray(c.type) ? c.type.includes('attributeReport') : c.type === 'attributeReport'));
         }
 
+        if (has_elevated_debug) {
+            const message = `${converters.length} converter${converters.length > 1 ? 's' : ''} available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`
+            this.emit('device_debug', { ID:debugId, data: { flag:'02', IO:true }, message:message})
+        }
+
         if (!converters.length) {
             if (type !== 'readResponse' && type !== 'commandQueryNextImageRequest') {
                 const message = `No converter available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`;
@@ -1322,7 +1369,7 @@ class StatesController extends EventEmitter {
 
         meta.state = { state: '' };   // for tuya
 
-        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId)
+        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId, has_elevated_debug)
             .catch((error) => {
                 //   'Error: Expected one of: 0, 1, got: 'undefined''
                 if (cluster !== '64529') {
@@ -1336,9 +1383,6 @@ class StatesController extends EventEmitter {
     async stop() {
         this.localConfig.retainData();
     }
-
-
-
 }
 
-module.exports = StatesController;
+module.exports = StatesController;

package/lib/zbDelayedAction.js

@@ -45,10 +45,10 @@ class DelayedAction extends BaseExtension {
 
     onZigbeeEvent(data) {
         try {
-            const device = data.device;
-            // if (this.shouldAction(device, mappedDevice)) {
-            this.doActions(device);
-            // }
+            if (data && data.device) {
+                const device = data.device;
+                this.doActions(device);
+            }
         } catch (error) {
             this.sendError(error);
             this.error(

package/lib/zbDeviceAvailability.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const BaseExtension = require('./zbBaseExtension');
-const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const utils = require('./utils');
 
 // Some EndDevices should be pinged
@@ -19,6 +18,11 @@ const Hours25 = 1000 * 60 * 60 * 25;
 const MinAvailabilityTimeout = 300; // ping every 5 minutes with few devices
 const MaxAvailabilityTimeout = 1800; // ping every 30 minutes with many devices;
 const AverageTimeBetweenPings = 45; // on average, plan for 30 seconds between pings.
+const pingClusters = {
+    c0a0: {id:'genBasic', attribute:'zclVersion'},
+    c0a5: {id:'genBasic', attribute:'modelId'},
+    c25a0: {id:'genOta', attribute:'upgradeServerId'},
+};
 
 /**
  * This extensions pings devices to check if they are online.
@@ -31,8 +35,6 @@ class DeviceAvailability extends BaseExtension {
         this.ping_counters = {};
         this.max_ping = 3;
         this.state = {};
-        this.active_ping = true;
-        this.forced_ping = true;
         this.forcedNonPingable = {};
         this.number_of_registered_devices = 0;
         // force publish availability for new devices
@@ -48,34 +50,14 @@ class DeviceAvailability extends BaseExtension {
         this.name = 'DeviceAvailability';
         this.elevate_debug = false;
         this.isStarted = false;
-        this.active_ping = !config.disablePing;
-        this.forced_ping = false;
+        this.active_ping = config.pingCluster != 'off';
         this.max_ping = 5;
         this.availability_timeout = Math.max(60, typeof config.pingTimeout == 'number' ? config.pingTimeout : 300);
         this.startReadDelay = config.readAllAtStart ? Math.max(500, Math.min(10000, config.startReadDelay * 1000)) : 0;
         this.debugDevices = [];
+        this.pingCluster = pingClusters[config.pingCluster] ? pingClusters[config.pingCluster] : {};
     }
 
-    /* setOptions(options) {
-        if (typeof options !== 'object') {
-            return false;
-        }
-        if (options.disableActivePing) {
-            this.active_ping = false;
-        }
-        if (options.disableForcedPing) {
-            this.forced_ping = false;
-        }
-        if (typeof options.pingTimeout === 'number') {
-            this.availability_timeout = Math.min(60, options.pingTimeout);
-        }
-        if (typeof options.pingCount === 'number') {
-            this.max_ping = Math.min(2, options.pingCount);
-        }
-        this.startReadDelay = (typeof options.startReadDelay === 'number') ? Math.max(500, Math.min(10000, options.startReadDelay * 1000)) : 0;
-        this.warn(`DA: setting options to ${JSON.stringify(options)} - Read Delay is ${this.startReadDelay}`)
-        return true;
-    } */
     checkDebugDevice(dev) {
         if (typeof dev != 'string' || dev == '') return false;
         if (this.debugDevices === undefined) return false;
@@ -115,7 +97,6 @@ class DeviceAvailability extends BaseExtension {
         if (!this.isStarted) return;
         this.debug(`register device Ping for ${JSON.stringify(device.ieeeAddr)}`);
         this.forcedNonPingable[device.ieeeAddr] = false;
-        //        this.warn(`Called registerDevicePing for '${device}' of '${entity}'`);
         if (!this.isPingable(device)) {
             return;
         }
@@ -145,7 +126,6 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async startDevicePing() {
-        //        this.warn(JSON.stringify(this));
         if (!this.isStarted) return;
         this.startDevicePingTimeout = null;
         const item = this.startDevicePingQueue.shift();
@@ -174,21 +154,21 @@ class DeviceAvailability extends BaseExtension {
         const readables = [];
 
         this.isStarted = true;
-        //        this.warn('onZigbeeStarted called');
+        this.debug('onZigbeeStarted called');
 
         for (const device of clients) {
-            if (this.isPingable(device)) {
+            if (this.isPingable(device) && this.active_ping) {
                 readables.push(device);
                 //                this.setTimerPingable(device);
             } else {
-                //                this.warn(`Setting '${device.ieeeAddr}'  as available - battery driven`);
+                this.debug(`Setting '${device.ieeeAddr}'  as available - battery driven or no active availability check`);
                 this.publishAvailability(device, true);
                 this.timers[device.ieeeAddr] = setInterval(() =>
                     this.handleIntervalNotPingable(device), utils.secondsToMilliseconds(this.availability_timeout));
             }
         }
         if (this.startReadDelay > 0 && readables.length > 0) {
-            this.warn(`Triggering device_query on ${readables.length} devices in ${this.startReadDelay / 1000} seconds.`)
+            this.info(`Triggering device_query on ${readables.length} devices in ${this.startReadDelay / 1000} seconds.`)
             setTimeout(() => {
                 readables.forEach(device => this.zigbee.doDeviceQuery(device, Date().now, false));
             }, this.startReadDelay)
@@ -197,6 +177,9 @@ class DeviceAvailability extends BaseExtension {
 
     async handleIntervalPingable(device, entity) {
         if (!this.isStarted) return;
+        if (!this.active_ping) {
+            return await this.handleIntervalnonPingable();
+        }
         const has_elevated_debug = this.checkDebugDevice(device.ieeeAddr)
 
         const ieeeAddr = device.ieeeAddr;
@@ -215,13 +198,29 @@ class DeviceAvailability extends BaseExtension {
                 pingCount = {failed: 0, reported: 0};
             }
             try {
-                //this.warn(`Pinging '${ieeeAddr}' (${device.modelID})`)
-                await device.ping();
+                if (!this.pingCluster || !this.pingCluster.hasOwnProperty('id')) {
+                    this.debug(`Pinging '${ieeeAddr}' (${device.modelID}) via ZH Ping`)
+                    await device.ping();
+                }
+                else {
+                    const zclData = {};
+                    zclData[this.pingCluster.attribute] = {};
+                    this.debug(`Pinging '${ieeeAddr}' (${device.modelID}) via ZCL Read with ${this.pingCluster.id}:${this.pingCluster.attribute}`)
+                    await this.zigbee.publish(device, this.pingCluster.id, 'read', zclData, null, undefined, 'foundation');
+                }
                 this.publishAvailability(device, true);
                 if (has_elevated_debug) this.warn(`ELEVATED : Successfully pinged ${ieeeAddr} (${device.modelID}) in ${Date.now()-pt} ms`);
                 this.setTimerPingable(device, 1);
                 this.ping_counters[device.ieeeAddr].failed = 0;
             } catch (error) {
+                if (error && error.message && error.message.includes('UNSUPPORTED_ATTRIBUTE')) {
+                    // this error is acceptable, as it is raised off an answer of the device.
+                    this.publishAvailability(device, true);
+                    if (has_elevated_debug) this.warn(`ELEVATED : Successfully pinged ${ieeeAddr} (${device.modelID}) in ${Date.now()-pt} ms`);
+                    this.setTimerPingable(device, 1);
+                    this.ping_counters[device.ieeeAddr].failed = 0;
+                    return;
+                }
                 if (has_elevated_debug) this.warn(`ELEVATED : Failed to ping ${ieeeAddr} (${device.modelID}) after ${Date.now()-pt} ms${error && error.message ? ' - '+error.message : ''}`);
                 this.publishAvailability(device, false);
                 if (pingCount.failed++ <= this.max_ping) {

package/lib/zbDeviceConfigure.js

@@ -90,6 +90,7 @@ class DeviceConfigure extends BaseExtension {
     }
 
     onZigbeeEvent(data, mappedDevice) {
+        if (!mappedDevice || !data.device) return;
         try {
             const device = data.device;
             const com = this.configureOnMessageAttempts[device.ieeeAddr];
@@ -100,7 +101,13 @@ class DeviceConfigure extends BaseExtension {
                     this.info('Configure on Message for ' + device.ieeeAddr);
                     this.doConfigure(device, mappedDevice);
                 }
+                return;
+            }
+            // check if the event is a 'deviceInterview successful' Event
+            if (data.type == 'deviceJoined' || data.type == 'deviceInterview' && data.status == 'successful') {
+                this.PushDeviceToQueue(device, mappedDevice);
             }
+
         } catch (error) {
             this.sendError(error);
             this.error(`Failed to DeviceConfigure.onZigbeeEvent (${error && error.message ? error.message : 'no error message'})`);

package/lib/zbDeviceEvent.js

@@ -2,7 +2,6 @@
 
 const BaseExtension = require('./zbBaseExtension');
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
-
 class DeviceEvent extends BaseExtension {
     constructor(zigbee, options) {
         super(zigbee, options);
@@ -10,8 +9,10 @@ class DeviceEvent extends BaseExtension {
     }
 
     async onZigbeeStarted() {
-        for (const device of await this.zigbee.getClients()) {
-            await this.callOnEvent(device, 'start', {});
+        for (const device of await this.zigbee.getClientIterator()) {
+            const entity = await this.zigbee.resolveEntity(device);
+
+            await this.callOnEvent(device, 'start', {device, options:entity.options || {}});
         }
     }
 
@@ -29,7 +30,7 @@ class DeviceEvent extends BaseExtension {
     async stop() {
         if (this.zigbee.getClients() > 0) {
             for (const device of await this.zigbee.getClients()) {
-                await this.callOnEvent(device, 'stop', {});
+                await this.callOnEvent(device, 'stop', {ieeeAddr:device.ieeeAddr});
             }
         }
     }
@@ -38,9 +39,41 @@ class DeviceEvent extends BaseExtension {
         if (!mappedDevice) {
             mappedDevice = await zigbeeHerdsmanConverters.findByDevice(device);
         }
+        const baseData = {device, deviceExposeChanged: function() { return; }, options: data.options || {}, state: data.state || {}}
+        const eventData = {
+            type,
+        }
 
-        if (mappedDevice && mappedDevice.onEvent) {
-            mappedDevice.onEvent(type, data, device,mappedDevice.options,'{}');
+        switch (type) {
+            case 'start':
+            case 'deviceNetworkAddressChanged':
+            case 'deviceAnnounce':
+            case `deviceJoined`:
+            {
+                eventData.data = baseData;
+                break;
+            }
+            case 'stop':
+                eventData.data = { ieeeAddr:device.ieeeAddr };
+                break;
+            case 'deviceInterview':
+                eventData.data = {...baseData,status: data.status};
+                break;
+            case 'deviceOptionsChanged':
+                // NOTE: This does not currently work. OptionsChange is not yet defined.
+                eventData.data = {...baseData, from:data.from || {}, to:data.to || {}};
+                break;
+        }
+
+
+        if (mappedDevice && mappedDevice.onEvent && eventData.data) {
+            this.warn(`calling onEvent for ${eventData.type} on ${device.ieeeAddr}`);
+            try {
+                mappedDevice.onEvent(eventData);
+            }
+            catch (error) {
+                this.warn(`Error in onEvent: ${error && error.message ? error.message : 'no message'}`);
+            }
         }
     }
 }