matterbridge-roborock-vacuum-plugin 1.1.0-rc18 → 1.1.1-rc01

package/dist/helper.js

@@ -55,16 +55,13 @@ export async function getRoomMap(duid, platform) {
 export async function getRoomMapFromDevice(device, platform) {
     const rooms = device?.rooms ?? [];
     const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature.enableMultipleMap) ?? false;
-    platform.log.notice('-------------------------------------------0--------------------------------------------------------');
-    platform.log.notice(`getRoomMapFromDevice - device.rooms: ${debugStringify(rooms)}`);
     if (device && platform.roborockService) {
         const mapInfo = await platform.roborockService.getMapInformation(device.duid);
-        platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+        platform.log.debug(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+        platform.log.debug(`getRoomMapFromDevice - rooms: ${debugStringify(rooms)}`);
         if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
             const roomDataMap = mapInfo.allRooms;
             const roomMap = new RoomMap(roomDataMap, rooms, mapInfo.maps, enableMultipleMap);
-            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-            platform.log.notice('-------------------------------------------2--------------------------------------------------------');
             return roomMap;
         }
         const roomData = await platform.roborockService.getRoomMappings(device.duid);
@@ -72,8 +69,6 @@ export async function getRoomMapFromDevice(device, platform) {
             platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
             const roomDataMap = roomData.map((r) => ({ id: r[0], iot_name_id: String(r[1]), globalId: r[1], tag: r[2], mapId: 0, displayName: undefined }));
             const roomMap = new RoomMap(roomDataMap ?? [], rooms, [], enableMultipleMap);
-            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-            platform.log.notice('-------------------------------------------1--------------------------------------------------------');
             return roomMap;
         }
     }

package/dist/model/RoomMap.js

@@ -9,7 +9,7 @@ export class RoomMap {
             return {
                 id,
                 globalId: globalId !== undefined ? Number(globalId) : undefined,
-                displayName: room?.name,
+                displayName: room?.name ?? `Room ${id}`,
                 alternativeId: `${id}${tag}`,
                 mapId,
             };

package/dist/model/roomIndexMap.js

@@ -4,12 +4,16 @@ export class RoomIndexMap {
     constructor(roomMap) {
         this.indexMap = roomMap;
         this.roomMap = new Map();
-        for (const [areaId, { roomId }] of roomMap.entries()) {
-            this.roomMap.set(roomId, areaId);
+        for (const [areaId, { roomId, mapId }] of roomMap.entries()) {
+            this.roomMap.set(`${roomId}:${mapId}`, areaId);
         }
     }
-    getAreaId(roomId) {
-        return this.roomMap.get(roomId);
+    getAreaId(roomId, mapId) {
+        const areaId = this.roomMap.get(`${roomId}:${mapId}`);
+        if (areaId === undefined) {
+            return undefined;
+        }
+        return areaId;
     }
     getRoomId(areaId) {
         return this.indexMap.get(areaId)?.roomId;

package/dist/platform.js

@@ -26,8 +26,8 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     rrHomeId;
     constructor(matterbridge, log, config) {
         super(matterbridge, log, config);
-        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.8')) {
-            throw new Error(`This plugin requires Matterbridge version >= "3.1.8". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
+        if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.2.0')) {
+            throw new Error(`This plugin requires Matterbridge version >= "3.2.0". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`);
         }
         this.log.info('Initializing platform:', this.config.name);
         if (config.whiteList === undefined)
@@ -52,6 +52,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         }
         const axiosInstance = axios.default ?? axios;
         this.enableExperimentalFeature = this.config.enableExperimental;
+        this.enableExperimentalFeature.advancedFeature.enableMultipleMap = false;
         if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature?.cleanModeSettings?.enableCleanModeMapping) {
             this.cleanModeSettings = this.enableExperimentalFeature.cleanModeSettings;
             this.log.notice(`Experimental Feature has been enable`);
@@ -171,7 +172,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         this.roborockService.setSupportedAreaIndexMap(vacuum.duid, roomIndexMap);
         let routineAsRoom = [];
         if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.showRoutinesAsRoom) {
-            routineAsRoom = getSupportedScenes(vacuum.scenes, this.log);
+            routineAsRoom = getSupportedScenes(vacuum.scenes ?? [], this.log);
             this.roborockService.setSupportedScenes(vacuum.duid, routineAsRoom);
         }
         const robot = new RoborockVacuumCleaner(username, vacuum, roomMap, routineAsRoom, this.enableExperimentalFeature, this.log);

package/dist/platformRunner.js

@@ -1,15 +1,10 @@
-import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getRoomMap, getRoomMapFromDevice, getVacuumProperty, isStatusUpdate } from './helper.js';
-import { getRunningMode } from './initialData/getSupportedRunModes.js';
-import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
-import { getBatteryState, getBatteryStatus, getOperationalErrorState, getSupportedAreas } from './initialData/index.js';
+import { PowerSource, RvcOperationalState } from 'matterbridge/matter/clusters';
+import { getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
-import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
-import { hasDockingStationError, parseDockingStationStatus } from './model/DockingStationStatus.js';
-import { AdditionalPropCode } from './roborockCommunication/index.js';
-import { OperationStatusCode } from './roborockCommunication/Zenum/operationStatusCode.js';
-import { getCurrentCleanModeFunc } from './share/runtimeHelper.js';
 import { debugStringify } from 'matterbridge/logger';
+import { handleLocalMessage } from './runtimes/handleLocalMessage.js';
+import { handleCloudMessage } from './runtimes/handleCloudMessage.js';
+import { updateFromHomeData } from './runtimes/handleHomeDataMessage.js';
 export class PlatformRunner {
     platform;
     constructor(platform) {
@@ -17,7 +12,7 @@ export class PlatformRunner {
     }
     async updateRobot(messageSource, homeData) {
         if (messageSource === NotifyMessageTypes.HomeData) {
-            this.updateFromHomeData(homeData);
+            updateFromHomeData(homeData, this.platform);
         }
         else {
             await this.updateFromMQTTMessage(messageSource, homeData);
@@ -74,275 +69,22 @@ export class PlatformRunner {
             case NotifyMessageTypes.LocalMessage: {
                 const data = messageData;
                 const robot = platform.robots.get(duid);
-                if (!robot) {
-                    platform.log.error(`Error2: Robot with DUID ${duid} not found`);
+                if (robot && data) {
+                    await handleLocalMessage(data, platform, duid);
                     return;
                 }
-                if (data) {
-                    const state = state_to_matter_state(data.state);
-                    if (state) {
-                        robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
-                    }
-                    if (data.state === OperationStatusCode.Idle) {
-                        const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
-                    }
-                    if (state === RvcRunMode.ModeTag.Cleaning && !data.cleaning_info) {
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
-                    }
-                    else {
-                        const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-                        const roomIndexMap = this.platform.roborockService?.getSupportedAreasIndexMap(duid);
-                        const roomMap = await getRoomMap(duid, this.platform);
-                        const segment_id = data.cleaning_info?.segment_id ?? -1;
-                        const target_segment_id = data.cleaning_info?.target_segment_id ?? -1;
-                        let target_room_id = roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.id ?? -1;
-                        this.platform.log.debug(`Target segment id: ${segment_id}, targetRoom: ${target_room_id}`);
-                        const isMappedArea = currentMappedAreas?.some((x) => x.areaId == segment_id);
-                        if (segment_id !== -1 && isMappedArea) {
-                            this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-                            this.platform.log.debug(`Part1: CurrentRoom: ${segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`);
-                            const areaId = roomIndexMap?.getAreaId(segment_id) ?? segment_id;
-                            this.platform.log.notice(`AreaId: ${areaId}, segment_id: ${segment_id}`);
-                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log);
-                        }
-                        if (segment_id == -1) {
-                            const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == target_segment_id);
-                            target_room_id = roomMap?.rooms.find((x) => x.id == target_segment_id || x.alternativeId === target_segment_id.toString())?.id ?? -1;
-                            this.platform.log.debug(`Target segment id: ${target_segment_id}, targetRoom: ${target_room_id}`);
-                            if (target_segment_id !== -1 && isTargetMappedArea) {
-                                this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-                                this.platform.log.debug(`Part2: TargetRoom: ${target_segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === target_segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`);
-                                const areaId = roomIndexMap?.getAreaId(target_segment_id) ?? target_room_id;
-                                this.platform.log.notice(`AreaId: ${areaId}, target_segment_id: ${target_segment_id}`);
-                                robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log);
-                            }
-                        }
-                        if (target_segment_id == -1 && segment_id == -1) {
-                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
-                        }
-                    }
-                    if (data.battery) {
-                        const batteryLevel = data.battery;
-                        robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel * 2, platform.log);
-                        robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(data.state, data.battery), platform.log);
-                        robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
-                    }
-                    const currentCleanModeSetting = {
-                        suctionPower: data.cleaning_info?.fan_power ?? data.fan_power,
-                        waterFlow: data.cleaning_info?.water_box_status ?? data.water_box_mode,
-                        distance_off: data.distance_off,
-                        mopRoute: data.cleaning_info?.mop_mode ?? data.mop_mode,
-                        segment_id: data.cleaning_info?.segment_id,
-                        target_segment_id: data.cleaning_info?.target_segment_id,
-                    };
-                    this.platform.log.debug(`data: ${debugStringify(data)}`);
-                    this.platform.log.notice(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
-                    if (currentCleanModeSetting.mopRoute && currentCleanModeSetting.suctionPower && currentCleanModeSetting.waterFlow) {
-                        const currentCleanMode = getCurrentCleanModeFunc(deviceData.model, this.platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)(currentCleanModeSetting);
-                        this.platform.log.debug(`Current clean mode: ${currentCleanMode}`);
-                        if (currentCleanMode) {
-                            robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
-                        }
-                    }
-                    this.processAdditionalProps(robot, data, duid);
-                }
+                platform.log.error(`Error2: Robot with DUID ${duid} not found`);
                 break;
             }
             case NotifyMessageTypes.CloudMessage: {
                 const data = messageData;
                 if (!data)
                     return;
-                this.handlerCloudMessage(data, duid);
+                await handleCloudMessage(data, platform, this, duid);
                 break;
             }
             default:
                 break;
         }
     }
-    handlerCloudMessage(data, duid) {
-        const platform = this.platform;
-        const messageTypes = Object.keys(data.dps).map(Number);
-        const self = this;
-        const robot = platform.robots.get(duid);
-        if (robot === undefined) {
-            platform.log.error(`Error3: Robot with DUID ${duid} not found`);
-            return;
-        }
-        messageTypes.forEach(async (messageType) => {
-            switch (messageType) {
-                case Protocol.status_update: {
-                    const status = Number(data.dps[messageType]);
-                    const matterState = state_to_matter_state(status);
-                    if (matterState) {
-                        robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
-                    }
-                    const operationalStateId = state_to_matter_operational_status(status);
-                    if (operationalStateId) {
-                        const dssHasError = hasDockingStationError(robot.dockStationStatus);
-                        if (!(dssHasError && self.triggerDssError(robot))) {
-                            robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
-                        }
-                    }
-                    break;
-                }
-                case Protocol.rpc_response: {
-                    const response = data.dps[messageType];
-                    if (!isStatusUpdate(response.result)) {
-                        platform.log.debug('Ignore message:', debugStringify(data));
-                        return;
-                    }
-                    let roboStatus;
-                    if (Array.isArray(response.result) && response.result.length > 0) {
-                        roboStatus = response.result[0];
-                    }
-                    if (roboStatus) {
-                        const message = { ...roboStatus };
-                        platform.log.debug('rpc_response:', debugStringify(message));
-                        await self.updateFromMQTTMessage(NotifyMessageTypes.LocalMessage, message, duid, true);
-                    }
-                    break;
-                }
-                case Protocol.suction_power:
-                case Protocol.water_box_mode: {
-                    await platform.roborockService?.getCleanModeData(duid).then((cleanModeData) => {
-                        if (cleanModeData) {
-                            const currentCleanMode = getCurrentCleanModeFunc(robot.device.data.model, platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)({
-                                suctionPower: cleanModeData.suctionPower,
-                                waterFlow: cleanModeData.waterFlow,
-                                distance_off: cleanModeData.distance_off,
-                                mopRoute: cleanModeData.mopRoute,
-                            });
-                            platform.log.debug(`Clean mode data: ${debugStringify(cleanModeData)}`);
-                            platform.log.debug(`Current clean mode: ${currentCleanMode}`);
-                            if (currentCleanMode) {
-                                robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
-                            }
-                        }
-                    });
-                    break;
-                }
-                case Protocol.additional_props: {
-                    platform.log.notice(`Received additional properties for robot ${duid}: ${debugStringify(data)}`);
-                    const propCode = data.dps[Protocol.additional_props];
-                    platform.log.debug(`DPS for additional properties: ${propCode}, AdditionalPropCode: ${AdditionalPropCode[propCode]}`);
-                    const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap) ?? false;
-                    if (propCode === AdditionalPropCode.map_change) {
-                        platform.log.notice('------------------------ get roomData ----------------------------');
-                        const roomMap = await getRoomMapFromDevice(robot.device, platform);
-                        platform.log.notice('------------------------ Room map updated ------------------------');
-                        const { supportedAreas, supportedMaps, roomIndexMap } = getSupportedAreas(robot.device.rooms, roomMap, enableMultipleMap, platform.log);
-                        platform.log.notice(`Supported areas: ${debugStringify(supportedAreas)}`);
-                        platform.log.notice('------------------------ Supported areas updated ------------------');
-                        platform.roborockService?.setSupportedAreas(duid, supportedAreas);
-                        platform.roborockService?.setSelectedAreas(duid, []);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'supportedAreas', supportedAreas, platform.log);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
-                        if (enableMultipleMap) {
-                            platform.roborockService?.setSupportedAreaIndexMap(duid, roomIndexMap);
-                            robot.updateAttribute(ServiceArea.Cluster.id, 'supportedMaps', supportedMaps, platform.log);
-                        }
-                    }
-                    break;
-                }
-                case Protocol.back_type: {
-                    break;
-                }
-                default: {
-                    platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
-                    break;
-                }
-            }
-        });
-    }
-    async processAdditionalProps(robot, message, duid) {
-        const dssStatus = this.getDssStatus(message, duid);
-        if (dssStatus) {
-            this.triggerDssError(robot);
-        }
-    }
-    getDssStatus(message, duid) {
-        const platform = this.platform;
-        const robot = platform.robots.get(duid);
-        if (robot === undefined) {
-            platform.log.error(`Error4: Robot with DUID ${duid} not found`);
-            return undefined;
-        }
-        if (platform.enableExperimentalFeature &&
-            platform.enableExperimentalFeature.enableExperimentalFeature &&
-            platform.enableExperimentalFeature.advancedFeature.includeDockStationStatus &&
-            message.dss !== undefined) {
-            const dss = parseDockingStationStatus(message.dss);
-            if (dss && robot) {
-                robot.dockStationStatus = dss;
-            }
-            if (dss && hasDockingStationError(dss)) {
-                return RvcOperationalState.OperationalState.Error;
-            }
-        }
-        return undefined;
-    }
-    updateFromHomeData(homeData) {
-        const platform = this.platform;
-        if (platform.robots.size === 0)
-            return;
-        const devices = homeData.devices.filter((d) => platform.robots.has(d.duid));
-        for (const device of devices) {
-            const robot = platform.robots.get(device.duid);
-            if (robot === undefined) {
-                platform.log.error(`Error5: Robot with DUID ${device.duid} not found`);
-                continue;
-            }
-            const deviceData = robot.device.data;
-            if (!device || deviceData === undefined) {
-                platform.log.error('Device not found in home data');
-                return;
-            }
-            device.schema = homeData.products.find((prd) => prd.id === device.productId || prd.model === device.data.model)?.schema ?? [];
-            this.platform.log.debug('updateFromHomeData-homeData:', debugStringify(homeData));
-            this.platform.log.debug('updateFromHomeData-device:', debugStringify(device));
-            const batteryLevel = getVacuumProperty(device, 'battery');
-            this.platform.log.debug('updateFromHomeData-schema:' + debugStringify(device.schema));
-            this.platform.log.debug('updateFromHomeData-battery:' + debugStringify(device.deviceStatus));
-            if (batteryLevel) {
-                robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel ? batteryLevel * 2 : 200, platform.log);
-                robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
-            }
-            const state = getVacuumProperty(device, 'state');
-            const matterState = state_to_matter_state(state);
-            if (!state || !matterState) {
-                return;
-            }
-            this.platform.log.debug(`updateFromHomeData-RvcRunMode code: ${state} name: ${OperationStatusCode[state]}, matterState: ${RvcRunMode.ModeTag[matterState]}`);
-            if (matterState) {
-                robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
-            }
-            const operationalStateId = state_to_matter_operational_status(state);
-            if (operationalStateId) {
-                const dssHasError = hasDockingStationError(robot.dockStationStatus);
-                this.platform.log.debug(`dssHasError: ${dssHasError}, dockStationStatus: ${debugStringify(robot.dockStationStatus ?? {})}`);
-                if (!(dssHasError && this.triggerDssError(robot))) {
-                    this.platform.log.debug(`updateFromHomeData-OperationalState: ${RvcOperationalState.OperationalState[operationalStateId]}`);
-                    robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
-                }
-            }
-            if (batteryLevel) {
-                robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(state, batteryLevel), platform.log);
-            }
-        }
-    }
-    triggerDssError(robot) {
-        const platform = this.platform;
-        const currentOperationState = robot.getAttribute(RvcOperationalState.Cluster.id, 'operationalState');
-        if (currentOperationState === RvcOperationalState.OperationalState.Error) {
-            return true;
-        }
-        if (currentOperationState === RvcOperationalState.OperationalState.Docked) {
-            robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', RvcOperationalState.OperationalState.Error, platform.log);
-            return true;
-        }
-        return false;
-    }
 }

package/dist/runtimes/handleCloudMessage.js

@@ -0,0 +1,110 @@
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { AdditionalPropCode, Protocol } from '../roborockCommunication/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { RvcCleanMode, RvcOperationalState, RvcRunMode, ServiceArea } from 'matterbridge/matter/clusters';
+import { triggerDssError } from './handleLocalMessage.js';
+import { getRoomMapFromDevice, isStatusUpdate } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { NotifyMessageTypes } from '../notifyMessageTypes.js';
+import { getCurrentCleanModeFunc } from '../share/runtimeHelper.js';
+import { getSupportedAreas } from '../initialData/getSupportedAreas.js';
+export async function handleCloudMessage(data, platform, runner, duid) {
+    const messageTypes = Object.keys(data.dps).map(Number);
+    const robot = platform.robots.get(duid);
+    if (robot === undefined) {
+        platform.log.error(`Error3: Robot with DUID ${duid} not found`);
+        return;
+    }
+    messageTypes.forEach(async (messageType) => {
+        switch (messageType) {
+            case Protocol.status_update: {
+                const status = Number(data.dps[messageType]);
+                const matterState = state_to_matter_state(status);
+                if (matterState) {
+                    robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+                }
+                const operationalStateId = state_to_matter_operational_status(status);
+                if (operationalStateId) {
+                    const dssHasError = hasDockingStationError(robot.dockStationStatus);
+                    if (!(dssHasError && triggerDssError(robot, platform))) {
+                        robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+                    }
+                }
+                break;
+            }
+            case Protocol.rpc_response: {
+                const response = data.dps[messageType];
+                if (!isStatusUpdate(response.result)) {
+                    platform.log.debug('Ignore message:', debugStringify(data));
+                    return;
+                }
+                let roboStatus;
+                if (Array.isArray(response.result) && response.result.length > 0) {
+                    roboStatus = response.result[0];
+                }
+                if (roboStatus) {
+                    const message = { ...roboStatus };
+                    platform.log.debug('rpc_response:', debugStringify(message));
+                    await runner.updateFromMQTTMessage(NotifyMessageTypes.LocalMessage, message, duid, true);
+                }
+                break;
+            }
+            case Protocol.suction_power:
+            case Protocol.water_box_mode: {
+                await platform.roborockService?.getCleanModeData(duid).then((cleanModeData) => {
+                    if (cleanModeData) {
+                        const currentCleanMode = getCurrentCleanModeFunc(robot.device.data.model, platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)({
+                            suctionPower: cleanModeData.suctionPower,
+                            waterFlow: cleanModeData.waterFlow,
+                            distance_off: cleanModeData.distance_off,
+                            mopRoute: cleanModeData.mopRoute,
+                        });
+                        platform.log.debug(`Clean mode data: ${debugStringify(cleanModeData)}`);
+                        platform.log.debug(`Current clean mode: ${currentCleanMode}`);
+                        if (currentCleanMode) {
+                            robot.updateAttribute(RvcCleanMode.Cluster.id, 'currentMode', currentCleanMode, platform.log);
+                        }
+                    }
+                });
+                break;
+            }
+            case Protocol.additional_props: {
+                platform.log.notice(`Received additional properties for robot ${duid}: ${debugStringify(data)}`);
+                const propCode = data.dps[Protocol.additional_props];
+                platform.log.debug(`DPS for additional properties: ${propCode}, AdditionalPropCode: ${AdditionalPropCode[propCode]}`);
+                if (propCode === AdditionalPropCode.map_change) {
+                    await handleMapChange(robot, platform, duid);
+                }
+                break;
+            }
+            case Protocol.back_type: {
+                break;
+            }
+            default: {
+                platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
+                break;
+            }
+        }
+    });
+}
+export async function handleMapChange(robot, platform, duid) {
+    const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature?.enableMultipleMap) ?? false;
+    if (!enableMultipleMap)
+        return;
+    await getRoomMapFromDevice(robot.device, platform).then((roomMap) => {
+        const { supportedAreas, supportedMaps, roomIndexMap } = getSupportedAreas(robot.device.rooms, roomMap, enableMultipleMap, platform.log);
+        platform.log.debug(`handleMapChange - supportedAreas: ${debugStringify(supportedAreas)}`);
+        platform.log.debug(`handleMapChange - supportedMaps: ${debugStringify(supportedMaps)}`);
+        platform.log.debug(`handleMapChange - roomIndexMap: `, roomIndexMap);
+        platform.roborockService?.setSupportedAreas(duid, supportedAreas);
+        platform.roborockService?.setSelectedAreas(duid, []);
+        robot.updateAttribute(ServiceArea.Cluster.id, 'supportedAreas', supportedAreas, platform.log);
+        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+        if (enableMultipleMap) {
+            platform.roborockService?.setSupportedAreaIndexMap(duid, roomIndexMap);
+            robot.updateAttribute(ServiceArea.Cluster.id, 'supportedMaps', supportedMaps, platform.log);
+        }
+    });
+}

package/dist/runtimes/handleHomeDataMessage.js

@@ -0,0 +1,57 @@
+import { PowerSource, RvcOperationalState, RvcRunMode } from 'matterbridge/matter/clusters';
+import { getVacuumProperty } from '../helper.js';
+import { debugStringify } from 'matterbridge/logger';
+import { getBatteryState, getBatteryStatus } from '../initialData/index.js';
+import { state_to_matter_operational_status, state_to_matter_state } from '../share/function.js';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+import { getRunningMode } from '../initialData/getSupportedRunModes.js';
+import { hasDockingStationError } from '../model/DockingStationStatus.js';
+import { triggerDssError } from './handleLocalMessage.js';
+export async function updateFromHomeData(homeData, platform) {
+    if (platform.robots.size === 0)
+        return;
+    const devices = homeData.devices.filter((d) => platform.robots.has(d.duid));
+    for (const device of devices) {
+        const robot = platform.robots.get(device.duid);
+        if (robot === undefined) {
+            platform.log.error(`Error5: Robot with DUID ${device.duid} not found`);
+            continue;
+        }
+        const deviceData = robot.device.data;
+        if (!device || deviceData === undefined) {
+            platform.log.error('Device not found in home data');
+            return;
+        }
+        device.schema = homeData.products.find((prd) => prd.id === device.productId || prd.model === device.data.model)?.schema ?? [];
+        platform.log.debug('updateFromHomeData-homeData:', debugStringify(homeData));
+        platform.log.debug('updateFromHomeData-device:', debugStringify(device));
+        platform.log.debug('updateFromHomeData-schema:' + debugStringify(device.schema));
+        platform.log.debug('updateFromHomeData-battery:' + debugStringify(device.deviceStatus));
+        const batteryLevel = getVacuumProperty(device, 'battery');
+        if (batteryLevel) {
+            robot.updateAttribute(PowerSource.Cluster.id, 'batPercentRemaining', batteryLevel ? batteryLevel * 2 : 200, platform.log);
+            robot.updateAttribute(PowerSource.Cluster.id, 'batChargeLevel', getBatteryStatus(batteryLevel), platform.log);
+        }
+        const state = getVacuumProperty(device, 'state');
+        const matterState = state_to_matter_state(state);
+        if (!state || !matterState) {
+            return;
+        }
+        platform.log.debug(`updateFromHomeData-RvcRunMode code: ${state} name: ${OperationStatusCode[state]}, matterState: ${RvcRunMode.ModeTag[matterState]}`);
+        if (matterState) {
+            robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(matterState), platform.log);
+        }
+        if (batteryLevel) {
+            robot.updateAttribute(PowerSource.Cluster.id, 'batChargeState', getBatteryState(state, batteryLevel), platform.log);
+        }
+        const operationalStateId = state_to_matter_operational_status(state);
+        if (operationalStateId) {
+            const dssHasError = hasDockingStationError(robot.dockStationStatus);
+            platform.log.debug(`dssHasError: ${dssHasError}, dockStationStatus: ${debugStringify(robot.dockStationStatus ?? {})}`);
+            if (!(dssHasError && triggerDssError(robot, platform))) {
+                platform.log.debug(`updateFromHomeData-OperationalState: ${RvcOperationalState.OperationalState[operationalStateId]}`);
+                robot.updateAttribute(RvcOperationalState.Cluster.id, 'operationalState', operationalStateId, platform.log);
+            }
+        }
+    }
+}