@iotize/device-com-ble.cordova 3.7.2 → 4.0.0-alpha.1

package/packages/tap/protocol/ble/common/src/lib/universal-ble-protocol-adapter.d.ts

@@ -0,0 +1,146 @@
+import { ConnectionState } from '@iotize/tap/protocol/api';
+import { QueueComProtocol } from '@iotize/tap/protocol/core';
+import { Observable } from 'rxjs';
+export declare namespace UniversalBleProtocolAdapter {
+    interface Options {
+        /**
+         * Force BLE maximum transfer unit size (in bytes)
+         */
+        mtu?: number;
+        /**
+         * Maximum buffer length when response is splitted into multiple chunck
+         * (only used for legacy ble service)
+         */
+        maximumBufferLength: number;
+        /**
+         * True to wait for write characteristic acknowledge
+         * According to firmware implementation, write acknowledge is not
+         * always returns, leading to a timeout exception in client
+         */
+        waitForWriteAcknowledge: boolean;
+        /**
+         * TapNLinks may have 2 different BLE characteristic to communicate
+         * You can define which one should be used in priority
+         * If it does not exist, it will use the other one
+         */
+        preferedComServiceType?: 'legacy' | 'large-frame';
+        /**
+         * True if you want to remove '-' character from ID
+         */
+        sanitizeUUID?: boolean;
+    }
+}
+export declare const DEFAULT_BLE_OPTIONS: UniversalBleProtocolAdapter.Options;
+/**
+ * BLE communication
+ *
+ * With ble communication, data is split into sub packets.
+ * This class handles creation of packet chunks.
+ *
+ * - You must only implement the function to send one packet chunk writeLwm2mPacketChunk()
+ * -
+ */
+export declare class UniversalBleProtocolAdapter<T extends ServiceAdapterInterface = ServiceAdapterInterface> extends QueueComProtocol {
+    peripheral: PeripheralAdapterInterface<T>;
+    private _lwm2mCharc?;
+    private _useSplitter;
+    private _readPromise?;
+    bleOptions: UniversalBleProtocolAdapter.Options;
+    private _unexpectedBleDisconnection;
+    constructor(peripheral: PeripheralAdapterInterface<T>, bleOptions?: Partial<UniversalBleProtocolAdapter.Options>);
+    get lwm2mCharc(): CharacteristicAdapterInterface;
+    private sanitizeUUID;
+    _connect(): Observable<any>;
+    _disconnect(): Observable<any>;
+    private setupLwm2mCharacteristic;
+    private _selectLwm2mCharacteristic;
+    private _getLargeFrameLwm2mCharacteristic;
+    private _getLegacyLwm2mCharacteristic;
+    read(): Promise<Uint8Array>;
+    readUnit(): Promise<Uint8Array>;
+    write(data: Uint8Array): Promise<any>;
+    get useSplitter(): boolean;
+    get chunkSize(): number;
+    writeUnit(data: Uint8Array): Promise<any>;
+    private _createReadPromise;
+}
+export interface PeripheralAdapterInterface<T extends ServiceAdapterInterface = ServiceAdapterInterface> {
+    state: string;
+    stateChange: Observable<ConnectionState>;
+    name?: string;
+    id: string;
+    /**
+     * Discover services
+     * @param serviceUUIDs if not provided it will discover all services, if provided it will discover the given services
+     * @returns returns a map of services discovered. If a listed service is not discovered, it will be set to undefined
+     */
+    discoverServices<Key extends string = string>(serviceUUIDs?: Key[]): Promise<Partial<Record<Key, T>>>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getService(uuid: string): Promise<T>;
+}
+export interface CharacteristicProperties {
+    readonly broadcast: boolean;
+    readonly read: boolean;
+    readonly writeWithoutResponse: boolean;
+    readonly write: boolean;
+    readonly notify: boolean;
+    readonly indicate: boolean;
+    readonly authenticatedSignedWrites: boolean;
+    readonly reliableWrite: boolean;
+    readonly writableAuxiliaries: boolean;
+}
+export interface ServiceAdapterInterface<CharacteristicType extends CharacteristicAdapterInterface = CharacteristicAdapterInterface> {
+    uuid: string;
+    /**
+     * Get characteristic identified by the given UUID
+     * @throws if characteristic does not exist
+     *
+     * @param charcUUID
+     */
+    getCharacteristic(charcUUID: string): Promise<CharacteristicType>;
+    getCharacteristics(): Promise<CharacteristicType[]>;
+}
+export interface CharacteristicAdapterInterface<DescriptorType extends DescriptorAdapterInterface = DescriptorAdapterInterface> {
+    uuid: string;
+    properties: CharacteristicProperties;
+    data: Observable<{
+        data: Uint8Array;
+        isNotification: boolean;
+    }>;
+    /**
+     * Write characteristic value
+     * If successful, returns the written data
+     * @param data
+     * @param writeWithoutResponse
+     */
+    write(data: Uint8Array, writeWithoutResponse: boolean): Promise<Uint8Array>;
+    /**
+     * Read characteristic value
+     */
+    read(): Promise<Uint8Array>;
+    /**
+     * Start/Stop notifications with indication or notification accordording to
+     * characteristic configuration
+     * @param enabled
+     */
+    enableNotifications(enabled: boolean): Promise<void>;
+    /**
+     * Get descriptors
+     */
+    getDescriptors(): Promise<DescriptorType[]>;
+}
+export interface DescriptorAdapterInterface {
+    /**
+     * Descriptor UUID
+     */
+    uuid: string;
+    /**
+     * Write descriptor value
+     */
+    writeValue(data: Uint8Array): Promise<void>;
+    /**
+     * Read descriptor value
+     */
+    readValue(): Promise<Uint8Array>;
+}

package/packages/tap/protocol/ble/common/src/lib/util.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeUUID(input: string): string;

package/packages/tap/protocol/ble/common/src/public_api.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/ble-config';
+export * from './lib/abstract-ble-protocol';
+export * from './lib/ble-packet-builder';
+export * from './lib/ble-packet-splitter';
+export * from './lib/universal-ble-protocol-adapter';
+export * from './lib/errors';

package/packages/tap/protocol/core/src/lib/abstract-com-protocol.d.ts

@@ -0,0 +1,23 @@
+import { ComProtocol, ComProtocolConnectOptions, ComProtocolOptions, ComProtocolSendOptions, ConnectionState, ConnectionStateChangeEvent } from '@iotize/tap/protocol/api';
+import { Observable, Subject } from 'rxjs';
+export declare abstract class AbstractComProtocol implements ComProtocol {
+    _connectionStateChange?: Subject<ConnectionStateChangeEvent>;
+    protected connectionState: ConnectionState;
+    protected _options: ComProtocolOptions;
+    get options(): ComProtocolOptions;
+    set options(options: ComProtocolOptions);
+    abstract write(data: Uint8Array): Promise<any>;
+    abstract read(): Promise<Uint8Array>;
+    abstract connect(options?: ComProtocolConnectOptions): Observable<any>;
+    abstract disconnect(options?: ComProtocolConnectOptions): Observable<any>;
+    abstract send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
+    constructor();
+    getConnectionState(): ConnectionState;
+    isConnected(): boolean;
+    setConnectionState(connectionState: ConnectionState): this;
+    /**
+     * Must be implemented in childs
+     */
+    receiveStream(): Observable<Uint8Array>;
+    onConnectionStateChange(): Observable<ConnectionStateChangeEvent>;
+}

package/packages/tap/protocol/core/src/lib/debug.d.ts

@@ -0,0 +1,2 @@
+import { createDebugger } from '@iotize/common/debug';
+export declare const debug: createDebugger.Debugger;

package/packages/tap/protocol/core/src/lib/queue-com-protocol.d.ts

@@ -0,0 +1,35 @@
+import { ComProtocolConnectOptions, ComProtocolDisconnectOptions, ComProtocolSendOptions } from '@iotize/tap/protocol/api';
+import { Observable, Subscription } from 'rxjs';
+import { AbstractComProtocol } from './abstract-com-protocol';
+/**
+ *
+ */
+export declare abstract class QueueComProtocol extends AbstractComProtocol {
+    _disconnect$?: Observable<any>;
+    _connect$?: Observable<any>;
+    _connectionSubscription?: Subscription;
+    private _jobQueue;
+    abstract _connect(options?: ComProtocolConnectOptions): Observable<any>;
+    abstract _disconnect(options?: ComProtocolDisconnectOptions): Observable<any>;
+    _send(data: Uint8Array, options: ComProtocolSendOptions): Observable<Uint8Array>;
+    constructor();
+    /**
+     * Cancel pending requests
+     */
+    cancel(): void;
+    /**
+     *
+     * @param data
+     * @param options
+     */
+    send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
+    /**
+     * Connect with timeout
+     *
+     * If connect has already been called or is in progress / no further action
+     *
+     * @param options
+     */
+    connect(options?: ComProtocolConnectOptions): Observable<any>;
+    disconnect(options?: ComProtocolDisconnectOptions): Observable<any>;
+}

package/packages/tap/protocol/core/src/public_api.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/abstract-com-protocol';
+export * from './lib/queue-com-protocol';

package/packages/tap/scanner/api/src/lib/definitions.d.ts

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+/**
+ * Scan options provided when starting scan
+ */
+export interface DeviceScannerOptions {
+    /**
+     * Timeout in milliseconds
+     */
+    timeout?: number;
+}
+export interface DeviceScanner<DataType> {
+    /**
+     * Observable on scanner state (true = scanner is running)
+     */
+    scanning: Observable<boolean>;
+    /**
+     * return true if scanner is currently running
+     */
+    isScanning: boolean;
+    /**
+     * Emit scan results
+     */
+    results: Observable<DataType[]>;
+    /**
+     * Start scan
+     * Will return an Observable that emitts @{link DeviceScanResult} each time
+     * a device is disoverd
+     * @param option
+     */
+    start(option?: DeviceScannerOptions): Promise<any>;
+    /**
+     * Stop scan
+     */
+    stop(): Promise<any>;
+}

package/packages/tap/scanner/api/src/public_api.d.ts

@@ -0,0 +1 @@
+export * from './lib/definitions';