incyclist-devices 2.3.8 → 2.3.9

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

@@ -31,7 +31,10 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected discoverTask: InteruptableTask<TaskState, void>;
     protected onDiscovered: (peripheral: BleRawPeripheral) => void;
     protected instanceId: number;
-    protected connectedPeripherals: IBlePeripheral[];
+    protected connectedPeripherals: {
+        id: string;
+        peripheral: IBlePeripheral;
+    }[];
     protected connectAttemptCnt: number;
     protected emitted: BlePeripheralAnnouncement[];
     static getInstance(props?: InterfaceProps): BleInterface;
@@ -46,7 +49,8 @@ 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;
     scan(props: BleScanProps): Promise<DeviceSettings[]>;
     stopScan(): Promise<boolean>;

package/lib/ble/base/interface.js

@@ -147,8 +147,19 @@ class BleInterface extends events_1.default {
         var _a;
         return this.connectAttemptCnt > 0 && ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === '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;
@@ -298,14 +309,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 +417,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) {

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.9",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",