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

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.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);
+        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 - 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);
+            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 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;
+        }
     }
-    return new RoomMap([], rooms);
+    return new RoomMap([], rooms, [], enableMultipleMap);
 }

package/dist/initialData/getSupportedAreas.js

@@ -1,6 +1,7 @@
 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');
     const noVacuumRooms = !vacuumRooms || vacuumRooms.length === 0;
@@ -12,70 +13,108 @@ export function getSupportedAreas(vacuumRooms, roomMap, log) {
         if (noRoomMap) {
             log?.error('No room map found');
         }
-        return [
-            {
-                areaId: 1,
-                mapId: null,
-                areaInfo: {
-                    locationInfo: {
-                        locationName: 'Unknown',
-                        floorNumber: null,
-                        areaType: null,
-                    },
-                    landmarkInfo: null,
-                },
-            },
-        ];
-    }
-    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,
-                    floorNumber: null,
-                    areaType: null,
+            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 }]])),
         };
-    });
-    log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
+    }
+    const { supportedAreas, indexMap } = processValidData(enableMultipleMap, vacuumRooms, roomMap);
     const duplicated = findDuplicatedAreaIds(supportedAreas, log);
     if (duplicated) {
-        return [
-            {
-                areaId: 2,
-                mapId: null,
-                areaInfo: {
-                    locationInfo: {
-                        locationName: 'Unknown',
-                        floorNumber: null,
-                        areaType: null,
+        return {
+            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 }]])),
+        };
     }
-    return supportedAreas;
+    const supportedMaps = getSupportedMaps(enableMultipleMap, supportedAreas, roomMap);
+    log?.debug('getSupportedAreas - supportedAreas', debugStringify(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 = enableMultipleMap ? index + 100 : room.id;
+            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,14 +1,19 @@
 export class RoomMap {
     rooms;
-    constructor(roomData, rooms) {
-        this.rooms = roomData.map(([id, globalId, altId]) => {
+    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,
                 globalId: globalId !== undefined ? Number(globalId) : undefined,
                 displayName: room?.name,
-                alternativeId: `${id}${altId}`,
+                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)
@@ -165,8 +165,10 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         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

@@ -93,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;
@@ -102,7 +103,9 @@ 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) ?? 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);
@@ -111,7 +114,9 @@ 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) ?? 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) {
@@ -222,11 +227,12 @@ export class PlatformRunner {
                     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 = getSupportedAreas(robot.device.rooms, roomMap, platform.log);
+                        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);
@@ -234,6 +240,10 @@ export class PlatformRunner {
                         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;
                 }

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -4,14 +4,14 @@ export class MapInfo {
     allRooms = [];
     constructor(multimap) {
         this.maps = multimap.map_info.map((mapInfo) => {
-            const rooms = mapInfo.rooms.map((room) => ({
+            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,
@@ -19,7 +19,6 @@ export class MapInfo {
                 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;

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);

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;
     }

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

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc16",
+  "version": "1.1.0-rc18",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,
@@ -13,7 +13,8 @@
       "forceRunAtDefault": false,
       "useVacationModeToSendVacuumToDock": false,
       "enableServerMode": false,
-      "alwaysExecuteAuthentication": false
+      "alwaysExecuteAuthentication": false,
+      "enableMultipleMap": false
     },
     "cleanModeSettings": {
       "enableCleanModeMapping": false,
@@ -37,4 +38,4 @@
   "debug": true,
   "unregisterOnShutdown": false,
   "enableExperimentalFeature": false
-}
+}

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

@@ -1,8 +1,11 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc16 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc18 by https://github.com/RinDevJunior",
   "type": "object",
-  "required": ["username", "password"],
+  "required": [
+    "username",
+    "password"
+  ],
   "properties": {
     "name": {
       "description": "Plugin name",
@@ -57,7 +60,9 @@
                 "const": true
               }
             },
-            "required": ["enableExperimentalFeature"]
+            "required": [
+              "enableExperimentalFeature"
+            ]
           },
           "then": {
             "properties": {
@@ -94,6 +99,11 @@
                     "description": "Always execute authentication on startup.",
                     "type": "boolean",
                     "default": false
+                  },
+                  "enableMultipleMap": {
+                    "description": "Enable multiple maps support.",
+                    "type": "boolean",
+                    "default": false
                   }
                 }
               },
@@ -114,7 +124,9 @@
                           "const": true
                         }
                       },
-                      "required": ["enableCleanModeMapping"]
+                      "required": [
+                        "enableCleanModeMapping"
+                      ]
                     },
                     "then": {
                       "properties": {
@@ -159,7 +171,9 @@
                                     "default": 25
                                   }
                                 },
-                                "required": ["distanceOff"]
+                                "required": [
+                                  "distanceOff"
+                                ]
                               }
                             }
                           ]
@@ -196,7 +210,9 @@
                                     "default": 25
                                   }
                                 },
-                                "required": ["distanceOff"]
+                                "required": [
+                                  "distanceOff"
+                                ]
                               }
                             }
                           ]
@@ -226,20 +242,36 @@
     "fanMode": {
       "type": "string",
       "description": "Suction power mode to use (e.g., 'Quiet', 'Balanced', 'Turbo', 'Max', 'MaxPlus').",
-      "enum": ["Quiet", "Balanced", "Turbo", "Max", "MaxPlus"],
+      "enum": [
+        "Quiet",
+        "Balanced",
+        "Turbo",
+        "Max",
+        "MaxPlus"
+      ],
       "default": "Balanced"
     },
     "waterFlowMode": {
       "type": "string",
       "description": "Water flow mode to use (e.g., 'Low', 'Medium', 'High', 'CustomizeWithDistanceOff').",
-      "enum": ["Low", "Medium", "High", "CustomizeWithDistanceOff"],
+      "enum": [
+        "Low",
+        "Medium",
+        "High",
+        "CustomizeWithDistanceOff"
+      ],
       "default": "Medium"
     },
     "mopRouteMode": {
       "type": "string",
       "description": "Mop route intensity to use (e.g., 'Standard', 'Deep', 'DeepPlus', 'Fast').",
-      "enum": ["Standard", "Deep", "DeepPlus", "Fast"],
+      "enum": [
+        "Standard",
+        "Deep",
+        "DeepPlus",
+        "Fast"
+      ],
       "default": "Standard"
     }
   }
-}
+}

package/package.json

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