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

package/lib/direct-connect/base/interface.js

@@ -108,10 +108,10 @@ class DirectConnectInterface extends events_1.default {
                 if (!reconnect)
                     this.logEvent({ message: 'starting multicast DNS scan ..' });
                 this.getBinding().mdns.find(null, (service) => {
-                    this.addService(service);
+                    this.addService(service, 'unfiltered');
                 });
                 this.getBinding().mdns.find({ type: DC_TYPE }, (service) => {
-                    this.addService(service);
+                    this.addService(service, DC_TYPE);
                 });
             }
             catch (err) {
@@ -228,7 +228,7 @@ class DirectConnectInterface extends events_1.default {
     buildDeviceSettings(matching = []) {
         return matching.map((name) => ({ interface: DirectConnectInterface.INTERFACE_NAME, name }));
     }
-    addService(service) {
+    addService(service, source) {
         var _a, _b;
         try {
             service.transport = this.getName();
@@ -238,9 +238,9 @@ class DirectConnectInterface extends events_1.default {
                 this.services[idx] = { ts: Date.now(), service };
             }
             else {
-                this.logEvent({ message: 'device announced', device: service.name, announcement: service });
+                this.logEvent({ message: 'device announced', device: service.name, announcement: service, source });
                 this.services.push({ ts: Date.now(), service });
-                if (service.type !== DC_TYPE && ((_a = service.serviceUUIDs) === null || _a === void 0 ? void 0 : _a.length) === 0)
+                if (!((_a = service.serviceUUIDs) === null || _a === void 0 ? void 0 : _a.length))
                     return;
                 this.emitDevice(service);
                 (_b = this.matching) === null || _b === void 0 ? void 0 : _b.push(service.name);

package/lib/direct-connect/base/peripheral.d.ts

@@ -21,24 +21,24 @@ export declare class DirectConnectPeripheral implements IBlePeripheral {
     constructor(announcement: MulticastDnsAnnouncement);
     get services(): BleService[];
     connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
     discoverServices(): Promise<string[]>;
     discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
-    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    subscribe(characteristicUUID: string, callback?: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     unsubscribe(characteristicUUID: string): Promise<boolean>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     subscribeSelected(characteristics: string[], 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 startConnection(): Promise<boolean>;
     protected onPortError(err: Error): void;
     protected onPortClose(): Promise<void>;
     protected getPath(): string;
-    protected stopConnection(): Promise<boolean>;
+    protected stopConnection(connectionLost?: boolean): Promise<boolean>;
     protected getNextSeqNo(): number;
     protected send(seqNo: number, data: Buffer): Promise<Buffer>;
     protected getNextMessage(data: Buffer): Buffer;

package/lib/direct-connect/base/peripheral.js

@@ -55,10 +55,10 @@ class DirectConnectPeripheral {
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             try {
                 yield this.connectTask.stop();
-                yield this.stopConnection();
+                yield this.stopConnection(connectionLost);
                 delete this.socket;
             }
             catch (err) {
@@ -79,68 +79,126 @@ class DirectConnectPeripheral {
     }
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const seqNo = this.getNextSeqNo();
             const message = new messages_1.DiscoverServiceMessage();
             const request = message.createRequest(seqNo, {});
+            let response;
             this.logEvent({ message: 'DiscoverServices request', path: this.getPath(), raw: request.toString('hex') });
-            const response = yield this.send(seqNo, request);
-            const res = message.parseResponse(response);
-            const uuids = res.body.serviceDefinitions.map(s => (0, utils_1.beautifyUUID)(s.serviceUUID));
-            this.logEvent({ message: 'DiscoverServices response', path: this.getPath(), uuids, raw: request.toString('hex') });
-            return res.body.serviceDefinitions.map(s => s.serviceUUID);
+            try {
+                response = yield this.send(seqNo, request);
+                const res = message.parseResponse(response);
+                const uuids = res.body.serviceDefinitions.map(s => (0, utils_1.beautifyUUID)(s.serviceUUID));
+                const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                    this.logEvent({ message: 'DiscoverServices failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                    return [];
+                }
+                this.logEvent({ message: 'DiscoverServices response', path: this.getPath(), rc, uuids, raw: response.toString('hex') });
+                return res.body.serviceDefinitions.map(s => s.serviceUUID);
+            }
+            catch (err) {
+                this.logEvent({ message: 'DiscoverServices failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                return [];
+            }
         });
     }
     discoverCharacteristics(serviceUUID) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const seqNo = this.getNextSeqNo();
             const message = new messages_1.DiscoverCharacteristicsMessage();
             const request = message.createRequest(seqNo, { serviceUUID: (0, utils_1.parseUUID)(serviceUUID) });
+            let response;
             this.logEvent({ message: 'DiscoverCharacteritics request', path: this.getPath(), service: (0, utils_1.beautifyUUID)(serviceUUID), raw: request.toString('hex') });
-            const response = yield this.send(seqNo, request);
-            const res = message.parseResponse(response);
-            const service = (0, utils_1.beautifyUUID)(res.body.serviceUUID);
-            const characteristics = res.body.characteristicDefinitions.map(cd => `${(0, utils_1.beautifyUUID)(cd.characteristicUUID)}:${cd.properties.join('/')}`);
-            this.logEvent({ message: 'DiscoverCharacteritics response', path: this.getPath(), service, characteristics, raw: request.toString('hex') });
-            return res.body.characteristicDefinitions.map(c => ({ uuid: c.characteristicUUID, properties: c.properties }));
+            try {
+                response = yield this.send(seqNo, request);
+                const res = message.parseResponse(response);
+                const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                    this.logEvent({ message: 'DiscoverCharacteritics failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                    return [];
+                }
+                const service = (0, utils_1.beautifyUUID)(res.body.serviceUUID);
+                const characteristics = res.body.characteristicDefinitions.map(cd => `${(0, utils_1.beautifyUUID)(cd.characteristicUUID)}:${cd.properties.join('/')}`);
+                this.logEvent({ message: 'DiscoverCharacteritics response', path: this.getPath(), rc, service, characteristics, raw: response.toString('hex') });
+                return res.body.characteristicDefinitions.map(c => ({ uuid: c.characteristicUUID, properties: c.properties }));
+            }
+            catch (err) {
+                this.logEvent({ message: 'DiscoverCharacteritics failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                return [];
+            }
         });
     }
     subscribe(characteristicUUID, callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const uuid = (0, utils_1.parseUUID)(characteristicUUID);
+            if (this.subscribed.includes(uuid)) {
+                return true;
+            }
             const seqNo = this.getNextSeqNo();
             const message = new messages_1.EnableCharacteristicNotificationsMessage();
             const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), enable: true });
+            let response;
             this.logEvent({ message: 'EnableCharacteristicNotifications request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), enabled: true, raw: request.toString('hex') });
-            const response = yield this.send(seqNo, request);
-            const res = message.parseResponse(response);
-            this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: request.toString('hex') });
-            const confirmed = res.body.characteristicUUID;
-            if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
-                this.subscribed.push(characteristicUUID);
-                this.eventEmitter.on((0, utils_1.parseUUID)(characteristicUUID), (data) => {
-                    callback(characteristicUUID, data);
-                });
-                return true;
+            try {
+                response = yield this.send(seqNo, request);
+                const res = message.parseResponse(response);
+                const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                    this.logEvent({ message: 'EnableCharacteristicNotifications failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                    return false;
+                }
+                this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), rc, characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: response.toString('hex') });
+                const confirmed = res.body.characteristicUUID;
+                if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
+                    this.subscribed.push((0, utils_1.parseUUID)(characteristicUUID));
+                    if (callback) {
+                        this.eventEmitter.on((0, utils_1.parseUUID)(characteristicUUID), (data) => {
+                            callback(characteristicUUID, data);
+                        });
+                    }
+                    return true;
+                }
+                return false;
+            }
+            catch (err) {
+                this.logEvent({ message: 'EnableCharacteristicNotifications failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                return false;
             }
-            return false;
         });
     }
     unsubscribe(characteristicUUID) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             try {
                 const seqNo = this.getNextSeqNo();
                 const message = new messages_1.EnableCharacteristicNotificationsMessage();
                 const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), enable: false });
-                this.logEvent({ message: 'EnableCharacteristicNotifications request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), enabled: false, raw: request.toString('hex') });
-                const response = yield this.send(seqNo, request);
-                const res = message.parseResponse(response);
-                this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: request.toString('hex') });
-                const confirmed = res.body.characteristicUUID;
-                if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
-                    this.subscribed.splice(this.subscribed.indexOf(characteristicUUID), 1);
-                    this.eventEmitter.removeAllListeners((0, utils_1.parseUUID)(characteristicUUID));
-                    return true;
+                let response;
+                try {
+                    this.logEvent({ message: 'EnableCharacteristicNotifications request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), enabled: false, raw: request.toString('hex') });
+                    response = yield this.send(seqNo, request);
+                    const res = message.parseResponse(response);
+                    const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                    if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                        this.logEvent({ message: 'EnableCharacteristicNotifications failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                        return false;
+                    }
+                    this.logEvent({ message: 'EnableCharacteristicNotifications response', path: this.getPath(), rc, characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID), raw: response.toString('hex') });
+                    const confirmed = res.body.characteristicUUID;
+                    if ((0, utils_1.parseUUID)(confirmed) === (0, utils_1.parseUUID)(characteristicUUID)) {
+                        this.subscribed.splice(this.subscribed.indexOf((0, utils_1.parseUUID)(characteristicUUID)), 1);
+                        this.eventEmitter.removeAllListeners((0, utils_1.parseUUID)(characteristicUUID));
+                        return true;
+                    }
+                    return false;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'EnableCharacteristicNotifications failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                    return false;
                 }
-                return false;
             }
             catch (err) {
                 this.logEvent({ messsage: 'EnableCharacteristicNotifications failed', reason: err.message });
@@ -158,9 +216,8 @@ class DirectConnectPeripheral {
                 catch (err) {
                     this.logEvent({ message: 'could not discover services', reason: err.message });
                 }
-                const res = [];
-                for (let i = 0; i < services.length; i++) {
-                    const service = services[i];
+                for (const element of services) {
+                    const service = element;
                     let characteristics = [];
                     try {
                         characteristics = yield this.discoverCharacteristics(service);
@@ -171,8 +228,8 @@ class DirectConnectPeripheral {
                     }
                     if (!(characteristics === null || characteristics === void 0 ? void 0 : characteristics.length))
                         continue;
-                    for (let j = 0; j < characteristics.length; j++) {
-                        const characteristic = characteristics[j];
+                    for (const element of characteristics) {
+                        const characteristic = element;
                         if (characteristic.properties.includes('notify'))
                             yield this.subscribe(characteristic.uuid, callback);
                     }
@@ -187,69 +244,124 @@ class DirectConnectPeripheral {
     }
     subscribeSelected(characteristics, callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            let services = [];
+            let supported = [];
+            try {
+                services = yield this.discoverServices();
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not discover services', reason: err.message });
+            }
+            for (const element of services) {
+                const service = element;
+                try {
+                    const c = yield this.discoverCharacteristics(service);
+                    supported = supported.concat(c);
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not discover characteristics', service, reason: err.message });
+                    return false;
+                }
+            }
             const retry = [];
-            for (let i = 0; i < characteristics.length; i++) {
-                const uuid = characteristics[i];
-                const success = yield this.subscribe(uuid, callback);
-                if (!success)
-                    retry.push(uuid);
+            this.logEvent({ message: 'characteristics supported', requested: characteristics.map(c => (0, utils_1.beautifyUUID)(c)), supported: supported.map(c => (0, utils_1.beautifyUUID)(c.uuid)) });
+            for (const element of characteristics) {
+                const uuid = element;
+                const found = supported.find(c => (0, utils_1.beautifyUUID)(c.uuid) === (0, utils_1.beautifyUUID)(uuid));
+                if (!found) {
+                    this.logEvent({ message: 'characteristic not supported', requested: (0, utils_1.beautifyUUID)(uuid) });
+                }
+                else {
+                    const success = yield this.subscribe(uuid, callback);
+                    if (!success)
+                        retry.push(uuid);
+                }
             }
-            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;
         });
     }
     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(characteristicUUID => {
-                promises.push(this.unsubscribe(characteristicUUID));
+                promises.push(this.unsubscribe((0, utils_1.parseUUID)(characteristicUUID)));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const seqNo = this.getNextSeqNo();
             const message = new messages_1.ReadCharacteristicMessage();
             const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID) });
-            this.logEvent({ message: 'ReadCharacteristic request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), raw: request.toString('hex') });
-            const response = yield this.send(seqNo, request);
-            const res = message.parseResponse(response);
-            this.logEvent({ message: 'ReadCharacteristic response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID),
-                data: Buffer.from(res.body.characteristicData).toString('hex'),
-                raw: request.toString('hex') });
-            return Buffer.from(res.body.characteristicData);
+            let response;
+            try {
+                this.logEvent({ message: 'ReadCharacteristic request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), raw: request.toString('hex') });
+                response = yield this.send(seqNo, request);
+                const res = message.parseResponse(response);
+                const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                    this.logEvent({ message: 'ReadCharacteristic failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                    return Buffer.from([]);
+                }
+                this.logEvent({ message: 'ReadCharacteristic response', path: this.getPath(), rc, characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID),
+                    data: Buffer.from(res.body.characteristicData).toString('hex'),
+                    raw: response.toString('hex') });
+                return Buffer.from(res.body.characteristicData);
+            }
+            catch (err) {
+                this.logEvent({ message: 'ReadCharacteristic failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                return Buffer.from([]);
+            }
         });
     }
     write(characteristicUUID, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise(resolve => {
+                const seqNo = this.getNextSeqNo();
+                const message = new messages_1.WriteCharacteristicMessage();
+                const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), characteristicData: data });
+                let response;
+                let characteristic = characteristicUUID;
                 if (!(options === null || options === void 0 ? void 0 : options.withoutResponse)) {
+                    this.subscribe(characteristicUUID);
                     const uuid = (0, utils_1.parseUUID)(characteristicUUID);
                     this.eventEmitter.once(uuid, (data) => {
                         resolve(data);
                     });
                 }
-                const seqNo = this.getNextSeqNo();
-                const message = new messages_1.WriteCharacteristicMessage();
-                const request = message.createRequest(seqNo, { characteristicUUID: (0, utils_1.parseUUID)(characteristicUUID), characteristicData: data });
                 this.logEvent({ message: 'WriteCharacteristic request', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID),
                     data: data.toString('hex'),
                     raw: request.toString('hex') });
-                this.send(seqNo, request).then((response) => {
+                this.send(seqNo, request).then((data) => {
+                    var _a, _b;
+                    response = data;
                     const res = message.parseResponse(response);
-                    this.logEvent({ message: 'WriteCharacteristic response', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(res.body.characteristicUUID),
-                        raw: request.toString('hex') });
+                    const rc = (0, messages_1.RC)((_a = res === null || res === void 0 ? void 0 : res.header) === null || _a === void 0 ? void 0 : _a.respCode);
+                    if (((_b = res === null || res === void 0 ? void 0 : res.header) === null || _b === void 0 ? void 0 : _b.respCode) !== consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY) {
+                        this.logEvent({ message: 'WriteCharacteristic failed', path: this.getPath(), raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: rc });
+                        resolve(Buffer.from([]));
+                        return;
+                    }
+                    characteristic = (0, utils_1.beautifyUUID)(res.body.characteristicUUID);
+                    this.logEvent({ message: 'WriteCharacteristic response', path: this.getPath(), rc, characteristic,
+                        raw: response.toString('hex') });
                     if (options === null || options === void 0 ? void 0 : options.withoutResponse) {
                         resolve(Buffer.from([]));
                     }
                 })
                     .catch(err => {
-                    this.logEvent({ message: 'WriteCharacteristic error', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(characteristicUUID), error: err.message });
+                    this.logEvent({ message: 'WriteCharacteristic failed', path: this.getPath(), characteristic, raw: response === null || response === void 0 ? void 0 : response.toString('hex'), reason: err.message });
+                    resolve(Buffer.from([]));
                 });
             });
         });
@@ -288,9 +400,10 @@ class DirectConnectPeripheral {
     onPortClose() {
         return __awaiter(this, void 0, void 0, function* () {
             this.socket.removeAllListeners();
+            this.socket.on('error', () => { });
             this.logEvent({ message: 'port closed', path: this.getPath() });
             try {
-                yield this.disconnect();
+                yield this.disconnect(true);
             }
             catch (_a) { }
             if (this.onDisconnectHandler)
@@ -303,11 +416,11 @@ class DirectConnectPeripheral {
         return path;
     }
     stopConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.eventEmitter.removeAllListeners();
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             this.socket.removeAllListeners();
             return new Promise(done => {
                 const onClosed = () => {
@@ -362,7 +475,7 @@ class DirectConnectPeripheral {
         }
         if (incoming.length > header.length + 6) {
             this.remainingBuffer = Buffer.from(incoming.subarray(header.length + 6));
-            incoming = incoming.subarray(0, header.length + 6);
+            incoming = Buffer.from(incoming.subarray(0, header.length + 6));
         }
         return incoming;
     }
@@ -386,7 +499,7 @@ class DirectConnectPeripheral {
                     this.msgSeqNo = notification.header.seqNum;
                     const uuid = (0, utils_1.parseUUID)(notification.body.characteristicUUID);
                     this.logEvent({ message: 'Characteristic notification', path: this.getPath(), characteristic: (0, utils_1.beautifyUUID)(notification.body.characteristicUUID),
-                        data: Buffer.from(notification.body.characteristicData).toString('hex') });
+                        data: Buffer.from(notification.body.characteristicData).toString('hex'), raw: incoming.toString('hex') });
                     this.eventEmitter.emit(uuid, notification.body.characteristicData);
                 }
                 else {

package/lib/direct-connect/messages/message.d.ts

@@ -18,3 +18,4 @@ export declare class Message<TReq extends TDCBody, TRes extends TDCBody> {
     parseResponseBody(body: Buffer): TRes;
 }
 export declare const parseHeader: (buffer: Buffer) => TDCMessageHeader;
+export declare const RC: (code: any) => string;

package/lib/direct-connect/messages/message.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseHeader = exports.Message = void 0;
+exports.RC = exports.parseHeader = exports.Message = void 0;
 const consts_1 = require("../consts");
 const error_1 = require("./error");
 class Message {
@@ -88,3 +88,18 @@ const parseHeader = (buffer) => {
     return { msgVersion, msgId, seqNum, respCode, length };
 };
 exports.parseHeader = parseHeader;
+const RC = (code) => {
+    switch (code) {
+        case consts_1.DC_RC_REQUEST_COMPLETED_SUCCESSFULLY: return 'success';
+        case consts_1.DC_RC_UNKNOWN_MESSAGE_TYPE: return 'Unknown Message Type';
+        case consts_1.DC_RC_UNEXPECTED_ERROR: return 'Unexpected Error';
+        case consts_1.DC_RC_SERVICE_NOT_FOUND: return 'Service Not Found';
+        case consts_1.DC_RC_CHARACTERISTIC_NOT_FOUND: return 'Characteristic Not Found';
+        case consts_1.DC_RC_CHARACTERISTIC_OPERATION_NOT_SUPPORTED: return 'Characteristic Operation Not Supported';
+        case consts_1.DC_RC_CHARACTERISTIC_WRITE_FAILED_INVALID_SIZE: return 'Characteristic Write Failed';
+        case consts_1.DC_RC_UNKNOWN_PROTOCOL_VERSION: return 'Unknown Protocol Version';
+        default:
+            return `Unknown (${code})`;
+    }
+};
+exports.RC = RC;

package/lib/modes/ant-fe-adv-st-mode.d.ts

@@ -3,8 +3,8 @@ import SmartTrainerCyclingMode from "./antble-smarttrainer";
 import { UpdateRequest } from "./types";
 export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {
     constructor(adapter: IncyclistDeviceAdapter, props?: any);
-    getName(): string;
     getDescription(): string;
+    getConfig(): import("./types").CyclingModeConfig;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkForTempPowerAdjustments(request: UpdateRequest, newRequest?: UpdateRequest): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;

package/lib/modes/ant-fe-adv-st-mode.js

@@ -10,12 +10,14 @@ class AntAdvSimCyclingMode extends antble_smarttrainer_1.default {
         super(adapter, props);
         this.initLogger('AdvmartTrainerMode');
     }
-    getName() {
-        return 'Advanced Smart Trainer';
-    }
     getDescription() {
         return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
     }
+    getConfig() {
+        const config = super.getConfig();
+        config.name = 'Advanced Smart Trainer';
+        return config;
+    }
     checkForResetOrEmpty(request) {
         if (!request || request.reset) {
             this.prevRequest = {};

package/lib/types/adapter.d.ts

@@ -46,5 +46,8 @@ export interface IAdapter extends EventEmitter, IBike, ISensor {
     resume(): Promise<boolean>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
+    resetData(): void;
+    onScanStart(): void;
+    onScanStop(): void;
     onData(callback: OnDeviceDataCallback): any;
 }

package/lib/utils/task.d.ts

@@ -30,15 +30,18 @@ export declare class InteruptableTask<T extends TaskState, P> {
     protected props?: TaskProps<T, P>;
     protected internalEvents: EventEmitter<[never]>;
     protected promise?: Promise<P>;
+    protected onStopNotifiers: Array<() => void>;
     constructor(promise: Promise<any>, props?: TaskProps<T, P>);
     getPromise(): Promise<P>;
     getState(): T;
     run(): Promise<P>;
+    notifyOnStop(cb: () => void): void;
     start(): void;
     stop(): Promise<boolean>;
     isRunning(): boolean;
     protected clearTimeout(): void;
     protected onTimeout(): void;
+    protected sendStopNotification(): void;
     protected logEvent(event: any): void;
 }
 export {};

package/lib/utils/task.js

@@ -20,6 +20,7 @@ class InteruptableTask {
         var _a;
         this.internalState = { isRunning: false };
         this.internalEvents = new events_1.default();
+        this.onStopNotifiers = [];
         this.state = ((_a = props === null || props === void 0 ? void 0 : props.state) !== null && _a !== void 0 ? _a : {});
         this.props = props;
         delete this.props.state;
@@ -39,6 +40,9 @@ class InteruptableTask {
             return this.internalState.promise;
         });
     }
+    notifyOnStop(cb) {
+        this.onStopNotifiers.push(cb);
+    }
     start() {
         this.internalState.promise = new Promise((resolve, reject) => {
             var _a;
@@ -59,8 +63,10 @@ class InteruptableTask {
                     isRunning: false,
                 };
                 this.internalEvents.removeAllListeners();
+                this.sendStopNotification();
                 if (this.getState().result === 'completed' || this.getState().result === 'error')
                     return;
+                this.getState().result = 'stopped';
                 if (this.props.onDone)
                     resolve(this.props.onDone(this.getState()));
                 else
@@ -119,6 +125,12 @@ class InteruptableTask {
         else
             resolve(null);
     }
+    sendStopNotification() {
+        this.onStopNotifiers.forEach((cb) => {
+            if (typeof cb === 'function')
+                cb();
+        });
+    }
     logEvent(event) {
         if (this.props.log)
             this.props.log(event);

package/package.json

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