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

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/roborockCommunication/broadcast/abstractClient.js

@@ -11,9 +11,9 @@ export class AbstractClient {
     messageListeners = new ChainedMessageListener();
     serializer;
     deserializer;
+    context;
     connected = false;
     logger;
-    context;
     syncMessageListener;
     constructor(logger, context) {
         this.context = context;
@@ -40,8 +40,8 @@ export class AbstractClient {
             return undefined;
         });
     }
-    registerDevice(duid, localKey, pv) {
-        this.context.registerDevice(duid, localKey, pv);
+    registerDevice(duid, localKey, pv, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
     }
     registerConnectionListener(listener) {
         this.connectionListeners.register(listener);

package/dist/roborockCommunication/broadcast/client/LocalNetworkClient.js

@@ -148,6 +148,7 @@ export class LocalNetworkClient extends AbstractClient {
         const request = new RequestMessage({
             protocol: Protocol.hello_request,
             messageId: this.messageIdSeq.next(),
+            nonce: this.context.nonce,
         });
         await this.send(this.duid, request);
     }

package/dist/roborockCommunication/broadcast/client/LocalNetworkUDPClient.js

@@ -1,5 +1,5 @@
 import * as dgram from 'node:dgram';
-import { Parser } from 'binary-parser';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
 import { AbstractClient } from '../abstractClient.js';

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -17,8 +17,11 @@ export class ClientRouter {
         this.mqttClient.registerConnectionListener(this.connectionListeners);
         this.mqttClient.registerMessageListener(this.messageListeners);
     }
-    registerDevice(duid, localKey, pv) {
-        this.context.registerDevice(duid, localKey, pv);
+    registerDevice(duid, localKey, pv, nonce) {
+        this.context.registerDevice(duid, localKey, pv, nonce);
+    }
+    updateNonce(duid, nonce) {
+        this.context.updateNonce(duid, nonce);
     }
     registerClient(duid, ip) {
         const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);

package/dist/roborockCommunication/broadcast/model/contentMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/headerMessage.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/model/messageContext.js

@@ -1,18 +1,26 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomInt } from 'node:crypto';
 import * as CryptoUtils from '../../helper/cryptoHelper.js';
 export class MessageContext {
     endpoint;
-    nonce;
     devices = new Map();
+    nonce;
+    serializeNonce;
     constructor(userdata) {
         this.endpoint = CryptoUtils.md5bin(userdata.rriot.k).subarray(8, 14).toString('base64');
-        this.nonce = randomBytes(16);
+        this.nonce = randomInt(1000, 1000000);
+        this.serializeNonce = randomBytes(16);
     }
-    registerDevice(duid, localKey, pv) {
-        this.devices.set(duid, { localKey: localKey, protocolVersion: pv });
+    registerDevice(duid, localKey, pv, nonce) {
+        this.devices.set(duid, { localKey: localKey, protocolVersion: pv, nonce });
     }
-    getNonceAsHex() {
-        return this.nonce.toString('hex').toUpperCase();
+    updateNonce(duid, nonce) {
+        const device = this.devices.get(duid);
+        if (device) {
+            device.nonce = nonce;
+        }
+    }
+    getSerializeNonceAsHex() {
+        return this.serializeNonce.toString('hex').toUpperCase();
     }
     getLocalKey(duid) {
         return this.devices.get(duid)?.localKey;
@@ -20,6 +28,9 @@ export class MessageContext {
     getProtocolVersion(duid) {
         return this.devices.get(duid)?.protocolVersion;
     }
+    getDeviceNonce(duid) {
+        return this.devices.get(duid)?.nonce;
+    }
     getEndpoint() {
         return this.endpoint;
     }

package/dist/roborockCommunication/broadcast/model/requestMessage.js

@@ -6,12 +6,16 @@ export class RequestMessage {
     method;
     params;
     secure;
+    timestamp;
+    nonce;
     constructor(args) {
         this.messageId = args.messageId ?? randomInt(10000, 32767);
         this.protocol = args.protocol ?? Protocol.rpc_request;
         this.method = args.method;
         this.params = args.params;
         this.secure = args.secure ?? false;
+        this.nonce = args.nonce ?? randomInt(10000, 32767);
+        this.timestamp = args.timestamp ?? Math.floor(Date.now() / 1000);
     }
     toMqttRequest() {
         return this;
@@ -24,6 +28,7 @@ export class RequestMessage {
                 method: this.method,
                 params: this.params,
                 secure: this.secure,
+                timestamp: this.timestamp,
             });
         }
         else {

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -1,26 +1,29 @@
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
-import { Parser } from 'binary-parser';
 import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import * as CryptoUtils from './cryptoHelper.js';
 import { Protocol } from '../broadcast/model/protocol.js';
+import { Parser } from 'binary-parser/dist/binary_parser.js';
 export class MessageDeserializer {
     context;
-    messageParser;
+    headerMessageParser;
+    contentMessageParser;
     logger;
     supportedVersions = ['1.0', 'A01', 'B01'];
     constructor(context, logger) {
         this.context = context;
         this.logger = logger;
-        this.messageParser = new Parser()
+        this.headerMessageParser = new Parser()
             .endianness('big')
             .string('version', {
             length: 3,
         })
             .uint32('seq')
-            .uint32('random')
+            .uint32('nonce')
             .uint32('timestamp')
-            .uint16('protocol')
+            .uint16('protocol');
+        this.contentMessageParser = new Parser()
+            .endianness('big')
             .uint16('payloadLen')
             .buffer('payload', {
             length: 'payloadLen',
@@ -28,10 +31,21 @@ export class MessageDeserializer {
             .uint32('crc32');
     }
     deserialize(duid, message) {
-        const version = message.toString('latin1', 0, 3);
-        if (!this.supportedVersions.includes(version)) {
-            throw new Error('unknown protocol version ' + version);
+        const header = this.headerMessageParser.parse(message);
+        if (!this.supportedVersions.includes(header.version)) {
+            throw new Error('unknown protocol version ' + header.version);
+        }
+        if (header.protocol === Protocol.hello_response || header.protocol === Protocol.ping_response) {
+            const dpsValue = {
+                id: header.seq,
+                result: {
+                    version: header.version,
+                    nonce: header.nonce,
+                },
+            };
+            return new ResponseMessage(duid, { [header.protocol.toString()]: dpsValue });
         }
+        const data = this.contentMessageParser.parse(message.subarray(this.headerMessageParser.sizeOf()));
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
         const expectedCrc32 = message.readUInt32BE(message.length - 4);
         if (crc32 != expectedCrc32) {
@@ -42,30 +56,29 @@ export class MessageDeserializer {
             this.logger.notice(`Unable to retrieve local key for ${duid}, it should be from other vacuums`);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
-        const data = this.messageParser.parse(message);
-        if (version == '1.0') {
-            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(data.timestamp) + localKey + CryptoUtils.SALT);
+        if (header.version == '1.0') {
+            const aesKey = CryptoUtils.md5bin(CryptoUtils.encodeTimestamp(header.timestamp) + localKey + CryptoUtils.SALT);
             const decipher = crypto.createDecipheriv('aes-128-ecb', aesKey, null);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        else if (version == 'A01') {
-            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
+        else if (header.version == 'A01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        else if (version == 'B01') {
-            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+        else if (header.version == 'B01') {
+            const iv = CryptoUtils.md5hex(header.nonce.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
-        if (data.protocol == Protocol.map_response) {
+        if (header.protocol == Protocol.map_response) {
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
-        if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
+        if (header.protocol == Protocol.rpc_response || header.protocol == Protocol.general_request) {
             return this.deserializeRpcResponse(duid, data);
         }
         else {
-            this.logger.error('unknown protocol: ' + data.protocol);
+            this.logger.error('unknown protocol: ' + header.protocol);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
     }