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

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

@@ -3,27 +3,26 @@ export class ConnectionStateListener {
     client;
     clientName;
     shouldReconnect;
-    changeToSecureConnection;
-    constructor(logger, client, clientName, changeToSecureConnection, shouldReconnect = false) {
+    constructor(logger, client, clientName, shouldReconnect = false) {
         this.logger = logger;
         this.client = client;
         this.clientName = clientName;
         this.shouldReconnect = shouldReconnect;
-        this.changeToSecureConnection = changeToSecureConnection;
     }
     async onConnected(duid) {
         this.logger.notice(`Device ${duid} connected to ${this.clientName}`);
     }
-    async onDisconnected(duid) {
+    async onReconnect(duid, message) {
+        this.logger.info(`Device ${duid} reconnected to ${this.clientName} with message: ${message}`);
+    }
+    async onDisconnected(duid, message) {
+        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;
         }
         if (this.client.retryCount > 10) {
             this.logger.error(`Device with DUID ${duid} has exceeded retry limit, not re-registering.`);
-            if (this.changeToSecureConnection) {
-                this.changeToSecureConnection(duid);
-            }
             return;
         }
         this.client.retryCount++;
@@ -33,7 +32,9 @@ export class ConnectionStateListener {
             return;
         }
         this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
-        this.client.connect();
+        setTimeout(() => {
+            this.client.connect();
+        }, 3000);
         this.client.isInDisconnectingStep = false;
     }
     async onError(duid, message) {

package/dist/roborockCommunication/helper/messageDeserializer.js

@@ -13,7 +13,7 @@ export class MessageDeserializer {
         this.context = context;
         this.logger = logger;
         this.messageParser = new Parser()
-            .endianess('big')
+            .endianness('big')
             .string('version', {
             length: 3,
         })

package/dist/roborockService.js

@@ -54,6 +54,9 @@ export default class RoborockService {
         this.logger.debug('RoborockService - setSelectedAreas', selectedAreas);
         this.selectedAreas.set(duid, selectedAreas);
     }
+    getSelectedAreas(duid) {
+        return this.selectedAreas.get(duid) ?? [];
+    }
     setSupportedAreas(duid, supportedAreas) {
         this.supportedAreas.set(duid, supportedAreas);
     }
@@ -410,13 +413,13 @@ 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);
+                const localClient = this.messageClient.registerClient(device.duid, localIp);
                 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()) {
                     throw new Error('Local client did not connect after 10 attempts, something is wrong');
@@ -432,9 +435,6 @@ export default class RoborockService {
         }
         return true;
     }
-    onLocalClientDisconnect(duid) {
-        this.mqttAlwaysOnDevices.set(duid, true);
-    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }

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

@@ -1,7 +1,7 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
   "type": "DynamicPlatform",
-  "version": "1.1.0-rc12",
+  "version": "1.1.0-rc13",
   "whiteList": [],
   "blackList": [],
   "useInterval": true,
@@ -37,4 +37,4 @@
   "debug": true,
   "unregisterOnShutdown": false,
   "enableExperimentalFeature": false
-}
+}

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

@@ -1,11 +1,8 @@
 {
   "title": "Matterbridge Roborock Vacuum Plugin",
-  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc12 by https://github.com/RinDevJunior",
+  "description": "matterbridge-roborock-vacuum-plugin v. 1.1.0-rc13 by https://github.com/RinDevJunior",
   "type": "object",
-  "required": [
-    "username",
-    "password"
-  ],
+  "required": ["username", "password"],
   "properties": {
     "name": {
       "description": "Plugin name",
@@ -60,9 +57,7 @@
                 "const": true
               }
             },
-            "required": [
-              "enableExperimentalFeature"
-            ]
+            "required": ["enableExperimentalFeature"]
           },
           "then": {
             "properties": {
@@ -119,9 +114,7 @@
                           "const": true
                         }
                       },
-                      "required": [
-                        "enableCleanModeMapping"
-                      ]
+                      "required": ["enableCleanModeMapping"]
                     },
                     "then": {
                       "properties": {
@@ -166,9 +159,7 @@
                                     "default": 25
                                   }
                                 },
-                                "required": [
-                                  "distanceOff"
-                                ]
+                                "required": ["distanceOff"]
                               }
                             }
                           ]
@@ -205,9 +196,7 @@
                                     "default": 25
                                   }
                                 },
-                                "required": [
-                                  "distanceOff"
-                                ]
+                                "required": ["distanceOff"]
                               }
                             }
                           ]
@@ -237,36 +226,20 @@
     "fanMode": {
       "type": "string",
       "description": "Suction power mode to use (e.g., 'Quiet', 'Balanced', 'Turbo', 'Max', 'MaxPlus').",
-      "enum": [
-        "Quiet",
-        "Balanced",
-        "Turbo",
-        "Max",
-        "MaxPlus"
-      ],
+      "enum": ["Quiet", "Balanced", "Turbo", "Max", "MaxPlus"],
       "default": "Balanced"
     },
     "waterFlowMode": {
       "type": "string",
       "description": "Water flow mode to use (e.g., 'Low', 'Medium', 'High', 'CustomizeWithDistanceOff').",
-      "enum": [
-        "Low",
-        "Medium",
-        "High",
-        "CustomizeWithDistanceOff"
-      ],
+      "enum": ["Low", "Medium", "High", "CustomizeWithDistanceOff"],
       "default": "Medium"
     },
     "mopRouteMode": {
       "type": "string",
       "description": "Mop route intensity to use (e.g., 'Standard', 'Deep', 'DeepPlus', 'Fast').",
-      "enum": [
-        "Standard",
-        "Deep",
-        "DeepPlus",
-        "Fast"
-      ],
+      "enum": ["Standard", "Deep", "DeepPlus", "Fast"],
       "default": "Standard"
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc12",
+  "version": "1.1.0-rc13",
   "description": "Matterbridge Roborock Vacuum Plugin",
   "author": "https://github.com/RinDevJunior",
   "license": "MIT",
@@ -35,6 +35,7 @@
   },
   "dependencies": {
     "@log4js-node/log4js-api": "^1.0.2",
+    "@types/binary-parser": "^1.5.5",
     "@types/node-persist": "^3.1.8",
     "axios": "^1.9.0",
     "binary-parser": "^2.2.1",

package/src/initialData/getSupportedAreas.ts

@@ -4,12 +4,12 @@ import RoomMap from '../model/RoomMap.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 import { randomInt } from 'node:crypto';
 
-export function getSupportedAreas(rooms: Room[], roomMap: RoomMap | undefined, log?: AnsiLogger): ServiceArea.Area[] {
-  log?.debug('getSupportedAreas', debugStringify(rooms));
-  log?.debug('getSupportedAreas', roomMap ? debugStringify(roomMap) : 'undefined');
+export function getSupportedAreas(vacuumRooms: Room[], roomMap: RoomMap | undefined, log?: AnsiLogger): ServiceArea.Area[] {
+  log?.debug('getSupportedAreas-vacuum room', debugStringify(vacuumRooms));
+  log?.debug('getSupportedAreas-roomMap', roomMap ? debugStringify(roomMap) : 'undefined');
 
-  if (!rooms || rooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
-    if (!rooms || rooms.length === 0) {
+  if (!vacuumRooms || vacuumRooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
+    if (!vacuumRooms || vacuumRooms.length === 0) {
       log?.error('No rooms found');
     }
 
@@ -39,7 +39,7 @@ export function getSupportedAreas(rooms: Room[], roomMap: RoomMap | undefined, l
       mapId: null,
       areaInfo: {
         locationInfo: {
-          locationName: room.displayName ?? rooms.find((r) => r.id == room.globalId)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
+          locationName: room.displayName ?? vacuumRooms.find((r) => r.id == room.globalId || r.id == room.id)?.name ?? `Unknown Room ${randomInt(1000, 9999)}`,
           floorNumber: null,
           areaType: null,
         },
@@ -48,6 +48,8 @@ export function getSupportedAreas(rooms: Room[], roomMap: RoomMap | undefined, l
     };
   });
 
+  log?.debug('getSupportedAreas - supportedAreas', debugStringify(supportedAreas));
+
   const duplicated = findDuplicatedAreaIds(supportedAreas, log);
 
   return duplicated

package/src/model/RoomMap.ts

@@ -22,6 +22,7 @@ export default class RoomMap {
     id: number;
     globalId: number | undefined;
     displayName: string | undefined;
+    alternativeId: string;
   }[] = [];
 
   constructor(roomData: number[][], rooms: Room[]) {
@@ -30,6 +31,7 @@ export default class RoomMap {
         id: entry[0],
         globalId: Number(entry[1]),
         displayName: rooms.find((r) => Number(r.id) == Number(entry[1]))?.name,
+        alternativeId: `${entry[0]}${entry[2]}`,
       };
     });
   }

package/src/platform.ts

@@ -15,6 +15,7 @@ import { CleanModeSettings, createDefaultExperimentalFeatureSetting, Experimenta
 import { ServiceArea } from 'matterbridge/matter/clusters';
 import NodePersist from 'node-persist';
 import Path from 'node:path';
+import { Room } from './roborockCommunication/Zmodel/room.js';
 
 export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
   robots: Map<string, RoborockVacuumCleaner> = new Map<string, RoborockVacuumCleaner>();
@@ -224,10 +225,10 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     }
 
     if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
-      this.log.error(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
+      this.log.notice(`Fetching map information for device: ${vacuum.name} (${vacuum.duid}) to get rooms`);
       const map_info = await this.roborockService.getMapInformation(vacuum.duid);
       const rooms = map_info?.maps?.[0]?.rooms ?? [];
-      vacuum.rooms = rooms;
+      vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }) as Room);
     }
 
     const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);

package/src/platformRunner.ts

@@ -44,27 +44,40 @@ export class PlatformRunner {
   public async getRoomMapFromDevice(device: Device): Promise<RoomMap> {
     const platform = this.platform;
     const rooms = device?.rooms ?? [];
-    platform.log.error(`getRoomMapFromDevice: ${debugStringify(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.error(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-        return new RoomMap(roomData ?? [], rooms);
+        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) {
-        platform.log.error(`getRoomMapFromDevice - 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]);
+
+        const roomMap = new RoomMap(roomDataMap, rooms);
 
-        const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.name)] as [number, number]);
-        return new RoomMap(roomDataMap, rooms);
+        platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+        platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+        return roomMap;
       }
     }
 
     return new RoomMap([], rooms);
   }
 
-  async getRoomMap(duid: string): Promise<RoomMap | undefined> {
+  private async getRoomMap(duid: string): Promise<RoomMap | undefined> {
     const platform = this.platform;
 
     const robot = platform.robots.get(duid);
@@ -90,7 +103,7 @@ export class PlatformRunner {
       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.name)] as [number, number]);
+        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);
       }
     }
@@ -168,23 +181,51 @@ export class PlatformRunner {
             robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
           }
 
-          const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-          const roomMap = await this.getRoomMap(duid);
-          const targetRoom = data.cleaning_info?.target_segment_id ?? -1;
-          const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == targetRoom);
-
-          if (targetRoom !== -1 && isTargetMappedArea) {
-            this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-            this.platform.log.debug(`TargetRoom: ${targetRoom}, room name: ${roomMap?.rooms.find((x) => x.id === targetRoom)?.displayName ?? 'unknown'}`);
-            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', targetRoom, platform.log);
+          if (data.state === OperationStatusCode.Idle) {
+            const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
+            robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
           }
 
-          const currentRoom = data.cleaning_info?.segment_id ?? -1;
-          const isMappedArea = currentMappedAreas?.some((x) => x.areaId == currentRoom);
-          if (currentRoom !== -1 && isMappedArea) {
-            this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-            this.platform.log.debug(`CurrentRoom: ${currentRoom}, room name: ${roomMap?.rooms.find((x) => x.id === currentRoom)?.displayName ?? 'unknown'}`);
-            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', currentRoom, platform.log);
+          if (state === RvcRunMode.ModeTag.Cleaning && !data.cleaning_info) {
+            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+            robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
+          } else {
+            const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
+            const roomMap = await this.getRoomMap(duid);
+
+            // Get current room from segment_id
+            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;
+            this.platform.log.debug(`Target segment id: ${segment_id}, targetRoom: ${target_room_id}`);
+
+            const isMappedArea = currentMappedAreas?.some((x) => x.areaId == segment_id);
+            if (segment_id !== -1 && isMappedArea) {
+              this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+              this.platform.log.debug(
+                `Part1: CurrentRoom: ${segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`,
+              );
+              robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', segment_id, platform.log);
+            }
+
+            if (segment_id == -1) {
+              const isTargetMappedArea = currentMappedAreas?.some((x) => x.areaId == target_segment_id);
+              target_room_id = roomMap?.rooms.find((x) => x.id == target_segment_id || x.alternativeId === target_segment_id.toString())?.id ?? -1;
+              this.platform.log.debug(`Target segment id: ${target_segment_id}, targetRoom: ${target_room_id}`);
+
+              if (target_segment_id !== -1 && isTargetMappedArea) {
+                this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
+                this.platform.log.debug(
+                  `Part2: TargetRoom: ${target_segment_id}, room name: ${roomMap?.rooms.find((x) => x.id === target_segment_id || x.alternativeId === segment_id.toString())?.displayName ?? 'unknown'}`,
+                );
+                robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', target_segment_id, platform.log);
+              }
+            }
+
+            if (target_segment_id == -1 && segment_id == -1) {
+              robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', null, platform.log);
+            }
           }
 
           if (data.battery) {
@@ -199,10 +240,12 @@ export class PlatformRunner {
             waterFlow: data.cleaning_info?.water_box_status ?? data.water_box_mode,
             distance_off: data.distance_off,
             mopRoute: data.cleaning_info?.mop_mode ?? data.mop_mode,
+            segment_id: data.cleaning_info?.segment_id,
+            target_segment_id: data.cleaning_info?.target_segment_id,
           };
 
           this.platform.log.debug(`data: ${debugStringify(data)}`);
-          this.platform.log.debug(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
+          this.platform.log.notice(`currentCleanModeSetting: ${debugStringify(currentCleanModeSetting)}`);
 
           if (currentCleanModeSetting.mopRoute && currentCleanModeSetting.suctionPower && currentCleanModeSetting.waterFlow) {
             const currentCleanMode = getCurrentCleanModeFunc(
@@ -314,7 +357,7 @@ export class PlatformRunner {
           break;
         }
         default: {
-          platform.log.notice(`Unknown message type: ${Protocol[messageType] ?? messageType} ,`, debugStringify(data));
+          platform.log.notice(`Unknown message type ${messageType}, protocol: ${Protocol[messageType]}, message: ${debugStringify(data)}`);
           break;
         }
       }

package/src/roborockCommunication/Zmodel/map.ts

@@ -4,6 +4,7 @@ export interface Map {
   length: number;
   name: string;
   rooms: RoomInformation[];
+  bak_maps: { mapFlag: number; add_time: number }[];
 }
 
 export interface RoomInformation {

package/src/roborockCommunication/Zmodel/mapInfo.ts

@@ -1,10 +1,9 @@
 import decodeComponent from '../helper/nameDecoder.js';
 import { RoomInformation } from './map.js';
 import type { MultipleMap } from './multipleMap.js';
-import { Room } from './room.js';
 
 export class MapInfo {
-  readonly maps: { id: number; name: string | undefined; rooms: Room[] }[] = [];
+  readonly maps: { id: number; name: string | undefined; rooms: { id: number; iot_name_id: string; tag: number; displayName: string }[] }[] = [];
 
   constructor(multimap: MultipleMap) {
     multimap.map_info.forEach((map) => {
@@ -16,8 +15,10 @@ export class MapInfo {
             ? map.rooms.map((room: RoomInformation) => {
                 return {
                   id: room.id,
-                  name: room.iot_name_id,
-                } as Room;
+                  iot_name_id: room.iot_name_id,
+                  tag: room.tag,
+                  displayName: room.iot_name,
+                };
               })
             : [],
       });

package/src/roborockCommunication/broadcast/abstractClient.ts

@@ -25,7 +25,6 @@ export abstract class AbstractClient implements Client {
 
   protected abstract clientName: string;
   protected abstract shouldReconnect: boolean;
-  protected abstract changeToSecureConnection: (duid: string) => void;
 
   private readonly context: MessageContext;
   private readonly syncMessageListener: SyncMessageListener;
@@ -41,7 +40,7 @@ export abstract class AbstractClient implements Client {
   }
 
   protected initializeConnectionStateListener() {
-    const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.changeToSecureConnection, this.shouldReconnect);
+    const connectionStateListener = new ConnectionStateListener(this.logger, this, this.clientName, this.shouldReconnect);
     this.connectionListeners.register(connectionStateListener);
   }
 

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

@@ -9,7 +9,6 @@ import { Sequence } from '../../helper/sequence.js';
 import { ChunkBuffer } from '../../helper/chunkBuffer.js';
 
 export class LocalNetworkClient extends AbstractClient {
-  protected override changeToSecureConnection: (duid: string) => void;
   protected override clientName = 'LocalNetworkClient';
   protected override shouldReconnect = true;
 
@@ -20,29 +19,32 @@ export class LocalNetworkClient extends AbstractClient {
   duid: string;
   ip: string;
 
-  constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string, inject: (duid: string) => void) {
+  constructor(logger: AnsiLogger, context: MessageContext, duid: string, ip: string) {
     super(logger, context);
     this.duid = duid;
     this.ip = ip;
     this.messageIdSeq = new Sequence(100000, 999999);
 
     this.initializeConnectionStateListener();
-    this.changeToSecureConnection = inject;
   }
 
   public connect(): void {
     if (this.socket) {
-      this.socket.destroy();
-      this.socket = undefined;
-      return;
+      return; // Already connected
     }
 
     this.socket = new Socket();
+
+    // Socket event listeners
     this.socket.on('close', this.onDisconnect.bind(this));
     this.socket.on('end', this.onEnd.bind(this));
     this.socket.on('error', this.onError.bind(this));
+    this.socket.on('connect', this.onConnect.bind(this));
+    this.socket.on('timeout', this.onTimeout.bind(this));
+
+    // Data event listener
     this.socket.on('data', this.onMessage.bind(this));
-    this.socket.connect(58867, this.ip, this.onConnect.bind(this));
+    this.socket.connect(58867, this.ip);
   }
 
   public async disconnect(): Promise<void> {
@@ -61,7 +63,7 @@ export class LocalNetworkClient extends AbstractClient {
 
   public async send(duid: string, request: RequestMessage): Promise<void> {
     if (!this.socket || !this.connected) {
-      this.logger.error(`${duid}: socket is not online, ${debugStringify(request)}`);
+      this.logger.error(`${duid}: socket is not online, , ${debugStringify(request)}`);
       return;
     }
 
@@ -73,32 +75,35 @@ 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;
-    const address = this.socket?.address();
-    this.logger.debug(`${this.duid} connected to ${this.ip}, address: ${address ? debugStringify(address) : 'undefined'}`);
+    this.retryCount = 0;
+
     await this.sendHelloMessage();
     this.pingInterval = setInterval(this.sendPingRequest.bind(this), 5000);
     await this.connectionListeners.onConnected(this.duid);
-    this.retryCount = 0;
   }
 
   private async onEnd(): Promise<void> {
-    this.logger.notice('LocalNetworkClient: Socket has ended.');
-    this.connected = false;
+    await this.destroySocket('Socket has ended.');
+    await this.connectionListeners.onDisconnected(this.duid, 'Socket has ended.');
+  }
 
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = undefined;
-    }
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
+  private async onDisconnect(hadError: boolean): Promise<void> {
+    await this.destroySocket(`Socket disconnected. Had error: ${hadError}`);
+
+    if (!hadError) {
+      await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
     }
+  }
 
-    await this.connectionListeners.onDisconnected(this.duid);
+  private async onTimeout(): Promise<void> {
+    this.logger.error(`LocalNetworkClient: Socket for ${this.duid} timed out.`);
   }
 
-  private async onDisconnect(): Promise<void> {
-    this.logger.notice('LocalNetworkClient: Socket has disconnected.');
+  private async destroySocket(message: string): Promise<void> {
+    this.logger.error(`LocalNetworkClient: Destroying socket for ${this.duid} due to: ${message}`);
     this.connected = false;
 
     if (this.socket) {
@@ -108,12 +113,10 @@ export class LocalNetworkClient extends AbstractClient {
     if (this.pingInterval) {
       clearInterval(this.pingInterval);
     }
-
-    await this.connectionListeners.onDisconnected(this.duid);
   }
 
-  private async onError(result: Error): Promise<void> {
-    this.logger.error('LocalNetworkClient: Socket connection error: ' + result);
+  private async onError(error: Error): Promise<void> {
+    this.logger.error('LocalNetworkClient: Socket connection error: ' + error.message);
     this.connected = false;
 
     if (this.socket) {
@@ -121,12 +124,15 @@ export class LocalNetworkClient extends AbstractClient {
       this.socket = undefined;
     }
 
-    await this.connectionListeners.onError(this.duid, result.toString());
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+
+    await this.connectionListeners.onError(this.duid, error.message);
   }
 
   private async onMessage(message: Buffer): Promise<void> {
     if (!this.socket) {
-      this.logger.error('unable to receive data if there is no socket available');
       return;
     }