incyclist-devices 2.2.9 → 2.3.0

package/lib/direct-connect/base/peripheral.js

@@ -0,0 +1,413 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectConnectPeripheral = void 0;
+const task_1 = require("../../utils/task");
+const interface_1 = __importDefault(require("./interface"));
+const messages_1 = require("../messages");
+const events_1 = __importDefault(require("events"));
+const consts_1 = require("../consts");
+const utils_1 = require("../../ble/utils");
+class DirectConnectPeripheral {
+    static create(announcement) {
+        const { address, port } = announcement;
+        const key = `${address}:${port}`;
+        if (!this.instances[key])
+            this.instances[key] = new DirectConnectPeripheral(announcement);
+        return this.instances[key];
+    }
+    constructor(announcement) {
+        this.announcement = announcement;
+        this.msgSeqNo = 0;
+        this.onDataHandler = this.onData.bind(this);
+        this.onPortErrorHandler = this.onPortError.bind(this);
+        this.onPortCloseHandler = this.onPortClose.bind(this);
+        this.partialBuffer = null;
+        this.remainingBuffer = null;
+        this.eventEmitter = new events_1.default();
+        this.subscribed = [];
+    }
+    get services() {
+        const services = this.announcement.serviceUUIDs;
+        return services.map(s => ({ uuid: s }));
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return true;
+            if (this.isConnecting())
+                yield this.connectTask.getPromise();
+            this.connectTask = new task_1.InteruptableTask(this.startConnection(), {
+                timeout: 1000,
+            });
+            return yield this.connectTask.run();
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.connectTask.stop();
+                yield this.stopConnection();
+                delete this.socket;
+            }
+            catch (err) {
+                return false;
+            }
+            return true;
+        });
+    }
+    isConnected() {
+        return this.socket !== undefined;
+    }
+    isConnecting() {
+        var _a;
+        return (_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.isRunning();
+    }
+    onDisconnect(callback) {
+        this.onDisconnectHandler = callback;
+    }
+    discoverServices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seqNo = this.getNextSeqNo();
+            const message = new messages_1.DiscoverServiceMessage();
+            const request = message.createRequest(seqNo, {});
+            this.logEvent({ message: 'DiscoverServices request', path: this.getPath(), raw: request.toString('hex') });
+            const response = yield this.send(seqNo, request);
+            const res = message.parseResponse(response);
+            const uuids = res.body.serviceDefinitions.map(s => (0, utils_1.beautifyUUID)(s.serviceUUID));
+            this.logEvent({ message: 'DiscoverServices response', path: this.getPath(), uuids, raw: request.toString('hex') });
+            return res.body.serviceDefinitions.map(s => s.serviceUUID);
+        });
+    }
+    discoverCharacteristics(serviceUUID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seqNo = this.getNextSeqNo();
+            const message = new messages_1.DiscoverCharacteristicsMessage();
+            const request = message.createRequest(seqNo, { serviceUUID: (0, utils_1.parseUUID)(serviceUUID) });
+            this.logEvent({ message: 'DiscoverCharacteritics request', path: this.getPath(), service: (0, utils_1.beautifyUUID)(serviceUUID), raw: request.toString('hex') });
+            const response = yield this.send(seqNo, request);
+            const res = message.parseResponse(response);
+            const service = (0, utils_1.beautifyUUID)(res.body.serviceUUID);
+            const characteristics = res.body.characteristicDefinitions.map(cd => `${(0, utils_1.beautifyUUID)(cd.characteristicUUID)}:${cd.properties.join('/')}`);
+            this.logEvent({ message: 'DiscoverCharacteritics response', path: this.getPath(), service, characteristics, raw: request.toString('hex') });
+            return res.body.characteristicDefinitions.map(c => ({ uuid: c.characteristicUUID, properties: c.properties }));
+        });
+    }
+    subscribe(characteristicUUID, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seqNo = this.getNextSeqNo();
+            const message = new messages_1.EnableCharacteristicNotificationsMessage();
+            const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), enable: true });
+            this.logEvent({ message: 'EnableCharacteristicNotifications request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), enabled: true, raw: request.toString('hex') });
+            const response = yield this.send(seqNo, request);
+            const res = message.parseResponse(response);
+            this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: request.toString('hex') });
+            const confirmed = res.body.characteristicUUID;
+            if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
+                this.subscribed.push(characteristicUUID);
+                this.eventEmitter.on((0, utils_1.parseUUID)(characteristicUUID), (data) => {
+                    callback(characteristicUUID, data);
+                });
+                return true;
+            }
+            return false;
+        });
+    }
+    unsubscribe(characteristicUUID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const seqNo = this.getNextSeqNo();
+                const message = new messages_1.EnableCharacteristicNotificationsMessage();
+                const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), enable: false });
+                this.logEvent({ message: 'EnableCharacteristicNotifications request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), enabled: false, raw: request.toString('hex') });
+                const response = yield this.send(seqNo, request);
+                const res = message.parseResponse(response);
+                this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: request.toString('hex') });
+                const confirmed = res.body.characteristicUUID;
+                if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
+                    this.subscribed.splice(this.subscribed.indexOf(characteristicUUID), 1);
+                    this.eventEmitter.removeAllListeners((0, utils_1.parseUUID)(characteristicUUID));
+                    return true;
+                }
+                return false;
+            }
+            catch (err) {
+                this.logEvent({ messsage: 'EnableCharacteristicNotifications failed', reason: err.message });
+                return false;
+            }
+        });
+    }
+    subscribeAll(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let services = [];
+                try {
+                    services = yield this.discoverServices();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not discover services', reason: err.message });
+                }
+                const res = [];
+                for (let i = 0; i < services.length; i++) {
+                    const service = services[i];
+                    let characteristics = [];
+                    try {
+                        characteristics = yield this.discoverCharacteristics(service);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'could not discover characteristics', service, reason: err.message });
+                        return false;
+                    }
+                    if (!(characteristics === null || characteristics === void 0 ? void 0 : characteristics.length))
+                        continue;
+                    for (let j = 0; j < characteristics.length; j++) {
+                        const characteristic = characteristics[j];
+                        if (characteristic.properties.includes('notify'))
+                            yield this.subscribe(characteristic.uuid, callback);
+                    }
+                }
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not subscribe', reason: err.message });
+                return false;
+            }
+        });
+    }
+    subscribeSelected(characteristics, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const retry = [];
+            for (let i = 0; i < characteristics.length; i++) {
+                const uuid = characteristics[i];
+                const success = yield this.subscribe(uuid, callback);
+                if (!success)
+                    retry.push(uuid);
+            }
+            for (let i = 0; i < retry.length; i++) {
+                const c = retry[i];
+                yield this.subscribe(c.uuid, callback);
+            }
+            return true;
+        });
+    }
+    unsubscribeAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            this.subscribed.forEach(characteristicUUID => {
+                promises.push(this.unsubscribe(characteristicUUID));
+            });
+            yield Promise.allSettled(promises);
+            return true;
+        });
+    }
+    read(characteristicUUID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seqNo = this.getNextSeqNo();
+            const message = new messages_1.ReadCharacteristicMessage();
+            const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID) });
+            this.logEvent({ message: 'ReadCharacteristic request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), raw: request.toString('hex') });
+            const response = yield this.send(seqNo, request);
+            const res = message.parseResponse(response);
+            this.logEvent({ message: 'ReadCharacteristic response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID),
+                data: Buffer.from(res.body.characteristicData).toString('hex'),
+                raw: request.toString('hex') });
+            return Buffer.from(res.body.characteristicData);
+        });
+    }
+    write(characteristicUUID, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                if (!(options === null || options === void 0 ? void 0 : options.withoutResponse)) {
+                    const uuid = (0, utils_1.parseUUID)(characteristicUUID);
+                    this.eventEmitter.once(uuid, (data) => {
+                        resolve(data);
+                    });
+                }
+                const seqNo = this.getNextSeqNo();
+                const message = new messages_1.WriteCharacteristicMessage();
+                const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), characteristicData: data });
+                this.logEvent({ message: 'WriteCharacteristic request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID),
+                    data: data.toString('hex'),
+                    raw: request.toString('hex') });
+                this.send(seqNo, request).then((response) => {
+                    const res = message.parseResponse(response);
+                    this.logEvent({ message: 'WriteCharacteristic response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID),
+                        raw: request.toString('hex') });
+                    if (options === null || options === void 0 ? void 0 : options.withoutResponse) {
+                        resolve(Buffer.from([]));
+                    }
+                })
+                    .catch(err => {
+                    this.logEvent({ message: 'WriteCharacteristic error', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), error: err.message });
+                });
+            });
+        });
+    }
+    startConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address, port } = this.announcement;
+            try {
+                const net = this.getBinding().net;
+                this.socket = net.createSocket();
+                return new Promise((resolve, reject) => {
+                    this.socket.once('timeout', () => {
+                        this.stopConnection().then(() => resolve(false));
+                    });
+                    this.socket.once('error', (err) => {
+                        this.stopConnection().then(() => resolve(false));
+                    });
+                    this.socket.once('connect', () => {
+                        this.socket.on('data', this.onDataHandler);
+                        this.socket.on('error', this.onPortErrorHandler);
+                        this.socket.on('close', this.onPortCloseHandler);
+                        this.socket.on('end', this.onPortCloseHandler);
+                        resolve(true);
+                    });
+                    this.socket.connect(port, address);
+                });
+            }
+            catch (err) {
+                return false;
+            }
+        });
+    }
+    onPortError(err) {
+        this.logEvent({ message: 'port error', path: this.getPath(), reason: err.message });
+    }
+    onPortClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.socket.removeAllListeners();
+            this.logEvent({ message: 'port closed', path: this.getPath() });
+            try {
+                yield this.disconnect();
+            }
+            catch (_a) { }
+            if (this.onDisconnectHandler)
+                this.onDisconnectHandler();
+        });
+    }
+    getPath() {
+        const { address, port } = this.announcement;
+        const path = `${address}:${port}`;
+        return path;
+    }
+    stopConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.eventEmitter.removeAllListeners();
+            if (!this.isConnected())
+                return true;
+            yield this.unsubscribeAll();
+            this.socket.removeAllListeners();
+            return new Promise(done => {
+                const onClosed = () => {
+                    this.socket.removeAllListeners();
+                    delete this.socket;
+                    done(true);
+                };
+                const onCloseError = (err) => {
+                    this.logEvent({ message: 'port error', path: this.getPath(), reason: err.message });
+                    this.socket.removeAllListeners();
+                    delete this.socket;
+                    done(false);
+                };
+                this.socket.on('end', onClosed);
+                this.socket.on('error', onCloseError);
+                this.socket.on('close', onClosed);
+                this.socket.destroy();
+            });
+        });
+    }
+    getNextSeqNo() {
+        this.msgSeqNo = (this.msgSeqNo + 1) % 256;
+        return this.msgSeqNo;
+    }
+    send(seqNo, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.socket.write(data);
+            return new Promise(done => {
+                this.eventEmitter.once(`response-${seqNo}`, (response) => {
+                    done(response);
+                });
+            });
+        });
+    }
+    getNextMessage(data) {
+        let incoming = data;
+        if (this.partialBuffer) {
+            incoming = Buffer.concat([
+                Buffer.from(this.partialBuffer),
+                Buffer.from(data)
+            ]);
+            delete this.partialBuffer;
+        }
+        if (incoming.length < 6) {
+            this.partialBuffer = Buffer.from(incoming);
+            return null;
+        }
+        const header = (0, messages_1.parseHeader)(incoming);
+        if (incoming.length < header.length + 6) {
+            this.partialBuffer = Buffer.from(incoming);
+            return null;
+        }
+        if (incoming.length > header.length + 6) {
+            this.remainingBuffer = Buffer.from(incoming.subarray(header.length + 6));
+            incoming = incoming.subarray(0, header.length + 6);
+        }
+        return incoming;
+    }
+    processRemaining() {
+        if (this.remainingBuffer) {
+            const next = Buffer.from(this.remainingBuffer);
+            delete this.remainingBuffer;
+            this.onData(next);
+        }
+    }
+    onData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const incoming = this.getNextMessage(data);
+            if (incoming === null)
+                return;
+            try {
+                const header = (0, messages_1.parseHeader)(incoming);
+                if (header.msgId === consts_1.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION) {
+                    const message = new messages_1.CharacteristicNotificationMessage();
+                    const notification = message.parseResponse(incoming);
+                    this.msgSeqNo = notification.header.seqNum;
+                    const uuid = (0, utils_1.parseUUID)(notification.body.characteristicUUID);
+                    this.logEvent({ message: 'Characteristic notification', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(notification.body.characteristicUUID),
+                        data: Buffer.from(notification.body.characteristicData).toString('hex') });
+                    this.eventEmitter.emit(uuid, notification.body.characteristicData);
+                }
+                else {
+                    this.eventEmitter.emit(`response-${header.seqNum}`, incoming);
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'onData', error: err.message, stack: err.stack, path: this.getPath(), raw: incoming.toString('hex') });
+            }
+            this.processRemaining();
+        });
+    }
+    getInterface() {
+        return interface_1.default.getInstance();
+    }
+    logEvent(event) {
+        this.getInterface().logEvent(event);
+    }
+    getBinding() {
+        return this.getInterface().getBinding();
+    }
+}
+exports.DirectConnectPeripheral = DirectConnectPeripheral;
+DirectConnectPeripheral.instances = {};

package/lib/direct-connect/base/sensor.d.ts

@@ -0,0 +1,3 @@
+import { BleComms } from "../../ble/base/comms";
+export declare class DirectConnectComms extends BleComms {
+}

package/lib/direct-connect/base/sensor.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectConnectComms = void 0;
+const comms_1 = require("../../ble/base/comms");
+class DirectConnectComms extends comms_1.BleComms {
+}
+exports.DirectConnectComms = DirectConnectComms;

package/lib/direct-connect/bindings/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/lib/direct-connect/bindings/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);

package/lib/direct-connect/bindings/types.d.ts

@@ -0,0 +1,36 @@
+import EventEmitter from "events";
+import { PeripheralAnnouncement } from "../../ble/types";
+export interface Socket extends EventEmitter {
+    connect(port: number, host: string): Socket;
+    destroy(): void;
+    write(data: Buffer): boolean;
+}
+export interface NetBinding {
+    createSocket(): Socket;
+}
+export interface DirectConnectBinding {
+    mdns: MulticastDnsBinding;
+    net: NetBinding;
+}
+type KeyValue = {
+    [key: string]: any;
+};
+export interface BrowserConfig {
+    type: string;
+    name?: string;
+    protocol?: 'tcp' | 'udp';
+    subtypes?: string[];
+    txt?: KeyValue;
+}
+export interface MulticastDnsAnnouncement extends PeripheralAnnouncement {
+    address: string;
+    protocol?: 'tcp' | 'udp';
+    port: number;
+    serialNo?: string;
+}
+export interface MulticastDnsBinding {
+    connect(): void;
+    disconnect(): void;
+    find(opts: BrowserConfig | null, onup?: (service: MulticastDnsAnnouncement) => void): void;
+}
+export {};

package/lib/direct-connect/bindings/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/direct-connect/consts.d.ts

@@ -0,0 +1,17 @@
+export declare const DC_RC_REQUEST_COMPLETED_SUCCESSFULLY = 0;
+export declare const DC_RC_UNKNOWN_MESSAGE_TYPE = 1;
+export declare const DC_RC_UNEXPECTED_ERROR = 2;
+export declare const DC_RC_SERVICE_NOT_FOUND = 3;
+export declare const DC_RC_CHARACTERISTIC_NOT_FOUND = 4;
+export declare const DC_RC_CHARACTERISTIC_OPERATION_NOT_SUPPORTED = 5;
+export declare const DC_RC_CHARACTERISTIC_WRITE_FAILED_INVALID_SIZE = 6;
+export declare const DC_RC_UNKNOWN_PROTOCOL_VERSION = 7;
+export declare const DC_MESSAGE_DISCOVER_SERVICES = 1;
+export declare const DC_MESSAGE_DISCOVER_CHARACTERISTICS = 2;
+export declare const DC_MESSAGE_READ_CHARACTERISTIC = 3;
+export declare const DC_MESSAGE_WRITE_CHARACTERISTIC = 4;
+export declare const DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS = 5;
+export declare const DC_MESSAGE_CHARACTERISTIC_NOTIFICATION = 6;
+export declare const DC_ERROR_INVALID_MESSAGE_TYPE = 1;
+export declare const DC_ERROR_INVALID_MESSAGE_LENGTH = 2;
+export declare const DC_ERROR_UNKNOWN_MESSAGE_TYPE = 3;

package/lib/direct-connect/consts.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DC_ERROR_UNKNOWN_MESSAGE_TYPE = exports.DC_ERROR_INVALID_MESSAGE_LENGTH = exports.DC_ERROR_INVALID_MESSAGE_TYPE = exports.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION = exports.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS = exports.DC_MESSAGE_WRITE_CHARACTERISTIC = exports.DC_MESSAGE_READ_CHARACTERISTIC = exports.DC_MESSAGE_DISCOVER_CHARACTERISTICS = exports.DC_MESSAGE_DISCOVER_SERVICES = exports.DC_RC_UNKNOWN_PROTOCOL_VERSION = exports.DC_RC_CHARACTERISTIC_WRITE_FAILED_INVALID_SIZE = exports.DC_RC_CHARACTERISTIC_OPERATION_NOT_SUPPORTED = exports.DC_RC_CHARACTERISTIC_NOT_FOUND = exports.DC_RC_SERVICE_NOT_FOUND = exports.DC_RC_UNEXPECTED_ERROR = exports.DC_RC_UNKNOWN_MESSAGE_TYPE = exports.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY = void 0;
+exports.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY = 0;
+exports.DC_RC_UNKNOWN_MESSAGE_TYPE = 1;
+exports.DC_RC_UNEXPECTED_ERROR = 2;
+exports.DC_RC_SERVICE_NOT_FOUND = 3;
+exports.DC_RC_CHARACTERISTIC_NOT_FOUND = 4;
+exports.DC_RC_CHARACTERISTIC_OPERATION_NOT_SUPPORTED = 5;
+exports.DC_RC_CHARACTERISTIC_WRITE_FAILED_INVALID_SIZE = 6;
+exports.DC_RC_UNKNOWN_PROTOCOL_VERSION = 7;
+exports.DC_MESSAGE_DISCOVER_SERVICES = 0x01;
+exports.DC_MESSAGE_DISCOVER_CHARACTERISTICS = 0x02;
+exports.DC_MESSAGE_READ_CHARACTERISTIC = 0x03;
+exports.DC_MESSAGE_WRITE_CHARACTERISTIC = 0x04;
+exports.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS = 0x05;
+exports.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION = 0x06;
+exports.DC_ERROR_INVALID_MESSAGE_TYPE = 1;
+exports.DC_ERROR_INVALID_MESSAGE_LENGTH = 2;
+exports.DC_ERROR_UNKNOWN_MESSAGE_TYPE = 3;

package/lib/direct-connect/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './consts';
+export * from './messages';

package/lib/direct-connect/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const interface_factory_1 = require("../ble/factories/interface-factory");
+const interface_1 = require("./base/interface");
+__exportStar(require("./types"), exports);
+__exportStar(require("./consts"), exports);
+__exportStar(require("./messages"), exports);
+interface_factory_1.BleMultiTransportInterfaceFactory.register('wifi', interface_1.DirectConnectInterfaceFactory);

package/lib/direct-connect/messages/CharacteristicNotification.d.ts

@@ -0,0 +1,12 @@
+import { EmptyBody, TDCBody, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCCharacteristicNotification = TDCResponse<TDCCharacteristicNotificationBody>;
+export interface TDCCharacteristicNotificationBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export declare class CharacteristicNotificationMessage extends Message<EmptyBody, TDCCharacteristicNotificationBody> {
+    constructor(seqNum?: number);
+    buildResponseBody(body: TDCCharacteristicNotificationBody): Buffer;
+    parseResponseBody(body: Buffer): TDCCharacteristicNotificationBody;
+}

package/lib/direct-connect/messages/CharacteristicNotification.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CharacteristicNotificationMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class CharacteristicNotificationMessage extends message_1.Message {
+    constructor(seqNum) {
+        super(consts_1.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION);
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData)]);
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+}
+exports.CharacteristicNotificationMessage = CharacteristicNotificationMessage;

package/lib/direct-connect/messages/DiscoverCharacteristics.d.ts

@@ -0,0 +1,22 @@
+import { BleProperty } from "../../ble/types";
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCDiscoverCharacteristicsRequest = TDCRequest<TDCDiscoverCharacteristicsRequestBody>;
+export type TDCDiscoverCharacteristicsResponse = TDCResponse<TDCDiscoverCharacteristicsResponseBody>;
+export interface TDCDiscoverCharacteristicsRequestBody extends TDCBody {
+    serviceUUID: string;
+}
+export interface TDCDiscoverCharacteristicsResponseBody extends TDCBody {
+    serviceUUID: string;
+    characteristicDefinitions: Array<{
+        characteristicUUID: string;
+        properties: BleProperty[];
+    }>;
+}
+export declare class DiscoverCharacteristicsMessage extends Message<TDCDiscoverCharacteristicsRequestBody, TDCDiscoverCharacteristicsResponseBody> {
+    constructor();
+    parseRequestBody(body: Buffer): TDCDiscoverCharacteristicsRequestBody;
+    buildRequestBody(body: TDCDiscoverCharacteristicsRequestBody): Buffer;
+    buildResponseBody(body: TDCDiscoverCharacteristicsResponseBody): Buffer;
+    parseResponseBody(body: Buffer): TDCDiscoverCharacteristicsResponseBody;
+}

package/lib/direct-connect/messages/DiscoverCharacteristics.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverCharacteristicsMessage = void 0;
+const utils_1 = require("../../ble/utils");
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class DiscoverCharacteristicsMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_DISCOVER_CHARACTERISTICS);
+    }
+    parseRequestBody(body) {
+        const serviceUUID = body.subarray(0, 16).toString("hex");
+        return {
+            serviceUUID,
+        };
+    }
+    buildRequestBody(body) {
+        return Buffer.from(body.serviceUUID, "hex");
+    }
+    buildResponseBody(body) {
+        const serviceUUIDBuffer = Buffer.from(body.serviceUUID, "hex");
+        const characteristicBuffers = body.characteristicDefinitions.map((charDef) => Buffer.concat([
+            Buffer.from(charDef.characteristicUUID, "hex"),
+            Buffer.from([(0, utils_1.propertyVal)(charDef.properties)]),
+        ]));
+        return Buffer.concat([serviceUUIDBuffer, ...characteristicBuffers]);
+    }
+    parseResponseBody(body) {
+        const length = body.length;
+        const serviceUUID = body.subarray(0, 16).toString("hex");
+        const characteristicDefinitions = [];
+        for (let i = 16; i < length; i += 17) {
+            const characteristicUUID = Buffer.from(body.subarray(i, i + 16)).toString("hex");
+            const properties = (0, utils_1.propertyFromVal)(body.readUInt8(i + 16));
+            characteristicDefinitions.push({ characteristicUUID, properties });
+        }
+        return {
+            serviceUUID,
+            characteristicDefinitions,
+        };
+    }
+}
+exports.DiscoverCharacteristicsMessage = DiscoverCharacteristicsMessage;