iobroker.anthbot 0.0.3 → 0.0.5

package/main.js

@@ -50,7 +50,7 @@ class Anthbot extends utils.Adapter {
         // Verify we have credentials
         if (this.config.username == '' || this.config.password == '' || !this.config.regionCode) {
             this.log.error('Incomplete adapter configuration! Please check settings.');
-            this.terminate();
+            // Don't actually terminate - when the adapter config is updated that will trigger a restart
         } else {
             this.loginAndStart();
         }
@@ -82,143 +82,141 @@ class Anthbot extends utils.Adapter {
                 idParts.pop();
 
                 const serialNumber = idParts.pop();
-                const device = this.devices.find(checkDevice => checkDevice.sn === serialNumber);
-
-                if (!device) {
-                    this.log.error(`Could not find device for command with serial number: ${serialNumber}`);
+                if (!serialNumber) {
+                    this.log.error(`No serial number found in command ${id}`);
                 } else {
-                    switch (command) {
-                        case 'area_set': {
-                            let customAreas;
-                            if (typeof state?.val !== 'string') {
-                                this.log.error('Command custom_areas for ${serialNumber} is not a string');
-                            } else {
-                                try {
-                                    customAreas = JSON.parse(state.val);
-                                } catch (error) {
-                                    this.log.error(`Failed to parse for ${id}: ${error.message}`);
+                    const device = this.devices.find(checkDevice => checkDevice.sn === serialNumber);
+
+                    if (!serialNumber || !device) {
+                        this.log.error(`Could not find device for command with serial number: ${serialNumber}`);
+                    } else {
+                        switch (command) {
+                            case 'area_set': {
+                                let customAreas;
+                                if (typeof state?.val !== 'string') {
+                                    this.log.error('Command custom_areas for ${serialNumber} is not a string');
+                                } else {
+                                    try {
+                                        customAreas = JSON.parse(state.val);
+                                    } catch (error) {
+                                        this.log.error(`Failed to parse for ${id}: ${error.message}`);
+                                    }
                                 }
-                            }
 
-                            // Overlay elements from the state onto existing zones so user only has to set
-                            // the items they are changing and rest will be preserved.
+                                // Overlay elements from the state onto existing custom areas so user only has to set
+                                // the items they are changing and rest will be preserved.
 
-                            // Variable named to match asyncSendServiceCommand data
-                            const custom_areas = this.validateCustomAreas(device, customAreas);
-
-                            if (!custom_areas) {
-                                this.log.error(`Bad area data in ${id}`);
-                            } else {
-                                // Write the given area (zone) data
-                                this.log.info(`${device.alias}: area_set ${JSON.stringify(customAreas)}`);
-                                await this.client.asyncSendServiceCommand(serialNumber, 'area_set', {
-                                    custom_areas,
-                                });
-
-                                ackState = JSON.stringify(customAreas);
-                            }
+                                // Variable named to match asyncSendServiceCommand data
+                                const custom_areas = this.validateCustomAreas(device, customAreas);
 
-                            break;
-                        }
+                                if (!custom_areas) {
+                                    this.log.error(`Bad area data in ${id}`);
+                                } else {
+                                    // Write the given custom area data
+                                    this.log.info(`${device.alias}: area_set ${JSON.stringify(customAreas)}`);
+                                    await this.client.asyncSendServiceCommand(serialNumber, 'area_set', {
+                                        custom_areas,
+                                    });
 
-                        case 'custom_area_mow_start': {
-                            // Get/check command zone_list
-                            // This could be done in one shot, but get the state first for debug logging
-                            const command_zone_list_state = await this.getStateAsync(`${device.sn}.command.zone_list`);
-                            this.log.debug(
-                                `Current command.zone_list state: ${JSON.stringify(command_zone_list_state)}`,
-                            );
-
-                            let command_zone_list;
-                            if (typeof command_zone_list_state?.val !== 'string') {
-                                this.log.error('Command zone list for ${serialNumber} is not a string');
-                            } else {
-                                try {
-                                    command_zone_list = JSON.parse(command_zone_list_state.val);
-                                } catch (error) {
-                                    this.log.error(
-                                        `Failed to parse command zone list for ${serialNumber}: ${error.message}`,
-                                    );
+                                    ackState = JSON.stringify(customAreas);
                                 }
+
+                                break;
                             }
 
-                            if (Array.isArray(command_zone_list) && command_zone_list.length > 0) {
-                                if (!this.isGoodZoneList(device, command_zone_list)) {
-                                    this.log.error(
-                                        'Cannot start custom_area_mow_start due to invalid command.zone_list',
-                                    );
-                                } else {
+                            case 'custom_area_mow_start': {
+                                const goodAreaList = await this.isGoodAreaList(device, `map.custom_areas.raw`);
+                                if (goodAreaList) {
                                     this.log.info(
-                                        `${device.alias}: custom_area_mow_start ${JSON.stringify(command_zone_list)}`,
+                                        `${device.alias}: custom_area_mow_start ${JSON.stringify(goodAreaList)}`,
                                     );
                                     await this.client.asyncSendServiceCommand(serialNumber, 'custom_area_mow_start', {
-                                        id: command_zone_list,
+                                        id: goodAreaList,
                                     });
                                     ackState = true;
                                 }
+                                break;
                             }
-                            break;
-                        }
 
-                        case 'zone_list': {
-                            let zoneList;
-                            // This will affect the next start command only.
-                            if (typeof state?.val === 'string' && state.val !== '') {
-                                // Some kind of non-blank value given
-                                try {
-                                    zoneList = JSON.parse(state.val);
-                                } catch (error) {
-                                    this.log.error(`Failed to parse zone list for ${id}: ${error.message}`);
+                            case 'ridable_mow_start': {
+                                const goodAreaList = await this.isGoodAreaList(device, `map.ridable_areas.raw`);
+                                if (goodAreaList) {
+                                    this.log.info(`${device.alias}: ridable_mow_start ${JSON.stringify(goodAreaList)}`);
+                                    await this.client.asyncSendServiceCommand(serialNumber, 'ridable_mow_start', {
+                                        id: goodAreaList,
+                                    });
+                                    ackState = true;
                                 }
+                                break;
+                            }
 
-                                // Make sure all IDs in list are valid
-                                if (!this.isGoodZoneList(device, zoneList)) {
-                                    // Set to null so we don't ack it
-                                    zoneList = null;
+                            case 'area_list': {
+                                let areaList;
+                                // This will affect the next start command only.
+                                if (typeof state?.val === 'string' && state.val !== '') {
+                                    // Some kind of non-blank value given
+                                    try {
+                                        areaList = JSON.parse(state.val);
+                                    } catch (error) {
+                                        this.log.error(`Failed to parse area list for ${id}: ${error.message}`);
+                                    }
+
+                                    // Make sure this is a list & is of valid custom or ridable area IDs
+                                    if (
+                                        !areaList ||
+                                        !Array.isArray(areaList) ||
+                                        !(
+                                            (await this.isGoodAreaList(device, 'map.custom_areas.raw', areaList)) ||
+                                            (await this.isGoodAreaList(device, 'map.ridable_areas.raw', areaList))
+                                        )
+                                    ) {
+                                        // Set to null so we don't ack it
+                                        areaList = null;
+                                    }
+                                } else {
+                                    // No value given, so ack an empty list
+                                    areaList = [];
+                                }
+
+                                // Ack only if we now have a list
+                                if (Array.isArray(areaList)) {
+                                    ackState = JSON.stringify(areaList);
+                                    // We don't need to sync after this as no command was actually sent yet
+                                    doSync = false;
                                 }
-                            } else {
-                                // No value given, so ack an empty list
-                                zoneList = [];
-                            }
 
-                            // Ack only if we now have a list
-                            if (Array.isArray(zoneList)) {
-                                ackState = JSON.stringify(zoneList);
-                                // We don't need to sync after this as no command was actually sent yet
-                                doSync = false;
+                                break;
                             }
 
-                            break;
-                        }
+                            case 'mow_start':
+                                // To start mowing have to put app_state first.
+                                await this.client.asyncSendServiceCommand(serialNumber, 'app_state', 1);
+                            // Purposfully fall through to send the actual command!
+
+                            // Generic one-shot commands
+                            /* falls through */
+                            case 'charge_start':
+                            case 'mow_pause':
+                            case 'stop_all_tasks': {
+                                this.log.info(`${device.alias}: ${command}`);
+                                await this.client.asyncSendServiceCommand(serialNumber, command, 1);
+                                ackState = true;
+                                break;
+                            }
 
-                        case 'mow_start':
-                            // To start mowing have to put app_state first.
-                            await this.client.asyncSendServiceCommand(serialNumber, 'app_state', 1);
-                        // Purposfully fall through to send the actual command!
-
-                        // Generic one-shot commands
-                        /* falls through */
-                        case 'charge_start':
-                        case 'mow_pause':
-                        case 'stop_all_tasks': {
-                            this.log.info(`${device.alias}: ${command}`);
-                            await this.client.asyncSendServiceCommand(serialNumber, command, 1);
-                            ackState = true;
-                            break;
+                            default:
+                                this.log.warn(`Unknown command: ${command}`);
                         }
-
-                        default:
-                            this.log.warn(`Unknown command: ${command}`);
                     }
-                }
 
-                // Ack command if verified valid above
-                if (ackState) {
-                    await this.setState(id, ackState, true);
+                    // Ack command if verified valid above
+                    if (ackState) {
+                        await this.setState(id, ackState, true);
 
-                    // Sync device if no explicitally set not to
-                    if (doSync) {
-                        this.syncDevice(device);
+                        // Sync device if no explicitally set not to
+                        if (doSync) {
+                            this.syncDevice(device);
+                        }
                     }
                 }
             }
@@ -261,11 +259,7 @@ class Anthbot extends utils.Adapter {
 
         this.log.info('Connecting to Anthbot cloud...');
         try {
-            await this.client.asyncLogin({
-                username: this.config.username,
-                password: this.config.password,
-                areaCode: this.config.regionCode,
-            });
+            await this.client.asyncLogin(this.config.username, this.config.password, this.config.regionCode);
         } catch (error) {
             this.log.error(`Failed to login to Anthbot cloud: ${error.message}`);
             await this.retryConnection();
@@ -312,16 +306,6 @@ class Anthbot extends utils.Adapter {
             // Wait a second for their backend
             await new Promise(resolve => this.setTimeout(resolve, 1000, null));
 
-            // TODO: figure out how to tell when map changes and reload periodically?
-            const deviceMapFiles = await this.client.asyncGetDeviceMap(device.sn);
-
-            const areaSetting = deviceMapFiles['area_setting.json'];
-            this.log.debug(`area_setting.json: ${JSON.stringify(areaSetting)}`);
-            this.setZoneInfo(device, areaSetting?.content?.custom_areas);
-
-            const timeSetting = deviceMapFiles['time_setting.json'];
-            this.log.debug(`time_setting.json: ${JSON.stringify(timeSetting)}`);
-
             await this.pollDevice(device);
             this.pollingInterval = this.setInterval(async () => {
                 this.pollDevice(device);
@@ -351,18 +335,24 @@ class Anthbot extends utils.Adapter {
     // Poll device
     async pollDevice(device) {
         if (this.checkClient()) {
+            // Map area ID for checking for changes
+            let area_id;
+
+            // Shadow state
             try {
                 const shadowState = await this.client.asyncGetShadowReportedState(device.sn);
                 this.log.debug(`Device shadow reported state:\n${JSON.stringify(shadowState)}`);
                 await this.setShadowState(device, shadowState);
+                area_id = shadowState.map.area_id;
             } catch (err) {
                 this.log.error(`Failed to fetch shadow state for device ${device.sn}: ${err.message}`);
                 // TODO: If something goes wrong here, might not be serious, maybe don't do a full reconnect?
                 this.retryConnection();
             }
 
+            // Code list
             try {
-                const codeList = await this.client.asyncGetCodeList(device.sn);
+                const codeList = await this.client.asyncGetCodeList(device.sn, 1, 20 /* TODO: make configurable? */);
                 this.log.debug(`Device code list:\n${JSON.stringify(codeList)}`);
                 await this.setCodeList(device, codeList);
             } catch (err) {
@@ -370,243 +360,150 @@ class Anthbot extends utils.Adapter {
                 // TODO: If something goes wrong here, might not be serious, maybe don't do a full reconnect?
                 this.retryConnection();
             }
-        }
-    }
 
-    // Create objects for device
-    async createDeviceObjects(device) {
-        await this.setObjectNotExistsAsync(device.sn, {
-            type: 'device',
-            common: {
-                name: device.alias,
-            },
-            native: {},
-        });
+            // Fetch map if changed
+            if (area_id != device.area_id) {
+                this.log.info(`Device map area_id change detected, fetching new map info`);
 
-        // Shadow properties...
-        await this.setObjectNotExistsAsync(`${device.sn}.elec`, {
-            type: 'state',
-            common: {
-                name: 'elec',
-                type: 'number',
-                unit: '%',
-                desc: 'Battery level',
-                role: 'level.battery',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const deviceMapFiles = await this.client.asyncGetDeviceMap(device.sn);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mode`, {
-            type: 'state',
-            common: {
-                name: 'mode',
-                type: 'string',
-                role: 'text',
-                desc: 'Current mode',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const areaSetting = deviceMapFiles['area_setting.json'];
+                this.log.debug(`area_setting.json: ${JSON.stringify(areaSetting)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mowing_area`, {
-            type: 'state',
-            common: {
-                name: 'mowing_area',
-                type: 'number',
-                unit: 'm²',
-                desc: 'Current mowing area',
-                role: 'value',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const custom_areas = areaSetting?.content?.custom_areas;
+                this.log.debug(`custom_areas: ${JSON.stringify(custom_areas)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mowing_time`, {
-            type: 'state',
-            common: {
-                name: 'mowing_time',
-                type: 'number',
-                unit: 's',
-                role: 'time.span',
-                desc: 'Current mowing time',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // Stash custom_areas in the passed device
+                device.customAreas = custom_areas;
 
-        await this.setObjectNotExistsAsync(`${device.sn}.rtk_moved`, {
-            type: 'state',
-            common: {
-                name: 'rtk_moved',
-                type: 'boolean',
-                role: 'sensor.motion',
-                desc: 'RTK movement detected',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // And save the state
+                this.setStateChanged(`${device.sn}.map.custom_areas.raw`, {
+                    val: JSON.stringify(custom_areas),
+                    ack: true,
+                });
 
-        await this.setObjectNotExistsAsync(`${device.sn}.rtk_state`, {
-            type: 'state',
-            common: {
-                name: 'rtk_state',
-                type: 'boolean',
-                role: 'sensor',
-                desc: 'RTK state',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // Save ridable areas state
+                this.setStateChanged(`${device.sn}.map.ridable_areas.raw`, {
+                    val: JSON.stringify(areaSetting?.content?.ridable_areas),
+                    ack: true,
+                });
 
-        // Code list (aka. messages)
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code`, {
-            type: 'state',
-            common: {
-                name: 'last_code',
-                type: 'number',
-                desc: 'Last code',
-                role: 'value',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // TODO: plan is to create a channel for each area and store info for them indivicually.
 
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code_text`, {
-            type: 'state',
-            common: {
-                name: 'last_code_text',
-                type: 'string',
-                role: 'text',
-                desc: 'Last code text',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const timeSetting = deviceMapFiles['time_setting.json'];
+                this.log.debug(`time_setting.json: ${JSON.stringify(timeSetting)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code_type`, {
-            type: 'state',
-            common: {
-                name: 'last_code_type',
-                type: 'string',
-                role: 'text',
-                desc: 'Last code type (e.g. event, error, etc.)',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // And remember which area_id we loaded last
+                device.area_id = area_id;
+            }
+        }
+    }
 
-        await this.setObjectNotExistsAsync(`${device.sn}.zone_info`, {
-            type: 'state',
+    // Create objects for device
+    async createDeviceObjects(device) {
+        await this.setObjectNotExistsAsync(device.sn, {
+            type: 'device',
             common: {
-                name: 'zone_info',
-                type: 'string',
-                role: 'json',
-                desc: 'JSON object with zone information',
-                read: true,
-                write: false,
+                name: device.alias,
             },
             native: {},
         });
 
-        // Command buttons
-        await this.setObjectNotExistsAsync(`${device.sn}.command.custom_area_mow_start`, {
-            type: 'state',
-            common: {
-                name: 'start',
-                type: 'boolean',
-                role: 'button.start',
-                desc: 'Start zone mowing',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.mow_start`, {
-            type: 'state',
-            common: {
-                name: 'start',
-                type: 'boolean',
-                role: 'button.start',
-                desc: 'Start global mowing',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.stop_all_tasks`, {
-            type: 'state',
-            common: {
-                name: 'stop',
-                type: 'boolean',
-                role: 'button.stop',
-                desc: 'Stop',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.mow_pause`, {
-            type: 'state',
-            common: {
-                name: 'pause',
-                type: 'boolean',
-                role: 'button.pause',
-                desc: 'Pause',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.charge_start`, {
-            type: 'state',
-            common: {
-                name: 'home',
-                type: 'boolean',
-                role: 'button',
-                desc: 'Return home/start charging',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
+        const channels = [
+            ['command', 'Commands'],
+            ['map', 'Map info'],
+            ['map.custom_areas', 'Custom areas, aka. Zones'],
+            ['map.ridable_areas', 'Ridable areas, aka. Edges'],
+        ];
+
+        for (const channel of channels) {
+            await this.setObjectNotExistsAsync(`${device.sn}.${channel[0]}`, {
+                type: 'channel',
+                common: {
+                    name: channel[0],
+                    desc: channel[1],
+                },
+                native: {},
+            });
+        }
 
-        // Zone list for relevant commands
-        await this.setObjectNotExistsAsync(`${device.sn}.command.zone_list`, {
-            type: 'state',
-            common: {
-                name: 'zone_list',
-                type: 'array',
-                role: 'info.ids',
-                desc: `Zone list for next command (array of zone IDs, e.g. '[101,120,132]')`,
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
+        const readOnlyStates = [
+            // Shadow properties
+            ['active_area', 'array', 'info.ids', 'List of areas currently being mowed'],
+            ['elec', 'number', 'level.battery', 'Battery level', '%'],
+            ['mode', 'string', 'text', 'Current mode'],
+            ['mowing_area', 'number', 'value', 'Current mowing area', 'm²'],
+            ['mowing_time', 'number', 'time.span', 'Current mowing time', 's'],
+            ['rtk_moved', 'boolean', 'sensor.motion', 'RTK movement detected'],
+            ['rtk_state', 'boolean', 'sensor', 'RTK state'],
+
+            // Code list (aka. messages)
+            // Full list for 'power users'
+            ['code_list', 'string', 'json', 'JSON object with last page of codes'],
+            // Last code for simplcity
+            ['last_code', 'number', 'value', 'Last code'],
+            ['last_code_text', 'string', 'text', 'Last code text'],
+            ['last_code_type', 'string', 'text', 'Last code type (e.g. event, error, etc.)'],
+
+            // Maps
+            ['map.area_id', 'string', 'text', 'ID of current map area'],
+            ['map.map_area', 'number', 'value', 'Surface area of map', 'm²'],
+            ['map.custom_areas.raw', 'string', 'json', 'JSON object with custom area (aka. zone) information'],
+            ['map.ridable_areas.raw', 'string', 'json', 'JSON object with ridable area (aka. edge) information'],
+        ];
+
+        for (const state of readOnlyStates) {
+            const common = {
+                name: state[0],
+                type: state[1],
+                role: state[2],
+                desc: state[3],
+                read: true,
+                write: false,
+            };
+            if (state[4]) {
+                common.unit = state[4];
+            }
+            // @ts-expect-error as 'type' below as a plain string doesn't check against ioBroker.CommonType
+            await this.setObjectNotExistsAsync(`${device.sn}.${state[0]}`, {
+                type: 'state',
+                common,
+                native: {},
+            });
+        }
 
-        // For 'area_set'
-        await this.setObjectNotExistsAsync(`${device.sn}.command.area_set`, {
-            type: 'state',
-            common: {
-                name: 'area_set',
-                type: 'string',
-                role: 'json',
-                desc: 'JSON object with zone information to write',
+        const commandStates = [
+            // Command buttons
+            ['mow_start', 'boolean', 'button.start', 'Start global mowing'],
+            ['stop_all_tasks', 'boolean', 'button.stop', 'Stop'],
+            ['mow_pause', 'boolean', 'button.pause', 'Pause'],
+            ['charge_start', 'boolean', 'button', 'Return home/start charging'],
+            ['custom_area_mow_start', 'boolean', 'button.start', 'Start custom area (aka. zone) mowing'],
+            ['ridable_mow_start', 'boolean', 'button.start', 'Start ridable area (aka. edge) mowing'],
+
+            // Area list for relevant commands
+            ['area_list', 'string', 'info.ids', `Areas for next command (array of IDs, e.g. '[101,120,132]')`],
+
+            // For 'area_set'
+            ['area_set', 'string', 'json', 'JSON object with custom area (aka. zone) information to write'],
+        ];
+
+        for (const state of commandStates) {
+            const common = {
+                name: state[0],
+                type: state[1],
+                role: state[2],
+                desc: state[3],
                 read: false,
                 write: true,
-            },
-            native: {},
-        });
+            };
+            // @ts-expect-error as 'type' below as a plain string doesn't check against ioBroker.CommonType
+            await this.setObjectNotExistsAsync(`${device.sn}.command.${state[0]}`, {
+                type: 'state',
+                common,
+                native: {},
+            });
+        }
     }
 
     // Helper function to set shadow state values
@@ -617,15 +514,24 @@ class Anthbot extends utils.Adapter {
             this.setConnected(false);
         }
 
+        this.setStateChanged(`${device.sn}.active_area`, {
+            val: JSON.stringify(shadowState.active_area.id),
+            ack: true,
+        });
         this.setStateChanged(`${device.sn}.elec`, { val: shadowState.elec.value, ack: true });
         this.setStateChanged(`${device.sn}.mode`, { val: shadowState.mode.value, ack: true });
         this.setStateChanged(`${device.sn}.mowing_area`, { val: shadowState.mowing_area.value, ack: true });
         this.setStateChanged(`${device.sn}.mowing_time`, { val: shadowState.mowing_time.value, ack: true });
         this.setStateChanged(`${device.sn}.rtk_moved`, { val: shadowState.rtk.moved == 1, ack: true });
         this.setStateChanged(`${device.sn}.rtk_state`, { val: shadowState.rtk.state == 1, ack: true });
+
+        this.setStateChanged(`${device.sn}.map.area_id`, { val: shadowState.map.area_id, ack: true });
+        this.setStateChanged(`${device.sn}.map.map_area`, { val: shadowState.map.map_area, ack: true });
     }
 
     setCodeList(device, codeList) {
+        this.setStateChanged(`${device.sn}.code_list`, { val: JSON.stringify(codeList), ack: true });
+
         const lastCode = codeList[0];
         this.setStateChanged(`${device.sn}.last_code`, { val: lastCode.code, ack: true });
         this.setStateChanged(`${device.sn}.last_code_text`, { val: lastCode.event_message, ack: true });
@@ -641,7 +547,7 @@ class Anthbot extends utils.Adapter {
             for (const area of customAreas) {
                 let outArea;
 
-                const existingArea = device.zoneList.find(zone => zone.id === area.id);
+                const existingArea = device.customAreas.find(customArea => customArea.id === area.id);
                 if (existingArea) {
                     this.log.debug(`Found existing area ${area.id} for merge: ${JSON.stringify(existingArea)}`);
                     outArea = { ...existingArea, ...area };
@@ -691,42 +597,72 @@ class Anthbot extends utils.Adapter {
         return outputAreas;
     }
 
-    isGoodZoneList(device, zoneList) {
+    parseJsonList(jsonString) {
+        let out;
+        if (typeof jsonString !== 'string') {
+            this.log.error('JSON to parse is not a string');
+        } else {
+            try {
+                out = JSON.parse(jsonString);
+            } catch (error) {
+                this.log.error(`Failed to parse JSON list: ${error.message}`);
+            }
+        }
+
         // List to check must be an array
-        if (!Array.isArray(zoneList)) {
-            this.log.error(`Invalid zone list: not an array`);
+        if (!Array.isArray(out)) {
+            this.log.error(`Invalid JSON list: not an array`);
+            out = undefined;
+        }
+
+        // List to check must have at least one item
+        if (out && out.length < 1) {
+            this.log.error(`Invalid JSON list: array is empty`);
+            out = undefined;
+        }
+
+        return out;
+    }
+
+    /**
+     *
+     * @param {object} device Device object for the check or specific list
+     * @param {string} checkListStateId State ID holding raw JSON list to check against
+     * @param {array | null} passedToCheck Optional list to check instead of fetching from command state
+     * @returns {Promise<array | false>} List if good, false if not
+     */
+
+    async isGoodAreaList(device, checkListStateId, passedToCheck = null) {
+        const listToCheck = passedToCheck
+            ? passedToCheck
+            : this.parseJsonList((await this.getStateAsync(`${device.sn}.command.area_list`))?.val);
+
+        if (!listToCheck || !Array.isArray(listToCheck)) {
+            this.log.error('Area list to check is not valid');
             return false;
         }
 
-        // If we don't even have zones for our device any list is bad
-        if (!device.zoneList) {
-            this.log.error('Invalid zone list: device has no zone info');
+        // Get IDs to check against
+        const checkAreas = this.parseJsonList((await this.getStateAsync(`${device.sn}.${checkListStateId}`))?.val);
+        // If we don't even have custom areas for our device any list is bad
+        if (!checkAreas) {
+            this.log.error(`Area list invalid: no IDs to check against in ${checkListStateId}`);
             return false;
         }
 
-        // Each zone in array must be a known zone ID
-        checkZone: for (const zoneId of zoneList) {
-            for (const zone of device.zoneList) {
-                if (zone.id === zoneId) {
-                    continue checkZone;
+        // Each area in array must be a known custom area ID
+        checkArea: for (const areaToCheck of listToCheck) {
+            for (const checkArea of checkAreas) {
+                if (checkArea.id === areaToCheck) {
+                    continue checkArea;
                 }
             }
-            // If we didn't continue, then we didn't find the zoneId in our info list, so it's not good
-            this.log.error(`Invalid zone list: ${zoneId} not found in device info`);
+            // If we didn't continue, then we didn't find the area ID in our info list, so it's not good
+            this.log.warn(`Invalid custom area list: ${areaToCheck} not found in check list ${checkListStateId}`);
             return false;
         }
 
-        return true;
-    }
-
-    setZoneInfo(device, zoneInfo) {
-        this.log.debug(`zone_info for ${device.sn}: ${JSON.stringify(zoneInfo)}`);
-
-        // Stash in the passed device
-        device.zoneList = zoneInfo;
-
-        // And save the state
-        this.setStateChanged(`${device.sn}.zone_info`, { val: JSON.stringify(zoneInfo), ack: true });
+        return listToCheck;
     }
 
     subscribeToDevice(device) {