matterbridge-roborock-vacuum-plugin 1.0.5

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;
+  private readonly message: CloudMessageResult;
+
+  constructor(message: CloudMessageResult) {
+    this.message = message;
+    this.errorStatus = new VacuumError(message.error_code, 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/messageResult.ts

@@ -0,0 +1,72 @@
+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: {
+    target_segment_id: number;
+    segment_id: number;
+    fan_power: number;
+    water_box_status: number;
+    mop_mode: number;
+  };
+  exit_dock: number;
+}
+
+export enum CarpetCleanMode {
+  Avoid = 0,
+  Ignore = 2,
+  Cross = 3,
+  DynamicLift = 200, //TODO
+}

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,25 @@
+import decodeComponent from '../helper/nameDecoder.js';
+import { Room } from './room.js';
+
+export class RoomInfo {
+  readonly rooms: { id: number; name: string | undefined }[] = [];
+
+  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/userData.ts

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

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,61 @@
+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';
+
+export abstract class AbstractClient implements Client {
+  protected readonly connectionListeners = new ChainedConnectionListener();
+  protected readonly messageListeners = new ChainedMessageListener();
+
+  protected connected: boolean = false;
+
+  private readonly context: MessageContext;
+  protected readonly serializer: MessageSerializer;
+  protected readonly deserializer: MessageDeserializer;
+  private readonly syncMessageListener: SyncMessageListener;
+  protected logger: AnsiLogger;
+
+  protected constructor(logger: AnsiLogger, context: MessageContext) {
+    this.context = context;
+    this.serializer = new MessageSerializer(this.context);
+    this.deserializer = new MessageDeserializer(this.context);
+
+    this.syncMessageListener = new SyncMessageListener(logger);
+    this.messageListeners.register(this.syncMessageListener);
+    this.logger = logger;
+  }
+
+  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> {
+    return new Promise<any>((resolve, reject) => {
+      this.syncMessageListener.waitFor(request.messageId, resolve, reject);
+      this.send(duid, request);
+    });
+  }
+
+  public registerDevice(duid: string, localKey: string, pv: string): void {
+    this.context.registerDevice(duid, localKey, pv);
+  }
+
+  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,177 @@
+import { Socket } from 'node:net';
+import { clearInterval } from 'node:timers';
+import { Protocol } from '../model/protocol.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { AnsiLogger } 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 {
+  private socket: Socket | undefined = undefined;
+  private buffer: ChunkBuffer = new ChunkBuffer();
+  private messageIdSeq: Sequence;
+  private pingInterval?: NodeJS.Timeout;
+  duid: string;
+  ip: string;
+
+  public constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string) {
+    super(logger, context);
+    this.duid = duid;
+    this.ip = ip;
+    this.messageIdSeq = new Sequence(100000, 999999);
+  }
+
+  public connect(): void {
+    this.socket = new Socket();
+    this.socket.on('close', this.onDisconnect.bind(this));
+    this.socket.on('end', this.onDisconnect.bind(this));
+    this.socket.on('error', this.onError.bind(this));
+    this.socket.on('data', this.onMessage.bind(this));
+    this.socket.connect(58867, this.ip, this.onConnect.bind(this));
+  }
+
+  public async disconnect(): Promise<void> {
+    if (!this.socket) {
+      return;
+    }
+
+    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(`failed to send request to ${duid}, socket is not online, ${JSON.stringify(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.connected = true;
+    const address = this.socket?.address();
+    this.logger.debug(`${this.duid} connected to ${this.ip}, address: ${JSON.stringify(address)}`);
+    await this.sendHelloMessage();
+    this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
+    await this.connectionListeners.onConnected();
+  }
+
+  private async onDisconnect(): Promise<void> {
+    this.logger.info('Socket has disconnected.');
+    this.connected = false;
+
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = undefined;
+    }
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+
+    await this.connectionListeners.onDisconnected();
+  }
+
+  private async onError(result: any): Promise<void> {
+    this.logger.error('Socket connection error: ' + result);
+    this.connected = false;
+
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = undefined;
+    }
+
+    await this.connectionListeners.onError(result.toString());
+  }
+
+  private async onMessage(message: Buffer): Promise<void> {
+    if (!this.socket) {
+      this.logger.error('unable to receive data if there is no socket available');
+      return;
+    }
+
+    if (!message || message.length == 0) {
+      this.logger.debug('LocalNetworkClient received empty message from socket.');
+      return;
+    }
+
+    try {
+      this.buffer.append(message);
+
+      const recvBuffer = this.buffer.get();
+      if (!this.isMessageComplete(recvBuffer)) {
+        return;
+      }
+      this.buffer.reset();
+
+      let offset = 0;
+      while (offset + 4 <= recvBuffer.length) {
+        const segmentLength = recvBuffer.readUInt32BE(offset);
+        if (segmentLength == 17) {
+          offset += 4 + segmentLength;
+          continue;
+        }
+
+        try {
+          const currentBuffer = recvBuffer.subarray(offset + 4, offset + segmentLength + 4);
+          const response = this.deserializer.deserialize(this.duid, currentBuffer);
+          await this.messageListeners.onMessage(response);
+        } catch (error) {
+          this.logger.error('unable to process message: ' + error);
+        }
+        offset += 4 + segmentLength;
+      }
+    } catch (error) {
+      this.logger.error('failed to read from a socket: ' + 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; // Data is not complete yet
+      }
+    }
+
+    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(),
+    });
+
+    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);
+  }
+}

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

@@ -0,0 +1,129 @@
+import mqtt, { ErrorWithReasonCode, IConnackPacket, ISubscriptionGrant, MqttClient as MqttLibClient } from 'mqtt';
+import { CryptoUtils } from '../../helper/cryptoHelper.js';
+import { RequestMessage } from '../model/requestMessage.js';
+import { AbstractClient } from '../abstractClient.js';
+import { MessageContext } from '../model/messageContext.js';
+import { Rriot, UserData } from '../../Zmodel/userData.js';
+import { AnsiLogger } from 'matterbridge/logger';
+
+export class MQTTClient extends AbstractClient {
+  private readonly rriot: Rriot;
+  private readonly mqttUsername: string;
+  private readonly mqttPassword: string;
+  private client: MqttLibClient | undefined = undefined;
+
+  public constructor(logger: AnsiLogger, context: MessageContext, userdata: UserData) {
+    super(logger, context);
+    this.rriot = userdata.rriot;
+
+    this.mqttUsername = CryptoUtils.md5hex(userdata.rriot.u + ':' + userdata.rriot.k).substring(2, 10);
+    this.mqttPassword = CryptoUtils.md5hex(userdata.rriot.s + ':' + userdata.rriot.k).substring(16);
+  }
+
+  public connect(): void {
+    if (this.client) {
+      return;
+    }
+
+    this.client = mqtt.connect(this.rriot.r.m, {
+      clientId: this.mqttUsername,
+      username: this.mqttUsername,
+      password: this.mqttPassword,
+      keepalive: 30,
+      log: (...args: any[]) => {
+        //this.logger.debug('MQTTClient args:: ' + args[0]);
+      },
+    });
+
+    this.client.on('connect', this.onConnect.bind(this));
+    this.client.on('error', this.onError.bind(this));
+    this.client.on('reconnect', this.onReconnect.bind(this));
+    this.client.on('close', this.onDisconnect.bind(this));
+    this.client.on('disconnect', this.onDisconnect.bind(this));
+    this.client.on('offline', this.onDisconnect.bind(this));
+
+    // message events
+    this.client.on('message', this.onMessage.bind(this));
+  }
+
+  public async disconnect(): Promise<void> {
+    if (!this.client || !this.connected) {
+      return;
+    }
+    try {
+      this.client.end();
+    } catch (error) {
+      this.logger.error('MQTT client failed to disconnect with error: ' + error);
+    }
+  }
+
+  public async send(duid: string, request: RequestMessage): Promise<void> {
+    if (!this.client || !this.connected) {
+      return;
+    }
+
+    const mqttRequest = request.toMqttRequest();
+    const message = this.serializer.serialize(duid, mqttRequest);
+    this.client.publish('rr/m/i/' + this.rriot.u + '/' + this.mqttUsername + '/' + duid, message.buffer, { qos: 1 });
+  }
+
+  private async onConnect(result: IConnackPacket) {
+    if (!result) {
+      return;
+    }
+
+    this.connected = true;
+    await this.connectionListeners.onConnected();
+
+    this.subscribeToQueue();
+  }
+
+  private subscribeToQueue() {
+    if (!this.client) {
+      return;
+    }
+    this.client.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
+  }
+
+  private async onSubscribe(err: Error | null, granted: ISubscriptionGrant[] | undefined) {
+    if (!err) {
+      return;
+    }
+
+    this.logger.error('failed to subscribe to the queue: ' + err);
+    this.connected = false;
+
+    await this.connectionListeners.onDisconnected();
+  }
+
+  private async onDisconnect() {
+    await this.connectionListeners.onDisconnected();
+  }
+
+  private async onError(result: Error | ErrorWithReasonCode) {
+    this.logger.error('MQTT connection error: ' + result);
+    this.connected = false;
+
+    await this.connectionListeners.onError(result.toString());
+  }
+
+  private onReconnect() {
+    this.subscribeToQueue();
+  }
+
+  private async onMessage(topic: string, message: Buffer<ArrayBufferLike>) {
+    if (!message) {
+      //Ignore empty messages
+      this.logger.notice('MQTTClient received empty message from topic: ' + topic);
+      return;
+    }
+
+    try {
+      const duid = topic.split('/').slice(-1)[0];
+      const response = this.deserializer.deserialize(duid, message);
+      await this.messageListeners.onMessage(response);
+    } catch (error) {
+      this.logger.error('unable to process message from queue ' + topic + ': ' + error);
+    }
+  }
+}

package/src/roborockCommunication/broadcast/client.ts

@@ -0,0 +1,19 @@
+import { AbstractConnectionListener } from './listener/abstractConnectionListener.js';
+import { AbstractMessageListener } from './listener/abstractMessageListener.js';
+import { RequestMessage } from './model/requestMessage.js';
+
+export interface Client {
+  registerConnectionListener(listener: AbstractConnectionListener): void;
+
+  registerMessageListener(listener: AbstractMessageListener): void;
+
+  isConnected(): boolean;
+
+  connect(): void;
+
+  disconnect(): Promise<void>;
+
+  send(duid: string, request: RequestMessage): Promise<void>;
+
+  get<T>(duid: string, request: RequestMessage): Promise<T>;
+}