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

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

@@ -0,0 +1,157 @@
+import * as dgram from 'node:dgram';
+import { Socket } from 'node:dgram';
+import { Parser } from 'binary-parser';
+import crypto from 'node:crypto';
+import CRC32 from 'crc-32';
+import { AnsiLogger } from 'matterbridge/logger';
+import { AbstractClient } from '../abstractClient.js';
+import { RequestMessage, ResponseMessage } from '../../index.js';
+import { MessageContext } from '../model/messageContext.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class LocalNetworkUDPClient extends AbstractClient {
+  protected override clientName = 'LocalNetworkUDPClient';
+  protected override shouldReconnect = false;
+
+  private readonly PORT = 58866;
+  private server: Socket | undefined = undefined;
+
+  private readonly V10Parser: Parser<any>;
+  private readonly L01Parser: Parser<any>;
+
+  constructor(logger: AnsiLogger, context: MessageContext) {
+    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;
+  }
+
+  public connect(): void {
+    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;
+    }
+  }
+
+  public disconnect(): Promise<void> {
+    if (this.server) {
+      return new Promise<void>((resolve) => {
+        this.server?.close(() => {
+          this.server = undefined;
+          resolve();
+        });
+      });
+    }
+
+    return Promise.resolve();
+  }
+
+  public override send(duid: string, request: RequestMessage): Promise<void> {
+    this.logger.debug(`Sending request to ${duid}: ${JSON.stringify(request)}`);
+    return Promise.resolve();
+  }
+
+  private async onError(result: any) {
+    this.logger.error(`UDP socket error: ${result}`);
+
+    if (this.server) {
+      this.server.close();
+      this.server = undefined;
+    }
+  }
+
+  private async onMessage(buffer: Buffer) {
+    const message = await this.deserializeMessage(buffer);
+    this.logger.debug('Received message: ' + JSON.stringify(message));
+  }
+
+  private async deserializeMessage(buffer: Buffer): Promise<ResponseMessage | undefined> {
+    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':
+        // TODO: Implement A01 deserialization
+        return undefined; // Placeholder for A01 deserialization
+      default:
+        throw new Error('unknown protocol version ' + version);
+    }
+  }
+
+  private async deserializeV10Message(message: Buffer<ArrayBufferLike>): Promise<string> {
+    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);
+  }
+
+  private async deserializeL01Message(message: Buffer<ArrayBufferLike>): Promise<string> {
+    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: unknown) {
+      const message = e && typeof e === 'object' && 'message' in e ? (e as any).message : String(e);
+      throw new Error('failed to decrypt: ' + message + ' / iv: ' + iv.toString('hex') + ' / tag: ' + tag.toString('hex') + ' / encrypted: ' + ciphertext.toString('hex'));
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-import mqtt, { ErrorWithReasonCode, IConnackPacket, MqttClient as MqttLibClient } from 'mqtt';
+import mqtt, { ErrorWithReasonCode, IConnackPacket, ISubscriptionGrant, MqttClient as MqttLibClient } from 'mqtt';
 import * as CryptoUtils from '../../helper/cryptoHelper.js';
 import { RequestMessage } from '../model/requestMessage.js';
 import { AbstractClient } from '../abstractClient.js';
@@ -7,14 +7,14 @@ import { Rriot, UserData } from '../../Zmodel/userData.js';
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 
 export class MQTTClient extends AbstractClient {
-  protected override changeToSecureConnection: (duid: string) => void;
   protected override clientName = 'MQTTClient';
   protected override shouldReconnect = false;
 
   private readonly rriot: Rriot;
   private readonly mqttUsername: string;
   private readonly mqttPassword: string;
-  private client: MqttLibClient | undefined = undefined;
+  private mqttClient: MqttLibClient | undefined = undefined;
+  private keepConnectionAliveInterval: NodeJS.Timeout | undefined = undefined;
 
   public constructor(logger: AnsiLogger, context: MessageContext, userdata: UserData) {
     super(logger, context);
@@ -24,106 +24,139 @@ 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 {
-    if (this.client) {
-      return;
+    if (this.mqttClient) {
+      return; // Already connected
     }
 
-    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: () => {
-        // ...args: unknown[] -  this.logger.debug('MQTTClient args:: ' + args[0]);
+      log: (...args: unknown[]) => {
+        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.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));
 
-    // message events
-    this.client.on('message', this.onMessage.bind(this));
+    this.keepConnectionAlive();
   }
 
   public async disconnect(): Promise<void> {
-    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);
     }
   }
 
   public async send(duid: string, request: RequestMessage): Promise<void> {
-    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}`);
+  }
+
+  private keepConnectionAlive(): void {
+    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,
+    );
   }
 
-  private async onConnect(result: IConnackPacket) {
+  private async onConnect(result: IConnackPacket): Promise<void> {
     if (!result) {
       return;
     }
 
     this.connected = true;
     await this.connectionListeners.onConnected('mqtt-' + this.mqttUsername);
-
     this.subscribeToQueue();
   }
 
-  private subscribeToQueue() {
-    if (!this.client) {
+  private subscribeToQueue(): void {
+    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));
   }
 
-  private async onSubscribe(err: Error | null) {
+  private async onSubscribe(err: Error | null, granted: ISubscriptionGrant[] | undefined): Promise<void> {
     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());
   }
 
-  private async onDisconnect() {
+  private async onDisconnect(): Promise<void> {
     this.connected = false;
-    await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername);
+    await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'Disconnected from MQTT broker');
   }
 
-  private async onError(result: Error | ErrorWithReasonCode) {
+  private async onError(result: Error | ErrorWithReasonCode): Promise<void> {
     this.logger.error('MQTT connection error: ' + result);
     this.connected = false;
 
     await this.connectionListeners.onError('mqtt-' + this.mqttUsername, result.toString());
   }
 
-  private onReconnect() {
+  private async onClose(): Promise<void> {
+    if (this.connected) {
+      await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection closed');
+    }
+
+    this.connected = false;
+  }
+
+  private async onOffline(): Promise<void> {
+    this.connected = false;
+    await this.connectionListeners.onDisconnected('mqtt-' + this.mqttUsername, 'MQTT connection offline');
+  }
+
+  private onReconnect(): void {
     this.subscribeToQueue();
+    this.connectionListeners.onReconnect('mqtt-' + this.mqttUsername, 'Reconnected to MQTT broker');
   }
 
-  private async onMessage(topic: string, message: Buffer<ArrayBufferLike>) {
+  private async onMessage(topic: string, message: Buffer<ArrayBufferLike>): Promise<void> {
     if (!message) {
       // Ignore empty messages
       this.logger.notice('MQTTClient received empty message from topic: ' + topic);

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

package/src/roborockCommunication/broadcast/listener/abstractConnectionListener.ts

@@ -1,5 +1,6 @@
 export interface AbstractConnectionListener {
   onConnected(duid: string): Promise<void>;
-  onDisconnected(duid: string): Promise<void>;
+  onDisconnected(duid: string, message: string): Promise<void>;
   onError(duid: string, message: string): Promise<void>;
+  onReconnect(duid: string, message: string): Promise<void>;
 }

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

@@ -13,9 +13,9 @@ export class ChainedConnectionListener implements AbstractConnectionListener {
     }
   }
 
-  public async onDisconnected(duid: string): Promise<void> {
+  public async onDisconnected(duid: string, message: string): Promise<void> {
     for (const listener of this.listeners) {
-      await listener.onDisconnected(duid);
+      await listener.onDisconnected(duid, message);
     }
   }
 
@@ -24,4 +24,10 @@ export class ChainedConnectionListener implements AbstractConnectionListener {
       await listener.onError(duid, message);
     }
   }
+
+  public async onReconnect(duid: string, message: string): Promise<void> {
+    for (const listener of this.listeners) {
+      await listener.onReconnect(duid, message);
+    }
+  }
 }

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

@@ -7,21 +7,24 @@ 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, changeToSecureConnection: (duid: string) => void, shouldReconnect = false) {
+  constructor(logger: AnsiLogger, client: AbstractClient, clientName: string, shouldReconnect = false) {
     this.logger = logger;
     this.client = client;
     this.clientName = clientName;
     this.shouldReconnect = shouldReconnect;
-    this.changeToSecureConnection = changeToSecureConnection;
   }
 
   public async onConnected(duid: string): Promise<void> {
     this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
   }
 
-  public async onDisconnected(duid: string): Promise<void> {
+  public async onReconnect(duid: string, message: string): Promise<void> {
+    this.logger.info(`Device ${duid} reconnected to ${this.clientName} with message: ${message}`);
+  }
+
+  public async onDisconnected(duid: string, message: string): Promise<void> {
+    this.logger.error(`Device ${duid} disconnected from ${this.clientName} with message: ${message}`);
     if (!this.shouldReconnect) {
       this.logger.notice(`Device ${duid} disconnected from ${this.clientName}, but re-registration is disabled.`);
       return;
@@ -29,7 +32,6 @@ export class ConnectionStateListener implements AbstractConnectionListener {
 
     if (this.client.retryCount > 10) {
       this.logger.error(`Device with DUID ${duid} has exceeded retry limit, not re-registering.`);
-      this.changeToSecureConnection(duid);
       return;
     }
 
@@ -42,7 +44,10 @@ export class ConnectionStateListener implements AbstractConnectionListener {
     }
 
     this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
-    this.client.connect();
+
+    setTimeout(() => {
+      this.client.connect();
+    }, 3000);
 
     this.client.isInDisconnectingStep = false;
   }

package/src/roborockCommunication/helper/messageDeserializer.ts

@@ -1,6 +1,5 @@
 import crypto from 'node:crypto';
 import CRC32 from 'crc-32';
-// @ts-expect-error: binary-parser has no type definitions, using as-is for runtime parsing
 import { Parser } from 'binary-parser';
 import { ResponseMessage } from '../broadcast/model/responseMessage.js';
 import * as CryptoUtils from './cryptoHelper.js';
@@ -21,7 +20,7 @@ export interface Message {
 
 export class MessageDeserializer {
   private readonly context: MessageContext;
-  private readonly messageParser: Parser;
+  private readonly messageParser: Parser<Message>;
   private readonly logger: AnsiLogger;
   private readonly supportedVersions: string[] = ['1.0', 'A01', 'B01'];
 
@@ -30,7 +29,7 @@ export class MessageDeserializer {
     this.logger = logger;
 
     this.messageParser = new Parser()
-      .endianess('big')
+      .endianness('big')
       .string('version', {
         length: 3,
       })

package/src/roborockService.ts

@@ -98,6 +98,10 @@ export default class RoborockService {
     this.selectedAreas.set(duid, selectedAreas);
   }
 
+  public getSelectedAreas(duid: string): number[] {
+    return this.selectedAreas.get(duid) ?? [];
+  }
+
   public setSupportedAreas(duid: string, supportedAreas: ServiceArea.Area[]): void {
     this.supportedAreas.set(duid, supportedAreas);
   }
@@ -340,7 +344,6 @@ 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: {
@@ -394,7 +397,6 @@ 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: {
@@ -427,7 +429,6 @@ export default class RoborockService {
       this.logger.warn('messageClient not initialized. Waititing for next execution');
       return Promise.resolve(undefined);
     }
-
     return this.messageClient.get(duid, new RequestMessage({ method: 'get_room_mapping', secure: this.isRequestSecure(duid) }));
   }
 
@@ -528,14 +529,14 @@ 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, this.onLocalClientDisconnect) as LocalNetworkClient;
+        const localClient = this.messageClient.registerClient(device.duid, localIp) as LocalNetworkClient;
         localClient.connect();
 
         let count = 0;
         while (!localClient.isConnected() && count < 20) {
           this.logger.debug('Keep waiting for local client to connect');
           count++;
-          await this.sleep(200);
+          await this.sleep(500);
         }
 
         if (!localClient.isConnected()) {
@@ -554,10 +555,6 @@ 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));
   }

package/src/tests/initialData/getSupportedAreas.test.ts

@@ -78,4 +78,31 @@ describe('getSupportedAreas', () => {
 
     expect(result.length).toEqual(5);
   });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const result = getSupportedAreas(
+      [
+        { id: 11453731, name: 'Living room' },
+        { id: 11453727, name: 'Kitchen' },
+        { id: 11453415, name: 'Bathroom' },
+        { id: 11453409, name: 'Emile’s Room' },
+        { id: 11453404, name: 'Nadia’s Room' },
+        { id: 11453398, name: 'Hallway' },
+        { id: 11453391, name: 'Dining room' },
+        { id: 11453384, name: 'Outside' },
+      ],
+      {
+        rooms: [
+          { id: 16, globalId: 2775739, displayName: undefined },
+          { id: 17, globalId: 991195, displayName: undefined },
+          { id: 18, globalId: 991187, displayName: undefined },
+          { id: 19, globalId: 991185, displayName: undefined },
+          { id: 20, globalId: 991190, displayName: undefined },
+        ],
+      } as RoomMap,
+      mockLogger as any,
+    );
+
+    expect(result.length).toEqual(5);
+  });
 });

package/src/tests/platformRunner2.test.ts

@@ -0,0 +1,91 @@
+import RoomMap from '../model/RoomMap';
+import { RoborockMatterbridgePlatform } from '../platform';
+import { PlatformRunner } from '../platformRunner';
+import { MapInfo } from '../roborockCommunication';
+
+describe('PlatformRunner.getRoomMapFromDevice', () => {
+  let platform: any;
+  let runner: PlatformRunner;
+
+  beforeEach(() => {
+    platform = {
+      log: {
+        error: jest.fn(),
+        debug: jest.fn(),
+        notice: jest.fn(),
+      },
+      roborockService: {
+        getRoomMappings: jest.fn(),
+        getMapInformation: jest.fn(),
+      },
+    };
+    runner = new PlatformRunner(platform as RoborockMatterbridgePlatform);
+  });
+
+  it('returns RoomMap with roomData from getRoomMappings if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+    const roomData = [
+      [1, '11100845', 14],
+      [2, '11100849', 9],
+      [3, '11100842', 6],
+      [4, '11100847', 1],
+    ];
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(roomData);
+    platform.roborockService.getMapInformation.mockResolvedValue(undefined);
+
+    const result = await runner.getRoomMapFromDevice(device as any);
+
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(4);
+  });
+
+  it('returns RoomMap with roomData from getMapInformation if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+
+    const mapInfo = new MapInfo({
+      max_multi_map: 1,
+      max_bak_map: 1,
+      multi_map_count: 1,
+      map_info: [
+        {
+          mapFlag: 0,
+          add_time: 1753281130,
+          length: 0,
+          name: '',
+          bak_maps: [{ mapFlag: 4, add_time: 1753187168 }],
+          rooms: [
+            { id: 1, tag: 14, iot_name_id: '11100845', iot_name: 'Kitchen' },
+            { id: 2, tag: 9, iot_name_id: '11100849', iot_name: 'Study' },
+            { id: 3, tag: 6, iot_name_id: '11100842', iot_name: 'Living room' },
+            { id: 4, tag: 1, iot_name_id: '11100847', iot_name: 'Bedroom' },
+          ],
+        },
+      ],
+    });
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(undefined);
+    platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
+
+    const result = await runner.getRoomMapFromDevice(device as any);
+
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(4);
+  });
+});

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

@@ -134,7 +134,7 @@ describe('LocalNetworkClient', () => {
       jest.fn();
     }, 1000);
     await (client as any).onDisconnect();
-    expect(mockLogger.notice).toHaveBeenCalled();
+    expect(mockLogger.error).toHaveBeenCalled();
     expect(client['connected']).toBe(false);
     expect(mockSocket.destroy).toHaveBeenCalled();
     expect(client['socket']).toBeUndefined();
@@ -151,12 +151,6 @@ describe('LocalNetworkClient', () => {
     expect(client['connectionListeners'].onError).toHaveBeenCalledWith('duid1', expect.stringContaining('fail'));
   });
 
-  it('onMessage() should log error if no socket', async () => {
-    client['socket'] = undefined;
-    await (client as any).onMessage(Buffer.from([1, 2, 3]));
-    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('unable to receive data'));
-  });
-
   it('onMessage() should log debug if message is empty', async () => {
     client['socket'] = mockSocket;
     await (client as any).onMessage(Buffer.alloc(0));