incyclist-devices 2.2.9 → 2.3.0

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

@@ -0,0 +1,306 @@
+"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.DirectConnectInterfaceFactory = void 0;
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+const task_1 = require("../../utils/task");
+const peripheral_1 = require("./peripheral");
+const ble_1 = require("../../ble");
+const types_1 = require("../../ble/base/types");
+const DC_TYPE = 'wahoo-fitness-tnp';
+const DC_EXPIRATION_TIMEOUT = 10 * 1000 * 60;
+let instanceId = 0;
+class DirectConnectInterface extends events_1.default {
+    static getInstance(props = {}) {
+        if (DirectConnectInterface._instance === undefined)
+            DirectConnectInterface._instance = new DirectConnectInterface(props);
+        else {
+            if (props.binding) {
+                DirectConnectInterface._instance.setBinding(props.binding);
+            }
+            if (props.logger) {
+                DirectConnectInterface._instance.logger = props.logger;
+            }
+            if (props.log && !DirectConnectInterface._instance.logger) {
+                DirectConnectInterface._instance.logger = new gd_eventlog_1.EventLogger('DirectConnect');
+            }
+        }
+        return DirectConnectInterface._instance;
+    }
+    constructor(props) {
+        var _a;
+        super();
+        this.services = [];
+        this.matching = [];
+        this.connected = false;
+        this.props = props;
+        this.logEnabled = props.log || true;
+        const { binding } = props;
+        this.setLogger((_a = props.logger) !== null && _a !== void 0 ? _a : new gd_eventlog_1.EventLogger('DirectConnect'));
+        if (binding) {
+            this.setBinding(binding);
+        }
+        this.internalEvents = new events_1.default();
+        this.instance = ++instanceId;
+        if (this.binding)
+            this.autoConnect();
+    }
+    createPeripheral(announcement) {
+        return peripheral_1.DirectConnectPeripheral.create(announcement);
+    }
+    createDeviceSetting(service) {
+        const name = service.name;
+        const protocol = this.getProtocol(service);
+        return { interface: DirectConnectInterface.INTERFACE_NAME, name, protocol };
+    }
+    createPeripheralFromSettings(settings) {
+        const info = this.getAll().find(a => a.service.name === settings.name);
+        if (!(info === null || info === void 0 ? void 0 : info.service))
+            return null;
+        return this.createPeripheral(info.service);
+    }
+    getLogger() {
+        return this.logger;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    getName() {
+        return DirectConnectInterface.INTERFACE_NAME;
+    }
+    setBinding(binding) {
+        const prev = this.binding;
+        this.binding = binding;
+        if (!prev)
+            this.autoConnect();
+    }
+    getBinding() {
+        return this.binding;
+    }
+    autoConnect() {
+        this.connect();
+    }
+    connect(reconnect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.connected) {
+                return true;
+            }
+            try {
+                if (!((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.mdns)) {
+                    this.logEvent({ message: 'Direct Connect not available' });
+                    return false;
+                }
+                this.logEvent({ message: 'connecting to Direct Connect' });
+                this.getBinding().mdns.connect();
+                if (!reconnect)
+                    this.logEvent({ message: 'starting multicast DNS scan ..' });
+                this.getBinding().mdns.find({ type: DC_TYPE }, (service) => {
+                    this.addService(service);
+                });
+            }
+            catch (err) {
+                this.logError(err, 'connect');
+                return false;
+            }
+            this.connected = true;
+            return true;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.isConnected())
+                return true;
+            this.logEvent({ message: 'Disconnecting from Direct Connect' });
+            yield this.stopScan();
+            (_b = (_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.mdns) === null || _b === void 0 ? void 0 : _b.disconnect();
+            this.internalEvents.removeAllListeners();
+            this.connected = false;
+            return !this.isConnected();
+        });
+    }
+    isConnected() {
+        var _a;
+        return this.connected && ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.mdns) !== undefined && this.binding.mdns !== null;
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logDisabled = false;
+            if (this.isScanning()) {
+                this.logEvent({ message: 'starting scan - already scanning' });
+                yield this.scanTask.getPromise();
+            }
+            this.logEvent({ message: 'starting scan ..' });
+            yield this.reconnect();
+            this.scanTask = new task_1.InteruptableTask(this.startScan(), {
+                timeout: props.timeout,
+                state: { matching: [] },
+                name: 'scan',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this),
+                onDone: this.onScanDone.bind(this)
+            });
+            return this.scanTask.run();
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isScanning())
+                return Promise.resolve(true);
+            this.logEvent({ message: 'stopping scan ...' });
+            const res = yield this.scanTask.stop();
+            delete this.scanTask;
+            return res;
+        });
+    }
+    onScanDone() {
+        this.logEvent({ message: 'scan stopped' });
+        return this.buildDeviceSettings(this.matching);
+    }
+    pauseLogging() {
+        this.logDisabled = true;
+    }
+    resumeLogging() {
+        this.logDisabled = false;
+    }
+    isLoggingPaused() {
+        return this.logDisabled;
+    }
+    waitForPeripheral(settings) {
+        const peripheral = this.createPeripheralFromSettings(settings);
+        if (peripheral)
+            return Promise.resolve(peripheral);
+        return new Promise((done) => {
+            const onDevice = (device) => {
+                if (device.name === settings.name) {
+                    const peripheral = this.createPeripheralFromSettings(settings);
+                    if (peripheral) {
+                        this.off('device', onDevice);
+                        done(peripheral);
+                    }
+                }
+            };
+            this.on('device', onDevice);
+        });
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.disconnect();
+            yield this.connect(true);
+        });
+    }
+    isScanning() {
+        var _a;
+        return (_a = this.scanTask) === null || _a === void 0 ? void 0 : _a.isRunning();
+    }
+    startScan() {
+        this.logEvent({ message: 'scan started', success: this.isScanning() });
+        this.emitCachedDevices();
+        return new Promise(() => {
+        });
+    }
+    emitCachedDevices() {
+        const announced = this.getAll();
+        this.matching = announced.map(a => a.service.name);
+        announced.forEach(a => {
+            this.emitDevice(a.service);
+        });
+    }
+    emitDevice(service) {
+        this.emit('device', this.createDeviceSetting(service), service);
+    }
+    buildDeviceSettings(matching = []) {
+        return matching.map((name) => ({ interface: DirectConnectInterface.INTERFACE_NAME, name }));
+    }
+    addService(service) {
+        var _a;
+        try {
+            service.transport = this.getName();
+            const existing = this.find(service);
+            if (existing) {
+                const idx = this.services.indexOf(existing);
+                this.services[idx] = { ts: Date.now(), service };
+            }
+            else {
+                this.logEvent({ message: 'device announced', device: service.name, announcement: service });
+                this.services.push({ ts: Date.now(), service });
+                this.emitDevice(service);
+                (_a = this.matching) === null || _a === void 0 ? void 0 : _a.push(service.name);
+            }
+        }
+        catch (err) {
+            this.logError(err, 'addService');
+        }
+    }
+    find(service) {
+        return this.services.find(a => a.service.name === service.name && a.ts > Date.now() - DC_EXPIRATION_TIMEOUT);
+    }
+    getAll() {
+        return this.services.filter(a => a.ts > Date.now() - DC_EXPIRATION_TIMEOUT);
+    }
+    setDebug(enabled) {
+        this.debug = enabled;
+    }
+    logEvent(event) {
+        if (this.logDisabled && event.message !== 'Error')
+            return;
+        this.getLogger().logEvent(event);
+        const emitPayload = Object.assign({}, event);
+        delete emitPayload.ts;
+        this.emit('log', emitPayload);
+        const w = global.window;
+        if (this.debug || (w === null || w === void 0 ? void 0 : w.SERVICE_DEBUG) || process.env.DEBUG)
+            console.log(`~~~ ${this.logger.getName().toUpperCase()}-SVC`, event);
+    }
+    logError(err, fn, args) {
+        const logInfo = args || {};
+        this.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
+    }
+    getProtocol(announcement) {
+        var _a;
+        const DeviceClasses = (_a = this.getAdapterFactory().getAllSupportedSensors()) !== null && _a !== void 0 ? _a : [];
+        const matching = DeviceClasses.filter(C => {
+            const device = new C(null);
+            return device.isMatching(announcement.serviceUUIDs);
+        });
+        let DeviceClass;
+        DeviceClass = this.getBestDeviceMatch(matching);
+        const C = new DeviceClass(null);
+        return C.getProtocol();
+    }
+    getBestDeviceMatch(DeviceClasses) {
+        if (!DeviceClasses || DeviceClasses.length === 0)
+            return;
+        const details = DeviceClasses.map(c => ({ name: c.prototype.constructor.name, priority: c.detectionPriority || 0, class: c }));
+        details.sort((a, b) => b.priority - a.priority);
+        return details[0].class;
+    }
+    getAdapterFactory() {
+        return ble_1.BleAdapterFactory.getInstance('wifi');
+    }
+}
+DirectConnectInterface.INTERFACE_NAME = 'wifi';
+exports.default = DirectConnectInterface;
+class DirectConnectInterfaceFactory extends types_1.InterfaceFactory {
+    constructor() {
+        super();
+        this.iface = DirectConnectInterface.getInstance();
+    }
+    getInterface() {
+        return this.iface;
+    }
+}
+exports.DirectConnectInterfaceFactory = DirectConnectInterfaceFactory;

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

@@ -0,0 +1,50 @@
+import { BleCharacteristic, BleService, BleWriteProps, IBlePeripheral } from "../../ble/types";
+import { DirectConnectBinding, MulticastDnsAnnouncement, Socket } from "../bindings";
+import { InteruptableTask, TaskState } from "../../utils/task";
+import DirectConnectInterface from "./interface";
+import EventEmitter from "events";
+export declare class DirectConnectPeripheral implements IBlePeripheral {
+    protected announcement: MulticastDnsAnnouncement;
+    static readonly instances: Record<string, DirectConnectPeripheral>;
+    static create(announcement: MulticastDnsAnnouncement): DirectConnectPeripheral;
+    protected socket: Socket;
+    protected connectTask: InteruptableTask<TaskState, boolean>;
+    protected msgSeqNo: number;
+    protected onDataHandler: any;
+    protected onPortErrorHandler: any;
+    protected onPortCloseHandler: any;
+    protected partialBuffer: any;
+    protected remainingBuffer: any;
+    protected eventEmitter: EventEmitter<[never]>;
+    protected subscribed: Array<string>;
+    protected onDisconnectHandler: () => void;
+    constructor(announcement: MulticastDnsAnnouncement);
+    get services(): BleService[];
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    onDisconnect(callback: () => void): void;
+    discoverServices(): Promise<string[]>;
+    discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribe(characteristicUUID: string): Promise<boolean>;
+    subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribeAll(): Promise<boolean>;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+    protected startConnection(): Promise<boolean>;
+    protected onPortError(err: Error): void;
+    protected onPortClose(): Promise<void>;
+    protected getPath(): string;
+    protected stopConnection(): Promise<boolean>;
+    protected getNextSeqNo(): number;
+    protected send(seqNo: number, data: Buffer): Promise<Buffer>;
+    protected getNextMessage(data: Buffer): Buffer;
+    protected processRemaining(): void;
+    protected onData(data: Buffer): Promise<void>;
+    protected getInterface(): DirectConnectInterface;
+    protected logEvent(event: any): void;
+    protected getBinding(): DirectConnectBinding;
+}