incyclist-devices 2.0.1 → 2.0.3

package/lib/antv2/adapter.js

@@ -70,7 +70,7 @@ class AntAdapter extends adpater_1.default {
         const as = this.settings;
         if (as.interface !== settings.interface)
             return false;
-        if (as.deviceID !== settings.deviceID || as.profile !== settings.profile)
+        if (Number(as.deviceID) !== Number(settings.deviceID) || as.profile !== settings.profile)
             return false;
         return true;
     }
@@ -235,14 +235,19 @@ class AntAdapter extends adpater_1.default {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.stopDataTimeoutCheck();
-            let stopped = yield this.ant.stopSensor(this.sensor);
-            if (!stopped)
-                return false;
+            let stopped;
+            try {
+                this.stopDataTimeoutCheck();
+                stopped = yield this.ant.stopSensor(this.sensor);
+            }
+            catch (err) {
+                this.logEvent({ message: 'stop sensor failed', reason: err.message });
+            }
             this.started = false;
             this.stopped = true;
+            this.paused = false;
             this.removeAllListeners();
-            return true;
+            return stopped;
         });
     }
 }

package/lib/antv2/ant-interface.js

@@ -203,7 +203,7 @@ class AntInterface extends events_1.default {
                 return stopped;
             }
             catch (err) {
-                console.log('ERROR', err);
+                this.logEvent({ message: 'error', fn: 'stopScan()', error: err.message, stack: err.stack });
                 return false;
             }
         });
@@ -241,8 +241,9 @@ class AntInterface extends events_1.default {
     }
     stopSensor(sensor) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected() || !this.device)
+            if (!this.isConnected() || !this.device) {
                 return true;
+            }
             const channel = sensor.getChannel();
             if (channel) {
                 try {
@@ -257,7 +258,8 @@ class AntInterface extends events_1.default {
                     }
                     channel.flush();
                     channel.removeAllListeners('data');
-                    return yield channel.stopSensor(sensor);
+                    const stopped = yield channel.stopSensor(sensor);
+                    return stopped;
                 }
                 catch (err) {
                     this.logEvent({ message: 'could not stop sensor', error: err.message || err, stack: err.stack });

package/lib/antv2/fe/adapter.js

@@ -180,7 +180,8 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasPaused = this.paused;
-            this.paused = false;
+            if (wasPaused)
+                this.resume();
             if (this.started && !wasPaused) {
                 return true;
             }
@@ -214,10 +215,10 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                 while (!success && retry < MAX_RETRIES) {
                     retry++;
                     if (!this.started) {
-                        this.logger.logEvent({ message: 'start sensor', props });
+                        this.logEvent({ message: 'start sensor', props });
                         this.started = yield this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
                         if (this.started) {
-                            this.logger.logEvent({ message: 'sensor started', props });
+                            this.logEvent({ message: 'sensor started', props });
                             startSuccess++;
                         }
                         if (this.started && startSuccess === 1) {
@@ -258,8 +259,9 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                                     else if (startRequest.slope !== undefined && startRequest.slope !== null) {
                                         status.slopeSent = yield fe.sendTrackResistance(startRequest.slope);
                                     }
-                                    else
+                                    else {
                                         status.slopeSent = true;
+                                    }
                                 }
                                 else {
                                     status.slopeSent = yield fe.sendTrackResistance(0.0);
@@ -284,17 +286,19 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
                     yield (0, utils_2.sleep)(500);
                 }
                 if (success) {
-                    this.logger.logEvent({ message: 'start success' });
+                    this.logEvent({ message: 'start success' });
                     stopTimeoutCheck();
                     resolve(true);
                 }
                 else {
-                    this.logger.logEvent({ message: 'start failed' });
+                    this.logEvent({ message: 'start failed' });
                     stopTimeoutCheck();
-                    if (this.started)
+                    if (this.started) {
                         reject(new Error('could not start device, reason: could not send FE commands'));
+                    }
                     else
                         reject(new Error('could not start device, reason: could not connect'));
+                    this.started = false;
                 }
             }));
         });
@@ -325,7 +329,6 @@ class AntFEAdapter extends adapter_1.ControllableAntAdapter {
     setCyclingMode(mode, settings) {
         const modeChange = this.cyclingMode.getName() !== mode;
         super.setCyclingMode(mode, settings);
-        console.log('~~~ setCyclingMode', mode, modeChange, this.started, this.stopped, this.paused, this.isReconnecting, this.data);
         if (modeChange && this.started && !this.stopped) {
             if (this.getCyclingMode() instanceof ant_fe_erg_mode_1.default) {
                 const power = this.data.power;

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

@@ -41,6 +41,10 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     binding: BleBinding;
     connectedDevices: BleAdapter[];
     sensorIsConnecting: boolean;
+    emittingAdapters: {
+        comms: BleComms;
+        cb: (data: any) => void;
+    }[];
     static _instance: BleInterface;
     static getInstance(props?: {
         binding?: BleBinding;

package/lib/ble/ble-interface.js

@@ -42,6 +42,7 @@ class BleInterface extends events_1.default {
         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);
@@ -309,7 +310,7 @@ class BleInterface extends events_1.default {
                     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);
+                callback(settings, characteristics, peripheral);
             }
         });
     }
@@ -448,6 +449,11 @@ class BleInterface extends events_1.default {
                         this.scanState.isScanning = false;
                         resolve(detected);
                     });
+                    this.emittingAdapters.forEach(a => {
+                        a.comms.off('data', a.cb);
+                        a.comms.unsubscribeAll();
+                    });
+                    this.emittingAdapters = [];
                 };
                 this.logEvent({ message: `${opStr}: start scanning`, requested, timeout });
                 this.scanState.timeout = setTimeout(onTimeout, adjustedScanTimeout);
@@ -458,14 +464,22 @@ class BleInterface extends events_1.default {
                         return reject(err);
                     }
                     ble.on('discover', (p) => {
-                        this.onPeripheralFound(p, (deviceSettings, characteristics) => {
+                        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 });
+                        }), { protocolFilter });
                     });
                     const cachedItems = this.peripheralCache.filter(protocolFilter ? services : []);
                     if (cachedItems && cachedItems.length > 0) {
@@ -491,6 +505,11 @@ class BleInterface extends events_1.default {
             ble.removeAllListeners('discover');
             this.peripheralCache.handleStopScan();
             ble.stopScanning();
+            this.emittingAdapters.forEach(a => {
+                a.comms.unsubscribeAll();
+                a.comms.off('data', a.cb);
+            });
+            this.emittingAdapters = [];
             this.scanState.isScanning = false;
             this.logEvent({ message: 'scan stop result: success' });
             return true;

package/lib/serial/daum/premium/adapter.js

@@ -25,6 +25,7 @@ const DAUM_PREMIUM_DEFAULT_PORT = 51955;
 const START_RETRY_TIMEOUT = 1500;
 const DEFAULT_GEAR = 10;
 const getBikeProps = (props) => {
+    console.log('~~~getBikeProps', props);
     const { host, port = DAUM_PREMIUM_DEFAULT_PORT, interface: ifaceName } = props;
     let serial;
     if (ifaceName && typeof ifaceName === 'string') {
@@ -46,6 +47,7 @@ const getBikeProps = (props) => {
 };
 class DaumPremiumAdapter extends DaumAdapter_1.default {
     constructor(settings, props) {
+        console.log('~~~ new premium adapter');
         const logger = new gd_eventlog_1.EventLogger('DaumPremium');
         const commProps = Object.assign(Object.assign({}, getBikeProps(settings)), { logger });
         const bike = new comms_1.default(commProps);

package/lib/serial/serial-interface.js

@@ -85,11 +85,13 @@ exports.SinglePathScanner = SinglePathScanner;
 class SerialInterface extends events_1.default {
     static getInstance(props) {
         const { ifaceName, binding, logger } = props;
+        console.log('~~~ new instance #1', ifaceName, serialport_1.default.getInstance().getBinding(ifaceName));
         let instance = SerialInterface._instances.find(i => i.ifaceName === ifaceName);
         if (!instance) {
             if (binding)
                 instance = new SerialInterface(props);
             else {
+                console.log('~~~ new instance', ifaceName, serialport_1.default.getInstance().getBinding(ifaceName));
                 instance = new SerialInterface({ ifaceName, binding: serialport_1.default.getInstance().getBinding(ifaceName), logger });
                 if (instance)
                     SerialInterface._instances.push(instance);

package/package.json

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