matterbridge-roborock-vacuum-plugin 1.1.0-rc08 → 1.1.0-rc10

package/dist/platform.js

@@ -156,6 +156,11 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             this.log.error(`Failed to connect to local network for device: ${vacuum.name} (${vacuum.duid})`);
             return false;
         }
+        if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
+            const map_info = await this.roborockService.getMapInformation(vacuum.duid);
+            const rooms = map_info?.maps?.[0]?.rooms ?? [];
+            vacuum.rooms = rooms;
+        }
         const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
         const behaviorHandler = configurateBehavior(vacuum.data.model, vacuum.duid, this.roborockService, this.cleanModeSettings, this.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false, this.log);

package/dist/roborockCommunication/RESTAPI/roborockIoTApi.js

@@ -48,6 +48,17 @@ export class RoborockIoTApi {
             return undefined;
         }
     }
+    async getHomev3(homeId) {
+        const result = await this.api.get('v3/user/homes/' + homeId);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to retrieve the home data');
+            return undefined;
+        }
+    }
     async getScenes(homeId) {
         const result = await this.api.get('user/scene/home/' + homeId);
         const apiResponse = result.data;

package/dist/roborockCommunication/Zmodel/map.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -0,0 +1,24 @@
+import decodeComponent from '../helper/nameDecoder.js';
+export class MapInfo {
+    maps = [];
+    constructor(multimap) {
+        multimap.map_info.forEach((map) => {
+            this.maps.push({
+                id: map.mapFlag,
+                name: decodeComponent(map.name)?.toLowerCase(),
+                rooms: map.rooms.map((room) => {
+                    return {
+                        id: room.iot_name_id,
+                        name: room.iot_name,
+                    };
+                }),
+            });
+        });
+    }
+    getById(id) {
+        return this.maps.find((m) => m.id === id)?.name;
+    }
+    getByName(name) {
+        return this.maps.find((m) => m.name === name.toLowerCase())?.id;
+    }
+}

package/dist/roborockCommunication/Zmodel/multipleMap.js

@@ -0,0 +1 @@
+export {};

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -6,6 +6,7 @@ import { SyncMessageListener } from './listener/implementation/syncMessageListen
 import { ConnectionStateListener } from './listener/implementation/connectionStateListener.js';
 export class AbstractClient {
     isInDisconnectingStep = false;
+    retryCount = 0;
     connectionListeners = new ChainedConnectionListener();
     messageListeners = new ChainedMessageListener();
     serializer;
@@ -14,17 +15,18 @@ export class AbstractClient {
     logger;
     context;
     syncMessageListener;
-    connectionStateListener;
     constructor(logger, context) {
         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.connectionStateListener = new ConnectionStateListener(logger, this);
-        this.connectionListeners.register(this.connectionStateListener);
         this.logger = logger;
     }
+    initializeConnectionStateListener() {
+        const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.changeToSecureConnection, this.shouldReconnect);
+        this.connectionListeners.register(connectionStateListener);
+    }
     async get(duid, request) {
         return new Promise((resolve, reject) => {
             this.syncMessageListener.waitFor(request.messageId, (response) => resolve(response), reject);

package/dist/roborockCommunication/broadcast/client/LocalNetworkClient.js

@@ -7,22 +7,32 @@ import { AbstractClient } from '../abstractClient.js';
 import { Sequence } from '../../helper/sequence.js';
 import { ChunkBuffer } from '../../helper/chunkBuffer.js';
 export class LocalNetworkClient extends AbstractClient {
+    changeToSecureConnection;
+    clientName = 'LocalNetworkClient';
+    shouldReconnect = true;
     socket = undefined;
     buffer = new ChunkBuffer();
     messageIdSeq;
     pingInterval;
     duid;
     ip;
-    constructor(logger, context, duid, ip) {
+    constructor(logger, context, duid, ip, inject) {
         super(logger, context);
         this.duid = duid;
         this.ip = ip;
         this.messageIdSeq = new Sequence(100000, 999999);
+        this.initializeConnectionStateListener();
+        this.changeToSecureConnection = inject;
     }
     connect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+            return;
+        }
         this.socket = new Socket();
         this.socket.on('close', this.onDisconnect.bind(this));
-        this.socket.on('end', this.onDisconnect.bind(this));
+        this.socket.on('end', this.onEnd.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));
@@ -55,6 +65,19 @@ export class LocalNetworkClient extends AbstractClient {
         await this.sendHelloMessage();
         this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         await this.connectionListeners.onConnected(this.duid);
+        this.retryCount = 0;
+    }
+    async onEnd() {
+        this.logger.notice('LocalNetworkClient: Socket has ended.');
+        this.connected = false;
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        await this.connectionListeners.onDisconnected(this.duid);
     }
     async onDisconnect() {
         this.logger.notice('LocalNetworkClient: Socket has disconnected.');

package/dist/roborockCommunication/broadcast/client/MQTTClient.js

@@ -3,6 +3,9 @@ import * as CryptoUtils from '../../helper/cryptoHelper.js';
 import { AbstractClient } from '../abstractClient.js';
 import { debugStringify } from 'matterbridge/logger';
 export class MQTTClient extends AbstractClient {
+    changeToSecureConnection;
+    clientName = 'MQTTClient';
+    shouldReconnect = false;
     rriot;
     mqttUsername;
     mqttPassword;
@@ -12,6 +15,10 @@ export class MQTTClient extends AbstractClient {
         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);
+        this.initializeConnectionStateListener();
+        this.changeToSecureConnection = (duid) => {
+            this.logger.info(`MqttClient for ${duid} has been disconnected`);
+        };
     }
     connect() {
         if (this.client) {

package/dist/roborockCommunication/broadcast/clientRouter.js

@@ -20,8 +20,8 @@ export class ClientRouter {
     registerDevice(duid, localKey, pv) {
         this.context.registerDevice(duid, localKey, pv);
     }
-    registerClient(duid, ip) {
-        const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);
+    registerClient(duid, ip, onDisconnect) {
+        const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip, onDisconnect);
         localClient.registerConnectionListener(this.connectionListeners);
         localClient.registerMessageListener(this.messageListeners);
         this.localClients.set(duid, localClient);

package/dist/roborockCommunication/broadcast/listener/implementation/connectionStateListener.js

@@ -1,21 +1,36 @@
 export class ConnectionStateListener {
     logger;
     client;
-    constructor(logger, client) {
+    clientName;
+    shouldReconnect;
+    changeToSecureConnection;
+    constructor(logger, client, clientName, changeToSecureConnection, shouldReconnect = false) {
         this.logger = logger;
         this.client = client;
+        this.clientName = clientName;
+        this.shouldReconnect = shouldReconnect;
+        this.changeToSecureConnection = changeToSecureConnection;
     }
     async onConnected(duid) {
-        this.logger.notice(`Device ${duid} connected to MQTT broker`);
+        this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
     }
     async onDisconnected(duid) {
-        this.logger.notice(`Device ${duid} disconnected from MQTT broker`);
+        if (!this.shouldReconnect) {
+            this.logger.notice(`Device ${duid} disconnected from ${this.clientName}, but re-registration is disabled.`);
+            return;
+        }
+        if (this.client.retryCount > 10) {
+            this.logger.error(`Device with DUID ${duid} has exceeded retry limit, not re-registering.`);
+            this.changeToSecureConnection(duid);
+            return;
+        }
+        this.client.retryCount++;
         const isInDisconnectingStep = this.client.isInDisconnectingStep;
         if (isInDisconnectingStep) {
             this.logger.info(`Device with DUID ${duid} is in disconnecting step, skipping re-registration.`);
             return;
         }
-        this.logger.info(`Re-registering device with DUID ${duid} to MQTT broker`);
+        this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
         this.client.connect();
         this.client.isInDisconnectingStep = false;
     }

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -56,14 +56,14 @@ export class MessageDeserializer {
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
         if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
-            return this.deserializeProtocolRpcResponse(duid, data);
+            return this.deserializeRpcResponse(duid, data);
         }
         else {
             this.logger.error('unknown protocol: ' + data.protocol);
             return new ResponseMessage(duid, { dps: { id: 0, result: null } });
         }
     }
-    deserializeProtocolRpcResponse(duid, data) {
+    deserializeRpcResponse(duid, data) {
         const payload = JSON.parse(data.payload.toString());
         const dps = payload.dps;
         this.parseJsonInDps(dps, Protocol.general_request);

package/dist/roborockCommunication/index.js

@@ -7,4 +7,5 @@ export { Protocol } from './broadcast/model/protocol.js';
 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 { Scene } from './Zmodel/scene.js';

package/dist/roborockService.js

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 import { debugStringify } from 'matterbridge/logger';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
 import { clearInterval } from 'node:timers';
-import { RoborockAuthenticateApi, RoborockIoTApi, MessageProcessor, Protocol, RequestMessage, ResponseMessage, } from './roborockCommunication/index.js';
+import { RoborockAuthenticateApi, RoborockIoTApi, MessageProcessor, Protocol, RequestMessage, ResponseMessage, MapInfo, } from './roborockCommunication/index.js';
 export default class RoborockService {
     loginApi;
     logger;
@@ -69,6 +69,17 @@ export default class RoborockService {
         }
         return data;
     }
+    async getRoomIdFromMap(duid) {
+        const data = (await this.customGet(duid, new RequestMessage({ method: 'get_map_v1' })));
+        return data?.vacuumRoom;
+    }
+    async getMapInformation(duid) {
+        this.logger.debug('RoborockService - getMapInformation', duid);
+        assert(this.messageClient !== undefined);
+        return this.messageClient.get(duid, new RequestMessage({ method: 'get_multi_maps_list' })).then((response) => {
+            return new MapInfo(response[0]);
+        });
+    }
     async changeCleanMode(duid, { suctionPower, waterFlow, distance_off, mopRoute }) {
         this.logger.notice('RoborockService - changeCleanMode');
         return this.getMessageProcessor(duid)?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
@@ -129,13 +140,9 @@ export default class RoborockService {
         this.logger.debug('RoborockService - findMe');
         await this.getMessageProcessor(duid)?.findMyRobot(duid);
     }
-    async customGet(duid, method) {
-        this.logger.debug('RoborockService - customSend-message', method);
-        return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method }));
-    }
-    async customGetInSecure(duid, method) {
-        this.logger.debug('RoborockService - customGetInSecure-message', method);
-        return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
+    async customGet(duid, request) {
+        this.logger.debug('RoborockService - customSend-message', request.method, request.params, request.secure);
+        return this.getMessageProcessor(duid)?.getCustomMessage(duid, request);
     }
     async customSend(duid, request) {
         return this.getMessageProcessor(duid)?.sendCustomMessage(duid, request);
@@ -201,6 +208,18 @@ export default class RoborockService {
         const scenes = (await this.iotApi.getScenes(homeDetails.rrHomeId)) ?? [];
         const products = new Map();
         homeData.products.forEach((p) => products.set(p.id, p.model));
+        if (homeData.rooms.length === 0) {
+            const homeDataV2 = await this.iotApi.getHomev2(homeDetails.rrHomeId);
+            if (homeDataV2 && homeDataV2.rooms && homeDataV2.rooms.length > 0) {
+                homeData.rooms = homeDataV2.rooms;
+            }
+            else {
+                const homeDataV3 = await this.iotApi.getHomev3(homeDetails.rrHomeId);
+                if (homeDataV3 && homeDataV3.rooms && homeDataV3.rooms.length > 0) {
+                    homeData.rooms = homeDataV3.rooms;
+                }
+            }
+        }
         const devices = [...homeData.devices, ...homeData.receivedDevices];
         const result = devices.map((device) => {
             return {
@@ -347,7 +366,7 @@ export default class RoborockService {
             }
             if (localIp) {
                 this.logger.debug('initializing the local connection for this client towards ' + localIp);
-                const localClient = this.messageClient.registerClient(device.duid, localIp);
+                const localClient = this.messageClient.registerClient(device.duid, localIp, this.onLocalClientDisconnect);
                 localClient.connect();
                 let count = 0;
                 while (!localClient.isConnected() && count < 20) {
@@ -369,6 +388,9 @@ export default class RoborockService {
         }
         return true;
     }
+    onLocalClientDisconnect(duid) {
+        this.logger.debug('Local client disconnected for device', duid);
+    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }

package/matterbridge-roborock-vacuum-plugin.config.json

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc08",
+  "version": "1.1.0-rc10",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,

package/matterbridge-roborock-vacuum-plugin.schema.json

@@ -1,6 +1,6 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc08 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc10 by https://github.com/RinDevJunior",
   "type": "object",
   "required": ["username", "password"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc08",
+  "version": "1.1.0-rc10",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/platform.ts

@@ -223,6 +223,12 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       return false;
     }
 
+    if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
+      const map_info = await this.roborockService.getMapInformation(vacuum.duid);
+      const rooms = map_info?.maps?.[0]?.rooms ?? [];
+      vacuum.rooms = rooms;
+    }
+
     const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
 
     this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));

package/src/roborockCommunication/RESTAPI/roborockIoTApi.ts

@@ -57,6 +57,18 @@ export class RoborockIoTApi {
     }
   }
 
+  public async getHomev3(homeId: number): Promise<Home | undefined> {
+    const result = await this.api.get('v3/user/homes/' + homeId); // can be v3 also
+
+    const apiResponse: ApiResponse<Home> = result.data;
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to retrieve the home data');
+      return undefined;
+    }
+  }
+
   public async getScenes(homeId: number): Promise<Scene[] | undefined> {
     const result = await this.api.get('user/scene/home/' + homeId);
 

package/src/roborockCommunication/Zmodel/map.ts

@@ -0,0 +1,14 @@
+export interface Map {
+  mapFlag: number;
+  add_time: number;
+  length: number;
+  name: string;
+  rooms: RoomInformation[];
+}
+
+export interface RoomInformation {
+  id: number;
+  tag: number;
+  iot_name_id: string;
+  iot_name: string;
+}

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -0,0 +1,31 @@
+import decodeComponent from '../helper/nameDecoder.js';
+import { RoomInformation } from './map.js';
+import type { MultipleMap } from './multipleMap.js';
+import { Room } from './room.js';
+
+export class MapInfo {
+  readonly maps: { id: number; name: string | undefined; rooms: Room[] }[] = [];
+
+  constructor(multimap: MultipleMap) {
+    multimap.map_info.forEach((map) => {
+      this.maps.push({
+        id: map.mapFlag,
+        name: decodeComponent(map.name)?.toLowerCase(),
+        rooms: map.rooms.map((room: RoomInformation) => {
+          return {
+            id: room.iot_name_id,
+            name: room.iot_name,
+          } as unknown as Room;
+        }),
+      });
+    });
+  }
+
+  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 === name.toLowerCase())?.id;
+  }
+}

package/src/roborockCommunication/Zmodel/multipleMap.ts

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

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -14,6 +14,7 @@ import { ConnectionStateListener } from './listener/implementation/connectionSta
 
 export abstract class AbstractClient implements Client {
   public isInDisconnectingStep = false;
+  public retryCount = 0;
 
   protected readonly connectionListeners = new ChainedConnectionListener();
   protected readonly messageListeners = new ChainedMessageListener();
@@ -22,9 +23,12 @@ export abstract class AbstractClient implements Client {
   protected connected = false;
   protected logger: AnsiLogger;
 
+  protected abstract clientName: string;
+  protected abstract shouldReconnect: boolean;
+  protected abstract changeToSecureConnection: (duid: string) => void;
+
   private readonly context: MessageContext;
   private readonly syncMessageListener: SyncMessageListener;
-  private readonly connectionStateListener: ConnectionStateListener;
 
   protected constructor(logger: AnsiLogger, context: MessageContext) {
     this.context = context;
@@ -33,13 +37,14 @@ export abstract class AbstractClient implements Client {
 
     this.syncMessageListener = new SyncMessageListener(logger);
     this.messageListeners.register(this.syncMessageListener);
-
-    this.connectionStateListener = new ConnectionStateListener(logger, this);
-    this.connectionListeners.register(this.connectionStateListener);
-
     this.logger = logger;
   }
 
+  protected initializeConnectionStateListener() {
+    const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.changeToSecureConnection, this.shouldReconnect);
+    this.connectionListeners.register(connectionStateListener);
+  }
+
   abstract connect(): void;
   abstract disconnect(): Promise<void>;
   abstract send(duid: string, request: RequestMessage): Promise<void>;

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

@@ -9,6 +9,10 @@ import { Sequence } from '../../helper/sequence.js';
 import { ChunkBuffer } from '../../helper/chunkBuffer.js';
 
 export class LocalNetworkClient extends AbstractClient {
+  protected override changeToSecureConnection: (duid: string) => void;
+  protected override clientName = 'LocalNetworkClient';
+  protected override shouldReconnect = true;
+
   private socket: Socket | undefined = undefined;
   private buffer: ChunkBuffer = new ChunkBuffer();
   private messageIdSeq: Sequence;
@@ -16,17 +20,26 @@ export class LocalNetworkClient extends AbstractClient {
   duid: string;
   ip: string;
 
-  public constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string) {
+  constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string, inject: (duid: string) => void) {
     super(logger, context);
     this.duid = duid;
     this.ip = ip;
     this.messageIdSeq = new Sequence(100000, 999999);
+
+    this.initializeConnectionStateListener();
+    this.changeToSecureConnection = inject;
   }
 
   public connect(): void {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = undefined;
+      return;
+    }
+
     this.socket = new Socket();
     this.socket.on('close', this.onDisconnect.bind(this));
-    this.socket.on('end', this.onDisconnect.bind(this));
+    this.socket.on('end', this.onEnd.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));
@@ -66,6 +79,22 @@ export class LocalNetworkClient extends AbstractClient {
     await this.sendHelloMessage();
     this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
     await this.connectionListeners.onConnected(this.duid);
+    this.retryCount = 0;
+  }
+
+  private async onEnd(): Promise<void> {
+    this.logger.notice('LocalNetworkClient: Socket has ended.');
+    this.connected = false;
+
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = undefined;
+    }
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+
+    await this.connectionListeners.onDisconnected(this.duid);
   }
 
   private async onDisconnect(): Promise<void> {

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

@@ -7,6 +7,10 @@ import { Rriot, UserData } from '../../Zmodel/userData.js';
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 
 export class MQTTClient extends AbstractClient {
+  protected override changeToSecureConnection: (duid: string) => void;
+  protected override clientName = 'MQTTClient';
+  protected override shouldReconnect = false;
+
   private readonly rriot: Rriot;
   private readonly mqttUsername: string;
   private readonly mqttPassword: string;
@@ -18,6 +22,11 @@ export class MQTTClient extends AbstractClient {
 
     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);
+
+    this.initializeConnectionStateListener();
+    this.changeToSecureConnection = (duid: string) => {
+      this.logger.info(`MqttClient for ${duid} has been disconnected`);
+    };
   }
 
   public connect(): void {

package/src/roborockCommunication/broadcast/clientRouter.ts

@@ -32,8 +32,8 @@ export class ClientRouter implements Client {
     this.context.registerDevice(duid, localKey, pv);
   }
 
-  public registerClient(duid: string, ip: string): Client {
-    const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);
+  public registerClient(duid: string, ip: string, onDisconnect: (duid: string) => void): Client {
+    const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip, onDisconnect);
     localClient.registerConnectionListener(this.connectionListeners);
     localClient.registerMessageListener(this.messageListeners);
 

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

@@ -5,17 +5,35 @@ import { AbstractClient } from '../../abstractClient.js';
 export class ConnectionStateListener implements AbstractConnectionListener {
   protected logger: AnsiLogger;
   protected client: AbstractClient;
-  constructor(logger: AnsiLogger, client: AbstractClient) {
+  protected clientName: string;
+  protected shouldReconnect: boolean;
+  protected changeToSecureConnection: (duid: string) => void;
+
+  constructor(logger: AnsiLogger, client: AbstractClient, clientName: string, changeToSecureConnection: (duid: string) => void, shouldReconnect = false) {
     this.logger = logger;
     this.client = client;
+    this.clientName = clientName;
+    this.shouldReconnect = shouldReconnect;
+    this.changeToSecureConnection = changeToSecureConnection;
   }
 
   public async onConnected(duid: string): Promise<void> {
-    this.logger.notice(`Device ${duid} connected to MQTT broker`);
+    this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
   }
 
   public async onDisconnected(duid: string): Promise<void> {
-    this.logger.notice(`Device ${duid} disconnected from MQTT broker`);
+    if (!this.shouldReconnect) {
+      this.logger.notice(`Device ${duid} disconnected from ${this.clientName}, but re-registration is disabled.`);
+      return;
+    }
+
+    if (this.client.retryCount > 10) {
+      this.logger.error(`Device with DUID ${duid} has exceeded retry limit, not re-registering.`);
+      this.changeToSecureConnection(duid);
+      return;
+    }
+
+    this.client.retryCount++;
 
     const isInDisconnectingStep = this.client.isInDisconnectingStep;
     if (isInDisconnectingStep) {
@@ -23,7 +41,7 @@ export class ConnectionStateListener implements AbstractConnectionListener {
       return;
     }
 
-    this.logger.info(`Re-registering device with DUID ${duid} to MQTT broker`);
+    this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
     this.client.connect();
 
     this.client.isInDisconnectingStep = false;

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -79,14 +79,14 @@ export class MessageDeserializer {
     }
 
     if (data.protocol == Protocol.rpc_response || data.protocol == Protocol.general_request) {
-      return this.deserializeProtocolRpcResponse(duid, data);
+      return this.deserializeRpcResponse(duid, data);
     } else {
       this.logger.error('unknown protocol: ' + data.protocol);
       return new ResponseMessage(duid, { dps: { id: 0, result: null } });
     }
   }
 
-  private deserializeProtocolRpcResponse(duid: string, data: Message): ResponseMessage {
+  private deserializeRpcResponse(duid: string, data: Message): ResponseMessage {
     const payload = JSON.parse(data.payload.toString());
     const dps = payload.dps;
     this.parseJsonInDps(dps, Protocol.general_request);

package/src/roborockCommunication/index.ts

@@ -7,6 +7,7 @@ export { Protocol } from './broadcast/model/protocol.js';
 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 { Scene } from './Zmodel/scene.js';
 
@@ -18,3 +19,4 @@ export type { Home } from './Zmodel/home.js';
 export type { Client } from './broadcast/client.js';
 export type { SceneParam } from './Zmodel/scene.js';
 export type { BatteryMessage, DeviceErrorMessage, DeviceStatusNotify } from './Zmodel/batteryMessage.js';
+export type { MultipleMap } from './Zmodel/multipleMap.js';

package/src/roborockService.ts

@@ -19,8 +19,9 @@ import {
   ResponseMessage,
   Scene,
   SceneParam,
+  MapInfo,
 } from './roborockCommunication/index.js';
-import type { AbstractMessageHandler, AbstractMessageListener, BatteryMessage, DeviceErrorMessage, DeviceStatusNotify } from './roborockCommunication/index.js';
+import type { AbstractMessageHandler, AbstractMessageListener, BatteryMessage, DeviceErrorMessage, DeviceStatusNotify, MultipleMap } from './roborockCommunication/index.js';
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import { LocalNetworkClient } from './roborockCommunication/broadcast/client/LocalNetworkClient.js';
 export type Factory<A, T> = (logger: AnsiLogger, arg: A) => T;
@@ -115,6 +116,19 @@ export default class RoborockService {
     return data;
   }
 
+  public async getRoomIdFromMap(duid: string): Promise<number | undefined> {
+    const data = (await this.customGet(duid, new RequestMessage({ method: 'get_map_v1' }))) as { vacuumRoom: number | undefined };
+    return data?.vacuumRoom;
+  }
+
+  public async getMapInformation(duid: string): Promise<MapInfo> {
+    this.logger.debug('RoborockService - getMapInformation', duid);
+    assert(this.messageClient !== undefined);
+    return this.messageClient.get<MultipleMap[]>(duid, new RequestMessage({ method: 'get_multi_maps_list' })).then((response) => {
+      return new MapInfo(response[0]);
+    });
+  }
+
   public async changeCleanMode(
     duid: string,
     { suctionPower, waterFlow, distance_off, mopRoute }: { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number },
@@ -189,14 +203,9 @@ export default class RoborockService {
     await this.getMessageProcessor(duid)?.findMyRobot(duid);
   }
 
-  public async customGet(duid: string, method: string): Promise<unknown> {
-    this.logger.debug('RoborockService - customSend-message', method);
-    return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method }));
-  }
-
-  public async customGetInSecure(duid: string, method: string): Promise<unknown> {
-    this.logger.debug('RoborockService - customGetInSecure-message', method);
-    return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
+  public async customGet(duid: string, request: RequestMessage): Promise<unknown> {
+    this.logger.debug('RoborockService - customSend-message', request.method, request.params, request.secure);
+    return this.getMessageProcessor(duid)?.getCustomMessage(duid, request);
   }
 
   public async customSend(duid: string, request: RequestMessage): Promise<void> {
@@ -274,6 +283,20 @@ export default class RoborockService {
 
     const products = new Map<string, string>();
     homeData.products.forEach((p) => products.set(p.id, p.model));
+
+    // Try to get rooms from v2 API if rooms are empty
+    if (homeData.rooms.length === 0) {
+      const homeDataV2 = await this.iotApi.getHomev2(homeDetails.rrHomeId);
+      if (homeDataV2 && homeDataV2.rooms && homeDataV2.rooms.length > 0) {
+        homeData.rooms = homeDataV2.rooms;
+      } else {
+        const homeDataV3 = await this.iotApi.getHomev3(homeDetails.rrHomeId);
+        if (homeDataV3 && homeDataV3.rooms && homeDataV3.rooms.length > 0) {
+          homeData.rooms = homeDataV3.rooms;
+        }
+      }
+    }
+
     const devices: Device[] = [...homeData.devices, ...homeData.receivedDevices];
     // homeData.devices.length > 0 ? homeData.devices : homeData.receivedDevices;
 
@@ -457,7 +480,7 @@ export default class RoborockService {
 
       if (localIp) {
         this.logger.debug('initializing the local connection for this client towards ' + localIp);
-        const localClient = this.messageClient.registerClient(device.duid, localIp) as LocalNetworkClient;
+        const localClient = this.messageClient.registerClient(device.duid, localIp, this.onLocalClientDisconnect) as LocalNetworkClient;
         localClient.connect();
 
         let count = 0;
@@ -483,6 +506,11 @@ export default class RoborockService {
     return true;
   }
 
+  private onLocalClientDisconnect(duid: string): void {
+    // this.mqttAlwaysOnDevices.set(duid, true);
+    this.logger.debug('Local client disconnected for device', duid);
+  }
+
   private sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }

package/src/tests/roborockService.test.ts

@@ -2,7 +2,7 @@ import { AnsiLogger } from 'matterbridge/logger';
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import RoborockService from '../roborockService';
 import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
-import { Device } from '../roborockCommunication';
+import { Device, RequestMessage } from '../roborockCommunication';
 
 describe('RoborockService - startClean', () => {
   let roborockService: RoborockService;
@@ -316,20 +316,12 @@ describe('RoborockService - customGet/customGetInSecure/customSend', () => {
 
   it('customGet should call getCustomMessage', async () => {
     mockMessageProcessor.getCustomMessage.mockResolvedValue('result');
-    const result = await roborockService.customGet('duid', 'method');
-    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customSend-message', 'method');
+    const result = await roborockService.customGet('duid', { method: 'method', params: undefined, secure: true } as RequestMessage);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customSend-message', 'method', undefined, true);
     expect(mockMessageProcessor.getCustomMessage).toHaveBeenCalledWith('duid', expect.any(Object));
     expect(result).toBe('result');
   });
 
-  it('customGetInSecure should call getCustomMessage with secure', async () => {
-    mockMessageProcessor.getCustomMessage.mockResolvedValue('secureResult');
-    const result = await roborockService.customGetInSecure('duid', 'method');
-    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customGetInSecure-message', 'method');
-    expect(mockMessageProcessor.getCustomMessage).toHaveBeenCalledWith('duid', expect.objectContaining({ secure: true }));
-    expect(result).toBe('secureResult');
-  });
-
   it('customSend should call sendCustomMessage', async () => {
     const req = { foo: 'bar' } as any;
     await roborockService.customSend('duid', req);