matterbridge-roborock-vacuum-plugin 1.1.0-rc14 → 1.1.0-rc15

package/dist/helper.js

@@ -1,3 +1,5 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
 export function getVacuumProperty(device, property) {
     if (device) {
         const schemas = device.schema;
@@ -14,3 +16,63 @@ export function getVacuumProperty(device, property) {
 export function isSupportedDevice(model) {
     return model.startsWith('roborock.vacuum.');
 }
+export function isStatusUpdate(result) {
+    return (Array.isArray(result) &&
+        result.length > 0 &&
+        typeof result[0] === 'object' &&
+        result[0] !== null &&
+        'msg_ver' in result[0] &&
+        result[0].msg_ver !== undefined &&
+        result[0].msg_ver !== null);
+}
+export async function getRoomMap(duid, platform) {
+    const robot = platform.robots.get(duid);
+    if (robot === undefined) {
+        platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+        return undefined;
+    }
+    if (platform.roborockService === undefined)
+        return undefined;
+    const rooms = robot.device.rooms ?? [];
+    if (robot.roomInfo === undefined) {
+        const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+        if (roomData !== undefined && roomData.length > 0) {
+            robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+            return robot.roomInfo;
+        }
+    }
+    if (robot.roomInfo === undefined) {
+        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.iot_name_id), r.tag]);
+            robot.roomInfo = new RoomMap(roomDataMap, rooms);
+        }
+    }
+    return robot.roomInfo;
+}
+export async function getRoomMapFromDevice(device, platform) {
+    const rooms = device?.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.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) {
+            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);
+}

package/dist/model/RoomMap.js

@@ -1,4 +1,4 @@
-export default class RoomMap {
+export class RoomMap {
     rooms = [];
     constructor(roomData, rooms) {
         this.rooms = roomData.map((entry) => {

package/dist/platform.js

@@ -4,7 +4,7 @@ import { debugStringify } from 'matterbridge/logger';
 import RoborockService from './roborockService.js';
 import { PLUGIN_NAME } from './settings.js';
 import ClientManager from './clientManager.js';
-import { isSupportedDevice } from './helper.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
 import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
@@ -162,7 +162,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             const rooms = map_info?.maps?.[0]?.rooms ?? [];
             vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }));
         }
-        const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+        const roomMap = await getRoomMapFromDevice(vacuum, this);
         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);
         const supportedAreas = getSupportedAreas(vacuum.rooms, roomMap, this.log);

package/dist/platformRunner.js

@@ -1,8 +1,7 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getVacuumProperty } from './helper.js';
+import { getRoomMap, getVacuumProperty, isStatusUpdate } from './helper.js';
 import { getRunningMode } from './initialData/getSupportedRunModes.js';
 import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
-import RoomMap from './model/RoomMap.js';
 import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
 import { Protocol } from './roborockCommunication/broadcast/model/protocol.js';
@@ -32,59 +31,6 @@ export class PlatformRunner {
         const homeData = await platform.roborockService.getHomeDataForUpdating(platform.rrHomeId);
         await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
     }
-    async getRoomMapFromDevice(device) {
-        const platform = this.platform;
-        const rooms = device?.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.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) {
-                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);
-    }
-    async getRoomMap(duid) {
-        const platform = this.platform;
-        const robot = platform.robots.get(duid);
-        if (robot === undefined) {
-            platform.log.error(`Error6: Robot with DUID ${duid} not found`);
-            return undefined;
-        }
-        if (platform.roborockService === undefined)
-            return undefined;
-        const rooms = robot.device.rooms ?? [];
-        if (robot.roomInfo === undefined) {
-            const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-            if (roomData !== undefined && roomData.length > 0) {
-                robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-                return robot.roomInfo;
-            }
-        }
-        if (robot.roomInfo === undefined) {
-            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.iot_name_id), r.tag]);
-                robot.roomInfo = new RoomMap(roomDataMap, rooms);
-            }
-        }
-        return robot.roomInfo;
-    }
     async updateFromMQTTMessage(messageSource, messageData, duid = '', tracked = false) {
         const platform = this.platform;
         duid = duid || messageData?.duid || '';
@@ -146,7 +92,7 @@ export class PlatformRunner {
                     }
                     else {
                         const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-                        const roomMap = await this.getRoomMap(duid);
+                        const roomMap = await getRoomMap(duid, this.platform);
                         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;
@@ -237,7 +183,7 @@ export class PlatformRunner {
                 }
                 case Protocol.rpc_response: {
                     const response = data.dps[messageType];
-                    if (!self.isStatusUpdate(response.result)) {
+                    if (!isStatusUpdate(response.result)) {
                         platform.log.debug('Ignore message:', debugStringify(data));
                         return;
                     }
@@ -309,15 +255,6 @@ export class PlatformRunner {
         }
         return undefined;
     }
-    isStatusUpdate(result) {
-        return (Array.isArray(result) &&
-            result.length > 0 &&
-            typeof result[0] === 'object' &&
-            result[0] !== null &&
-            'msg_ver' in result[0] &&
-            result[0].msg_ver !== undefined &&
-            result[0].msg_ver !== null);
-    }
     updateFromHomeData(homeData) {
         const platform = this.platform;
         if (platform.robots.size === 0)

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

@@ -61,10 +61,10 @@ export class LocalNetworkClient extends AbstractClient {
     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}`);
-        await this.sendHelloMessage();
-        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         this.connected = true;
         this.retryCount = 0;
+        await this.sendHelloMessage();
+        this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
         await this.connectionListeners.onConnected(this.duid);
     }
     async onDisconnect(hadError) {

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

@@ -18,10 +18,6 @@ export class SyncMessageListener {
             const dps = message.get(Protocol.rpc_response);
             const messageId = dps.id;
             const responseHandler = this.pending.get(messageId);
-            const result = dps.result;
-            if (result && result.length == 1 && result[0] == 'ok') {
-                return;
-            }
             if (responseHandler) {
                 responseHandler(dps.result);
             }

package/dist/roborockCommunication/broadcast/messageProcessor.js

@@ -80,7 +80,7 @@ export class MessageProcessor {
     }
     async findMyRobot(duid) {
         const request = new RequestMessage({ method: 'find_me' });
-        return this.client.send(duid, request);
+        return this.client.get(duid, request);
     }
     async getCleanModeData(duid) {
         const currentMopMode = await this.getCustomMessage(duid, new RequestMessage({ method: 'get_mop_mode' }));

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

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

package/src/helper.ts

@@ -1,4 +1,8 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
+import { RoborockMatterbridgePlatform } from './platform.js';
 import { Device } from './roborockCommunication/index.js';
+import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
 
 export function getVacuumProperty(device: Device, property: string): number | undefined {
   if (device) {
@@ -20,3 +24,82 @@ export function getVacuumProperty(device: Device, property: string): number | un
 export function isSupportedDevice(model: string): boolean {
   return model.startsWith('roborock.vacuum.');
 }
+
+export function isStatusUpdate(result: unknown): boolean {
+  return (
+    Array.isArray(result) &&
+    result.length > 0 &&
+    typeof result[0] === 'object' &&
+    result[0] !== null &&
+    'msg_ver' in result[0] &&
+    (result[0] as CloudMessageResult).msg_ver !== undefined &&
+    (result[0] as CloudMessageResult).msg_ver !== null
+  );
+}
+
+export async function getRoomMap(duid: string, platform: RoborockMatterbridgePlatform): Promise<RoomMap | undefined> {
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+    return undefined;
+  }
+
+  if (platform.roborockService === undefined) return undefined;
+
+  const rooms = robot.device.rooms ?? [];
+  // if (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
+  if (robot.roomInfo === undefined) {
+    const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+      return robot.roomInfo;
+    }
+  }
+
+  if (robot.roomInfo === undefined) {
+    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.iot_name_id), r.tag] as [number, number, number]);
+      robot.roomInfo = new RoomMap(roomDataMap, rooms);
+    }
+  }
+
+  return robot.roomInfo;
+}
+
+export async function getRoomMapFromDevice(device: Device, platform: RoborockMatterbridgePlatform): Promise<RoomMap> {
+  const rooms = device?.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.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) {
+      const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
+
+      const roomMap = new RoomMap(roomDataMap, rooms);
+
+      platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+      platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+      return roomMap;
+    }
+  }
+
+  return new RoomMap([], rooms);
+}

package/src/initialData/getSupportedAreas.ts

@@ -1,6 +1,6 @@
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { ServiceArea } from 'matterbridge/matter/clusters';
-import RoomMap from '../model/RoomMap.js';
+import { RoomMap } from '../model/RoomMap.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 import { randomInt } from 'node:crypto';
 

package/src/model/RoomMap.ts

@@ -17,7 +17,7 @@ roomMap = {
 
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 
-export default class RoomMap {
+export class RoomMap {
   readonly rooms: {
     id: number;
     globalId: number | undefined;

package/src/platform.ts

@@ -4,7 +4,7 @@ import { AnsiLogger, debugStringify, LogLevel } from 'matterbridge/logger';
 import RoborockService from './roborockService.js';
 import { PLUGIN_NAME } from './settings.js';
 import ClientManager from './clientManager.js';
-import { isSupportedDevice } from './helper.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
 import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
@@ -231,7 +231,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }) as Room);
     }
 
-    const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+    const roomMap = await getRoomMapFromDevice(vacuum, this);
 
     this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
 

package/src/platformRunner.ts

@@ -1,10 +1,9 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getVacuumProperty } from './helper.js';
+import { getRoomMap, getVacuumProperty, isStatusUpdate } from './helper.js';
 import { getRunningMode } from './initialData/getSupportedRunModes.js';
 import { CloudMessageModel } from './model/CloudMessageModel.js';
 import { RoborockMatterbridgePlatform } from './platform.js';
 import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
-import RoomMap from './model/RoomMap.js';
 import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
 import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
@@ -41,76 +40,6 @@ export class PlatformRunner {
     await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
   }
 
-  public async getRoomMapFromDevice(device: Device): Promise<RoomMap> {
-    const platform = this.platform;
-    const rooms = device?.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.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) {
-        const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
-
-        const roomMap = new RoomMap(roomDataMap, rooms);
-
-        platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-        platform.log.notice('-------------------------------------------2--------------------------------------------------------');
-        return roomMap;
-      }
-    }
-
-    return new RoomMap([], rooms);
-  }
-
-  private async getRoomMap(duid: string): Promise<RoomMap | undefined> {
-    const platform = this.platform;
-
-    const robot = platform.robots.get(duid);
-    if (robot === undefined) {
-      platform.log.error(`Error6: Robot with DUID ${duid} not found`);
-      return undefined;
-    }
-
-    if (platform.roborockService === undefined) return undefined;
-
-    const rooms = robot.device.rooms ?? [];
-    // if (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
-    if (robot.roomInfo === undefined) {
-      const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-      if (roomData !== undefined && roomData.length > 0) {
-        robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-        return robot.roomInfo;
-      }
-    }
-
-    if (robot.roomInfo === undefined) {
-      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.iot_name_id), r.tag] as [number, number, number]);
-        robot.roomInfo = new RoomMap(roomDataMap, rooms);
-      }
-    }
-
-    return robot.roomInfo;
-  }
-
   private async updateFromMQTTMessage(messageSource: NotifyMessageTypes, messageData: unknown, duid = '', tracked = false): Promise<void> {
     const platform = this.platform;
     duid = duid || (messageData as DeviceStatusNotify)?.duid || '';
@@ -191,7 +120,7 @@ export class PlatformRunner {
             robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
           } else {
             const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-            const roomMap = await this.getRoomMap(duid);
+            const roomMap = await getRoomMap(duid, this.platform);
 
             // Get current room from segment_id
             const segment_id = data.cleaning_info?.segment_id ?? -1;
@@ -311,7 +240,7 @@ export class PlatformRunner {
         case Protocol.rpc_response: {
           const response = data.dps[messageType] as DpsPayload;
           // ignore network info
-          if (!self.isStatusUpdate(response.result)) {
+          if (!isStatusUpdate(response.result)) {
             platform.log.debug('Ignore message:', debugStringify(data));
             return;
           }
@@ -398,18 +327,6 @@ export class PlatformRunner {
     return undefined;
   }
 
-  private isStatusUpdate(result: unknown): boolean {
-    return (
-      Array.isArray(result) &&
-      result.length > 0 &&
-      typeof result[0] === 'object' &&
-      result[0] !== null &&
-      'msg_ver' in result[0] &&
-      (result[0] as CloudMessageResult).msg_ver !== undefined &&
-      (result[0] as CloudMessageResult).msg_ver !== null
-    );
-  }
-
   private updateFromHomeData(homeData: Home): void {
     const platform = this.platform;
 

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

@@ -80,12 +80,11 @@ export class LocalNetworkClient extends AbstractClient {
   private async onConnect(): Promise<void> {
     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;
+    this.retryCount = 0;
 
     await this.sendHelloMessage();
     this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
-
-    this.connected = true;
-    this.retryCount = 0;
     await this.connectionListeners.onConnected(this.duid);
   }
 

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

@@ -28,10 +28,10 @@ export class SyncMessageListener implements AbstractMessageListener {
       const messageId = dps.id;
 
       const responseHandler = this.pending.get(messageId);
-      const result = dps.result as Record<string, unknown>;
-      if (result && result.length == 1 && result[0] == 'ok') {
-        return;
-      }
+      // const result = dps.result as Record<string, unknown>;
+      // if (result && result.length == 1 && result[0] == 'ok') {
+      //   return;
+      // }
 
       if (responseHandler) {
         responseHandler(dps.result as ResponseMessage);

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -105,9 +105,9 @@ export class MessageProcessor {
     return this.client.get(duid, def);
   }
 
-  public async findMyRobot(duid: string): Promise<void> {
+  public async findMyRobot(duid: string): Promise<unknown> {
     const request = new RequestMessage({ method: 'find_me' });
-    return this.client.send(duid, request);
+    return this.client.get(duid, request);
   }
 
   public async getCleanModeData(duid: string): Promise<{ suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> {

package/src/rvc.ts

@@ -1,5 +1,5 @@
 import { RoboticVacuumCleaner } from 'matterbridge/devices';
-import RoomMap from './model/RoomMap.js';
+import { RoomMap } from './model/RoomMap.js';
 import { Device } from './roborockCommunication/index.js';
 import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
 import { AnsiLogger } from 'matterbridge/logger';

package/src/tests/platformRunner2.test.ts

@@ -1,11 +1,9 @@
-import RoomMap from '../model/RoomMap';
-import { RoborockMatterbridgePlatform } from '../platform';
-import { PlatformRunner } from '../platformRunner';
+import { getRoomMapFromDevice } from '../helper';
+import { RoomMap } from '../model/RoomMap';
 import { MapInfo } from '../roborockCommunication';
 
 describe('PlatformRunner.getRoomMapFromDevice', () => {
   let platform: any;
-  let runner: PlatformRunner;
 
   beforeEach(() => {
     platform = {
@@ -19,7 +17,6 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
         getMapInformation: jest.fn(),
       },
     };
-    runner = new PlatformRunner(platform as RoborockMatterbridgePlatform);
   });
 
   it('returns RoomMap with roomData from getRoomMappings if available', async () => {
@@ -42,7 +39,7 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
     platform.roborockService.getRoomMappings.mockResolvedValue(roomData);
     platform.roborockService.getMapInformation.mockResolvedValue(undefined);
 
-    const result = await runner.getRoomMapFromDevice(device as any);
+    const result = await getRoomMapFromDevice(device as any, platform);
 
     expect(result).toBeInstanceOf(RoomMap);
     expect(result.rooms.length).toEqual(4);
@@ -83,7 +80,7 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
     platform.roborockService.getRoomMappings.mockResolvedValue(undefined);
     platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
 
-    const result = await runner.getRoomMapFromDevice(device as any);
+    const result = await getRoomMapFromDevice(device as any, platform);
 
     expect(result).toBeInstanceOf(RoomMap);
     expect(result.rooms.length).toEqual(4);

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

@@ -35,7 +35,7 @@ describe('SyncMessageListener', () => {
     expect(listener['pending'].has(messageId)).toBe(false);
   });
 
-  it('should not call resolve if result is ["ok"]', async () => {
+  it('should call resolve if result is ["ok"]', async () => {
     const resolve = jest.fn();
     const reject = jest.fn();
     const messageId = 456;
@@ -49,8 +49,8 @@ describe('SyncMessageListener', () => {
 
     await listener.onMessage(message);
 
-    expect(resolve).not.toHaveBeenCalled();
-    expect(listener['pending'].has(messageId)).toBe(true);
+    expect(resolve).toHaveBeenCalled();
+    expect(listener['pending'].has(messageId)).toBe(false);
   });
 
   it('should remove pending on map_response', async () => {

package/src/tests/roborockCommunication/broadcast/messageProcessor.test.ts

@@ -104,7 +104,7 @@ describe('MessageProcessor', () => {
 
   it('findMyRobot should call client.send', async () => {
     await processor.findMyRobot('duid');
-    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+    expect(mockClient.get).toHaveBeenCalledWith('duid', expect.any(Object));
   });
 
   it('getCleanModeData should parse and return correct values', async () => {