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

package/CHANGELOG.md

@@ -0,0 +1,143 @@
+## 3.5.2 (2024-01-02)
+
+### Bug Fixes
+
+- fix ble connection status after `connect()` method successful. 28642ac
+
+## 3.5.1 (2023-11-21)
+
+### Bug Fixes
+
+- android.permission.ACCESS_FINE_LOCATION for maxSdkVersion 32 399971d
+
+# 3.5.0 (2023-11-21)
+
+### Features
+
+- added support for rxjs@7 98c7a3b
+
+## 3.4.2 (2023-07-17)
+
+### Bug Fixes
+
+- fix android `BLECom.close()` method on Android 11 and below 8375e49
+
+# 3.4.1 (2023-02-20)
+
+### Bug Fixes
+
+- added check permission before attempting BLE tap connect (**Android only**) 66b7418
+- detect ble disconnection error during send requests and remove peripheral from cache to allow reconnection de556ca
+
+### Others
+
+- Updated dependency `org.apache.commons:commons-collections4:4.1` to `org.apache.commons:commons-collections4:4.4`
+
+# 3.4.0 (2022-11-23)
+
+### Features
+
+- Support for android target sdk 31 (Android 11)
+
+## 3.3.2 (2022-09-12)
+
+### Bug Fixes
+
+- changed default connection priority to CONNECTION_PRIORITY_BALANCED (to work with TAP WB) 0e38fc6
+- fix des problèmes de build auto sur iOS 15
+
+## 3.3.1 (2022-03-22)
+
+### Bug Fixes
+
+- added gradle option allowInsecureProtocol = true 4111e89
+
+# 3.3.0 (2022-01-11)
+
+### Features
+
+- added additional `CordovaBLEError.Code` error 0e123b5
+- ask user to enable ble on connect if it's currently disabled 7da5d14
+
+## 3.2.1 (2022-01-11)
+
+### Features
+
+- added `close()` exposed method def9d79
+- added `requestEnableBle()` method f5453e4
+
+## 3.1.0 (2021-09-30)
+
+- Changed plugin identifier from `cordova-plugin-iotize-device-com-ble` to `@iotize/device-com-ble.cordova` (requires cordova >= 10)
+
+### Features
+
+- added functions to `IoTizeBleCordovaPlugin`:
+  - `requestMTU`
+  - `characteristicStartNotification`
+  - `characteristicStopNotification`
+  - `characteristicReadValue`
+  - `characteristicWrite`
+  - `characteristicWriteWithoutResponse`
+
+## 3.0.2 (2021-03-02)
+
+- fix optional constructor parameter for `BLEScanner`
+
+## 3.0.1 (2021-03-02)
+
+### Bug Fixes
+
+- lazy reference to iotizeBLE. iotizeBLE variable will not be referenced until it's required. bf783c7
+
+<a name="3.0.0"></a>
+
+# [3.0.0](https://bitbucket.org/iotize-solutions/tap-workspace/compare/v3.0.0-alpha.1...v3.0.0) (2021-02-19)
+
+<a name="3.0.0-alpha.1"></a>
+
+# [3.0.0-alpha.1](https://bitbucket.org/iotize-solutions/tap-workspace/compare/v2.0.0-alpha.5...v3.0.0-alpha.1) (2020-12-11)
+
+- Migrated to `@iotize/tap@2.0.0` APIs
+
+<a name="2.0.0-alpha.5"></a>
+
+# [2.0.0-alpha.5] (2020-08-28)
+
+### Bug Fixes
+
+- changed background thread in iOS swift plugin 4d61ef4
+- `checkState` waits for an update only if BLE state is unknown. 5260298
+- Scan no longer needs active location to work fb2b469
+- **scanner:** fix "ble" spelling to "BLE" ce6c3cb
+
+### Features
+
+- renamed interface `DiscoveredDeviceType` into `CordovaBLEScanResult` 3ed0259
+
+<a name="1.1.0-alpha.30"></a>
+
+- Improved BLE device Scanner
+
+<a name="1.1.0-alpha.23"></a>
+
+- fix: iOS : CheckAvailable now uses actual bluetooth manager state
+
+<a name="1.1.0-alpha.21"></a>
+
+# [1.1.0-alpha.21](2019-04-04)
+
+- fix: Scan no longer needs active location to work
+
+<a name="1.1.0-alpha.20"></a>
+
+# [1.1.0-alpha.20](2019-03-06)
+
+## Breaking changes :
+
+- Added minified files
+- non minified js and typescript declaration files now imported from '@iotize/cordova-device-iotize-ble' (used to be '@iotize/cordova-device-iotize-ble/dist')
+
+<a name="1.1.0-alpha.18"></a>
+
+# [1.1.0-alpha.18](2019-03-06)

package/package.json

@@ -1,8 +1,11 @@
 {
   "author": "IoTize <contact@iotize.com>",
   "license": "MIT",
+  "homepage": "http://developer.iotize.com",
   "name": "@iotize/device-com-ble.cordova",
-  "version": "3.7.2",
+  "version": "4.0.0-alpha.1",
+  "main": "plugin.js",
+  "types": "packages/device-com-ble.cordova/src/plugin.d.ts",
   "cordova": {
     "id": "@iotize/device-com-ble.cordova",
     "platforms": [
@@ -12,12 +15,7 @@
     ]
   },
   "description": "Bluetooth Low Energy (BLE) for IoTize modules Plugin",
-  "peerDependencies": {
-    "@iotize/common": "^2.0.0",
-    "@iotize/tap": "^2.8.0",
-    "debug": "^4.1.0",
-    "rxjs": "^6.0.0 || ^7.0.0"
-  },
+  "peerDependencies": {},
   "keywords": [
     "bluetooth",
     "BLE",
@@ -34,17 +32,5 @@
     "cordova-android",
     "cordova-windows",
     "cordova-ios"
-  ],
-  "homepage": "http://developer.iotize.com",
-  "main": "bundles/iotize-device-com-ble.cordova.umd.js",
-  "module": "fesm2015/iotize-device-com-ble.cordova.js",
-  "es2015": "fesm2015/iotize-device-com-ble.cordova.js",
-  "esm2015": "esm2015/iotize-device-com-ble.cordova.js",
-  "fesm2015": "fesm2015/iotize-device-com-ble.cordova.js",
-  "typings": "iotize-device-com-ble.cordova.d.ts",
-  "metadata": "iotize-device-com-ble.cordova.metadata.json",
-  "sideEffects": false,
-  "dependencies": {
-    "tslib": "^2.2.0"
-  }
-}
+  ]
+}

package/packages/common/byte-converter/src/lib/byte-converter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Convert a ASCII string to byte buffer
+ * For example "01" will give [0x30, 0x31]
+ * @param str
+ */
+export declare function asciiStringToByteBuffer(str: string): Uint8Array;
+export declare function typedArrayToBuffer(array: Uint8Array): ArrayBuffer;
+/**
+ * Convert a byte buffer to the hexadecimal string representation
+ * For example [0x1, 0x2] will returns string "0102"
+ * @param buffer
+ */
+export declare function bufferToHexString(buffer: Uint8Array): string;
+/**
+ * Convert a byte buffer to the binary string representation
+ * For example [0x1, 0x2] will returns string "0000000100000002"
+ * @param buffer
+ */
+export declare function bufferToBinaryString(buffer: Uint8Array): string;
+/**
+ * Convert an hexadecimal string to a buffer
+ * For example "0102" or "01 02" will returns string [0x1, 0x2]
+ * @param hexString
+ */
+export declare function hexStringToBuffer(hexString: string): Uint8Array;
+/**
+ * Converts data to an ascii string
+ * @param data
+ */
+export declare function bufferToAsciiString(data: Uint8Array | number[]): string;

package/packages/common/byte-converter/src/public_api.d.ts

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

package/packages/common/byte-stream/src/lib/kaitai/kaitai-stream-reader.d.ts

@@ -0,0 +1,155 @@
+import { KaitaiStream, StreamBufferType } from './kaitai-stream';
+/**
+ * KaitaiStreamReader is an implementation of Kaitai Struct API for JavaScript.
+ *
+ * Some functions are based on KaitaiStream.js - https://github.com/kaitai-io/kaitai_struct_javascript_runtime/blob/master/KaitaiStream.js that comes with the following license
+ *
+ * @license Copyright 2012-2016 Ilmari Heikkinen Copyright 2016-2020 Kaitai Project licensed under Apache License, Version 2.0 (the "License");
+ *
+ * Implementation has been translated to Typescript and modified to fit our needs
+ */
+export declare class KaitaiStreamReader extends KaitaiStream {
+    static fromArray(array: Uint8Array): KaitaiStreamReader;
+    static create(packet: Uint8Array | KaitaiStreamReader): KaitaiStreamReader;
+    /**
+     * @param arrayBuffer ArrayBuffer to read from.
+     * @param byteOffset Offset from arrayBuffer beginning for the KaitaiStream.
+     */
+    constructor(arrayBuffer?: StreamBufferType, byteOffset?: number, isBigEndian?: boolean);
+    readS(size: 1 | 2 | 4): number;
+    readSigned(size: 1 | 2 | 4): number;
+    read(type: 'f' | 'u' | 's' | 'b', bitSize: number, isLittleEndian?: boolean): any;
+    /**
+        Reads an 8-bit signed int from the stream.
+        @return {number} The read number.
+       */
+    readS1(): number;
+    /**
+        Reads a 16-bit big-endian signed int from the stream.
+        @return {number} The read number.
+       */
+    readS2be(): number;
+    /**
+        Reads a 32-bit big-endian signed int from the stream.
+        @return {number} The read number.
+       */
+    readS4be(): number;
+    /**
+        Reads a 64-bit big-endian unsigned int from the stream. Note that
+        JavaScript does not support 64-bit integers natively, so it will
+        automatically upgrade internal representation to use IEEE 754
+        double precision float.
+        @return {number} The read number.
+       */
+    readS8be(): number;
+    /**
+        Reads a 16-bit little-endian signed int from the stream.
+        @return {number} The read number.
+       */
+    readS2le(): number;
+    /**
+        Reads a 32-bit little-endian signed int from the stream.
+        @return {number} The read number.
+       */
+    readS4le(): number;
+    /**
+        Reads a 64-bit little-endian unsigned int from the stream. Note that
+        JavaScript does not support 64-bit integers natively, so it will
+        automatically upgrade internal representation to use IEEE 754
+        double precision float.
+        @return {number} The read number.
+       */
+    readS8le(): number;
+    /**
+     * Read unsigned
+     * @param size
+     */
+    readU(size: 1 | 2 | 4 | number): number;
+    readUnsigned(size: 1 | 2 | 4 | number): number;
+    /**
+        Reads an 8-bit unsigned int from the stream.
+        @return {number} The read number.
+       */
+    readU1(): number;
+    /**
+        Reads a 16-bit big-endian unsigned int from the stream.
+        @return {number} The read number.
+       */
+    readU2be(): number;
+    /**
+        Reads a 32-bit big-endian unsigned int from the stream.
+        @return {number} The read number.
+       */
+    readU4be(): number;
+    /**
+        Reads a 64-bit big-endian unsigned int from the stream. Note that
+        JavaScript does not support 64-bit integers natively, so it will
+        automatically upgrade internal representation to use IEEE 754
+        double precision float.
+        @return {number} The read number.
+       */
+    readU8be(): number;
+    /**
+        Reads a 16-bit little-endian unsigned int from the stream.
+        @return {number} The read number.
+       */
+    readU2le(): number;
+    /**
+        Reads a 32-bit little-endian unsigned int from the stream.
+        @return {number} The read number.
+       */
+    readU4le(): number;
+    /**
+        Reads a 64-bit little-endian unsigned int from the stream. Note that
+        JavaScript does not support 64-bit integers natively, so it will
+        automatically upgrade internal representation to use IEEE 754
+        double precision float.
+        @return {number} The read number.
+       */
+    readU8le(): number;
+    readF(size: 4 | 8): number;
+    readFloat(size: 4 | 8): number;
+    readF4be(): number;
+    readF8be(): number;
+    readF4le(): number;
+    readF8le(): number;
+    readBitsBoolean(n: number): boolean;
+    readB(n: number): number;
+    readBits(n: number): number;
+    readBoolean(n: number): boolean;
+    /**
+     * Read n bits as unsigned integer
+     * @param n
+     * @returns
+     */
+    readBitsInt(n: number): number;
+    /**
+     *
+     * @param len number of bytes(s) to read. If value is < 0, read until up to buffer position 'size - |len|'
+     */
+    readBytes(len?: number): Uint8Array;
+    /**
+     * Read all remaining bytes in buffer
+     */
+    readBytesFull(): Uint8Array<ArrayBuffer>;
+    /**
+     * Read bytes until terminator value is found
+     * @throws if eosError is set to true and terminator is not found
+     *
+     * @param terminator value to search for
+     * @param include true to include terminator to result
+     * @param consume true to consume terminator
+     * @param eosError true to throw an error if we reach end of stream
+     */
+    readBytesTerm(terminator: number, { include, consume, eosError, }?: {
+        include?: boolean;
+        consume?: boolean;
+        eosError?: boolean;
+    }): Uint8Array<ArrayBuffer>;
+    /**
+     * Ensure that the next stream bytes are the one expected
+     * @param expected expected content to check
+     * @throws UnexpectedDataError is not the expected bytes
+     */
+    ensureFixedContents(expected: Uint8Array): Uint8Array<ArrayBuffer>;
+}

package/packages/common/byte-stream/src/lib/kaitai/kaitai-stream-writer.d.ts

@@ -0,0 +1,76 @@
+import { KaitaiStream, StreamBufferType } from './kaitai-stream';
+export declare class KaitaiStreamWriter extends KaitaiStream {
+    options: {
+        /**
+         * True to check that value we are trying to write fit the available size.
+         * For example it will throw an error if trying to write 0xFFFF on 1 byte.
+         */
+        checkValueSize: boolean;
+    };
+    /**
+     * @param arrayBuffer ArrayBuffer to read from.
+     * @param byteOffset Offset from arrayBuffer beginning for the KaitaiStream.
+     */
+    constructor(arrayBuffer?: StreamBufferType, byteOffset?: number, isBigEndian?: boolean, options?: {
+        /**
+         * True to check that value we are trying to write fit the available size.
+         * For example it will throw an error if trying to write 0xFFFF on 1 byte.
+         */
+        checkValueSize: boolean;
+    });
+    /**
+     * Utility function to merge byte arrays
+     * @param data
+     */
+    static mergeArrays(...data: Uint8Array[]): Uint8Array<ArrayBuffer>;
+    static create(size: number): KaitaiStreamWriter;
+    get toBytes(): Uint8Array;
+    /**
+     *
+     * @param value
+     * @param type
+     * @param size size in bits
+     */
+    write(value: number | boolean, type: 'f' | 'u' | 's' | 'b', size: number): any;
+    /**
+     * Append value on 1 byte
+     * @param value
+     */
+    writeByte(value: number): this;
+    writeU(value: number, byteSize: number): this;
+    writeF(value: any, byteSize: number): this;
+    writeS(value: any, byteSize: number): this;
+    /**
+     * @deprecated flush bit calls are now useless
+     * @param v
+     */
+    flushBits(): void;
+    private _setBitsAtCurrentPosition;
+    _setBit(value: boolean): this;
+    /**
+     * Write bit per bit
+     * @param v
+     * @param n
+     */
+    writeB(v: number | boolean, n?: number): this;
+    forwardBit(): void;
+    /**
+     *
+     * @param v true or false
+     * @param n number of bits
+     */
+    writeBitsBoolean(v: boolean, n: number): this;
+    /**
+     * Append given bytes to stream
+     * @param data
+     * @param size
+     */
+    writeBytes(data: Uint8Array, size?: number): this;
+    /**
+     * Check that buffer size has enaugh room to add the byteSize bytes
+     * Will resize buffer if not
+     * @param byteSize
+     */
+    private _checkSize;
+    resize(newSize: number): void;
+}

package/packages/common/byte-stream/src/lib/kaitai/kaitai-stream.d.ts

@@ -0,0 +1,209 @@
+export type StreamBufferType = ArrayBufferLike | DataView;
+/**
+ * KaitaiStream is an implementation of Kaitai Struct API for JavaScript.
+ *
+ * It's based on KaitaiStream.js - https://github.com/kaitai-io/kaitai_struct_javascript_runtime/blob/master/KaitaiStream.js that comes with the following license
+ *
+ * @license Copyright 2012-2016 Ilmari Heikkinen Copyright 2016-2020 Kaitai Project licensed under Apache License, Version 2.0 (the "License");
+ *
+ * Implementation has been translated to Typescript and modified to fit our needs
+ */
+export declare abstract class KaitaiStream {
+    /**
+     * @param arrayBuffer ArrayBuffer to read from.
+     * @param byteOffset Offset from arrayBuffer beginning for the KaitaiStream.
+     * @param isBigEndian
+     */
+    constructor(arrayBuffer?: StreamBufferType, byteOffset?: number, isBigEndian?: boolean);
+    get byteLeft(): number;
+    set pos(v: number);
+    get pos(): number;
+    /**
+          Set/get the backing ArrayBuffer of the KaitaiStream object.
+          The setter updates the DataView to point to the new buffer.
+          @type {Object}
+          */
+    get buffer(): ArrayBufferLike;
+    get toBytes(): Uint8Array;
+    set buffer(v: ArrayBuffer);
+    get isBigEndian(): boolean;
+    get isLittleEndian(): boolean;
+    /**
+        Set/get the byteOffset of the KaitaiStream object.
+        The setter updates the DataView to point to the new byteOffset.
+        @type {number}
+        */
+    get byteOffset(): number;
+    set byteOffset(v: number);
+    /**
+        Set/get the backing DataView of the KaitaiStream object.
+        The setter updates the buffer and byteOffset to point to the DataView values.
+        @type {Object}
+        */
+    get dataView(): DataView<ArrayBuffer>;
+    set dataView(v: DataView<ArrayBuffer>);
+    /**
+        Returns the byte length of the KaitaiStream object.
+        @type {number}
+        */
+    get size(): number;
+    static iconvlite: any;
+    static zlib: any;
+    /**
+        Dependency configuration data. Holds urls for (optional) dynamic loading
+        of code dependencies from a remote server. For use by (static) processing functions.
+        Caller should the supported keys to the asset urls as needed.
+        NOTE: `depUrls` is a static property of KaitaiStream (the factory),like the various
+              processing functions. It is NOT part of the prototype of instances.
+        @type {Object}
+        */
+    static depUrls: {
+        zlib: any | undefined;
+    };
+    /**
+        Native endianness. Either KaitaiStream.BIG_ENDIAN or KaitaiStream.LITTLE_ENDIAN
+        depending on the platform endianness.
+        @type {boolean}
+       */
+    static endianness: boolean;
+    protected _byteOffset: number;
+    protected _buffer: ArrayBufferLike;
+    protected _dataView: DataView;
+    protected _pos: number;
+    protected _bitsLeft: number;
+    /**
+     * Number of bits left to read/write for the current byte (when read bit by bit instead of bytes)
+     * Number between 8 and 1
+     * @deprecated
+     */
+    get bitsLeft(): number;
+    /**
+     * @deprecated will be removed in future release
+     */
+    get bits(): number;
+    /**
+        Virtual byte length of the KaitaiStream backing buffer.
+        Updated to be max of original buffer size and last written size.
+        If dynamicSize is false is set to buffer size.
+        @type {number}
+        */
+    _byteLength: number;
+    _isBigEndian: boolean;
+    static bytesStripRight(data: Uint8Array, padByte: number): Uint8Array<ArrayBuffer>;
+    static bytesTerminate(data: Uint8Array, term: number, include?: boolean): Uint8Array<ArrayBuffer>;
+    /**
+     * @deprecated will be removed in future major release
+     * @param arr
+     * @param encoding
+     * @returns
+     */
+    static bytesToStr(arr: Uint8Array, encoding: string): string;
+    /**
+     * @deprecated
+     * @param a
+     * @param b
+     * @returns
+     */
+    static mod(a: number, b: number): number;
+    /**
+     * @deprecated
+     * @param a
+     * @param b
+     * @returns
+     */
+    static arrayMin(arr: Uint8Array): number;
+    /**
+     * @deprecated
+     * @param a
+     * @param b
+     * @returns
+     */
+    static arrayMax(arr: Uint8Array): number;
+    /**
+     * @deprecated
+     * @param a
+     * @param b
+     * @returns
+     */
+    static byteArrayCompare(a: Uint8Array, b: Uint8Array): number;
+    /**
+      * @deprecated
+      * Creates an array from an array of character codes.
+        Uses String.fromCharCode in chunks for memory efficiency and then concatenates
+        the resulting string chunks.
+        @param {array} array Array of character codes.
+        @return {string} String created from the character codes.
+      */
+    static createStringFromArray(array: any): string;
+    /**
+     * @deprecated
+     * @param data
+     * @param key
+     * @returns
+     */
+    static processXorOne(data: Uint8Array, key: number): Uint8Array<ArrayBuffer>;
+    /**
+     * @deprecated
+     * @param data
+     * @param key
+     * @returns
+     */
+    static processXorMany(data: Uint8Array, key: Uint8Array): Uint8Array<ArrayBuffer>;
+    /**
+     * @deprecated
+     * @param data
+     * @param amount
+     * @param groupSize
+     * @returns
+     */
+    static processRotateLeft(data: Uint8Array, amount: number, groupSize: number): Uint8Array<ArrayBuffer>;
+    getStreamSize(): number;
+    alignToByte(): void;
+    protected _getBitsFromCurrentPosition(): number;
+    protected _decreaseBitsLeft(val: number): void;
+    /**
+        Internal function to trim the KaitaiStream buffer when required.
+        Used for stripping out the extra bytes from the backing buffer when
+        the virtual byteLength is smaller than the buffer byteLength (happens after
+        growing the buffer with writes and not filling the extra space completely).
+        @return {null}
+        */
+    _trimAlloc(): void;
+    /**
+        Returns true if the KaitaiStream seek pointer is at the end of buffer and
+        there's no more data to read.
+        @return {boolean} True if the seek pointer is at the end of the buffer.
+        */
+    isEof(): boolean;
+    forward(relativePosition: number): this;
+    /**
+        Sets the KaitaiStream read/write position to given position.
+        Clamps between 0 and KaitaiStream length.
+        @param {number} pos Position to seek to.
+        @return {null}
+        */
+    seek(pos: number): void;
+    forwardBits(n: number): this;
+    setBitPosition(bitPosition: number): void;
+    getBitPosition(): number;
+    /**
+        Maps a Uint8Array into the KaitaiStream buffer.
+        Nice for quickly reading in data.
+        @param {number} length Number of elements to map.
+        @return {Object} Uint8Array to the KaitaiStream backing buffer.
+        */
+    mapUint8Array(length: number): Uint8Array;
+}
+export declare class EOFError extends Error {
+    bytesReq: number;
+    bytesAvail: number;
+    constructor(bytesReq: number, bytesAvail: number);
+}
+export declare class UnexpectedDataError extends Error {
+    expected: Uint8Array;
+    actual: Uint8Array;
+    constructor(expected: Uint8Array, actual: Uint8Array);
+}
+export declare class UndecidedEndiannessError extends Error {
+    constructor();
+}

package/packages/common/byte-stream/src/lib/utility.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bit wise & operator that works with number > 32bits
+ *
+ * @param v1
+ * @param v2
+ * @returns
+ */
+export declare function bitWiseAnd(v1: number, v2: number): number;
+/**
+ * Bit wise | operator that works with number > 32bits
+ *
+ * @param v1
+ * @param v2
+ * @returns
+ */
+export declare function bitWiseOr(v1: number, v2: number): number;

package/packages/common/byte-stream/src/public_api.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/kaitai/kaitai-stream';
+export * from './lib/kaitai/kaitai-stream-reader';
+export * from './lib/kaitai/kaitai-stream-writer';
+export { bitWiseOr, bitWiseAnd } from './lib/utility';

package/packages/common/converter/api/src/lib/converter.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Converter<InputType, OutputType> {
+    convert(value: InputType): OutputType;
+}

package/packages/common/converter/api/src/lib/decoder.interface.d.ts

@@ -0,0 +1,4 @@
+export interface Decoder<InputType, OutputType> {
+    decode(type: InputType): OutputType;
+}
+export type DecoderFct<InputType, OutputType> = (input: InputType) => OutputType;