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

package/src/roborockCommunication/Zmodel/device.ts

@@ -36,6 +36,7 @@ export interface Device {
     model: string;
     category: string;
     batteryLevel: number;
+    // schema: DeviceSchema[];
   };
 
   scenes: Scene[];

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,34 @@
+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.rooms.length > 0
+            ? 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/Zmodel/userData.ts

@@ -7,9 +7,6 @@ export interface UserData {
   country: string;
   nickname: string;
   rriot: Rriot;
-
-  // For caching purposes
-  baseUrl: string;
 }
 
 export interface Rriot {

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();
@@ -24,6 +25,7 @@ export abstract class AbstractClient implements Client {
 
   protected abstract clientName: string;
   protected abstract shouldReconnect: boolean;
+  protected abstract changeToSecureConnection: (duid: string) => void;
 
   private readonly context: MessageContext;
   private readonly syncMessageListener: SyncMessageListener;
@@ -39,7 +41,7 @@ export abstract class AbstractClient implements Client {
   }
 
   protected 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);
   }
 
@@ -47,11 +49,18 @@ export abstract class AbstractClient implements Client {
   abstract disconnect(): Promise<void>;
   abstract send(duid: string, request: RequestMessage): Promise<void>;
 
-  public async get<T>(duid: string, request: RequestMessage): Promise<T> {
+  public async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
     return new Promise<T>((resolve, reject) => {
-      this.syncMessageListener.waitFor(request.messageId, (response: ResponseMessage) => resolve(response as unknown as T), reject);
+      this.syncMessageListener.waitFor(request.messageId, request, (response: ResponseMessage) => resolve(response as unknown as T), reject);
       this.send(duid, request);
-    });
+    })
+      .then((result: T) => {
+        return result;
+      })
+      .catch((error: Error) => {
+        this.logger.error(error.message);
+        return undefined;
+      });
   }
 
   public registerDevice(duid: string, localKey: string, pv: string): void {

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

@@ -9,6 +9,7 @@ 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;
 
@@ -19,19 +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));
@@ -71,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,7 @@ 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;
 
@@ -23,6 +24,9 @@ export class MQTTClient extends AbstractClient {
     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/client.ts

@@ -15,5 +15,5 @@ export interface Client {
 
   send(duid: string, request: RequestMessage): Promise<void>;
 
-  get<T>(duid: string, request: RequestMessage): Promise<T>;
+  get<T>(duid: string, request: RequestMessage): Promise<T | undefined>;
 }

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);
 
@@ -81,7 +81,7 @@ export class ClientRouter implements Client {
     }
   }
 
-  async get<T>(duid: string, request: RequestMessage): Promise<T> {
+  async get<T>(duid: string, request: RequestMessage): Promise<T | undefined> {
     if (request.secure) {
       return await this.mqttClient.get(duid, request);
     } else {

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

@@ -7,12 +7,14 @@ export class ConnectionStateListener implements AbstractConnectionListener {
   protected client: AbstractClient;
   protected clientName: string;
   protected shouldReconnect: boolean;
+  protected changeToSecureConnection: (duid: string) => void;
 
-  constructor(logger: AnsiLogger, client: AbstractClient, clientName: string, shouldReconnect = false) {
+  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> {
@@ -25,7 +27,13 @@ export class ConnectionStateListener implements AbstractConnectionListener {
       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) {

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

@@ -1,8 +1,9 @@
-import { AnsiLogger } from 'matterbridge/logger';
+import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { DpsPayload } from '../../model/dps.js';
 import { Protocol } from '../../model/protocol.js';
 import { ResponseMessage } from '../../model/responseMessage.js';
 import { AbstractMessageListener } from '../index.js';
+import { RequestMessage } from '../../model/requestMessage.js';
 
 export class SyncMessageListener implements AbstractMessageListener {
   private readonly pending = new Map<number, (response: ResponseMessage) => void>();
@@ -12,12 +13,12 @@ export class SyncMessageListener implements AbstractMessageListener {
     this.logger = logger;
   }
 
-  public waitFor(messageId: number, resolve: (response: ResponseMessage) => void, reject: () => void): void {
+  public waitFor(messageId: number, request: RequestMessage, resolve: (response: ResponseMessage) => void, reject: (error?: Error) => void): void {
     this.pending.set(messageId, resolve);
 
     setTimeout(() => {
       this.pending.delete(messageId);
-      reject();
+      reject(new Error(`Message timeout for messageId: ${messageId}, request: ${debugStringify(request)}`));
     }, 10000);
   }
 

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -29,7 +29,7 @@ export class MessageProcessor {
     this.messageListener.registerListener(listener);
   }
 
-  public async getNetworkInfo(duid: string): Promise<NetworkInfo> {
+  public async getNetworkInfo(duid: string): Promise<NetworkInfo | undefined> {
     const request = new RequestMessage({ method: 'get_network_info' });
     return await this.client.get(duid, request);
   }
@@ -39,17 +39,21 @@ export class MessageProcessor {
   //   return this.client.get<CloudMessageResult[]>(duid, request).then((response) => new DeviceStatus(response[0]));
   // }
 
-  public async getDeviceStatus(duid: string): Promise<DeviceStatus> {
+  public async getDeviceStatus(duid: string): Promise<DeviceStatus | undefined> {
     const request = new RequestMessage({ method: 'get_status' });
     const response = await this.client.get<CloudMessageResult[]>(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;
   }
 
   public async getRooms(duid: string, rooms: Room[]): Promise<RoomInfo> {
     const request = new RequestMessage({ method: 'get_room_mapping' });
-    return this.client.get<number[][]>(duid, request).then((response) => new RoomInfo(rooms, response));
+    return this.client.get<number[][] | undefined>(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
   }
 
   public async gotoDock(duid: string): Promise<void> {

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -23,6 +23,7 @@ export class MessageDeserializer {
   private readonly context: MessageContext;
   private readonly messageParser: Parser;
   private readonly logger: AnsiLogger;
+  private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
   constructor(context: MessageContext, logger: AnsiLogger) {
     this.context = context;
@@ -46,7 +47,7 @@ export class MessageDeserializer {
 
   public deserialize(duid: string, message: Buffer<ArrayBufferLike>): ResponseMessage {
     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);
     }
 
@@ -71,6 +72,11 @@ export class MessageDeserializer {
       const iv = CryptoUtils.md5hex(data.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       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);
+      // unpad ??
+      data.payload = Buffer.concat([decipher.update(data.payload), decipher.final()]);
     }
 
     // map visualization not support
@@ -79,14 +85,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/helper/messageSerializer.ts

@@ -66,6 +66,12 @@ export class MessageSerializer {
       const iv = CryptoUtils.md5hex(this.random.toString(16).padStart(8, '0') + '726f626f726f636b2d67a6d6da').substring(8, 24);
       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);
+      // pad ??
+      encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
     } else {
       throw new Error('unable to build the message: unsupported protocol version: ' + version);
     }

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;
@@ -38,6 +39,7 @@ export default class RoborockService {
   messageProcessorMap = new Map<string, MessageProcessor>();
   ipMap = new Map<string, string>();
   localClientMap = new Map<string, Client>();
+  mqttAlwaysOnDevices = new Map<string, boolean>();
   clientManager: ClientManager;
   refreshInterval: number;
   requestDeviceStatusInterval: NodeJS.Timeout | undefined;
@@ -47,6 +49,8 @@ export default class RoborockService {
   private supportedRoutines = new Map<string, ServiceArea.Area[]>();
   private selectedAreas = new Map<string, number[]>();
 
+  private readonly vacuumNeedAPIV3 = ['roborock.vacuum.ss07'];
+
   constructor(
     authenticateApiSupplier: Factory<void, RoborockAuthenticateApi> = (logger) => new RoborockAuthenticateApi(logger),
     iotApiSupplier: Factory<UserData, RoborockIoTApi> = (logger, ud) => new RoborockIoTApi(ud, logger),
@@ -115,6 +119,20 @@ 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 };
+    return data?.vacuumRoom;
+  }
+
+  public async getMapInformation(duid: string): Promise<MapInfo | undefined> {
+    this.logger.debug('RoborockService - getMapInformation', duid);
+    assert(this.messageClient !== undefined);
+    return this.messageClient.get<MultipleMap[] | undefined>(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;
+    });
+  }
+
   public async changeCleanMode(
     duid: string,
     { suctionPower, waterFlow, distance_off, mopRoute }: { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number },
@@ -189,20 +207,26 @@ 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> {
     return this.getMessageProcessor(duid)?.sendCustomMessage(duid, request);
   }
 
+  public async getCustomAPI(url: string): Promise<unknown> {
+    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}` };
+    }
+  }
+
   public stopService(): void {
     if (this.messageClient) {
       this.messageClient.disconnect();
@@ -236,15 +260,15 @@ export default class RoborockService {
     this.deviceNotify = callback;
   }
 
-  public async activateDeviceNotify(device: Device): Promise<void> {
+  public activateDeviceNotify(device: Device): void {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     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: DeviceStatus) => {
-          if (self.deviceNotify) {
+        await messageProcessor.getDeviceStatus(device.duid).then((response: DeviceStatus | undefined) => {
+          if (self.deviceNotify && response) {
             const message = { duid: device.duid, ...response.errorStatus, ...response.message } as DeviceStatusNotify;
             self.logger.debug('Device status update', debugStringify(message));
             self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
@@ -274,8 +298,31 @@ export default class RoborockService {
 
     const products = new Map<string, string>();
     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))];
+    }
+
+    // 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;
 
     const result = devices.map((device) => {
       return {
@@ -293,6 +340,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: {
@@ -321,6 +369,18 @@ export default class RoborockService {
     homeData.products.forEach((p) => products.set(p.id, p.model));
     const devices: Device[] = 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,
@@ -334,6 +394,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: {
@@ -361,13 +422,13 @@ export default class RoborockService {
     return this.iotApi.startScene(sceneId);
   }
 
-  public getRoomMappings(duid: string): Promise<number[][]> | undefined {
+  public getRoomMappings(duid: string): Promise<number[][] | undefined> {
     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) }));
   }
 
   public async initializeMessageClient(username: string, device: Device, userdata: UserData): Promise<void> {
@@ -411,6 +472,7 @@ export default class RoborockService {
       this.logger.error('messageClient not initialized');
       return false;
     }
+
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
 
@@ -439,6 +501,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 {
@@ -457,7 +528,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 +554,10 @@ export default class RoborockService {
     return true;
   }
 
+  private onLocalClientDisconnect(duid: string): void {
+    this.mqttAlwaysOnDevices.set(duid, true);
+  }
+
   private sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -492,4 +567,8 @@ export default class RoborockService {
     this.iotApi = this.iotApiFactory(this.logger, userdata);
     return userdata;
   }
+
+  private isRequestSecure(duid: string): boolean {
+    return this.mqttAlwaysOnDevices.get(duid) ?? false;
+  }
 }