All the work
This commit is contained in:
1 parent
f6767c9e8f
commit
2a1efb2aff
15 files changed
+5006
-349
No files matched your search
@@ -0,0 +1,139 @@
|
||||
import { HAComponent, HADevice, HAmqtt } from "./HAmqtt";
|
||||
import { makeLogger } from "./Logger";
|
||||
import { Button, ButtonModule } from "./flicTypes";
|
||||
|
||||
export type ButtonControllerOpt = {
|
||||
debug: boolean;
|
||||
}
|
||||
export const makeOptions = (opt: Partial<ButtonControllerOpt>): ButtonControllerOpt => ({
|
||||
debug: false,
|
||||
...opt,
|
||||
})
|
||||
const ENTITIES: Record<string, [HAComponent, Record<string, any>]> = {
|
||||
"action": ['sensor', { icon: 'mdi:gesture-tap-button' }],
|
||||
"state": ['sensor', { icon: 'mdi:radiobox-indeterminate-variant' }],
|
||||
"battery": ['sensor', { unit_of_measurement: '%', device_class: 'battery' }],
|
||||
"connected": ['binary_sensor', { device_class: 'connectivity' }],
|
||||
"ready": ['binary_sensor', { device_class: 'running' }],
|
||||
}
|
||||
export type ButtonController = ReturnType<typeof makeButtonController>;
|
||||
export function makeButtonController(
|
||||
ha: HAmqtt,
|
||||
buttonModule: ButtonModule,
|
||||
options: Partial<ButtonControllerOpt> = {},
|
||||
) {
|
||||
options = makeOptions(options);
|
||||
const logger = makeLogger('btnc', options.debug)
|
||||
logger.info("Starting Flic ButtonController with", JSON.stringify(options, null, 4));
|
||||
|
||||
const getDeviceFromButton = (button: Button): HADevice => {
|
||||
return {
|
||||
name: button.name,
|
||||
identifiers: [button.serialNumber, button.uuid],
|
||||
manufacturer: 'Flic',
|
||||
model: `v${button.flicVersion}_${button.color.trim().length > 0 ? button.color : 'white'}`,
|
||||
sw: String(button.firmwareVersion),
|
||||
hw: String(button.flicVersion),
|
||||
}
|
||||
}
|
||||
const genButtonUniqueId = (bdaddr: string): string => bdaddr.replace(/:/g, '_')
|
||||
const registerButton = (button: Button) => {
|
||||
logger.info('Registering', JSON.stringify(button, null, 4))
|
||||
const haDevice = getDeviceFromButton(button);
|
||||
Object.keys(ENTITIES).forEach(objectId => {
|
||||
ha.registerEntity(
|
||||
`Button ${objectId}`,
|
||||
ENTITIES[objectId][0],
|
||||
genButtonUniqueId(button.bdaddr),
|
||||
objectId,
|
||||
haDevice,
|
||||
{
|
||||
...ENTITIES[objectId][1],
|
||||
availability: [
|
||||
{
|
||||
payload_available: 'ON',
|
||||
payload_not_available: 'OFF',
|
||||
topic: ha.genFlicPrefix(genButtonUniqueId(button.bdaddr), 'ready')
|
||||
},
|
||||
{
|
||||
payload_available: 'ON',
|
||||
payload_not_available: 'OFF',
|
||||
topic: ha.genFlicPrefix(genButtonUniqueId(button.bdaddr), 'connected')
|
||||
}
|
||||
],
|
||||
availability_mode: 'all',
|
||||
},
|
||||
)
|
||||
});
|
||||
}
|
||||
const deregisterButton = (button: Button) => {
|
||||
logger.info('Deregistering', JSON.stringify(button, null, 4))
|
||||
Object.keys(ENTITIES).forEach(objectId => {
|
||||
ha.deregisterEntity(
|
||||
ENTITIES[objectId][0],
|
||||
genButtonUniqueId(button.bdaddr),
|
||||
objectId,
|
||||
)
|
||||
});
|
||||
}
|
||||
const publishButtonState = (button: Button, state: 'released' | 'pressed') => {
|
||||
ha.publishState(genButtonUniqueId(button.bdaddr), 'state', state);
|
||||
}
|
||||
const publishButtonAction = (button: Button, state: string) => {
|
||||
ha.publishState(genButtonUniqueId(button.bdaddr), 'action', state);
|
||||
}
|
||||
const publishButtonMeta = (button: Button) => {
|
||||
ha.publishState(genButtonUniqueId(button.bdaddr), 'battery', button.batteryStatus);
|
||||
ha.publishState(genButtonUniqueId(button.bdaddr), 'connected', button.connected ? 'ON' : "OFF");
|
||||
ha.publishState(genButtonUniqueId(button.bdaddr), 'ready', button.ready ? 'ON' : "OFF");
|
||||
}
|
||||
const addBtn = (eventName: string) => (obj: { bdaddr: string }) => {
|
||||
const button = buttonModule.getButton(obj.bdaddr);
|
||||
logger.info(eventName, "upserting", button.name, genButtonUniqueId(button.bdaddr));
|
||||
registerButton(button);
|
||||
}
|
||||
const start = () => {
|
||||
logger.info("Starting...")
|
||||
buttonModule.on('buttonAdded', addBtn('buttonAdded'));
|
||||
buttonModule.on('buttonConnected', addBtn('buttonConnected'));
|
||||
buttonModule.on('buttonReady', addBtn('buttonReady'));
|
||||
buttonModule.on('buttonUpdated', addBtn('buttonUpdated'));
|
||||
buttonModule.on('buttonDeleted', (btn) => {
|
||||
logger.debug('buttonDeleted', JSON.stringify(btn, null, 4))
|
||||
deregisterButton(btn);
|
||||
publishButtonMeta(btn);
|
||||
});
|
||||
buttonModule.on('buttonDisconnected', ({ bdaddr }) => {
|
||||
publishButtonMeta(buttonModule.getButton(bdaddr));
|
||||
});
|
||||
buttonModule.on('buttonDown', ({ bdaddr }) => {
|
||||
const btn = buttonModule.getButton(bdaddr);
|
||||
publishButtonState(btn, 'pressed');
|
||||
publishButtonMeta(btn);
|
||||
});
|
||||
buttonModule.on('buttonUp', ({ bdaddr }) => {
|
||||
const btn = buttonModule.getButton(bdaddr);
|
||||
publishButtonState(btn, 'released');
|
||||
publishButtonMeta(btn);
|
||||
});
|
||||
buttonModule.on('buttonSingleOrDoubleClickOrHold', obj => {
|
||||
const btn = buttonModule.getButton(obj.bdaddr);
|
||||
publishButtonAction(
|
||||
btn,
|
||||
obj.isSingleClick ? "click" : obj.isDoubleClick ? "double_click" : "hold",
|
||||
);
|
||||
publishButtonMeta(btn);
|
||||
});
|
||||
logger.info("Registering all buttons...")
|
||||
buttonModule.getButtons().forEach(registerButton);
|
||||
setInterval(() => buttonModule.getButtons().forEach(publishButtonMeta), 1000);
|
||||
logger.info('is up')
|
||||
}
|
||||
|
||||
return {
|
||||
start,
|
||||
publishButtonAction,
|
||||
publishButtonMeta,
|
||||
publishButtonState,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
import { makeLogger } from "./Logger";
|
||||
import { MQTT } from "./mqtt";
|
||||
|
||||
export type HAmqttOptions = {
|
||||
debug: boolean,
|
||||
topics: {
|
||||
homeassistant: string,
|
||||
flic: string,
|
||||
}
|
||||
}
|
||||
export type MQTTPublishOpt = {
|
||||
retain?: boolean // the server should retain this message and send it out again to new subscribers
|
||||
dup?: boolean // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only)
|
||||
}
|
||||
export type HADevice = {
|
||||
name: string,
|
||||
identifiers: string[],
|
||||
manufacturer: string,
|
||||
model: string,
|
||||
sw?: string,
|
||||
hw?: string,
|
||||
}
|
||||
export type HAComponent = 'sensor' | 'binary_sensor' | 'button' | 'switch' | 'text';
|
||||
export const makeOptions = (opt: Partial<HAmqttOptions>): HAmqttOptions => ({
|
||||
debug: false,
|
||||
...opt,
|
||||
topics: {
|
||||
homeassistant: 'homeassistant',
|
||||
flic: 'flic',
|
||||
...opt.topics,
|
||||
}
|
||||
})
|
||||
export type HAmqtt = ReturnType<typeof makeHAmqtt>;
|
||||
export function makeHAmqtt(
|
||||
mqttServer: MQTT,
|
||||
options: Partial<HAmqttOptions> = {},
|
||||
) {
|
||||
options = makeOptions(options);
|
||||
const logger = makeLogger('mqtt:ha', options.debug);
|
||||
logger.info("starting...", JSON.stringify(options, null, 4));
|
||||
|
||||
const genFlicPrefix = (nodeId: string, objectId: string): string => {
|
||||
return `${options.topics.flic}/${nodeId}/${objectId}`
|
||||
}
|
||||
|
||||
const genHAPrefix = (component: HAComponent, nodeId: string, objectId: string) => {
|
||||
return `${options.topics.homeassistant}/${component}/${nodeId}/${objectId}`
|
||||
}
|
||||
|
||||
const publishState = (nodeId: string, objectId: string, state: any, opt: MQTTPublishOpt = {}) => {
|
||||
const btntopic = genFlicPrefix(nodeId, objectId);
|
||||
mqttServer.publish(btntopic, state + "", opt);
|
||||
logger.debug(btntopic, state, JSON.stringify(opt))
|
||||
}
|
||||
const registerEntity = (
|
||||
name: string,
|
||||
component: HAComponent,
|
||||
nodeId: string,
|
||||
objectId: string,
|
||||
device: HADevice,
|
||||
additionalProps: Record<string, any> = {},
|
||||
) => {
|
||||
const configtopic = genHAPrefix(component, nodeId, objectId) + "/config"
|
||||
const configObj = {
|
||||
...additionalProps,
|
||||
name,
|
||||
state_topic: genFlicPrefix(nodeId, objectId),
|
||||
unique_id: `Flic_${nodeId}_${objectId}`,
|
||||
device,
|
||||
};
|
||||
mqttServer.publish(configtopic, JSON.stringify(configObj), {
|
||||
retain: true,
|
||||
});
|
||||
logger.debug(configtopic, JSON.stringify(configObj, null, 4));
|
||||
}
|
||||
|
||||
const deregisterEntity = (
|
||||
component: HAComponent,
|
||||
nodeId: string,
|
||||
objectId: string,
|
||||
) => {
|
||||
const configtopic = genHAPrefix(component, nodeId, objectId) + "/config"
|
||||
mqttServer.publish(configtopic, null, { retain: false });
|
||||
logger.debug(configtopic, null);
|
||||
}
|
||||
|
||||
return {
|
||||
deregisterEntity,
|
||||
registerEntity,
|
||||
publishState,
|
||||
genFlicPrefix,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
import { HADevice, HAmqtt } from "./HAmqtt";
|
||||
import { makeLogger } from "./Logger";
|
||||
import { IRModule } from "./flicTypes";
|
||||
import { MQTT } from "./mqtt";
|
||||
|
||||
const NODE_ID = 'FlicHubIR';
|
||||
const convertUint32Array2Str = (arr: Uint32Array): string => {
|
||||
let outStr = []
|
||||
for (let i = 0; i < arr.length; i++) {
|
||||
outStr.push(arr[i].toString(32))
|
||||
}
|
||||
return outStr.join('_')
|
||||
}
|
||||
const convertStr2Uint32Array = (s: string): Uint32Array => {
|
||||
const a = s.split('_');
|
||||
return new Uint32Array(a.slice(0, a.length - 2).map(v => parseInt(v, 32)))
|
||||
}
|
||||
export type IRControllerOpt = {
|
||||
debug: boolean;
|
||||
}
|
||||
export const makeOptions = (opt: Partial<IRControllerOpt>): IRControllerOpt => ({
|
||||
debug: false,
|
||||
...opt,
|
||||
})
|
||||
export const makeIRController = (
|
||||
ir: IRModule,
|
||||
ha: HAmqtt,
|
||||
mqtt: MQTT,
|
||||
uniqueId: string,
|
||||
options: Partial<IRControllerOpt> = {},
|
||||
) => {
|
||||
options = makeOptions(options);
|
||||
const logger = makeLogger('ir', options.debug);
|
||||
const haDevice: HADevice = {
|
||||
name: 'IR',
|
||||
manufacturer: 'Flic',
|
||||
model: `${NODE_ID}${uniqueId}`,
|
||||
identifiers: ['FlicHubIR']
|
||||
}
|
||||
const nodeId = `${NODE_ID}${uniqueId}`;
|
||||
const RECORD_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'record/set');
|
||||
const VALUE_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'signal/set');
|
||||
const VALUE_SIGNAL_STATE = ha.genFlicPrefix(nodeId, 'signal');
|
||||
const PLAY_SIGNAL_SET = ha.genFlicPrefix(nodeId, 'play/set');
|
||||
let currentSignal: string | null = null;
|
||||
|
||||
const set_topics = [
|
||||
RECORD_SIGNAL_SET,
|
||||
VALUE_SIGNAL_SET,
|
||||
PLAY_SIGNAL_SET,
|
||||
VALUE_SIGNAL_STATE,
|
||||
];
|
||||
|
||||
return {
|
||||
start() {
|
||||
logger.info('starting...')
|
||||
logger.debug('setting up entities...')
|
||||
ha.registerEntity(
|
||||
'Record Signal',
|
||||
'switch',
|
||||
nodeId,
|
||||
'record',
|
||||
haDevice,
|
||||
{
|
||||
icon: 'mdi:record-rec',
|
||||
command_topic: RECORD_SIGNAL_SET,
|
||||
device_class: 'switch',
|
||||
}
|
||||
)
|
||||
ha.registerEntity(
|
||||
'Signal',
|
||||
'text',
|
||||
nodeId,
|
||||
'signal',
|
||||
haDevice,
|
||||
{
|
||||
command_topic: VALUE_SIGNAL_SET,
|
||||
icon: 'mdi:broadcast',
|
||||
max: 255,
|
||||
}
|
||||
)
|
||||
ha.registerEntity(
|
||||
'Play Signal',
|
||||
'button',
|
||||
nodeId,
|
||||
'play',
|
||||
haDevice,
|
||||
{
|
||||
icon: 'mdi:play',
|
||||
command_topic: PLAY_SIGNAL_SET,
|
||||
}
|
||||
)
|
||||
logger.debug('setting default states....')
|
||||
ha.publishState(nodeId, 'record', 'OFF')
|
||||
ha.publishState(nodeId, 'play', 'OFF')
|
||||
logger.debug('registering events')
|
||||
mqtt.on('message', (topic, message) => {
|
||||
logger.debug('message:', JSON.stringify({ topic, message }))
|
||||
if (topic === RECORD_SIGNAL_SET) {
|
||||
logger.debug('starting record')
|
||||
ir.record()
|
||||
ha.publishState(nodeId, 'record', 'ON')
|
||||
} else if (topic === PLAY_SIGNAL_SET) {
|
||||
if (currentSignal !== null) {
|
||||
logger.info('playing', currentSignal)
|
||||
let arr: Uint32Array | null = null
|
||||
try {
|
||||
arr = convertStr2Uint32Array(currentSignal)
|
||||
} catch (err) {
|
||||
logger.error('invalid string signal set', JSON.stringify(err), err)
|
||||
return
|
||||
}
|
||||
ir.play(arr, (err) => {
|
||||
if (err) {
|
||||
logger.error('failed to play signal', JSON.stringify(err), err)
|
||||
} else {
|
||||
logger.debug('signal played!')
|
||||
}
|
||||
})
|
||||
} else {
|
||||
logger.error('cannot play an unset signal')
|
||||
}
|
||||
} else if (topic === VALUE_SIGNAL_STATE) {
|
||||
currentSignal = message
|
||||
logger.info('setting currentSignal', currentSignal)
|
||||
} else if (topic === VALUE_SIGNAL_SET) {
|
||||
ha.publishState(nodeId, 'signal', message, { retain: true })
|
||||
}
|
||||
})
|
||||
ir.on('recordComplete', data => {
|
||||
const stringMessage = convertUint32Array2Str(data)
|
||||
logger.debug('recording completed with', JSON.stringify({ data, stringMessage, rev: convertStr2Uint32Array(stringMessage) }))
|
||||
if (stringMessage.length > 255) {
|
||||
logger.error("stringMessage is too big! size=", stringMessage.length, 'max=255')
|
||||
}
|
||||
ha.publishState(nodeId, 'signal', stringMessage, { retain: true })
|
||||
ha.publishState(nodeId, 'record', 'OFF')
|
||||
})
|
||||
|
||||
logger.debug('subscribing to', set_topics)
|
||||
mqtt.subscribe(set_topics)
|
||||
logger.info('is up')
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
export type Logger = ReturnType<typeof makeLogger>;
|
||||
export function makeLogger(
|
||||
prefix: string,
|
||||
debugMode: boolean = false,
|
||||
) {
|
||||
return {
|
||||
info(...args: any[]) {
|
||||
console.log(`${prefix}|INFO| ${args.map(String).join('\t')}`)
|
||||
},
|
||||
error(...args: any[]) {
|
||||
console.log(`${prefix}|ERROR| ${args.map(String).join('\t')}`)
|
||||
},
|
||||
debug(...args: any[]) {
|
||||
if (debugMode) {
|
||||
console.log(`${prefix}|DEBUG| ${args.map(String).join('\t')}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
|
||||
|
||||
export type Button = {
|
||||
bdaddr: string // Device address of button
|
||||
serialNumber: string // Serial number
|
||||
color: string // Colour of the button (lowercase)
|
||||
name: string // The user assigned button name
|
||||
activeDisconnect: boolean // The user has explicitly disconnected the button
|
||||
connected: boolean // The connection to the button is currently established
|
||||
ready: boolean // The connection is verified (see buttonReady)
|
||||
batteryStatus: number | null // Battery level in percent (0-100), or null if unknown
|
||||
firmwareVersion: number | null // Firmware version of button, or null if unknown
|
||||
flicVersion: number | null // Flic version (1 or 2)
|
||||
uuid: string // A 32 characters long hex string, unique for every button
|
||||
key: number | null // A 40 characters long hex string (only for Flic 2)
|
||||
}
|
||||
|
||||
export interface ButtonModule {
|
||||
getButtons(): Button[],
|
||||
getButton(bdaddr: string): Button,
|
||||
on(ev: "buttonAdded", cb: (btn: Button) => void): void,
|
||||
on(ev: "buttonUpdated", cb: (btn: Button) => void): void,
|
||||
on(ev: "buttonDeleted", cb: (btn: Button) => void): void,
|
||||
on(ev: "buttonConnected", cb: (btn: Button) => void): void,
|
||||
on(ev: "buttonReady", cb: (obj: { bdaddr: string }) => void): void,
|
||||
on(ev: "buttonDisconnected", cb: (obj: { bdaddr: string }) => void): void,
|
||||
on(ev: "buttonDown", cb: (obj: { bdaddr: string }) => void): void,
|
||||
on(ev: "buttonUp", cb: (obj: { bdaddr: string }) => void): void,
|
||||
on(ev: "buttonClickOrHold", cb: (obj: { bdaddr: string, isClick: boolean, isHold: boolean }) => void): void,
|
||||
on(ev: "buttonSingleOrDoubleClick", cb: (obj: { bdaddr: string, isSingleClick: boolean, isDoubleClick: boolean }) => void): void,
|
||||
on(ev: "buttonSingleOrDoubleClickOrHold", cb: (obj: { bdaddr: string, isSingleClick: boolean, isDoubleClick: boolean, isHold: boolean }) => void): void,
|
||||
}
|
||||
|
||||
export interface IRModule {
|
||||
record(): void;
|
||||
cancelRecord(): void;
|
||||
play(arr: Uint32Array, cb: (err: any | undefined) => void): void;
|
||||
on(ev: 'recordComplete', cb: (d: Uint32Array) => void): void;
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
import { ButtonControllerOpt, makeButtonController } from "./ButtonController";
|
||||
import { HAmqttOptions, makeHAmqtt } from './HAmqtt';
|
||||
import { IRControllerOpt, makeIRController } from "./IRController";
|
||||
import { makeLogger } from "./Logger";
|
||||
import { ButtonModule, IRModule } from './flicTypes';
|
||||
import * as mqtt from './mqtt';
|
||||
export type MQTTOpt = {
|
||||
host: string;
|
||||
port: number;
|
||||
client_id: string;
|
||||
keep_alive: boolean;
|
||||
clean_session: boolean;
|
||||
username: string;
|
||||
password: string;
|
||||
}
|
||||
export type Options = {
|
||||
mqtt: Partial<MQTTOpt> & { host: string };
|
||||
debug?: boolean;
|
||||
ha?: Partial<HAmqttOptions>;
|
||||
flicBtns?: Partial<ButtonControllerOpt> & { disabled?: boolean };
|
||||
flicIR?: Partial<IRControllerOpt> & { disabled?: boolean };
|
||||
}
|
||||
export const start = (
|
||||
buttonModule: ButtonModule,
|
||||
irModule: IRModule,
|
||||
uniqueId: string,
|
||||
options: Options,
|
||||
) => {
|
||||
const mqttServer = mqtt.create(
|
||||
options.mqtt.host,
|
||||
{ ...options.mqtt, keep_alive: true },
|
||||
);
|
||||
const logger = makeLogger('root', options.debug ?? false);
|
||||
options.ha = options.ha ?? {}
|
||||
options.flicBtns = options.flicBtns ?? {}
|
||||
options.ha.debug = options.ha.debug ?? options.debug ?? false
|
||||
options.flicBtns.debug = options.flicBtns.debug ?? options.debug ?? false
|
||||
const ha = makeHAmqtt(mqttServer, options.ha);
|
||||
mqttServer.on('connected', () => {
|
||||
logger.info("connected to mqtt")
|
||||
if (!options.flicBtns?.disabled) {
|
||||
makeButtonController(
|
||||
ha, buttonModule, options.flicBtns,
|
||||
).start();
|
||||
}
|
||||
if (!options.flicIR?.disabled) {
|
||||
makeIRController(
|
||||
irModule,
|
||||
ha,
|
||||
mqttServer,
|
||||
uniqueId,
|
||||
options.flicIR,
|
||||
).start();
|
||||
}
|
||||
logger.info("all services up!")
|
||||
});
|
||||
mqttServer.on('error', function (err) {
|
||||
logger.info("'Error' event", JSON.stringify(err));
|
||||
setTimeout(function () {
|
||||
throw new Error("Crashed")
|
||||
}, 1000);
|
||||
});
|
||||
mqttServer.on("disconnected", function (err) {
|
||||
logger.info("'Error' disconnected", JSON.stringify(err));
|
||||
setTimeout(function () {
|
||||
throw new Error("Crashed")
|
||||
}, 1000);
|
||||
});
|
||||
mqttServer.on("close", function (err) {
|
||||
logger.info("'Error' close", JSON.stringify(err));
|
||||
setTimeout(function () {
|
||||
throw new Error("Crashed")
|
||||
}, 1000);
|
||||
});
|
||||
mqttServer.connect()
|
||||
}
|
||||
+610
@@ -0,0 +1,610 @@
|
||||
/* Copyright (c) 2013 Gordon Williams, Pur3 Ltd
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
All sections of code within this repository are licensed under an MIT License:
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
|
||||
Modified by Flic Shortcut Labs.
|
||||
|
||||
*/
|
||||
|
||||
/** 'private' constants */
|
||||
var C = {
|
||||
PROTOCOL_LEVEL: 4, // MQTT protocol level
|
||||
DEF_PORT: 1883, // MQTT default server port
|
||||
DEF_KEEP_ALIVE: 60 // Default keep_alive (s)
|
||||
};
|
||||
|
||||
/** Control packet types */
|
||||
var TYPE = {
|
||||
CONNECT: 1,
|
||||
CONNACK: 2,
|
||||
PUBLISH: 3,
|
||||
PUBACK: 4,
|
||||
PUBREC: 5,
|
||||
PUBREL: 6,
|
||||
PUBCOMP: 7,
|
||||
SUBSCRIBE: 8,
|
||||
SUBACK: 9,
|
||||
UNSUBSCRIBE: 10,
|
||||
UNSUBACK: 11,
|
||||
PINGREQ: 12,
|
||||
PINGRESP: 13,
|
||||
DISCONNECT: 14
|
||||
};
|
||||
|
||||
var pakId = Math.floor(Math.random() * 65534);
|
||||
|
||||
Uint8Array.prototype.charCodeAt = function (a, b) {
|
||||
return this.toString().charCodeAt(a, b);
|
||||
}
|
||||
|
||||
/**
|
||||
Return Codes
|
||||
http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc385349256
|
||||
**/
|
||||
var RETURN_CODES = {
|
||||
0: 'ACCEPTED',
|
||||
1: 'UNACCEPTABLE_PROTOCOL_VERSION',
|
||||
2: 'IDENTIFIER_REJECTED',
|
||||
3: 'SERVER_UNAVAILABLE',
|
||||
4: 'BAD_USER_NAME_OR_PASSWORD',
|
||||
5: 'NOT_AUTHORIZED'
|
||||
};
|
||||
|
||||
/** MQTT constructor */
|
||||
function MQTT(server, options) {
|
||||
this.server = server;
|
||||
options = options || {};
|
||||
this.port = options.port || C.DEF_PORT;
|
||||
this.client_id = options.client_id || mqttUid();
|
||||
this.keep_alive = options.keep_alive || C.DEF_KEEP_ALIVE;
|
||||
this.clean_session = options.clean_session || true;
|
||||
this.username = options.username;
|
||||
this.password = options.password;
|
||||
this.client = false;
|
||||
this.connected = false;
|
||||
/* if keep_alive is less than the ping interval we need to use
|
||||
a shorter ping interval, otherwise we'll just time out! */
|
||||
this.ping_interval =
|
||||
this.keep_alive < this.C.PING_INTERVAL ? (this.keep_alive - 5) : this.C.PING_INTERVAL;
|
||||
this.protocol_name = options.protocol_name || "MQTT";
|
||||
this.protocol_level = (options.protocol_level || C.PROTOCOL_LEVEL);
|
||||
|
||||
if (typeof this.client_id == 'string') {
|
||||
var payloadarray = [this.client_id.length >> 8, this.client_id.length & 255];
|
||||
var i = 2;
|
||||
var messagearray = this.client_id.split('');
|
||||
for (var j = 0; j < this.client_id.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
this.client_id = payloadarray;
|
||||
}
|
||||
if (this.password) {
|
||||
var payloadarray = [this.password.length >> 8, this.password.length & 255];
|
||||
var i = 2;
|
||||
var messagearray = this.password.split('');
|
||||
for (var j = 0; j < this.password.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
this.password = payloadarray;
|
||||
}
|
||||
if (this.username) {
|
||||
var payloadarray = [this.username.length >> 8, this.username.length & 255];
|
||||
var i = 2;
|
||||
var messagearray = this.username.split('');
|
||||
for (var j = 0; j < this.username.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
this.username = payloadarray;
|
||||
}
|
||||
}
|
||||
|
||||
var __listeners = {};
|
||||
|
||||
Object.prototype.on = function (type, fn) {
|
||||
if (!__listeners[type]) {
|
||||
__listeners[type] = [];
|
||||
}
|
||||
__listeners[type].push(fn);
|
||||
}
|
||||
|
||||
Object.prototype.emit = function (type, ...data) {
|
||||
if (__listeners[type]) {
|
||||
__listeners[type].map(function (fn) {
|
||||
fn(...data);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (!Buffer.from) {
|
||||
Buffer.from = function (a) {
|
||||
return new Buffer(a);
|
||||
}
|
||||
}
|
||||
|
||||
/** 'public' constants here */
|
||||
MQTT.prototype.C = {
|
||||
DEF_QOS: 0, // Default QOS level
|
||||
CONNECT_TIMEOUT: 10000, // Time (ms) to wait for CONNACK
|
||||
PING_INTERVAL: 40 // Server ping interval (s)
|
||||
};
|
||||
|
||||
/* Utility functions ***************************/
|
||||
|
||||
var fromCharCode = String.fromCharCode;
|
||||
|
||||
/** MQTT string (length MSB, LSB + data) */
|
||||
export function mqttStr(s) {
|
||||
var payloadarray = [s.length >> 8, s.length & 255];
|
||||
var i = 2;
|
||||
var messagearray = s.split('');
|
||||
for (var j = 0; j < s.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
|
||||
return payloadarray;
|
||||
}
|
||||
|
||||
export function mqttInt2Str(arr: number[] | Uint8Array): string {
|
||||
let outStr = "";
|
||||
for (var i = 0; i < arr.length; i++) {
|
||||
outStr += createEscapedHex(arr[i])
|
||||
}
|
||||
return outStr
|
||||
}
|
||||
|
||||
/** MQTT packet length formatter - algorithm from reference docs */
|
||||
function mqttPacketLength(length) {
|
||||
var encLength = [];
|
||||
var i = 0;
|
||||
do {
|
||||
var encByte = length & 127;
|
||||
length = length >> 7;
|
||||
// if there are more data to encode, set the top bit of this byte
|
||||
if (length > 0) {
|
||||
encByte += 128;
|
||||
}
|
||||
encLength[i] = encByte;
|
||||
i++;
|
||||
} while (length > 0);
|
||||
return encLength;
|
||||
}
|
||||
|
||||
/** MQTT packet length decoder - algorithm from reference docs */
|
||||
function mqttPacketLengthDec(length) {
|
||||
var bytes = 0;
|
||||
var decL = 0;
|
||||
var lb = 0;
|
||||
do {
|
||||
lb = length[bytes];
|
||||
decL |= (lb & 127) << (bytes++ * 7);
|
||||
} while ((lb & 128) && (bytes < 4))
|
||||
return { "decLen": decL, "lenBy": bytes };
|
||||
}
|
||||
|
||||
/** MQTT standard packet formatter */
|
||||
function mqttPacket(cmd, variable, payload) {
|
||||
var cmdAndLengthArray = [cmd].concat(mqttPacketLength(variable.length + payload.length));
|
||||
var headerAndPayloadArray = cmdAndLengthArray.concat(variable).concat(payload);
|
||||
var messageBuffer = Buffer.from(headerAndPayloadArray);
|
||||
return messageBuffer;
|
||||
}
|
||||
|
||||
/** Generate random UID */
|
||||
var mqttUid = (function () {
|
||||
function s4() {
|
||||
var numberstring = Math.floor((1 + Math.random() * 10));
|
||||
if (numberstring == 10) numberstring = 9;
|
||||
numberstring = 97 + numberstring;
|
||||
return numberstring;
|
||||
}
|
||||
|
||||
return function () {
|
||||
var output = [0, 12, s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4(), s4()];
|
||||
return output;
|
||||
};
|
||||
})();
|
||||
|
||||
/** Generate PID */
|
||||
function mqttPid() {
|
||||
pakId = pakId > 65534 ? 1 : ++pakId;
|
||||
return [pakId >> 8, pakId & 0xFF];
|
||||
}
|
||||
|
||||
/** Get PID from message */
|
||||
function getPid(data) {
|
||||
return data.slice(0, 2);
|
||||
}
|
||||
|
||||
/** PUBLISH control packet */
|
||||
function mqttPublish(topic, message, qos, flags) {
|
||||
var cmd = TYPE.PUBLISH << 4 | (qos << 1) | flags;
|
||||
var variable = mqttStr(topic);
|
||||
// Packet id must be included for QOS > 0
|
||||
if (qos > 0) {
|
||||
var newvariable = variable.concat(mqttPid());
|
||||
return mqttPacket(cmd, newvariable, message);
|
||||
} else {
|
||||
return mqttPacket(cmd, variable, message);
|
||||
}
|
||||
}
|
||||
|
||||
/** SUBSCRIBE control packet */
|
||||
function mqttSubscribe(topic, qos) {
|
||||
var cmd = TYPE.SUBSCRIBE << 4 | 2;
|
||||
var payloadarray = [];
|
||||
var i = 0;
|
||||
var messagearray = topic.split('');
|
||||
for (var j = 0; j < topic.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
return mqttPacket(cmd,
|
||||
mqttPid(),
|
||||
mqttStr(topic).concat([qos]));
|
||||
}
|
||||
|
||||
/** UNSUBSCRIBE control packet */
|
||||
function mqttUnsubscribe(topic) {
|
||||
var cmd = TYPE.UNSUBSCRIBE << 4 | 2;
|
||||
return mqttPacket(cmd,
|
||||
mqttPid(),
|
||||
mqttStr(topic));
|
||||
}
|
||||
|
||||
/** Create escaped hex value from number */
|
||||
function createEscapedHex(n: number): string {
|
||||
return fromCharCode(parseInt(n.toString(16), 16));
|
||||
}
|
||||
|
||||
// Handle a single packet of data
|
||||
MQTT.prototype.packetHandler = function (data) {
|
||||
|
||||
// if we had some data left over from last
|
||||
// time, add it on
|
||||
if (this.partData && this.partData.length > 0) {
|
||||
data = Buffer.from(Array.prototype.slice.call(this.partData).concat(Array.prototype.slice.call(data)));
|
||||
this.partData = [];
|
||||
}
|
||||
|
||||
// Figure out packet length...
|
||||
var dLen = mqttPacketLengthDec(data.slice(1, data.length));
|
||||
var pLen = dLen.decLen + dLen.lenBy + 1;
|
||||
// less than one packet?
|
||||
if (data.length < pLen) {
|
||||
this.partData = data;
|
||||
return;
|
||||
}
|
||||
// Get the data for this packet
|
||||
var pData = data.slice(1 + dLen.lenBy, pLen);
|
||||
// more than one packet? re-emit it so we handle it later
|
||||
if (data.length > pLen) {
|
||||
this.client.emit('data', data.slice(pLen, data.length));
|
||||
}
|
||||
// Now handle this MQTT packet
|
||||
var cmd = data[0];
|
||||
var type = cmd >> 4;
|
||||
var flag = cmd & 15;
|
||||
if (type === TYPE.PUBLISH) {
|
||||
var qos = (cmd & 0x6) >> 1;
|
||||
var topic_len = pData[0] << 8 | pData[1];
|
||||
var msg_start = 2 + topic_len + (qos ? 2 : 0);
|
||||
var parsedData = {
|
||||
topic: pData.slice(2, 2 + topic_len),
|
||||
message: pData.slice(msg_start, pData.length),
|
||||
dup: (cmd & 0x8) >> 3,
|
||||
qos: qos,
|
||||
pid: qos ? pData.slice(2 + topic_len, 4 + topic_len) : 0,
|
||||
retain: cmd & 0x1
|
||||
};
|
||||
if (parsedData.qos) {
|
||||
this.client.write([((parsedData.qos == 1) ? TYPE.PUBACK : TYPE.PUBREC) << 4, 2, parsedData.pid]);
|
||||
}
|
||||
this.emit('publish', parsedData);
|
||||
this.emit('message', mqttInt2Str(parsedData.topic), mqttInt2Str(parsedData.message));
|
||||
} else if (type === TYPE.PUBACK) {
|
||||
this.emit('puback', data.charCodeAt(2) << 8 | data.charCodeAt(3));
|
||||
} else if (type === TYPE.PUBREC) {
|
||||
var pubrelArray = [(TYPE.PUBREL << 4 | 2), 2];
|
||||
var pidArray = Array.prototype.slice.call(getPid(pData));
|
||||
var pubrecResponse = pubrelArray.concat(pidArray);
|
||||
this.client.write(Buffer.from(pubrecResponse));
|
||||
} else if (type === TYPE.PUBREL) {
|
||||
var pubcompArray = [(TYPE.PUBCOMP << 4), 2];
|
||||
var pidArray = Array.prototype.slice.call(getPid(pData));
|
||||
var pubrelResponse = pubcompArray.concat(pidArray);
|
||||
this.client.write(pubrelResponse);
|
||||
} else if (type === TYPE.PUBCOMP) {
|
||||
this.emit('pubcomp', data.charCodeAt(2) << 8 | data.charCodeAt(3));
|
||||
} else if (type === TYPE.SUBACK) {
|
||||
if (pData.length > 0) {
|
||||
if (pData[pData.length - 1] == 0x80) {
|
||||
this.emit('subscribed_fail');
|
||||
} else {
|
||||
this.emit('subscribed');
|
||||
}
|
||||
}
|
||||
} else if (type === TYPE.UNSUBACK) {
|
||||
this.emit('unsubscribed');
|
||||
} else if (type === TYPE.PINGREQ) {
|
||||
this.client.write([(TYPE.PINGRESP << 4), 0]);
|
||||
} else if (type === TYPE.PINGRESP) {
|
||||
this.emit('ping_reply');
|
||||
} else if (type === TYPE.CONNACK) {
|
||||
if (this.ctimo) clearTimeout(this.ctimo);
|
||||
this.ctimo = undefined;
|
||||
this.partData = [];
|
||||
var returnCode = pData[1];
|
||||
if (RETURN_CODES[returnCode] === 'ACCEPTED') {
|
||||
this.connected = true;
|
||||
// start pinging
|
||||
if (this.pintr) clearInterval(this.pintr);
|
||||
this.pintr = setInterval(this.ping.bind(this), this.ping_interval * 1000);
|
||||
// emit connected events
|
||||
this.emit('connected');
|
||||
this.emit('connect');
|
||||
} else {
|
||||
var mqttError = "Connection refused, ";
|
||||
this.connected = false;
|
||||
if (returnCode > 0 && returnCode < 6) {
|
||||
mqttError += RETURN_CODES[returnCode];
|
||||
} else {
|
||||
mqttError += "unknown return code: " + returnCode + ".";
|
||||
}
|
||||
this.emit('error', mqttError);
|
||||
}
|
||||
} else {
|
||||
this.emit('error', "MQTT unsupported packet type: " + type);
|
||||
}
|
||||
};
|
||||
|
||||
/* Public interface ****************************/
|
||||
|
||||
/** Establish connection and set up keep_alive ping */
|
||||
MQTT.prototype.connect = function (client) {
|
||||
if (this.connected) return;
|
||||
var mqo = this;
|
||||
var onConnect = function () {
|
||||
mqo.client = client;
|
||||
// write connection message
|
||||
var teststring = mqo.mqttConnect(mqo.client_id)
|
||||
client.write(teststring);
|
||||
// handle connection timeout if too slow
|
||||
mqo.ctimo = setTimeout(function () {
|
||||
mqo.ctimo = undefined;
|
||||
mqo.emit('disconnected');
|
||||
mqo.disconnect();
|
||||
}, mqo.C.CONNECT_TIMEOUT);
|
||||
// Incoming data
|
||||
client.on('data', mqo.packetHandler.bind(mqo));
|
||||
// Socket closed
|
||||
client.on('end', function () {
|
||||
mqo._scktClosed();
|
||||
});
|
||||
};
|
||||
if (client) {
|
||||
onConnect();
|
||||
} else {
|
||||
try {
|
||||
var self = this;
|
||||
client = require("net").Socket().connect({ host: mqo.server, port: mqo.port }, onConnect);
|
||||
client.on('error', function (err) {
|
||||
self.emit('error', err.message);
|
||||
});
|
||||
} catch (e) {
|
||||
this.client = false;
|
||||
this.emit('error', e.message);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/** Called internally when the connection closes */
|
||||
MQTT.prototype._scktClosed = function () {
|
||||
if (this.connected) {
|
||||
this.connected = false;
|
||||
this.client = false;
|
||||
if (this.pintr) clearInterval(this.pintr);
|
||||
if (this.ctimo) clearTimeout(this.ctimo);
|
||||
this.pintr = this.ctimo = undefined;
|
||||
this.emit('disconnected');
|
||||
this.emit('close');
|
||||
}
|
||||
};
|
||||
|
||||
/** Disconnect from server */
|
||||
MQTT.prototype.disconnect = function () {
|
||||
if (!this.client) return;
|
||||
try {
|
||||
this.client.write(Buffer.from([(TYPE.DISCONNECT << 4), 0]));
|
||||
} catch (e) {
|
||||
return this._scktClosed();
|
||||
}
|
||||
this.client.end();
|
||||
this.client = false;
|
||||
};
|
||||
|
||||
/** Publish message using specified topic.
|
||||
opts = {
|
||||
retain: bool // the server should retain this message and send it out again to new subscribers
|
||||
dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only)
|
||||
}
|
||||
*/
|
||||
MQTT.prototype.publish = function (topic, message, opts) {
|
||||
if (!this.client) return;
|
||||
opts = opts || {};
|
||||
try {
|
||||
var payloadarray = [];
|
||||
var i = 0;
|
||||
var messagearray = message.split('');
|
||||
for (var j = 0; j < message.length; j++) {
|
||||
var char = messagearray[j];
|
||||
var numberrepres = char.charCodeAt(0);
|
||||
payloadarray[i] = numberrepres;
|
||||
i = i + 1;
|
||||
}
|
||||
var publishMessage = mqttPublish(topic, payloadarray, opts.qos || this.C.DEF_QOS, (opts.retain ? 1 : 0) | (opts.dup ? 8 : 0));
|
||||
this.client.write(publishMessage);
|
||||
} catch (e) {
|
||||
this._scktClosed();
|
||||
}
|
||||
};
|
||||
|
||||
/** Subscribe to topic (filter) */
|
||||
MQTT.prototype.subscribe = function (topics, opts) {
|
||||
if (!this.client) return;
|
||||
opts = opts || {};
|
||||
|
||||
var subs = [];
|
||||
if ('string' === typeof topics) {
|
||||
topics = [topics];
|
||||
}
|
||||
if (Array.isArray(topics)) {
|
||||
topics.forEach(function (topic) {
|
||||
subs.push({
|
||||
topic: topic,
|
||||
qos: opts.qos || this.C.DEF_QOS
|
||||
});
|
||||
}.bind(this));
|
||||
} else {
|
||||
Object
|
||||
.keys(topics)
|
||||
.forEach(function (k) {
|
||||
subs.push({
|
||||
topic: k,
|
||||
qos: topics[k]
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
subs.forEach(function (sub) {
|
||||
var subpacket = mqttSubscribe(sub.topic, sub.qos);
|
||||
this.client.write(subpacket);
|
||||
}.bind(this));
|
||||
};
|
||||
|
||||
/** Unsubscribe to topic (filter) */
|
||||
MQTT.prototype.unsubscribe = function (topic) {
|
||||
if (!this.client) return;
|
||||
this.client.write(mqttUnsubscribe(topic));
|
||||
};
|
||||
|
||||
/** Send ping request to server */
|
||||
MQTT.prototype.ping = function () {
|
||||
if (!this.client) return;
|
||||
try {
|
||||
this.client.write(Buffer.from([TYPE.PINGREQ << 4, 0]));
|
||||
} catch (e) {
|
||||
this._scktClosed();
|
||||
}
|
||||
};
|
||||
|
||||
/* Packet specific functions *******************/
|
||||
|
||||
/** Create connection flags */
|
||||
MQTT.prototype.createFlagsForConnection = function (options) {
|
||||
var flags = 0;
|
||||
flags |= (this.username) ? 0x80 : 0;
|
||||
flags |= (this.username && this.password) ? 0x40 : 0;
|
||||
flags |= (options.clean_session) ? 0x02 : 0;
|
||||
return flags;
|
||||
};
|
||||
|
||||
/** CONNECT control packet
|
||||
Clean Session and Userid/Password are currently only supported
|
||||
connect flag. Wills are not
|
||||
currently supported.
|
||||
*/
|
||||
MQTT.prototype.mqttConnect = function (clean) {
|
||||
var cmd = TYPE.CONNECT << 4;
|
||||
var flags = this.createFlagsForConnection({
|
||||
clean_session: clean
|
||||
});
|
||||
|
||||
var keep_alive = [this.keep_alive >> 8, this.keep_alive & 255];
|
||||
|
||||
/* payload */
|
||||
var payload = this.client_id;
|
||||
if (this.username) {
|
||||
payload = payload.concat(this.username);
|
||||
if (this.password) {
|
||||
payload = payload.concat(this.password);
|
||||
}
|
||||
}
|
||||
return mqttPacket(cmd,
|
||||
mqttStr(this.protocol_name)/*protocol name*/.concat(
|
||||
[this.protocol_level]) /*protocol level*/.concat(
|
||||
[flags]).concat(keep_alive),
|
||||
payload);
|
||||
};
|
||||
|
||||
/* Exports *************************************/
|
||||
|
||||
/** This is 'exported' so it can be used with `require('MQTT.js').create(server, options)` */
|
||||
export function create(server, options): MQTT {
|
||||
return new MQTT(server, options);
|
||||
};
|
||||
|
||||
export function connect(options): MQTT {
|
||||
var mqtt = new MQTT(options.host, options);
|
||||
mqtt.connect();
|
||||
return mqtt;
|
||||
};
|
||||
|
||||
|
||||
export interface MQTT {
|
||||
connect(): void;
|
||||
publish(topic: string, message: string, opts: {
|
||||
retain?: boolean, // the server should retain this message and send it out again to new subscribers
|
||||
dup?: boolean, // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only)
|
||||
} | undefined): void;
|
||||
subscribe(topics: string[]): void;
|
||||
unsubscribe(topic: string): void;
|
||||
on(ev: 'publish', cb: (data: { topic: Buffer, message: Buffer }) => void): void;
|
||||
on(ev: 'message', cb: (topic: string, message: string) => void): void;
|
||||
on(ev: 'puback', cb: (data) => void): void;
|
||||
on(ev: 'pubcomp', cb: (data) => void): void;
|
||||
on(ev: 'subscribed_fail', cb: (data) => void): void;
|
||||
on(ev: 'subscribed', cb: (data) => void): void;
|
||||
on(ev: 'unsubscribed', cb: (data) => void): void;
|
||||
on(ev: 'ping_reply', cb: (data) => void): void;
|
||||
on(ev: 'connected', cb: (data) => void): void;
|
||||
on(ev: 'connect', cb: (data) => void): void;
|
||||
on(ev: 'error', cb: (data) => void): void;
|
||||
on(ev: 'disconnected', cb: (data) => void): void;
|
||||
on(ev: 'close', cb: (data) => void): void;
|
||||
};
|
||||
Reference in new issue
Block a user