incyclist-devices 1.4.25 → 1.4.28

package/lib/Device.d.ts

@@ -49,7 +49,7 @@ export interface DeviceAdapter extends Device {
     sendUpdate(request: any): void;
     onData(callback: OnDeviceDataCallback): void;
 }
-export default class DeviceAdapterBase implements DeviceAdapter {
+export default class IncyclistDevice implements DeviceAdapter {
     protocol: DeviceProtocol;
     detected: boolean;
     selected: boolean;

package/lib/Device.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
-class DeviceAdapterBase {
+class IncyclistDevice {
     constructor(proto) {
         this.protocol = proto;
         this.detected = false;
@@ -42,4 +42,4 @@ class DeviceAdapterBase {
         this.onDataFn = callback;
     }
 }
-exports.default = DeviceAdapterBase;
+exports.default = IncyclistDevice;

package/lib/DeviceProtocol.d.ts

@@ -16,7 +16,7 @@ export declare type Device = {
 };
 export interface DeviceSettings {
     name: string;
-    port: string;
+    port?: string;
     userSettings?: User;
     bikeSettings?: any;
 }
@@ -64,6 +64,7 @@ export default class DeviceProtocolBase {
     getSerialPort(): void;
     setNetImpl(netClass: any): void;
     getNetImpl(): any;
+    setBinding(_bindingClass: any): void;
     static setAnt(antClass: any): void;
     static getAnt(): any;
     static setSerialPort(serialClass: any): void;

package/lib/DeviceProtocol.js

@@ -29,6 +29,7 @@ class DeviceProtocolBase {
     getSerialPort() { DeviceProtocolBase.getSerialPort(); }
     setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
     getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
+    setBinding(_bindingClass) { }
     static setAnt(antClass) { _ant = antClass; }
     static getAnt() { return _ant; }
     static setSerialPort(serialClass) { _serial = serialClass; }

package/lib/DeviceSupport.d.ts

@@ -6,11 +6,16 @@ import DaumPremiumProtocol from './daum/premium/DaumPremiumProtocol';
 import DaumClassicProtocol from './daum/classic/DaumClassicProtocol';
 import KettlerRacerProtocol from './kettler/ergo-racer/protocol';
 import { AntScanner } from './ant/AntScanner';
+import BleProtocol from './ble/incyclist-protocol';
 import { CyclingModeProperyType } from './CyclingMode';
+import BleInterface from './ble/ble-interface';
+import BleHrmDevice from './ble/hrm';
+import BleCyclingPowerDevice from './ble/pwr';
 declare const Protocols: {
     SimulatorProtocol: typeof SimulatorProtocol;
     DaumClassicProtocol: typeof DaumClassicProtocol;
     DaumPremiumProtocol: typeof DaumPremiumProtocol;
     KettlerRacerProtocol: typeof KettlerRacerProtocol;
+    BleProtocol: typeof BleProtocol;
 };
-export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, CyclingModeProperyType };
+export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, BleProtocol, CyclingModeProperyType, BleInterface, BleHrmDevice, BleCyclingPowerDevice };

package/lib/DeviceSupport.js

@@ -23,12 +23,21 @@ const DaumClassicProtocol_1 = __importDefault(require("./daum/classic/DaumClassi
 const protocol_1 = __importDefault(require("./kettler/ergo-racer/protocol"));
 const AntScanner_1 = require("./ant/AntScanner");
 exports.AntScanner = AntScanner_1.AntScanner;
+const incyclist_protocol_1 = __importDefault(require("./ble/incyclist-protocol"));
+exports.BleProtocol = incyclist_protocol_1.default;
 const CyclingMode_1 = require("./CyclingMode");
 exports.CyclingModeProperyType = CyclingMode_1.CyclingModeProperyType;
+const ble_interface_1 = __importDefault(require("./ble/ble-interface"));
+exports.BleInterface = ble_interface_1.default;
+const hrm_1 = __importDefault(require("./ble/hrm"));
+exports.BleHrmDevice = hrm_1.default;
+const pwr_1 = __importDefault(require("./ble/pwr"));
+exports.BleCyclingPowerDevice = pwr_1.default;
 const Protocols = {
     SimulatorProtocol: Simulator_1.default,
     DaumClassicProtocol: DaumClassicProtocol_1.default,
     DaumPremiumProtocol: DaumPremiumProtocol_1.default,
     KettlerRacerProtocol: protocol_1.default,
+    BleProtocol: incyclist_protocol_1.default
 };
 exports.Protocols = Protocols;

package/lib/ant/AntScanner.js

@@ -231,23 +231,25 @@ class AntProtocol extends DeviceProtocol_1.default {
                             });
                         }
                         if (!open) {
-                            let detachedKernelDriver = false;
                             while (devices.length) {
                                 let device;
                                 try {
                                     device = devices.shift();
                                     device.open();
                                     const iface = device.interfaces[0];
+                                    let kernelDriverActive = undefined;
+                                    let claimRequested = false;
                                     try {
-                                        if (iface.isKernelDriverActive()) {
-                                            detachedKernelDriver = true;
+                                        kernelDriverActive = iface.isKernelDriverActive();
+                                        if (kernelDriverActive) {
                                             iface.detachKernelDriver();
                                         }
+                                        claimRequested = true;
+                                        iface.claim();
                                     }
                                     catch (kernelErr) {
-                                        this.logger.logEvent({ message: 'Kernel Error', error: kernelErr.message });
+                                        this.logger.logEvent({ message: 'Kernel Error', error: kernelErr.message, kernelDriverActive, claimRequested });
                                     }
-                                    iface.claim();
                                     break;
                                 }
                                 catch (deviceErr) {

package/lib/ant/antfe/AntFEAdapter.js

@@ -287,28 +287,9 @@ class AntFEAdapter extends AntAdapter_1.default {
             yield _super.stop.call(this);
             this.logger.logEvent({ message: 'stop()' });
             this.stopWorker();
-            const Messages = this.getProtocol().getAnt().Messages;
-            const stick = this.stick;
-            const channel = this.channel;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.starting = false;
                 return resolve(true);
-                if (!this.started && !this.connected)
-                    return resolve(false);
-                try {
-                    stick.write(Messages.openChannel(channel));
-                    const protocol = this.getProtocol();
-                    yield protocol.detachSensor(this);
-                    this.started = false;
-                    this.connected = false;
-                    this.logger.logEvent({ message: 'stop() finished' });
-                    resolve(true);
-                }
-                catch (err) {
-                    this.connected = false;
-                    this.logger.logEvent({ message: 'stop() error', error: err.message });
-                    reject(err);
-                }
             }));
         });
     }

package/lib/ant/anthrm/AntHrmAdapter.js

@@ -123,17 +123,6 @@ class AntHrmAdapter extends AntAdapter_1.default {
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.starting = false;
                 return resolve(true);
-                this.started = false;
-                if (this.ignoreHrm)
-                    return resolve(false);
-                try {
-                    const protocol = this.getProtocol();
-                    yield protocol.detachSensor(this);
-                    resolve(true);
-                }
-                catch (err) {
-                    reject(err);
-                }
             }));
         });
     }

package/lib/ant/antpwr/pwr-adapter.js

@@ -241,17 +241,6 @@ class AntFEAdapter extends AntAdapter_1.default {
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 this.starting = false;
                 return resolve(true);
-                this.started = false;
-                if (this.ignoreHrm)
-                    return resolve(false);
-                try {
-                    const protocol = this.getProtocol();
-                    yield protocol.detachSensor(this);
-                    resolve(true);
-                }
-                catch (err) {
-                    reject(err);
-                }
             }));
         });
     }

package/lib/ble/ble-device.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { EventLogger } from "gd-eventlog";
+import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleCharacteristic, BleDeviceProps, ConnectProps } from "./ble";
+interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    isDisconnecting: boolean;
+}
+interface BleDeviceConstructProps extends BleDeviceProps {
+    log?: boolean;
+    logger?: EventLogger;
+}
+export declare abstract class BleDevice extends BleDeviceClass {
+    id: string;
+    address: string;
+    name: string;
+    services: string[];
+    ble: BleInterfaceClass;
+    peripheral?: BlePeripheral;
+    characteristics: BleCharacteristic[];
+    state?: string;
+    connectState: ConnectState;
+    logger?: EventLogger;
+    constructor(props?: BleDeviceConstructProps);
+    logEvent(event: any): void;
+    setInterface(ble: BleInterfaceClass): void;
+    private cleanupListeners;
+    private onDisconnect;
+    connect(props?: ConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    abstract getProfile(): string;
+    abstract onData(characteristic: string, data: Buffer): void;
+    abstract write(characteristic: string, data: Buffer): Promise<boolean>;
+    abstract read(characteristic: string): Promise<Buffer>;
+}
+export {};

package/lib/ble/ble-device.js

@@ -0,0 +1,174 @@
+"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 BleDevice extends ble_1.BleDeviceClass {
+    constructor(props) {
+        super();
+        this.characteristics = [];
+        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
+        this.id = props.id;
+        this.address = props.address;
+        this.name = props.name;
+        this.services = props.services;
+        this.ble = props.ble;
+        this.characteristics = [];
+        if (props.peripheral) {
+            const { id, address, advertisement, state } = props.peripheral;
+            this.peripheral = props.peripheral;
+            this.id = id;
+            this.address = address;
+            this.name = advertisement.localName;
+            this.services = advertisement.serviceUuids;
+            this.state = state;
+        }
+        if (props.logger) {
+            this.logger = props.logger;
+        }
+        else if (props.log) {
+            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
+        }
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        if (process.env.BLE_DEBUG) {
+            console.log(event);
+        }
+    }
+    setInterface(ble) {
+        this.ble = ble;
+    }
+    cleanupListeners() {
+        if (this.characteristics === undefined) {
+            this.characteristics = [];
+        }
+        else {
+            this.characteristics.forEach(c => {
+                c.removeAllListeners('data');
+            });
+            this.characteristics = [];
+        }
+    }
+    onDisconnect() {
+        this.state = "disconnected";
+        if (!this.connectState.isDisconnecting) {
+            this.connect();
+        }
+        this.emit('disconnected');
+    }
+    connect(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
+                this.connectState.isConnecting = true;
+                try {
+                    yield peripheral.connectAsync();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'cannot connect', error: err.message || err });
+                }
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = true;
+                this.state = "connected";
+                this.emit('connected');
+                this.cleanupListeners();
+                this.ble.addConnectedDevice(this);
+                this.peripheral.once('disconnect', () => { this.onDisconnect(); });
+                try {
+                    const { characteristics } = yield peripheral.discoverSomeServicesAndCharacteristicsAsync(this.services || [], []);
+                    characteristics.forEach(c => {
+                        if (c.properties.find(p => p === 'notify')) {
+                            c.on('data', (data, _isNotification) => {
+                                this.onData(c.uuid, data);
+                            });
+                            c.subscribe((err) => {
+                                if (err)
+                                    this.logEvent({ message: 'cannot subscribe', error: err.message || err });
+                            });
+                        }
+                    });
+                }
+                catch (err) {
+                    this.logEvent({ message: 'cannot connect', error: err.message || err });
+                }
+            });
+            try {
+                if (this.peripheral) {
+                    const { id, address, advertisement } = this.peripheral;
+                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
+                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
+                    yield connectPeripheral(this.peripheral);
+                    this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
+                    return true;
+                }
+                else {
+                    const { id, name, address } = this;
+                    if (this.address || this.id || this.name) {
+                        this.connectState.isConnecting = true;
+                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
+                        try {
+                            if (this.ble.isScanning()) {
+                                yield this.ble.stopScan();
+                            }
+                            const devices = yield this.ble.scan({ device: this });
+                            if (devices && devices.length > 0) {
+                                this.peripheral = devices[0].peripheral;
+                                yield connectPeripheral(this.peripheral);
+                                this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
+                                return true;
+                            }
+                        }
+                        catch (err) {
+                        }
+                    }
+                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address } });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = false;
+                    return false;
+                }
+            }
+            catch (err) {
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'connect result: error', error: err.message });
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, name, address } = this;
+            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.connectState.isDisconnecting = true;
+            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
+                this.connectState.isDisconnecting = false;
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnecting) {
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnected) {
+                this.ble.removeConnectedDevice(this);
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+        });
+    }
+}
+exports.BleDevice = BleDevice;

package/lib/ble/ble-interface.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { EventLogger } from 'gd-eventlog';
+import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BleBinding } from './ble';
+export interface ScanState {
+    isScanning: boolean;
+    timeout?: NodeJS.Timeout;
+}
+export interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    timeout?: NodeJS.Timeout;
+    isOpened: boolean;
+}
+export interface BleDeviceInfo {
+    device: BleDeviceClass;
+    isConnected: boolean;
+}
+export interface BleDeviceClassInfo {
+    Class: typeof BleDeviceClass;
+    type: string;
+    services: string[];
+    id: string;
+}
+export default class BleInterface extends BleInterfaceClass {
+    scanState: ScanState;
+    connectState: ConnectState;
+    devices: BleDeviceInfo[];
+    logger: EventLogger;
+    static deviceClasses: BleDeviceClassInfo[];
+    static _instance: BleInterface;
+    static getInstance(props?: {
+        binding?: BleBinding;
+        log?: boolean;
+        logger?: EventLogger;
+    }): BleInterface;
+    constructor(props?: {
+        binding?: BleBinding;
+        log?: boolean;
+        logger?: EventLogger;
+    });
+    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
+    logEvent(event: any): void;
+    onStateChange(state: any): void;
+    onError(err: any): void;
+    connect(props?: ConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
+    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
+    getServicesFromDevice(device: BleDeviceClass): string[];
+    connectDevice(requested: BleDeviceClass, timeout?: number): Promise<BleDeviceClass>;
+    scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+    addConnectedDevice(device: BleDeviceClass): void;
+    removeConnectedDevice(device: BleDeviceClass): void;
+}