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

package/packages/tap/client/impl/src/lib/response/result-code-translation.d.ts

@@ -0,0 +1,170 @@
+/**
+ *   Generated file. Do not edit
+ */
+export declare const ResultCodeTranslation: {
+    /**
+     * OK
+     * decimal: 0
+     */
+    0: string;
+    /**
+     * CREATED
+     * decimal: 65
+     */
+    65: string;
+    /**
+     * DELETED
+     * decimal: 66
+     */
+    66: string;
+    /**
+     * CHANGED
+     * decimal: 68
+     */
+    68: string;
+    /**
+     * CONTENT
+     * decimal: 69
+     */
+    69: string;
+    /**
+     * BUSY
+     * decimal: 70
+     */
+    70: string;
+    /**
+     * BAD_REQUEST
+     * decimal: 128
+     */
+    128: string;
+    /**
+     * UNAUTHORIZED
+     * decimal: 129
+     */
+    129: string;
+    /**
+     * NOT_FOUND
+     * decimal: 132
+     */
+    132: string;
+    /**
+     * METHOD_NOT_ALLOWED
+     * decimal: 133
+     */
+    133: string;
+    /**
+     * NOT_ACCEPTABLE
+     * decimal: 134
+     */
+    134: string;
+    /**
+     * RESOURCE_LOCKED
+     * decimal: 135
+     */
+    135: string;
+    /**
+     * INTERNAL_SERVER_ERROR
+     * decimal: 160
+     */
+    160: string;
+    /**
+     * NOT_IMPLEMENTED
+     * decimal: 161
+     */
+    161: string;
+    /**
+     * SERVICE_UNAVAILABLE
+     * decimal: 163
+     */
+    163: string;
+    /**
+     * NVM_ERROR
+     * decimal: 164
+     */
+    164: string;
+    /**
+     * UNABLE_TO_CONNECT_TO_TARGET
+     * decimal: 165
+     */
+    165: string;
+    /**
+     * TARGET_POWER_FAILURE
+     * decimal: 166
+     */
+    166: string;
+    /**
+     * NVM_FULL
+     * decimal: 167
+     */
+    167: string;
+    /**
+     * DEVICE_UNAVAILABLE
+     * decimal: 168
+     */
+    168: string;
+    /**
+     * RESPONSE_TOO_LARGE
+     * decimal: 169
+     */
+    169: string;
+    /**
+     * TARGET_PROTOCOL_ERROR
+     * decimal: 176
+     */
+    176: string;
+    /**
+     * TARGET_PROTOCOL_BUSY
+     * decimal: 177
+     */
+    177: string;
+    /**
+     * TARGET_PROTOCOL_REAL
+     * decimal: 178
+     */
+    178: string;
+    /**
+     * TARGET_PROTOCOL_WRONG_PARAM
+     * decimal: 179
+     */
+    179: string;
+    /**
+     * TARGET_PROTOCOL_FORBIDDEN
+     * decimal: 180
+     */
+    180: string;
+    /**
+     * TARGET_PROTOCOL_DATA
+     * decimal: 181
+     */
+    181: string;
+    /**
+     * TARGET_PROTOCOL_COM
+     * decimal: 182
+     */
+    182: string;
+    /**
+     * TARGET_PROTOCOL_LOST_COM
+     * decimal: 183
+     */
+    183: string;
+    /**
+     * TARGET_PROTOCOL_PARAM
+     * decimal: 184
+     */
+    184: string;
+    /**
+     * TARGET_PROTOCOL_INT
+     * decimal: 185
+     */
+    185: string;
+    /**
+     * TARGET_PROTOCOL_ABORT
+     * decimal: 186
+     */
+    186: string;
+    /**
+     * TARGET_PROTOCOL_NOT_IMPLEMENTED
+     * decimal: 187
+     */
+    187: string;
+};

package/packages/tap/client/impl/src/lib/response/tap-response-builder.d.ts

@@ -0,0 +1,6 @@
+import { TapResponseFrame } from '@iotize/tap/client/api';
+export declare class TapResponseFrameBuilder {
+    static SUCCESS(data?: Uint8Array): TapResponseFrame;
+    static ERROR(status?: number, data?: Uint8Array): TapResponseFrame;
+    static create(status: number, data?: Uint8Array): TapResponseFrame;
+}

package/packages/tap/client/impl/src/lib/response/tap-response-status-to-string.d.ts

@@ -0,0 +1 @@
+export declare function tapResponseStatusToString(status: number): any;

package/packages/tap/client/impl/src/lib/tap-client-error.d.ts

@@ -0,0 +1,33 @@
+import { CodeError } from '@iotize/common/error';
+import { ApduResponse, TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
+export declare class TapClientError extends CodeError<TapClientError.Code> {
+    cause?: Error | undefined;
+    constructor(code: TapClientError.Code, message: string, cause?: Error | undefined);
+    static illegalArgument(msg: string): TapClientError;
+    static illegalStateError(msg: string): TapClientError;
+    static encodeRequestError(command: TapRequestFrame, cause: Error): TapClientError;
+    static decodeResponseError(cause: Error, frameOrCommand: Uint8Array | TapRequestFrame): TapClientError;
+    static notConnectedError(): TapClientError;
+    static cannotDecodeResponseError(err: Error, bufferData: Uint8Array): TapClientError;
+    static unexpectedApduStatusCode(apduResponse: ApduResponse): TapClientError;
+    static cannotEncodeRequest(err: Error, tapRequest: TapRequestFrame): TapClientError;
+}
+export declare namespace TapClientError {
+    enum Code {
+        NotConnectedError = "TapClientErrorNotConnected",
+        EncodeRequestError = "TapClientErrorEncodeRequest",
+        IllegalArgumentError = "TapClientErrorIllegalArgument",
+        IllegalStateError = "TapClientErrorIllegalState",
+        DecodeResponseError = "TapClientErrorDecodeResponse",
+        UnexpectedTapResponse = "TapClientErrorUnexpectedTapResponse",
+        UnexpectedApduResponseStatus = "TapClientErrorUnexpectedApduResponseStatus",
+        CannotEncodeRequest = "TapClientErrorCannotEncodeRequest",
+        TapClientResponseStatusError = "TapClientErrorResponseStatus"
+    }
+}
+export declare class TapClientResponseStatusError extends TapClientError {
+    response: TapResponseFrame;
+    request?: TapRequestFrame | undefined;
+    constructor(response: TapResponseFrame, request?: TapRequestFrame | undefined);
+    static createErrorMessage(response: TapResponseFrame, request?: TapRequestFrame): string;
+}

package/packages/tap/client/impl/src/lib/tap-client.d.ts

@@ -0,0 +1,74 @@
+import { Decoder, Encoder } from '@iotize/common/converter/api';
+import { ProtocolChangeEvent, RequestInterceptorType, TapClientInterface, TapRequestFrame, TapResponseFrame } from '@iotize/tap/client/api';
+import { ComProtocol, ConnectionStateChangeEvent } from '@iotize/tap/protocol/api';
+import { Observable } from 'rxjs';
+import { InterceptorChain } from './interceptors/interceptor-chain';
+export declare class TapClient implements TapClientInterface {
+    private _commandEncoder;
+    private _responseDecoder;
+    private _onProtocolChange;
+    private protocols;
+    private currentProtocolId?;
+    private _interceptorChain;
+    static create(protocol?: ComProtocol): TapClient;
+    constructor(requestEncoder: Encoder<TapRequestFrame, Uint8Array>, responseDecoder: Decoder<Uint8Array, TapResponseFrame>);
+    get interceptorChain(): InterceptorChain;
+    addInterceptor(interceptor: RequestInterceptorType): this;
+    isConnected(): boolean;
+    /**
+     * see {@link getCurrentProtocol}
+     */
+    get protocol(): ComProtocol;
+    get commandEncoder(): Encoder<TapRequestFrame, Uint8Array>;
+    get responseDecoder(): Decoder<Uint8Array<ArrayBuffer>, TapResponseFrame>;
+    /**
+     * Get current protocol or throw an error if no protocol
+     */
+    getCurrentProtocol(): ComProtocol;
+    /**
+     * Register/replace a communication protocol with given id
+     * If no communication protocol is selected yet, it will select it.
+     * @param newProtocol
+     * @param id
+     */
+    addComProtocol(newProtocol: ComProtocol, id?: string): this;
+    /**
+     * Switch to given communication protocol identifier
+     * @throws if protocol identifier does not exist
+     * @param name
+     */
+    switchProtocol(name: string): this;
+    /**
+     * Change communication protocol
+     * @throws if protocol identifier does not exist
+     * @param protocol can either be the communication protocol instance or a string identifier
+     */
+    useComProtocol(protocol: ComProtocol | string): this;
+    /**
+     * Return true if protocol identifier is registered
+     * @param id
+     */
+    hasProtocol(id: any): boolean;
+    connect(): Observable<any>;
+    disconnect(): Observable<any>;
+    /**
+     * Send request
+     * @param request
+     * @param bodyDecoder
+     */
+    request<T>(request: TapRequestFrame): Observable<TapResponseFrame>;
+    /**
+     * Send raw request
+     * No interceptors/No encryption will be triggered
+     * @param dataIn request bytes
+     * @param bodyDecoder optional body decoder to use
+     */
+    send<T>(dataIn: Uint8Array): Observable<TapResponseFrame>;
+    /**
+     * Listen to connection state change event
+     * We have to resubscribe when protocol change..
+     */
+    onConnectionStateChange(): Observable<ConnectionStateChangeEvent>;
+    onProtocolChange(): Observable<ProtocolChangeEvent>;
+    protected _command<T>(command: TapRequestFrame): Observable<TapResponseFrame>;
+}

package/packages/tap/client/impl/src/public_api.d.ts

@@ -0,0 +1,39 @@
+import './lib/generated-adapter';
+export { TapClient } from './lib/tap-client';
+export { TapClientError } from './lib/tap-client-error';
+export { TapRequestFrameBuilder } from './lib/request/tap-request-builder';
+export { TapRequestHelper } from './lib/request/tap-request-helper';
+export { TapResponseFrameBuilder } from './lib/response/tap-response-builder';
+export { ResultCodeTranslation } from './lib/response/result-code-translation';
+export { tapResponseStatusToString } from './lib/response/tap-response-status-to-string';
+export { createApduFromTapRequest } from './lib/apdu/tap-apdu-request-builder';
+export { ArrayConverter, type ArrayConverterOptions, } from './lib/converter/body/array-converter';
+export { BooleanConverter } from './lib/converter/body/boolean-decoder';
+export { ByteSwapConverter } from './lib/converter/body/byte-swap-converter';
+export { ConverterError } from './lib/converter/error';
+export { CryptedFrameConverter } from './lib/converter/crypted-frame-converter';
+export { EnumConverter } from './lib/converter/body/enum-converter';
+export { EnumListConverter } from './lib/converter/body/enum-converter';
+export { FixedSizeEnumConverter } from './lib/converter/body/enum-converter';
+export { FloatConverter, type FloatConverterOptions, } from './lib/converter/body/float-converter';
+export { HexStringConverter } from './lib/converter/body/hex-string';
+export { Ipv4StringConverter } from './lib/converter/body/ipv4-string-decoder';
+export { MacAddressStringConverter } from './lib/converter/body/mac-address-string-decoder';
+export { MultipleMaskConverter } from './lib/converter/body/multiple-mask-decoder';
+export { NumberConverter } from './lib/converter/body/number-converter';
+export { type NumberDecoderOptions } from './lib/converter/body/number-converter';
+export { PipeConverter } from './lib/converter/body/pipe-converter';
+export { PipeConverterBuilder } from './lib/converter/body/pipe-converter';
+export { StringConverter } from './lib/converter/body/string-converter';
+export { TLVConverter } from './lib/converter/tlv-converter';
+export { TlvBundleConverter } from './lib/converter/body/tlv-bundle-converter';
+export { UniqMaskConverter } from './lib/converter/body/uniq-mask-decoder';
+export { StringVersionConverter } from './lib/converter/body/string-version-converter';
+export { TapApduResponseConverter, TapApduRequestConverter, } from './lib/converters';
+export { TAP_REQUEST_FRAME_CONVERTER, TAP_RESPONSE_FRAME_CONVERTER, } from './lib/converters';
+export { createTapEncryptedFrame } from './lib/model/models.extensions';
+export { TapStreamReader, TapStreamWriter, enumKeyOrValueToNumber, } from './lib/frame/tap-stream-core';
+export { CRC } from './lib/error-detection/crc';
+export { Checksum } from './lib/error-detection/checksum';
+export * from './lib/generated-adapter';
+export { type TapStreamEncoderDecoder } from './lib/frame/tap-stream-encoder-decoder';

package/packages/tap/protocol/api/src/lib/com-protocol.interface.d.ts

@@ -0,0 +1,76 @@
+import { Observable } from 'rxjs';
+import { ConnectionState } from './definitions';
+export interface ConnectionStateChangeEvent {
+    newState: ConnectionState;
+    oldState: ConnectionState;
+}
+/**
+ * Communication protocol options
+ */
+export interface ComProtocolOptions {
+    connect: ComProtocolConnectOptions;
+    disconnect: ComProtocolDisconnectOptions;
+    send: ComProtocolSendOptions;
+}
+export interface ComProtocolConnectOptions {
+    timeout: number;
+}
+export interface ComProtocolDisconnectOptions {
+    timeout: number;
+}
+export interface ComProtocolSendOptions {
+    timeout: number;
+}
+export interface ComProtocol {
+    /**
+     * @return connection state (connected or not)
+     */
+    getConnectionState(): ConnectionState;
+    /**
+     * @return true if connection to device has been made
+     */
+    isConnected(): boolean;
+    connect(options?: ComProtocolConnectOptions): Observable<any>;
+    disconnect(options?: ComProtocolConnectOptions): Observable<any>;
+    /**
+     * Send data and wait for response
+     * @param data
+     * @param options
+     */
+    send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
+    write(data: Uint8Array): Promise<any>;
+    read(): Promise<Uint8Array>;
+    /**
+     * Message stream. Any message received by the protocol will be notify on this stream
+     */
+    receiveStream(): Observable<Uint8Array>;
+    /**
+     * Observe connection state changes
+     */
+    onConnectionStateChange(): Observable<ConnectionStateChangeEvent>;
+}
+export declare namespace ComProtocol {
+    class Errors extends Error {
+        code: ErrorCode;
+        static operationCanceled(): Errors;
+        static notConnected(info: {
+            protocol: ComProtocol;
+        }): Errors;
+        static timeoutError(info: {
+            msg?: string;
+            protocol: ComProtocol;
+            timeout: number;
+            startTime: Date;
+        }): Errors;
+        static operationInProgress(msg: string): Errors;
+        static unknownError(): Errors;
+        private constructor();
+    }
+    enum ErrorCode {
+        ProtocolNotConnected = "ProtocolNotConnected",
+        TimeoutError = "TimeoutError",
+        UnknownError = "UnknownError",
+        OperationCancelled = "OperationCancelled",
+        OperationInProgress = "ComProtocolOperationInProgress"
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare enum ConnectionState {
+    DISCONNECTED = 0,
+    CONNECTING = 1,
+    CONNECTED = 2,
+    DISCONNECTING = 3
+}

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

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

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

@@ -0,0 +1,49 @@
+import { QueueComProtocol } from '@iotize/tap/protocol/core';
+import { BLEPacketBuilder } from './ble-packet-builder';
+import { BLEPacketSplitter } from './ble-packet-splitter';
+import { BleComError } from './errors';
+/**
+ * @deprecated use UniversalBleProtocolAdpater
+ * Abstract class for 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 abstract class AbstractBleProtocol extends QueueComProtocol {
+    bleOptions: {
+        mtu: number;
+    };
+    static RECEIVED_BUFFER_LENGTH: number;
+    protected packetBuilder?: BLEPacketBuilder;
+    protected packetSplitter?: BLEPacketSplitter;
+    protected _readReject?: (reason?: any) => void;
+    protected _pendingRead?: Uint8Array;
+    protected _readResolve?: (value: Uint8Array | PromiseLike<Uint8Array>) => void;
+    protected _readPromise?: Promise<Uint8Array>;
+    /**
+     * Actual implementation to send a packet chunk with ble
+     */
+    abstract writeLwm2mPacketChunk(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Actual implementation to listen ble messages coming from LWM2M IoTize device
+     */
+    abstract subscribeToLwm2mMessage(): void;
+    constructor(bleOptions?: {
+        mtu: number;
+    });
+    onNewLwm2mMessage(data: Uint8Array): void;
+    onNewLwm2mMessageError(err: Error): void;
+    onLwm2mDataChunkError(error: BleComError): void;
+    getLwm2mResponsePromise(): Promise<Uint8Array<ArrayBuffer>>;
+    createLwm2mResponsePromise(): Promise<Uint8Array>;
+    read(): Promise<Uint8Array>;
+    write(data: Uint8Array): Promise<any>;
+    /**
+     *
+     * @param data data chunk
+     */
+    onNewLwm2mPacket(data: Uint8Array): void;
+}

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

@@ -0,0 +1,20 @@
+export declare const BleConfig: {
+    maxPacketLengthWithoutOffset: number;
+    services: {
+        upgrade: {
+            service: string;
+            charac: string;
+        };
+        lwm2m: {
+            service: string;
+            charac: string;
+        };
+        fastLwm2m: {
+            service: string;
+            charac: string;
+        };
+        standardClientConfig: {
+            service: string;
+        };
+    };
+};

package/packages/tap/protocol/ble/common/src/lib/ble-packet-builder.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Created by IoTize on 19/04/2018.
+ * <p>
+ * Glue packet chunk to build the original ble packet
+ * @param {number} bufferLength
+ * @class
+ */
+export declare class BLEPacketBuilder {
+    bufferOffset: number;
+    protected data: Uint8Array;
+    dataLength: number;
+    constructor(bufferLength: number);
+    /**
+     * Append new chunk of data into the builder
+     * @param {Array} dataChunk the data chunk. The first byte must be the position offset of this chunk in the buffer (in bytes)
+     */
+    append(dataChunk: Uint8Array): void;
+    reset(): void;
+    hasAllChunks(): boolean;
+    isChecksumValid(): boolean;
+    getComputedChecksum(): number;
+    getExpectedChecksum(): number;
+    /**
+     * @return {Array} the result data without the checksum
+     */
+    getData(): Uint8Array;
+    /**
+     * @return {Array} the buffer (with the checksum)
+     */
+    getBuffer(): Uint8Array;
+}

package/packages/tap/protocol/ble/common/src/lib/ble-packet-splitter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Created by IoTize on 19/04/2018.
+ *
+ * Split data into chunks with a size of maxPacketSize + 1
+ * @param {Array} data
+ * @param {number} maxPacketSize
+ * @class
+ */
+export declare class BLEPacketSplitter {
+    lastPacketSize: number;
+    data: Uint8Array;
+    maxPacketSize: number;
+    currentPacketIndex: number;
+    /**
+     *
+     * @param data
+     * @param maxPacketSize
+     */
+    constructor(data: Uint8Array, maxPacketSize: number);
+    /**
+     * Create a BLEPacketSplitter instance from data and add the checksum at the end
+     * @param {Array} data body data
+     * @param {number} maxPacketSize packet size
+     * @return {BLEPacketSplitter} the new instance
+     */
+    static wrapWithChecksum(data: Uint8Array, maxPacketSize: number): BLEPacketSplitter;
+    getTotalNumberOfPacket(): number;
+    getLastPacketSize(): number;
+    getPackets(): Uint8Array[];
+    getNextPacket(): Uint8Array;
+    hasNextPacket(): boolean;
+    static computeChecksum(data: Uint8Array): number;
+    getTotalSize(): number;
+}

package/packages/tap/protocol/ble/common/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/ble/common/src/lib/errors.d.ts

@@ -0,0 +1,28 @@
+import { CodeError } from '@iotize/common/error';
+import { BLEPacketBuilder } from './ble-packet-builder';
+export declare class BleComError extends CodeError<BleComError.Code> {
+    static invalidBleChunkChecksum(packetBuilder: BLEPacketBuilder): InvalidBleFrameChecksum;
+    static writeSizeAboveMTU(data: Uint8Array, mtu: number): BleComError;
+    static serviceNotFound(uuid: string): BleComError;
+    static charcacteristicNotFound(uuid: string): BleComError;
+    static bleNotAvailable(msg?: string): BleComError;
+    static gattServerNotAvailable(): BleComError;
+    static gattServerConnectionFailed(): BleComError;
+    constructor(code: BleComError.Code, msg: string);
+}
+export declare class InvalidBleFrameChecksum extends BleComError {
+    packetBuilder: BLEPacketBuilder;
+    constructor(packetBuilder: BLEPacketBuilder);
+    static create(packetBuilder: BLEPacketBuilder): InvalidBleFrameChecksum;
+}
+export declare namespace BleComError {
+    enum Code {
+        InvalidChecksum = "InvalidChecksum",
+        BleGattServiceNotFound = "BleGattServiceNotFound",
+        BleGattCharacteristicNotFound = "BleGattCharacteristicNotFound",
+        BleWriteSizeAboveMTU = "BleWriteSizeAboveMTU",
+        GATTServerNotAvailable = "BleComErrorGATTServerNotAvailable",
+        GATTServerConnectionFailed = "BleComErrorGATTServerConnectionFailed",
+        NotAvailable = "BleComErrorNotAvailable"
+    }
+}