matterbridge-roborock-vacuum-plugin 1.1.0-rc14 → 1.1.0-rc16

package/.github/workflows/build.yml

@@ -1,6 +1,10 @@
 name: Build, lint and test
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
 
 jobs:
   publish:

package/.github/workflows/coverage.yml

@@ -1,6 +1,10 @@
 name: Analyze code coverage
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - main
+      - dev
 
 jobs:
   publish:

package/CHANGELOG.md

@@ -0,0 +1,62 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+---
+
+## [1.1.0-rc15] - 2025-07-26
+### Changed
+- Refactor codebase.
+- Correct LocalNetworkClient connecting process.
+- Update and fix unit tests.
+- Various lint fixes.
+
+## [1.1.0-rc14] - 2025-07-26
+### Added
+- Initialize sync device status via MQTT.
+
+## [1.1.0-rc13] - 2025-07-25
+### Added
+- More unit tests.
+- Increased unit test coverage.
+
+### Fixed
+- Several bugs related to socket connection issues.
+- Improve reconnect logic and cleaning status reporting.
+
+## [1.1.0-rc11] - 2025-07-22
+### Fixed
+- Unable to get room from `get_room_mapping`.
+- Can not get room from `get_multi_maps_list`.
+
+## [1.1.0-rc10] - 2025-07-22
+### Fixed
+- Stop retrying to connect socket when exceeding retry count.
+- Lint and unit test updates.
+
+## [1.1.0-rc09] - 2025-07-20
+### Fixed
+- Do not re-connect MQTT unnecessarily.
+- Reconnect when socket or MQTT is unexpectedly disconnected.
+
+### Enhanced
+- Save user data for subsequent logins.
+- Unit test improvements.
+
+## [1.1.0-rc07] - 2025-07-17
+### Changed
+- Enable server mode fixes.
+- Improved error logging when plugin can't connect to device.
+
+## [1.1.0-rc06] - 2025-07-16
+### Fixed
+- Can not start plugin when server mode is disabled.
+
+## [1.1.0-rc04] - 2025-07-16
+### Added
+- Unit tests.
+- GitHub Actions improvements.
+
+---
+
+**Note:** This changelog includes only the most recent 30 commits. For the full commit history, view more on [GitHub](https://github.com/RinDevJunior/matterbridge-roborock-vacuum-plugin/commits?sort=updated&direction=desc).

package/dist/helper.js

@@ -1,3 +1,5 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
 export function getVacuumProperty(device, property) {
     if (device) {
         const schemas = device.schema;
@@ -14,3 +16,63 @@ export function getVacuumProperty(device, property) {
 export function isSupportedDevice(model) {
     return model.startsWith('roborock.vacuum.');
 }
+export function isStatusUpdate(result) {
+    return (Array.isArray(result) &&
+        result.length > 0 &&
+        typeof result[0] === 'object' &&
+        result[0] !== null &&
+        'msg_ver' in result[0] &&
+        result[0].msg_ver !== undefined &&
+        result[0].msg_ver !== null);
+}
+export async function getRoomMap(duid, platform) {
+    const robot = platform.robots.get(duid);
+    if (robot === undefined) {
+        platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+        return undefined;
+    }
+    if (platform.roborockService === undefined)
+        return undefined;
+    const rooms = robot.device.rooms ?? [];
+    if (robot.roomInfo === undefined) {
+        const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+            return robot.roomInfo;
+        }
+    }
+    if (robot.roomInfo === undefined) {
+        const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+        if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+            platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.allRooms)}`);
+            const roomDataMap = mapInfo.allRooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
+            robot.roomInfo = new RoomMap(roomDataMap, rooms);
+        }
+    }
+    return robot.roomInfo;
+}
+export async function getRoomMapFromDevice(device, platform) {
+    const rooms = device?.rooms ?? [];
+    platform.log.notice('-------------------------------------------0--------------------------------------------------------');
+    platform.log.notice(`getRoomMapFromDevice - device.rooms: ${debugStringify(rooms)}`);
+    if (device && platform.roborockService) {
+        const roomData = await platform.roborockService.getRoomMappings(device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+            const roomMap = new RoomMap(roomData ?? [], rooms);
+            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+            platform.log.notice('-------------------------------------------1--------------------------------------------------------');
+            return roomMap;
+        }
+        const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+        platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+        if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+            const roomDataMap = mapInfo.allRooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
+            const roomMap = new RoomMap(roomDataMap, rooms);
+            platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+            platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+            return roomMap;
+        }
+    }
+    return new RoomMap([], rooms);
+}

package/dist/initialData/getSupportedAreas.js

@@ -3,11 +3,13 @@ import { randomInt } from 'node:crypto';
 export function getSupportedAreas(vacuumRooms, roomMap, log) {
     log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
     log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
-    if (!vacuumRooms || vacuumRooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
-        if (!vacuumRooms || vacuumRooms.length === 0) {
+    const noVacuumRooms = !vacuumRooms || vacuumRooms.length === 0;
+    const noRoomMap = !roomMap?.rooms || roomMap.rooms.length === 0;
+    if (noVacuumRooms || noRoomMap) {
+        if (noVacuumRooms) {
             log?.error('No rooms found');
         }
-        if (!roomMap || !roomMap.rooms || roomMap.rooms.length == 0) {
+        if (noRoomMap) {
             log?.error('No room map found');
         }
         return [
@@ -26,12 +28,13 @@ export function getSupportedAreas(vacuumRooms, roomMap, log) {
         ];
     }
     const supportedAreas = roomMap.rooms.map((room) => {
+        const locationName = room.displayName ?? vacuumRooms.find((r) => r.id === room.globalId || r.id === room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`;
         return {
             areaId: room.id,
             mapId: null,
             areaInfo: {
                 locationInfo: {
-                    locationName: room.displayName ?? vacuumRooms.find((r) => r.id == room.globalId || r.id == room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
+                    locationName,
                     floorNumber: null,
                     areaType: null,
                 },
@@ -41,8 +44,8 @@ export function getSupportedAreas(vacuumRooms, roomMap, log) {
     });
     log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
     const duplicated = findDuplicatedAreaIds(supportedAreas, log);
-    return duplicated
-        ? [
+    if (duplicated) {
+        return [
             {
                 areaId: 2,
                 mapId: null,
@@ -55,8 +58,9 @@ export function getSupportedAreas(vacuumRooms, roomMap, log) {
                     landmarkInfo: null,
                 },
             },
-        ]
-        : supportedAreas;
+        ];
+    }
+    return supportedAreas;
 }
 function findDuplicatedAreaIds(areas, log) {
     const seen = new Set();

package/dist/model/RoomMap.js

@@ -1,12 +1,13 @@
-export default class RoomMap {
-    rooms = [];
+export class RoomMap {
+    rooms;
     constructor(roomData, rooms) {
-        this.rooms = roomData.map((entry) => {
+        this.rooms = roomData.map(([id, globalId, altId]) => {
+            const room = rooms.find((r) => Number(r.id) === Number(globalId) || Number(r.id) === Number(id));
             return {
-                id: entry[0],
-                globalId: Number(entry[1]),
-                displayName: rooms.find((r) => Number(r.id) == Number(entry[1]))?.name,
-                alternativeId: `${entry[0]}${entry[2]}`,
+                id,
+                globalId: globalId !== undefined ? Number(globalId) : undefined,
+                displayName: room?.name,
+                alternativeId: `${id}${altId}`,
             };
         });
     }

package/dist/platform.js

@@ -4,7 +4,7 @@ import { debugStringify } from 'matterbridge/logger';
 import RoborockService from './roborockService.js';
 import { PLUGIN_NAME } from './settings.js';
 import ClientManager from './clientManager.js';
-import { isSupportedDevice } from './helper.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
 import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
@@ -159,10 +159,10 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
             this.log.notice(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
             const map_info = await this.roborockService.getMapInformation(vacuum.duid);
-            const rooms = map_info?.maps?.[0]?.rooms ?? [];
-            vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }));
+            const rooms = map_info?.allRooms ?? [];
+            vacuum.rooms = rooms.map((room) => ({ id: room.globalId, name: room.displayName }));
         }
-        const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+        const roomMap = await getRoomMapFromDevice(vacuum, this);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
         const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.cleanModeSettings, this.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false, this.log);
         const supportedAreas = getSupportedAreas(vacuum.rooms, roomMap, this.log);

package/dist/platformRunner.js

@@ -1,12 +1,12 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getVacuumProperty } from './helper.js';
+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 RoomMap from './model/RoomMap.js';
-import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
+import { getBatteryState, getBatteryStatus, getOperationalErrorState, getSupportedAreas } 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';
@@ -32,59 +32,6 @@ export class PlatformRunner {
         const homeData = await platform.roborockService.getHomeDataForUpdating(platform.rrHomeId);
         await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
     }
-    async getRoomMapFromDevice(device) {
-        const platform = this.platform;
-        const rooms = device?.rooms ?? [];
-        platform.log.notice('-------------------------------------------0--------------------------------------------------------');
-        platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
-        if (device && platform.roborockService) {
-            const roomData = await platform.roborockService.getRoomMappings(device.duid);
-            if (roomData !== undefined && roomData.length > 0) {
-                platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-                const roomMap = new RoomMap(roomData ?? [], rooms);
-                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-                platform.log.notice('-------------------------------------------1--------------------------------------------------------');
-                return roomMap;
-            }
-            const mapInfo = await platform.roborockService.getMapInformation(device.duid);
-            platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
-            if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
-                const roomMap = new RoomMap(roomDataMap, rooms);
-                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-                platform.log.notice('-------------------------------------------2--------------------------------------------------------');
-                return roomMap;
-            }
-        }
-        return new RoomMap([], rooms);
-    }
-    async getRoomMap(duid) {
-        const platform = this.platform;
-        const robot = platform.robots.get(duid);
-        if (robot === undefined) {
-            platform.log.error(`Error6: Robot with DUID ${duid} not found`);
-            return undefined;
-        }
-        if (platform.roborockService === undefined)
-            return undefined;
-        const rooms = robot.device.rooms ?? [];
-        if (robot.roomInfo === undefined) {
-            const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-            if (roomData !== undefined && roomData.length > 0) {
-                robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-                return robot.roomInfo;
-            }
-        }
-        if (robot.roomInfo === undefined) {
-            const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
-            if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-                platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
-                robot.roomInfo = new RoomMap(roomDataMap, rooms);
-            }
-        }
-        return robot.roomInfo;
-    }
     async updateFromMQTTMessage(messageSource, messageData, duid = '', tracked = false) {
         const platform = this.platform;
         duid = duid || messageData?.duid || '';
@@ -146,7 +93,7 @@ export class PlatformRunner {
                     }
                     else {
                         const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-                        const roomMap = await this.getRoomMap(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;
@@ -237,7 +184,7 @@ export class PlatformRunner {
                 }
                 case Protocol.rpc_response: {
                     const response = data.dps[messageType];
-                    if (!self.isStatusUpdate(response.result)) {
+                    if (!isStatusUpdate(response.result)) {
                         platform.log.debug('Ignore message:', debugStringify(data));
                         return;
                     }
@@ -271,7 +218,25 @@ export class PlatformRunner {
                     });
                     break;
                 }
-                case Protocol.additional_props:
+                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) {
+                        platform.log.notice('------------------------ get roomData ----------------------------');
+                        const roomMap = await getRoomMapFromDevice(robot.device, platform);
+                        platform.log.notice('------------------------ Room map updated ------------------------');
+                        const supportedAreas = getSupportedAreas(robot.device.rooms, roomMap, 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);
+                    }
+                    break;
+                }
                 case Protocol.back_type: {
                     break;
                 }
@@ -309,15 +274,6 @@ export class PlatformRunner {
         }
         return undefined;
     }
-    isStatusUpdate(result) {
-        return (Array.isArray(result) &&
-            result.length > 0 &&
-            typeof result[0] === 'object' &&
-            result[0] !== null &&
-            'msg_ver' in result[0] &&
-            result[0].msg_ver !== undefined &&
-            result[0].msg_ver !== null);
-    }
     updateFromHomeData(homeData) {
         const platform = this.platform;
         if (platform.robots.size === 0)

package/dist/roborockCommunication/Zenum/additionalPropCode.js

@@ -0,0 +1,4 @@
+export var AdditionalPropCode;
+(function (AdditionalPropCode) {
+    AdditionalPropCode[AdditionalPropCode["map_change"] = 4] = "map_change";
+})(AdditionalPropCode || (AdditionalPropCode = {}));

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -1,28 +1,30 @@
 import decodeComponent from '../helper/nameDecoder.js';
 export class MapInfo {
     maps = [];
+    allRooms = [];
     constructor(multimap) {
-        multimap.map_info.forEach((map) => {
-            this.maps.push({
-                id: map.mapFlag,
-                name: decodeComponent(map.name)?.toLowerCase(),
-                rooms: map.rooms && map.rooms.length > 0
-                    ? map.rooms.map((room) => {
-                        return {
-                            id: room.id,
-                            iot_name_id: room.iot_name_id,
-                            tag: room.tag,
-                            displayName: room.iot_name,
-                        };
-                    })
-                    : [],
-            });
+        this.maps = multimap.map_info.map((mapInfo) => {
+            const rooms = mapInfo.rooms.map((room) => ({
+                id: room.id,
+                globalId: parseInt(room.iot_name_id),
+                iot_name_id: room.iot_name_id,
+                tag: room.tag,
+                displayName: room.iot_name,
+                mapId: mapInfo.mapFlag,
+            }));
+            this.allRooms.push(...rooms);
+            return {
+                id: mapInfo.mapFlag,
+                name: decodeComponent(mapInfo.name),
+                rooms,
+            };
         });
+        this.allRooms = this.allRooms.filter((room, index, self) => index === self.findIndex((r) => r.globalId === room.globalId));
     }
     getById(id) {
         return this.maps.find((m) => m.id === id)?.name;
     }
     getByName(name) {
-        return this.maps.find((m) => m.name === name.toLowerCase())?.id;
+        return this.maps.find((m) => m.name?.toLowerCase() === name.toLowerCase())?.id;
     }
 }

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

@@ -61,10 +61,10 @@ export class LocalNetworkClient extends AbstractClient {
     async onConnect() {
         this.logger.debug(` [LocalNetworkClient]: ${this.duid} connected to ${this.ip}`);
         this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
-        await this.sendHelloMessage();
-        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         this.connected = true;
         this.retryCount = 0;
+        await this.sendHelloMessage();
+        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         await this.connectionListeners.onConnected(this.duid);
     }
     async onDisconnect(hadError) {

package/dist/roborockCommunication/broadcast/listener/implementation/syncMessageListener.js

@@ -18,10 +18,6 @@ export class SyncMessageListener {
             const dps = message.get(Protocol.rpc_response);
             const messageId = dps.id;
             const responseHandler = this.pending.get(messageId);
-            const result = dps.result;
-            if (result && result.length == 1 && result[0] == 'ok') {
-                return;
-            }
             if (responseHandler) {
                 responseHandler(dps.result);
             }

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -1,5 +1,4 @@
 import { debugStringify } from 'matterbridge/logger';
-import { RoomInfo } from '../Zmodel/roomInfo.js';
 import { SimpleMessageListener } from './listener/index.js';
 import { RequestMessage } from './model/requestMessage.js';
 import { DeviceStatus } from '../Zmodel/deviceStatus.js';
@@ -40,9 +39,9 @@ export class MessageProcessor {
         }
         return undefined;
     }
-    async getRooms(duid, rooms) {
+    async getRooms(duid) {
         const request = new RequestMessage({ method: 'get_room_mapping' });
-        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
+        return this.client.get(duid, request);
     }
     async gotoDock(duid) {
         const request = new RequestMessage({ method: 'app_charge' });
@@ -80,7 +79,7 @@ export class MessageProcessor {
     }
     async findMyRobot(duid) {
         const request = new RequestMessage({ method: 'find_me' });
-        return this.client.send(duid, request);
+        return this.client.get(duid, request);
     }
     async getCleanModeData(duid) {
         const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_mop_mode' }));

package/dist/roborockCommunication/index.js

@@ -8,4 +8,5 @@ export { ClientRouter } from './broadcast/clientRouter.js';
 export { DeviceStatus } from './Zmodel/deviceStatus.js';
 export { ResponseMessage } from './broadcast/model/responseMessage.js';
 export { MapInfo } from './Zmodel/mapInfo.js';
+export { AdditionalPropCode } from './Zenum/additionalPropCode.js';
 export { Scene } from './Zmodel/scene.js';

package/dist/roborockService.js

@@ -351,7 +351,7 @@ export default class RoborockService {
         assert(this.iotApi !== undefined);
         return this.iotApi.startScene(sceneId);
     }
-    getRoomMappings(duid) {
+    async getRoomMappings(duid) {
         if (!this.messageClient) {
             this.logger.warn('messageClient not initialized. Waititing for next execution');
             return Promise.resolve(undefined);

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc14",
+  "version": "1.1.0-rc16",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,

package/matterbridge-roborock-vacuum-plugin.schema.json

@@ -1,6 +1,6 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc14 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc16 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc14",
+  "version": "1.1.0-rc16",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/helper.ts

@@ -1,4 +1,8 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
+import { RoborockMatterbridgePlatform } from './platform.js';
 import { Device } from './roborockCommunication/index.js';
+import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
 
 export function getVacuumProperty(device: Device, property: string): number | undefined {
   if (device) {
@@ -20,3 +24,81 @@ export function getVacuumProperty(device: Device, property: string): number | un
 export function isSupportedDevice(model: string): boolean {
   return model.startsWith('roborock.vacuum.');
 }
+
+export function isStatusUpdate(result: unknown): boolean {
+  return (
+    Array.isArray(result) &&
+    result.length > 0 &&
+    typeof result[0] === 'object' &&
+    result[0] !== null &&
+    'msg_ver' in result[0] &&
+    (result[0] as CloudMessageResult).msg_ver !== undefined &&
+    (result[0] as CloudMessageResult).msg_ver !== null
+  );
+}
+
+export async function getRoomMap(duid: string, platform: RoborockMatterbridgePlatform): Promise<RoomMap | undefined> {
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+    return undefined;
+  }
+
+  if (platform.roborockService === undefined) return undefined;
+
+  const rooms = robot.device.rooms ?? [];
+  if (robot.roomInfo === undefined) {
+    const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+      return robot.roomInfo;
+    }
+  }
+
+  if (robot.roomInfo === undefined) {
+    const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+    if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+      platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.allRooms)}`);
+
+      const roomDataMap = mapInfo.allRooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
+      robot.roomInfo = new RoomMap(roomDataMap, rooms);
+    }
+  }
+
+  return robot.roomInfo;
+}
+
+export async function getRoomMapFromDevice(device: Device, platform: RoborockMatterbridgePlatform): Promise<RoomMap> {
+  const rooms = device?.rooms ?? [];
+
+  platform.log.notice('-------------------------------------------0--------------------------------------------------------');
+  platform.log.notice(`getRoomMapFromDevice - device.rooms: ${debugStringify(rooms)}`);
+
+  if (device && platform.roborockService) {
+    const roomData = await platform.roborockService.getRoomMappings(device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+
+      const roomMap = new RoomMap(roomData ?? [], rooms);
+
+      platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+      platform.log.notice('-------------------------------------------1--------------------------------------------------------');
+      return roomMap;
+    }
+
+    const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+    platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+
+    if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+      const roomDataMap = mapInfo.allRooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
+
+      const roomMap = new RoomMap(roomDataMap, rooms);
+
+      platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+      platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+      return roomMap;
+    }
+  }
+
+  return new RoomMap([], rooms);
+}