incyclist-devices 2.3.0-beta.11 → 2.3.0-beta.12

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

@@ -42,7 +42,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     getBinding(): BleBinding;
     protected autoConnect(): void;
     connect(reconnect?: boolean): Promise<boolean>;
-    disconnect(cleanup?: boolean): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     registerConnected(peripheral: IBlePeripheral): void;
     protected isConnecting(): boolean;
@@ -59,6 +59,8 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected reconnect(): Promise<void>;
     protected startPeripheralScan(retry?: boolean): Promise<void>;
     protected stopPeripheralScan(): Promise<void>;
+    protected emitDisconnectAllPeripherals(): void;
+    protected disconnectAllPeripherals(): Promise<void>;
     protected isDiscovering(): boolean;
     protected discoverPeripherals(): Promise<void>;
     protected onPeripheralFound(peripheral: BleRawPeripheral): void;

package/lib/ble/base/interface.js

@@ -110,21 +110,24 @@ class BleInterface extends events_1.default {
             return success;
         });
     }
-    disconnect(cleanup) {
+    disconnect(connectionLost) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (!this.getBinding()) {
                 return false;
             }
-            if (!this.isConnected() && !cleanup)
+            if (!this.isConnected() && !connectionLost)
                 return true;
-            if (!cleanup)
+            if (!connectionLost)
                 this.logEvent({ message: 'disconnect request' });
             this.emit('disconnect-request');
             yield this.stopPeripheralScan();
-            const promises = this.connectedPeripherals.map(p => p.disconnect());
-            yield Promise.allSettled(promises);
-            this.connectedPeripherals = [];
+            if (connectionLost) {
+                this.emitDisconnectAllPeripherals();
+            }
+            else {
+                yield this.disconnectAllPeripherals();
+            }
             if (this.isConnecting())
                 yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
             this.getBinding().removeAllListeners();
@@ -274,6 +277,20 @@ class BleInterface extends events_1.default {
             });
         });
     }
+    emitDisconnectAllPeripherals() {
+        this.connectedPeripherals.forEach(p => {
+            const peripheral = p.getPeripheral();
+            peripheral.emit('disconnect');
+        });
+        this.connectedPeripherals = [];
+    }
+    disconnectAllPeripherals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = this.connectedPeripherals.map(p => p.disconnect());
+            yield Promise.allSettled(promises);
+            this.connectedPeripherals = [];
+        });
+    }
     isDiscovering() {
         var _a;
         return ((_a = this.discoverTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
@@ -369,11 +386,11 @@ class BleInterface extends events_1.default {
             try {
                 peripheral.on('error', (err) => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device error', error: err.message });
+                    this.logEvent({ message: 'peripheral error', error: err.message });
                 });
                 peripheral.on('disconnect', () => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device disconnected' });
+                    this.logEvent({ message: 'peripheral disconnected' });
                 });
                 yield peripheral.connectAsync();
                 if (peripheral.discoverServicesAsync !== undefined) {

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

@@ -11,14 +11,17 @@ export declare class BlePeripheral implements IBlePeripheral {
         callback: (data: Buffer) => void;
     }>;
     protected disconnecting: boolean;
+    protected onErrorHandler: any;
     constructor(announcement: BlePeripheralAnnouncement);
     get services(): BleService[];
-    protected getPeripheral(): BleRawPeripheral;
+    getPeripheral(): BleRawPeripheral;
     connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
+    protected onPeripheralDisconnect(): Promise<void>;
+    protected onPeripheralError(err: Error): void;
     discoverServices(): Promise<string[]>;
     discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
     subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
@@ -27,7 +30,7 @@ export declare class BlePeripheral implements IBlePeripheral {
     discoverAllCharacteristics(): Promise<string[]>;
     discoverSomeCharacteristics(characteristics: string[]): Promise<string[]>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
-    unsubscribeAll(): Promise<boolean>;
+    unsubscribeAll(connectionLost?: boolean): Promise<void>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     protected getRawCharacteristic(uuid: string): BleRawCharacteristic;

package/lib/ble/base/peripheral.js

@@ -19,6 +19,7 @@ class BlePeripheral {
         this.characteristics = {};
         this.subscribed = [];
         this.disconnecting = false;
+        this.onErrorHandler = this.onPeripheralError.bind(this);
         this.ble = interface_1.BleInterface.getInstance();
     }
     get services() {
@@ -31,28 +32,37 @@ class BlePeripheral {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isConnected())
                 return true;
-            yield this.getPeripheral().connectAsync();
+            const peripheral = this.getPeripheral();
+            yield peripheral.connectAsync();
             this.ble.registerConnected(this);
+            peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
+            peripheral.on('error', this.onErrorHandler);
             this.connected = true;
             return this.connected;
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.disconnecting = true;
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             Object.keys(this.characteristics).forEach(uuid => {
                 const c = this.characteristics[uuid];
                 c.removeAllListeners();
             });
-            if (!this.getPeripheral().disconnectAsync) {
-                this.getPeripheral().disconnectAsync = () => {
-                    return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
-                };
+            const peripheral = this.getPeripheral();
+            if (peripheral) {
+                if (!connectionLost) {
+                    if (!peripheral.disconnectAsync) {
+                        peripheral.disconnectAsync = () => {
+                            return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
+                        };
+                    }
+                    yield this.getPeripheral().disconnectAsync();
+                }
+                peripheral.removeAllListeners();
             }
-            yield this.getPeripheral().disconnectAsync();
             this.connected = false;
             this.disconnecting = false;
             return !this.connected;
@@ -67,6 +77,20 @@ class BlePeripheral {
     onDisconnect(callback) {
         this.onDisconnectHandler = callback;
     }
+    onPeripheralDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'disconnect' });
+            try {
+                yield this.disconnect(true);
+            }
+            catch (_a) { }
+            if (this.onDisconnectHandler)
+                this.onDisconnectHandler();
+        });
+    }
+    onPeripheralError(err) {
+        this.logEvent({ message: 'peripheral error', error: err.message });
+    }
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.getPeripheral().discoverServicesAsync) {
@@ -184,16 +208,16 @@ class BlePeripheral {
                     yield this.discoverAllCharacteristics();
                 }
                 const retry = [];
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = this.getRawCharacteristic(characteristics[i]);
+                for (const element of characteristics) {
+                    const c = this.getRawCharacteristic(element);
                     if (c === null || c === void 0 ? void 0 : c.properties.includes('notify')) {
                         const success = yield this.subscribe(c.uuid, callback);
                         if (!success)
                             retry.push(c);
                     }
                 }
-                for (let i = 0; i < retry.length; i++) {
-                    const c = retry[i];
+                for (const element of retry) {
+                    const c = element;
                     yield this.subscribe(c.uuid, callback);
                 }
                 return true;
@@ -247,13 +271,16 @@ class BlePeripheral {
         });
     }
     unsubscribeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
+            if (connectionLost) {
+                this.subscribed = [];
+                return;
+            }
             const promises = [];
             this.subscribed.forEach(d => {
                 promises.push(this.unsubscribe(d.uuid));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
@@ -305,6 +332,8 @@ class BlePeripheral {
         return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
     }
     logEvent(event) {
+        var _a;
+        event.peripheral = (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.name;
         this.ble.logEvent(event);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.3.0-beta.11",
+  "version": "2.3.0-beta.12",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",