matterbridge-roborock-vacuum-plugin 1.1.0-rc12 → 1.1.0-rc13

package/dist/initialData/getSupportedAreas.js

@@ -1,10 +1,10 @@
 import { debugStringify } from 'matterbridge/logger';
 import { randomInt } from 'node:crypto';
-export function getSupportedAreas(rooms, roomMap, log) {
-    log?.debug('getSupportedAreas', debugStringify(rooms));
-    log?.debug('getSupportedAreas', roomMap ? debugStringify(roomMap) : 'undefined');
-    if (!rooms || rooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
-        if (!rooms || rooms.length === 0) {
+export function getSupportedAreas(vacuumRooms, roomMap, log) {
+    log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
+    log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
+    if (!vacuumRooms || vacuumRooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
+        if (!vacuumRooms || vacuumRooms.length === 0) {
             log?.error('No rooms found');
         }
         if (!roomMap || !roomMap.rooms || roomMap.rooms.length == 0) {
@@ -31,7 +31,7 @@ export function getSupportedAreas(rooms, roomMap, log) {
             mapId: null,
             areaInfo: {
                 locationInfo: {
-                    locationName: room.displayName ?? rooms.find((r) => r.id == room.globalId)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
+                    locationName: room.displayName ?? vacuumRooms.find((r) => r.id == room.globalId || r.id == room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
                     floorNumber: null,
                     areaType: null,
                 },
@@ -39,6 +39,7 @@ export function getSupportedAreas(rooms, roomMap, log) {
             },
         };
     });
+    log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
     const duplicated = findDuplicatedAreaIds(supportedAreas, log);
     return duplicated
         ? [

package/dist/model/RoomMap.js

@@ -6,6 +6,7 @@ export default class RoomMap {
                 id: entry[0],
                 globalId: Number(entry[1]),
                 displayName: rooms.find((r) => Number(r.id) == Number(entry[1]))?.name,
+                alternativeId: `${entry[0]}${entry[2]}`,
             };
         });
     }

package/dist/platform.js

@@ -157,10 +157,10 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             return false;
         }
         if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
-            this.log.error(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
+            this.log.notice(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
             const map_info = await this.roborockService.getMapInformation(vacuum.duid);
             const rooms = map_info?.maps?.[0]?.rooms ?? [];
-            vacuum.rooms = rooms;
+            vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }));
         }
         const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
         this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));

package/dist/platformRunner.js

@@ -35,18 +35,25 @@ export class PlatformRunner {
     async getRoomMapFromDevice(device) {
         const platform = this.platform;
         const rooms = device?.rooms ?? [];
-        platform.log.error(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
+        platform.log.notice('-------------------------------------------0--------------------------------------------------------');
+        platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
         if (device && platform.roborockService) {
             const roomData = await platform.roborockService.getRoomMappings(device.duid);
             if (roomData !== undefined && roomData.length > 0) {
-                platform.log.error(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-                return new RoomMap(roomData ?? [], rooms);
+                platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+                const roomMap = new RoomMap(roomData ?? [], rooms);
+                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+                platform.log.notice('-------------------------------------------1--------------------------------------------------------');
+                return roomMap;
             }
             const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+            platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
             if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-                platform.log.error(`getRoomMapFromDevice - mapInfo: ${debugStringify(mapInfo.maps)}`);
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.name)]);
-                return new RoomMap(roomDataMap, rooms);
+                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
+                const roomMap = new RoomMap(roomDataMap, rooms);
+                platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+                platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+                return roomMap;
             }
         }
         return new RoomMap([], rooms);
@@ -72,7 +79,7 @@ export class PlatformRunner {
             const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
             if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
                 platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
-                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.name)]);
+                const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag]);
                 robot.roomInfo = new RoomMap(roomDataMap, rooms);
             }
         }
@@ -129,21 +136,40 @@ export class PlatformRunner {
                     if (state) {
                         robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
                     }
-                    const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-                    const roomMap = await this.getRoomMap(duid);
-                    const targetRoom = data.cleaning_info?.target_segment_id ?? -1;
-                    const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == targetRoom);
-                    if (targetRoom !== -1 && isTargetMappedArea) {
-                        this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-                        this.platform.log.debug(`TargetRoom: ${targetRoom}, room name: ${roomMap?.rooms.find((x) => x.id === targetRoom)?.displayName ?? 'unknown'}`);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', targetRoom, platform.log);
+                    if (data.state === OperationStatusCode.Idle) {
+                        const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
+                        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
                     }
-                    const currentRoom = data.cleaning_info?.segment_id ?? -1;
-                    const isMappedArea = currentMappedAreas?.some((x) => x.areaId == currentRoom);
-                    if (currentRoom !== -1 && isMappedArea) {
-                        this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-                        this.platform.log.debug(`CurrentRoom: ${currentRoom}, room name: ${roomMap?.rooms.find((x) => x.id === currentRoom)?.displayName ?? 'unknown'}`);
-                        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', currentRoom, platform.log);
+                    if (state === RvcRunMode.ModeTag.Cleaning && !data.cleaning_info) {
+                        robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+                        robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+                    }
+                    else {
+                        const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
+                        const roomMap = await this.getRoomMap(duid);
+                        const segment_id = data.cleaning_info?.segment_id ?? -1;
+                        const target_segment_id = data.cleaning_info?.target_segment_id ?? -1;
+                        let target_room_id = roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.id ?? -1;
+                        this.platform.log.debug(`Target segment id: ${segment_id}, targetRoom: ${target_room_id}`);
+                        const isMappedArea = currentMappedAreas?.some((x) => x.areaId == segment_id);
+                        if (segment_id !== -1 && isMappedArea) {
+                            this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+                            this.platform.log.debug(`Part1: CurrentRoom: ${segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`);
+                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', segment_id, platform.log);
+                        }
+                        if (segment_id == -1) {
+                            const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == target_segment_id);
+                            target_room_id = roomMap?.rooms.find((x) => x.id == target_segment_id || x.alternativeId === target_segment_id.toString())?.id ?? -1;
+                            this.platform.log.debug(`Target segment id: ${target_segment_id}, targetRoom: ${target_room_id}`);
+                            if (target_segment_id !== -1 && isTargetMappedArea) {
+                                this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+                                this.platform.log.debug(`Part2: TargetRoom: ${target_segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === target_segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`);
+                                robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', target_segment_id, platform.log);
+                            }
+                        }
+                        if (target_segment_id == -1 && segment_id == -1) {
+                            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+                        }
                     }
                     if (data.battery) {
                         const batteryLevel = data.battery;
@@ -156,9 +182,11 @@ export class PlatformRunner {
                         waterFlow: data.cleaning_info?.water_box_status ?? data.water_box_mode,
                         distance_off: data.distance_off,
                         mopRoute: data.cleaning_info?.mop_mode ?? data.mop_mode,
+                        segment_id: data.cleaning_info?.segment_id,
+                        target_segment_id: data.cleaning_info?.target_segment_id,
                     };
                     this.platform.log.debug(`data: ${debugStringify(data)}`);
-                    this.platform.log.debug(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
+                    this.platform.log.notice(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
                     if (currentCleanModeSetting.mopRoute && currentCleanModeSetting.suctionPower && currentCleanModeSetting.waterFlow) {
                         const currentCleanMode = getCurrentCleanModeFunc(deviceData.model, this.platform.enableExperimentalFeature?.advancedFeature?.forceRunAtDefault ?? false)(currentCleanModeSetting);
                         this.platform.log.debug(`Current clean mode: ${currentCleanMode}`);
@@ -248,7 +276,7 @@ export class PlatformRunner {
                     break;
                 }
                 default: {
-                    platform.log.notice(`Unknown message type: ${Protocol[messageType] ?? messageType} ,`, debugStringify(data));
+                    platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
                     break;
                 }
             }

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -10,7 +10,9 @@ export class MapInfo {
                     ? map.rooms.map((room) => {
                         return {
                             id: room.id,
-                            name: room.iot_name_id,
+                            iot_name_id: room.iot_name_id,
+                            tag: room.tag,
+                            displayName: room.iot_name,
                         };
                     })
                     : [],

package/dist/roborockCommunication/broadcast/abstractClient.js

@@ -24,7 +24,7 @@ export class AbstractClient {
         this.logger = logger;
     }
     initializeConnectionStateListener() {
-        const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.changeToSecureConnection, this.shouldReconnect);
+        const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.shouldReconnect);
         this.connectionListeners.register(connectionStateListener);
     }
     async get(duid, request) {

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

@@ -7,7 +7,6 @@ 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;
@@ -16,26 +15,25 @@ export class LocalNetworkClient extends AbstractClient {
     pingInterval;
     duid;
     ip;
-    constructor(logger, context, duid, ip, inject) {
+    constructor(logger, context, duid, ip) {
         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.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));
         this.socket.on('data', this.onMessage.bind(this));
-        this.socket.connect(58867, this.ip, this.onConnect.bind(this));
+        this.socket.connect(58867, this.ip);
     }
     async disconnect() {
         if (!this.socket) {
@@ -50,7 +48,7 @@ export class LocalNetworkClient extends AbstractClient {
     }
     async send(duid, request) {
         if (!this.socket || !this.connected) {
-            this.logger.error(`${duid}: socket is not online, ${debugStringify(request)}`);
+            this.logger.error(`${duid}: socket is not online, , ${debugStringify(request)}`);
             return;
         }
         const localRequest = request.toLocalRequest();
@@ -59,16 +57,29 @@ export class LocalNetworkClient extends AbstractClient {
         this.socket.write(this.wrapWithLengthData(message.buffer));
     }
     async onConnect() {
+        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;
-        const address = this.socket?.address();
-        this.logger.debug(`${this.duid} connected to ${this.ip}, address: ${address ? debugStringify(address) : 'undefined'}`);
+        this.retryCount = 0;
         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.');
+        await this.destroySocket('Socket has ended.');
+        await this.connectionListeners.onDisconnected(this.duid, 'Socket has ended.');
+    }
+    async onDisconnect(hadError) {
+        await this.destroySocket(`Socket disconnected. Had error: ${hadError}`);
+        if (!hadError) {
+            await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
+        }
+    }
+    async onTimeout() {
+        this.logger.error(`LocalNetworkClient: Socket for ${this.duid} timed out.`);
+    }
+    async destroySocket(message) {
+        this.logger.error(`LocalNetworkClient: Destroying socket for ${this.duid} due to: ${message}`);
         this.connected = false;
         if (this.socket) {
             this.socket.destroy();
@@ -77,10 +88,9 @@ export class LocalNetworkClient extends AbstractClient {
         if (this.pingInterval) {
             clearInterval(this.pingInterval);
         }
-        await this.connectionListeners.onDisconnected(this.duid);
     }
-    async onDisconnect() {
-        this.logger.notice('LocalNetworkClient: Socket has disconnected.');
+    async onError(error) {
+        this.logger.error('LocalNetworkClient: Socket connection error: ' + error.message);
         this.connected = false;
         if (this.socket) {
             this.socket.destroy();
@@ -89,20 +99,10 @@ export class LocalNetworkClient extends AbstractClient {
         if (this.pingInterval) {
             clearInterval(this.pingInterval);
         }
-        await this.connectionListeners.onDisconnected(this.duid);
-    }
-    async onError(result) {
-        this.logger.error('LocalNetworkClient: Socket connection error: ' + result);
-        this.connected = false;
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = undefined;
-        }
-        await this.connectionListeners.onError(this.duid, result.toString());
+        await this.connectionListeners.onError(this.duid, error.message);
     }
     async onMessage(message) {
         if (!this.socket) {
-            this.logger.error('unable to receive data if there is no socket available');
             return;
         }
         if (!message || message.length == 0) {

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

@@ -0,0 +1,129 @@
+import * as dgram from 'node:dgram';
+import { Parser } from 'binary-parser';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { AbstractClient } from '../abstractClient.js';
+export class LocalNetworkUDPClient extends AbstractClient {
+    clientName = 'LocalNetworkUDPClient';
+    shouldReconnect = false;
+    PORT = 58866;
+    server = undefined;
+    V10Parser;
+    L01Parser;
+    constructor(logger, context) {
+        super(logger, context);
+        this.V10Parser = new Parser()
+            .endianness('big')
+            .string('version', { length: 3 })
+            .uint32('seq')
+            .uint16('protocol')
+            .uint16('payloadLen')
+            .buffer('payload', { length: 'payloadLen' })
+            .uint32('crc32');
+        this.L01Parser = new Parser()
+            .endianness('big')
+            .string('version', { length: 3 })
+            .string('field1', { length: 4 })
+            .string('field2', { length: 2 })
+            .uint16('payloadLen')
+            .buffer('payload', { length: 'payloadLen' })
+            .uint32('crc32');
+        this.logger = logger;
+    }
+    connect() {
+        try {
+            this.server = dgram.createSocket('udp4');
+            this.server.bind(this.PORT);
+            this.server.on('message', this.onMessage.bind(this));
+            this.server.on('error', this.onError.bind(this));
+        }
+        catch (err) {
+            this.logger.error(`Failed to create UDP socket: ${err}`);
+            this.server = undefined;
+        }
+    }
+    disconnect() {
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server?.close(() => {
+                    this.server = undefined;
+                    resolve();
+                });
+            });
+        }
+        return Promise.resolve();
+    }
+    send(duid, request) {
+        this.logger.debug(`Sending request to ${duid}: ${JSON.stringify(request)}`);
+        return Promise.resolve();
+    }
+    async onError(result) {
+        this.logger.error(`UDP socket error: ${result}`);
+        if (this.server) {
+            this.server.close();
+            this.server = undefined;
+        }
+    }
+    async onMessage(buffer) {
+        const message = await this.deserializeMessage(buffer);
+        this.logger.debug('Received message: ' + JSON.stringify(message));
+    }
+    async deserializeMessage(buffer) {
+        const version = buffer.toString('latin1', 0, 3);
+        if (version !== '1.0' && version !== 'L01' && version !== 'A01') {
+            throw new Error('unknown protocol version ' + version);
+        }
+        let data;
+        switch (version) {
+            case '1.0':
+                data = await this.deserializeV10Message(buffer);
+                return JSON.parse(data);
+            case 'L01':
+                data = await this.deserializeL01Message(buffer);
+                return JSON.parse(data);
+            case 'A01':
+                return undefined;
+            default:
+                throw new Error('unknown protocol version ' + version);
+        }
+    }
+    async deserializeV10Message(message) {
+        const data = this.V10Parser.parse(message);
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = data.crc32;
+        if (crc32 != expectedCrc32) {
+            throw new Error('wrong CRC32 ' + crc32 + ', expected ' + expectedCrc32);
+        }
+        const decipher = crypto.createDecipheriv('aes-128-ecb', Buffer.from('qWKYcdQWrbm9hPqe', 'utf8'), null);
+        decipher.setAutoPadding(false);
+        let decrypted = decipher.update(data.payload, 'binary', 'utf8');
+        decrypted += decipher.final('utf8');
+        const paddingLength = decrypted.charCodeAt(decrypted.length - 1);
+        return decrypted.slice(0, -paddingLength);
+    }
+    async deserializeL01Message(message) {
+        const data = this.L01Parser.parse(message);
+        const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
+        const expectedCrc32 = data.crc32;
+        if (crc32 != expectedCrc32) {
+            throw new Error('wrong CRC32 ' + crc32 + ', expected ' + expectedCrc32);
+        }
+        const payload = data.payload;
+        const key = crypto.createHash('sha256').update(Buffer.from('qWKYcdQWrbm9hPqe', 'utf8')).digest();
+        const digestInput = message.subarray(0, 9);
+        const digest = crypto.createHash('sha256').update(digestInput).digest();
+        const iv = digest.subarray(0, 12);
+        const tag = payload.subarray(payload.length - 16);
+        const ciphertext = payload.subarray(0, payload.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        try {
+            const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+            return decrypted.toString('utf8');
+        }
+        catch (e) {
+            const message = e && typeof e === 'object' && 'message' in e ? e.message : String(e);
+            throw new Error('failed to decrypt: ' + message + ' / iv: ' + iv.toString('hex') + ' / tag: ' + tag.toString('hex') + ' / encrypted: ' + ciphertext.toString('hex'));
+        }
+    }
+}

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

@@ -3,63 +3,79 @@ 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;
-    client = undefined;
+    mqttClient = undefined;
+    keepConnectionAliveInterval = undefined;
     constructor(logger, context, 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);
         this.initializeConnectionStateListener();
-        this.changeToSecureConnection = (duid) => {
-            this.logger.info(`MqttClient for ${duid} has been disconnected`);
-        };
     }
     connect() {
-        if (this.client) {
+        if (this.mqttClient) {
             return;
         }
-        this.client = mqtt.connect(this.rriot.r.m, {
+        this.mqttClient = mqtt.connect(this.rriot.r.m, {
             clientId: this.mqttUsername,
             username: this.mqttUsername,
             password: this.mqttPassword,
             keepalive: 30,
-            log: () => {
+            log: (...args) => {
+                this.logger.debug(`MQTTClient args: ${debugStringify(args)}`);
             },
         });
-        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));
-        this.client.on('message', this.onMessage.bind(this));
+        this.mqttClient.on('connect', this.onConnect.bind(this));
+        this.mqttClient.on('error', this.onError.bind(this));
+        this.mqttClient.on('reconnect', this.onReconnect.bind(this));
+        this.mqttClient.on('close', this.onClose.bind(this));
+        this.mqttClient.on('disconnect', this.onDisconnect.bind(this));
+        this.mqttClient.on('offline', this.onOffline.bind(this));
+        this.mqttClient.on('message', this.onMessage.bind(this));
+        this.keepConnectionAlive();
     }
     async disconnect() {
-        if (!this.client || !this.connected) {
+        if (!this.mqttClient || !this.connected) {
             return;
         }
         try {
             this.isInDisconnectingStep = true;
-            this.client.end();
+            this.mqttClient.end();
         }
         catch (error) {
             this.logger.error('MQTT client failed to disconnect with error: ' + error);
         }
     }
     async send(duid, request) {
-        if (!this.client || !this.connected) {
+        if (!this.mqttClient || !this.connected) {
             this.logger.error(`${duid}: mqtt is not available, ${debugStringify(request)}`);
             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 });
+        this.logger.debug(`MQTTClient sending message to ${duid}: ${debugStringify(mqttRequest)}`);
+        this.mqttClient.publish(`rr/m/i/${this.rriot.u}/${this.mqttUsername}/${duid}`, message.buffer, { qos: 1 });
+        this.logger.debug(`MQTTClient published message to topic: rr/m/i/${this.rriot.u}/${this.mqttUsername}/${duid}`);
+    }
+    keepConnectionAlive() {
+        if (this.keepConnectionAliveInterval) {
+            clearTimeout(this.keepConnectionAliveInterval);
+            this.keepConnectionAliveInterval.unref();
+        }
+        this.keepConnectionAliveInterval = setInterval(() => {
+            if (this.mqttClient) {
+                this.mqttClient.end();
+                this.mqttClient.reconnect();
+            }
+            else {
+                this.connect();
+            }
+        }, 30 * 60 * 1000);
     }
     async onConnect(result) {
         if (!result) {
@@ -70,30 +86,42 @@ export class MQTTClient extends AbstractClient {
         this.subscribeToQueue();
     }
     subscribeToQueue() {
-        if (!this.client) {
+        if (!this.mqttClient || !this.connected) {
             return;
         }
-        this.client.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
+        this.mqttClient.subscribe('rr/m/o/' + this.rriot.u + '/' + this.mqttUsername + '/#', this.onSubscribe.bind(this));
     }
-    async onSubscribe(err) {
+    async onSubscribe(err, granted) {
         if (!err) {
+            this.logger.info('onSubscribe: ' + JSON.stringify(granted));
             return;
         }
-        this.logger.error('failed to subscribe to the queue: ' + err);
+        this.logger.error('failed to subscribe: ' + err);
         this.connected = false;
-        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername);
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Failed to subscribe to the queue: ' + err.toString());
     }
     async onDisconnect() {
         this.connected = false;
-        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername);
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Disconnected from MQTT broker');
     }
     async onError(result) {
         this.logger.error('MQTT connection error: ' + result);
         this.connected = false;
         await this.connectionListeners.onError('mqtt-' + this.mqttUsername, result.toString());
     }
+    async onClose() {
+        if (this.connected) {
+            await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection closed');
+        }
+        this.connected = false;
+    }
+    async onOffline() {
+        this.connected = false;
+        await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection offline');
+    }
     onReconnect() {
         this.subscribeToQueue();
+        this.connectionListeners.onReconnect('mqtt-' + this.mqttUsername, 'Reconnected to MQTT broker');
     }
     async onMessage(topic, message) {
         if (!message) {

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, onDisconnect) {
-        const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip, onDisconnect);
+    registerClient(duid, ip) {
+        const localClient = new LocalNetworkClient(this.logger, this.context, duid, ip);
         localClient.registerConnectionListener(this.connectionListeners);
         localClient.registerMessageListener(this.messageListeners);
         this.localClients.set(duid, localClient);

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

@@ -8,9 +8,9 @@ export class ChainedConnectionListener {
             await listener.onConnected(duid);
         }
     }
-    async onDisconnected(duid) {
+    async onDisconnected(duid, message) {
         for (const listener of this.listeners) {
-            await listener.onDisconnected(duid);
+            await listener.onDisconnected(duid, message);
         }
     }
     async onError(duid, message) {
@@ -18,4 +18,9 @@ export class ChainedConnectionListener {
             await listener.onError(duid, message);
         }
     }
+    async onReconnect(duid, message) {
+        for (const listener of this.listeners) {
+            await listener.onReconnect(duid, message);
+        }
+    }
 }