matterbridge-roborock-vacuum-plugin 1.1.0-rc03 → 1.1.0-rc05

package/.github/workflows/build.yml

@@ -13,6 +13,11 @@ jobs:
         os: [ubuntu-latest, windows-latest, macos-latest]
 
     steps:
+      - name: Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@0.12.0
+        with:
+          access_token: ${{ github.token }}
+
       - name: Checkout code
         uses: actions/checkout@v4
 

package/.github/workflows/coverage.yml

@@ -7,6 +7,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
+      - name: Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@0.12.0
+        with:
+          access_token: ${{ github.token }}
+
       - name: Checkout code
         uses: actions/checkout@v4
 

package/dist/platform.js

@@ -82,7 +82,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
             this.log.error('Initializing: No device found');
             return;
         }
-        if (!this.enableExperimentalFeature || !this.enableExperimentalFeature.advancedFeature.enableServerMode) {
+        if (!this.enableExperimentalFeature?.enableExperimentalFeature || !this.enableExperimentalFeature?.advancedFeature?.enableServerMode) {
             vacuums = [vacuums[0]];
         }
         for (const vacuum of vacuums) {

package/dist/roborockService.js

@@ -12,9 +12,9 @@ export default class RoborockService {
     deviceNotify;
     messageClient;
     remoteDevices = new Set();
-    messageProcessor;
-    ip;
-    localClient;
+    messageProcessorMap = new Map();
+    ipMap = new Map();
+    localClientMap = new Map();
     clientManager;
     refreshInterval;
     requestDeviceStatusInterval;
@@ -32,11 +32,12 @@ export default class RoborockService {
         const userdata = await this.loginApi.loginWithPassword(username, password);
         return this.auth(userdata);
     }
-    getMessageProcessor() {
-        if (!this.messageProcessor) {
+    getMessageProcessor(duid) {
+        const messageProcessor = this.messageProcessorMap.get(duid);
+        if (!messageProcessor) {
             this.logger.error('MessageApi is not initialized.');
         }
-        return this.messageProcessor;
+        return messageProcessor;
     }
     setSelectedAreas(duid, selectedAreas) {
         this.logger.debug('RoborockService - setSelectedAreas', selectedAreas);
@@ -53,7 +54,7 @@ export default class RoborockService {
     }
     async getCleanModeData(duid) {
         this.logger.notice('RoborockService - getCleanModeData');
-        const data = await this.messageProcessor?.getCleanModeData(duid);
+        const data = await this.getMessageProcessor(duid)?.getCleanModeData(duid);
         if (!data) {
             throw new Error('Failed to retrieve clean mode data');
         }
@@ -61,7 +62,7 @@ export default class RoborockService {
     }
     async changeCleanMode(duid, { suctionPower, waterFlow, distance_off, mopRoute }) {
         this.logger.notice('RoborockService - changeCleanMode');
-        return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
+        return this.getMessageProcessor(duid)?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
     }
     async startClean(duid) {
         const supportedRooms = this.supportedAreas.get(duid) ?? [];
@@ -71,11 +72,11 @@ export default class RoborockService {
         if (supportedRoutines.length === 0) {
             if (selected.length == supportedRooms.length || selected.length === 0 || supportedRooms.length === 0) {
                 this.logger.debug('RoborockService - startGlobalClean');
-                this.getMessageProcessor()?.startClean(duid);
+                this.getMessageProcessor(duid)?.startClean(duid);
             }
             else {
                 this.logger.debug('RoborockService - startRoomClean', debugStringify({ duid, selected }));
-                return this.messageProcessor?.startRoomClean(duid, selected, 1);
+                return this.getMessageProcessor(duid)?.startRoomClean(duid, selected, 1);
             }
         }
         else {
@@ -91,11 +92,11 @@ export default class RoborockService {
             }
             else if (rooms.length == supportedRooms.length || rooms.length === 0 || supportedRooms.length === 0) {
                 this.logger.debug('RoborockService - startGlobalClean');
-                this.getMessageProcessor()?.startClean(duid);
+                this.getMessageProcessor(duid)?.startClean(duid);
             }
             else if (rooms.length > 0) {
                 this.logger.debug('RoborockService - startRoomClean', debugStringify({ duid, rooms }));
-                return this.messageProcessor?.startRoomClean(duid, rooms, 1);
+                return this.getMessageProcessor(duid)?.startRoomClean(duid, rooms, 1);
             }
             else {
                 this.logger.warn('RoborockService - something goes wrong.', debugStringify({ duid, rooms, rt, selected, supportedRooms, supportedRoutines }));
@@ -105,42 +106,50 @@ export default class RoborockService {
     }
     async pauseClean(duid) {
         this.logger.debug('RoborockService - pauseClean');
-        await this.getMessageProcessor()?.pauseClean(duid);
+        await this.getMessageProcessor(duid)?.pauseClean(duid);
     }
     async stopAndGoHome(duid) {
         this.logger.debug('RoborockService - stopAndGoHome');
-        await this.getMessageProcessor()?.gotoDock(duid);
+        await this.getMessageProcessor(duid)?.gotoDock(duid);
     }
     async resumeClean(duid) {
         this.logger.debug('RoborockService - resumeClean');
-        await this.getMessageProcessor()?.resumeClean(duid);
+        await this.getMessageProcessor(duid)?.resumeClean(duid);
     }
     async playSoundToLocate(duid) {
         this.logger.debug('RoborockService - findMe');
-        await this.getMessageProcessor()?.findMyRobot(duid);
+        await this.getMessageProcessor(duid)?.findMyRobot(duid);
     }
     async customGet(duid, method) {
         this.logger.debug('RoborockService - customSend-message', method);
-        return this.getMessageProcessor()?.getCustomMessage(duid, new RequestMessage({ method }));
+        return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method }));
     }
     async customGetInSecure(duid, method) {
         this.logger.debug('RoborockService - customGetInSecure-message', method);
-        return this.getMessageProcessor()?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
+        return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
     }
     async customSend(duid, request) {
-        return this.getMessageProcessor()?.sendCustomMessage(duid, request);
+        return this.getMessageProcessor(duid)?.sendCustomMessage(duid, request);
     }
     stopService() {
         if (this.messageClient) {
             this.messageClient.disconnect();
             this.messageClient = undefined;
         }
-        if (this.localClient) {
-            this.localClient.disconnect();
-            this.localClient = undefined;
+        if (this.localClientMap.size > 0) {
+            for (const [duid, client] of this.localClientMap.entries()) {
+                this.logger.debug('Disconnecting local client for device', duid);
+                client.disconnect();
+                this.localClientMap.delete(duid);
+                this.logger.debug('Local client disconnected for device', duid);
+            }
         }
-        if (this.messageProcessor) {
-            this.messageProcessor = undefined;
+        if (this.messageProcessorMap.size > 0) {
+            for (const [duid] of this.messageProcessorMap.entries()) {
+                this.logger.debug('Disconnecting message processor for device', duid);
+                this.messageProcessorMap.delete(duid);
+                this.logger.debug('Message processor disconnected for device', duid);
+            }
         }
         if (this.requestDeviceStatusInterval) {
             clearInterval(this.requestDeviceStatusInterval);
@@ -153,9 +162,10 @@ export default class RoborockService {
     async 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 (this.messageProcessor) {
-                await this.messageProcessor.getDeviceStatus(device.duid).then((response) => {
+            if (messageProcessor) {
+                await messageProcessor.getDeviceStatus(device.duid).then((response) => {
                     if (self.deviceNotify) {
                         const message = { duid: device.duid, ...response.errorStatus, ...response.message };
                         self.logger.debug('Device status update', debugStringify(message));
@@ -307,9 +317,9 @@ export default class RoborockService {
             return;
         }
         const self = this;
-        this.messageProcessor = new MessageProcessor(this.messageClient);
-        this.messageProcessor.injectLogger(this.logger);
-        this.messageProcessor.registerListener({
+        const messageProcessor = new MessageProcessor(this.messageClient);
+        messageProcessor.injectLogger(this.logger);
+        messageProcessor.registerListener({
             onError: (message) => {
                 if (self.deviceNotify) {
                     self.deviceNotify(NotifyMessageTypes.ErrorOccurred, { duid: device.duid, errorCode: message });
@@ -323,26 +333,30 @@ export default class RoborockService {
             onStatusChanged: () => {
             },
         });
+        this.messageProcessorMap.set(device.duid, messageProcessor);
         this.logger.debug('Local device', device.duid);
+        let localIp = this.ipMap.get(device.duid);
         try {
-            if (!this.ip) {
+            if (!localIp) {
                 this.logger.debug('Requesting network info for device', device.duid);
-                const networkInfo = await this.messageProcessor.getNetworkInfo(device.duid);
-                this.ip = networkInfo.ip;
+                const networkInfo = await messageProcessor.getNetworkInfo(device.duid);
+                localIp = networkInfo.ip;
             }
-            if (this.ip) {
-                this.logger.debug('initializing the local connection for this client towards ' + this.ip);
-                this.localClient = this.messageClient.registerClient(device.duid, this.ip);
-                this.localClient.connect();
+            if (localIp) {
+                this.logger.debug('initializing the local connection for this client towards ' + localIp);
+                const localClient = this.messageClient.registerClient(device.duid, localIp);
+                localClient.connect();
                 let count = 0;
-                while (!this.localClient.isConnected() && count < 20) {
+                while (!localClient.isConnected() && count < 20) {
                     this.logger.debug('Keep waiting for local client to connect');
                     count++;
-                    await this.sleep(500);
+                    await this.sleep(200);
                 }
-                if (!this.localClient.isConnected()) {
+                if (!localClient.isConnected()) {
                     throw new Error('Local client did not connect after 10 attempts, something is wrong');
                 }
+                this.ipMap.set(device.duid, localIp);
+                this.localClientMap.set(device.duid, localClient);
                 this.logger.debug('LocalClient connected');
             }
         }

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

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc03",
+  "version": "1.1.0-rc05",
   "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-rc03 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc05 by https://github.com/RinDevJunior",
   "type": "object",
   "required": [
     "username",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc03",
+  "version": "1.1.0-rc05",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",

package/src/platform.ts

@@ -111,7 +111,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       return;
     }
 
-    if (!this.enableExperimentalFeature || !this.enableExperimentalFeature.advancedFeature.enableServerMode) {
+    if (!this.enableExperimentalFeature?.enableExperimentalFeature || !this.enableExperimentalFeature?.advancedFeature?.enableServerMode) {
       vacuums = [vacuums[0]]; // If server mode is not enabled, only use the first vacuum
     }
     // else {
@@ -179,6 +179,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     this.log.info('onConfigurateDevice finished');
   }
 
+  // Running in loop to configurate devices
   private async configurateDevice(vacuum: Device) {
     const username = this.config.username as string;
 

package/src/roborockService.ts

@@ -42,9 +42,9 @@ export default class RoborockService {
   deviceNotify?: (messageSource: NotifyMessageTypes, homeData: unknown) => void;
   messageClient: ClientRouter | undefined;
   remoteDevices = new Set<string>();
-  messageProcessor: MessageProcessor | undefined;
-  ip: string | undefined;
-  localClient: Client | undefined;
+  messageProcessorMap = new Map<string, MessageProcessor>();
+  ipMap = new Map<string, string>();
+  localClientMap = new Map<string, Client>();
   clientManager: ClientManager;
   refreshInterval: number;
   requestDeviceStatusInterval: NodeJS.Timeout | undefined;
@@ -73,11 +73,12 @@ export default class RoborockService {
     return this.auth(userdata);
   }
 
-  public getMessageProcessor(): MessageProcessor | undefined {
-    if (!this.messageProcessor) {
+  public getMessageProcessor(duid: string): MessageProcessor | undefined {
+    const messageProcessor = this.messageProcessorMap.get(duid);
+    if (!messageProcessor) {
       this.logger.error('MessageApi is not initialized.');
     }
-    return this.messageProcessor;
+    return messageProcessor;
   }
 
   public setSelectedAreas(duid: string, selectedAreas: number[]): void {
@@ -99,7 +100,7 @@ export default class RoborockService {
 
   public async getCleanModeData(duid: string): Promise<{ suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> {
     this.logger.notice('RoborockService - getCleanModeData');
-    const data = await this.messageProcessor?.getCleanModeData(duid);
+    const data = await this.getMessageProcessor(duid)?.getCleanModeData(duid);
     if (!data) {
       throw new Error('Failed to retrieve clean mode data');
     }
@@ -111,7 +112,7 @@ export default class RoborockService {
     { suctionPower, waterFlow, distance_off, mopRoute }: { suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number },
   ): Promise<void> {
     this.logger.notice('RoborockService - changeCleanMode');
-    return this.messageProcessor?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
+    return this.getMessageProcessor(duid)?.changeCleanMode(duid, suctionPower, waterFlow, mopRoute, distance_off);
   }
 
   public async startClean(duid: string): Promise<void> {
@@ -123,10 +124,10 @@ export default class RoborockService {
     if (supportedRoutines.length === 0) {
       if (selected.length == supportedRooms.length || selected.length === 0 || supportedRooms.length === 0) {
         this.logger.debug('RoborockService - startGlobalClean');
-        this.getMessageProcessor()?.startClean(duid);
+        this.getMessageProcessor(duid)?.startClean(duid);
       } else {
         this.logger.debug('RoborockService - startRoomClean', debugStringify({ duid, selected }));
-        return this.messageProcessor?.startRoomClean(duid, selected, 1);
+        return this.getMessageProcessor(duid)?.startRoomClean(duid, selected, 1);
       }
     } else {
       const rooms = selected.filter((slt) => supportedRooms.some((a: ServiceArea.Area) => a.areaId == slt));
@@ -146,13 +147,13 @@ export default class RoborockService {
          * If no rooms are selected, or all selected rooms match the supported rooms,
          */
         this.logger.debug('RoborockService - startGlobalClean');
-        this.getMessageProcessor()?.startClean(duid);
+        this.getMessageProcessor(duid)?.startClean(duid);
       } else if (rooms.length > 0) {
         /**
          * If there are rooms selected
          */
         this.logger.debug('RoborockService - startRoomClean', debugStringify({ duid, rooms }));
-        return this.messageProcessor?.startRoomClean(duid, rooms, 1);
+        return this.getMessageProcessor(duid)?.startRoomClean(duid, rooms, 1);
       } else {
         this.logger.warn('RoborockService - something goes wrong.', debugStringify({ duid, rooms, rt, selected, supportedRooms, supportedRoutines }));
         return;
@@ -162,36 +163,36 @@ export default class RoborockService {
 
   public async pauseClean(duid: string): Promise<void> {
     this.logger.debug('RoborockService - pauseClean');
-    await this.getMessageProcessor()?.pauseClean(duid);
+    await this.getMessageProcessor(duid)?.pauseClean(duid);
   }
 
   public async stopAndGoHome(duid: string): Promise<void> {
     this.logger.debug('RoborockService - stopAndGoHome');
-    await this.getMessageProcessor()?.gotoDock(duid);
+    await this.getMessageProcessor(duid)?.gotoDock(duid);
   }
 
   public async resumeClean(duid: string): Promise<void> {
     this.logger.debug('RoborockService - resumeClean');
-    await this.getMessageProcessor()?.resumeClean(duid);
+    await this.getMessageProcessor(duid)?.resumeClean(duid);
   }
 
   public async playSoundToLocate(duid: string): Promise<void> {
     this.logger.debug('RoborockService - findMe');
-    await this.getMessageProcessor()?.findMyRobot(duid);
+    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()?.getCustomMessage(duid, new RequestMessage({ 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()?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
+    return this.getMessageProcessor(duid)?.getCustomMessage(duid, new RequestMessage({ method, secure: true }));
   }
 
   public async customSend(duid: string, request: RequestMessage): Promise<void> {
-    return this.getMessageProcessor()?.sendCustomMessage(duid, request);
+    return this.getMessageProcessor(duid)?.sendCustomMessage(duid, request);
   }
 
   public stopService(): void {
@@ -200,13 +201,21 @@ export default class RoborockService {
       this.messageClient = undefined;
     }
 
-    if (this.localClient) {
-      this.localClient.disconnect();
-      this.localClient = undefined;
+    if (this.localClientMap.size > 0) {
+      for (const [duid, client] of this.localClientMap.entries()) {
+        this.logger.debug('Disconnecting local client for device', duid);
+        client.disconnect();
+        this.localClientMap.delete(duid);
+        this.logger.debug('Local client disconnected for device', duid);
+      }
     }
 
-    if (this.messageProcessor) {
-      this.messageProcessor = undefined;
+    if (this.messageProcessorMap.size > 0) {
+      for (const [duid] of this.messageProcessorMap.entries()) {
+        this.logger.debug('Disconnecting message processor for device', duid);
+        this.messageProcessorMap.delete(duid);
+        this.logger.debug('Message processor disconnected for device', duid);
+      }
     }
 
     if (this.requestDeviceStatusInterval) {
@@ -223,9 +232,10 @@ export default class RoborockService {
     // 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 (this.messageProcessor) {
-        await this.messageProcessor.getDeviceStatus(device.duid).then((response: DeviceStatus) => {
+      if (messageProcessor) {
+        await messageProcessor.getDeviceStatus(device.duid).then((response: DeviceStatus) => {
           if (self.deviceNotify) {
             const message = { duid: device.duid, ...response.errorStatus, ...response.message } as DeviceStatusNotify;
             self.logger.debug('Device status update', debugStringify(message));
@@ -407,9 +417,9 @@ export default class RoborockService {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
 
-    this.messageProcessor = new MessageProcessor(this.messageClient);
-    this.messageProcessor.injectLogger(this.logger);
-    this.messageProcessor.registerListener({
+    const messageProcessor = new MessageProcessor(this.messageClient);
+    messageProcessor.injectLogger(this.logger);
+    messageProcessor.registerListener({
       onError: (message: VacuumErrorCode) => {
         if (self.deviceNotify) {
           self.deviceNotify(NotifyMessageTypes.ErrorOccurred, { duid: device.duid, errorCode: message } as DeviceErrorMessage);
@@ -430,30 +440,35 @@ export default class RoborockService {
       },
     } as AbstractMessageHandler);
 
+    this.messageProcessorMap.set(device.duid, messageProcessor);
+
     this.logger.debug('Local device', device.duid);
+    let localIp = this.ipMap.get(device.duid);
     try {
-      if (!this.ip) {
+      if (!localIp) {
         this.logger.debug('Requesting network info for device', device.duid);
-        const networkInfo = await this.messageProcessor.getNetworkInfo(device.duid);
-        this.ip = networkInfo.ip;
+        const networkInfo = await messageProcessor.getNetworkInfo(device.duid);
+        localIp = networkInfo.ip;
       }
 
-      if (this.ip) {
-        this.logger.debug('initializing the local connection for this client towards ' + this.ip);
-        this.localClient = this.messageClient.registerClient(device.duid, this.ip) as LocalNetworkClient;
-        this.localClient.connect();
+      if (localIp) {
+        this.logger.debug('initializing the local connection for this client towards ' + localIp);
+        const localClient = this.messageClient.registerClient(device.duid, localIp) as LocalNetworkClient;
+        localClient.connect();
 
         let count = 0;
-        while (!this.localClient.isConnected() && count < 20) {
+        while (!localClient.isConnected() && count < 20) {
           this.logger.debug('Keep waiting for local client to connect');
           count++;
-          await this.sleep(500);
+          await this.sleep(200);
         }
 
-        if (!this.localClient.isConnected()) {
+        if (!localClient.isConnected()) {
           throw new Error('Local client did not connect after 10 attempts, something is wrong');
         }
 
+        this.ipMap.set(device.duid, localIp);
+        this.localClientMap.set(device.duid, localClient);
         this.logger.debug('LocalClient connected');
       }
     } catch (error) {

package/src/tests/roborockService.test.ts

@@ -2,6 +2,7 @@ import { AnsiLogger } from 'matterbridge/logger';
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import RoborockService from '../roborockService';
 import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { Device } from '../roborockCommunication';
 
 describe('RoborockService - startClean', () => {
   let roborockService: RoborockService;
@@ -22,7 +23,7 @@ describe('RoborockService - startClean', () => {
     } as any;
 
     roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
-    roborockService['messageProcessor'] = mockMessageProcessor;
+    roborockService['messageProcessorMap'] = new Map<string, MessageProcessor>([['test-duid', mockMessageProcessor]]);
   });
 
   it('should start global clean when no areas or selected areas are provided', async () => {
@@ -152,4 +153,252 @@ describe('RoborockService - startClean', () => {
     expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startRoomClean', expect.anything());
     expect(mockMessageProcessor.startRoomClean).toHaveBeenCalledWith(duid, [1, 3], 1);
   });
+
+  it('should initialize and store MessageProcessor for the given duid', () => {
+    const duid = 'test-duid';
+    roborockService.initializeMessageClientForLocal({ duid } as Device);
+    const storedProcessor = roborockService['messageProcessorMap'].get(duid);
+    expect(storedProcessor).not.toBeUndefined();
+  });
+});
+
+describe('RoborockService - basic setters/getters', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+  });
+
+  it('setSelectedAreas should set selected areas', () => {
+    roborockService.setSelectedAreas('duid', [1, 2]);
+    expect(roborockService['selectedAreas'].get('duid')).toEqual([1, 2]);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - setSelectedAreas', [1, 2]);
+  });
+
+  it('setSupportedAreas should set supported areas', () => {
+    const areas = [{ areaId: 1, mapId: null, areaInfo: {} as any }];
+    roborockService.setSupportedAreas('duid', areas);
+    expect(roborockService['supportedAreas'].get('duid')).toEqual(areas);
+  });
+
+  it('setSupportedScenes should set supported routines', () => {
+    const routines = [{ areaId: 99, mapId: null, areaInfo: {} as any }];
+    roborockService.setSupportedScenes('duid', routines);
+    expect(roborockService['supportedRoutines'].get('duid')).toEqual(routines);
+  });
+
+  it('getSupportedAreas should return supported areas', () => {
+    const areas = [{ areaId: 1, mapId: null, areaInfo: {} as any }];
+    roborockService['supportedAreas'].set('duid', areas);
+    expect(roborockService.getSupportedAreas('duid')).toEqual(areas);
+  });
+});
+
+describe('RoborockService - getMessageProcessor', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { startClean: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+  });
+
+  it('should return processor if present', () => {
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+    expect(roborockService.getMessageProcessor('duid')).toBe(mockMessageProcessor);
+  });
+
+  it('should log error if processor not present', () => {
+    expect(roborockService.getMessageProcessor('unknown')).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('MessageApi is not initialized.');
+  });
+});
+
+describe('RoborockService - getCleanModeData', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { getCleanModeData: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('should return clean mode data', async () => {
+    mockMessageProcessor.getCleanModeData.mockResolvedValue({ suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    const result = await roborockService.getCleanModeData('duid');
+    expect(result).toEqual({ suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    expect(mockLogger.notice).toHaveBeenCalledWith('RoborockService - getCleanModeData');
+  });
+});
+
+describe('RoborockService - changeCleanMode', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { changeCleanMode: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('should call changeCleanMode on processor', async () => {
+    await roborockService.changeCleanMode('duid', { suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    expect(mockLogger.notice).toHaveBeenCalledWith('RoborockService - changeCleanMode');
+    expect(mockMessageProcessor.changeCleanMode).toHaveBeenCalledWith('duid', 1, 2, 4, 3);
+  });
+});
+
+describe('RoborockService - pause/stop/resume/playSound', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = {
+      pauseClean: jest.fn(),
+      gotoDock: jest.fn(),
+      resumeClean: jest.fn(),
+      findMyRobot: jest.fn(),
+    } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('pauseClean should call processor and log', async () => {
+    await roborockService.pauseClean('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - pauseClean');
+    expect(mockMessageProcessor.pauseClean).toHaveBeenCalledWith('duid');
+  });
+
+  it('stopAndGoHome should call processor and log', async () => {
+    await roborockService.stopAndGoHome('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - stopAndGoHome');
+    expect(mockMessageProcessor.gotoDock).toHaveBeenCalledWith('duid');
+  });
+
+  it('resumeClean should call processor and log', async () => {
+    await roborockService.resumeClean('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - resumeClean');
+    expect(mockMessageProcessor.resumeClean).toHaveBeenCalledWith('duid');
+  });
+
+  it('playSoundToLocate should call processor and log', async () => {
+    await roborockService.playSoundToLocate('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - findMe');
+    expect(mockMessageProcessor.findMyRobot).toHaveBeenCalledWith('duid');
+  });
+});
+
+describe('RoborockService - customGet/customGetInSecure/customSend', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = {
+      getCustomMessage: jest.fn(),
+      sendCustomMessage: jest.fn(),
+    } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('customGet should call getCustomMessage', async () => {
+    mockMessageProcessor.getCustomMessage.mockResolvedValue('result');
+    const result = await roborockService.customGet('duid', 'method');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customSend-message', 'method');
+    expect(mockMessageProcessor.getCustomMessage).toHaveBeenCalledWith('duid', expect.any(Object));
+    expect(result).toBe('result');
+  });
+
+  it('customGetInSecure should call getCustomMessage with secure', async () => {
+    mockMessageProcessor.getCustomMessage.mockResolvedValue('secureResult');
+    const result = await roborockService.customGetInSecure('duid', 'method');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customGetInSecure-message', 'method');
+    expect(mockMessageProcessor.getCustomMessage).toHaveBeenCalledWith('duid', expect.objectContaining({ secure: true }));
+    expect(result).toBe('secureResult');
+  });
+
+  it('customSend should call sendCustomMessage', async () => {
+    const req = { foo: 'bar' } as any;
+    await roborockService.customSend('duid', req);
+    expect(mockMessageProcessor.sendCustomMessage).toHaveBeenCalledWith('duid', req);
+  });
+});
+
+describe('RoborockService - stopService', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageClient: any;
+  let mockLocalClient: any;
+  let mockMessageProcessor: any;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageClient = { disconnect: jest.fn() };
+    mockLocalClient = { disconnect: jest.fn(), isConnected: jest.fn() };
+    mockMessageProcessor = {};
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService.messageClient = mockMessageClient;
+    roborockService.localClientMap.set('duid', mockLocalClient);
+    roborockService.messageProcessorMap.set('duid', mockMessageProcessor);
+    roborockService.requestDeviceStatusInterval = setInterval(() => {
+      jest.fn();
+    }, 1000);
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  it('should disconnect messageClient, localClient, remove processors, clear interval', () => {
+    roborockService.stopService();
+    expect(mockMessageClient.disconnect).toHaveBeenCalled();
+    expect(mockLocalClient.disconnect).toHaveBeenCalled();
+    expect(roborockService.localClientMap.size).toBe(0);
+    expect(roborockService.messageProcessorMap.size).toBe(0);
+    expect(roborockService.requestDeviceStatusInterval).toBeUndefined();
+  });
+});
+
+describe('RoborockService - setDeviceNotify', () => {
+  it('should set deviceNotify callback', () => {
+    const roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, {} as any);
+    const cb = jest.fn();
+    roborockService.setDeviceNotify(cb);
+    expect(roborockService.deviceNotify).toBe(cb);
+  });
+});
+
+describe('RoborockService - sleep', () => {
+  it('should resolve after ms', async () => {
+    const roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, {} as any);
+    const start = Date.now();
+    await roborockService['sleep'](100);
+    expect(Date.now() - start).toBeGreaterThanOrEqual(100);
+  });
+});
+
+describe('RoborockService - auth', () => {
+  it('should set userdata and iotApi', () => {
+    const mockLogger = {} as any;
+    const mockIotApiFactory = jest.fn().mockReturnValue('iotApi');
+    const roborockService = new RoborockService(jest.fn(), mockIotApiFactory, 10, {} as any, mockLogger);
+    const userData = { foo: 'bar' } as any;
+    const result = roborockService['auth'](userData);
+    expect(roborockService['userdata']).toBe(userData);
+    expect(roborockService['iotApi']).toBe('iotApi');
+    expect(result).toBe(userData);
+  });
 });

package/src/tests/roborockService2.test.ts

@@ -0,0 +1,69 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../roborockService';
+import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { Device, DeviceStatus } from '../roborockCommunication';
+
+jest.useFakeTimers();
+
+describe('RoborockService - activateDeviceNotify', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+  let mockDeviceNotify: jest.Mock;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: jest.fn(),
+      notice: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    mockMessageProcessor = {
+      getDeviceStatus: jest.fn(),
+    } as any;
+
+    mockDeviceNotify = jest.fn(() => {
+      jest.fn();
+    });
+
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 1, {} as any, mockLogger); // refreshInterval = 1
+    roborockService['deviceNotify'] = mockDeviceNotify;
+    roborockService['getMessageProcessor'] = jest.fn().mockReturnValue(mockMessageProcessor);
+    roborockService['refreshInterval'] = 1;
+  });
+
+  it('should call getDeviceStatus periodically and notify with status message', async () => {
+    const duid = 'test-duid';
+    const device: Device = { duid } as Device;
+
+    const fakeStatus: DeviceStatus = {
+      errorStatus: { errorCode: 0 },
+      message: { battery: 80 },
+    } as any;
+
+    (roborockService['getMessageProcessor'] as jest.Mock).mockReturnValue(mockMessageProcessor);
+    mockMessageProcessor.getDeviceStatus.mockResolvedValue(fakeStatus);
+
+    await roborockService.activateDeviceNotify(device);
+
+    jest.advanceTimersByTime(2000); // 1s = 1 cycle
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('Requesting device info for device', duid);
+    expect(mockMessageProcessor.getDeviceStatus).toHaveBeenCalledWith(duid);
+  });
+
+  it('should log error if message processor is not found', async () => {
+    const duid = 'not-found-duid';
+    const device: Device = { duid } as Device;
+
+    (roborockService['getMessageProcessor'] as jest.Mock).mockReturnValue(undefined);
+
+    await roborockService.activateDeviceNotify(device);
+
+    jest.advanceTimersByTime(1000); // trigger the interval
+
+    expect(mockLogger.error).toHaveBeenCalledWith('Local client not initialized');
+    expect(mockDeviceNotify).not.toHaveBeenCalled();
+  });
+});