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

package/src/roborockCommunication/Zmodel/deviceStatus.ts

@@ -0,0 +1,30 @@
+import { VacuumErrorCode, DockErrorCode } from '../Zenum/vacuumAndDockErrorCode.js';
+import { DockInfo } from './dockInfo.js';
+import { CloudMessageResult } from './messageResult.js';
+import { VacuumError } from './vacuumError.js';
+
+export class DeviceStatus {
+  errorStatus: VacuumError;
+  message: CloudMessageResult;
+
+  constructor(message: CloudMessageResult[]) {
+    this.message = message[0];
+    this.errorStatus = new VacuumError(this.message.error_code, this.message.dock_error_status);
+  }
+
+  getBattery(): number {
+    return this.message.battery;
+  }
+
+  getVacuumErrorCode(): VacuumErrorCode {
+    return this.message.error_code;
+  }
+
+  getDockInfo(): DockInfo {
+    return new DockInfo(this.message.dock_type);
+  }
+
+  getDockErrorCode(): DockErrorCode {
+    return this.message.dock_error_status;
+  }
+}

package/src/roborockCommunication/Zmodel/dockInfo.ts

@@ -0,0 +1,9 @@
+import { DockType } from '../Zenum/dockType.js';
+
+export class DockInfo {
+  private readonly dockType: DockType;
+
+  constructor(dockType: DockType) {
+    this.dockType = dockType;
+  }
+}

package/src/roborockCommunication/Zmodel/home.ts

@@ -0,0 +1,13 @@
+import { Device } from './device.js';
+import { Product } from './product.js';
+import { Room } from './room.js';
+
+export interface Home {
+  id: number;
+  name: string;
+
+  products: Product[];
+  devices: Device[];
+  receivedDevices: Device[];
+  rooms: Room[];
+}

package/src/roborockCommunication/Zmodel/homeInfo.ts

@@ -0,0 +1,5 @@
+export interface HomeInfo {
+  id: number;
+  name: string;
+  rrHomeId: number;
+}

package/src/roborockCommunication/Zmodel/map.ts

@@ -0,0 +1,20 @@
+interface MapBackupInformation {
+  mapFlag: number;
+  add_time: number;
+}
+
+export interface MapInformation {
+  mapFlag: number;
+  add_time: number;
+  length: number;
+  name: string;
+  rooms?: RoomInformation[] | undefined;
+  bak_maps: MapBackupInformation[];
+}
+
+export interface RoomInformation {
+  id: number;
+  tag: number;
+  iot_name_id: string;
+  iot_name: string;
+}

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -0,0 +1,54 @@
+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 {
+  public readonly maps: MapEntry[] = [];
+  public readonly allRooms: MapRoom[] = [];
+
+  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,
+        })) ?? [];
+
+      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 {
+    return this.maps.find((m) => m.id === id)?.name;
+  }
+
+  getByName(name: string): number | undefined {
+    return this.maps.find((m) => m.name?.toLowerCase() === name.toLowerCase())?.id;
+  }
+}

package/src/roborockCommunication/Zmodel/messageResult.ts

@@ -0,0 +1,75 @@
+export interface CloudMessageResult {
+  msg_ver: number;
+  msg_seq: number;
+  state: number;
+  battery: number;
+  clean_time: number;
+  clean_area: number;
+  error_code: number;
+  map_present: number;
+  in_cleaning: number;
+  in_returning: number;
+  in_fresh_state: number;
+  lab_status: number;
+  water_box_status: number;
+  back_type?: number;
+  wash_phase?: number;
+  wash_ready?: number;
+  wash_status?: number;
+  fan_power: number;
+  dnd_enabled: number;
+  map_status: number;
+  is_locating: number;
+  lock_status: number;
+  water_box_mode: number;
+  distance_off: number;
+  water_box_carriage_status: number;
+  mop_forbidden_enable: number;
+  camera_status?: number;
+  is_exploring?: number;
+  adbumper_status: number[];
+  water_shortage_status?: number;
+  dock_type: number;
+  dust_collection_status: number;
+  auto_dust_collection: number;
+  avoid_count?: number;
+  mop_mode?: number;
+  debug_mode: number;
+  in_warmup?: number;
+  collision_avoid_status?: number;
+  switch_map_mode: number;
+  dock_error_status: number;
+  charge_status: number;
+  unsave_map_reason?: number;
+  unsave_map_flag?: number;
+  dry_status?: number;
+  rdt?: number;
+  clean_percent?: number;
+  extra_time?: number;
+  rss?: number;
+  dss?: number;
+  common_status?: number;
+  last_clean_t?: number;
+  replenish_mode?: number;
+  repeat?: number;
+  kct?: number;
+  subdivision_sets?: number;
+  cleaning_info?: CleanInformation;
+  exit_dock?: number;
+  seq_type?: number;
+}
+
+interface CleanInformation {
+  target_segment_id: number;
+  segment_id: number;
+  fan_power: number;
+  water_box_status: number;
+  mop_mode: number;
+}
+
+export enum CarpetCleanMode {
+  Avoid = 0,
+  Ignore = 2,
+  Cross = 3,
+  DynamicLift = 200, // TODO
+}

package/src/roborockCommunication/Zmodel/multipleMap.ts

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

package/src/roborockCommunication/Zmodel/networkInfo.ts

@@ -0,0 +1,7 @@
+export interface NetworkInfo {
+  ssid: string;
+  ip: string;
+  mac: string;
+  bssid: string;
+  rssi: number;
+}

package/src/roborockCommunication/Zmodel/product.ts

@@ -0,0 +1,9 @@
+import { DeviceSchema } from './deviceSchema.js';
+
+export interface Product {
+  id: string;
+  name: string;
+  model: string;
+  category: string;
+  schema: DeviceSchema[];
+}

package/src/roborockCommunication/Zmodel/room.ts

@@ -0,0 +1,4 @@
+export interface Room {
+  id: number; // this is global id
+  name: string;
+}

package/src/roborockCommunication/Zmodel/roomInfo.ts

@@ -0,0 +1,30 @@
+import decodeComponent from '../helper/nameDecoder.js';
+import { Room } from './room.js';
+
+interface RoomEntry {
+  id: number;
+  name: string | undefined;
+}
+
+export class RoomInfo {
+  readonly rooms: RoomEntry[] = [];
+
+  constructor(roomInfo: Room[], roomData: number[][]) {
+    this.rooms = roomData
+      .map((entry) => {
+        return { id: entry[0], globalId: entry[1] };
+      })
+      .map((entry) => {
+        return {
+          id: entry.id,
+          room: roomInfo.find((el) => el.id == entry.globalId),
+        };
+      })
+      .map((entry) => {
+        return {
+          id: entry.id,
+          name: decodeComponent(entry.room?.name)?.toLowerCase(),
+        };
+      });
+  }
+}

package/src/roborockCommunication/Zmodel/scene.ts

@@ -0,0 +1,44 @@
+export class Scene {
+  id: number | undefined;
+  name: string | undefined;
+  param: string | undefined;
+  enabled: boolean | undefined;
+  extra: unknown | undefined;
+  type: string | undefined;
+}
+
+interface ActionInformation {
+  type: string;
+  items: SceneItem[];
+}
+
+export interface SceneParam {
+  triggers: unknown[];
+  action: ActionInformation;
+  matchType: string;
+}
+
+export class SceneItem {
+  id: number | undefined;
+  type: string | undefined;
+  name: string | undefined;
+  entityId: string | undefined;
+  param: SceneCommand | undefined;
+  finishDpIds: number[] | undefined;
+}
+
+export interface SceneCommand {
+  id: number;
+  method: string;
+  params: SceneCommandParam[];
+}
+
+export interface SceneCommandParam {
+  fan_power: number;
+  water_box_mode: number;
+  mop_mode: number;
+  mop_template_id: number;
+  repeat: number;
+  auto_dustCollection: number;
+  source: number;
+}

package/src/roborockCommunication/Zmodel/userData.ts

@@ -0,0 +1,26 @@
+export interface UserData {
+  uid: string | number;
+  tokentype: string;
+  token: string;
+  rruid: string;
+  region: string;
+  countrycode: string;
+  country: string;
+  nickname: string;
+  rriot: Rriot;
+}
+
+interface r {
+  r: string;
+  a: string;
+  m: string;
+  l: string;
+}
+
+export interface Rriot {
+  u: string;
+  s: string;
+  h: string;
+  k: string;
+  r: r;
+}

package/src/roborockCommunication/Zmodel/vacuumError.ts

@@ -0,0 +1,35 @@
+import { DockErrorCode, VacuumErrorCode } from '../Zenum/vacuumAndDockErrorCode.js';
+
+export class VacuumError {
+  private readonly vacuumErrorCode: VacuumErrorCode;
+  private readonly dockErrorCode: DockErrorCode;
+
+  constructor(errorCode: VacuumErrorCode, dockErrorCode: DockErrorCode) {
+    this.vacuumErrorCode = errorCode;
+    this.dockErrorCode = dockErrorCode;
+  }
+
+  hasError() {
+    return this.vacuumErrorCode != 0 || this.dockErrorCode != 0;
+  }
+
+  isStuck(): boolean {
+    return this.vacuumErrorCode === VacuumErrorCode.RobotTrapped;
+  }
+
+  isBatteryLow(): boolean {
+    return this.vacuumErrorCode === VacuumErrorCode.LowBattery;
+  }
+
+  isBinFull(): boolean {
+    return this.vacuumErrorCode === VacuumErrorCode.CleanAutoEmptyDock || this.dockErrorCode == DockErrorCode.DuctBlockage;
+  }
+
+  isCleanWaterEmpty(): boolean {
+    return this.vacuumErrorCode === VacuumErrorCode.ClearWaterTankEmpty || this.dockErrorCode == DockErrorCode.WaterEmpty;
+  }
+
+  isWasteWaterFull(): boolean {
+    return this.dockErrorCode == DockErrorCode.WasteWaterTankFull;
+  }
+}

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -0,0 +1,80 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { MessageDeserializer } from '../helper/messageDeserializer.js';
+import { MessageSerializer } from '../helper/messageSerializer.js';
+import { AbstractConnectionListener } from './listener/abstractConnectionListener.js';
+import { AbstractMessageListener } from './listener/abstractMessageListener.js';
+import { RequestMessage } from './model/requestMessage.js';
+import { Client } from './client.js';
+import { MessageContext } from './model/messageContext.js';
+import { ChainedConnectionListener } from './listener/implementation/chainedConnectionListener.js';
+import { ChainedMessageListener } from './listener/implementation/chainedMessageListener.js';
+import { SyncMessageListener } from './listener/implementation/syncMessageListener.js';
+import { ResponseMessage } from '../index.js';
+import { ConnectionStateListener } from './listener/implementation/connectionStateListener.js';
+
+export abstract class AbstractClient implements Client {
+  public isInDisconnectingStep = false;
+  public retryCount = 0;
+
+  protected readonly connectionListeners = new ChainedConnectionListener();
+  protected readonly messageListeners = new ChainedMessageListener();
+  protected readonly serializer: MessageSerializer;
+  protected readonly deserializer: MessageDeserializer;
+  protected readonly context: MessageContext;
+  protected connected = false;
+  protected logger: AnsiLogger;
+
+  protected abstract clientName: string;
+  protected abstract shouldReconnect: boolean;
+
+  private readonly syncMessageListener: SyncMessageListener;
+
+  protected constructor(logger: AnsiLogger, context: MessageContext) {
+    this.context = context;
+    this.serializer = new MessageSerializer(this.context, logger);
+    this.deserializer = new MessageDeserializer(this.context, logger);
+
+    this.syncMessageListener = new SyncMessageListener(logger);
+    this.messageListeners.register(this.syncMessageListener);
+    this.logger = logger;
+  }
+
+  protected initializeConnectionStateListener() {
+    const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.shouldReconnect);
+    this.connectionListeners.register(connectionStateListener);
+  }
+
+  abstract connect(): void;
+  abstract disconnect(): Promise<void>;
+  abstract send(duid: string, request: RequestMessage): Promise<void>;
+
+  public async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
+    return new Promise<T>((resolve, reject) => {
+      this.syncMessageListener.waitFor(request.messageId, request, (response: ResponseMessage) => resolve(response as unknown as T), reject);
+      this.send(duid, request);
+    })
+      .then((result: T) => {
+        return result;
+      })
+      .catch((error: Error) => {
+        this.logger.error(error.message);
+        return undefined;
+      });
+  }
+
+  public registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void {
+    this.context.registerDevice(duid, localKey, pv, nonce);
+  }
+
+  public registerConnectionListener(listener: AbstractConnectionListener): void {
+    this.connectionListeners.register(listener);
+  }
+
+  public registerMessageListener(listener: AbstractMessageListener): void {
+    this.messageListeners.register(listener);
+  }
+
+  public isConnected() {
+    return this.connected;
+  }
+}

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

@@ -0,0 +1,218 @@
+import { Socket } from 'node:net';
+import { clearInterval } from 'node:timers';
+import { Protocol } from '../model/protocol.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
+import { AbstractClient } from '../abstractClient.js';
+import { MessageContext } from '../model/messageContext.js';
+import { Sequence } from '../../helper/sequence.js';
+import { ChunkBuffer } from '../../helper/chunkBuffer.js';
+
+export class LocalNetworkClient extends AbstractClient {
+  protected override clientName = 'LocalNetworkClient';
+  protected override shouldReconnect = true;
+
+  private socket: Socket | undefined = undefined;
+  private buffer: ChunkBuffer = new ChunkBuffer();
+  private messageIdSeq: Sequence;
+  private pingInterval?: NodeJS.Timeout;
+  private keepConnectionAliveInterval: NodeJS.Timeout | undefined = undefined;
+
+  public duid: string;
+  public ip: string;
+
+  constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string) {
+    super(logger, context);
+    this.duid = duid;
+    this.ip = ip;
+    this.messageIdSeq = new Sequence(100000, 999999);
+
+    this.initializeConnectionStateListener();
+  }
+
+  public connect(): void {
+    if (this.socket) {
+      return; // Already connected
+    }
+
+    this.socket = new Socket();
+
+    // Socket event listeners
+    this.socket.on('close', this.onDisconnect.bind(this));
+    this.socket.on('end', this.onEnd.bind(this));
+    this.socket.on('error', this.onError.bind(this));
+    this.socket.on('connect', this.onConnect.bind(this));
+    this.socket.on('timeout', this.onTimeout.bind(this));
+
+    // Data event listener
+    this.socket.on('data', this.onMessage.bind(this));
+    this.socket.connect(58867, this.ip);
+
+    this.keepConnectionAlive();
+  }
+
+  public async disconnect(): Promise<void> {
+    if (!this.socket) {
+      return;
+    }
+
+    this.isInDisconnectingStep = true;
+
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+    this.socket.destroy();
+    this.socket = undefined;
+  }
+
+  public async send(duid: string, request: RequestMessage): Promise<void> {
+    if (!this.socket || !this.connected) {
+      this.logger.error(`${duid}: socket is not online, , ${debugStringify(request)}`);
+      return;
+    }
+
+    const localRequest = request.toLocalRequest();
+    const message = this.serializer.serialize(duid, localRequest);
+
+    this.logger.debug(`sending message ${message.messageId}, protocol:${localRequest.protocol}, method:${localRequest.method}, secure:${request.secure} to ${duid}`);
+    this.socket.write(this.wrapWithLengthData(message.buffer));
+  }
+
+  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);
+    await this.connectionListeners.onConnected(this.duid);
+  }
+
+  private async onDisconnect(hadError: boolean): Promise<void> {
+    this.logger.info(` [LocalNetworkClient]: ${this.duid} socket disconnected. Had error: ${hadError}`);
+    this.connected = false;
+
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = undefined;
+    }
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+    await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
+  }
+
+  private async onError(error: Error): Promise<void> {
+    this.logger.error(` [LocalNetworkClient]: Socket error for ${this.duid}: ${error.message}`);
+    await this.connectionListeners.onError(this.duid, error.message);
+  }
+
+  private async onTimeout(): Promise<void> {
+    this.logger.error(` [LocalNetworkClient]: Socket for ${this.duid} timed out.`);
+  }
+
+  private async onEnd(): Promise<void> {
+    this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket ended.`);
+  }
+
+  private async onMessage(message: Buffer): Promise<void> {
+    if (!this.socket) {
+      return;
+    }
+
+    if (!message || message.length == 0) {
+      this.logger.debug('LocalNetworkClient received empty message from socket.');
+      return;
+    }
+
+    try {
+      this.buffer.append(message);
+
+      const receivedBuffer = this.buffer.get();
+      if (!this.isMessageComplete(receivedBuffer)) {
+        return;
+      }
+      this.buffer.reset();
+
+      let offset = 0;
+      while (offset + 4 <= receivedBuffer.length) {
+        const segmentLength = receivedBuffer.readUInt32BE(offset);
+        if (segmentLength == 17) {
+          offset += 4 + segmentLength;
+          continue;
+        }
+
+        try {
+          const currentBuffer = receivedBuffer.subarray(offset + 4, offset + segmentLength + 4);
+          const response = this.deserializer.deserialize(this.duid, currentBuffer);
+          await this.messageListeners.onMessage(response);
+        } catch (error) {
+          this.logger.error('LocalNetworkClient: unable to process message with error: ' + error);
+          // unable to process message: TypeError: Cannot read properties of undefined (reading 'length')
+        }
+        offset += 4 + segmentLength;
+      }
+    } catch (error) {
+      this.logger.error('LocalNetworkClient: read socket buffer error: ' + error);
+    }
+  }
+
+  private isMessageComplete(buffer: Buffer): boolean {
+    let totalLength = 0;
+    let offset = 0;
+
+    while (offset + 4 <= buffer.length) {
+      const segmentLength = buffer.readUInt32BE(offset);
+      totalLength += 4 + segmentLength;
+      offset += 4 + segmentLength;
+
+      if (offset > buffer.length) {
+        return false;
+      }
+    }
+
+    return totalLength <= buffer.length;
+  }
+
+  private wrapWithLengthData(buffer: Buffer<ArrayBufferLike>): Buffer<ArrayBufferLike> {
+    const lengthBuffer = Buffer.alloc(4);
+    lengthBuffer.writeUInt32BE(buffer.length, 0);
+    return Buffer.concat([lengthBuffer, buffer]);
+  }
+
+  private async sendHelloMessage(): Promise<void> {
+    const request = new RequestMessage({
+      protocol: Protocol.hello_request,
+      messageId: this.messageIdSeq.next(),
+      nonce: this.context.nonce,
+    });
+
+    await this.send(this.duid, request);
+  }
+
+  private async sendPingRequest(): Promise<void> {
+    const request = new RequestMessage({
+      protocol: Protocol.ping_request,
+      messageId: this.messageIdSeq.next(),
+    });
+    await this.send(this.duid, request);
+  }
+
+  private keepConnectionAlive(): void {
+    if (this.keepConnectionAliveInterval) {
+      clearTimeout(this.keepConnectionAliveInterval);
+      this.keepConnectionAliveInterval.unref();
+    }
+
+    this.keepConnectionAliveInterval = setInterval(
+      () => {
+        if (this.socket === undefined || !this.connected || !this.socket.writable || this.socket.readable) {
+          this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket is not writable or readable, reconnecting...`);
+          this.connect();
+        }
+      },
+      60 * 60 * 1000,
+    );
+  }
+}