incyclist-devices 1.5.38 → 2.0.0

package/lib/ble/bindings/types.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { BleCharacteristic } from "../types";
+export type Property = 'read' | 'write' | 'notify' | 'indicate';
+export type Descriptor = {
+    uuid: string;
+    value: string | Buffer;
+};
+export type Characteristic = {
+    uuid: string;
+    properties: Property[];
+    secure?: boolean;
+    value: Buffer;
+    descriptors: Descriptor[];
+};
+export declare const RESULT_SUCCESS = 0;
+export declare const RESULT_INVALID_OFFSET = 7;
+export declare const RESULT_ATTR_NOT_LONG = 11;
+export declare const RESULT_INVALID_ATTRIBUTE_LENGTH = 13;
+export declare const RESULT_UNLIKELY_ERROR = 14;
+export declare class MockCharacteristic extends EventEmitter implements BleCharacteristic {
+    uuid: string;
+    properties: Property[];
+    secure?: boolean | undefined;
+    value: Buffer;
+    descriptors: Descriptor[];
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: ((err: Error | undefined) => void) | undefined): void;
+}
+export declare class StaticReadCharacteristic extends MockCharacteristic {
+    constructor(uuid: string, description: string, value: any);
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+}
+export declare class StaticWriteCharacteristic extends MockCharacteristic {
+    size: number;
+    constructor(uuid: string, description: string, size: number);
+    write(data: Buffer, withoutResponse: boolean, callback?: (err?: Error) => void): void;
+}
+export declare abstract class StaticNotifyCharacteristic extends MockCharacteristic {
+    cntSubscriptions: number;
+    iv: NodeJS.Timer;
+    notifyFrequency: number;
+    constructor(uuid: string, description: string);
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    abstract notify(): void;
+    startNotify(): void;
+    stopNotify(): void;
+}
+export type PrimaryService = {
+    uuid: string;
+    characteristics: Characteristic[];
+};

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,11 +1,20 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding, BleCharacteristic, BleDeviceDescription } from './ble';
+import BleAdapterFactory from './adapter-factory';
+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;
@@ -13,88 +22,58 @@ export interface ConnectState {
     timeout?: NodeJS.Timeout;
     isInitSuccess: boolean;
 }
-export interface PeripheralState {
-    isLoading: boolean;
-    isConfigured: boolean;
-    isInterrupted: boolean;
-}
 export interface BleDeviceInfo {
-    device: BleDeviceClass;
+    device: BleComms;
     isConnected: boolean;
 }
 export interface BleDeviceClassInfo {
-    Class: typeof BleDeviceClass;
+    Class: typeof BleComms;
     type: string;
     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;
-    static deviceClasses: BleDeviceClassInfo[];
+    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;
-    });
-    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
+    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;
-    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
-    getAllSupportedServices(): any[];
-    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
-    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
-    getServicesFromDevice(device: BleDeviceClass): string[];
     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>;
-    getDeviceClasses(peripheral: any, props?: {
-        deviceTypes?: (typeof BleDeviceClass)[];
-        profile?: string;
-        services?: string[];
-    }): (typeof BleDeviceClass)[];
-    createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): BleDeviceClass;
-    connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;
+    getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
     waitForScanFinished(timeout: any): Promise<unknown>;
-    getBestDeviceMatch(DeviceClasses: (typeof BleDeviceClass)[]): typeof BleDeviceClass;
-    scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    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: BleDeviceClass): void;
-    addDeviceToCache(device: BleDeviceClass, isConnected: boolean): void;
-    findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
-    findDeviceInCache(device: {
-        id?: string;
-        address?: string;
-        name?: string;
-        profile: string;
-    }): BleDeviceClass;
-    removeConnectedDevice(device: BleDeviceClass): void;
+    addConnectedDevice(device: BleAdapter): void;
+    removeConnectedDevice(device: BleAdapter): void;
 }