matterbridge-roborock-vacuum-plugin 1.1.0-rc09 → 1.1.0-rc11

package/dist/platform.js

@@ -140,7 +140,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             if (!configurateSuccess.get(duid)) {
                 continue;
             }
-            await this.roborockService.activateDeviceNotify(robot.device);
+            this.roborockService.activateDeviceNotify(robot.device);
         }
         await this.platformRunner?.requestHomeData();
         this.log.info('onConfigurateDevice finished');
@@ -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);
@@ -191,7 +196,4 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
         this.log.logLevel = logLevel;
         return Promise.resolve();
     }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
 }

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;
@@ -70,4 +81,15 @@ export class RoborockIoTApi {
             return undefined;
         }
     }
+    async getCustom(url) {
+        const result = await this.api.get(url);
+        const apiResponse = result.data;
+        if (apiResponse.result) {
+            return apiResponse.result;
+        }
+        else {
+            this.logger.error('Failed to execute scene');
+            return undefined;
+        }
+    }
 }

package/dist/roborockCommunication/Zmodel/map.js

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

package/dist/roborockCommunication/Zmodel/mapInfo.js

@@ -0,0 +1,26 @@
+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.rooms.length > 0
+                    ? 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;
@@ -23,13 +24,20 @@ export class AbstractClient {
         this.logger = logger;
     }
     initializeConnectionStateListener() {
-        const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.shouldReconnect);
+        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);
+            this.syncMessageListener.waitFor(request.messageId, request, (response) => resolve(response), reject);
             this.send(duid, request);
+        })
+            .then((result) => {
+            return result;
+        })
+            .catch((error) => {
+            this.logger.error(error.message);
+            return undefined;
         });
     }
     registerDevice(duid, localKey, pv) {

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

@@ -7,6 +7,7 @@ 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;
@@ -15,17 +16,23 @@ export class LocalNetworkClient extends AbstractClient {
     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));
@@ -58,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,7 @@ 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;
@@ -15,6 +16,9 @@ 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) => {
+            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

@@ -3,11 +3,13 @@ export class ConnectionStateListener {
     client;
     clientName;
     shouldReconnect;
-    constructor(logger, client, clientName, shouldReconnect = false) {
+    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 ${this.clientName}`);
@@ -17,7 +19,12 @@ export class ConnectionStateListener {
             this.logger.notice(`Device ${duid} disconnected from ${this.clientName}, but re-registration is disabled.`);
             return;
         }
-        this.logger.notice(`Device ${duid} disconnected from ${this.clientName}`);
+        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.`);

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

@@ -1,3 +1,4 @@
+import { debugStringify } from 'matterbridge/logger';
 import { Protocol } from '../../model/protocol.js';
 export class SyncMessageListener {
     pending = new Map();
@@ -5,11 +6,11 @@ export class SyncMessageListener {
     constructor(logger) {
         this.logger = logger;
     }
-    waitFor(messageId, resolve, reject) {
+    waitFor(messageId, request, resolve, reject) {
         this.pending.set(messageId, resolve);
         setTimeout(() => {
             this.pending.delete(messageId);
-            reject();
+            reject(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
         }, 10000);
     }
     async onMessage(message) {

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -25,12 +25,15 @@ export class MessageProcessor {
     async getDeviceStatus(duid) {
         const request = new RequestMessage({ method: 'get_status' });
         const response = await this.client.get(duid, request);
-        this.logger?.debug('Device status: ', debugStringify(response));
-        return new DeviceStatus(response);
+        if (response) {
+            this.logger?.debug('Device status: ', debugStringify(response));
+            return new DeviceStatus(response);
+        }
+        return undefined;
     }
     async getRooms(duid, rooms) {
         const request = new RequestMessage({ method: 'get_room_mapping' });
-        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response));
+        return this.client.get(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
     }
     async gotoDock(duid) {
         const request = new RequestMessage({ method: 'app_charge' });

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -8,6 +8,7 @@ export class MessageDeserializer {
     context;
     messageParser;
     logger;
+    supportedVersions = ['1.0', 'A01', 'B01'];
     constructor(context, logger) {
         this.context = context;
         this.logger = logger;
@@ -28,7 +29,7 @@ export class MessageDeserializer {
     }
     deserialize(duid, message) {
         const version = message.toString('latin1', 0, 3);
-        if (version !== '1.0' && version !== 'A01') {
+        if (!this.supportedVersions.includes(version)) {
             throw new Error('unknown protocol version ' + version);
         }
         const crc32 = CRC32.buf(message.subarray(0, message.length - 4)) >>> 0;
@@ -52,18 +53,23 @@ export class MessageDeserializer {
             const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
             data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
         }
+        else if (version == 'B01') {
+            const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const decipher = crypto.createDecipheriv('aes-128-cbc', localKey, iv);
+            data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
+        }
         if (data.protocol == Protocol.map_response) {
             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/helper/messageSerializer.js

@@ -54,6 +54,12 @@ export class MessageSerializer {
             const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
             encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
         }
+        else if (version == 'B01') {
+            const encoder = new TextEncoder();
+            const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '5wwh9ikChRjASpMU8cxg7o1d2E').substring(9, 25);
+            const cipher = crypto.createCipheriv('aes-128-cbc', encoder.encode(localKey), iv);
+            encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+        }
         else {
             throw new Error('unable to build the message: unsupported protocol version: ' + version);
         }

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;
@@ -15,12 +15,14 @@ export default class RoborockService {
     messageProcessorMap = new Map();
     ipMap = new Map();
     localClientMap = new Map();
+    mqttAlwaysOnDevices = new Map();
     clientManager;
     refreshInterval;
     requestDeviceStatusInterval;
     supportedAreas = new Map();
     supportedRoutines = new Map();
     selectedAreas = new Map();
+    vacuumNeedAPIV3 = ['roborock.vacuum.ss07'];
     constructor(authenticateApiSupplier = (logger) => new RoborockAuthenticateApi(logger), iotApiSupplier = (logger, ud) => new RoborockIoTApi(ud, logger), refreshInterval, clientManager, logger) {
         this.logger = logger;
         this.loginApi = authenticateApiSupplier(logger);
@@ -69,6 +71,18 @@ 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) => {
+            this.logger.debug('RoborockService - getMapInformation response', debugStringify(response ?? []));
+            return response ? new MapInfo(response[0]) : undefined;
+        });
+    }
     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,17 +143,24 @@ 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);
     }
+    async getCustomAPI(url) {
+        this.logger.debug('RoborockService - getCustomAPI', url);
+        assert(this.iotApi !== undefined);
+        try {
+            return await this.iotApi.getCustom(url);
+        }
+        catch (error) {
+            this.logger.error(`Failed to get custom API with url ${url}: ${error ? debugStringify(error) : 'undefined'}`);
+            return { result: undefined, error: `Failed to get custom API with url ${url}` };
+        }
+    }
     stopService() {
         if (this.messageClient) {
             this.messageClient.disconnect();
@@ -168,14 +189,14 @@ export default class RoborockService {
     setDeviceNotify(callback) {
         this.deviceNotify = callback;
     }
-    async activateDeviceNotify(device) {
+    activateDeviceNotify(device) {
         const self = this;
         this.logger.debug('Requesting device info for device', device.duid);
         const messageProcessor = this.getMessageProcessor(device.duid);
         this.requestDeviceStatusInterval = setInterval(async () => {
             if (messageProcessor) {
                 await messageProcessor.getDeviceStatus(device.duid).then((response) => {
-                    if (self.deviceNotify) {
+                    if (self.deviceNotify && response) {
                         const message = { duid: device.duid, ...response.errorStatus, ...response.message };
                         self.logger.debug('Device status update', debugStringify(message));
                         self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
@@ -201,6 +222,27 @@ 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.products.some((p) => this.vacuumNeedAPIV3.includes(p.model))) {
+            this.logger.debug('Using v3 API for home data retrieval');
+            const homeDataV3 = await this.iotApi.getHomev3(homeDetails.rrHomeId);
+            if (!homeDataV3) {
+                throw new Error('Failed to retrieve the home data from v3 API');
+            }
+            homeData.devices = [...homeData.devices, ...homeDataV3.devices.filter((d) => !homeData.devices.some((x) => x.duid === d.duid))];
+            homeData.receivedDevices = [...homeData.receivedDevices, ...homeDataV3.receivedDevices.filter((d) => !homeData.receivedDevices.some((x) => x.duid === d.duid))];
+        }
+        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 {
@@ -218,6 +260,7 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
+                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     username: username,
@@ -240,6 +283,18 @@ export default class RoborockService {
         const products = new Map();
         homeData.products.forEach((p) => products.set(p.id, p.model));
         const devices = homeData.devices.length > 0 ? homeData.devices : homeData.receivedDevices;
+        if (homeData.rooms.length === 0) {
+            const homeDataV3 = await this.iotApi.getHomev3(homeid);
+            if (homeDataV3 && homeDataV3.rooms && homeDataV3.rooms.length > 0) {
+                homeData.rooms = homeDataV3.rooms;
+            }
+            else {
+                const homeDataV1 = await this.iotApi.getHome(homeid);
+                if (homeDataV1 && homeDataV1.rooms && homeDataV1.rooms.length > 0) {
+                    homeData.rooms = homeDataV1.rooms;
+                }
+            }
+        }
         const dvs = devices.map((device) => {
             return {
                 ...device,
@@ -253,6 +308,7 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
+                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     userData: this.userdata,
@@ -278,9 +334,9 @@ export default class RoborockService {
     getRoomMappings(duid) {
         if (!this.messageClient) {
             this.logger.warn('messageClient not initialized. Waititing for next execution');
-            return undefined;
+            return Promise.resolve(undefined);
         }
-        return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping' }));
+        return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping', secure: this.isRequestSecure(duid) }));
     }
     async initializeMessageClient(username, device, userdata) {
         if (this.clientManager === undefined) {
@@ -332,6 +388,15 @@ export default class RoborockService {
             },
         });
         this.messageProcessorMap.set(device.duid, messageProcessor);
+        this.logger.debug('Checking if device supports local connection', device.pv, device.data.model, device.duid);
+        if (device.pv === 'B01') {
+            this.logger.warn('Device does not support local connection', device.duid);
+            this.mqttAlwaysOnDevices.set(device.duid, true);
+            return true;
+        }
+        else {
+            this.mqttAlwaysOnDevices.set(device.duid, false);
+        }
         this.logger.debug('Local device', device.duid);
         let localIp = this.ipMap.get(device.duid);
         try {
@@ -347,7 +412,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 +434,9 @@ export default class RoborockService {
         }
         return true;
     }
+    onLocalClientDisconnect(duid) {
+        this.mqttAlwaysOnDevices.set(duid, true);
+    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
@@ -377,4 +445,7 @@ export default class RoborockService {
         this.iotApi = this.iotApiFactory(this.logger, userdata);
         return userdata;
     }
+    isRequestSecure(duid) {
+        return this.mqttAlwaysOnDevices.get(duid) ?? false;
+    }
 }

package/eslint.config.js

@@ -9,7 +9,7 @@ import eslintPluginN from 'eslint-plugin-n';
 export default [
   {
     name: 'global ignores',
-    ignores: ['dist/', 'build/', 'node_modules/', 'coverage/', 'frontend/', 'rock-s0/', 'webui/', 'exampleData/', '.shouldnotcommit/'],
+    ignores: ['dist/', 'build/', 'node_modules/', 'coverage/', 'frontend/', 'rock-s0/', 'webui/', 'exampleData/', '.shouldnotcommit/', 'web-for-testing/'],
   },
   eslint.configs.recommended,
   ...tseslint.configs.strict,

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

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc09",
+  "version": "1.1.0-rc11",
   "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-rc09 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc11 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-rc09",
+  "version": "1.1.0-rc11",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/platform.ts

@@ -199,7 +199,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       if (!configurateSuccess.get(duid)) {
         continue;
       }
-      await this.roborockService.activateDeviceNotify(robot.device);
+      this.roborockService.activateDeviceNotify(robot.device);
     }
 
     await this.platformRunner?.requestHomeData();
@@ -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));
@@ -273,8 +279,4 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     this.log.logLevel = logLevel;
     return Promise.resolve();
   }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 }

package/src/roborockCommunication/RESTAPI/roborockIoTApi.ts

@@ -46,7 +46,19 @@ export class RoborockIoTApi {
   }
 
   public async getHomev2(homeId: number): Promise<Home | undefined> {
-    const result = await this.api.get('v2/user/homes/' + homeId); // can be v3 also
+    const result = await this.api.get('v2/user/homes/' + homeId);
+
+    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 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) {
@@ -80,4 +92,16 @@ export class RoborockIoTApi {
       return undefined;
     }
   }
+
+  public async getCustom(url: string): Promise<unknown> {
+    const result = await this.api.get(url);
+    const apiResponse: ApiResponse<unknown> = result.data;
+
+    if (apiResponse.result) {
+      return apiResponse.result;
+    } else {
+      this.logger.error('Failed to execute scene');
+      return undefined;
+    }
+  }
 }