incyclist-devices 1.5.10 → 1.5.12

package/lib/ant/AntScanner.js

@@ -1,651 +1,651 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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) {
-        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 });
-exports.AntScanner = exports.AntProtocol = void 0;
-const gd_eventlog_1 = require("gd-eventlog");
-const protocol_1 = __importStar(require("../protocol"));
-const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));
-const pwr_adapter_1 = __importDefault(require("./antpwr/pwr-adapter"));
-const AntFEAdapter_1 = __importDefault(require("./antfe/AntFEAdapter"));
-const LOGGER_NAME = 'ANT+Scanner';
-const DEFAULT_SCAN_TIMEOUT = 30000;
-const TIMEOUT_STARTUP = 3000;
-const hex = (n, len) => {
-    const c = "0";
-    let s = n.toString(16);
-    if (s.length < len)
-        return `0x${c.repeat(len - s.length)}${s}`;
-    return `0x${s}`;
-};
-const isStickPresent = (stick, retries) => __awaiter(void 0, void 0, void 0, function* () {
-    let n = 0;
-    while (n < retries) {
-        try {
-            return stick.is_present();
-        }
-        catch (e) {
-            n++;
-            yield new Promise(resolve => setTimeout(resolve, 1000));
-        }
-    }
-    return false;
-});
-class AntProfile {
-    constructor(profile, AntScannerClass, stick, message, onNewDevice, onData) {
-        if (process.env.ANT_PROFILE_DEBUG)
-            console.log('adding profile', profile, AntScannerClass, message, onNewDevice, onData);
-        this.ids = [];
-        this.scanner = new AntScannerClass(stick);
-        this.scanner.on(message, data => {
-            try {
-                if (process.env.ANT_PROFILE_DEBUG)
-                    console.log(data);
-                if (data.DeviceID) {
-                    if (this.ids.find(id => id === data.DeviceID)) {
-                        if (onData)
-                            onData(profile, data.DeviceID, data);
-                        return;
-                    }
-                    this.ids.push(data.DeviceID);
-                    if (onNewDevice)
-                        onNewDevice(profile, data.DeviceID);
-                }
-            }
-            catch (err) {
-            }
-        });
-    }
-    getScanner() {
-        return this.scanner;
-    }
-    getProfile() {
-        return this.profile;
-    }
-}
-class AntProtocol extends protocol_1.default {
-    constructor(antClass) {
-        super();
-        this.logger = new gd_eventlog_1.EventLogger(LOGGER_NAME);
-        this.ant = antClass;
-        this.activeScans = {};
-        this.sensors = {};
-        this.sticks = [];
-        this.scanning = false;
-        this.profiles = [
-            { name: 'Heartrate Monitor', Adapter: AntHrmAdapter_1.default },
-            { name: 'Smart Trainer', Adapter: AntFEAdapter_1.default },
-            { name: 'Power Meter', Adapter: pwr_adapter_1.default }
-        ];
-    }
-    add(settings) {
-        this.logger.logEvent({ message: 'adding device', settings });
-        const { profile, deviceID, port } = settings;
-        const profileInfo = this.profiles.find(i => i.name === profile);
-        if (profileInfo) {
-            let device;
-            try {
-                device = new profileInfo.Adapter(deviceID, port, undefined, this);
-                this.devices.push(device);
-                return device;
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'adding device error', error: err.message });
-                return;
-            }
-        }
-        this.logger.logEvent({ message: 'adding device: profile not found' });
-    }
-    getAnt() {
-        return this.ant || protocol_1.default.getAnt();
-    }
-    getName() { return 'Ant'; }
-    getInterfaces() { return [protocol_1.INTERFACE.ANT]; }
-    isBike() { return true; }
-    isHrm() { return true; }
-    isPower() { return true; }
-    isScanning() { return Object.keys(this.activeScans).length > 0; }
-    getSupportedProfiles() {
-        return this.profiles.map(i => i.name);
-    }
-    getUSBDeviceInfo(d) {
-        if (!d)
-            return;
-        return ({
-            port: `usb:${d.busNumber}-${d.deviceAddress}`,
-            vendor: d.deviceDescriptor.idVendor,
-            product: d.deviceDescriptor.idProduct,
-            inUse: d.inUse
-        });
-    }
-    getStickInfo(sticks) {
-        const isStick = i => {
-            return (i && i.vendor === 0x0FCF && (i.product === 0x1008 || i.product === 0x1009));
-        };
-        const inUse = i => i && i.inUse;
-        return sticks
-            .map(d => this.getUSBDeviceInfo(d))
-            .reduce((r, i) => r + `${r === '' ? '' : ','}[${i.port} ${hex(i.vendor, 4)} ${hex(i.product, 4)}${isStick(i) ? '*' : ''}${inUse(i) ? 'x' : ''}]`, '');
-    }
-    findStickByPort(port) {
-        const info = this.sticks.find(i => i.port === port);
-        if (info)
-            return info.stick;
-    }
-    logStickInfo() {
-        const sticks = this.ant.getSticks();
-        const info = this.getStickInfo(sticks);
-        this.logger.logEvent({ message: 'stick info', info });
-    }
-    getDetailedStickInfo(stick) {
-        const devices = stick.getDevices();
-        if (devices.length > 0) {
-            const device = devices[0];
-            try {
-                const config = JSON.parse(JSON.stringify(device.configDescriptor));
-                const interfaces = config ? config.interfaces : [];
-                delete config.interfaces;
-                this.logger.logEvent({ message: 'USB DeviceConfig', config, interfaces });
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'USB Error', error: err.message });
-            }
-        }
-    }
-    getStick(onStart, onError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.ant)
-                return;
-            const startupAttempt = (stick, name) => {
-                return new Promise((resolve, reject) => {
-                    this.logger.logEvent({ message: `${name} startup attempt` });
-                    if (stick.scanConnected) {
-                        onStart(this);
-                        resolve(stick);
-                        return;
-                    }
-                    if (isStickPresent(stick, 2)) {
-                        stick.on('error', (err) => {
-                            this.logger.logEvent({ message: `${name} startup error`, error: err.message });
-                            onError(err.message);
-                        });
-                        stick.on('startup', () => {
-                            if (stick.scanConnected)
-                                return;
-                            this.logger.logEvent({ message: `${name} startup completed` });
-                            stick.scanConnected = true;
-                            onStart(stick);
-                            resolve(stick);
-                        });
-                        const devices = stick.getDevices();
-                        if (devices && devices.length > 0) {
-                            devices.forEach(d => {
-                                d.closeFn = d.close;
-                                d.close = () => { };
-                            });
-                        }
-                        else {
-                            this.logger.logEvent({ message: `${name} startup failed: no devices ` });
-                            resolve(null);
-                        }
-                        this.getDetailedStickInfo(stick);
-                        let open = false;
-                        try {
-                            open = stick.open();
-                            if (open) {
-                                this.logger.logEvent({ message: `found ${name}` });
-                                const timeoutStartup = Date.now() + TIMEOUT_STARTUP;
-                                const iv = setInterval(() => {
-                                    if (!stick.scanConnected && Date.now() > timeoutStartup) {
-                                        clearInterval(iv);
-                                        this.logger.logEvent({ message: `${name} startup timeout` });
-                                    }
-                                    if (stick.scanConnected)
-                                        clearInterval(iv);
-                                }, 100);
-                                return stick;
-                            }
-                        }
-                        catch (openErr) {
-                            this.logger.logEvent({ message: 'Open Error', error: openErr.message });
-                        }
-                        if (devices && devices.length > 0) {
-                            devices.forEach(d => {
-                                d.close = d.closeFn;
-                            });
-                        }
-                        if (!open) {
-                            while (devices.length) {
-                                let device;
-                                try {
-                                    device = devices.shift();
-                                    device.open();
-                                    const iface = device.interfaces[0];
-                                    let kernelDriverActive = undefined;
-                                    let claimRequested = false;
-                                    try {
-                                        kernelDriverActive = iface.isKernelDriverActive();
-                                        if (kernelDriverActive) {
-                                            iface.detachKernelDriver();
-                                        }
-                                        claimRequested = true;
-                                        iface.claim();
-                                    }
-                                    catch (kernelErr) {
-                                        this.logger.logEvent({ message: 'Kernel Error', error: kernelErr.message, kernelDriverActive, claimRequested });
-                                    }
-                                    break;
-                                }
-                                catch (deviceErr) {
-                                    this.logger.logEvent({ message: 'Device Error', error: deviceErr.message });
-                                    if (device) {
-                                        try {
-                                            device.close();
-                                        }
-                                        catch (_a) { }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    this.logger.logEvent({ message: `${name} startup failed: no stick present` });
-                    resolve(null);
-                });
-            };
-            let stick = undefined;
-            stick = yield startupAttempt(new this.ant.GarminStick2(), 'GarminStick2');
-            if (!stick)
-                stick = yield startupAttempt(new this.ant.GarminStick3(), 'GarminStick3');
-            if (!stick)
-                onError('No stick found');
-            else
-                return stick;
-        });
-    }
-    getFirstStick() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (!this.ant)
-                    return reject(new Error('Ant not supported'));
-                if (this.sticks && this.sticks.length > 0 && this.sticks[0].connected) {
-                    this.logger.logEvent({ message: 'stick already connected' });
-                    return resolve(this.sticks[0]);
-                }
-                try {
-                    let start = Date.now();
-                    let timeout = start + 5000;
-                    let found = false;
-                    const iv = setInterval(() => {
-                        if (!found && Date.now() > timeout) {
-                            clearInterval(iv);
-                            reject(new Error('timeout'));
-                        }
-                    }, 100);
-                    this.getStick((stick) => {
-                        clearInterval(iv);
-                        const port = this.getUSBDeviceInfo(stick.device).port;
-                        if (!this.sticks.find(i => i.port === port)) {
-                            this.sticks.push({ port, stick, connected: true });
-                        }
-                        resolve({ port, stick });
-                    }, (reason) => {
-                        resolve(undefined);
-                    });
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'getFirstStick error', error: err.message, stack: err.stack });
-                }
-            }));
-        });
-    }
-    closeStick(stick) {
-        this.logger.logEvent({ message: 'closing stick' });
-        return new Promise((resolve, reject) => {
-            stick.on('shutdown', () => {
-                this.logger.logEvent({ message: 'stick shutdown' });
-                stick.removeAllListeners('shutdown');
-                const port = this.getUSBDeviceInfo(stick.device).port;
-                const idx = this.sticks.findIndex(i => i.port === port);
-                if (idx !== -1) {
-                    this.sticks[idx].connected = false;
-                }
-                this.sensors = {};
-                resolve(true);
-            });
-            try {
-                stick.detach_all();
-                setTimeout(() => {
-                    try {
-                        stick.close();
-                    }
-                    catch (err) { }
-                    this.logger.logEvent({ message: 'stick closed' });
-                    stick.scanConnected = false;
-                    this.sensors = {};
-                }, 1000);
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    stopScanOnStick(stickInfo) {
-        const { stick, port } = stickInfo;
-        const state = this.activeScans[port];
-        return this.closeStick(stick)
-            .then(() => {
-            state.isScanning = false;
-            this.scanning = this.stillScanning();
-            if (state.iv) {
-                clearInterval(state.iv);
-                state.iv = undefined;
-            }
-            return true;
-        })
-            .catch(err => {
-            this.logger.logEvent({ message: 'error on closing stick', error: err.message, port });
-            return true;
-        });
-    }
-    stillScanning() {
-        const ports = Object.keys(this.activeScans);
-        return ports.find(p => this.activeScans[p].isScanning) !== undefined;
-    }
-    scanOnStick(stickInfo, props = {}) {
-        const { stick, port } = stickInfo;
-        const timeout = props.timeout || DEFAULT_SCAN_TIMEOUT;
-        const { onDeviceFound, onScanFinished, onUpdate, id } = props;
-        this.logger.logEvent({ message: 'stick scan request', port, activeScans: this.activeScans });
-        if (process.env.ANT_DEBUG) {
-            stick.props = { debug: true };
-        }
-        return new Promise((resolve, reject) => {
-            if (!port)
-                return reject(new Error('busy'));
-            if (this.activeScans[port] && this.activeScans[port].isScanning)
-                return reject(new Error('busy'));
-            if (!this.activeScans[port]) {
-                this.activeScans[port] = { isScanning: false, stick };
-            }
-            const state = this.activeScans[port];
-            if (state.isScanning)
-                return reject(new Error('busy'));
-            state.isScanning = true;
-            this.logger.logEvent({ message: 'start scan', port });
-            state.timeout = Date.now() + timeout;
-            const onNewDevice = (profile, deviceId) => {
-                this.logger.logEvent({ message: 'found device', profile, id: deviceId });
-                const profileInfo = this.profiles.find(i => i.name === profile);
-                if (profileInfo) {
-                    let device;
-                    try {
-                        device = new profileInfo.Adapter(deviceId, port, stick, this, props);
-                        const existing = this.devices.find(d => (d.getID() === deviceId && d.getProfile() === profile));
-                        if (!existing)
-                            this.devices.push(device);
-                    }
-                    catch (err) {
-                        this.logger.logEvent({ message: 'onNewDevice:ERROR', error: err.message });
-                    }
-                    if (device && onDeviceFound) {
-                        onDeviceFound(device, this);
-                        device.setDetected(true);
-                    }
-                }
-            };
-            const onData = (profile, deviceId, data) => {
-                const device = this.devices.find(d => d.getID() === deviceId);
-                if (device) {
-                    const isHrm = device.isHrm();
-                    device.onDeviceData(data);
-                    if (device.isHrm() && !isHrm && onDeviceFound) {
-                        onDeviceFound(device, this);
-                    }
-                    if (onUpdate)
-                        onUpdate(device);
-                }
-            };
-            const hrm = new AntProfile('Heartrate Monitor', this.ant.HeartRateScanner, stick, 'hbData', onNewDevice, onData);
-            const fe = new AntProfile('Smart Trainer', this.ant.FitnessEquipmentScanner, stick, 'fitnessData', onNewDevice, onData);
-            const power = new AntProfile('Power Meter', this.ant.BicyclePowerScanner, stick, 'powerData', onNewDevice, onData);
-            try {
-                hrm.getScanner().scan();
-                hrm.getScanner().on('attached', () => {
-                    power.getScanner().scan();
-                    fe.getScanner().scan();
-                });
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'scan error', error: err.message });
-            }
-            state.iv = setInterval(() => {
-                if (Date.now() > timeout) {
-                    this.logger.logEvent({ message: 'scan timeout', port });
-                    this.stopScanOnStick(stickInfo).then(() => {
-                        if (onScanFinished)
-                            onScanFinished(id);
-                        resolve(true);
-                    });
-                }
-            }, timeout);
-        });
-    }
-    scan(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'scan request', props });
-            this.scanning = true;
-            this.logStickInfo();
-            if (this.sensors && this.sensors.stick && this.sensors.stickOpen) {
-                try {
-                    yield this.closeStick(this.sensors.stick);
-                    this.sensors = {};
-                    this.devices = [];
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'error on closing stick', error: err.message });
-                }
-            }
-            try {
-                const stick = yield this.getFirstStick();
-                if (!stick) {
-                    this.logger.logEvent({ message: 'no stick found' });
-                    return;
-                }
-                this.scanOnStick(stick, props);
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'scan request error', error: err.message });
-            }
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const activePorts = Object.keys(this.activeScans);
-            for (let i = 0; i < activePorts.length; i++) {
-                const port = activePorts[i];
-                const scanState = this.activeScans[port];
-                if (scanState.isScanning) {
-                    yield this.stopScanOnStick({ port, stick: scanState.stick });
-                }
-            }
-            this.sensors = {};
-            this.logger.logEvent({ message: 'scan stopped' });
-            this.scanning = false;
-            return true;
-        });
-    }
-    waitForStickOpenedForSensor() {
-        return new Promise((resolve, reject) => {
-            const iv = setInterval(() => {
-                if (!this.sensors.stickOpening && !this.scanning) {
-                    clearInterval(iv);
-                    resolve(true);
-                }
-            }, 100);
-        });
-    }
-    attachSensors(d, SensorClass, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (d === undefined) {
-                    resolve(false);
-                    return;
-                }
-                const devices = Array.isArray(d) ? d : [d];
-                if (devices.length === 0) {
-                    return resolve(false);
-                }
-                this.logger.logEvent({ message: 'attachSensors', names: Array.isArray(d) ? d.map(dd => dd.getName()) : d.getName(), state: this.sensors });
-                if (this.sensors.stickOpening || this.scanning) {
-                    yield this.waitForStickOpenedForSensor();
-                }
-                this.sensors.stickOpening = true;
-                let stick;
-                if (!this.sensors.stick) {
-                    this.logger.logEvent({ message: 'openStick', device: devices[0].getName() });
-                    let retryCnt = 0;
-                    while (!stick && retryCnt < 3) {
-                        try {
-                            const stickInfo = yield this.getFirstStick();
-                            if (stickInfo && stickInfo.stick) {
-                                this.logger.logEvent({ message: 'stick opened', device: devices[0].getName() });
-                                stick = stickInfo.stick;
-                                this.sensors.stick = stick;
-                                this.sensors.stickOpen = true;
-                                this.sensors.stickStarted = true;
-                                this.sensors.stickOpening = false;
-                            }
-                            else {
-                                retryCnt++;
-                            }
-                        }
-                        catch (err) {
-                            retryCnt++;
-                            this.logger.logEvent({ message: 'stick open error', error: err.message, device: devices[0].getName() });
-                        }
-                    }
-                    if (!stick) {
-                        return reject(new Error('could not pen stick'));
-                    }
-                }
-                if (this.sensors.stickOpen) {
-                    if (!this.sensors.pending)
-                        this.sensors.pending = [];
-                    devices.forEach(device => {
-                        const sensor = new SensorClass(this.sensors.stick);
-                        device.setSensor(sensor);
-                        device.setStick(stick);
-                        sensor.on(message, (data) => { device.onDeviceData(data); });
-                        sensor.on('eventData', (data) => { device.onDeviceEvent(data); });
-                        sensor.once('attached', () => { device.onAttached(); });
-                        this.sensors.pending.push({ device, sensor, message });
-                    });
-                }
-                const attachFromPending = () => {
-                    if (!this.sensors.attached)
-                        this.sensors.attached = [];
-                    const channelsUsed = this.sensors.attached.length;
-                    try {
-                        this.sensors.pending.forEach((i, idx) => {
-                            const channel = channelsUsed + idx;
-                            const { sensor } = i;
-                            i.device.setChannel(channel);
-                            sensor.attach(channel, i.device.getID());
-                            this.sensors.attached.push(i);
-                        });
-                        this.sensors.pending = [];
-                        resolve(true);
-                    }
-                    catch (err) {
-                        this.logger.logEvent({ message: 'error', fn: 'attachFromPending()', error: err.message || err });
-                        reject(err.message ? err : new Error(err));
-                    }
-                };
-                if (this.sensors.stickStarted) {
-                    attachFromPending();
-                }
-                else {
-                    const sensors = this.sensors;
-                    const stick = this.sensors.stick;
-                    stick.on('error', (err) => {
-                        this.logger.logEvent({ message: 'stick error', error: err.message });
-                    });
-                    stick.once('startup', () => {
-                        sensors.stickStarted = true;
-                        setTimeout(attachFromPending, 1000);
-                    });
-                }
-            }));
-        });
-    }
-    detachSensor(adapter) {
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            const idx = (this.sensors && this.sensors.attached) ?
-                this.sensors.attached.findIndex(i => (i.device.getID() === adapter.getID() && i.device.getName() === adapter.getName())) : -1;
-            if (idx === -1)
-                return resolve(true);
-            this.sensors.attached.splice(idx, 1);
-            if (this.sensors.attached.length > 0)
-                return resolve(true);
-            const stick = this.sensors.stick;
-            if (stick === undefined)
-                return resolve(false);
-            try {
-                yield this.closeStick(stick);
-                resolve(true);
-            }
-            catch (err) {
-                reject(err);
-            }
-        }));
-    }
-    closeSensor(device) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stick = this.findStickByPort(device.getPort());
-            if (stick.inUse) {
-                try {
-                    stick.close();
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'closeSensor error', error: err.message, device: device ? device.getName() : 'unknown' });
-                }
-            }
-        });
-    }
-}
-exports.AntProtocol = AntProtocol;
-let _scanner = undefined;
-function AntScanner(antClass) {
-    const scanner = _scanner || new AntProtocol(antClass);
-    return scanner;
-}
-exports.AntScanner = AntScanner;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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) {
+        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 });
+exports.AntScanner = exports.AntProtocol = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const protocol_1 = __importStar(require("../protocol"));
+const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));
+const pwr_adapter_1 = __importDefault(require("./antpwr/pwr-adapter"));
+const AntFEAdapter_1 = __importDefault(require("./antfe/AntFEAdapter"));
+const LOGGER_NAME = 'ANT+Scanner';
+const DEFAULT_SCAN_TIMEOUT = 30000;
+const TIMEOUT_STARTUP = 3000;
+const hex = (n, len) => {
+    const c = "0";
+    let s = n.toString(16);
+    if (s.length < len)
+        return `0x${c.repeat(len - s.length)}${s}`;
+    return `0x${s}`;
+};
+const isStickPresent = (stick, retries) => __awaiter(void 0, void 0, void 0, function* () {
+    let n = 0;
+    while (n < retries) {
+        try {
+            return stick.is_present();
+        }
+        catch (e) {
+            n++;
+            yield new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    }
+    return false;
+});
+class AntProfile {
+    constructor(profile, AntScannerClass, stick, message, onNewDevice, onData) {
+        if (process.env.ANT_PROFILE_DEBUG)
+            console.log('adding profile', profile, AntScannerClass, message, onNewDevice, onData);
+        this.ids = [];
+        this.scanner = new AntScannerClass(stick);
+        this.scanner.on(message, data => {
+            try {
+                if (process.env.ANT_PROFILE_DEBUG)
+                    console.log(data);
+                if (data.DeviceID) {
+                    if (this.ids.find(id => id === data.DeviceID)) {
+                        if (onData)
+                            onData(profile, data.DeviceID, data);
+                        return;
+                    }
+                    this.ids.push(data.DeviceID);
+                    if (onNewDevice)
+                        onNewDevice(profile, data.DeviceID);
+                }
+            }
+            catch (err) {
+            }
+        });
+    }
+    getScanner() {
+        return this.scanner;
+    }
+    getProfile() {
+        return this.profile;
+    }
+}
+class AntProtocol extends protocol_1.default {
+    constructor(antClass) {
+        super();
+        this.logger = new gd_eventlog_1.EventLogger(LOGGER_NAME);
+        this.ant = antClass;
+        this.activeScans = {};
+        this.sensors = {};
+        this.sticks = [];
+        this.scanning = false;
+        this.profiles = [
+            { name: 'Heartrate Monitor', Adapter: AntHrmAdapter_1.default },
+            { name: 'Smart Trainer', Adapter: AntFEAdapter_1.default },
+            { name: 'Power Meter', Adapter: pwr_adapter_1.default }
+        ];
+    }
+    add(settings) {
+        this.logger.logEvent({ message: 'adding device', settings });
+        const { profile, deviceID, port } = settings;
+        const profileInfo = this.profiles.find(i => i.name === profile);
+        if (profileInfo) {
+            let device;
+            try {
+                device = new profileInfo.Adapter(deviceID, port, undefined, this);
+                this.devices.push(device);
+                return device;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'adding device error', error: err.message });
+                return;
+            }
+        }
+        this.logger.logEvent({ message: 'adding device: profile not found' });
+    }
+    getAnt() {
+        return this.ant || protocol_1.default.getAnt();
+    }
+    getName() { return 'Ant'; }
+    getInterfaces() { return [protocol_1.INTERFACE.ANT]; }
+    isBike() { return true; }
+    isHrm() { return true; }
+    isPower() { return true; }
+    isScanning() { return Object.keys(this.activeScans).length > 0; }
+    getSupportedProfiles() {
+        return this.profiles.map(i => i.name);
+    }
+    getUSBDeviceInfo(d) {
+        if (!d)
+            return;
+        return ({
+            port: `usb:${d.busNumber}-${d.deviceAddress}`,
+            vendor: d.deviceDescriptor.idVendor,
+            product: d.deviceDescriptor.idProduct,
+            inUse: d.inUse
+        });
+    }
+    getStickInfo(sticks) {
+        const isStick = i => {
+            return (i && i.vendor === 0x0FCF && (i.product === 0x1008 || i.product === 0x1009));
+        };
+        const inUse = i => i && i.inUse;
+        return sticks
+            .map(d => this.getUSBDeviceInfo(d))
+            .reduce((r, i) => r + `${r === '' ? '' : ','}[${i.port} ${hex(i.vendor, 4)} ${hex(i.product, 4)}${isStick(i) ? '*' : ''}${inUse(i) ? 'x' : ''}]`, '');
+    }
+    findStickByPort(port) {
+        const info = this.sticks.find(i => i.port === port);
+        if (info)
+            return info.stick;
+    }
+    logStickInfo() {
+        const sticks = this.ant.getSticks();
+        const info = this.getStickInfo(sticks);
+        this.logger.logEvent({ message: 'stick info', info });
+    }
+    getDetailedStickInfo(stick) {
+        const devices = stick.getDevices();
+        if (devices.length > 0) {
+            const device = devices[0];
+            try {
+                const config = JSON.parse(JSON.stringify(device.configDescriptor));
+                const interfaces = config ? config.interfaces : [];
+                delete config.interfaces;
+                this.logger.logEvent({ message: 'USB DeviceConfig', config, interfaces });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'USB Error', error: err.message });
+            }
+        }
+    }
+    getStick(onStart, onError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.ant)
+                return;
+            const startupAttempt = (stick, name) => {
+                return new Promise((resolve, reject) => {
+                    this.logger.logEvent({ message: `${name} startup attempt` });
+                    if (stick.scanConnected) {
+                        onStart(this);
+                        resolve(stick);
+                        return;
+                    }
+                    if (isStickPresent(stick, 2)) {
+                        stick.on('error', (err) => {
+                            this.logger.logEvent({ message: `${name} startup error`, error: err.message });
+                            onError(err.message);
+                        });
+                        stick.on('startup', () => {
+                            if (stick.scanConnected)
+                                return;
+                            this.logger.logEvent({ message: `${name} startup completed` });
+                            stick.scanConnected = true;
+                            onStart(stick);
+                            resolve(stick);
+                        });
+                        const devices = stick.getDevices();
+                        if (devices && devices.length > 0) {
+                            devices.forEach(d => {
+                                d.closeFn = d.close;
+                                d.close = () => { };
+                            });
+                        }
+                        else {
+                            this.logger.logEvent({ message: `${name} startup failed: no devices ` });
+                            resolve(null);
+                        }
+                        this.getDetailedStickInfo(stick);
+                        let open = false;
+                        try {
+                            open = stick.open();
+                            if (open) {
+                                this.logger.logEvent({ message: `found ${name}` });
+                                const timeoutStartup = Date.now() + TIMEOUT_STARTUP;
+                                const iv = setInterval(() => {
+                                    if (!stick.scanConnected && Date.now() > timeoutStartup) {
+                                        clearInterval(iv);
+                                        this.logger.logEvent({ message: `${name} startup timeout` });
+                                    }
+                                    if (stick.scanConnected)
+                                        clearInterval(iv);
+                                }, 100);
+                                return stick;
+                            }
+                        }
+                        catch (openErr) {
+                            this.logger.logEvent({ message: 'Open Error', error: openErr.message });
+                        }
+                        if (devices && devices.length > 0) {
+                            devices.forEach(d => {
+                                d.close = d.closeFn;
+                            });
+                        }
+                        if (!open) {
+                            while (devices.length) {
+                                let device;
+                                try {
+                                    device = devices.shift();
+                                    device.open();
+                                    const iface = device.interfaces[0];
+                                    let kernelDriverActive = undefined;
+                                    let claimRequested = false;
+                                    try {
+                                        kernelDriverActive = iface.isKernelDriverActive();
+                                        if (kernelDriverActive) {
+                                            iface.detachKernelDriver();
+                                        }
+                                        claimRequested = true;
+                                        iface.claim();
+                                    }
+                                    catch (kernelErr) {
+                                        this.logger.logEvent({ message: 'Kernel Error', error: kernelErr.message, kernelDriverActive, claimRequested });
+                                    }
+                                    break;
+                                }
+                                catch (deviceErr) {
+                                    this.logger.logEvent({ message: 'Device Error', error: deviceErr.message });
+                                    if (device) {
+                                        try {
+                                            device.close();
+                                        }
+                                        catch (_a) { }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    this.logger.logEvent({ message: `${name} startup failed: no stick present` });
+                    resolve(null);
+                });
+            };
+            let stick = undefined;
+            stick = yield startupAttempt(new this.ant.GarminStick2(), 'GarminStick2');
+            if (!stick)
+                stick = yield startupAttempt(new this.ant.GarminStick3(), 'GarminStick3');
+            if (!stick)
+                onError('No stick found');
+            else
+                return stick;
+        });
+    }
+    getFirstStick() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.ant)
+                    return reject(new Error('Ant not supported'));
+                if (this.sticks && this.sticks.length > 0 && this.sticks[0].connected) {
+                    this.logger.logEvent({ message: 'stick already connected' });
+                    return resolve(this.sticks[0]);
+                }
+                try {
+                    let start = Date.now();
+                    let timeout = start + 5000;
+                    let found = false;
+                    const iv = setInterval(() => {
+                        if (!found && Date.now() > timeout) {
+                            clearInterval(iv);
+                            reject(new Error('timeout'));
+                        }
+                    }, 100);
+                    this.getStick((stick) => {
+                        clearInterval(iv);
+                        const port = this.getUSBDeviceInfo(stick.device).port;
+                        if (!this.sticks.find(i => i.port === port)) {
+                            this.sticks.push({ port, stick, connected: true });
+                        }
+                        resolve({ port, stick });
+                    }, (reason) => {
+                        resolve(undefined);
+                    });
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'getFirstStick error', error: err.message, stack: err.stack });
+                }
+            }));
+        });
+    }
+    closeStick(stick) {
+        this.logger.logEvent({ message: 'closing stick' });
+        return new Promise((resolve, reject) => {
+            stick.on('shutdown', () => {
+                this.logger.logEvent({ message: 'stick shutdown' });
+                stick.removeAllListeners('shutdown');
+                const port = this.getUSBDeviceInfo(stick.device).port;
+                const idx = this.sticks.findIndex(i => i.port === port);
+                if (idx !== -1) {
+                    this.sticks[idx].connected = false;
+                }
+                this.sensors = {};
+                resolve(true);
+            });
+            try {
+                stick.detach_all();
+                setTimeout(() => {
+                    try {
+                        stick.close();
+                    }
+                    catch (err) { }
+                    this.logger.logEvent({ message: 'stick closed' });
+                    stick.scanConnected = false;
+                    this.sensors = {};
+                }, 1000);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    stopScanOnStick(stickInfo) {
+        const { stick, port } = stickInfo;
+        const state = this.activeScans[port];
+        return this.closeStick(stick)
+            .then(() => {
+            state.isScanning = false;
+            this.scanning = this.stillScanning();
+            if (state.iv) {
+                clearInterval(state.iv);
+                state.iv = undefined;
+            }
+            return true;
+        })
+            .catch(err => {
+            this.logger.logEvent({ message: 'error on closing stick', error: err.message, port });
+            return true;
+        });
+    }
+    stillScanning() {
+        const ports = Object.keys(this.activeScans);
+        return ports.find(p => this.activeScans[p].isScanning) !== undefined;
+    }
+    scanOnStick(stickInfo, props = {}) {
+        const { stick, port } = stickInfo;
+        const timeout = props.timeout || DEFAULT_SCAN_TIMEOUT;
+        const { onDeviceFound, onScanFinished, onUpdate, id } = props;
+        this.logger.logEvent({ message: 'stick scan request', port, activeScans: this.activeScans });
+        if (process.env.ANT_DEBUG) {
+            stick.props = { debug: true };
+        }
+        return new Promise((resolve, reject) => {
+            if (!port)
+                return reject(new Error('busy'));
+            if (this.activeScans[port] && this.activeScans[port].isScanning)
+                return reject(new Error('busy'));
+            if (!this.activeScans[port]) {
+                this.activeScans[port] = { isScanning: false, stick };
+            }
+            const state = this.activeScans[port];
+            if (state.isScanning)
+                return reject(new Error('busy'));
+            state.isScanning = true;
+            this.logger.logEvent({ message: 'start scan', port });
+            state.timeout = Date.now() + timeout;
+            const onNewDevice = (profile, deviceId) => {
+                this.logger.logEvent({ message: 'found device', profile, id: deviceId });
+                const profileInfo = this.profiles.find(i => i.name === profile);
+                if (profileInfo) {
+                    let device;
+                    try {
+                        device = new profileInfo.Adapter(deviceId, port, stick, this, props);
+                        const existing = this.devices.find(d => (d.getID() === deviceId && d.getProfile() === profile));
+                        if (!existing)
+                            this.devices.push(device);
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'onNewDevice:ERROR', error: err.message });
+                    }
+                    if (device && onDeviceFound) {
+                        onDeviceFound(device, this);
+                        device.setDetected(true);
+                    }
+                }
+            };
+            const onData = (profile, deviceId, data) => {
+                const device = this.devices.find(d => d.getID() === deviceId);
+                if (device) {
+                    const isHrm = device.isHrm();
+                    device.onDeviceData(data);
+                    if (device.isHrm() && !isHrm && onDeviceFound) {
+                        onDeviceFound(device, this);
+                    }
+                    if (onUpdate)
+                        onUpdate(device);
+                }
+            };
+            const hrm = new AntProfile('Heartrate Monitor', this.ant.HeartRateScanner, stick, 'hbData', onNewDevice, onData);
+            const fe = new AntProfile('Smart Trainer', this.ant.FitnessEquipmentScanner, stick, 'fitnessData', onNewDevice, onData);
+            const power = new AntProfile('Power Meter', this.ant.BicyclePowerScanner, stick, 'powerData', onNewDevice, onData);
+            try {
+                hrm.getScanner().scan();
+                hrm.getScanner().on('attached', () => {
+                    power.getScanner().scan();
+                    fe.getScanner().scan();
+                });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scan error', error: err.message });
+            }
+            state.iv = setInterval(() => {
+                if (Date.now() > timeout) {
+                    this.logger.logEvent({ message: 'scan timeout', port });
+                    this.stopScanOnStick(stickInfo).then(() => {
+                        if (onScanFinished)
+                            onScanFinished(id);
+                        resolve(true);
+                    });
+                }
+            }, timeout);
+        });
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'scan request', props });
+            this.scanning = true;
+            this.logStickInfo();
+            if (this.sensors && this.sensors.stick && this.sensors.stickOpen) {
+                try {
+                    yield this.closeStick(this.sensors.stick);
+                    this.sensors = {};
+                    this.devices = [];
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'error on closing stick', error: err.message });
+                }
+            }
+            try {
+                const stick = yield this.getFirstStick();
+                if (!stick) {
+                    this.logger.logEvent({ message: 'no stick found' });
+                    return;
+                }
+                this.scanOnStick(stick, props);
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scan request error', error: err.message });
+            }
+        });
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activePorts = Object.keys(this.activeScans);
+            for (let i = 0; i < activePorts.length; i++) {
+                const port = activePorts[i];
+                const scanState = this.activeScans[port];
+                if (scanState.isScanning) {
+                    yield this.stopScanOnStick({ port, stick: scanState.stick });
+                }
+            }
+            this.sensors = {};
+            this.logger.logEvent({ message: 'scan stopped' });
+            this.scanning = false;
+            return true;
+        });
+    }
+    waitForStickOpenedForSensor() {
+        return new Promise((resolve, reject) => {
+            const iv = setInterval(() => {
+                if (!this.sensors.stickOpening && !this.scanning) {
+                    clearInterval(iv);
+                    resolve(true);
+                }
+            }, 100);
+        });
+    }
+    attachSensors(d, SensorClass, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (d === undefined) {
+                    resolve(false);
+                    return;
+                }
+                const devices = Array.isArray(d) ? d : [d];
+                if (devices.length === 0) {
+                    return resolve(false);
+                }
+                this.logger.logEvent({ message: 'attachSensors', names: Array.isArray(d) ? d.map(dd => dd.getName()) : d.getName(), state: this.sensors });
+                if (this.sensors.stickOpening || this.scanning) {
+                    yield this.waitForStickOpenedForSensor();
+                }
+                this.sensors.stickOpening = true;
+                let stick;
+                if (!this.sensors.stick) {
+                    this.logger.logEvent({ message: 'openStick', device: devices[0].getName() });
+                    let retryCnt = 0;
+                    while (!stick && retryCnt < 3) {
+                        try {
+                            const stickInfo = yield this.getFirstStick();
+                            if (stickInfo && stickInfo.stick) {
+                                this.logger.logEvent({ message: 'stick opened', device: devices[0].getName() });
+                                stick = stickInfo.stick;
+                                this.sensors.stick = stick;
+                                this.sensors.stickOpen = true;
+                                this.sensors.stickStarted = true;
+                                this.sensors.stickOpening = false;
+                            }
+                            else {
+                                retryCnt++;
+                            }
+                        }
+                        catch (err) {
+                            retryCnt++;
+                            this.logger.logEvent({ message: 'stick open error', error: err.message, device: devices[0].getName() });
+                        }
+                    }
+                    if (!stick) {
+                        return reject(new Error('could not pen stick'));
+                    }
+                }
+                if (this.sensors.stickOpen) {
+                    if (!this.sensors.pending)
+                        this.sensors.pending = [];
+                    devices.forEach(device => {
+                        const sensor = new SensorClass(this.sensors.stick);
+                        device.setSensor(sensor);
+                        device.setStick(stick);
+                        sensor.on(message, (data) => { device.onDeviceData(data); });
+                        sensor.on('eventData', (data) => { device.onDeviceEvent(data); });
+                        sensor.once('attached', () => { device.onAttached(); });
+                        this.sensors.pending.push({ device, sensor, message });
+                    });
+                }
+                const attachFromPending = () => {
+                    if (!this.sensors.attached)
+                        this.sensors.attached = [];
+                    const channelsUsed = this.sensors.attached.length;
+                    try {
+                        this.sensors.pending.forEach((i, idx) => {
+                            const channel = channelsUsed + idx;
+                            const { sensor } = i;
+                            i.device.setChannel(channel);
+                            sensor.attach(channel, i.device.getID());
+                            this.sensors.attached.push(i);
+                        });
+                        this.sensors.pending = [];
+                        resolve(true);
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'error', fn: 'attachFromPending()', error: err.message || err });
+                        reject(err.message ? err : new Error(err));
+                    }
+                };
+                if (this.sensors.stickStarted) {
+                    attachFromPending();
+                }
+                else {
+                    const sensors = this.sensors;
+                    const stick = this.sensors.stick;
+                    stick.on('error', (err) => {
+                        this.logger.logEvent({ message: 'stick error', error: err.message });
+                    });
+                    stick.once('startup', () => {
+                        sensors.stickStarted = true;
+                        setTimeout(attachFromPending, 1000);
+                    });
+                }
+            }));
+        });
+    }
+    detachSensor(adapter) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const idx = (this.sensors && this.sensors.attached) ?
+                this.sensors.attached.findIndex(i => (i.device.getID() === adapter.getID() && i.device.getName() === adapter.getName())) : -1;
+            if (idx === -1)
+                return resolve(true);
+            this.sensors.attached.splice(idx, 1);
+            if (this.sensors.attached.length > 0)
+                return resolve(true);
+            const stick = this.sensors.stick;
+            if (stick === undefined)
+                return resolve(false);
+            try {
+                yield this.closeStick(stick);
+                resolve(true);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }));
+    }
+    closeSensor(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stick = this.findStickByPort(device.getPort());
+            if (stick.inUse) {
+                try {
+                    stick.close();
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'closeSensor error', error: err.message, device: device ? device.getName() : 'unknown' });
+                }
+            }
+        });
+    }
+}
+exports.AntProtocol = AntProtocol;
+let _scanner = undefined;
+function AntScanner(antClass) {
+    const scanner = _scanner || new AntProtocol(antClass);
+    return scanner;
+}
+exports.AntScanner = AntScanner;