incyclist-devices 2.3.8 → 2.3.10

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

@@ -27,13 +27,18 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected expectedServices: string[];
     protected matching: string[];
     protected connectTask: InteruptableTask<TaskState, boolean>;
+    protected disconnectTask: InteruptableTask<TaskState, boolean>;
     protected scanTask: InteruptableTask<TaskState, void>;
     protected discoverTask: InteruptableTask<TaskState, void>;
     protected onDiscovered: (peripheral: BleRawPeripheral) => void;
     protected instanceId: number;
-    protected connectedPeripherals: IBlePeripheral[];
-    protected connectAttemptCnt: number;
+    protected connectedPeripherals: {
+        id: string;
+        peripheral: IBlePeripheral;
+    }[];
     protected emitted: BlePeripheralAnnouncement[];
+    protected confirmedBleState: BleInterfaceState;
+    protected currentBleState: BleInterfaceState;
     static getInstance(props?: InterfaceProps): BleInterface;
     protected constructor(props: InterfaceProps);
     setProps(props: InterfaceProps): void;
@@ -46,8 +51,10 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     connect(reconnect?: boolean): Promise<boolean>;
     disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
-    registerConnected(peripheral: IBlePeripheral): void;
+    registerConnected(peripheral: IBlePeripheral, id: string): void;
+    unregisterConnected(id: string): void;
     protected isConnecting(): boolean;
+    protected isDisconnecting(): boolean;
     scan(props: BleScanProps): Promise<DeviceSettings[]>;
     stopScan(): Promise<boolean>;
     onScanDone(): DeviceSettings[];
@@ -90,9 +97,9 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected connectBle(): Promise<boolean>;
     protected waitForBleConnected(): Promise<boolean>;
     protected onError(err: Error): void;
-    protected onConnected(): void;
+    protected onConnected(): Promise<void>;
     protected onDisconnected(): Promise<void>;
-    protected onBleStateChange(state: BleInterfaceState): void;
+    protected onBleStateChange(state: BleInterfaceState): Promise<void>;
     protected getAdapterFactory(): BleAdapterFactory<TBleSensor>;
     protected getConnectTimeout(): number;
     protected getExpectedServices(): string[];

package/lib/ble/base/interface.js

@@ -50,7 +50,6 @@ class BleInterface extends events_1.default {
         this.expectedServices = ['180d', '1818', '1826', '6e40fec1'];
         this.matching = [];
         this.connectedPeripherals = [];
-        this.connectAttemptCnt = 0;
         this.emitted = [];
         this.instanceId = ++instanceCount;
         this.props = props;
@@ -111,49 +110,82 @@ class BleInterface extends events_1.default {
                 log: this.logEvent.bind(this),
             });
             const success = yield this.connectTask.run().catch(() => false);
-            if (success) {
-                this.startPeripheralScan();
-            }
             return success;
         });
     }
     disconnect(connectionLost) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!this.getBinding()) {
-                return false;
-            }
-            if (!this.isConnected() && !connectionLost)
+            if (!this.isConnected())
                 return true;
-            if (!connectionLost)
-                this.logEvent({ message: 'disconnect request' });
-            this.emit('disconnect-request');
-            yield this.stopPeripheralScan();
-            if (connectionLost) {
-                this.emitDisconnectAllPeripherals();
-            }
-            else {
-                yield this.disconnectAllPeripherals();
+            const performDisconnect = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!this.getBinding()) {
+                    this.confirmedBleState = 'poweredOff';
+                    return false;
+                }
+                this.getBinding().removeAllListeners('error');
+                if (!this.isConnected() && !connectionLost) {
+                    this.confirmedBleState = 'poweredOff';
+                    return true;
+                }
+                if (!connectionLost)
+                    this.logEvent({ message: 'disconnect request' });
+                this.emit('disconnect-request');
+                yield this.stopPeripheralScan();
+                if (connectionLost) {
+                    this.emitDisconnectAllPeripherals();
+                }
+                else {
+                    yield this.disconnectAllPeripherals();
+                }
+                if (this.isConnecting())
+                    yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
+                this.emit('disconnect-done');
+                this.getBinding().removeAllListeners('stateChange');
+                this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+                this.getBinding().on('error', this.onError.bind(this));
+                this.logEvent({ message: 'interface disconnected', interface: 'BLE' });
+                this.confirmedBleState = 'poweredOff';
+                return true;
+            });
+            if (this.isDisconnecting()) {
+                return this.disconnectTask.getPromise();
             }
-            if (this.isConnecting())
-                yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
-            this.getBinding().removeAllListeners();
-            this.connectAttemptCnt = 0;
-            this.emit('disconnect-done');
-            return true;
+            this.disconnectTask = new task_1.InteruptableTask(performDisconnect(), {
+                timeout: this.getConnectTimeout(),
+                name: 'BLE connect',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this),
+            });
+            const success = yield this.disconnectTask.run().catch(() => false);
+            return success;
         });
     }
     isConnected() {
-        var _a;
-        return this.connectAttemptCnt > 0 && ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
+        return this.confirmedBleState === 'poweredOn';
     }
-    registerConnected(peripheral) {
-        this.connectedPeripherals.push(peripheral);
+    registerConnected(peripheral, id) {
+        const p = this.connectedPeripherals.find(p => p.id === id);
+        if (p) {
+            p.peripheral = peripheral;
+        }
+        else
+            this.connectedPeripherals.push({ peripheral, id });
+    }
+    unregisterConnected(id) {
+        const p = this.connectedPeripherals.find(p => p.id === id);
+        if (p) {
+            this.connectedPeripherals.splice(this.connectedPeripherals.indexOf(p), 1);
+        }
     }
     isConnecting() {
         var _a;
         return ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
     }
+    isDisconnecting() {
+        var _a;
+        return ((_a = this.disconnectTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
+    }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.resumeLogging();
@@ -261,12 +293,12 @@ class BleInterface extends events_1.default {
     }
     startPeripheralScan() {
         return __awaiter(this, arguments, void 0, function* (retry = false) {
-            this.expectedServices = this.getExpectedServices();
-            if (!retry)
-                this.logEvent({ message: 'starting peripheral discovery ...' });
             if (!this.isConnected() || this.isDiscovering()) {
                 return;
             }
+            this.expectedServices = this.getExpectedServices();
+            if (!retry)
+                this.logEvent({ message: 'starting peripheral discovery ...' });
             this.discoverTask = new task_1.InteruptableTask(this.discoverPeripherals(), {
                 errorOnTimeout: false,
                 name: 'discover',
@@ -298,14 +330,14 @@ class BleInterface extends events_1.default {
     }
     emitDisconnectAllPeripherals() {
         this.connectedPeripherals.forEach(p => {
-            const peripheral = p.getPeripheral();
+            const peripheral = p.peripheral.getPeripheral();
             peripheral.emit('disconnect');
         });
         this.connectedPeripherals = [];
     }
     disconnectAllPeripherals() {
         return __awaiter(this, void 0, void 0, function* () {
-            const promises = this.connectedPeripherals.map(p => p.disconnect());
+            const promises = this.connectedPeripherals.map(p => p.peripheral.disconnect());
             yield Promise.allSettled(promises);
             this.connectedPeripherals = [];
         });
@@ -406,11 +438,11 @@ class BleInterface extends events_1.default {
             try {
                 peripheral.on('error', (err) => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'peripheral error', error: err.message });
+                    this.logEvent({ message: 'discover services: peripheral error', error: err.message });
                 });
                 peripheral.on('disconnect', () => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'peripheral disconnected' });
+                    this.logEvent({ message: 'discover services: peripheral disconnected' });
                 });
                 yield peripheral.connectAsync();
                 if (peripheral.discoverServicesAsync !== undefined) {
@@ -545,10 +577,9 @@ class BleInterface extends events_1.default {
     }
     connectBle() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.connectAttemptCnt++;
-            const state = this.getBinding().state;
-            if (state === 'poweredOn') {
-                this.logEvent({ message: 'BLE connected' });
+            this.currentBleState = this.getBinding().state;
+            if (this.currentBleState === 'poweredOn') {
+                this.onConnected();
                 return true;
             }
             const res = yield this.waitForBleConnected();
@@ -562,13 +593,13 @@ class BleInterface extends events_1.default {
                 return done(false);
             });
             this.getBinding().on('stateChange', (state) => {
+                if (state === this.confirmedBleState)
+                    return;
+                this.logEvent({ message: 'BLE state change', state });
                 if (state === 'poweredOn') {
                     this.onConnected();
                     return done(true);
                 }
-                else {
-                    this.logEvent({ message: 'BLE state change', state });
-                }
             });
         });
     }
@@ -576,26 +607,41 @@ class BleInterface extends events_1.default {
         this.logError(err, 'BLE connect');
     }
     onConnected() {
-        this.logEvent({ message: 'BLE connected' });
-        this.getBinding().removeAllListeners('error');
-        this.getBinding().removeAllListeners('stateChange');
-        this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
-        this.getBinding().on('error', this.onError.bind(this));
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return;
+            this.confirmedBleState = 'poweredOn';
+            this.getBinding().removeAllListeners('error');
+            this.getBinding().removeAllListeners('stateChange');
+            this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+            this.getBinding().on('error', this.onError.bind(this));
+            this.logEvent({ message: 'BLE connected' });
+            this.startPeripheralScan();
+        });
     }
     onDisconnected() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isDisconnecting() || !this.isConnected())
+                return;
             this.logEvent({ message: 'BLE Disconnected' });
             yield this.disconnect(true);
-            this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
-            this.getBinding().on('error', this.onError.bind(this));
         });
     }
     onBleStateChange(state) {
-        if (state !== 'poweredOn') {
-            this.onDisconnected();
-        }
-        else
-            this.onConnected();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (state === this.currentBleState)
+                return;
+            this.currentBleState = state;
+            if (state === 'poweredOff') {
+                this.onDisconnected();
+            }
+            else {
+                if (this.isDisconnecting()) {
+                    yield this.disconnectTask.getPromise();
+                }
+                this.onConnected();
+            }
+        });
     }
     getAdapterFactory() {
         return factories_1.BleAdapterFactory.getInstance('ble');

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

@@ -3,6 +3,7 @@ import { BleInterface } from "./interface";
 export declare class BlePeripheral implements IBlePeripheral {
     protected announcement: BlePeripheralAnnouncement;
     protected connected: boolean;
+    protected connectPromise: Promise<void>;
     protected characteristics: Record<string, BleRawCharacteristic>;
     protected onDisconnectHandler?: () => void;
     protected ble: BleInterface;
@@ -11,6 +12,7 @@ export declare class BlePeripheral implements IBlePeripheral {
         callback: (data: Buffer) => void;
     }>;
     protected disconnecting: boolean;
+    protected disconnectedSignalled: boolean;
     protected onErrorHandler: any;
     constructor(announcement: BlePeripheralAnnouncement);
     get services(): BleService[];
@@ -33,6 +35,7 @@ export declare class BlePeripheral implements IBlePeripheral {
     unsubscribeAll(connectionLost?: boolean): Promise<void>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
-    protected getRawCharacteristic(uuid: string): BleRawCharacteristic;
+    protected queryRawCharacteristic(uuid: string): Promise<BleRawCharacteristic>;
+    protected getRawCharacteristic(uuid: string, query?: boolean): BleRawCharacteristic;
     logEvent(event: any): void;
 }

package/lib/ble/base/peripheral.js

@@ -19,6 +19,7 @@ class BlePeripheral {
         this.characteristics = {};
         this.subscribed = [];
         this.disconnecting = false;
+        this.disconnectedSignalled = false;
         this.onErrorHandler = this.onPeripheralError.bind(this);
         this.ble = interface_1.BleInterface.getInstance();
     }
@@ -32,28 +33,42 @@ class BlePeripheral {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isConnected())
                 return true;
-            const peripheral = this.getPeripheral();
-            yield peripheral.connectAsync();
-            this.ble.registerConnected(this);
-            peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
-            peripheral.on('error', this.onErrorHandler);
-            this.connected = true;
+            if (this.connectPromise !== undefined) {
+                return this.connectPromise.then(() => this.connected);
+            }
+            this.connectPromise = new Promise((done) => {
+                const peripheral = this.getPeripheral();
+                this.logEvent({ message: 'connect peripheral', address: peripheral.address });
+                peripheral.connectAsync().then(() => {
+                    this.ble.registerConnected(this, peripheral.id);
+                    peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
+                    peripheral.on('error', this.onErrorHandler);
+                    this.connected = true;
+                    done();
+                });
+            });
+            yield this.connectPromise;
+            delete this.connectPromise;
             return this.connected;
         });
     }
     disconnect() {
         return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.disconnecting = true;
-            if (!this.isConnected())
+            if (!this.isConnected()) {
                 return true;
+            }
             yield this.unsubscribeAll(connectionLost);
             Object.keys(this.characteristics).forEach(uuid => {
                 const c = this.characteristics[uuid];
                 c.removeAllListeners();
             });
+            this.characteristics = {};
+            this.subscribed = [];
             const peripheral = this.getPeripheral();
             if (peripheral) {
                 if (!connectionLost) {
+                    this.logEvent({ message: 'disconnect peripheral', address: peripheral.address });
                     if (!peripheral.disconnectAsync) {
                         peripheral.disconnectAsync = () => {
                             return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
@@ -63,6 +78,7 @@ class BlePeripheral {
                 }
                 peripheral.removeAllListeners();
             }
+            this.ble.unregisterConnected(peripheral.id);
             this.connected = false;
             this.disconnecting = false;
             return !this.connected;
@@ -79,27 +95,35 @@ class BlePeripheral {
     }
     onPeripheralDisconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'peripheral disconnected' });
+            var _a;
+            if (this.disconnectedSignalled || this.disconnecting)
+                return;
+            this.disconnectedSignalled = true;
+            this.logEvent({ message: 'peripheral disconnected', address: (_a = this.getPeripheral()) === null || _a === void 0 ? void 0 : _a.address });
             try {
                 yield this.disconnect(true);
+                this.disconnectedSignalled = false;
             }
-            catch (_a) { }
+            catch (_b) { }
             if (this.onDisconnectHandler)
                 this.onDisconnectHandler();
         });
     }
     onPeripheralError(err) {
-        this.logEvent({ message: 'peripheral error', error: err.message });
+        var _a;
+        this.logEvent({ message: 'peripheral error', address: (_a = this.getPeripheral()) === null || _a === void 0 ? void 0 : _a.address, error: err.message });
     }
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getPeripheral())
+                return [];
             if (this.getPeripheral().discoverServicesAsync) {
-                this.logEvent({ message: 'discover services' });
+                this.logEvent({ message: 'discover services', address: this.getPeripheral().address });
                 const services = yield this.getPeripheral().discoverServicesAsync([]);
                 return services.map(s => s.uuid);
             }
             else {
-                this.logEvent({ message: 'discover services and characteristics' });
+                this.logEvent({ message: 'discover services and characteristics', address: this.getPeripheral().address });
                 const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
                 return res.services.map(s => s.uuid);
             }
@@ -107,6 +131,9 @@ class BlePeripheral {
     }
     discoverCharacteristics(serviceUUID) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getPeripheral())
+                return [];
+            this.logEvent({ message: 'discover services and characteristics', service: serviceUUID, address: this.getPeripheral().address });
             const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([serviceUUID], []);
             res.characteristics.forEach(c => this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c);
             return res.characteristics.map(c => {
@@ -120,20 +147,23 @@ class BlePeripheral {
             try {
                 if (this.disconnecting || !this.connected)
                     return false;
+                const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
                 const onData = (data) => {
                     try {
                         callback(characteristicUUID, data);
                     }
                     catch (_a) { }
                 };
-                const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
+                const subscription = this.subscribed.find(s => s.uuid === uuid);
                 if (subscription) {
                     const c = this.getRawCharacteristic(characteristicUUID);
-                    if (c)
+                    if (c) {
+                        c.off('data', onData);
                         c.on('data', onData);
+                    }
                     return true;
                 }
-                const c = this.getRawCharacteristic(characteristicUUID);
+                let c = yield this.queryRawCharacteristic(characteristicUUID);
                 if (!c) {
                     return false;
                 }
@@ -142,22 +172,22 @@ class BlePeripheral {
                     if (info) {
                         return Promise.resolve(true);
                     }
-                    const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
-                    this.logEvent({ message: 'subscribe request', characteristic: uuid, success: true });
+                    this.logEvent({ message: 'subscribe request', address: this.getPeripheral().address, characteristic: uuid, success: true });
                     c.subscribe((err) => {
                         if (err) {
-                            this.logEvent({ message: 'subscribe result', characteristic: uuid, success: false, reason: err.message });
+                            this.logEvent({ message: 'subscribe result', address: this.getPeripheral().address, characteristic: uuid, success: false, reason: err.message });
                             resolve(false);
                         }
                         else {
                             if (callback) {
-                                this.subscribed.push({ uuid: characteristicUUID, callback: onData });
+                                this.subscribed.push({ uuid, callback: onData });
+                                c.off('data', onData);
                                 c.on('data', onData);
                             }
                             else {
-                                this.subscribed.push({ uuid: characteristicUUID, callback: null });
+                                this.subscribed.push({ uuid, callback: null });
                             }
-                            this.logEvent({ message: 'subscribe result', characteristic: uuid, success: true });
+                            this.logEvent({ message: 'subscribe result', address: this.getPeripheral().address, characteristic: uuid, success: true });
                             resolve(true);
                         }
                     });
@@ -171,7 +201,8 @@ class BlePeripheral {
     }
     unsubscribe(characteristicUUID) {
         try {
-            const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
+            const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
+            const subscription = this.subscribed.find(s => s.uuid === uuid);
             if (!subscription) {
                 return Promise.resolve(true);
             }
@@ -185,7 +216,7 @@ class BlePeripheral {
                         resolve(false);
                     }
                     else {
-                        const info = this.subscribed.find(s => s.uuid === characteristicUUID);
+                        const info = this.subscribed.find(s => s.uuid === uuid);
                         if (info) {
                             this.subscribed.splice(this.subscribed.indexOf(info), 1);
                             if (info.callback)
@@ -328,7 +359,24 @@ class BlePeripheral {
             });
         });
     }
-    getRawCharacteristic(uuid) {
+    queryRawCharacteristic(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const characteristicUUID = (0, utils_1.beautifyUUID)(uuid);
+            let c = this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
+            if (c)
+                return c;
+            const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], [characteristicUUID]);
+            if (res.characteristics.length === 0) {
+                return;
+            }
+            c = res.characteristics.find(dc => (0, utils_1.beautifyUUID)(dc.uuid) === (0, utils_1.beautifyUUID)(characteristicUUID));
+            if (c) {
+                this.characteristics[characteristicUUID] = c;
+            }
+            return c;
+        });
+    }
+    getRawCharacteristic(uuid, query = false) {
         return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
     }
     logEvent(event) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.3.8",
+  "version": "2.3.10",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",