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

package/src/helper.ts

@@ -3,6 +3,7 @@ import { RoomMap } from './model/RoomMap.js';
 import { RoborockMatterbridgePlatform } from './platform.js';
 import { Device } from './roborockCommunication/index.js';
 import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
+import { MapRoom } from './roborockCommunication/Zmodel/mapInfo.js';
 
 export function getVacuumProperty(device: Device, property: string): number | undefined {
   if (device) {
@@ -39,6 +40,7 @@ export function isStatusUpdate(result: unknown): boolean {
 
 export async function getRoomMap(duid: string, platform: RoborockMatterbridgePlatform): Promise<RoomMap | undefined> {
   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;
@@ -47,21 +49,21 @@ export async function getRoomMap(duid: string, platform: RoborockMatterbridgePla
   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)}`);
+      platform.log.info(`getRoomMap - mapInfo: ${debugStringify(mapInfo.allRooms)}`);
+      robot.roomInfo = new RoomMap(mapInfo.allRooms, rooms, mapInfo.maps, enableMultipleMap);
+    }
+  }
 
-      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);
+  if (robot.roomInfo === undefined) {
+    const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      const roomDataMap: MapRoom[] = 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;
     }
   }
 
@@ -70,35 +72,36 @@ export async function getRoomMap(duid: string, platform: RoborockMatterbridgePla
 
 export async function getRoomMapFromDevice(device: Device, platform: RoborockMatterbridgePlatform): Promise<RoomMap> {
   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] as [number, number, number]);
+      const roomDataMap = mapInfo.allRooms; // .map((r) => [r.id, parseInt(r.iot_name_id), r.tag, r.mapId] as [number, number, number, number]);
 
-      const roomMap = new RoomMap(roomDataMap, rooms);
+      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: MapRoom[] = 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/src/initialData/getSupportedAreas.ts

@@ -3,8 +3,14 @@ import { ServiceArea } from 'matterbridge/matter/clusters';
 import { RoomMap } from '../model/RoomMap.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 import { randomInt } from 'node:crypto';
+import { RoomIndexMap } from '../model/roomIndexMap.js';
 
-export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefined, log?: AnsiLogger): ServiceArea.Area[] {
+export function getSupportedAreas(
+  vacuumRooms: Room[],
+  roomMap: RoomMap | undefined,
+  enableMultipleMap = false,
+  log?: AnsiLogger,
+): { supportedAreas: ServiceArea.Area[]; supportedMaps: ServiceArea.Map[]; roomIndexMap: RoomIndexMap } {
   log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
   log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
 
@@ -18,79 +24,135 @@ export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefi
     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: ServiceArea.Area[] = 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: ServiceArea.Area[], log?: AnsiLogger): boolean {
-  const seen = new Set<number>();
-  const duplicates: number[] = [];
+  const seen = new Set<string>();
+  const duplicates: { areaId: number; mapId: number }[] = [];
 
   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: boolean,
+  vacuumRooms: Room[],
+  roomMap?: RoomMap,
+): { supportedAreas: ServiceArea.Area[]; indexMap: Map<number, { roomId: number; mapId: number | null }> } {
+  const indexMap = new Map<number, { roomId: number; mapId: number | null }>();
+  const supportedAreas: ServiceArea.Area[] =
+    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, // `${locationName} - (${areaId})  - (${room.id}) - (${room.globalId})`,
+                floorNumber: room.mapId ?? null,
+                areaType: null,
+              },
+              landmarkInfo: null,
+            },
+          };
+        })
+      : [];
+
+  return {
+    supportedAreas,
+    indexMap,
+  };
+}
+
+function getSupportedMaps(enableMultipleMap: boolean, supportedAreas: ServiceArea.Area[], roomMap?: RoomMap): ServiceArea.Map[] {
+  if (enableMultipleMap) {
+    return (
+      roomMap?.mapInfo?.map((map) => ({
+        mapId: map.id,
+        name: map.name ?? `Map ${map.id}`,
+      })) ?? []
+    );
+  }
+
+  return [];
+
+  // return supportedAreas.map((area) => ({
+  //   mapId: area.mapId ?? 0,
+  //   name: `Map ${area.mapId ?? 0}`,
+  // }));
+}

package/src/model/ExperimentalFeatureSetting.ts

@@ -7,6 +7,7 @@ export interface ExperimentalFeatureSetting {
     useVacationModeToSendVacuumToDock: boolean;
     enableServerMode: boolean;
     alwaysExecuteAuthentication: boolean;
+    enableMultipleMap: boolean;
   };
   cleanModeSettings: CleanModeSettings;
 }
@@ -40,6 +41,7 @@ export function createDefaultExperimentalFeatureSetting(): ExperimentalFeatureSe
       useVacationModeToSendVacuumToDock: false,
       enableServerMode: false,
       alwaysExecuteAuthentication: false,
+      enableMultipleMap: false,
     },
     cleanModeSettings: {
       enableCleanModeMapping: false,

package/src/model/RoomMap.ts

@@ -15,6 +15,7 @@ roomMap = {
 };
 */
 
+import { MapRoom } from '../roborockCommunication/Zmodel/mapInfo.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 
 export interface RoomMapEntry {
@@ -22,21 +23,34 @@ export interface RoomMapEntry {
   globalId: number | undefined;
   displayName?: string;
   alternativeId: string;
+  mapId?: number;
+}
+
+export interface MapInfo {
+  id: number;
+  name: string | undefined;
 }
 
 export class RoomMap {
   readonly rooms: RoomMapEntry[];
+  readonly mapInfo?: MapInfo[];
 
-  constructor(roomData: number[][], rooms: Room[]) {
-    this.rooms = roomData.map(([id, globalId, altId]) => {
+  constructor(roomData: MapRoom[], rooms: Room[], mapInfo: MapInfo[], enableMultipleMap: boolean) {
+    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;
   }
 
   // Optionally, add utility methods for clarity

package/src/model/roomIndexMap.ts

@@ -0,0 +1,20 @@
+export class RoomIndexMap {
+  private indexMap: Map<number, { roomId: number; mapId: number | null }>;
+  private roomMap: Map<number, number>;
+
+  constructor(roomMap: Map<number, { roomId: number; mapId: number | null }>) {
+    this.indexMap = roomMap;
+    this.roomMap = new Map();
+    for (const [areaId, { roomId }] of roomMap.entries()) {
+      this.roomMap.set(roomId, areaId);
+    }
+  }
+
+  public getAreaId(roomId: number): number | undefined {
+    return this.roomMap.get(roomId);
+  }
+
+  public getRoomId(areaId: number): number | undefined {
+    return this.indexMap.get(areaId)?.roomId;
+  }
+}

package/src/platform.ts

@@ -33,9 +33,9 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     super(matterbridge, log, config);
 
     // Verify that Matterbridge is the correct version
-    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.7')) {
+    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.8')) {
       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.`,
+        `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);
@@ -244,8 +244,11 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       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: ServiceArea.Area[] = [];
     if (this.enableExperimentalFeature?.enableExperimentalFeature && this.enableExperimentalFeature.advancedFeature?.showRoutinesAsRoom) {

package/src/platformRunner.ts

@@ -120,6 +120,7 @@ export class PlatformRunner {
             robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
           } else {
             const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
+            const roomIndexMap = this.platform.roborockService?.getSupportedAreasIndexMap(duid);
             const roomMap = await getRoomMap(duid, this.platform);
 
             // Get current room from segment_id
@@ -135,7 +136,10 @@ export class PlatformRunner {
               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) {
@@ -148,7 +152,9 @@ export class PlatformRunner {
                 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);
               }
             }
 
@@ -284,6 +290,8 @@ export class PlatformRunner {
           platform.log.notice(`Received additional properties for robot ${duid}: ${debugStringify(data)}`);
           const propCode = data.dps[Protocol.additional_props] as number;
           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 ----------------------------');
@@ -291,7 +299,7 @@ export class PlatformRunner {
             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 ------------------');
@@ -301,6 +309,11 @@ 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/src/roborockCommunication/Zmodel/map.ts

@@ -3,7 +3,7 @@ export interface MapInformation {
   add_time: number;
   length: number;
   name: string;
-  rooms: RoomInformation[];
+  rooms?: RoomInformation[] | undefined;
   bak_maps: { mapFlag: number; add_time: number }[];
 }
 

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -7,7 +7,7 @@ export interface MapRoom {
   iot_name_id: string;
   tag: number;
   globalId?: number;
-  displayName: string;
+  displayName?: string;
   mapId?: number;
 }
 
@@ -23,14 +23,15 @@ export class MapInfo {
 
   constructor(multimap: MultipleMap) {
     this.maps = multimap.map_info.map((mapInfo) => {
-      const rooms: MapRoom[] = mapInfo.rooms.map((room: RoomInformation) => ({
-        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,
-      }));
+      const rooms: MapRoom[] =
+        mapInfo.rooms?.map((room: RoomInformation) => ({
+          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 {
@@ -40,7 +41,7 @@ export class MapInfo {
       };
     });
 
-    this.allRooms = this.allRooms.filter((room, index, self) => index === self.findIndex((r) => r.globalId === room.globalId));
+    // this.allRooms = this.allRooms.filter((room, index, self) => index === self.findIndex((r) => r.globalId === room.globalId));
   }
 
   getById(id: number): string | undefined {

package/src/roborockService.ts

@@ -24,6 +24,7 @@ import {
 import type { AbstractMessageHandler, AbstractMessageListener, BatteryMessage, DeviceErrorMessage, DeviceStatusNotify, MultipleMap } from './roborockCommunication/index.js';
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import { LocalNetworkClient } from './roborockCommunication/broadcast/client/LocalNetworkClient.js';
+import { RoomIndexMap } from './model/roomIndexMap.js';
 export type Factory<A, T> = (logger: AnsiLogger, arg: A) => T;
 
 export default class RoborockService {
@@ -48,6 +49,7 @@ export default class RoborockService {
   private supportedAreas = new Map<string, ServiceArea.Area[]>();
   private supportedRoutines = new Map<string, ServiceArea.Area[]>();
   private selectedAreas = new Map<string, number[]>();
+  private supportedAreaIndexMaps = new Map<string, RoomIndexMap>();
 
   private readonly vacuumNeedAPIV3 = ['roborock.vacuum.ss07'];
 
@@ -95,7 +97,12 @@ export default class RoborockService {
 
   public setSelectedAreas(duid: string, selectedAreas: number[]): void {
     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),
+    );
   }
 
   public getSelectedAreas(duid: string): number[] {
@@ -106,6 +113,10 @@ export default class RoborockService {
     this.supportedAreas.set(duid, supportedAreas);
   }
 
+  public setSupportedAreaIndexMap(duid: string, indexMap: RoomIndexMap): void {
+    this.supportedAreaIndexMaps.set(duid, indexMap);
+  }
+
   public setSupportedScenes(duid: string, routineAsRooms: ServiceArea.Area[]) {
     this.supportedRoutines.set(duid, routineAsRooms);
   }
@@ -114,6 +125,10 @@ export default class RoborockService {
     return this.supportedAreas.get(duid);
   }
 
+  public getSupportedAreasIndexMap(duid: string): RoomIndexMap | undefined {
+    return this.supportedAreaIndexMaps.get(duid);
+  }
+
   public async getCleanModeData(duid: string): Promise<{ suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> {
     this.logger.notice('RoborockService - getCleanModeData');
     const data = await this.getMessageProcessor(duid)?.getCleanModeData(duid);

package/src/rvc.ts

@@ -24,7 +24,10 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
   ) {
     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(
@@ -33,6 +36,7 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
     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(
@@ -47,9 +51,10 @@ export class RoborockVacuumCleaner extends RoboticVacuumCleaner {
       undefined, // phaseList
       RvcOperationalState.OperationalState.Docked, // operationalState
       getOperationalStates(), // operationalStateList
-      supportedAreas, // supportedAreas
+      supportedAreaAndRoutines, // supportedAreas
       undefined, // selectedAreas
       supportedAreas[0].areaId, // currentArea
+      supportedMaps, // supportedMaps
     );
 
     this.username = username;