incyclist-devices 2.2.10-beta.0 → 2.3.0

package/lib/antv2/base/interface.js

@@ -16,7 +16,7 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
 const utils_1 = require("../../utils/utils");
-const incyclist_devices_1 = require("incyclist-devices");
+const adapter_factory_1 = __importDefault(require("../factories/adapter-factory"));
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)
@@ -300,7 +300,7 @@ class AntInterface extends events_1.default {
             this.logger.logEvent({ message: 'stopping devices' });
             let promises = [];
             detected.forEach((settings) => {
-                const adapter = incyclist_devices_1.AdapterFactory.create(settings);
+                const adapter = adapter_factory_1.default.getInstance().createInstance(settings);
                 promises.push(adapter.stop().catch(err => {
                     this.logger.logEvent({ message: 'could not stop device', error: err.message, deviceID: settings.deviceID, stack: err.stack });
                 }));

package/lib/antv2/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './adapter-factory';

package/lib/antv2/factories/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter-factory"), exports);

package/lib/antv2/fe/adapter.js

@@ -88,16 +88,17 @@ class AntFEAdapter extends adapter_1.default {
         }
     }
     mapData(deviceData) {
+        var _a, _b, _c, _d;
         const data = {
             isPedalling: false,
             power: 0,
             pedalRpm: 0,
             speed: 0,
         };
-        data.speed = (deviceData.VirtualSpeed !== undefined ? deviceData.VirtualSpeed : (deviceData.RealSpeed || 0)) * 3.6;
-        data.slope = (deviceData.Incline !== undefined ? deviceData.Incline : data.slope);
-        data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
-        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
+        data.speed = ((_a = deviceData === null || deviceData === void 0 ? void 0 : deviceData.VirtualSpeed) !== null && _a !== void 0 ? _a : (deviceData.RealSpeed || 0)) * 3.6;
+        data.slope = (_b = deviceData === null || deviceData === void 0 ? void 0 : deviceData.Incline) !== null && _b !== void 0 ? _b : data.slope;
+        data.power = (_c = deviceData === null || deviceData === void 0 ? void 0 : deviceData.InstantaneousPower) !== null && _c !== void 0 ? _c : data.power;
+        data.pedalRpm = (_d = deviceData.Cadence) !== null && _d !== void 0 ? _d : data.pedalRpm;
         data.isPedalling = data.pedalRpm > 0 || data.power > 0;
         if (deviceData.HeartRate !== undefined)
             data.heartrate = deviceData.HeartRate;

package/lib/antv2/index.d.ts

@@ -8,4 +8,5 @@ import { AntInterfaceProps } from "./types";
 import AntSpdAdapter from "./spd";
 import AntScAdapter from "./sc";
 export { AntDeviceSettings, AntDeviceProperties, AntScanProps } from "./types";
+export declare const initAntFactory: () => void;
 export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntScAdapter, AntSpdAdapter, AntCadAdapter, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntInterface = exports.AntCadAdapter = exports.AntSpdAdapter = exports.AntScAdapter = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
+exports.AntInterface = exports.AntCadAdapter = exports.AntSpdAdapter = exports.AntScAdapter = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = exports.initAntFactory = void 0;
 const pwr_1 = __importDefault(require("./pwr"));
 exports.AntPwrAdapter = pwr_1.default;
 const fe_1 = __importDefault(require("./fe"));
@@ -20,10 +20,14 @@ const spd_1 = __importDefault(require("./spd"));
 exports.AntSpdAdapter = spd_1.default;
 const sc_1 = __importDefault(require("./sc"));
 exports.AntScAdapter = sc_1.default;
-const af = adapter_factory_1.default.getInstance();
-af.register('PWR', 'Power Meter', pwr_1.default);
-af.register('HR', 'Heartrate Monitor', hr_1.default);
-af.register('FE', 'Smart Trainer', fe_1.default);
-af.register('CAD', 'Cadence Sensor', cad_1.default);
-af.register('SPD', 'Speed Sensor', spd_1.default);
-af.register('SC', 'Speed + Cadence Sensor', sc_1.default);
+const initAntFactory = () => {
+    const af = adapter_factory_1.default.getInstance();
+    af.register('PWR', 'Power Meter', pwr_1.default);
+    af.register('HR', 'Heartrate Monitor', hr_1.default);
+    af.register('FE', 'Smart Trainer', fe_1.default);
+    af.register('CAD', 'Cadence Sensor', cad_1.default);
+    af.register('SPD', 'Speed Sensor', spd_1.default);
+    af.register('SC', 'Speed + Cadence Sensor', sc_1.default);
+};
+exports.initAntFactory = initAntFactory;
+(0, exports.initAntFactory)();

package/lib/base/adpater.js

@@ -200,7 +200,7 @@ class IncyclistDevice extends events_1.default {
             if (!request.enforced && (this.isPaused() || this.isStopped()))
                 return;
             if (!this.hasCapability(types_1.IncyclistCapability.Control))
-                return yield this.getCyclingMode().sendBikeUpdate(request);
+                return this.getCyclingMode().sendBikeUpdate(request);
             else
                 throw new Error('method not implemented');
         });

package/lib/ble/adapter-factory.d.ts

@@ -1,34 +1,30 @@
 import BleAdapter from "./base/adapter";
-import { BleDeviceSettings, BleProtocol } from "./types";
+import { BleDeviceSettings, BleProtocol, TBleSensor } from "./types";
 import { DeviceProperties } from "../types";
-import { BleComms } from "./base/comms";
 import { BleDeviceData } from "./base/types";
-export interface BleAdapterInfo {
+export interface BleAdapterInfo<T extends TBleSensor> {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
-    Comm: typeof BleComms;
+    Adapter: typeof BleAdapter<BleDeviceData, T>;
+    Comm: typeof TBleSensor;
 }
-export default class BleAdapterFactory {
-    static _instance: BleAdapterFactory;
-    implementations: BleAdapterInfo[];
-    instances: Array<BleAdapter<BleDeviceData, BleComms>>;
-    static getInstance(): BleAdapterFactory;
-    constructor();
-    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
-    getAll(): BleAdapterInfo[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, BleComms>;
+export default class BleAdapterFactory<T extends TBleSensor> {
+    transport: string;
+    static readonly _instances: Record<string, BleAdapterFactory<any>>;
+    implementations: BleAdapterInfo<any>[];
+    instances: Array<BleAdapter<BleDeviceData, T>>;
+    static getInstance(transport: string): BleAdapterFactory<any>;
+    constructor(transport: string);
+    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo<T>;
+    getAll(): BleAdapterInfo<T>[];
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, T>;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter<BleDeviceData, BleComms>;
+        adapter?: BleAdapter<BleDeviceData, T>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, BleComms>;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, BleComms>, Comm: typeof BleComms): void;
-    getAllInstances(): Array<BleAdapter<BleDeviceData, BleComms>>;
-    getAllSupportedComms(): (typeof BleComms)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, BleComms>)>;
+    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, T>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, T>, Comm: typeof TBleSensor): void;
+    getAllInstances(): Array<BleAdapter<BleDeviceData, T>>;
+    getAllSupportedComms(): (typeof TBleSensor)[];
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
     getAllSupportedServices(): string[];
-    getDeviceClasses(peripheral: any, props?: {
-        protocol?: BleProtocol;
-        services?: string[];
-    }): (typeof BleComms)[];
 }

package/lib/ble/adapter-factory.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const comms_utils_1 = require("./base/comms-utils");
 const utils_1 = require("./utils");
 class BleAdapterFactory {
-    static getInstance() {
-        if (!BleAdapterFactory._instance)
-            BleAdapterFactory._instance = new BleAdapterFactory();
-        return BleAdapterFactory._instance;
+    static getInstance(transport) {
+        if (!BleAdapterFactory._instances[transport])
+            BleAdapterFactory._instances[transport] = new BleAdapterFactory(transport);
+        return BleAdapterFactory._instances[transport];
     }
-    constructor() {
+    constructor(transport) {
+        this.transport = transport;
         this.implementations = [];
         this.instances = [];
     }
@@ -37,7 +37,8 @@ class BleAdapterFactory {
             return existing;
         }
         const info = this.getAdapterInfo(protocol);
-        if (!info || !info.Adapter)
+        console.log('~~~~ INFO:', info);
+        if (!(info === null || info === void 0 ? void 0 : info.Adapter))
             return;
         const adapter = new info.Adapter(adapterSettings, props);
         this.instances.push(adapter);
@@ -69,42 +70,18 @@ class BleAdapterFactory {
         return this.instances;
     }
     getAllSupportedComms() {
-        const supported = BleAdapterFactory.getInstance().getAll();
+        const supported = this.getAll();
         return supported.map(info => info.Comm);
     }
     getAllSupportedAdapters() {
-        const supported = BleAdapterFactory.getInstance().getAll();
+        const supported = this.getAll();
         return supported.map(info => info.Adapter);
     }
     getAllSupportedServices() {
-        const supported = BleAdapterFactory.getInstance().getAll();
-        const res = [];
-        if (supported && supported.length > 0) {
-            supported.forEach(info => {
-                if (info && info.Comm && info.Comm.services) {
-                    info.Comm.services.forEach(s => {
-                        if (!res.includes(s))
-                            res.push(s);
-                    });
-                }
-            });
-        }
+        const supported = this.getAll();
+        const res = ['180d', '1818', '1826', '6e40fec1'];
         return res;
     }
-    getDeviceClasses(peripheral, props = {}) {
-        let DeviceClasses;
-        const { protocol, services = peripheral.advertisement.serviceUuids } = props;
-        const classes = this.getAllSupportedComms();
-        DeviceClasses = (0, comms_utils_1.getDevicesFromServices)(classes, services);
-        if (protocol && DeviceClasses && DeviceClasses.length > 0) {
-            DeviceClasses = DeviceClasses.filter((C) => {
-                const device = new C({ peripheral });
-                if (device.getProtocol() !== protocol)
-                    return false;
-                return true;
-            });
-        }
-        return DeviceClasses;
-    }
 }
+BleAdapterFactory._instances = {};
 exports.default = BleAdapterFactory;

package/lib/ble/base/adapter.d.ts

@@ -1,22 +1,25 @@
 import IncyclistDevice from "../../base/adpater";
-import { BleComms } from "./comms";
-import BleInterface from "../ble-interface";
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBlePeripheral } from "../types";
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
 import { BleDeviceData } from "./types";
 import { LegacyProfile } from "../../antv2/types";
 import ICyclingMode from "../../modes/types";
-export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends BleComms> extends IncyclistDevice<BleDeviceProperties> {
-    protected ble: BleInterface;
+import { InteruptableTask, TaskState } from "../../utils/task";
+import { TBleSensor } from "./sensor";
+export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends TBleSensor> extends IncyclistDevice<BleDeviceProperties> {
     protected deviceData: TDeviceData;
     protected data: IncyclistAdapterData;
     protected dataMsgCount: number;
     protected lastDataTS: number;
     protected device: TDevice;
     protected onDeviceDataHandler: any;
+    protected startTask: InteruptableTask<TaskState, boolean>;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     getUniqueName(): string;
     connect(): Promise<boolean>;
+    getPeripheral(): IBlePeripheral;
+    waitForPeripheral(): Promise<void>;
+    updateSensor(peripheral: IBlePeripheral): void;
     close(): Promise<boolean>;
     getComms(): TDevice;
     isEqual(settings: BleDeviceSettings): boolean;
@@ -35,8 +38,16 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     getSettings(): BleDeviceSettings;
     setProperties(props: BleDeviceProperties): void;
     check(): Promise<boolean>;
+    getDefaultStartupTimeout(): number;
     startPreChecks(props: BleStartProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     start(startProps?: BleStartProperties): Promise<boolean>;
+    protected isStarting(): boolean;
+    protected hasData(): boolean;
+    protected waitForInitialData(startupTimeout: any): Promise<void>;
+    protected checkCapabilities(): void;
+    protected initControl(_props?: BleStartProperties): Promise<void>;
+    protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
+    startSensor(): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;

package/lib/ble/base/adapter.js

@@ -13,24 +13,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const adpater_1 = __importDefault(require("../../base/adpater"));
-const ble_interface_1 = __importDefault(require("../ble-interface"));
-const INTERFACE_NAME = 'ble';
+const types_1 = require("../../types");
+const interface_factory_1 = require("../factories/interface-factory");
+const task_1 = require("../../utils/task");
+const utils_1 = require("../../utils/utils");
 class BleAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.onDeviceDataHandler = this.onDeviceData.bind(this);
-        if (this.settings.interface !== INTERFACE_NAME)
-            throw new Error('Incorrect interface');
         this.deviceData = {};
         this.data = {};
         this.dataMsgCount = 0;
         this.updateFrequency = 1000;
-        this.ble = ble_interface_1.default.getInstance();
     }
     getUniqueName() {
         var _a;
         const settings = this.settings;
-        if (((_a = settings.name) === null || _a === void 0 ? void 0 : _a.match(/[0-9]/g)) || settings.address === undefined)
+        if (((_a = settings.name) === null || _a === void 0 ? void 0 : _a.match(/\d/g)) || settings.address === undefined)
             return this.getName();
         else {
             const addressHash = settings.address.substring(0, 2) + settings.address.slice(-2);
@@ -39,26 +38,29 @@ class BleAdapter extends adpater_1.default {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device) {
-                throw new Error('No Comms');
-            }
-            if (this.isConnected())
-                return true;
-            let connected = false;
-            try {
-                connected = yield this.device.connect();
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
-            }
-            return connected;
+            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+            return yield iface.connect();
         });
     }
+    getPeripheral() {
+        const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+        const p = iface === null || iface === void 0 ? void 0 : iface.createPeripheralFromSettings(this.settings);
+        return p;
+    }
+    waitForPeripheral() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'waiting for sensor ...' });
+            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+            const peripheral = yield iface.waitForPeripheral(this.settings);
+            this.updateSensor(peripheral);
+        });
+    }
+    updateSensor(peripheral) {
+        throw new Error('method not implemented');
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device || !this.isConnected())
-                return true;
-            return yield this.device.disconnect();
+            return true;
         });
     }
     getComms() {
@@ -81,7 +83,8 @@ class BleAdapter extends adpater_1.default {
         return this.isEqual(adapter.getSettings());
     }
     isConnected() {
-        return this.device && this.device.isConnected();
+        var _a;
+        return (_a = this.device) === null || _a === void 0 ? void 0 : _a.isConnected();
     }
     resetData() {
         this.dataMsgCount = 0;
@@ -90,7 +93,13 @@ class BleAdapter extends adpater_1.default {
         this.lastDataTS = undefined;
     }
     getInterface() {
-        return INTERFACE_NAME;
+        const iface = this.settings.interface;
+        if (typeof iface === 'string')
+            return this.settings.interface;
+        else {
+            const i = this.settings.interface;
+            return i.getName();
+        }
     }
     getProfile() {
         const C = this.constructor;
@@ -164,6 +173,9 @@ class BleAdapter extends adpater_1.default {
     check() {
         return this.start({ scanOnly: true });
     }
+    getDefaultStartupTimeout() {
+        return 30000;
+    }
     startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasPaused = this.paused;
@@ -185,45 +197,150 @@ class BleAdapter extends adpater_1.default {
     }
     start(startProps) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            if (this.isStarting()) {
+                yield this.stop();
+            }
+            this.startTask = new task_1.InteruptableTask(this.startAdapter(startProps), {
+                timeout: startProps === null || startProps === void 0 ? void 0 : startProps.timeout,
+                name: 'start',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this)
+            });
+            const res = yield this.startTask.run();
+            return res;
+        });
+    }
+    isStarting() {
+        var _a;
+        return (_a = this.startTask) === null || _a === void 0 ? void 0 : _a.isRunning();
+    }
+    hasData() {
+        return this.dataMsgCount > 0;
+    }
+    waitForInitialData(startupTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let waitTask;
+            let iv;
+            const wait = () => {
+                const res = new Promise((resolve) => {
+                    iv = setInterval(() => {
+                        if (this.hasData()) {
+                            clearInterval(iv);
+                            resolve(true);
+                        }
+                        else if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
+                            resolve(false);
+                            clearInterval(iv);
+                        }
+                    }, 10);
+                });
+                return res;
+            };
+            waitTask = new task_1.InteruptableTask(wait(), {
+                errorOnTimeout: false,
+                timeout: startupTimeout
+            });
+            this.logEvent({ message: 'wait for sensor data', device: this.getName() });
+            const hasData = yield waitTask.run();
+            clearInterval(iv);
+            if (hasData)
+                this.logEvent({ message: 'sensor data received', device: this.getName() });
+        });
+    }
+    checkCapabilities() {
+    }
+    initControl(_props) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    startAdapter(startProps) {
+        return __awaiter(this, void 0, void 0, function* () {
             const props = this.getStartProps(startProps);
+            const { timeout = this.getDefaultStartupTimeout() } = startProps;
+            const wasPaused = this.paused;
             const preCheckResult = yield this.startPreChecks(props);
-            if (preCheckResult === 'done')
+            if (preCheckResult === 'done') {
+                yield (0, utils_1.resolveNextTick)();
                 return this.started;
-            if (preCheckResult === 'connection-failed')
-                throw new Error(`could not start device, reason:could not connect`);
+            }
+            if (preCheckResult === 'connection-failed') {
+                this.logEvent({ message: 'start result: error', error: 'could not start device, reason:could not connect', protocol: this.getProtocolName() });
+                yield (0, utils_1.resolveNextTick)();
+                return false;
+            }
             this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
             try {
-                const comms = this.device;
-                if (comms) {
-                    comms.on('data', this.onDeviceDataHandler);
-                    this.resetData();
-                    this.stopped = false;
-                    this.started = true;
-                    this.paused = false;
-                    return true;
+                const connected = yield this.startSensor();
+                if (connected) {
+                    this.logEvent({ message: 'peripheral connected', device: this.getName(), props });
                 }
+                else {
+                    this.logEvent({ message: 'peripheral connection failed', device: this.getName(), reason: 'unknown', props });
+                    return false;
+                }
+                yield this.waitForInitialData(timeout);
+                yield this.checkCapabilities();
+                if (this.hasCapability(types_1.IncyclistCapability.Control))
+                    yield this.initControl(startProps);
+                this.resetData();
+                this.stopped = false;
+                this.started = true;
+                if (wasPaused)
+                    this.resume();
+                return true;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
-                (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
-                throw new Error(`could not start device, reason:${err.message}`);
+                this.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                return false;
             }
         });
     }
+    startSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
+                yield this.waitForPeripheral();
+            }
+            if (!this.getComms()) {
+                return false;
+            }
+            const connected = yield this.getComms().startSensor();
+            if (connected) {
+                this.getComms().on('data', this.onDeviceDataHandler);
+                this.getComms().on('disconnected', this.emit.bind(this));
+                this.getComms().on('error', console.log);
+            }
+            return connected;
+        });
+    }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
-            this.device.reset();
-            this.device.off('data', this.onDeviceDataHandler);
-            const stopped = this.device.disconnect();
-            if (stopped) {
-                this.stopped = true;
-                this.started = false;
-                this.paused = false;
+            this.logEvent({ message: 'stopping device', device: this.getName() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
+            }
+            let reason = 'unknown';
+            let stopped = false;
+            if (!this.getComms()) {
+                this.logEvent({ message: 'device stopped - not started yet', device: this.getName() });
                 return true;
             }
-            return false;
+            this.getComms().reset();
+            try {
+                stopped = yield this.getComms().stopSensor();
+            }
+            catch (err) {
+                reason = err.message;
+            }
+            if (stopped) {
+                this.logEvent({ message: 'device stopped', device: this.getName() });
+            }
+            else {
+                this.logEvent({ message: 'stopping device failed', device: this.getName(), reason });
+            }
+            this.started = false;
+            this.stopped = true;
+            return stopped;
         });
     }
     pause() {
@@ -231,9 +348,9 @@ class BleAdapter extends adpater_1.default {
             pause: { get: () => super.pause }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const res = yield _super.pause.call(this);
-            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
+            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+            iface.pauseLogging();
             return res;
         });
     }
@@ -242,9 +359,9 @@ class BleAdapter extends adpater_1.default {
             resume: { get: () => super.resume }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            const iface = interface_factory_1.BleMultiTransportInterfaceFactory.createInstance(this.getInterface());
+            iface.resumeLogging();
             const res = yield _super.resume.call(this);
-            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.resume();
             return res;
         });
     }