incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/ble/bindings/types.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticNotifyCharacteristic = exports.StaticWriteCharacteristic = exports.StaticReadCharacteristic = exports.MockCharacteristic = exports.RESULT_UNLIKELY_ERROR = exports.RESULT_INVALID_ATTRIBUTE_LENGTH = exports.RESULT_ATTR_NOT_LONG = exports.RESULT_INVALID_OFFSET = exports.RESULT_SUCCESS = void 0;
+const events_1 = __importDefault(require("events"));
+exports.RESULT_SUCCESS = 0x00;
+exports.RESULT_INVALID_OFFSET = 0x07;
+exports.RESULT_ATTR_NOT_LONG = 0x0b;
+exports.RESULT_INVALID_ATTRIBUTE_LENGTH = 0x0d;
+exports.RESULT_UNLIKELY_ERROR = 0x0e;
+class MockCharacteristic extends events_1.default {
+    subscribe(callback) {
+        throw new Error("Method not implemented.");
+    }
+    unsubscribe(callback) {
+        throw new Error("Method not implemented.");
+    }
+    read(callback) {
+        throw new Error("Method not implemented.");
+    }
+    write(data, withoutResponse, callback) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockCharacteristic = MockCharacteristic;
+class StaticReadCharacteristic extends MockCharacteristic {
+    constructor(uuid, description, value) {
+        super();
+        this.uuid = uuid;
+        this.properties = ['read'];
+        this.value = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        this.descriptors = [{ uuid: '2901', value: description }];
+    }
+    read(callback) {
+        callback(undefined, this.value);
+    }
+}
+exports.StaticReadCharacteristic = StaticReadCharacteristic;
+class StaticWriteCharacteristic extends MockCharacteristic {
+    constructor(uuid, description, size) {
+        super();
+        this.uuid = uuid;
+        this.properties = ['write'];
+        this.value = Buffer.alloc(2);
+        this.descriptors = [{ uuid: '2901', value: description }];
+        this.size = size;
+    }
+    write(data, withoutResponse, callback) {
+        this.value = data;
+        if (!withoutResponse && callback)
+            callback();
+    }
+}
+exports.StaticWriteCharacteristic = StaticWriteCharacteristic;
+class StaticNotifyCharacteristic extends MockCharacteristic {
+    constructor(uuid, description) {
+        super();
+        this.uuid = uuid;
+        this.properties = ['notify'];
+        this.descriptors = [{ uuid: '2901', value: description }];
+        this.cntSubscriptions = 0;
+        this.notifyFrequency = 500;
+    }
+    subscribe(callback) {
+        this.cntSubscriptions++;
+        this.startNotify();
+        if (callback)
+            callback(undefined);
+    }
+    unsubscribe(callback) {
+        if (this.cntSubscriptions === 0) {
+            if (callback)
+                callback(new Error('not subscribed'));
+            return;
+        }
+        this.cntSubscriptions--;
+        if (this.cntSubscriptions === 0) {
+            this.stopNotify();
+        }
+        if (callback)
+            callback(undefined);
+    }
+    startNotify() {
+        if (!this.iv)
+            this.iv = setInterval(this.notify.bind(this), this.notifyFrequency);
+    }
+    stopNotify() {
+        if (this.iv) {
+            clearInterval(this.iv);
+            this.iv = null;
+        }
+    }
+}
+exports.StaticNotifyCharacteristic = StaticNotifyCharacteristic;

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

@@ -1,14 +1,20 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, BleScanProps, BleBinding } from './ble';
-import { BleComms } from './ble-comms';
 import BleAdapterFactory from './adapter-factory';
-import { ConnectProps, BlePeripheral, BleCharacteristic, BleDeviceSettings } from './types';
+import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
+import { BleComms } from './base/comms';
+import { IncyclistInterface } from '../types/interface';
+import BleAdapter from './base/adapter';
+import { IncyclistScanProps } from '../types/device';
+import BlePeripheralCache from './peripheral-cache';
+import EventEmitter from 'events';
 export interface ScanState {
     isScanning: boolean;
     isConnecting: boolean;
     isBackgroundScan: boolean;
     timeout?: NodeJS.Timeout;
+    peripherals?: Map<string, BlePeripheral>;
 }
 export interface ConnectState {
     isConnecting: boolean;
@@ -16,11 +22,6 @@ export interface ConnectState {
     timeout?: NodeJS.Timeout;
     isInitSuccess: boolean;
 }
-export interface PeripheralState {
-    isLoading: boolean;
-    isConfigured: boolean;
-    isInterrupted: boolean;
-}
 export interface BleDeviceInfo {
     device: BleComms;
     isConnected: boolean;
@@ -31,61 +32,48 @@ export interface BleDeviceClassInfo {
     services: string[];
     id: string;
 }
-export interface PeripheralCacheItem {
-    address: string;
-    ts: number;
-    peripheral: BlePeripheral;
-    state?: PeripheralState;
-    characteristics?: BleCharacteristic[];
-}
-export default class BleInterface extends BleInterfaceClass {
+export default class BleInterface extends EventEmitter implements IncyclistInterface {
     scanState: ScanState;
     connectState: ConnectState;
-    devices: BleDeviceInfo[];
-    peripheralCache: any[];
+    peripheralCache: BlePeripheralCache;
     logger: EventLogger;
+    props: BleInterfaceProps;
+    binding: BleBinding;
+    connectedDevices: BleAdapter[];
+    sensorIsConnecting: boolean;
     static _instance: BleInterface;
     static getInstance(props?: {
         binding?: BleBinding;
         log?: boolean;
         logger?: EventLogger;
     }): BleInterface;
-    constructor(props?: {
-        binding?: BleBinding;
-        log?: boolean;
-        logger?: EventLogger;
-    });
+    constructor(props?: BleInterfaceProps);
+    getBinding(): BleBinding;
+    setBinding(binding: BleBinding): void;
+    getName(): string;
+    startConnectSensor(): void;
+    stopConnectSensor(): void;
+    waitForSensorConnectionFinish(): Promise<void>;
     getAdapterFactory(): BleAdapterFactory;
     logEvent(event: any): void;
-    onStateChange(state: any): void;
+    onStateChange(state: BleInterfaceState): void;
     onError(err: any): void;
-    connect(props?: ConnectProps): Promise<boolean>;
+    connect(to?: number): Promise<boolean>;
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
     waitForConnectFinished(timeout: any): Promise<unknown>;
-    addPeripheralToCache(peripheral: any, props?: {}): void;
     onDisconnect(peripheral: any): void;
-    getConnector(peripheral: BlePeripheral): any;
-    findPeripheral(peripheral: BlePeripheral | {
-        id?: string;
-        address?: string;
-        name?: string;
-    }): BlePeripheral;
-    getCharacteristics(peripheral: any): Promise<any>;
-    createDeviceComms(DeviceClass: (typeof BleComms), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): any;
-    connectDevice(requested: BleComms | BleDeviceSettings, timeout?: number): Promise<BleComms>;
+    getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
     waitForScanFinished(timeout: any): Promise<unknown>;
-    scan(props: BleScanProps): Promise<BleComms[]>;
+    onPeripheralFound(p: BlePeripheral, callback: any, props?: {
+        request?: BleDeviceSettings;
+        comms?: BleComms;
+        protocolFilter?: BleProtocol[] | null;
+    }): Promise<any>;
+    scanForDevice(comms: BleComms, props: IncyclistScanProps): Promise<BlePeripheral>;
+    scan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    addConnectedDevice(device: BleComms): void;
-    addDeviceToCache(device: BleComms, isConnected: boolean): void;
-    findConnected(device: BleComms | BlePeripheral): BleComms;
-    findDeviceInCache(device: {
-        id?: string;
-        address?: string;
-        name?: string;
-        profile: string;
-    }): BleComms;
-    removeConnectedDevice(device: BleComms): void;
+    addConnectedDevice(device: BleAdapter): void;
+    removeConnectedDevice(device: BleAdapter): void;
 }