incyclist-devices 1.4.98 → 1.4.102

package/lib/ble/ble-device.js

@@ -1,442 +1,444 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BleDevice = void 0;
-const gd_eventlog_1 = require("gd-eventlog");
-const ble_1 = require("./ble");
-const ble_2 = require("./ble");
-const CONNECT_WAIT_TIMEOUT = 10000;
-const BLE_TIMEOUT = 1000;
-class BleDevice extends ble_1.BleDeviceClass {
-    constructor(props) {
-        super();
-        this.characteristics = [];
-        this.deviceInfo = {};
-        this.id = props.id;
-        this.address = props.address;
-        this.name = props.name;
-        this.services = props.services;
-        this.ble = props.ble;
-        this.characteristics = [];
-        this.subscribedCharacteristics = [];
-        this.isInitialized = false;
-        this.writeQueue = [];
-        this.workerIv = null;
-        this.prevMessages = [];
-        if (props.peripheral) {
-            const { id, address, advertisement, state } = props.peripheral;
-            this.peripheral = props.peripheral;
-            this.id = id;
-            this.address = address;
-            this.name = advertisement.localName;
-            this.services = advertisement.serviceUuids;
-            this.state = state;
-        }
-        if (props.logger) {
-            this.logger = props.logger;
-        }
-        else if (props.log !== false) {
-            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
-        }
-    }
-    getServices() {
-        return this.services;
-    }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        console.log('~~~BLE:', event);
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    setInterface(ble) {
-        this.ble = ble;
-    }
-    isMatching(characteristics) {
-        return true;
-    }
-    cleanupListeners() {
-        if (this.characteristics === undefined) {
-            this.characteristics = [];
-        }
-        else {
-            const connector = this.ble.getConnector(this.peripheral);
-            this.characteristics.forEach(c => {
-                connector.removeAllListeners((0, ble_1.uuid)(c.uuid));
-            });
-        }
-    }
-    onDisconnect() {
-        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
-        this.state = "disconnected";
-        if (!this.connectState.isDisconnecting) {
-            this.peripheral.state = 'disconnected';
-            this.connectState.isConnecting = false;
-            this.connectState.isConnected = false;
-            this.cleanupListeners();
-            this.subscribedCharacteristics = [];
-            this.ble.onDisconnect(this.peripheral);
-            this.connect({ reconnect: true });
-        }
-        this.emit('disconnected');
-    }
-    waitForConnectFinished(timeout) {
-        const waitStart = Date.now();
-        const waitTimeout = waitStart + timeout;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                try {
-                    if (this.connectState.isConnecting && Date.now() > waitTimeout) {
-                        clearInterval(waitIv);
-                        return reject(new Error('connection already in progress'));
-                    }
-                    if (!this.connectState.isConnecting) {
-                        clearInterval(waitIv);
-                        return resolve(true);
-                    }
-                }
-                catch (err) {
-                    console.log('~~~ error', err);
-                }
-            }, 100);
-        });
-    }
-    hasService(serviceUuid) {
-        return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.initDevice();
-        });
-    }
-    initDevice() {
-        this.logEvent({ message: 'get device info' });
-        return this.getDeviceInfo().then(() => {
-            this.emit('deviceInfo', this.deviceInfo);
-            this.logEvent(Object.assign({ message: 'device init done' }, this.deviceInfo));
-            this.isInitialized = true;
-            return true;
-        });
-    }
-    connectPeripheral(peripheral) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.connectState.isConnecting = true;
-            try {
-                const connector = this.ble.getConnector(peripheral);
-                connector.on('disconnect', () => { this.onDisconnect(); });
-                yield connector.connect();
-                yield connector.initialize();
-                yield this.subscribeAll(connector);
-                this.connectState.isConnected = true;
-                this.state = "connected";
-                this.emit('connected');
-                yield this.init();
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
-            }
-            this.connectState.isConnecting = false;
-        });
-    }
-    subscribeAll(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const connector = conn || this.ble.getConnector(this.peripheral);
-                const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
-                subscribed.forEach(c => this.subscribedCharacteristics.push(c));
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
-            }
-        });
-    }
-    connect(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { reconnect } = props || {};
-            try {
-                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
-                if (!reconnect && this.connectState.isConnecting) {
-                    yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
-                }
-                if (this.connectState.isConnected) {
-                    try {
-                        yield this.subscribeAll();
-                        yield this.init();
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
-                        return false;
-                    }
-                    return true;
-                }
-                this.connectState.isConnecting = true;
-                if (!this.peripheral) {
-                    const { id, name, address } = this;
-                    try {
-                        this.peripheral = this.ble.findPeripheral({ id, name, address });
-                    }
-                    catch (err) {
-                        console.log('~~~ error', err);
-                    }
-                }
-                if (this.peripheral) {
-                    const { id, address, advertisement } = this.peripheral;
-                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
-                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
-                    yield this.connectPeripheral(this.peripheral);
-                    this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
-                    return true;
-                }
-                else {
-                    const { id, name, address } = this;
-                    let error;
-                    if (this.address || this.id || this.name) {
-                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
-                        try {
-                            if (this.ble.isScanning()) {
-                                yield this.ble.stopScan();
-                            }
-                            const devices = yield this.ble.scan({ requested: this });
-                            if (devices && devices.length > 0) {
-                                this.peripheral = devices[0].peripheral;
-                                yield this.connectPeripheral(this.peripheral);
-                                this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
-                                this.connectState.isConnecting = false;
-                                this.connectState.isConnected = true;
-                                return true;
-                            }
-                        }
-                        catch (err) {
-                            console.log('~~~ error', err);
-                            error = err;
-                        }
-                    }
-                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message, stack: error.stack });
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = false;
-                    return false;
-                }
-            }
-            catch (err) {
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                this.logEvent({ message: 'connect result: error', error: err.message });
-                return false;
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, name, address } = this;
-            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
-            this.connectState.isDisconnecting = true;
-            if (this.workerIv) {
-                this.stopWorker();
-            }
-            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
-                this.connectState.isDisconnecting = false;
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
-                return true;
-            }
-            if (this.connectState.isConnecting) {
-                this.cleanupListeners();
-                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
-                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                return true;
-            }
-            if (this.connectState.isConnected) {
-                this.ble.removeConnectedDevice(this);
-                this.cleanupListeners();
-                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
-                this.connectState.isDisconnecting = false;
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                return true;
-            }
-        });
-    }
-    checkForDuplicate(characteristic, data) {
-        const prev = this.prevMessages.find(i => i.uuid === characteristic);
-        if (prev) {
-            if (prev.data === data.toString('hex') && prev.timestamp > Date.now() - 500) {
-                prev.timestamp = Date.now();
-                return true;
-            }
-            else {
-                prev.data = data.toString('hex');
-                prev.timestamp = Date.now();
-            }
-        }
-        else {
-            this.prevMessages.push({ uuid: characteristic, timestamp: Date.now(), data: data.toString('hex') });
-        }
-        return false;
-    }
-    onData(characteristic, _data) {
-        const data = Buffer.from(_data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate) {
-            return false;
-        }
-        this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
-        if (this.writeQueue.length > 0) {
-            const writeIdx = this.writeQueue.findIndex(i => (0, ble_2.matches)(i.uuid, characteristic));
-            if (writeIdx !== -1) {
-                const writeItem = this.writeQueue[writeIdx];
-                this.writeQueue.splice(writeIdx, 1);
-                if (writeItem.resolve)
-                    writeItem.resolve(data);
-                return false;
-            }
-        }
-        return true;
-    }
-    timeoutCheck() {
-        const now = Date.now();
-        const updatedQueue = [];
-        let hasTimeout = false;
-        this.writeQueue.forEach(writeItem => {
-            if (writeItem.timeout && writeItem.timeout < now) {
-                if (writeItem.reject) {
-                    hasTimeout = true;
-                    writeItem.reject(new Error('timeout'));
-                }
-            }
-            else {
-                updatedQueue.push(writeItem);
-            }
-        });
-        if (hasTimeout)
-            this.writeQueue = updatedQueue;
-    }
-    startWorker() {
-        if (this.workerIv)
-            return;
-        this.workerIv = setInterval(() => { this.timeoutCheck(); }, 100);
-    }
-    stopWorker() {
-        if (!this.workerIv)
-            return;
-        clearInterval(this.workerIv);
-        this.workerIv = null;
-    }
-    write(characteristicUuid, data, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.isConnected())
-                    throw new Error('not connected');
-                const { withoutResponse, timeout } = props || {};
-                const connector = this.ble.getConnector(this.peripheral);
-                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
-                if (!withoutResponse && !this.workerIv) {
-                    this.startWorker();
-                }
-                if (!withoutResponse && !isAlreadySubscribed) {
-                    const connector = this.ble.getConnector(this.peripheral);
-                    connector.removeAllListeners(characteristicUuid);
-                    connector.on(characteristicUuid, (uuid, data) => {
-                        this.onData(uuid, data);
-                    });
-                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
-                    yield connector.subscribe(characteristicUuid);
-                    this.subscribedCharacteristics.push(characteristicUuid);
-                }
-                return new Promise((resolve, reject) => {
-                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-                    if (!characteristic) {
-                        reject(new Error('Characteristic not found'));
-                        return;
-                    }
-                    if (withoutResponse) {
-                        this.logEvent({ message: 'writing', data: data.toString('hex'), withoutResponse });
-                        characteristic.write(data, withoutResponse);
-                        resolve(new ArrayBuffer(0));
-                        return;
-                    }
-                    else {
-                        const writeId = this.writeQueue.length;
-                        let messageDeleted = false;
-                        const writeTimeout = timeout !== undefined ? timeout : BLE_TIMEOUT;
-                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, timeout: Date.now() + writeTimeout, resolve, reject });
-                        const to = setTimeout(() => {
-                            if (this.writeQueue.length > writeId && !messageDeleted)
-                                this.writeQueue.splice(writeId, 1);
-                            this.logEvent({ message: 'writing response', err: 'timeout' });
-                            reject(new Error('timeout'));
-                        }, 5000);
-                        this.logEvent({ message: 'writing' });
-                        characteristic.write(data, withoutResponse, (err) => {
-                            clearTimeout(to);
-                            this.logEvent({ message: 'writing response', err });
-                            if (err) {
-                                this.writeQueue.splice(writeId, 1);
-                                messageDeleted = true;
-                                reject(err);
-                            }
-                        });
-                    }
-                });
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: '', error: err.message || err, stack: err.stack });
-            }
-        });
-    }
-    read(characteristicUuid) {
-        return new Promise((resolve, reject) => {
-            if (!this.isConnected())
-                return reject(new Error('not connected'));
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-            if (!characteristic) {
-                reject(new Error('Characteristic not found'));
-                return;
-            }
-            characteristic.read((err, data) => {
-                if (err && data instanceof Error)
-                    reject(err);
-                else if (data instanceof Error)
-                    reject(data);
-                else
-                    resolve(data);
-            });
-        });
-    }
-    getDeviceInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = this.deviceInfo;
-            const readValue = (c) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const b = yield this.read(c);
-                    const buffer = b ? Buffer.from(b) : undefined;
-                    return buffer ? buffer.toString() : undefined;
-                }
-                catch (_a) {
-                    return undefined;
-                }
-            });
-            info.model = info.model || (yield readValue('2a24'));
-            info.serialNo = info.serialNo || (yield readValue('2a25'));
-            info.fwRevision = info.fwRevision || (yield readValue('2a26'));
-            info.hwRevision = info.hwRevision || (yield readValue('2a27'));
-            info.swRevision = info.swRevision || (yield readValue('2a28'));
-            info.manufacturer = info.manufacturer || (yield readValue('2a29'));
-            this.deviceInfo = info;
-            return info;
-        });
-    }
-}
-exports.BleDevice = BleDevice;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleDevice = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const ble_1 = require("./ble");
+const ble_2 = require("./ble");
+const CONNECT_WAIT_TIMEOUT = 10000;
+const BLE_TIMEOUT = 1000;
+class BleDevice extends ble_1.BleDeviceClass {
+    constructor(props) {
+        super();
+        this.characteristics = [];
+        this.deviceInfo = {};
+        this.id = props.id;
+        this.address = props.address;
+        this.name = props.name;
+        this.services = props.services;
+        this.ble = props.ble;
+        this.characteristics = [];
+        this.subscribedCharacteristics = [];
+        this.isInitialized = false;
+        this.writeQueue = [];
+        this.workerIv = null;
+        this.prevMessages = [];
+        if (props.peripheral) {
+            const { id, address, advertisement, state } = props.peripheral;
+            this.peripheral = props.peripheral;
+            this.id = id;
+            this.address = address;
+            this.name = advertisement.localName;
+            this.services = advertisement.serviceUuids;
+            this.state = state;
+        }
+        if (props.logger) {
+            this.logger = props.logger;
+        }
+        else if (props.log !== false) {
+            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
+        }
+    }
+    getServices() {
+        return this.services;
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        if (process.env.BLE_DEBUG) {
+            console.log('~~~BLE:', event);
+        }
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    setInterface(ble) {
+        this.ble = ble;
+    }
+    isMatching(characteristics) {
+        return true;
+    }
+    cleanupListeners() {
+        if (this.characteristics === undefined) {
+            this.characteristics = [];
+        }
+        else {
+            const connector = this.ble.getConnector(this.peripheral);
+            this.characteristics.forEach(c => {
+                connector.removeAllListeners((0, ble_1.uuid)(c.uuid));
+            });
+        }
+    }
+    onDisconnect() {
+        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
+        this.state = "disconnected";
+        if (!this.connectState.isDisconnecting) {
+            this.peripheral.state = 'disconnected';
+            this.connectState.isConnecting = false;
+            this.connectState.isConnected = false;
+            this.cleanupListeners();
+            this.subscribedCharacteristics = [];
+            this.ble.onDisconnect(this.peripheral);
+            this.connect({ reconnect: true });
+        }
+        this.emit('disconnected');
+    }
+    waitForConnectFinished(timeout) {
+        const waitStart = Date.now();
+        const waitTimeout = waitStart + timeout;
+        return new Promise((resolve, reject) => {
+            const waitIv = setInterval(() => {
+                try {
+                    if (this.connectState.isConnecting && Date.now() > waitTimeout) {
+                        clearInterval(waitIv);
+                        return reject(new Error('connection already in progress'));
+                    }
+                    if (!this.connectState.isConnecting) {
+                        clearInterval(waitIv);
+                        return resolve(true);
+                    }
+                }
+                catch (err) {
+                    console.log('~~~ error', err);
+                }
+            }, 100);
+        });
+    }
+    hasService(serviceUuid) {
+        return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.initDevice();
+        });
+    }
+    initDevice() {
+        this.logEvent({ message: 'get device info' });
+        return this.getDeviceInfo().then(() => {
+            this.emit('deviceInfo', this.deviceInfo);
+            this.logEvent(Object.assign({ message: 'device init done' }, this.deviceInfo));
+            this.isInitialized = true;
+            return true;
+        });
+    }
+    connectPeripheral(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connectState.isConnecting = true;
+            try {
+                const connector = this.ble.getConnector(peripheral);
+                connector.on('disconnect', () => { this.onDisconnect(); });
+                yield connector.connect();
+                yield connector.initialize();
+                yield this.subscribeAll(connector);
+                this.connectState.isConnected = true;
+                this.state = "connected";
+                this.emit('connected');
+                yield this.init();
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+            }
+            this.connectState.isConnecting = false;
+        });
+    }
+    subscribeAll(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connector = conn || this.ble.getConnector(this.peripheral);
+                const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
+                subscribed.forEach(c => this.subscribedCharacteristics.push(c));
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
+            }
+        });
+    }
+    connect(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { reconnect } = props || {};
+            try {
+                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
+                if (!reconnect && this.connectState.isConnecting) {
+                    yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
+                }
+                if (this.connectState.isConnected) {
+                    try {
+                        yield this.subscribeAll();
+                        yield this.init();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
+                        return false;
+                    }
+                    return true;
+                }
+                this.connectState.isConnecting = true;
+                if (!this.peripheral) {
+                    const { id, name, address } = this;
+                    try {
+                        this.peripheral = this.ble.findPeripheral({ id, name, address });
+                    }
+                    catch (err) {
+                        console.log('~~~ error', err);
+                    }
+                }
+                if (this.peripheral) {
+                    const { id, address, advertisement } = this.peripheral;
+                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
+                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
+                    yield this.connectPeripheral(this.peripheral);
+                    this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
+                    return true;
+                }
+                else {
+                    const { id, name, address } = this;
+                    let error;
+                    if (this.address || this.id || this.name) {
+                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
+                        try {
+                            if (this.ble.isScanning()) {
+                                yield this.ble.stopScan();
+                            }
+                            const devices = yield this.ble.scan({ requested: this });
+                            if (devices && devices.length > 0) {
+                                this.peripheral = devices[0].peripheral;
+                                yield this.connectPeripheral(this.peripheral);
+                                this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
+                                this.connectState.isConnecting = false;
+                                this.connectState.isConnected = true;
+                                return true;
+                            }
+                        }
+                        catch (err) {
+                            console.log('~~~ error', err);
+                            error = err;
+                        }
+                    }
+                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message, stack: error.stack });
+                    this.connectState.isConnecting = false;
+                    this.connectState.isConnected = false;
+                    return false;
+                }
+            }
+            catch (err) {
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'connect result: error', error: err.message });
+                return false;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, name, address } = this;
+            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.connectState.isDisconnecting = true;
+            if (this.workerIv) {
+                this.stopWorker();
+            }
+            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                return true;
+            }
+            if (this.connectState.isConnecting) {
+                this.cleanupListeners();
+                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
+                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                return true;
+            }
+            if (this.connectState.isConnected) {
+                this.ble.removeConnectedDevice(this);
+                this.cleanupListeners();
+                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
+                this.connectState.isDisconnecting = false;
+                this.connectState.isConnecting = false;
+                this.connectState.isConnected = false;
+                return true;
+            }
+        });
+    }
+    checkForDuplicate(characteristic, data) {
+        const prev = this.prevMessages.find(i => i.uuid === characteristic);
+        if (prev) {
+            if (prev.data === data.toString('hex') && prev.timestamp > Date.now() - 500) {
+                prev.timestamp = Date.now();
+                return true;
+            }
+            else {
+                prev.data = data.toString('hex');
+                prev.timestamp = Date.now();
+            }
+        }
+        else {
+            this.prevMessages.push({ uuid: characteristic, timestamp: Date.now(), data: data.toString('hex') });
+        }
+        return false;
+    }
+    onData(characteristic, _data) {
+        const data = Buffer.from(_data);
+        const isDuplicate = this.checkForDuplicate(characteristic, data);
+        if (isDuplicate) {
+            return false;
+        }
+        this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
+        if (this.writeQueue.length > 0) {
+            const writeIdx = this.writeQueue.findIndex(i => (0, ble_2.matches)(i.uuid, characteristic));
+            if (writeIdx !== -1) {
+                const writeItem = this.writeQueue[writeIdx];
+                this.writeQueue.splice(writeIdx, 1);
+                if (writeItem.resolve)
+                    writeItem.resolve(data);
+                return false;
+            }
+        }
+        return true;
+    }
+    timeoutCheck() {
+        const now = Date.now();
+        const updatedQueue = [];
+        let hasTimeout = false;
+        this.writeQueue.forEach(writeItem => {
+            if (writeItem.timeout && writeItem.timeout < now) {
+                if (writeItem.reject) {
+                    hasTimeout = true;
+                    writeItem.reject(new Error('timeout'));
+                }
+            }
+            else {
+                updatedQueue.push(writeItem);
+            }
+        });
+        if (hasTimeout)
+            this.writeQueue = updatedQueue;
+    }
+    startWorker() {
+        if (this.workerIv)
+            return;
+        this.workerIv = setInterval(() => { this.timeoutCheck(); }, 100);
+    }
+    stopWorker() {
+        if (!this.workerIv)
+            return;
+        clearInterval(this.workerIv);
+        this.workerIv = null;
+    }
+    write(characteristicUuid, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected())
+                throw new Error('not connected');
+            try {
+                const { withoutResponse, timeout } = props || {};
+                const connector = this.ble.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
+                if (!withoutResponse && !this.workerIv) {
+                    this.startWorker();
+                }
+                if (!withoutResponse && !isAlreadySubscribed) {
+                    const connector = this.ble.getConnector(this.peripheral);
+                    connector.removeAllListeners(characteristicUuid);
+                    connector.on(characteristicUuid, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
+                    yield connector.subscribe(characteristicUuid);
+                    this.subscribedCharacteristics.push(characteristicUuid);
+                }
+                return new Promise((resolve, reject) => {
+                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                    if (!characteristic) {
+                        reject(new Error('Characteristic not found'));
+                        return;
+                    }
+                    if (withoutResponse) {
+                        this.logEvent({ message: 'writing', data: data.toString('hex'), withoutResponse });
+                        characteristic.write(data, withoutResponse);
+                        resolve(new ArrayBuffer(0));
+                        return;
+                    }
+                    else {
+                        const writeId = this.writeQueue.length;
+                        let messageDeleted = false;
+                        const writeTimeout = timeout !== undefined ? timeout : BLE_TIMEOUT;
+                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, timeout: Date.now() + writeTimeout, resolve, reject });
+                        const to = setTimeout(() => {
+                            if (this.writeQueue.length > writeId && !messageDeleted)
+                                this.writeQueue.splice(writeId, 1);
+                            this.logEvent({ message: 'writing response', err: 'timeout' });
+                            reject(new Error('timeout'));
+                        }, 5000);
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse, (err) => {
+                            clearTimeout(to);
+                            this.logEvent({ message: 'writing response', err });
+                            if (err) {
+                                this.writeQueue.splice(writeId, 1);
+                                messageDeleted = true;
+                                reject(err);
+                            }
+                        });
+                    }
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'write', error: err.message || err, stack: err.stack });
+            }
+        });
+    }
+    read(characteristicUuid) {
+        return new Promise((resolve, reject) => {
+            if (!this.isConnected())
+                return reject(new Error('not connected'));
+            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+            if (!characteristic) {
+                reject(new Error('Characteristic not found'));
+                return;
+            }
+            characteristic.read((err, data) => {
+                if (err && data instanceof Error)
+                    reject(err);
+                else if (data instanceof Error)
+                    reject(data);
+                else
+                    resolve(data);
+            });
+        });
+    }
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = this.deviceInfo;
+            const readValue = (c) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const b = yield this.read(c);
+                    const buffer = b ? Buffer.from(b) : undefined;
+                    return buffer ? buffer.toString() : undefined;
+                }
+                catch (_a) {
+                    return undefined;
+                }
+            });
+            info.model = info.model || (yield readValue('2a24'));
+            info.serialNo = info.serialNo || (yield readValue('2a25'));
+            info.fwRevision = info.fwRevision || (yield readValue('2a26'));
+            info.hwRevision = info.hwRevision || (yield readValue('2a27'));
+            info.swRevision = info.swRevision || (yield readValue('2a28'));
+            info.manufacturer = info.manufacturer || (yield readValue('2a29'));
+            this.deviceInfo = info;
+            return info;
+        });
+    }
+}
+exports.BleDevice = BleDevice;