incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/ble/base/adapter.js

@@ -13,24 +13,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const adpater_1 = __importDefault(require("../../base/adpater"));
-const ble_interface_1 = __importDefault(require("../ble-interface"));
-const INTERFACE_NAME = 'ble';
+const types_1 = require("../../types");
+const interface_factory_1 = require("../factories/interface-factory");
+const task_1 = require("../../utils/task");
+const utils_1 = require("../../utils/utils");
 class BleAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.onDeviceDataHandler = this.onDeviceData.bind(this);
-        if (this.settings.interface !== INTERFACE_NAME)
-            throw new Error('Incorrect interface');
         this.deviceData = {};
         this.data = {};
         this.dataMsgCount = 0;
         this.updateFrequency = 1000;
-        this.ble = ble_interface_1.default.getInstance();
     }
     getUniqueName() {
         var _a;
         const settings = this.settings;
-        if (((_a = settings.name) === null || _a === void 0 ? void 0 : _a.match(/[0-9]/g)) || settings.address === undefined)
+        if (((_a = settings.name) === null || _a === void 0 ? void 0 : _a.match(/\d/g)) || settings.address === undefined)
             return this.getName();
         else {
             const addressHash = settings.address.substring(0, 2) + settings.address.slice(-2);
@@ -39,26 +38,29 @@ class BleAdapter extends adpater_1.default {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device) {
-                throw new Error('No Comms');
-            }
-            if (this.isConnected())
-                return true;
-            let connected = false;
-            try {
-                connected = yield this.device.connect();
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
-            }
-            return connected;
+            const ble = this.getBle();
+            return yield ble.connect();
+        });
+    }
+    getPeripheral() {
+        const ble = this.getBle();
+        const p = ble === null || ble === void 0 ? void 0 : ble.createPeripheralFromSettings(this.settings);
+        return p;
+    }
+    waitForPeripheral() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'waiting for sensor ...', device: this.getName(), interface: this.getInterface() });
+            const ble = this.getBle();
+            const peripheral = yield ble.waitForPeripheral(this.settings);
+            this.updateSensor(peripheral);
         });
     }
+    updateSensor(peripheral) {
+        throw new Error('method not implemented');
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device || !this.isConnected())
-                return true;
-            return yield this.device.disconnect();
+            return true;
         });
     }
     getComms() {
@@ -81,16 +83,24 @@ class BleAdapter extends adpater_1.default {
         return this.isEqual(adapter.getSettings());
     }
     isConnected() {
-        return this.device && this.device.isConnected();
+        var _a;
+        return (_a = this.device) === null || _a === void 0 ? void 0 : _a.isConnected();
     }
     resetData() {
+        super.resetData();
         this.dataMsgCount = 0;
         this.deviceData = {};
         this.data = {};
         this.lastDataTS = undefined;
     }
     getInterface() {
-        return INTERFACE_NAME;
+        const iface = this.settings.interface;
+        if (typeof iface === 'string')
+            return this.settings.interface;
+        else {
+            const i = this.settings.interface;
+            return i.getName();
+        }
     }
     getProfile() {
         const C = this.constructor;
@@ -112,7 +122,7 @@ class BleAdapter extends adpater_1.default {
         if (this.isStopped() || this.isPaused())
             return;
         try {
-            this.logEvent({ message: 'refreshDeviceData', data: this.deviceData, isControllable: this.isControllable() });
+            this.logEvent({ message: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), data: this.deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(this.deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -124,7 +134,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'error', fn: 'refreshDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'error', fn: 'refreshDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     onDeviceData(deviceData) {
@@ -132,9 +142,10 @@ class BleAdapter extends adpater_1.default {
             this.dataMsgCount++;
             this.lastDataTS = Date.now();
             this.deviceData = Object.assign({}, deviceData);
-            if (!this.canEmitData())
+            if (!this.canEmitData()) {
                 return;
-            this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
+            }
+            this.logEvent({ message: 'onDeviceData', device: this.getName(), interface: this.getInterface(), data: deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(deviceData);
                 const incyclistData = this.getCyclingMode().updateData(mappedData);
@@ -146,7 +157,7 @@ class BleAdapter extends adpater_1.default {
             this.emitData(this.data);
         }
         catch (err) {
-            this.logEvent({ message: 'Error', fn: 'onDeviceData', error: err.message, stack: err.stack });
+            this.logEvent({ message: 'Error', fn: 'onDeviceData', device: this.getName(), interface: this.getInterface(), error: err.message, stack: err.stack });
         }
     }
     mapData(deviceData) {
@@ -164,6 +175,9 @@ class BleAdapter extends adpater_1.default {
     check() {
         return this.start({ scanOnly: true });
     }
+    getDefaultStartupTimeout() {
+        return 30000;
+    }
     startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasPaused = this.paused;
@@ -171,10 +185,7 @@ class BleAdapter extends adpater_1.default {
             this.stopped = false;
             if (wasPaused)
                 this.resume();
-            if (this.started && !wasPaused && !wasStopped) {
-                return 'done';
-            }
-            if (this.started && wasPaused) {
+            if (this.started && !wasStopped) {
                 return 'done';
             }
             const connected = yield this.connect();
@@ -185,45 +196,176 @@ class BleAdapter extends adpater_1.default {
     }
     start(startProps) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            if (this.isStarting()) {
+                yield this.stop();
+            }
+            const ble = this.getBle();
+            ble.once('disconnect-done', this.onDisconnectDone.bind(this));
+            this.startTask = new task_1.InteruptableTask(this.startAdapter(startProps), {
+                timeout: startProps === null || startProps === void 0 ? void 0 : startProps.timeout,
+                name: 'start',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this)
+            });
+            const res = yield this.startTask.run();
+            return res;
+        });
+    }
+    isStarting() {
+        var _a;
+        return (_a = this.startTask) === null || _a === void 0 ? void 0 : _a.isRunning();
+    }
+    hasData() {
+        return this.dataMsgCount > 0;
+    }
+    waitForInitialData(startupTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let waitTask;
+            let iv;
+            const wait = () => {
+                const res = new Promise((resolve) => {
+                    iv = setInterval(() => {
+                        if (this.hasData()) {
+                            clearInterval(iv);
+                            resolve(true);
+                        }
+                        else if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
+                            resolve(false);
+                            clearInterval(iv);
+                        }
+                    }, 10);
+                });
+                return res;
+            };
+            waitTask = new task_1.InteruptableTask(wait(), {
+                errorOnTimeout: false,
+                timeout: startupTimeout
+            });
+            this.logEvent({ message: 'wait for sensor data', device: this.getName(), interface: this.getInterface() });
+            const hasData = yield waitTask.run();
+            clearInterval(iv);
+            if (hasData)
+                this.logEvent({ message: 'sensor data received', device: this.getName(), interface: this.getInterface() });
+        });
+    }
+    checkCapabilities() {
+    }
+    initControl(_props) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    startAdapter(startProps) {
+        return __awaiter(this, void 0, void 0, function* () {
             const props = this.getStartProps(startProps);
+            const { timeout = this.getDefaultStartupTimeout() } = startProps !== null && startProps !== void 0 ? startProps : {};
+            const wasPaused = this.paused;
             const preCheckResult = yield this.startPreChecks(props);
-            if (preCheckResult === 'done')
+            if (preCheckResult === 'done') {
+                yield (0, utils_1.resolveNextTick)();
+                this.logEvent({ message: `start result: ${this.started ? 'success' : 'failed'}`, preCheckResult, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
                 return this.started;
-            if (preCheckResult === 'connection-failed')
-                throw new Error(`could not start device, reason:could not connect`);
-            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
+            }
+            if (preCheckResult === 'connection-failed') {
+                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
+                yield (0, utils_1.resolveNextTick)();
+                return false;
+            }
+            this.logEvent({ message: 'starting device', device: this.getName(), interface: this.getInterface(), props, isStarted: this.started });
             try {
-                const comms = this.device;
-                if (comms) {
-                    comms.on('data', this.onDeviceDataHandler);
-                    this.resetData();
-                    this.stopped = false;
-                    this.started = true;
-                    this.paused = false;
-                    return true;
+                this.resetData();
+                this.stopped = false;
+                const connected = yield this.startSensor();
+                if (connected) {
+                    this.logEvent({ message: 'peripheral connected', device: this.getName(), interface: this.getInterface(), props });
+                }
+                else {
+                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), interface: this.getInterface(), reason: 'unknown', props });
+                    this.stopped = true;
+                    return false;
                 }
+                yield this.waitForInitialData(timeout);
+                this.checkCapabilities();
+                if (this.hasCapability(types_1.IncyclistCapability.Control))
+                    yield this.initControl(startProps);
+                this.stopped = false;
+                this.started = true;
+                if (wasPaused)
+                    this.resume();
+                if (!this.isStarting()) {
+                    this.started = false;
+                    this.stopped = true;
+                    return false;
+                }
+                this.logEvent({ message: 'start result: success', device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'start result: error', error: err.message, device: this.getName(), interface: this.getInterface(), protocol: this.getProtocolName() });
+                this.started = false;
+                this.stopped = true;
+                return false;
+            }
+        });
+    }
+    startSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
+                yield this.waitForPeripheral();
+            }
+            if (!this.getComms()) {
+                return false;
+            }
+            const sensor = this.getComms();
+            const connected = yield sensor.startSensor();
+            yield sensor.subscribe();
+            if (connected) {
+                sensor.on('data', this.onDeviceDataHandler);
+                sensor.on('disconnected', this.emit.bind(this));
+                sensor.on('error', console.log);
+            }
+            return connected;
+        });
+    }
+    onDisconnectDone() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'disconnecting device', device: this.getName(), interface: this.getInterface() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
+            }
+            let reason = 'unknown';
+            let stopped = false;
+            const sensor = this.getComms();
+            try {
+                stopped = yield sensor.stopSensor();
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
-                (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
-                throw new Error(`could not start device, reason:${err.message}`);
+                reason = err.message;
+            }
+            if (!stopped) {
+                this.logEvent({ message: 'disconnecting device failed', device: this.getName(), interface: this.getInterface(), reason });
             }
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
-            this.device.reset();
-            this.device.off('data', this.onDeviceDataHandler);
-            const stopped = this.device.disconnect();
-            if (stopped) {
-                this.stopped = true;
-                this.started = false;
-                this.paused = false;
+            this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
+            }
+            this.started = false;
+            this.resetData();
+            if (!this.getComms()) {
+                this.logEvent({ message: 'device stopped - not started yet', device: this.getName(), interface: this.getInterface() });
                 return true;
             }
-            return false;
+            const sensor = this.getComms();
+            sensor.reset();
+            this.resetData();
+            this.stopped = true;
+            this.started = false;
+            this.logEvent({ message: 'device stopped', device: this.getName(), interface: this.getInterface() });
+            return this.stopped;
         });
     }
     pause() {
@@ -231,9 +373,9 @@ class BleAdapter extends adpater_1.default {
             pause: { get: () => super.pause }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const res = yield _super.pause.call(this);
-            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
+            const ble = this.getBle();
+            ble.pauseLogging();
             return res;
         });
     }
@@ -242,17 +384,24 @@ class BleAdapter extends adpater_1.default {
             resume: { get: () => super.resume }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            const ble = this.getBle();
+            ble.resumeLogging();
             const res = yield _super.resume.call(this);
-            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.resume();
             return res;
         });
     }
+    getBle() {
+        return interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+    }
     update() {
     }
     setCyclingMode(mode, settings, sendInitCommands) {
         super.setCyclingMode(mode, settings, sendInitCommands);
         this.refreshDeviceData();
     }
+    onScanStart() {
+        if (!this.isStarted())
+            this.start();
+    }
 }
 exports.default = BleAdapter;

package/lib/ble/base/comms.d.ts

@@ -1,75 +1,3 @@
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { LegacyProfile } from "../../antv2/types";
-import BleInterface from "../ble-interface";
-import BlePeripheralConnector from "../ble-peripheral";
-import { BleCharacteristic, BleCommsConnectProps, BleDeviceConstructProps, BleDeviceInfo, BleDeviceSettings, BlePeripheral, BleProtocol, BleWriteProps, ConnectState, IBlePeripheralConnector } from "../types";
-type CommandQueueItem = {
-    uuid: string;
-    data: Buffer;
-    timeout: number;
-    resolve: any;
-    reject: any;
-};
-export interface MessageLog {
-    uuid: string;
-    timestamp: any;
-    data: string;
+import { IBleSensor } from "../types";
+export declare class BleSensor implements IBleSensor {
 }
-export declare class BleComms extends EventEmitter {
-    static services: string[];
-    static protocol: BleProtocol;
-    id: string;
-    paused: boolean;
-    address: string;
-    name: string;
-    services: string[];
-    ble: BleInterface;
-    peripheral?: BlePeripheral;
-    characteristics: BleCharacteristic[];
-    state?: string;
-    logger?: EventLogger;
-    deviceInfo: BleDeviceInfo;
-    isInitialized: boolean;
-    subscribedCharacteristics: string[];
-    writeQueue: CommandQueueItem[];
-    workerIv: NodeJS.Timeout;
-    prevMessages: MessageLog[];
-    connectState: ConnectState;
-    constructor(props?: BleDeviceConstructProps);
-    getConnectState(): ConnectState;
-    isConnected(): boolean;
-    pause(): void;
-    resume(): void;
-    getServiceUUids(): string[];
-    getProfile(): LegacyProfile;
-    getProtocol(): BleProtocol;
-    getSettings(): BleDeviceSettings;
-    getServices(): string[];
-    logEvent(event: any): void;
-    setLogger(logger: EventLogger): void;
-    setInterface(ble: BleInterface): void;
-    static isMatching(characteristics: string[]): boolean;
-    reset(): void;
-    cleanupListeners(): void;
-    onDisconnect(): Promise<void>;
-    waitForConnectFinished(timeout: any): Promise<unknown>;
-    hasService(serviceUuid: any): boolean;
-    init(): Promise<boolean>;
-    initDevice(): Promise<boolean>;
-    connectPeripheral(peripheral: BlePeripheral): Promise<boolean>;
-    subscribeMultiple(characteristics: string[], conn?: IBlePeripheralConnector): Promise<void>;
-    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
-    unsubscribeAll(conn?: BlePeripheralConnector): void;
-    connect(props?: BleCommsConnectProps): Promise<boolean>;
-    disconnect(): Promise<boolean>;
-    checkForDuplicate(characteristic: string, data: Buffer): boolean;
-    onData(characteristic: string, _data: Buffer): boolean;
-    timeoutCheck(): void;
-    startWorker(): void;
-    stopWorker(): void;
-    write(characteristicUuid: string, data: Buffer, props?: BleWriteProps): Promise<ArrayBuffer>;
-    read(characteristicUuid: string): Promise<Uint8Array>;
-    getDeviceInfo(): Promise<BleDeviceInfo>;
-}
-export {};