lavva.exalushome/build/js/Services/ExalusConnectionService.d.ts

Library implementing communication and abstraction layers for ExalusHome system

import { IDataFrame } from "../DataFrame";
import { ConnectionResult, IExalusConnectionService, AuthorizationInfo, ConnectionState, StreamHandler } from "./IExalusConnectionService";
import { ITypedEvent } from "../TypedEvent";
export declare class ExalusConnectionService implements IExalusConnectionService {
    private _logPackets;
    private _pingInterval;
    private _connection?;
    private _disconnectedOnPurpose;
    private _defaultPacketsBrokerAddress?;
    private _serversBrokerAddress?;
    private _serversBrokerAddressList;
    private _allBrokersChecked;
    private _address?;
    private _serialId?;
    private _PIN?;
    private _isEstabilished;
    private readonly _timeout;
    private _dataReceivedEvent;
    private _pongReceivedEvent;
    private _authorizationReceivedEvent;
    private _registrationReceivedEvent;
    private _streamStartedEvent;
    private _connectionStateChangedEvent;
    private _errorOccuredEvent;
    private _log;
    private _controllerConfiguration;
    private _cache;
    private _session;
    static readonly ServiceName: string;
    private _packetsBrokerServers;
    private _lastReceivedPacketTime;
    private _connectedAtLeastOnce;
    private _pingIntervalId;
    SubscribeTo<T>(resourceId: string, handler: {
        (data: IDataFrame<T>): void;
    }): () => void;
    GetControllerSerialNumber(): string | undefined;
    GetControllerPin(): string | undefined;
    GetServiceName(): string;
    EnablePacketsLogging(): void;
    DisablePacketsLogging(): void;
    private InitializeConnection;
    GetAuthorizationInfo(): AuthorizationInfo | null;
    SetServersBrokerAddress(address: string): void;
    SetDefaultPacketsBrokerAddress(address: string): void;
    GetServerAddressAsync(): Promise<string | null>;
    ConnectAsync(address: string): Promise<ConnectionResult>;
    AuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<boolean>;
    ConnectAndAuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<ConnectionResult>;
    private swapBrokersAsync;
    private connectAsync;
    FireConnectionStateChanged(): ConnectionResult;
    DisconnectAsync(): Promise<void>;
    IsConnected(): boolean;
    SendAndWaitForResponseAsync<T>(dataFrame: IDataFrame<any>, timeout: number, useCache: boolean, logTransmission?: boolean): Promise<IDataFrame<T>>;
    SendAndWaitForResponseWithRepeatAsync<T>(dataFrame: IDataFrame<any>, timeout: number, useCache: boolean, repeat?: boolean, logTransmission?: boolean): Promise<IDataFrame<T>>;
    SendAndHandleResponseAsync<T>(dataFrame: IDataFrame<any>, timeout: number, dataHandler: (result: IDataFrame<T>) => void, logTransmission?: boolean): Promise<void>;
    SendAndHandleStreamAsync<T>(dataFrame: IDataFrame<any>, streamHandler: StreamHandler<T>, logTransmission?: boolean): Promise<void>;
    PingControllerAsync(): Promise<boolean>;
    SendAsync(dataFrame: IDataFrame<any>, logTransmission?: boolean): Promise<boolean>;
    OnDataReceivedEvent(): ITypedEvent<any>;
    OnConnectionStateChangedEvent(): ITypedEvent<ConnectionState>;
    OnErrorOccuredEvent(): ITypedEvent<[sender: string, data: string]>;
}