incyclist-devices 1.4.25 → 1.4.28

package/lib/ble/ble-interface.js

@@ -0,0 +1,347 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const ble_1 = require("./ble");
+class BleInterface extends ble_1.BleInterfaceClass {
+    constructor(props = {}) {
+        super(props);
+        this.scanState = { isScanning: false, timeout: undefined };
+        this.connectState = { isConnecting: false, isConnected: false, isOpened: false };
+        this.devices = [];
+        console.log('BleInterface constructor', props);
+        if (props.logger)
+            this.logger = props.logger;
+        else if (props.log) {
+            this.logger = new gd_eventlog_1.EventLogger('BLE');
+        }
+    }
+    static getInstance(props = {}) {
+        if (!BleInterface._instance) {
+            BleInterface._instance = new BleInterface(props);
+        }
+        else {
+            if (props.binding) {
+                BleInterface._instance.setBinding(props.binding);
+            }
+            if (props.logger) {
+                BleInterface._instance.logger = props.logger;
+            }
+            if (props.log && !BleInterface._instance.logger) {
+                BleInterface._instance.logger = new gd_eventlog_1.EventLogger('BLE');
+            }
+        }
+        return BleInterface._instance;
+    }
+    static register(id, type, Class, services) {
+        if (this.deviceClasses.find(i => i.id === id))
+            return;
+        this.deviceClasses.push({ id, type, Class, services });
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        console.log(event);
+    }
+    onStateChange(state) {
+        if (state !== ble_1.BleState.POWERED_ON) {
+            this.connectState.isConnected = false;
+        }
+        else {
+            this.connectState.isConnected = true;
+        }
+    }
+    onError(err) {
+        this.logEvent({ message: 'error', error: err.message, stack: err.stack });
+    }
+    connect(props = {}) {
+        const timeout = props.timeout || 2000;
+        return new Promise((resolve, reject) => {
+            if (this.connectState.isConnected) {
+                return resolve(true);
+            }
+            this.logEvent({ message: 'connect request' });
+            if (!this.getBinding())
+                return Promise.reject(new Error('no binding defined'));
+            if (!this.connectState.isOpened) {
+                this.connectState.timeout = setTimeout(() => {
+                    this.connectState.isConnected = false;
+                    this.connectState.isConnecting = false;
+                    this.connectState.timeout = null;
+                    this.logEvent({ message: 'connect result: timeout' });
+                    reject(new Error('timeout'));
+                }, timeout);
+                try {
+                    const binding = this.getBinding()._bindings;
+                    const binding_init_original = binding.init.bind(binding);
+                    const self = this;
+                    binding.init = function () {
+                        try {
+                            binding_init_original();
+                            self.connectState.isOpened = true;
+                        }
+                        catch (err) {
+                            self.connectState.isOpened = false;
+                            self.connectState.isConnected = false;
+                            self.connectState.isConnecting = false;
+                            this.logEvent({ message: 'connect result: error', error: err.message });
+                            return reject(new Error(err.message));
+                        }
+                    };
+                    this.getBinding().once('error', (err) => {
+                        this.connectState.isConnected = true;
+                        this.connectState.isConnecting = false;
+                        this.logEvent({ message: 'connect result: error', error: err.message });
+                        this.getBinding().on('error', this.onError.bind(this));
+                        return reject(err);
+                    });
+                    this.getBinding().on('stateChange', (state) => {
+                        if (state === ble_1.BleState.POWERED_ON) {
+                            clearTimeout(this.connectState.timeout);
+                            this.connectState.timeout = null;
+                            this.getBinding().removeAllListeners('stateChange');
+                            this.getBinding().on('stateChange', this.onStateChange.bind(this));
+                            this.connectState.isConnected = true;
+                            this.connectState.isConnecting = false;
+                            this.logEvent({ message: 'connect result: success' });
+                            return resolve(true);
+                        }
+                    });
+                }
+                catch (err) {
+                    this.connectState.isConnected = false;
+                    this.connectState.isConnecting = false;
+                    if (this.connectState.timeout)
+                        clearTimeout(this.connectState.timeout);
+                    this.connectState.timeout = null;
+                    this.logEvent({ message: 'connect result: error', error: err.message });
+                    return reject(new Error('bluetooth unavailable, cause: ' + err.message));
+                }
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connectState.isConnected) {
+                return Promise.resolve(true);
+            }
+            if (!this.getBinding())
+                return Promise.reject(new Error('no binding defined'));
+            this.logEvent({ message: 'disconnect request' });
+            if (this.scanState.isScanning) {
+                yield this.stopScan();
+            }
+            const connectedDevices = this.devices.filter(d => d.isConnected);
+            for (let i = 0; i < connectedDevices.length; i++) {
+                const d = connectedDevices[i];
+                const device = d.device;
+                yield device.disconnect();
+            }
+            this.connectState.isConnected = false;
+            this.connectState.isConnecting = false;
+            if (this.connectState.timeout) {
+                clearTimeout(this.connectState.timeout);
+                this.connectState.timeout = null;
+            }
+            this.logEvent({ message: 'disconnect result: success' });
+            return true;
+        });
+    }
+    isConnected() {
+        return this.connectState.isConnected;
+    }
+    getDevicesFromServices(deviceTypes, services) {
+        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+            return [];
+        }
+        const get = (deviceTypes, fnCompare) => {
+            return deviceTypes.filter(DeviceType => {
+                const C = DeviceType;
+                if (!C.services)
+                    return false;
+                return C.services.find((s) => fnCompare(s));
+            });
+        };
+        if (typeof services === 'string') {
+            return get(deviceTypes, (s) => s === services);
+        }
+        if (Array.isArray(services)) {
+            return get(deviceTypes, s => services.includes(s));
+        }
+        return [];
+    }
+    getServicesFromDeviceTypes(deviceTypes) {
+        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+            return [];
+        }
+        const services = [];
+        deviceTypes.forEach(DeviceType => {
+            if (DeviceType.services) {
+                const dtServices = DeviceType.services;
+                dtServices.forEach(s => {
+                    if (!services.find(s2 => s2 === s))
+                        services.push(s);
+                });
+            }
+        });
+        return services;
+    }
+    getServicesFromDevice(device) {
+        if (!device)
+            return [];
+        const services = [];
+        const dServices = device.getServiceUUids();
+        dServices.forEach(s => {
+            if (!services.find(s2 => s2 === s))
+                services.push(s);
+        });
+        return services;
+    }
+    connectDevice(requested, timeout = 2000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.scan({ timeout, device: requested });
+            const { id, address, name } = requested;
+            if (devices.length === 0)
+                throw new Error('device not found');
+            if (devices[0]) {
+                const connected = yield devices[0].connect();
+                if (connected) {
+                    return devices[0];
+                }
+                else {
+                    throw new Error('connect failed');
+                }
+            }
+        });
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { timeout = 5000, deviceTypes = [], device } = props;
+            const scanForDevice = (device !== null && device !== undefined);
+            const services = this.getServicesFromDeviceTypes(deviceTypes);
+            const bleBinding = this.getBinding();
+            if (!bleBinding)
+                return Promise.reject(new Error('no binding defined'));
+            if (!this.isConnected()) {
+                yield this.connect();
+            }
+            const detectedPeripherals = {};
+            if (scanForDevice)
+                this.logEvent({ message: 'search device request', device, deviceTypes });
+            else
+                this.logEvent({ message: 'scan start', services });
+            return new Promise((resolve, reject) => {
+                if (this.scanState.isScanning) {
+                    this.logEvent({ message: 'scan result: already scanning' });
+                    return reject(new Error('scanning already in progress'));
+                }
+                this.scanState.isScanning = true;
+                bleBinding.startScanning(services, true, (err) => {
+                    if (err) {
+                        this.logEvent({ message: 'scan result: error', error: err.message });
+                        this.scanState.isScanning = false;
+                        return reject(err);
+                    }
+                    bleBinding.on('discover', (peripheral) => {
+                        if (!peripheral || !peripheral.advertisement)
+                            return;
+                        if (!detectedPeripherals[peripheral.id]) {
+                            detectedPeripherals[peripheral.id] = peripheral;
+                            let DeviceClasses;
+                            if (scanForDevice && (!deviceTypes || deviceTypes.length === 0)) {
+                                const classes = BleInterface.deviceClasses.map(c => c.Class);
+                                DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+                            }
+                            else {
+                                DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+                            }
+                            let cntFound = 0;
+                            DeviceClasses.forEach(DeviceClass => {
+                                if (!DeviceClass)
+                                    return;
+                                if (scanForDevice && cntFound > 0)
+                                    return;
+                                const C = DeviceClass;
+                                const d = new C({ peripheral });
+                                d.setInterface(this);
+                                if (scanForDevice) {
+                                    if ((device.id && d.id === device.id) || (device.address && d.address === device.address) || (device.name && d.name === device.name))
+                                        cntFound++;
+                                }
+                                else
+                                    cntFound++;
+                                if (cntFound > 0) {
+                                    this.logEvent({ message: 'scan: device found', device: d.name, services: d.services.join(',') });
+                                    this.devices.push({ device: d, isConnected: false });
+                                    this.emit('device', d);
+                                }
+                                if (scanForDevice && cntFound > 0) {
+                                    if (this.scanState.timeout) {
+                                        clearTimeout(this.scanState.timeout);
+                                        this.scanState.timeout = null;
+                                        bleBinding.stopScanning(() => {
+                                            this.scanState.isScanning = false;
+                                        });
+                                    }
+                                    resolve([d]);
+                                }
+                            });
+                        }
+                    });
+                });
+                this.scanState.timeout = setTimeout(() => {
+                    this.scanState.timeout = null;
+                    this.logEvent({ message: 'scan result: devices found', devices: this.devices.map(i => i.device.name) });
+                    resolve(this.devices.map(i => i.device));
+                    bleBinding.stopScanning(() => {
+                        this.scanState.isScanning = false;
+                    });
+                }, timeout);
+            });
+        });
+    }
+    stopScan() {
+        if (!this.scanState.isScanning) {
+            return Promise.resolve(true);
+        }
+        if (!this.getBinding())
+            return Promise.reject(new Error('no binding defined'));
+        this.logEvent({ message: 'scan stop request' });
+        return new Promise(resolve => {
+            this.getBinding().stopScanning(() => {
+                this.scanState.isScanning = false;
+                this.logEvent({ message: 'scan stop result: success' });
+                resolve(true);
+            });
+        });
+    }
+    isScanning() {
+        return this.scanState.isScanning;
+    }
+    addConnectedDevice(device) {
+        const existigDevice = this.devices.find(i => i.device.id === device.id);
+        if (existigDevice) {
+            existigDevice.isConnected = true;
+            return;
+        }
+        this.devices.push({ device, isConnected: true });
+    }
+    removeConnectedDevice(device) {
+        const existigDevice = this.devices.find(i => i.device.id === device.id);
+        if (existigDevice) {
+            existigDevice.isConnected = false;
+            return;
+        }
+    }
+}
+exports.default = BleInterface;
+BleInterface.deviceClasses = [];

package/lib/ble/ble.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+export declare type ConnectProps = {
+    timeout?: number;
+};
+export interface BleDeviceIdentifier {
+    id?: string;
+    address?: string;
+    name?: string;
+}
+export declare abstract class BleDeviceClass extends EventEmitter {
+    static services: string[];
+    id?: string;
+    address?: string;
+    name?: string;
+    peripheral?: BlePeripheral;
+    abstract getProfile(): string;
+    abstract getServiceUUids(): string[];
+    abstract connect(props?: ConnectProps): Promise<boolean>;
+    abstract disconnect(): Promise<boolean>;
+}
+export interface BleBinding extends EventEmitter {
+    startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
+    stopScanning(callback?: () => void): void;
+    _bindings: any;
+}
+export declare type ScanProps = {
+    timeout?: number;
+    deviceTypes?: (typeof BleDeviceClass)[];
+    device?: BleDeviceClass;
+};
+export declare class BleBindingWrapper {
+    protected binding: BleBinding;
+    constructor(binding: BleBinding);
+    open(): {
+        err: Error;
+        opened: boolean;
+    };
+    get(): BleBinding;
+}
+export declare abstract class BleInterfaceClass extends EventEmitter {
+    binding: BleBinding;
+    constructor(props?: {
+        binding?: BleBinding;
+    });
+    abstract connect(props: ConnectProps): Promise<boolean>;
+    abstract scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    abstract stopScan(): Promise<boolean>;
+    abstract disconnect(): Promise<boolean>;
+    abstract isScanning(): boolean;
+    abstract addConnectedDevice(device: BleDeviceClass): void;
+    abstract removeConnectedDevice(device: BleDeviceClass): void;
+    getBinding(): BleBinding;
+    setBinding(binding: BleBinding): void;
+}
+export interface BlePeripheral extends EventEmitter, BleDeviceIdentifier {
+    services: string[];
+    advertisement: any;
+    state: string;
+    connectAsync(): Promise<void>;
+    disconnect(cb: (err?: Error) => void): Promise<void>;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<any>;
+}
+export interface BleCharacteristic extends EventEmitter {
+}
+export declare type BleDeviceProps = {
+    id?: string;
+    address?: string;
+    name?: string;
+    services?: string[];
+    ble: BleInterfaceClass;
+    peripheral?: BlePeripheral;
+};
+export declare enum BleState {
+    UNKNOWN = "unknown",
+    RESETTING = "resetting",
+    UNSUPPORTED = "unsupported",
+    UNAUTHORIZED = "unauthorized",
+    POWERED_OFF = "poweredOff",
+    POWERED_ON = "poweredOn"
+}

package/lib/ble/ble.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+class BleDeviceClass extends events_1.default {
+}
+exports.BleDeviceClass = BleDeviceClass;
+BleDeviceClass.services = [];
+class BleBindingWrapper {
+    constructor(binding) {
+        this.binding = binding;
+        this.binding = binding;
+    }
+    open() {
+        const binding = this.binding._bindings;
+        const binding_init = binding.init.bind(binding);
+        try {
+            binding_init();
+            return { err: null, opened: true };
+        }
+        catch (err) {
+            const error = err;
+            const opened = false;
+            return { err: error, opened };
+        }
+    }
+    get() {
+        return this.binding;
+    }
+}
+exports.BleBindingWrapper = BleBindingWrapper;
+class BleInterfaceClass extends events_1.default {
+    constructor(props = {}) {
+        super();
+        this.setBinding(props.binding);
+    }
+    getBinding() { return this.binding; }
+    setBinding(binding) { this.binding = binding; }
+}
+exports.BleInterfaceClass = BleInterfaceClass;
+var BleState;
+(function (BleState) {
+    BleState["UNKNOWN"] = "unknown";
+    BleState["RESETTING"] = "resetting";
+    BleState["UNSUPPORTED"] = "unsupported";
+    BleState["UNAUTHORIZED"] = "unauthorized";
+    BleState["POWERED_OFF"] = "poweredOff";
+    BleState["POWERED_ON"] = "poweredOn";
+})(BleState = exports.BleState || (exports.BleState = {}));

package/lib/ble/hrm.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { BleDevice } from './ble-device';
+import BleInterface from './ble-interface';
+import DeviceAdapter from '../Device';
+import { DeviceProtocol } from '../DeviceProtocol';
+import { BleDeviceClass } from './ble';
+import BleProtocol from './incyclist-protocol';
+import { EventLogger } from 'gd-eventlog';
+declare type HrmData = {
+    heartrate: number;
+    rr: number;
+    raw: string;
+};
+export default class BleHrmDevice extends BleDevice {
+    static services: string[];
+    static characteristics: string[];
+    heartrate: number;
+    rr: number;
+    constructor(props?: any);
+    getProfile(): string;
+    getServiceUUids(): string[];
+    parseHrm(data: Buffer): HrmData;
+    onData(characteristic: string, data: Buffer): void;
+    write(characteristic: any, data: any): Promise<boolean>;
+    read(characteristic: any): Promise<Buffer>;
+}
+export declare class HrmAdapter extends DeviceAdapter {
+    device: BleHrmDevice;
+    ignore: boolean;
+    ble: BleInterface;
+    protocol: DeviceProtocol;
+    paused: boolean;
+    logger: EventLogger;
+    constructor(device: BleDeviceClass, protocol: BleProtocol);
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    getProfile(): string;
+    getName(): string;
+    getDisplayName(): string;
+    getPort(): string;
+    setIgnoreHrm(ignore: any): void;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+}
+export {};

package/lib/ble/hrm.js

@@ -0,0 +1,128 @@
+"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 });
+const ble_device_1 = require("./ble-device");
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const Device_1 = __importDefault(require("../Device"));
+const gd_eventlog_1 = require("gd-eventlog");
+class BleHrmDevice extends ble_device_1.BleDevice {
+    constructor(props) {
+        super(props);
+        this.heartrate = undefined;
+        this.rr = undefined;
+    }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
+    getServiceUUids() {
+        return BleHrmDevice.services;
+    }
+    parseHrm(data) {
+        try {
+            const ab = new Uint8Array(data);
+            const flags = ab[0];
+            let offset = 1;
+            if (flags % 1 === 0) {
+                this.heartrate = ab[1];
+            }
+            else {
+                this.heartrate = ab[1] + ab[2] * 256;
+                offset = 2;
+            }
+            if (flags % 0xF) {
+                this.rr = (ab[offset + 1] + ab[offset + 2] * 256) / 1024;
+            }
+        }
+        catch (err) {
+        }
+        const { heartrate, rr } = this;
+        return { heartrate, rr, raw: data.toString('hex') };
+    }
+    onData(characteristic, data) {
+        if (characteristic.toLocaleLowerCase() === '2a37') {
+            const res = this.parseHrm(data);
+            this.emit('data', res);
+        }
+    }
+    write(characteristic, data) {
+        console.log('write', characteristic, data);
+        return Promise.resolve(true);
+    }
+    read(characteristic) {
+        console.log('read', characteristic);
+        return Promise.resolve(Buffer.from([]));
+    }
+}
+exports.default = BleHrmDevice;
+BleHrmDevice.services = ['180d'];
+BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
+ble_interface_1.default.register('BleHrmDevice', 'hr', BleHrmDevice, BleHrmDevice.services);
+class HrmAdapter extends Device_1.default {
+    constructor(device, protocol) {
+        super(protocol);
+        this.ignore = false;
+        this.paused = false;
+        this.device = device;
+        this.ble = protocol.ble;
+        this.logger = new gd_eventlog_1.EventLogger('BleHrm');
+    }
+    isBike() { return false; }
+    isHrm() { return true; }
+    isPower() { return false; }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
+    getName() {
+        return `${this.device.name}`;
+    }
+    getDisplayName() {
+        const { name, heartrate: hrm } = this.device;
+        const hrmStr = hrm ? ` (${hrm})` : '';
+        return `${name}${hrmStr}`;
+    }
+    getPort() {
+        return 'ble';
+    }
+    setIgnoreHrm(ignore) {
+        this.ignore = ignore;
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start requested', props });
+            try {
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    bleDevice.on('data', (data) => {
+                        if (this.onDataFn && !this.ignore && !this.paused)
+                            this.onDataFn(data);
+                    });
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message });
+                return false;
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.device.disconnect();
+        });
+    }
+    pause() { this.paused = true; return Promise.resolve(true); }
+    resume() { this.paused = false; return Promise.resolve(true); }
+}
+exports.HrmAdapter = HrmAdapter;

package/lib/ble/incyclist-protocol.d.ts

@@ -0,0 +1,31 @@
+import { EventLogger } from "gd-eventlog";
+import DeviceProtocolBase, { DeviceProtocol, DeviceSettings, ScanProps, Device } from "../DeviceProtocol";
+import { BleBinding, BleDeviceClass } from "./ble";
+import BleInterface from "./ble-interface";
+interface BleDeviceSettings extends DeviceSettings {
+    id?: string;
+    profile: string;
+    address?: string;
+    protocol: string;
+    interface: string;
+}
+export default class BleProtocol extends DeviceProtocolBase implements DeviceProtocol {
+    static _defaultBinding: BleBinding;
+    static _instances: BleProtocol[];
+    logger: EventLogger;
+    ble: BleInterface;
+    constructor(binding?: BleBinding);
+    static setDefaultBinding(binding: BleBinding): void;
+    setBinding(binding: BleBinding): void;
+    createDevice(bleDevice: BleDeviceClass | BleDeviceSettings): Device;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    add(settings: BleDeviceSettings): Device;
+    scan(props: ScanProps): Promise<void>;
+    stopScan(): Promise<void>;
+    isScanning(): boolean;
+}
+export {};