incyclist-devices 1.4.42 → 1.4.45

package/lib/CyclingMode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
 var CyclingModeProperyType;
 (function (CyclingModeProperyType) {
     CyclingModeProperyType["Integer"] = "Integer";

package/lib/Device.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
 class IncyclistDevice {

package/lib/DeviceProtocol.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERFACE = void 0;
 exports.INTERFACE = {
     SERIAL: 'serial',
     ANT: 'ant',

package/lib/DeviceSupport.js

@@ -1,32 +1,49 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleFitnessMachineDevice = exports.BleCyclingPowerDevice = exports.BleHrmDevice = exports.BleInterface = exports.CyclingModeProperyType = exports.BleProtocol = exports.AntScanner = exports.Protocols = exports.Device = exports.INTERFACE = exports.DeviceRegistry = exports.DeviceProtocolBase = void 0;
 const DeviceRegistry_1 = __importDefault(require("./DeviceRegistry"));
 exports.DeviceRegistry = DeviceRegistry_1.default;
 const Device_1 = __importDefault(require("./Device"));
 exports.Device = Device_1.default;
 const DeviceProtocol_1 = __importStar(require("./DeviceProtocol"));
 exports.DeviceProtocolBase = DeviceProtocol_1.default;
-exports.INTERFACE = DeviceProtocol_1.INTERFACE;
+Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return DeviceProtocol_1.INTERFACE; } });
 const Simulator_1 = __importDefault(require("./simulator/Simulator"));
 const DaumPremiumProtocol_1 = __importDefault(require("./daum/premium/DaumPremiumProtocol"));
 const DaumClassicProtocol_1 = __importDefault(require("./daum/classic/DaumClassicProtocol"));
 const protocol_1 = __importDefault(require("./kettler/ergo-racer/protocol"));
 const AntScanner_1 = require("./ant/AntScanner");
-exports.AntScanner = AntScanner_1.AntScanner;
+Object.defineProperty(exports, "AntScanner", { enumerable: true, get: function () { return AntScanner_1.AntScanner; } });
 const incyclist_protocol_1 = __importDefault(require("./ble/incyclist-protocol"));
 exports.BleProtocol = incyclist_protocol_1.default;
 const CyclingMode_1 = require("./CyclingMode");
-exports.CyclingModeProperyType = CyclingMode_1.CyclingModeProperyType;
+Object.defineProperty(exports, "CyclingModeProperyType", { enumerable: true, get: function () { return CyclingMode_1.CyclingModeProperyType; } });
 const ble_interface_1 = __importDefault(require("./ble/ble-interface"));
 exports.BleInterface = ble_interface_1.default;
 const hrm_1 = __importDefault(require("./ble/hrm"));

package/lib/ant/AntAdapter.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const Device_1 = __importDefault(require("../Device"));
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 class AntAdapter extends Device_1.default {

package/lib/ant/AntScanner.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -8,17 +31,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntScanner = exports.AntProtocol = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));

package/lib/ant/antfe/AntFEAdapter.js

@@ -52,7 +52,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(ManId)} FE ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
     }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
@@ -233,7 +233,7 @@ class AntFEAdapter extends AntAdapter_1.default {
                                 trackResistanceSent: false,
                                 userSent: false,
                             };
-                            utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+                            (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                                 if (this.isStopped())
                                     resolve(false);
                                 try {
@@ -299,18 +299,18 @@ class AntFEAdapter extends AntAdapter_1.default {
             try {
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (request.slope !== undefined) {
-                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
                 }
                 if (request.targetPower !== undefined) {
-                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
                 }
                 else if (request.maxPower !== undefined) {
                     if (this.data.power && this.data.power > request.maxPower)
-                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
                 }
                 else if (request.minPower !== undefined) {
                     if (this.data.power && this.data.power < request.minPower)
-                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
                 }
             }
             catch (err) {
@@ -395,7 +395,7 @@ class AntFEAdapter extends AntAdapter_1.default {
             this.currentCmd = this.queue.dequeue();
             this.currentCmd.tsStart = Date.now();
             const { msg, logStr } = this.currentCmd;
-            this.logger.logEvent({ message: "sending", cmd: logStr, msg: utils_2.hexstr(msg), queueSize: this.queue.size() });
+            this.logger.logEvent({ message: "sending", cmd: logStr, msg: (0, utils_2.hexstr)(msg), queueSize: this.queue.size() });
             if (this.stick)
                 this.stick.write(msg);
         }

package/lib/ant/anthrm/AntHrmAdapter.js

@@ -43,7 +43,7 @@ class AntHrmAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, manID, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(manID)} Hrm ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(manID)} Hrm ${DeviceID}${hrmStr}`;
     }
     onDeviceData(deviceData) {
         if (!this.started)

package/lib/ant/antpwr/pwr-adapter.js

@@ -48,7 +48,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     getDisplayName() {
         const { DeviceID, ManId } = this.deviceData;
-        return `${utils_1.getBrand(ManId)} PWR ${DeviceID}`;
+        return `${(0, utils_1.getBrand)(ManId)} PWR ${DeviceID}`;
     }
     getCyclingMode() {
         if (!this.mode)

package/lib/ant/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = (manId) => {
+exports.getBrand = void 0;
+const getBrand = (manId) => {
     if (manId === undefined)
         return "ANT+";
     switch (manId) {
@@ -19,3 +20,4 @@ exports.getBrand = (manId) => {
             return "ANT+";
     }
 };
+exports.getBrand = getBrand;

package/lib/ble/ble-device.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps } from "./ble";
+import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps, BleDeviceInfo } from "./ble";
 interface BleDeviceConstructProps extends BleDeviceProps {
     log?: boolean;
     logger?: EventLogger;
@@ -15,17 +15,24 @@ export declare abstract class BleDevice extends BleDeviceClass {
     characteristics: any[];
     state?: string;
     logger?: EventLogger;
+    deviceInfo: BleDeviceInfo;
+    isSubscribed: boolean;
     constructor(props?: BleDeviceConstructProps);
     logEvent(event: any): void;
     setInterface(ble: BleInterfaceClass): void;
     private cleanupListeners;
     private onDisconnect;
     waitForConnectFinished(timeout: any): Promise<unknown>;
+    hasService(serviceUuid: any): boolean;
+    init(): Promise<boolean>;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     abstract onData(characteristic: string, data: Buffer): void;
-    abstract write(characteristic: string, data: Buffer): Promise<boolean>;
-    abstract read(characteristic: string): Promise<Buffer>;
+    subscribeAll(device?: this): Promise<void>;
+    subscribe(characteristicUuid: string): Promise<boolean>;
+    write(characteristicUuid: string, data: Buffer, withoutResponse: boolean): Promise<boolean>;
+    read(characteristicUuid: string): Promise<Buffer>;
+    getDeviceInfo(): Promise<BleDeviceInfo>;
 }
 export {};

package/lib/ble/ble-device.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleDevice = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const ble_1 = require("./ble");
 const CONNECT_WAIT_TIMEOUT = 10000;
@@ -16,12 +17,14 @@ 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.isSubscribed = false;
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -58,11 +61,14 @@ class BleDevice extends ble_1.BleDeviceClass {
                 c.unsubscribe();
                 c.removeAllListeners('data');
             });
+            this.isSubscribed = false;
         }
     }
     onDisconnect() {
         this.state = "disconnected";
         if (!this.connectState.isDisconnecting) {
+            this.peripheral.state = 'disconnected';
+            this.connectState.isConnected = false;
             this.connect();
         }
         this.emit('disconnected');
@@ -88,12 +94,19 @@ class BleDevice extends ble_1.BleDeviceClass {
             }, 100);
         });
     }
+    hasService(serviceUuid) {
+        return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
+    }
+    init() {
+        return this.getDeviceInfo().then(() => true);
+    }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
                 this.connectState.isConnecting = true;
                 const connected = this.ble.findConnected(peripheral);
-                if (!connected) {
+                if (peripheral.state !== 'connected') {
+                    this.isSubscribed = false;
                     try {
                         yield peripheral.connectAsync();
                     }
@@ -102,38 +115,41 @@ class BleDevice extends ble_1.BleDeviceClass {
                     }
                 }
                 try {
-                    this.cleanupListeners();
+                    if (!this.characteristics)
+                        this.characteristics = [];
                     if (!connected) {
-                        this.logEvent({ message: 'connect: discover characteristics start' });
-                        const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
-                        const { characteristics } = res;
-                        this.logEvent({ message: 'connect: discover characteristics result',
-                            result: characteristics.map(c => ({ uuid: ble_1.uuid(c.uuid), properties: c.properties.join(','), service: ble_1.uuid(c._serviceUuid) }))
-                        });
-                        this.characteristics = characteristics;
+                        if (!this.characteristics || this.characteristics.length === 0) {
+                            this.logEvent({ message: 'connect: discover characteristics start' });
+                            const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
+                            const { characteristics } = res;
+                            this.logEvent({ message: 'connect: discover characteristics result',
+                                result: characteristics.map(c => ({ uuid: (0, ble_1.uuid)(c.uuid), properties: c.properties.join(','), service: (0, ble_1.uuid)(c._serviceUuid) }))
+                            });
+                            this.characteristics = characteristics;
+                        }
+                        else {
+                        }
                     }
                     else {
                         this.characteristics = connected.characteristics;
                     }
+                    let device;
+                    if (!connected) {
+                        this.ble.addConnectedDevice(this);
+                        device = this;
+                    }
+                    else {
+                        device = connected;
+                    }
+                    this.peripheral.once('disconnect', () => { this.onDisconnect(); });
+                    yield this.subscribeAll(device);
                     this.connectState.isConnecting = false;
                     this.connectState.isConnected = true;
                     this.state = "connected";
                     this.emit('connected');
-                    this.ble.addConnectedDevice(this);
-                    this.peripheral.once('disconnect', () => { this.onDisconnect(); });
-                    this.characteristics.forEach(c => {
-                        if (c.properties.find(p => p === 'notify')) {
-                            c.on('data', (data, _isNotification) => {
-                                this.onData(ble_1.uuid(c.uuid), data);
-                            });
-                            if (!connected) {
-                                this.logEvent({ message: 'subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid });
-                                c.subscribe((err) => {
-                                    if (err)
-                                        this.logEvent({ message: 'cannot subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid, error: err.message || err });
-                                });
-                            }
-                        }
+                    this.init().then((isInitialized) => {
+                        if (isInitialized)
+                            this.emit('deviceInfo', this.deviceInfo);
                     });
                 }
                 catch (err) {
@@ -147,13 +163,9 @@ class BleDevice extends ble_1.BleDeviceClass {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
                 if (this.connectState.isConnected) {
-                    this.characteristics.forEach(c => {
-                        if (c.properties.find(p => p === 'notify')) {
-                            c.on('data', (data, _isNotification) => {
-                                this.onData(ble_1.uuid(c.uuid), data);
-                            });
-                        }
-                    });
+                    if (!this.isSubscribed) {
+                        yield this.subscribeAll();
+                    }
                     return true;
                 }
                 this.connectState.isConnecting = true;
@@ -174,7 +186,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                             if (this.ble.isScanning()) {
                                 yield this.ble.stopScan();
                             }
-                            const devices = yield this.ble.scan({ device: this });
+                            const devices = yield this.ble.scan({ requested: this });
                             if (devices && devices.length > 0) {
                                 this.peripheral = devices[0].peripheral;
                                 yield connectPeripheral(this.peripheral);
@@ -226,5 +238,105 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
         });
     }
+    subscribeAll(device = this) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed)
+                return;
+            const cnt = this.characteristics.length;
+            for (let i = 0; i < cnt; i++) {
+                try {
+                    const c = this.characteristics[i];
+                    const isNotify = c.properties.find(p => p === 'notify');
+                    if (isNotify) {
+                        c.on('data', (data, _isNotification) => {
+                            this.onData((0, ble_1.uuid)(c.uuid), data);
+                        });
+                        if (!device.isSubscribed) {
+                            this.logEvent({ message: 'subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid });
+                            try {
+                                yield this.subscribe(c.uuid);
+                            }
+                            catch (err) {
+                                this.logEvent({ message: 'cannot subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid, error: err.message || err });
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.log('~~~ error', err);
+                }
+            }
+            this.isSubscribed = true;
+        });
+    }
+    subscribe(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;
+            }
+            characteristic.subscribe((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(true);
+            });
+        });
+    }
+    write(characteristicUuid, data, withoutResponse) {
+        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;
+            }
+            characteristic.write(data, withoutResponse, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(true);
+            });
+        });
+    }
+    read(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;
+            }
+            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);
+                    return b ? b.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;

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding } from './ble';
+import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding, BleCharacteristic, BleDeviceDescription } from './ble';
 export interface ScanState {
     isScanning: boolean;
     isConnecting: boolean;
@@ -13,6 +13,11 @@ export interface ConnectState {
     timeout?: NodeJS.Timeout;
     isInitSuccess: boolean;
 }
+export interface PeripheralState {
+    isLoading: boolean;
+    isConfigured: boolean;
+    isInterrupted: boolean;
+}
 export interface BleDeviceInfo {
     device: BleDeviceClass;
     isConnected: boolean;
@@ -23,12 +28,19 @@ export interface BleDeviceClassInfo {
     services: string[];
     id: string;
 }
+export interface PeripheralCacheItem {
+    address: string;
+    ts: number;
+    peripheral: BlePeripheral;
+    state?: PeripheralState;
+    characteristics?: BleCharacteristic[];
+}
 export default class BleInterface extends BleInterfaceClass {
     scanState: ScanState;
     connectState: ConnectState;
     devices: BleDeviceInfo[];
+    peripheralCache: any[];
     logger: EventLogger;
-    deviceCache: any[];
     static deviceClasses: BleDeviceClassInfo[];
     static _instance: BleInterface;
     static getInstance(props?: {
@@ -52,9 +64,15 @@ export default class BleInterface extends BleInterfaceClass {
     getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;
-    connectDevice(requested: BleDeviceClass, timeout?: number): Promise<BleDeviceClass>;
+    addPeripheralToCache(peripheral: any, props?: {}): void;
+    getCharacteristics(peripheral: any): Promise<any>;
+    getDeviceClasses(peripheral: any, props?: {
+        deviceTypes?: (typeof BleDeviceClass)[];
+        profile?: string;
+    }): (typeof BleDeviceClass)[];
+    createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): any;
+    connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;
     waitForScanFinished(timeout: any): Promise<unknown>;
-    addPeripheralToCache(peripheral: BlePeripheral): void;
     scan(props: ScanProps): Promise<BleDeviceClass[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;