incyclist-devices 2.3.9 → 2.3.11

package/lib/ble/ble-interface.js

@@ -1,622 +0,0 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const gd_eventlog_1 = require("gd-eventlog");
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
-const utils_1 = require("./utils");
-const comms_utils_1 = require("./base/comms-utils");
-const peripheral_cache_1 = __importDefault(require("./peripheral-cache"));
-const events_1 = __importDefault(require("events"));
-const utils_2 = require("../utils/utils");
-const DEFAULT_SCAN_TIMEOUT = 20000;
-class BleInterface extends events_1.default {
-    static getInstance(props = {}) {
-        if (!BleInterface._instance) {
-            BleInterface._instance = new BleInterface(props);
-        }
-        else {
-            if (props.binding) {
-                BleInterface._instance.setBinding(props.binding);
-            }
-            if (props.logger) {
-                BleInterface._instance.logger = props.logger;
-            }
-            if (props.log && !BleInterface._instance.logger) {
-                BleInterface._instance.logger = new gd_eventlog_1.EventLogger('BLE');
-            }
-        }
-        return BleInterface._instance;
-    }
-    constructor(props = {}) {
-        super();
-        this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
-        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
-        this.emittingAdapters = [];
-        this.props = props;
-        if (props.binding)
-            this.setBinding(props.binding);
-        this.peripheralCache = new peripheral_cache_1.default();
-        if (props.logger)
-            this.logger = props.logger;
-        else
-            this.logger = new gd_eventlog_1.EventLogger('BLE');
-        this.loggingPaused = false;
-    }
-    getBinding() { return this.binding; }
-    setBinding(binding) { if (binding)
-        this.binding = binding; }
-    getName() {
-        return 'ble';
-    }
-    getReconnectPause() {
-        return 1000;
-    }
-    startConnectSensor() {
-        this.sensorIsConnecting = true;
-    }
-    stopConnectSensor() {
-        this.sensorIsConnecting = false;
-    }
-    waitForSensorConnectionFinish() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (this.sensorIsConnecting && this.connectState.isConnected) {
-                yield (0, utils_2.sleep)(100);
-            }
-            return;
-        });
-    }
-    getAdapterFactory() {
-        return adapter_factory_1.default.getInstance();
-    }
-    pauseLogging(debugOnly = false) {
-        if (this.loggingPaused)
-            return;
-        this.logEvent({ message: 'pause logging on BLE Interface', debugOnly });
-        this.loggingPaused = debugOnly;
-        try {
-            this.getBinding().pauseLogging();
-        }
-        catch (_a) { }
-    }
-    resumeLogging() {
-        if (!this.loggingPaused)
-            return;
-        const event = { message: 'resume logging on BLE Interface' };
-        this.logger.logEvent(event);
-        if (this.isDebugEnabled()) {
-            console.log('~~~ BLE', event);
-        }
-        this.loggingPaused = false;
-        try {
-            this.getBinding().resumeLogging();
-        }
-        catch (_a) { }
-    }
-    isDebugEnabled() {
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            return true;
-        }
-        return false;
-    }
-    logEvent(event) {
-        if (this.logger && !this.loggingPaused) {
-            this.logger.logEvent(event);
-        }
-        if (this.isDebugEnabled()) {
-            console.log('~~~ BLE', event);
-        }
-    }
-    onStateChange(state) {
-        if (state !== 'poweredOn') {
-            this.logEvent({ message: 'Ble disconnected', });
-            this.connectState.isConnected = false;
-            this.stopConnectSensor();
-        }
-        else {
-            this.connectState.isConnected = true;
-        }
-    }
-    onError(err) {
-        this.logEvent({ message: 'error', error: err.message, stack: err.stack });
-    }
-    connect(to) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.connectState.isConnected) {
-                return true;
-            }
-            if (this.connectState.isConnecting) {
-                return yield this.connectState.connectPromise;
-            }
-            this.resumeLogging();
-            const timeout = this.props.timeout || to || 2000;
-            const connect = new Promise((resolve, reject) => {
-                this.logEvent({ message: 'Ble connect request' });
-                if (!this.getBinding())
-                    return reject(new Error('no binding defined'));
-                this.connectState.timeout = setTimeout(() => {
-                    this.connectState.isConnected = false;
-                    this.connectState.isConnecting = false;
-                    this.connectState.timeout = null;
-                    this.logEvent({ message: 'Ble connect result: timeout' });
-                    resolve(false);
-                }, timeout);
-                try {
-                    const state = this.getBinding().state;
-                    if (state === 'poweredOn') {
-                        clearTimeout(this.connectState.timeout);
-                        this.connectState.timeout = null;
-                        this.getBinding().removeAllListeners('stateChange');
-                        this.getBinding().on('stateChange', this.onStateChange.bind(this));
-                        this.connectState.isConnected = true;
-                        this.connectState.isConnecting = false;
-                        this.logEvent({ message: 'connect result: already connected' });
-                        resolve(true);
-                        return;
-                    }
-                    else {
-                        this.getBinding().once('error', (err) => {
-                            this.connectState.isConnected = true;
-                            this.connectState.isConnecting = false;
-                            this.logEvent({ message: 'connect result: error', error: err.message });
-                            this.getBinding().on('error', this.onError.bind(this));
-                            return reject(err);
-                        });
-                        this.getBinding().on('stateChange', (state) => {
-                            if (state === 'poweredOn') {
-                                clearTimeout(this.connectState.timeout);
-                                this.connectState.timeout = null;
-                                this.getBinding().removeAllListeners('stateChange');
-                                this.getBinding().on('stateChange', this.onStateChange.bind(this));
-                                this.connectState.isConnected = true;
-                                this.connectState.isConnecting = false;
-                                this.logEvent({ message: 'Ble connect result: success' });
-                                return resolve(true);
-                            }
-                            else {
-                                this.logEvent({ message: 'BLE state change', state });
-                            }
-                        });
-                    }
-                }
-                catch (err) {
-                    this.connectState.isConnected = false;
-                    this.connectState.isConnecting = false;
-                    if (this.connectState.timeout)
-                        clearTimeout(this.connectState.timeout);
-                    this.connectState.timeout = null;
-                    this.logEvent({ message: 'Ble connect result: error', error: err.message });
-                    return reject(new Error('bluetooth unavailable, cause: ' + err.message));
-                }
-            });
-            const cleanup = () => {
-                if (this.connectState.timeout) {
-                    clearTimeout(this.connectState.timeout);
-                    this.connectState.timeout = null;
-                }
-                this.connectState.isConnecting = false;
-                delete this.connectState.connectPromise;
-            };
-            this.connectState.isConnecting = true;
-            this.connectState.connectPromise = connect;
-            try {
-                const connected = yield connect;
-                cleanup();
-                return connected;
-            }
-            catch (err) {
-                cleanup();
-                throw err;
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.connectState.isConnected) {
-                return Promise.resolve(true);
-            }
-            if (!this.getBinding())
-                return Promise.reject(new Error('no binding defined'));
-            this.logEvent({ message: 'disconnect request' });
-            if (this.scanState.isScanning) {
-                yield this.stopScan();
-            }
-            const devices = this.getAdapterFactory().getAllInstances();
-            const connectedDevices = devices.filter(d => d.isConnected());
-            for (let i = 0; i < connectedDevices.length; i++) {
-                const d = connectedDevices[i];
-                yield d.close();
-            }
-            this.connectState.isConnected = false;
-            this.connectState.isConnecting = false;
-            if (this.connectState.timeout) {
-                clearTimeout(this.connectState.timeout);
-                this.connectState.timeout = null;
-            }
-            this.logEvent({ message: 'disconnect result: success' });
-            this.pauseLogging();
-            return true;
-        });
-    }
-    isConnected() {
-        return this.connectState.isConnected;
-    }
-    onDisconnect(peripheral) {
-        this.peripheralCache.remove(peripheral);
-    }
-    scannerWaitForConnection(tsTimeoutExpired) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const timeoutExpired = () => {
-                if (!tsTimeoutExpired)
-                    return false;
-                return Date.now() >= tsTimeoutExpired;
-            };
-            while (!this.isConnected() && this.scanState.isScanning && !timeoutExpired()) {
-                const connected = yield this.connect();
-                if (!connected)
-                    yield (0, utils_2.sleep)(this.getReconnectPause());
-            }
-        });
-    }
-    getCharacteristics(peripheral) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let characteristics = undefined;
-            let chachedPeripheralInfo = this.peripheralCache.find({ peripheral });
-            if (chachedPeripheralInfo && Date.now() - chachedPeripheralInfo.ts > 600000) {
-                chachedPeripheralInfo.ts = Date.now();
-            }
-            if (!chachedPeripheralInfo) {
-                chachedPeripheralInfo = this.peripheralCache.add({ address: peripheral.address, ts: Date.now(), peripheral });
-            }
-            const connector = chachedPeripheralInfo.connector;
-            if (!chachedPeripheralInfo.characteristics) {
-                try {
-                    chachedPeripheralInfo.state = { isConfigured: false, isLoading: true, isInterrupted: false };
-                    yield connector.connect();
-                    peripheral.state = connector.getState();
-                    const initialized = yield connector.initialize();
-                    if (!initialized)
-                        return null;
-                    characteristics = connector.getCharachteristics();
-                    this.logEvent({ message: 'characteristic info (+):', address: peripheral.address, info: characteristics.map(utils_1.getCharachteristicsInfo) });
-                    chachedPeripheralInfo.characteristics = characteristics;
-                    chachedPeripheralInfo.state = { isConfigured: true, isLoading: false, isInterrupted: false };
-                }
-                catch (err) {
-                    console.log('~~ ERROR', err);
-                }
-            }
-            else {
-                characteristics = chachedPeripheralInfo.characteristics;
-                this.logEvent({ message: 'characteristic info (*):', address: peripheral.address, info: characteristics.map(utils_1.getCharachteristicsInfo) });
-            }
-            if (!characteristics)
-                this.logEvent({ message: 'characteristic info:', info: 'none' });
-            return characteristics;
-        });
-    }
-    waitForScanFinished(timeout) {
-        const waitStart = Date.now();
-        const waitTimeout = waitStart + timeout;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                if (this.scanState.isScanning && Date.now() > waitTimeout) {
-                    clearInterval(waitIv);
-                    return reject(new Error('scanning already in progress'));
-                }
-                if (!this.scanState.isScanning) {
-                    clearInterval(waitIv);
-                    return resolve(true);
-                }
-            }, 100);
-        });
-    }
-    onPeripheralFound(p_1, callback_1) {
-        return __awaiter(this, arguments, void 0, function* (p, callback, props = {}) {
-            var _a;
-            let peripheral = p;
-            if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName) {
-                return;
-            }
-            const scanForDevice = (props.comms !== undefined) || (props.request !== undefined && props.request !== null);
-            const request = props.comms ? props.comms.getSettings() : props.request;
-            if (scanForDevice && this.scanState.peripherals.size > 0) {
-                return;
-            }
-            if (!this.scanState.peripherals)
-                this.scanState.peripherals = new Map();
-            if (peripheral.address === undefined || peripheral.address === '')
-                peripheral.address = peripheral.id || peripheral.name;
-            const isPeripheralProcessed = this.scanState.peripherals.get(peripheral.address) !== undefined;
-            if (isPeripheralProcessed) {
-                return;
-            }
-            if (scanForDevice) {
-                const alreadyDetected = ((_a = this.scanState.detected) === null || _a === void 0 ? void 0 : _a.find(p => p === peripheral.address)) !== undefined;
-                if (alreadyDetected)
-                    return;
-                this.scanState.detected.push(peripheral.address);
-            }
-            if (scanForDevice) {
-                let found = false;
-                found =
-                    (request.name !== undefined && peripheral.advertisement && request.name === peripheral.advertisement.localName) ||
-                        (request.address !== undefined && request.address === peripheral.address);
-                this.logEvent({ message: 'search device: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, matching: found });
-                if (!found) {
-                    return;
-                }
-                this.scanState.peripherals.set(peripheral.address, peripheral);
-                const characteristics = yield this.getCharacteristics(peripheral);
-                if (characteristics) {
-                    callback(peripheral, characteristics);
-                }
-                else {
-                    callback(null);
-                }
-                this.stopScan();
-                return;
-            }
-            else {
-                this.logEvent({ message: 'BLE scan: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, callback: callback !== undefined });
-                this.scanState.peripherals.set(peripheral.address, peripheral);
-                const { protocolFilter } = props;
-                const connector = this.peripheralCache.getConnector(p);
-                const characteristics = yield this.getCharacteristics(p);
-                if (!characteristics) {
-                    return callback(null);
-                }
-                const announcedServices = connector.getServices();
-                const services = announcedServices ? announcedServices.map(utils_1.uuid) : undefined;
-                peripheral = connector.getPeripheral();
-                const DeviceClasses = this.getAdapterFactory().getDeviceClasses(peripheral, { services }) || [];
-                const MatchingClasses = protocolFilter && DeviceClasses ? DeviceClasses.filter(C => protocolFilter.includes(C.protocol)) : DeviceClasses;
-                const DeviceClass = (0, comms_utils_1.getBestDeviceMatch)(MatchingClasses.filter(C => C.isMatching(characteristics.map(c => c.uuid))));
-                this.logEvent({ message: 'BLE scan: device connected', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), services, protocols: DeviceClasses.map(c => c.protocol), found: DeviceClass !== undefined });
-                if (!DeviceClass)
-                    return callback(null);
-                const { id, name, address } = (0, utils_1.getPeripheralInfo)(peripheral);
-                const settings = { protocol: DeviceClass.protocol, interface: 'ble', id, name: peripheral.name || name, address: peripheral.address || address };
-                callback(settings, characteristics, peripheral);
-            }
-        });
-    }
-    scanForDevice(comms, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT } = props;
-            const request = comms.getSettings();
-            const { protocol } = request;
-            const ble = this.getBinding();
-            try {
-                this.getBinding().setServerDebug(true);
-            }
-            catch (_a) { }
-            if (!this.isConnected()) {
-                yield this.connect();
-            }
-            const device = adapter_factory_1.default.getInstance().createInstance(request);
-            if (device.isConnected())
-                return device.getComms().peripheral;
-            let opStr;
-            opStr = 'search device';
-            this.logEvent({ message: 'search device request', request });
-            const wasLoggingPaused = this.loggingPaused;
-            this.resumeLogging();
-            if (this.scanState.isScanning) {
-                try {
-                    this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
-                    yield this.waitForScanFinished(timeout);
-                }
-                catch (err) {
-                    this.logEvent({ message: `${opStr} result: already scanning`, error: err.message });
-                    throw (err);
-                }
-            }
-            return new Promise((resolve, reject) => {
-                this.scanState.isScanning = true;
-                this.scanState.peripherals = new Map();
-                this.scanState.detected = [];
-                const onTimeout = () => {
-                    if (!this.scanState.isScanning || !this.scanState.timeout)
-                        return;
-                    this.scanState.timeout = null;
-                    this.logEvent({ message: `${opStr} result: timeout`, request });
-                    ble.removeAllListeners('discover');
-                    this.logEvent({ message: `${opStr}: stop scanning`, request });
-                    if (wasLoggingPaused)
-                        this.pauseLogging();
-                    ble.stopScanning(() => {
-                        this.scanState.isScanning = false;
-                        try {
-                            this.getBinding().setServerDebug(false);
-                        }
-                        catch (_a) { }
-                        reject(new Error('device not found'));
-                        return;
-                    });
-                };
-                this.logEvent({ message: `${opStr}: start scanning`, request, timeout });
-                let services = [];
-                if (protocol !== 'tacx') {
-                    services = (device.getComms().getServices()) || [];
-                }
-                ble.startScanning(services, true, (err) => {
-                    if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, request, error: err.message });
-                        this.scanState.isScanning = false;
-                        return reject(err);
-                    }
-                    ble.on('discover', (p) => {
-                        this.onPeripheralFound(p, (peripheral, characteristics) => {
-                            if (!peripheral)
-                                return reject(new Error('could not connect'));
-                            device.getComms().characteristics = characteristics;
-                            process.nextTick(() => {
-                                if (this.scanState.timeout) {
-                                    clearTimeout(this.scanState.timeout);
-                                    this.scanState.timeout = null;
-                                }
-                                this.logEvent({ message: `${opStr}: stop scanning`, request });
-                                if (wasLoggingPaused)
-                                    this.pauseLogging();
-                                ble.stopScanning(() => {
-                                    ble.removeAllListeners('discover');
-                                    this.scanState.isScanning = false;
-                                    try {
-                                        this.getBinding().setServerDebug(false);
-                                    }
-                                    catch (_a) { }
-                                    resolve(peripheral);
-                                });
-                            });
-                        }, { comms });
-                    });
-                    const cachedItem = this.peripheralCache.find(request);
-                    if (cachedItem) {
-                        this.logEvent({ message: `${opStr}: adding peripheral from cache `, peripheral: (0, utils_1.getPeripheralInfo)(cachedItem.peripheral) });
-                        ble.emit('discover', cachedItem.peripheral);
-                    }
-                });
-                this.scanState.timeout = setTimeout(onTimeout, timeout);
-            });
-        });
-    }
-    scan() {
-        return __awaiter(this, arguments, void 0, function* (props = {}) {
-            this.logEvent({ message: 'starting scan ..' });
-            this.resumeLogging();
-            const { timeout, protocol, protocols } = props;
-            const requestedProtocols = protocols || [];
-            if (protocol && !requestedProtocols.find(p => p === protocol))
-                requestedProtocols.push(protocol);
-            const protocolFilter = requestedProtocols.length > 0 ? requestedProtocols : null;
-            const services = protocolFilter === null ? this.getAdapterFactory().getAllSupportedServices() : (0, comms_utils_1.getServicesFromProtocols)(protocolFilter);
-            const ble = this.getBinding();
-            if (!ble)
-                throw new Error('no binding defined');
-            const opStr = 'scan';
-            if (this.scanState.isScanning) {
-                try {
-                    this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
-                    yield this.waitForScanFinished(timeout);
-                }
-                catch (err) {
-                    this.logEvent({ message: `${opStr} result: already scanning` });
-                    throw (err);
-                }
-            }
-            this.scanState.isScanning = true;
-            this.scanState.emitter = new events_1.default();
-            const tsStart = Date.now();
-            const tsTimeoutExpired = timeout ? tsStart + timeout : undefined;
-            yield this.scannerWaitForConnection(tsTimeoutExpired);
-            if (Date.now() > tsTimeoutExpired || !this.scanState.isScanning) {
-                return [];
-            }
-            const adjustedScanTimeout = timeout;
-            const supported = adapter_factory_1.default.getInstance().getAll().map(i => i.protocol);
-            this.logEvent({ message: 'scan start', services, supported });
-            return new Promise((resolve, reject) => {
-                this.scanState.peripherals = new Map();
-                const detected = [];
-                const requested = protocolFilter;
-                const onTimeoutOrStopped = (...args_1) => __awaiter(this, [...args_1], void 0, function* (wasTimeout = false) {
-                    if (!this.scanState.isScanning || !this.scanState.timeout)
-                        return;
-                    if (this.scanState.timeout) {
-                        clearTimeout(this.scanState.timeout);
-                        this.scanState.timeout = null;
-                    }
-                    const devices = detected.map(d => {
-                        const { id, name, address, protocol } = d;
-                        return { id, name, address, protocol };
-                    });
-                    if (wasTimeout)
-                        this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
-                    ble.removeAllListeners('discover');
-                    yield ble.stopScanning();
-                    resolve(detected);
-                    this.emittingAdapters.forEach(a => {
-                        a.comms.off('data', a.cb);
-                        a.comms.unsubscribeAll();
-                    });
-                    this.emittingAdapters = [];
-                    this.emit('scan stopped', true);
-                });
-                if (timeout)
-                    this.scanState.timeout = setTimeout(onTimeoutOrStopped, adjustedScanTimeout);
-                this.scanState.emitter.on('stop', () => {
-                    this.emit('stop-scan');
-                    onTimeoutOrStopped();
-                });
-                ble.startScanning(protocolFilter ? services : [], false, (err) => {
-                    if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, requested, error: err.message });
-                        this.scanState.isScanning = false;
-                        return reject(err);
-                    }
-                    ble.on('discover', (p) => {
-                        this.onPeripheralFound(p, (deviceSettings, characteristics, peripheral) => __awaiter(this, void 0, void 0, function* () {
-                            if (deviceSettings) {
-                                detected.push(deviceSettings);
-                                const device = this.getAdapterFactory().createInstance(deviceSettings);
-                                device.getComms().characteristics = characteristics;
-                                device.getComms().peripheral = peripheral;
-                                try {
-                                    yield device.getComms().subscribeAll();
-                                    const cb = (deviceData) => { this.emit('data', deviceSettings, deviceData); };
-                                    device.getComms().on('data', cb);
-                                    this.emittingAdapters.push({ comms: device.getComms(), cb });
-                                }
-                                catch (_a) { }
-                                this.emit('device', deviceSettings);
-                            }
-                        }), { protocolFilter });
-                    });
-                    const cachedItems = this.peripheralCache.filter(protocolFilter ? services : []);
-                    if (cachedItems && cachedItems.length > 0) {
-                        cachedItems.map(c => c.peripheral).forEach(peripheral => {
-                            this.logEvent({ message: `${opStr}: adding peripheral from cache `, peripheral: (0, utils_1.getPeripheralInfo)(peripheral) });
-                            ble.emit('discover', peripheral);
-                        });
-                    }
-                });
-            });
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping scan ..' });
-            this.pauseLogging(true);
-            if (!this.isScanning()) {
-                this.logEvent({ message: 'stopping scan done ..' });
-                return true;
-            }
-            yield new Promise(done => {
-                var _a;
-                (_a = this.scanState.emitter) === null || _a === void 0 ? void 0 : _a.emit('stop');
-                this.once('scan stopped', (res) => {
-                    done(res);
-                });
-            });
-            this.scanState.isScanning = false;
-            this.logEvent({ message: 'stopping scan done ..' });
-            return true;
-        });
-    }
-    isScanning() {
-        return this.scanState.isScanning === true;
-    }
-}
-exports.default = BleInterface;

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

@@ -1,39 +0,0 @@
-import { BleCharacteristic, BlePeripheral, IBlePeripheralConnector } from './types';
-export type ConnectorState = {
-    isConnected: boolean;
-    isConnecting: boolean;
-    isInitialized: boolean;
-    isInitializing: boolean;
-    isSubscribing: boolean;
-    subscribed?: string[];
-    connectPromise?: Promise<void>;
-};
-export default class BlePeripheralConnector implements IBlePeripheralConnector {
-    private state;
-    private services;
-    private characteristics;
-    private ble;
-    private peripheral;
-    private logger?;
-    private emitter;
-    constructor(peripheral: BlePeripheral);
-    logEvent(event: any): void;
-    connect(): Promise<void>;
-    reconnect(): Promise<void>;
-    onDisconnect(): void;
-    initialize(enforce?: boolean): Promise<boolean>;
-    isSubscribed(characteristicUuid: string): boolean;
-    subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
-    subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;
-    unsubscribeAll(): void;
-    unubscribe(c: BleCharacteristic): void;
-    onData(characteristicUuid: string, data: any): void;
-    on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
-    once(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
-    off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
-    removeAllListeners(characteristicUuid: string): void;
-    getState(): string;
-    getCharachteristics(): BleCharacteristic[];
-    getServices(): string[];
-    getPeripheral(): BlePeripheral;
-}