matterbridge-roborock-vacuum-plugin/dist/roborockCommunication/routing/abstractClient.js

Matterbridge Roborock Vacuum Plugin

import { MessageDeserializer } from '../protocol/deserializers/messageDeserializer.js';
import { MessageSerializer } from '../protocol/serializers/messageSerializer.js';
import { ConnectionBroadcaster } from './listeners/connectionBroadcaster.js';
import { ConnectionStateListener } from './listeners/implementation/connectionStateListener.js';
export class AbstractClient {
    logger;
    context;
    responseBroadcaster;
    responseTracker;
    isInDisconnectingStep = false;
    retryCount = 0;
    connectionBroadcaster;
    serializer;
    deserializer;
    connectionStateListener;
    constructor(logger, context, responseBroadcaster, responseTracker) {
        this.logger = logger;
        this.context = context;
        this.responseBroadcaster = responseBroadcaster;
        this.responseTracker = responseTracker;
        this.serializer = new MessageSerializer(this.context, this.logger);
        this.deserializer = new MessageDeserializer(this.context, this.logger);
        this.connectionBroadcaster = new ConnectionBroadcaster(this.logger);
    }
    /** Returns true when client is ready to send requests. Override for custom handshake logic. */
    isReady() {
        return this.isConnected();
    }
    initializeConnectionStateListener(client) {
        this.connectionStateListener = new ConnectionStateListener(this.logger, client, this.clientName);
        this.connectionBroadcaster.register(this.connectionStateListener);
    }
    registerMessageListener(listener) {
        this.responseBroadcaster.register(listener);
    }
    /**
     * Sends a request without waiting for a response (fire-and-forget).
     * Use get() if you need to wait for a response.
     */
    async send(duid, request) {
        this.sendInternal(duid, request);
    }
    connect() {
        if (this.connectionStateListener) {
            this.connectionStateListener.start();
        }
        this.isInDisconnectingStep = false;
    }
    disconnect() {
        if (this.connectionStateListener) {
            this.connectionStateListener.stop();
        }
        this.isInDisconnectingStep = true;
        return Promise.resolve();
    }
    async get(duid, request) {
        try {
            const responsePromise = this.responseTracker.waitFor(request, duid);
            this.sendInternal(duid, request);
            const response = await responsePromise;
            return response;
        }
        catch (error) {
            this.logger.error(error instanceof Error ? error.message : String(error));
            return undefined;
        }
    }
    registerDevice(duid, localKey, pv, nonce) {
        this.context.registerDevice(duid, localKey, pv, nonce);
    }
    registerConnectionListener(listener) {
        this.connectionBroadcaster.register(listener);
    }
}
//# sourceMappingURL=abstractClient.js.map