matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/src/helper.ts

@@ -0,0 +1,97 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
+import { RoborockMatterbridgePlatform } from './platform.js';
+import { Device } from './roborockCommunication/index.js';
+import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
+import { MapRoom } from './roborockCommunication/Zmodel/mapInfo.js';
+
+export function getVacuumProperty(device: Device, property: string): number | undefined {
+  if (device) {
+    const schemas = device.schema;
+    const schema = schemas.find((sch) => sch.code == property);
+
+    if (schema && device.deviceStatus && device.deviceStatus[schema.id] != undefined) {
+      return Number(device.deviceStatus[schema.id]);
+    }
+
+    if (device.deviceStatus && device.deviceStatus[property] != undefined) {
+      return Number(device.deviceStatus[property]);
+    }
+  }
+
+  return undefined;
+}
+
+export function isSupportedDevice(model: string): boolean {
+  return model.startsWith('roborock.vacuum.');
+}
+
+export function isStatusUpdate(result: unknown): boolean {
+  return (
+    Array.isArray(result) &&
+    result.length > 0 &&
+    typeof result[0] === 'object' &&
+    result[0] !== null &&
+    'msg_ver' in result[0] &&
+    (result[0] as CloudMessageResult).msg_ver !== undefined &&
+    (result[0] as CloudMessageResult).msg_ver !== null
+  );
+}
+
+export async function getRoomMap(duid: string, platform: RoborockMatterbridgePlatform): Promise<RoomMap | undefined> {
+  const robot = platform.robots.get(duid);
+  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;
+  }
+
+  if (platform.roborockService === undefined) return undefined;
+
+  const rooms = robot.device.rooms ?? [];
+
+  if (robot.roomInfo === undefined) {
+    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 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;
+    }
+  }
+
+  return robot.roomInfo;
+}
+
+export async function getRoomMapFromDevice(device: Device, platform: RoborockMatterbridgePlatform): Promise<RoomMap> {
+  const rooms = device?.rooms ?? [];
+  const enableMultipleMap = (platform.enableExperimentalFeature?.enableExperimentalFeature && platform.enableExperimentalFeature?.advancedFeature.enableMultipleMap) ?? false;
+  if (device && platform.roborockService) {
+    const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+    platform.log.debug(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+    platform.log.debug(`getRoomMapFromDevice - rooms: ${debugStringify(rooms)}`);
+
+    if (mapInfo && mapInfo.allRooms && mapInfo.allRooms.length > 0) {
+      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, mapInfo.maps, enableMultipleMap);
+      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);
+      return roomMap;
+    }
+  }
+
+  return new RoomMap([], rooms, [], enableMultipleMap);
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import { Matterbridge, PlatformConfig } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+import { RoborockMatterbridgePlatform } from './platform.js';
+
+/**
+ * This is the standard interface for Matterbridge plugins.
+ * Each plugin should export a default function that follows this signature.
+ *
+ * @param {Matterbridge} matterbridge - The Matterbridge instance.
+ * @param {AnsiLogger} log - The logger instance.
+ * @param {PlatformConfig} config - The platform configuration.
+ * @returns {RoborockMatterbridgePlatform} The initialized platform.
+ */
+export default function initializePlugin(matterbridge: Matterbridge, log: AnsiLogger, config: PlatformConfig): RoborockMatterbridgePlatform {
+  return new RoborockMatterbridgePlatform(matterbridge, log, config);
+}

package/src/initialData/getBatteryStatus.ts

@@ -0,0 +1,26 @@
+import { PowerSource } from 'matterbridge/matter/clusters';
+import { OperationStatusCode } from '../roborockCommunication/Zenum/operationStatusCode.js';
+
+export function getBatteryStatus(batteryLevel?: number): PowerSource.BatChargeLevel {
+  if (batteryLevel === undefined) return PowerSource.BatChargeLevel.Ok;
+
+  if (batteryLevel >= 70) {
+    return PowerSource.BatChargeLevel.Ok;
+  } else if (batteryLevel >= 40) {
+    return PowerSource.BatChargeLevel.Warning;
+  } else {
+    return PowerSource.BatChargeLevel.Critical;
+  }
+}
+
+export function getBatteryState(deviceState: number, batRemaining: number): PowerSource.BatChargeState {
+  if (deviceState == OperationStatusCode.Charging) {
+    return batRemaining < 100 ? PowerSource.BatChargeState.IsCharging : PowerSource.BatChargeState.IsAtFullCharge;
+  }
+
+  if (deviceState == OperationStatusCode.ChargingError) {
+    return PowerSource.BatChargeState.IsNotCharging;
+  }
+
+  return PowerSource.BatChargeState.IsAtFullCharge;
+}

package/src/initialData/getOperationalStates.ts

@@ -0,0 +1,94 @@
+import { RvcOperationalState } from 'matterbridge/matter/clusters';
+import { getDefaultOperationalStates } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { VacuumErrorCode } from '../roborockCommunication/Zenum/vacuumAndDockErrorCode.js';
+import { DockingStationStatus, DockingStationStatusType, hasDockingStationError } from '../model/DockingStationStatus.js';
+
+export function getOperationalStates(): RvcOperationalState.OperationalStateStruct[] {
+  return getDefaultOperationalStates();
+}
+
+export function getOperationalErrorState(errorCode: VacuumErrorCode): RvcOperationalState.OperationalState | undefined {
+  switch (errorCode) {
+    case VacuumErrorCode.None:
+      return undefined;
+    default: {
+      return RvcOperationalState.OperationalState.Error;
+    }
+  }
+}
+
+export function getErrorFromErrorCode(errorCode: VacuumErrorCode): RvcOperationalState.ErrorStateStruct | undefined {
+  const operationalState = getOperationalErrorState(errorCode);
+  if (operationalState) {
+    return {
+      errorStateId: RvcOperationalState.ErrorState.NoError,
+      errorStateLabel: `${RvcOperationalState.ErrorState.NoError}`,
+      errorStateDetails: `Error code: ${errorCode}`,
+    };
+  }
+  return undefined;
+}
+
+export function getErrorFromDSS(status: DockingStationStatus): RvcOperationalState.ErrorStateStruct | undefined {
+  if (!status) {
+    return {
+      errorStateId: RvcOperationalState.ErrorState.NoError,
+      errorStateLabel: 'No Docking Station Status',
+      errorStateDetails: 'Docking station status is not available.',
+    };
+  }
+
+  const hasError = hasDockingStationError(status);
+
+  if (hasError) {
+    if (status.cleanFluidStatus === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.MopCleaningPadMissing,
+        errorStateLabel: 'Clean Fluid Error',
+        errorStateDetails: 'The clean fluid is not available or has an issue.',
+      };
+    }
+
+    if (status.waterBoxFilterStatus === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty,
+        errorStateLabel: 'Water Box Filter Error',
+        errorStateDetails: 'The water box filter is not available or has an issue.',
+      };
+    }
+
+    if (status.dustBagStatus === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.DustBinMissing,
+        errorStateLabel: 'Dust Bag Error',
+        errorStateDetails: 'The dust bag is not available or has an issue.',
+      };
+    }
+
+    if (status.dirtyWaterBoxStatus === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty, // TODO: Check if this is correct
+        errorStateLabel: 'Dirty Water Box Error',
+        errorStateDetails: 'The dirty water box is not available or has an issue.',
+      };
+    }
+
+    if (status.clearWaterBoxStatus === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.WaterTankEmpty,
+        errorStateLabel: 'Clear Water Box Error',
+        errorStateDetails: 'The clear water box is not available or has an issue.',
+      };
+    }
+
+    if (status.isUpdownWaterReady === DockingStationStatusType.Error) {
+      return {
+        errorStateId: RvcOperationalState.ErrorState.WaterTankMissing,
+        errorStateLabel: 'Updown Water Ready Error',
+        errorStateDetails: 'The updown water tank is not ready or has an issue.',
+      };
+    }
+  }
+
+  return undefined;
+}

package/src/initialData/getSupportedAreas.ts

@@ -0,0 +1,162 @@
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+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 interface SupportedAreasResult {
+  supportedAreas: ServiceArea.Area[];
+  supportedMaps: ServiceArea.Map[];
+  roomIndexMap: RoomIndexMap;
+}
+
+export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefined, enableMultipleMap = false, log?: AnsiLogger): SupportedAreasResult {
+  log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
+  log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
+
+  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 (noRoomMap) {
+      log?.error('No room map found');
+    }
+
+    return {
+      supportedAreas: [
+        {
+          areaId: 1,
+          mapId: null,
+          areaInfo: {
+            locationInfo: {
+              locationName: 'Unknown',
+              floorNumber: null,
+              areaType: null,
+            },
+            landmarkInfo: null,
+          },
+        },
+      ],
+      supportedMaps: [],
+      roomIndexMap: new RoomIndexMap(new Map([[1, { roomId: 1, mapId: null }]])),
+    };
+  }
+  const { supportedAreas, indexMap } = processValidData(enableMultipleMap, vacuumRooms, roomMap);
+  const duplicated = findDuplicatedAreaIds(supportedAreas, log);
+
+  if (duplicated) {
+    return {
+      supportedAreas: [
+        {
+          areaId: 2,
+          mapId: null,
+          areaInfo: {
+            locationInfo: {
+              locationName: 'Unknown - Duplicated Areas Found',
+              floorNumber: null,
+              areaType: 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));
+  log?.debug('getSupportedAreas - supportedMaps', debugStringify(supportedMaps));
+  const roomIndexMap = new RoomIndexMap(indexMap);
+  return {
+    supportedAreas,
+    supportedMaps,
+    roomIndexMap,
+  };
+}
+
+interface SupportedArea {
+  areaId: number;
+  mapId: number;
+}
+
+function findDuplicatedAreaIds(areas: ServiceArea.Area[], log?: AnsiLogger): boolean {
+  const seen = new Set<string>();
+  const duplicates: SupportedArea[] = [];
+
+  for (const area of areas) {
+    const key = `${area.areaId}=${area.mapId}`;
+    if (seen.has(key)) {
+      duplicates.push({ areaId: area.areaId, mapId: area.mapId ?? 0 });
+    } else {
+      seen.add(key);
+    }
+  }
+
+  if (duplicates.length > 0 && log) {
+    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;
+}
+
+export interface MapInfo {
+  roomId: number;
+  mapId: number | null;
+}
+
+interface ProcessedData {
+  supportedAreas: ServiceArea.Area[];
+  indexMap: Map<number, MapInfo>;
+}
+
+function processValidData(enableMultipleMap: boolean, vacuumRooms: Room[], roomMap?: RoomMap): ProcessedData {
+  const indexMap = new Map<number, MapInfo>();
+  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,
+                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 [];
+}

package/src/initialData/getSupportedCleanModes.ts

@@ -0,0 +1,22 @@
+import { RvcCleanMode } from 'matterbridge/matter/clusters';
+import { getSupportedCleanModesSmart } from '../behaviors/roborock.vacuum/smart/initalData.js';
+import { getDefaultSupportedCleanModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+import { ExperimentalFeatureSetting } from '../model/ExperimentalFeatureSetting.js';
+
+export function getSupportedCleanModes(model: string, enableExperimentalFeature: ExperimentalFeatureSetting | undefined): RvcCleanMode.ModeOption[] {
+  if (enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false) {
+    return getDefaultSupportedCleanModes(enableExperimentalFeature);
+  }
+
+  switch (model) {
+    case DeviceModel.QREVO_EDGE_5V1:
+      return getSupportedCleanModesSmart(enableExperimentalFeature);
+
+    case DeviceModel.S7_MAXV:
+    case DeviceModel.S8_PRO_ULTRA:
+    case DeviceModel.S6_PURE:
+    default:
+      return getDefaultSupportedCleanModes(enableExperimentalFeature);
+  }
+}

package/src/initialData/getSupportedRunModes.ts

@@ -0,0 +1,14 @@
+import { RvcRunMode } from 'matterbridge/matter/clusters';
+import { getDefaultSupportedRunModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+
+export function getRunningMode(modeTag: RvcRunMode.ModeTag | undefined): number | null {
+  if (!modeTag) return null;
+
+  const supportedMode = getDefaultSupportedRunModes();
+  const runningMode = supportedMode.find((s) => s.modeTags.some((mt) => mt.value === modeTag));
+  return runningMode?.mode ?? null;
+}
+
+export function getSupportedRunModes(): RvcRunMode.ModeOption[] {
+  return getDefaultSupportedRunModes();
+}

package/src/initialData/getSupportedScenes.ts

@@ -0,0 +1,32 @@
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { ServiceArea } from 'matterbridge/matter/clusters';
+import { Scene } from '../roborockCommunication/index.js';
+import { randomInt } from 'node:crypto';
+
+export function getSupportedScenes(scenes: Scene[], log?: AnsiLogger): ServiceArea.Area[] {
+  log?.debug('getSupportedScenes', debugStringify(scenes));
+
+  if (!scenes || scenes.length === 0) {
+    log?.error('No scenes found');
+    return [];
+  }
+
+  const supportedAreas: ServiceArea.Area[] = scenes
+    .filter((s) => s.enabled && s.id)
+    .map((scene) => {
+      return {
+        areaId: scene.id ?? 0 + randomInt(5000, 9000),
+        mapId: null,
+        areaInfo: {
+          locationInfo: {
+            locationName: `Scene: ${scene.name}`,
+            floorNumber: null,
+            areaType: null,
+          },
+          landmarkInfo: null,
+        },
+      };
+    });
+
+  return supportedAreas;
+}

package/src/initialData/index.ts

@@ -0,0 +1,6 @@
+export { getSupportedRunModes } from './getSupportedRunModes.js';
+export { getOperationalStates, getOperationalErrorState } from './getOperationalStates.js';
+export { getSupportedCleanModes } from './getSupportedCleanModes.js';
+export { getSupportedAreas } from './getSupportedAreas.js';
+export { getBatteryStatus, getBatteryState } from './getBatteryStatus.js';
+export { getSupportedScenes } from './getSupportedScenes.js';

package/src/model/CloudMessageModel.ts

@@ -0,0 +1,11 @@
+import { CloudMessageResult } from '../roborockCommunication/Zmodel/messageResult.js';
+
+interface CloudMessageDpsEntry {
+  id: number;
+  result: CloudMessageResult[];
+}
+
+export interface CloudMessageModel {
+  duid: string;
+  dps: Record<string, number | CloudMessageDpsEntry>;
+}

package/src/model/DockingStationStatus.ts

@@ -0,0 +1,41 @@
+export interface DockingStationStatus {
+  cleanFluidStatus: number;
+  waterBoxFilterStatus: number;
+  dustBagStatus: number;
+  dirtyWaterBoxStatus: number;
+  clearWaterBoxStatus: number;
+  isUpdownWaterReady: number;
+}
+// {"cleanFluidStatus":0,"waterBoxFilterStatus":0,"dustBagStatus":2,"dirtyWaterBoxStatus":2,"clearWaterBoxStatus":2,"isUpdownWaterReady":0}
+
+export enum DockingStationStatusType {
+  Unknown = 0,
+  Error = 1,
+  OK = 2,
+}
+
+export function parseDockingStationStatus(dss: number): DockingStationStatus {
+  return {
+    cleanFluidStatus: (dss >> 10) & 0b11,
+    waterBoxFilterStatus: (dss >> 8) & 0b11,
+    dustBagStatus: (dss >> 6) & 0b11,
+    dirtyWaterBoxStatus: (dss >> 4) & 0b11,
+    clearWaterBoxStatus: (dss >> 2) & 0b11,
+    isUpdownWaterReady: dss & 0b11,
+  };
+}
+
+export function hasDockingStationError(status: DockingStationStatus | undefined): boolean {
+  if (!status) {
+    return false;
+  }
+
+  return (
+    status.cleanFluidStatus === DockingStationStatusType.Error ||
+    status.waterBoxFilterStatus === DockingStationStatusType.Error ||
+    status.dustBagStatus === DockingStationStatusType.Error ||
+    status.dirtyWaterBoxStatus === DockingStationStatusType.Error ||
+    status.clearWaterBoxStatus === DockingStationStatusType.Error
+    // || status.isUpdownWaterReady === DockingStationStatusType.Error
+  );
+}

package/src/model/ExperimentalFeatureSetting.ts

@@ -0,0 +1,77 @@
+export interface AdvancedFeature {
+  showRoutinesAsRoom: boolean;
+  includeDockStationStatus: boolean;
+  forceRunAtDefault: boolean;
+  useVacationModeToSendVacuumToDock: boolean;
+  enableServerMode: boolean;
+  alwaysExecuteAuthentication: boolean;
+  enableMultipleMap: boolean;
+}
+
+export interface AuthenticationPayload {
+  authenticationMethod: 'VerificationCode' | 'Password';
+  verificationCode?: string;
+  password?: string;
+}
+
+export interface ExperimentalFeatureSetting {
+  enableExperimentalFeature: boolean;
+  advancedFeature: AdvancedFeature;
+  cleanModeSettings: CleanModeSettings;
+}
+
+interface VacuumingCleanModeSetting {
+  fanMode: 'Balanced' | string;
+  mopRouteMode: 'Standard' | string;
+}
+
+interface MoppingCleanModeSetting {
+  waterFlowMode: 'Medium' | string;
+  mopRouteMode: 'Standard' | string;
+  distanceOff?: number;
+}
+
+interface VacMopCleanModeSetting {
+  fanMode: 'Balanced' | string;
+  waterFlowMode: 'Medium' | string;
+  mopRouteMode: 'Standard' | string;
+  distanceOff?: number;
+}
+
+export interface CleanModeSettings {
+  enableCleanModeMapping: boolean;
+  vacuuming?: VacuumingCleanModeSetting;
+  mopping?: MoppingCleanModeSetting;
+  vacmop?: VacMopCleanModeSetting;
+}
+
+export function createDefaultExperimentalFeatureSetting(): ExperimentalFeatureSetting {
+  return {
+    enableExperimentalFeature: false,
+    advancedFeature: {
+      showRoutinesAsRoom: false,
+      includeDockStationStatus: false,
+      forceRunAtDefault: false,
+      useVacationModeToSendVacuumToDock: false,
+      enableServerMode: false,
+      alwaysExecuteAuthentication: false,
+      enableMultipleMap: false,
+    },
+    cleanModeSettings: {
+      enableCleanModeMapping: false,
+      vacuuming: {
+        fanMode: 'Balanced',
+        mopRouteMode: 'Standard',
+      },
+      mopping: {
+        waterFlowMode: 'Medium',
+        mopRouteMode: 'Standard',
+      },
+      vacmop: {
+        fanMode: 'Balanced',
+        waterFlowMode: 'Medium',
+        mopRouteMode: 'Standard',
+      },
+    },
+  };
+}

package/src/model/RoomMap.ts

@@ -0,0 +1,38 @@
+import { MapRoom } from '../roborockCommunication/Zmodel/mapInfo.js';
+import { Room } from '../roborockCommunication/Zmodel/room.js';
+
+export interface RoomMapEntry {
+  id: number;
+  globalId: number | undefined;
+  displayName: string;
+  alternativeId: string;
+  mapId?: number;
+}
+
+export interface MapInfo {
+  id: number;
+  name: string | undefined;
+}
+
+export class RoomMap {
+  rooms: RoomMapEntry[];
+  mapInfo?: MapInfo[];
+
+  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 ?? `Room ${id}`,
+        alternativeId: `${id}${tag}`,
+        mapId,
+      };
+    });
+
+    this.mapInfo = mapInfo;
+  }
+}

package/src/model/roomIndexMap.ts

@@ -0,0 +1,26 @@
+import { MapInfo } from '../initialData/getSupportedAreas.js';
+
+export class RoomIndexMap {
+  public indexMap: Map<number, MapInfo>;
+  public roomMap: Map<string, number>;
+
+  constructor(roomMap: Map<number, MapInfo>) {
+    this.indexMap = roomMap;
+    this.roomMap = new Map();
+    for (const [areaId, r] of roomMap.entries()) {
+      this.roomMap.set(`${r.roomId}:${r.mapId}`, areaId);
+    }
+  }
+
+  public getAreaId(roomId: number, mapId: number): number | undefined {
+    const areaId = this.roomMap.get(`${roomId}:${mapId}`);
+    if (areaId === undefined) {
+      return undefined;
+    }
+    return areaId;
+  }
+
+  public getRoomId(areaId: number): number | undefined {
+    return this.indexMap.get(areaId)?.roomId;
+  }
+}

package/src/notifyMessageTypes.ts

@@ -0,0 +1,8 @@
+export enum NotifyMessageTypes {
+  LocalMessage = 'LocalMessage',
+  CloudMessage = 'CloudMessage',
+  BatteryUpdate = 'BatteryUpdate',
+  ErrorOccurred = 'ErrorOccurred',
+  HomeData = 'HomeData',
+  DeviceStatus = 'DeviceStatus',
+}