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

package/src/initialData/getSupportedAreas.ts

@@ -1,6 +1,6 @@
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { ServiceArea } from 'matterbridge/matter/clusters';
-import RoomMap from '../model/RoomMap.js';
+import { RoomMap } from '../model/RoomMap.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 import { randomInt } from 'node:crypto';
 
@@ -8,15 +8,16 @@ export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefi
   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,
@@ -34,12 +35,14 @@ export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefi
   }
 
   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: room.displayName ?? vacuumRooms.find((r) => r.id == room.globalId || r.id == room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
+          locationName,
           floorNumber: null,
           areaType: null,
         },
@@ -52,27 +55,30 @@ export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefi
 
   const duplicated = findDuplicatedAreaIds(supportedAreas, log);
 
-  return duplicated
-    ? [
-        {
-          areaId: 2,
-          mapId: null,
-          areaInfo: {
-            locationInfo: {
-              locationName: 'Unknown',
-              floorNumber: null,
-              areaType: null,
-            },
-            landmarkInfo: null,
+  if (duplicated) {
+    return [
+      {
+        areaId: 2,
+        mapId: null,
+        areaInfo: {
+          locationInfo: {
+            locationName: 'Unknown',
+            floorNumber: null,
+            areaType: null,
           },
+          landmarkInfo: null,
         },
-      ]
-    : supportedAreas;
+      },
+    ];
+  }
+
+  return supportedAreas;
 }
 
 function findDuplicatedAreaIds(areas: ServiceArea.Area[], log?: AnsiLogger): boolean {
   const seen = new Set<number>();
   const duplicates: number[] = [];
+
   for (const area of areas) {
     if (seen.has(area.areaId)) {
       duplicates.push(area.areaId);
@@ -80,9 +86,11 @@ function findDuplicatedAreaIds(areas: ServiceArea.Area[], log?: AnsiLogger): boo
       seen.add(area.areaId);
     }
   }
+
   if (duplicates.length > 0 && log) {
     const duplicated = areas.filter((x) => duplicates.includes(x.areaId));
     log.error(`Duplicated areaId(s) found: ${debugStringify(duplicated)}`);
   }
+
   return duplicates.length > 0;
 }

package/src/model/RoomMap.ts

@@ -17,30 +17,34 @@ roomMap = {
 
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 
-export default class RoomMap {
-  readonly rooms: {
-    id: number;
-    globalId: number | undefined;
-    displayName: string | undefined;
-    alternativeId: string;
-  }[] = [];
+export interface RoomMapEntry {
+  id: number;
+  globalId: number | undefined;
+  displayName?: string;
+  alternativeId: string;
+}
+
+export class RoomMap {
+  readonly rooms: RoomMapEntry[];
 
   constructor(roomData: number[][], rooms: Room[]) {
-    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}`,
       };
     });
   }
 
+  // Optionally, add utility methods for clarity
   // getGlobalId(id: number): number | undefined {
-  //   return this.rooms.find((r) => Number(r.id) == Number(id))?.globalId;
+  //   return this.rooms.find((r) => r.id === id)?.globalId;
   // }
 
   // getRoomId(globalId: number): number | undefined {
-  //   return this.rooms.find((r) => Number(r.globalId) == Number(globalId))?.id;
+  //   return this.rooms.find((r) => r.globalId === globalId)?.id;
   // }
 }

package/src/platform.ts

@@ -4,7 +4,7 @@ import { AnsiLogger, debugStringify, LogLevel } 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';
@@ -227,11 +227,11 @@ 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 }) as Room);
+      const rooms = map_info?.allRooms ?? [];
+      vacuum.rooms = rooms.map((room) => ({ id: room.globalId, name: room.displayName }) as Room);
     }
 
-    const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+    const roomMap = await getRoomMapFromDevice(vacuum, this);
 
     this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
 

package/src/platformRunner.ts

@@ -1,18 +1,17 @@
 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 { CloudMessageModel } from './model/CloudMessageModel.js';
 import { RoborockMatterbridgePlatform } from './platform.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 { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
 import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
 import { DpsPayload } from './roborockCommunication/broadcast/model/dps.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { hasDockingStationError, parseDockingStationStatus } from './model/DockingStationStatus.js';
-import { BatteryMessage, Device, DeviceErrorMessage, DeviceStatusNotify, Home } from './roborockCommunication/index.js';
+import { AdditionalPropCode, BatteryMessage, Device, DeviceErrorMessage, DeviceStatusNotify, Home } from './roborockCommunication/index.js';
 import { OperationStatusCode } from './roborockCommunication/Zenum/operationStatusCode.js';
 import { getCurrentCleanModeFunc } from './share/runtimeHelper.js';
 import { debugStringify } from 'matterbridge/logger';
@@ -41,76 +40,6 @@ export class PlatformRunner {
     await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
   }
 
-  public async getRoomMapFromDevice(device: Device): Promise<RoomMap> {
-    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] 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);
-  }
-
-  private async getRoomMap(duid: string): Promise<RoomMap | undefined> {
-    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 (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
-    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] as [number, number, number]);
-        robot.roomInfo = new RoomMap(roomDataMap, rooms);
-      }
-    }
-
-    return robot.roomInfo;
-  }
-
   private async updateFromMQTTMessage(messageSource: NotifyMessageTypes, messageData: unknown, duid = '', tracked = false): Promise<void> {
     const platform = this.platform;
     duid = duid || (messageData as DeviceStatusNotify)?.duid || '';
@@ -191,7 +120,7 @@ export class PlatformRunner {
             robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
           } else {
             const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-            const roomMap = await this.getRoomMap(duid);
+            const roomMap = await getRoomMap(duid, this.platform);
 
             // Get current room from segment_id
             const segment_id = data.cleaning_info?.segment_id ?? -1;
@@ -311,7 +240,7 @@ export class PlatformRunner {
         case Protocol.rpc_response: {
           const response = data.dps[messageType] as DpsPayload;
           // ignore network info
-          if (!self.isStatusUpdate(response.result)) {
+          if (!isStatusUpdate(response.result)) {
             platform.log.debug('Ignore message:', debugStringify(data));
             return;
           }
@@ -351,7 +280,30 @@ export class PlatformRunner {
           });
           break; // Do nothing, handled in local message
         }
-        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] as number;
+          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: {
           // TODO: check if this is needed
           break;
@@ -398,18 +350,6 @@ export class PlatformRunner {
     return undefined;
   }
 
-  private 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
-    );
-  }
-
   private updateFromHomeData(homeData: Home): void {
     const platform = this.platform;
 

package/src/roborockCommunication/Zenum/additionalPropCode.ts

@@ -0,0 +1,3 @@
+export enum AdditionalPropCode {
+  map_change = 4,
+}

package/src/roborockCommunication/Zmodel/map.ts

@@ -1,4 +1,4 @@
-export interface Map {
+export interface MapInformation {
   mapFlag: number;
   add_time: number;
   length: number;

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -2,27 +2,45 @@ import decodeComponent from '../helper/nameDecoder.js';
 import { RoomInformation } from './map.js';
 import type { MultipleMap } from './multipleMap.js';
 
+export interface MapRoom {
+  id: number;
+  iot_name_id: string;
+  tag: number;
+  globalId?: number;
+  displayName: string;
+  mapId?: number;
+}
+
+export interface MapEntry {
+  id: number;
+  name: string | undefined;
+  rooms: MapRoom[];
+}
+
 export class MapInfo {
-  readonly maps: { id: number; name: string | undefined; rooms: { id: number; iot_name_id: string; tag: number; displayName: string }[] }[] = [];
+  public readonly maps: MapEntry[] = [];
+  public readonly allRooms: MapRoom[] = [];
 
   constructor(multimap: MultipleMap) {
-    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: RoomInformation) => {
-                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: 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 {
+        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: number): string | undefined {
@@ -30,6 +48,6 @@ export class MapInfo {
   }
 
   getByName(name: string): number | undefined {
-    return this.maps.find((m) => m.name === name.toLowerCase())?.id;
+    return this.maps.find((m) => m.name?.toLowerCase() === name.toLowerCase())?.id;
   }
 }

package/src/roborockCommunication/Zmodel/multipleMap.ts

@@ -1,8 +1,8 @@
-import { Map } from './map.js';
+import { MapInformation } from './map.js';
 
 export interface MultipleMap {
   max_multi_map: number;
   max_bak_map: number;
   multi_map_count: number;
-  map_info: Map[];
+  map_info: MapInformation[];
 }

package/src/roborockCommunication/broadcast/client/LocalNetworkClient.ts

@@ -80,12 +80,11 @@ export class LocalNetworkClient extends AbstractClient {
   private async onConnect(): Promise<void> {
     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}`);
+    this.connected = true;
+    this.retryCount = 0;
 
     await this.sendHelloMessage();
     this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
-
-    this.connected = true;
-    this.retryCount = 0;
     await this.connectionListeners.onConnected(this.duid);
   }
 

package/src/roborockCommunication/broadcast/listener/implementation/syncMessageListener.ts

@@ -28,10 +28,10 @@ export class SyncMessageListener implements AbstractMessageListener {
       const messageId = dps.id;
 
       const responseHandler = this.pending.get(messageId);
-      const result = dps.result as Record<string, unknown>;
-      if (result && result.length == 1 && result[0] == 'ok') {
-        return;
-      }
+      // const result = dps.result as Record<string, unknown>;
+      // if (result && result.length == 1 && result[0] == 'ok') {
+      //   return;
+      // }
 
       if (responseHandler) {
         responseHandler(dps.result as ResponseMessage);

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -1,11 +1,9 @@
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { CloudMessageResult } from '../Zmodel/messageResult.js';
-import { RoomInfo } from '../Zmodel/roomInfo.js';
 import { AbstractMessageHandler } from './listener/abstractMessageHandler.js';
 import { SimpleMessageListener } from './listener/index.js';
 import { RequestMessage } from './model/requestMessage.js';
 import { DeviceStatus } from '../Zmodel/deviceStatus.js';
-import { Room } from '../Zmodel/room.js';
 import { Client } from './client.js';
 import { NetworkInfo } from '../Zmodel/networkInfo.js';
 
@@ -58,9 +56,9 @@ export class MessageProcessor {
     return undefined;
   }
 
-  public async getRooms(duid: string, rooms: Room[]): Promise<RoomInfo> {
+  public async getRooms(duid: string): Promise<number[][] | undefined> {
     const request = new RequestMessage({ method: 'get_room_mapping' });
-    return this.client.get<number[][] | undefined>(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
+    return this.client.get<number[][] | undefined>(duid, request); // .then((response) => new RoomInfo(rooms, response ?? []));
   }
 
   public async gotoDock(duid: string): Promise<void> {
@@ -105,9 +103,9 @@ export class MessageProcessor {
     return this.client.get(duid, def);
   }
 
-  public async findMyRobot(duid: string): Promise<void> {
+  public async findMyRobot(duid: string): Promise<unknown> {
     const request = new RequestMessage({ method: 'find_me' });
-    return this.client.send(duid, request);
+    return this.client.get(duid, request);
   }
 
   public async getCleanModeData(duid: string): Promise<{ suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> {

package/src/roborockCommunication/index.ts

@@ -8,6 +8,7 @@ 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/src/roborockService.ts

@@ -375,6 +375,7 @@ export default class RoborockService {
         },
       };
     }) as Device[];
+
     return result;
   }
 
@@ -444,12 +445,14 @@ export default class RoborockService {
     return this.iotApi.startScene(sceneId);
   }
 
-  public getRoomMappings(duid: string): Promise<number[][] | undefined> {
+  public async getRoomMappings(duid: string): Promise<number[][] | undefined> {
     if (!this.messageClient) {
       this.logger.warn('messageClient not initialized. Waititing for next execution');
       return Promise.resolve(undefined);
     }
     return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping', secure: this.isRequestSecure(duid) }));
+
+    // return await this.getMessageProcessor(duid)?.getRooms(duid);
   }
 
   public async initializeMessageClient(username: string, device: Device, userdata: UserData): Promise<void> {

package/src/rvc.ts

@@ -1,5 +1,5 @@
 import { RoboticVacuumCleaner } from 'matterbridge/devices';
-import RoomMap from './model/RoomMap.js';
+import { RoomMap } from './model/RoomMap.js';
 import { Device } from './roborockCommunication/index.js';
 import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
 import { AnsiLogger } from 'matterbridge/logger';

package/src/tests/helper.test.ts

@@ -0,0 +1,113 @@
+import { getRoomMapFromDevice } from '../helper';
+import { RoomMap } from '../model/RoomMap';
+
+// Mocks
+// const mockLog = {
+//   notice: (message: string, ...arg: unknown[]) => console.log('NOTICE:', message, ...arg),
+//   error: (message: string, ...arg: unknown[]) => console.error('ERROR:', message, ...arg),
+//   debug: (message: string, ...arg: unknown[]) => console.debug('DEBUG:', message, ...arg),
+//   info: (message: string, ...arg: unknown[]) => console.info('INFO:', message, ...arg),
+//   warn: (message: string, ...arg: unknown[]) => console.warn('WARN:', message, ...arg),
+//   verbose: (message: string, ...arg: unknown[]) => console.log('VERBOSE:', message, ...arg),
+// };
+
+const mockLog = {
+  notice: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  verbose: jest.fn(),
+};
+
+const mockRoborockService = {
+  getRoomMappings: jest.fn(),
+  getMapInformation: jest.fn(),
+};
+
+const mockPlatform = {
+  log: mockLog,
+  roborockService: mockRoborockService,
+};
+
+describe('getRoomMapFromDevice', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  //   it('returns RoomMap from getRoomMappings if available', async () => {
+  //     const device = {
+  //       duid: '123',
+  //       rooms: [
+  //         {
+  //           'id': 12461114,
+  //           'name': 'Guest bedroom',
+  //         },
+  //         {
+  //           'id': 12461111,
+  //           'name': 'Balcony',
+  //         },
+  //         {
+  //           'id': 12461109,
+  //           'name': 'Master bedroom',
+  //         },
+  //         {
+  //           'id': 11100849,
+  //           'name': 'Study',
+  //         },
+  //         {
+  //           'id': 11100847,
+  //           'name': 'Bedroom',
+  //         },
+  //         {
+  //           'id': 11100845,
+  //           'name': 'Kitchen',
+  //         },
+  //         {
+  //           'id': 11100842,
+  //           'name': 'Living room',
+  //         },
+  //       ],
+  //     };
+  //     mockRoborockService.getRoomMappings.mockResolvedValue([
+  //       [1, '11100842', 6],
+  //       [2, '12461114', 3],
+  //       [3, '12461109', 2],
+  //       [4, '12461111', 7],
+  //     ]);
+  //     mockRoborockService.getMapInformation.mockResolvedValue(undefined);
+
+  //     const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+
+  //     //console.log('Result:', result);
+  //     expect(result).toBeInstanceOf(RoomMap);
+  //     expect(mockRoborockService.getRoomMappings).toHaveBeenCalledWith('123');
+  //     expect(result.rooms.length).toBeGreaterThan(0);
+  //   });
+
+  it('returns RoomMap from getRoomMappings if available', async () => {
+    const device = {
+      duid: '123',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+    mockRoborockService.getRoomMappings.mockResolvedValue([
+      [1, '11100845', 14],
+      [2, '11100849', 9],
+      [3, '11100842', 6],
+      [4, '11100847', 1],
+    ]);
+    mockRoborockService.getMapInformation.mockResolvedValue(undefined);
+
+    const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+
+    // console.log('Result:', result);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(mockRoborockService.getRoomMappings).toHaveBeenCalledWith('123');
+    expect(result.rooms.length).toBeGreaterThan(0);
+  });
+});