matterbridge-roborock-vacuum-plugin 1.0.5

package/src/initialData/getSupportedAreas.ts

@@ -0,0 +1,95 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { ServiceArea } from 'matterbridge/matter/clusters';
+import RoomMap from '../model/RoomMap.js';
+import { Room } from '../roborockCommunication/Zmodel/room.js';
+
+/*
+rooms = [
+  { id: 123456, name: 'Study' },
+  { id: 123457, name: 'Bedroom' },
+  { id: 123458, name: 'Kitchen' },
+  { id: 123459, name: 'Living room' }
+]
+roomMap = {
+  rooms: [
+    { id: 1, globalId: "123456", displayName: undefined },
+    { id: 2, globalId: "123457", displayName: undefined },
+    { id: 3, globalId: "123458", displayName: undefined },
+    { id: 4, globalId: "123459", displayName: undefined },
+  ],
+};
+*/
+
+export function getSupportedAreas(rooms: Room[], roomMap: RoomMap | undefined, log?: AnsiLogger): ServiceArea.Area[] {
+  log?.debug('getSupportedAreas', JSON.stringify(rooms));
+  log?.debug('getSupportedAreas', JSON.stringify(roomMap));
+
+  if (!rooms || rooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
+    log?.error('No rooms found');
+    return [
+      {
+        areaId: 1,
+        mapId: null,
+        areaInfo: {
+          locationInfo: {
+            locationName: 'Unknown',
+            floorNumber: null,
+            areaType: null,
+          },
+          landmarkInfo: null,
+        },
+      },
+    ];
+  }
+
+  const supportedAreas: ServiceArea.Area[] = rooms.map((room, index) => {
+    return {
+      areaId: roomMap.getRoomId(room.id) ?? index + 1,
+      mapId: null,
+      areaInfo: {
+        locationInfo: {
+          locationName: room.name,
+          floorNumber: null,
+          areaType: null,
+        },
+        landmarkInfo: null,
+      },
+    };
+  });
+
+  const duplicated = findDuplicatedAreaIds(supportedAreas, log);
+
+  return duplicated
+    ? [
+        {
+          areaId: 1,
+          mapId: null,
+          areaInfo: {
+            locationInfo: {
+              locationName: 'Unknown',
+              floorNumber: null,
+              areaType: null,
+            },
+            landmarkInfo: null,
+          },
+        },
+      ]
+    : 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);
+    } else {
+      seen.add(area.areaId);
+    }
+  }
+  if (duplicates.length > 0 && log) {
+    const duplicated = areas.filter((x) => duplicates.includes(x.areaId));
+    log.error(`Duplicated areaId(s) found: ${JSON.stringify(duplicated)}`);
+  }
+  return duplicates.length > 0;
+}

package/src/initialData/getSupportedCleanModes.ts

@@ -0,0 +1,13 @@
+import { RvcCleanMode } from 'matterbridge/matter/clusters';
+import { getSupportedCleanModesA187 } from '../behaviors/roborock.vacuum/QREVO_EDGE_5V1/initalData.js';
+import { getDefaultSupportedCleanModes } from '../behaviors/roborock.vacuum/default/initalData.js';
+import { DeviceModel } from '../roborockCommunication/Zmodel/deviceModel.js';
+
+export function getSupportedCleanModes(model: string): RvcCleanMode.ModeOption[] {
+  switch (model) {
+    case DeviceModel.QREVO_EDGE_5V1:
+      return getSupportedCleanModesA187();
+    default:
+      return getDefaultSupportedCleanModes();
+  }
+}

package/src/initialData/getSupportedRunModes.ts

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

package/src/initialData/index.ts

@@ -0,0 +1,5 @@
+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';

package/src/model/CloudMessageModel.ts

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

package/src/model/DockingStationStatus.ts

@@ -0,0 +1,37 @@
+export type 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): boolean {
+  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/RoomMap.ts

@@ -0,0 +1,44 @@
+/*
+rooms = [
+  { id: 123456, name: 'Study' },
+  { id: 123457, name: 'Bedroom' },
+  { id: 123458, name: 'Kitchen' },
+  { id: 123459, name: 'Living room' }
+]
+roomMap = {
+  rooms: [
+    { id: 1, globalId: "123456", displayName: undefined },
+    { id: 2, globalId: "123457", displayName: undefined },
+    { id: 3, globalId: "123458", displayName: undefined },
+    { id: 4, globalId: "123459", displayName: undefined },
+  ],
+};
+*/
+
+import { Room } from '../roborockCommunication/Zmodel/room.js';
+
+export default class RoomMap {
+  readonly rooms: {
+    id: number;
+    globalId: number | undefined;
+    displayName: string | undefined;
+  }[] = [];
+
+  constructor(roomData: number[][], rooms: Room[]) {
+    this.rooms = roomData.map((entry) => {
+      return {
+        id: entry[0],
+        globalId: Number(entry[1]),
+        displayName: rooms.find((r) => Number(r.id) == Number(entry[1]))?.name,
+      };
+    });
+  }
+
+  getGlobalId(id: number): number | undefined {
+    return this.rooms.find((r) => Number(r.id) == Number(id))?.globalId;
+  }
+
+  getRoomId(globalId: number): number | undefined {
+    return this.rooms.find((r) => Number(r.globalId) == Number(globalId))?.id;
+  }
+}

package/src/notifyMessageTypes.ts

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

package/src/platform.ts

@@ -0,0 +1,192 @@
+import './extensions/index.js';
+import { Matterbridge, MatterbridgeDynamicPlatform, PlatformConfig } from 'matterbridge';
+import * as axios from 'axios';
+import { AnsiLogger, 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 { PlatformRunner } from './platformRunner.js';
+import { RoborockVacuumCleaner } from './rvc.js';
+import { configurateBehavior } from './behaviorFactory.js';
+import { NotifyMessageTypes } from './notifyMessageTypes.js';
+import { Device, RoborockAuthenticateApi, RoborockIoTApi } from './roborockCommunication/index.js';
+import { getSupportedAreas } from './initialData/index.js';
+
+export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
+  robot: RoborockVacuumCleaner | undefined;
+  rvcInterval: NodeJS.Timeout | undefined;
+  roborockService: RoborockService | undefined;
+  clientManager: ClientManager;
+  platformRunner: PlatformRunner | undefined;
+  devices: Map<string, Device>;
+  serialNumber: string | undefined;
+
+  constructor(matterbridge: Matterbridge, log: AnsiLogger, config: PlatformConfig) {
+    super(matterbridge, log, config);
+
+    // Verify that Matterbridge is the correct version
+    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.0.4')) {
+      throw new Error(
+        `This plugin requires Matterbridge version >= "3.0.4". 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) config.whiteList = [];
+    if (config.blackList === undefined) config.blackList = [];
+    if (config.enableExperimentalFeature === undefined) config.enableExperimentalFeature = false;
+
+    this.clientManager = new ClientManager(this.log);
+    this.devices = new Map<string, Device>();
+  }
+
+  override async onStart(reason?: string) {
+    this.log.notice('onStart called with reason:', reason ?? 'none');
+    const self = this;
+
+    // Wait for the platform to start
+    await this.ready;
+    await this.clearSelect();
+
+    // Verify that the config is correct
+    if (this.config.username === undefined || this.config.password === undefined) {
+      this.log.error('"username" and "password" are required in the config');
+      return;
+    }
+
+    // Add request interceptor
+    const axiosInstance = axios.default ?? axios;
+    axiosInstance.interceptors.request.use((request: any) => {
+      self.log.debug('Axios Request:', {
+        method: request.method,
+        url: request.url,
+        data: request.data,
+        headers: request.headers,
+      });
+      return request;
+    });
+
+    axiosInstance.interceptors.response.use((response: any) => {
+      self.log.debug('Axios Response:', {
+        status: response.status,
+        data: response.data,
+        headers: response.headers,
+        url: response.config.url,
+      });
+      return response;
+    });
+
+    this.platformRunner = new PlatformRunner(this);
+
+    this.roborockService = new RoborockService(
+      () => new RoborockAuthenticateApi(this.log, axiosInstance),
+      (logger, ud) => new RoborockIoTApi(ud, logger),
+      (this.config.refreshInterval as number) ?? 60,
+      this.clientManager,
+      this.log,
+    );
+
+    const username = this.config.username as string;
+    const password = this.config.password as string;
+
+    const userData = await this.roborockService.loginWithPassword(username, password);
+    this.log.debug('Initializing - userData:', JSON.stringify(userData));
+    const devices = await this.roborockService.listDevices(username);
+    this.log.notice('Initializing - devices: ', JSON.stringify(devices));
+
+    let vacuum: Device | undefined = undefined;
+    if ((this.config.whiteList as string[]).length > 0) {
+      const firstDUID = (this.config.whiteList as string[])[0];
+      vacuum = devices.find((d) => d.duid == firstDUID);
+    } else {
+      vacuum = devices.find((d) => isSupportedDevice(d.data.model));
+    }
+
+    if (!vacuum) {
+      this.log.error('Initializing: No supported devices found');
+      return;
+    }
+    await this.roborockService.initializeMessageClient(username, vacuum, userData);
+    this.devices.set(vacuum.serialNumber, vacuum);
+    this.serialNumber = vacuum.serialNumber;
+
+    await this.onConfigurateDevice();
+    this.log.notice('onStart finished');
+  }
+
+  override async onConfigure() {
+    await super.onConfigure();
+    const self = this;
+    this.rvcInterval = setInterval(
+      async () => {
+        self.platformRunner?.requestHomeData();
+      },
+      ((this.config.refreshInterval as number) ?? 60) * 1000 + 100,
+    );
+  }
+
+  async onConfigurateDevice(): Promise<void> {
+    this.log.info('onConfigurateDevice start');
+    if (this.platformRunner === undefined || this.roborockService === undefined) {
+      this.log.error('Initializing: PlatformRunner or RoborockService is undefined');
+      return;
+    }
+    const vacuum = this.devices.get(this.serialNumber as string);
+    const username = this.config.username as string;
+    if (!vacuum || !username) {
+      this.log.error('Initializing: No supported devices found');
+      return;
+    }
+
+    const self = this;
+    await this.roborockService.initializeMessageClientForLocal(vacuum);
+    const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+
+    this.log.debug('Initializing - roomMap: ', JSON.stringify(roomMap));
+
+    const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.log);
+
+    this.roborockService.setSupportedAreas(vacuum.duid, getSupportedAreas(vacuum.rooms, roomMap, this.log));
+    this.robot = new RoborockVacuumCleaner(username, vacuum, roomMap, this.log);
+    this.robot.configurateHandler(behaviorHandler);
+
+    // const xxx = this.roborockService.customGet(vacuum.duid, 'get_custom_mode');
+    // this.log.error('XXXXXXX: ', JSON.stringify(xxx));
+    // const yyyy = this.roborockService.customGetInSecure(vacuum.duid, 'get_custom_mode');
+    // this.log.error('XXXXXXX: ', JSON.stringify(yyyy));
+
+    this.log.info('vacuum:', JSON.stringify(vacuum));
+
+    this.setSelectDevice(this.robot.serialNumber ?? '', this.robot.deviceName ?? '', undefined, 'hub');
+    if (this.validateDevice(this.robot.deviceName ?? '')) {
+      await this.registerDevice(this.robot);
+    }
+
+    this.roborockService.setDeviceNotify(async function (messageSource: NotifyMessageTypes, homeData: any) {
+      await self.platformRunner?.updateRobot(messageSource, homeData);
+    });
+
+    await this.roborockService.activateDeviceNotify(this.robot.device);
+    await self.platformRunner?.requestHomeData();
+
+    this.log.info('onConfigurateDevice finished');
+  }
+
+  override async onShutdown(reason?: string) {
+    await super.onShutdown(reason);
+    this.log.notice('onShutdown called with reason:', reason ?? 'none');
+    this.rvcInterval && clearInterval(this.rvcInterval);
+    if (this.roborockService) this.roborockService.stopService();
+    if (this.config.unregisterOnShutdown === true) await this.unregisterAllDevices(500);
+  }
+
+  override async onChangeLoggerLevel(logLevel: LogLevel): Promise<void> {
+    this.log.notice(`Change ${PLUGIN_NAME} log level: ${logLevel} (was ${this.log.logLevel})`);
+    this.log.logLevel = logLevel;
+    return Promise.resolve();
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}