matterbridge-roborock-vacuum-plugin 1.1.0-rc15 → 1.1.0-rc17

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

@@ -27,6 +27,7 @@ export function isStatusUpdate(result) {
 }
 export async function getRoomMap(duid, platform) {
     const robot = platform.robots.get(duid);
+    const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature.enableMultipleMap) ?? false;
     if (robot === undefined) {
         platform.log.error(`Error6: Robot with DUID ${duid} not found`);
         return undefined;
@@ -35,44 +36,46 @@ export async function getRoomMap(duid, platform) {
         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;
+        const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+        if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+            platform.log.info(`getRoomMap - mapInfo: ${debugStringify(mapInfo.allRooms)}`);
+            robot.roomInfo = new RoomMap(mapInfo.allRooms, rooms, mapInfo.maps, enableMultipleMap);
         }
     }
     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);
+        const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            const roomDataMap = roomData.map((r) => ({ id: r[0], iot_name_id: String(r[1]), globalId: r[1], tag: r[2], mapId: 0, displayName: undefined }));
+            robot.roomInfo = new RoomMap(roomDataMap, rooms, [], enableMultipleMap);
+            return robot.roomInfo;
         }
     }
     return robot.roomInfo;
 }
 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: ${debugStringify(rooms)}`);
+    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'}`);
+        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);
         if (roomData !== undefined && roomData.length > 0) {
             platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-            const roomMap = new RoomMap(roomData ?? [], rooms);
+            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;
         }
-        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);
+    return new RoomMap([], rooms, [], enableMultipleMap);
 }

package/dist/initialData/getSupportedAreas.js

@@ -1,77 +1,120 @@
 import { debugStringify } from 'matterbridge/logger';
 import { randomInt } from 'node:crypto';
-export function getSupportedAreas(vacuumRooms, roomMap, log) {
+import { RoomIndexMap } from '../model/roomIndexMap.js';
+export function getSupportedAreas(vacuumRooms, roomMap, enableMultipleMap = false, 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 [
-            {
-                areaId: 1,
-                mapId: null,
-                areaInfo: {
-                    locationInfo: {
-                        locationName: 'Unknown',
-                        floorNumber: null,
-                        areaType: null,
+        return {
+            supportedAreas: [
+                {
+                    areaId: 1,
+                    mapId: null,
+                    areaInfo: {
+                        locationInfo: {
+                            locationName: 'Unknown',
+                            floorNumber: null,
+                            areaType: null,
+                        },
+                        landmarkInfo: null,
                     },
-                    landmarkInfo: null,
                 },
-            },
-        ];
+            ],
+            supportedMaps: [],
+            roomIndexMap: new RoomIndexMap(new Map([[1, { roomId: 1, mapId: null }]])),
+        };
     }
-    const supportedAreas = roomMap.rooms.map((room) => {
+    const { supportedAreas, indexMap } = processValidData(enableMultipleMap, vacuumRooms, roomMap);
+    const duplicated = findDuplicatedAreaIds(supportedAreas, log);
+    if (duplicated) {
         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)}`,
-                    floorNumber: null,
-                    areaType: null,
+            supportedAreas: [
+                {
+                    areaId: 2,
+                    mapId: null,
+                    areaInfo: {
+                        locationInfo: {
+                            locationName: 'Unknown - Duplicated Areas Found',
+                            floorNumber: null,
+                            areaType: null,
+                        },
+                        landmarkInfo: null,
+                    },
                 },
-                landmarkInfo: null,
-            },
+            ],
+            supportedMaps: [],
+            roomIndexMap: new RoomIndexMap(new Map([[2, { roomId: 2, mapId: null }]])),
         };
-    });
+    }
+    const supportedMaps = getSupportedMaps(enableMultipleMap, supportedAreas, roomMap);
     log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
-    const duplicated = findDuplicatedAreaIds(supportedAreas, log);
-    return duplicated
-        ? [
-            {
-                areaId: 2,
-                mapId: null,
-                areaInfo: {
-                    locationInfo: {
-                        locationName: 'Unknown',
-                        floorNumber: null,
-                        areaType: null,
-                    },
-                    landmarkInfo: null,
-                },
-            },
-        ]
-        : supportedAreas;
+    log?.debug('getSupportedAreas - supportedMaps', debugStringify(supportedMaps));
+    const roomIndexMap = new RoomIndexMap(indexMap);
+    return {
+        supportedAreas,
+        supportedMaps,
+        roomIndexMap,
+    };
 }
 function findDuplicatedAreaIds(areas, log) {
     const seen = new Set();
     const duplicates = [];
     for (const area of areas) {
-        if (seen.has(area.areaId)) {
-            duplicates.push(area.areaId);
+        const key = `${area.areaId}=${area.mapId}`;
+        if (seen.has(key)) {
+            duplicates.push({ areaId: area.areaId, mapId: area.mapId ?? 0 });
         }
         else {
-            seen.add(area.areaId);
+            seen.add(key);
         }
     }
     if (duplicates.length > 0 && log) {
-        const duplicated = areas.filter((x) => duplicates.includes(x.areaId));
+        const duplicated = areas.filter(({ areaId, mapId }) => duplicates.some((y) => y.areaId === areaId && y.mapId === (mapId ?? 0)));
         log.error(`Duplicated areaId(s) found: ${debugStringify(duplicated)}`);
     }
     return duplicates.length > 0;
 }
+function processValidData(enableMultipleMap, vacuumRooms, roomMap) {
+    const indexMap = new Map();
+    const supportedAreas = roomMap?.rooms !== undefined && roomMap.rooms.length > 0
+        ? roomMap.rooms.map((room, index) => {
+            const locationName = room.displayName ?? vacuumRooms.find((r) => r.id === room.globalId || r.id === room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`;
+            const areaId = index + 100;
+            const mapId = enableMultipleMap ? (room.mapId ?? null) : null;
+            indexMap.set(areaId, { roomId: room.id, mapId: room.mapId ?? null });
+            return {
+                areaId: areaId,
+                mapId: mapId,
+                areaInfo: {
+                    locationInfo: {
+                        locationName: locationName,
+                        floorNumber: room.mapId ?? null,
+                        areaType: null,
+                    },
+                    landmarkInfo: null,
+                },
+            };
+        })
+        : [];
+    return {
+        supportedAreas,
+        indexMap,
+    };
+}
+function getSupportedMaps(enableMultipleMap, supportedAreas, roomMap) {
+    if (enableMultipleMap) {
+        return (roomMap?.mapInfo?.map((map) => ({
+            mapId: map.id,
+            name: map.name ?? `Map ${map.id}`,
+        })) ?? []);
+    }
+    return [];
+}

package/dist/model/ExperimentalFeatureSetting.js

@@ -8,6 +8,7 @@ export function createDefaultExperimentalFeatureSetting() {
             useVacationModeToSendVacuumToDock: false,
             enableServerMode: false,
             alwaysExecuteAuthentication: false,
+            enableMultipleMap: false,
         },
         cleanModeSettings: {
             enableCleanModeMapping: false,

package/dist/model/RoomMap.js

@@ -1,13 +1,19 @@
 export class RoomMap {
-    rooms = [];
-    constructor(roomData, rooms) {
-        this.rooms = roomData.map((entry) => {
+    rooms;
+    mapInfo;
+    constructor(roomData, rooms, mapInfo, enableMultipleMap) {
+        const mapid = mapInfo[0]?.id ?? 0;
+        const roomDataTmp = enableMultipleMap ? roomData : roomData.filter((room) => room.mapId === undefined || room.mapId === mapid);
+        this.rooms = roomDataTmp.map(({ id, globalId, tag, mapId }) => {
+            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}${tag}`,
+                mapId,
             };
         });
+        this.mapInfo = mapInfo;
     }
 }

package/dist/model/roomIndexMap.js

@@ -0,0 +1,17 @@
+export class RoomIndexMap {
+    indexMap;
+    roomMap;
+    constructor(roomMap) {
+        this.indexMap = roomMap;
+        this.roomMap = new Map();
+        for (const [areaId, { roomId }] of roomMap.entries()) {
+            this.roomMap.set(roomId, areaId);
+        }
+    }
+    getAreaId(roomId) {
+        return this.roomMap.get(roomId);
+    }
+    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.7')) {
-            throw new Error(`This plugin requires Matterbridge version >= "3.1.7". 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.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.`);
         }
         this.log.info('Initializing platform:', this.config.name);
         if (config.whiteList === undefined)
@@ -159,14 +159,16 @@ 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 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);
+        const enableMultipleMap = this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.enableMultipleMap;
+        const { supportedAreas, roomIndexMap } = getSupportedAreas(vacuum.rooms, roomMap, enableMultipleMap, this.log);
         this.roborockService.setSupportedAreas(vacuum.duid, supportedAreas);
+        this.roborockService.setSupportedAreaIndexMap(vacuum.duid, roomIndexMap);
         let routineAsRoom = [];
         if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.showRoutinesAsRoom) {
             routineAsRoom = getSupportedScenes(vacuum.scenes, this.log);

package/dist/platformRunner.js

@@ -1,11 +1,12 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getRoomMap, getVacuumProperty, isStatusUpdate } 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 { 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';
@@ -92,6 +93,7 @@ export class PlatformRunner {
                     }
                     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;
@@ -101,7 +103,8 @@ export class PlatformRunner {
                         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'}`);
-                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', segment_id, platform.log);
+                            const areaId = roomIndexMap?.getAreaId(segment_id) ?? null;
+                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log);
                         }
                         if (segment_id == -1) {
                             const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == target_segment_id);
@@ -110,7 +113,8 @@ export class PlatformRunner {
                             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'}`);
-                                robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', target_segment_id, platform.log);
+                                const areaId = roomIndexMap?.getAreaId(target_segment_id) ?? null;
+                                robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', areaId, platform.log);
                             }
                         }
                         if (target_segment_id == -1 && segment_id == -1) {
@@ -217,7 +221,30 @@ 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]}`);
+                    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;
                 }

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,29 @@
 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,
+            };
         });
     }
     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/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' });

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

@@ -22,6 +22,7 @@ export default class RoborockService {
     supportedAreas = new Map();
     supportedRoutines = new Map();
     selectedAreas = new Map();
+    supportedAreaIndexMaps = new Map();
     vacuumNeedAPIV3 = ['roborock.vacuum.ss07'];
     constructor(authenticateApiSupplier = (logger) => new RoborockAuthenticateApi(logger), iotApiSupplier = (logger, ud) => new RoborockIoTApi(ud, logger), refreshInterval, clientManager, logger) {
         this.logger = logger;
@@ -52,7 +53,9 @@ export default class RoborockService {
     }
     setSelectedAreas(duid, selectedAreas) {
         this.logger.debug('RoborockService - setSelectedAreas', selectedAreas);
-        this.selectedAreas.set(duid, selectedAreas);
+        const roomIds = selectedAreas.map((areaId) => this.supportedAreaIndexMaps.get(duid)?.getRoomId(areaId)) ?? [];
+        this.logger.debug('RoborockService - setSelectedAreas - roomIds', roomIds);
+        this.selectedAreas.set(duid, roomIds.filter((id) => id !== undefined).map((id) => id));
     }
     getSelectedAreas(duid) {
         return this.selectedAreas.get(duid) ?? [];
@@ -60,12 +63,18 @@ export default class RoborockService {
     setSupportedAreas(duid, supportedAreas) {
         this.supportedAreas.set(duid, supportedAreas);
     }
+    setSupportedAreaIndexMap(duid, indexMap) {
+        this.supportedAreaIndexMaps.set(duid, indexMap);
+    }
     setSupportedScenes(duid, routineAsRooms) {
         this.supportedRoutines.set(duid, routineAsRooms);
     }
     getSupportedAreas(duid) {
         return this.supportedAreas.get(duid);
     }
+    getSupportedAreasIndexMap(duid) {
+        return this.supportedAreaIndexMaps.get(duid);
+    }
     async getCleanModeData(duid) {
         this.logger.notice('RoborockService - getCleanModeData');
         const data = await this.getMessageProcessor(duid)?.getCleanModeData(duid);
@@ -351,7 +360,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/dist/rvc.js

@@ -9,14 +9,17 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
     constructor(username, device, roomMap, routineAsRoom, enableExperimentalFeature, log) {
         const cleanModes = getSupportedCleanModes(device.data.model, enableExperimentalFeature);
         const supportedRunModes = getSupportedRunModes();
-        const supportedAreas = [...getSupportedAreas(device.rooms, roomMap, log), ...routineAsRoom];
+        const enableMultipleMap = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableMultipleMap;
+        const { supportedAreas, supportedMaps } = getSupportedAreas(device.rooms, roomMap, enableMultipleMap, log);
+        const supportedAreaAndRoutines = [...supportedAreas, ...routineAsRoom];
         const deviceName = `${device.name}-${device.duid}`.replace(/\s+/g, '');
         log.debug(`Creating RoborockVacuumCleaner for device: ${deviceName}, model: ${device.data.model}, forceRunAtDefault: ${enableExperimentalFeature?.advancedFeature?.forceRunAtDefault}`);
         log.debug(`Supported Clean Modes: ${JSON.stringify(cleanModes)}`);
         log.debug(`Supported Run Modes: ${JSON.stringify(supportedRunModes)}`);
         log.debug(`Supported Areas: ${JSON.stringify(supportedAreas)}`);
+        log.debug(`Supported Maps: ${JSON.stringify(supportedMaps)}`);
         const bridgeMode = enableExperimentalFeature?.enableExperimentalFeature && enableExperimentalFeature?.advancedFeature?.enableServerMode ? 'server' : undefined;
-        super(deviceName, device.duid, bridgeMode, supportedRunModes[0].mode, supportedRunModes, cleanModes[0].mode, cleanModes, undefined, undefined, RvcOperationalState.OperationalState.Docked, getOperationalStates(), supportedAreas, undefined, supportedAreas[0].areaId);
+        super(deviceName, device.duid, bridgeMode, supportedRunModes[0].mode, supportedRunModes, cleanModes[0].mode, cleanModes, undefined, undefined, RvcOperationalState.OperationalState.Docked, getOperationalStates(), supportedAreaAndRoutines, undefined, supportedAreas[0].areaId, supportedMaps);
         this.username = username;
         this.device = device;
     }