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

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

@@ -3,25 +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.`);
-            this.changeToSecureConnection(duid);
             return;
         }
         this.client.retryCount++;
@@ -31,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);
     }
@@ -260,7 +263,6 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
-                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     username: username,
@@ -308,7 +310,6 @@ export default class RoborockService {
                     model: homeData.products.find((p) => p.id === device.productId)?.model,
                     category: homeData.products.find((p) => p.id === device.productId)?.category,
                     batteryLevel: device.deviceStatus?.[Protocol.battery] ?? 100,
-                    schema: homeData.products.find((p) => p.id === device.productId)?.schema,
                 },
                 store: {
                     userData: this.userdata,
@@ -412,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');
@@ -434,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-rc11",
+  "version": "1.1.0-rc13",
   "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-rc11 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"],
   "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-roborock-vacuum-plugin",
-  "version": "1.1.0-rc11",
+  "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,19 @@ 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 (!vacuumRooms || vacuumRooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
+    if (!vacuumRooms || vacuumRooms.length === 0) {
+      log?.error('No rooms found');
+    }
+
+    if (!roomMap || !roomMap.rooms || roomMap.rooms.length == 0) {
+      log?.error('No room map found');
+    }
 
-  if (!rooms || rooms.length === 0 || !roomMap?.rooms || roomMap.rooms.length == 0) {
-    log?.error('No rooms found');
     return [
       {
         areaId: 1,
@@ -32,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,
         },
@@ -41,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>();
@@ -32,9 +33,9 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     super(matterbridge, log, config);
 
     // Verify that Matterbridge is the correct version
-    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.5')) {
+    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.6')) {
       throw new Error(
-        `This plugin requires Matterbridge version >= "3.1.5". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`,
+        `This plugin requires Matterbridge version >= "3.1.6". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`,
       );
     }
     this.log.info('Initializing platform:', this.config.name);
@@ -224,9 +225,10 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     }
 
     if (vacuum.rooms === undefined || vacuum.rooms.length === 0) {
+      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

@@ -45,14 +45,39 @@ export class PlatformRunner {
     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);
-      return new RoomMap(roomData ?? [], rooms);
+      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);
   }
 
-  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);
@@ -67,8 +92,20 @@ export class PlatformRunner {
     // if (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
     if (robot.roomInfo === undefined) {
       const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-      robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-      return robot.roomInfo;
+      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;
@@ -144,15 +181,51 @@ export class PlatformRunner {
             robot.updateAttribute(RvcRunMode.Cluster.id, 'currentMode', getRunningMode(state), platform.log);
           }
 
-          const currentRoom = data.cleaning_info?.segment_id ?? -1;
-          const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-          const isMappedArea = currentMappedAreas?.some((x) => x.areaId == currentRoom);
+          if (data.state === OperationStatusCode.Idle) {
+            const selectedAreas = platform.roborockService?.getSelectedAreas(duid) ?? [];
+            robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', selectedAreas, platform.log);
+          }
 
-          if (currentRoom !== -1 && isMappedArea) {
+          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);
-            this.platform.log.debug(`RoomMap: ${roomMap ? debugStringify(roomMap) : 'undefined'}`);
-            this.platform.log.debug('CurrentRoom:', currentRoom);
-            robot.updateAttribute(ServiceArea.Cluster.id, 'currentArea', currentRoom, platform.log);
+
+            // 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) {
@@ -167,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(
@@ -282,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/device.ts

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

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) => {
@@ -15,9 +14,11 @@ export class MapInfo {
           map.rooms && map.rooms.length > 0
             ? map.rooms.map((room: RoomInformation) => {
                 return {
-                  id: room.iot_name_id,
-                  name: room.iot_name,
-                } as unknown as Room;
+                  id: room.id,
+                  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;
     }