@iotize/device-com-nfc.cordova 3.8.1 → 3.9.0

package/fesm2015/iotize-device-com-nfc.cordova.js

@@ -1,450 +1,578 @@
 import { Buffer } from 'buffer';
-import { bufferToAsciiString, bufferToHexString, hexStringToBuffer } from '@iotize/common/byte-converter';
+import { bufferToAsciiString, asciiStringToByteBuffer, bufferToHexString, hexStringToBuffer } from '@iotize/common/byte-converter';
 import { ConnectionState } from '@iotize/tap/protocol/api';
 import { QueueComProtocol } from '@iotize/tap/protocol/core';
 import { defer } from 'rxjs';
 import { createDebugger } from '@iotize/common/debug';
 
-class NfcError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-    static tagLostError() {
-        return new NfcError(NfcError.ErrorCode.TagLostError, 'NFC tag lost');
-    }
-    static notConnectedError() {
-        return new NfcError(NfcError.ErrorCode.NotConnectedError, 'NFC tag is not connected');
-    }
-    static unknownError(errString) {
-        throw new NfcError(NfcError.ErrorCode.Unknown, errString);
-    }
-    static tagConnectionFailed() {
-        throw new NfcError(NfcError.ErrorCode.NotConnectedError, `Tag connection failed`);
-    }
-    static internalError(message) {
-        throw new NfcError(NfcError.ErrorCode.InternalError, message);
-    }
-}
-(function (NfcError) {
-    let ErrorCode;
-    (function (ErrorCode) {
-        ErrorCode["Unknown"] = "NfcUnknownError";
-        ErrorCode["InternalError"] = "NfcInternalError";
-        ErrorCode["TagLostError"] = "NfcTagLostError";
-        ErrorCode["NotConnectedError"] = "NfcNotConnectedError";
-    })(ErrorCode = NfcError.ErrorCode || (NfcError.ErrorCode = {}));
+class NfcError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+    static tagLostError() {
+        return new NfcError(NfcError.ErrorCode.TagLostError, 'NFC tag lost');
+    }
+    static notConnectedError() {
+        return new NfcError(NfcError.ErrorCode.NotConnectedError, 'NFC tag is not connected');
+    }
+    static unknownError(errString) {
+        throw new NfcError(NfcError.ErrorCode.Unknown, errString);
+    }
+    static tagConnectionFailed() {
+        throw new NfcError(NfcError.ErrorCode.NotConnectedError, `Tag connection failed`);
+    }
+    static internalError(message) {
+        throw new NfcError(NfcError.ErrorCode.InternalError, message);
+    }
+}
+(function (NfcError) {
+    let ErrorCode;
+    (function (ErrorCode) {
+        ErrorCode["Unknown"] = "NfcUnknownError";
+        ErrorCode["InternalError"] = "NfcInternalError";
+        ErrorCode["TagLostError"] = "NfcTagLostError";
+        ErrorCode["NotConnectedError"] = "NfcNotConnectedError";
+    })(ErrorCode = NfcError.ErrorCode || (NfcError.ErrorCode = {}));
 })(NfcError || (NfcError = {}));
 
-var TNF;
-(function (TNF) {
-    TNF[TNF["EMPTY"] = 0] = "EMPTY";
-    TNF[TNF["WELL_KNOWN_TYPE"] = 1] = "WELL_KNOWN_TYPE";
-    TNF[TNF["MIME_TYPE"] = 2] = "MIME_TYPE";
-    TNF[TNF["ABSOLUTE_URI"] = 3] = "ABSOLUTE_URI";
-    TNF[TNF["EXTERNAL"] = 4] = "EXTERNAL";
-    TNF[TNF["UNKNOWN"] = 5] = "UNKNOWN";
-    TNF[TNF["UNCHANGED"] = 6] = "UNCHANGED";
-    TNF[TNF["RFU"] = 7] = "RFU";
-})(TNF || (TNF = {}));
-const WellKnownType = {
-    URI: [0x55],
-    TEXT: [0x54],
-    SMPART_POSTER: [0x53, 0x70],
+var TNF;
+(function (TNF) {
+    TNF[TNF["EMPTY"] = 0] = "EMPTY";
+    TNF[TNF["WELL_KNOWN_TYPE"] = 1] = "WELL_KNOWN_TYPE";
+    TNF[TNF["MIME_TYPE"] = 2] = "MIME_TYPE";
+    TNF[TNF["ABSOLUTE_URI"] = 3] = "ABSOLUTE_URI";
+    TNF[TNF["EXTERNAL"] = 4] = "EXTERNAL";
+    TNF[TNF["UNKNOWN"] = 5] = "UNKNOWN";
+    TNF[TNF["UNCHANGED"] = 6] = "UNCHANGED";
+    TNF[TNF["RFU"] = 7] = "RFU";
+})(TNF || (TNF = {}));
+const WellKnownType = {
+    URI: [0x55],
+    TEXT: [0x54],
+    SMPART_POSTER: [0x53, 0x70],
 };
 
-function toAsciiString(payload) {
-    if (payload.length > 0 && payload[0] === 0) {
-        payload = payload.slice(1);
-    }
-    return bufferToAsciiString(payload);
-}
-function arrayEquals(a1, a2) {
-    return (a1.length === a2.length && a1.every((a1Item, index) => a1Item === a2[index]));
+function toAsciiString(payload) {
+    if (payload.length > 0 && payload[0] === 0) {
+        payload = payload.slice(1);
+    }
+    return bufferToAsciiString(payload);
+}
+function arrayEquals(a1, a2) {
+    return (a1.length === a2.length && a1.every((a1Item, index) => a1Item === a2[index]));
 }
 
-function parseNdefMessages(messages) {
-    return (messages || []).map(parseNdefMessage);
-}
-function parseNdefMessage(message) {
-    switch (message.tnf) {
-        case TNF.ABSOLUTE_URI:
-            return {
-                tnf: 'uri',
-                value: toAsciiString(message.payload),
-            };
-        case TNF.WELL_KNOWN_TYPE:
-            return {
-                tnf: 'wkt',
-                value: parseWellKnownType(message),
-            };
-        case TNF.EMPTY:
-            return {
-                tnf: 'empty',
-                value: {
-                    type: message.type,
-                    payload: message.payload,
-                },
-            };
-        case TNF.EXTERNAL:
-            return {
-                tnf: 'external',
-                value: paseExternalType(message),
-            };
-        case TNF.MIME_TYPE:
-            return {
-                tnf: 'mimetype',
-                value: parseMimeType(message),
-            };
-        case TNF.RFU:
-            return {
-                tnf: 'rfu',
-                value: {
-                    type: message.type,
-                    payload: message.payload,
-                },
-            };
-        case TNF.UNCHANGED:
-            return {
-                tnf: 'unchanged',
-                value: {
-                    type: message.type,
-                    payload: message.payload,
-                },
-            };
-        case TNF.UNKNOWN:
-            return {
-                tnf: 'unknown',
-                value: {
-                    type: message.type,
-                    payload: message.payload,
-                },
-            };
-        default:
-            return {
-                tnf: message.tnf,
-                value: {
-                    type: message.type,
-                    payload: message.payload,
-                },
-            };
-    }
-}
-function parseWellKnownType(message) {
-    if (arrayEquals(message.type, WellKnownType.URI)) {
-        const prefixCode = message.payload[0];
-        let prefix = WELL_KNOWN_TYPE_URI_PREFIX[prefixCode] || '';
-        return {
-            type: 'uri',
-            value: prefix + toAsciiString(message.payload.slice(1)),
-        };
-    }
-    else if (arrayEquals(message.type, WellKnownType.TEXT)) {
-        const encodingNumber = message.payload[0];
-        let encoding = 'utf8';
-        let languageSizeInBytes = 0;
-        if (typeof encodingNumber === 'number') {
-            // b0: encodage utf8 s’il vaut 0 et utf16 s’il vaut 1.
-            // b1: RFU (set to 0)
-            // b2-b7: la taille en octets de la langue (n)
-            // B8-B8+n-1: language
-            // Bn: message
-            const b0 = encodingNumber & 0b10000000;
-            encoding = b0 ? 'utf16le' : 'utf8';
-            languageSizeInBytes = encodingNumber & 0b00111111;
-        }
-        const text = message.payload.slice(languageSizeInBytes + 1);
-        return {
-            type: 'text',
-            value: Buffer.from(text).toString(encoding),
-        };
-    }
-    //   else if (arrayEquals(message.type, WellKnownType.SMPART_POSTER)) {
-    //     return {
-    //       type: 'sp',
-    //       // TODO implement
-    //       payload: message.payload,
-    //     };
-    //   }
-    else {
-        return {
-            type: 'unknown',
-            value: {
-                type: message.type,
-                payload: message.payload,
-            },
-        };
-    }
-}
-function paseExternalType(message) {
-    const value = Buffer.from(message.payload).toString('utf8');
-    const domain = Buffer.from(message.type).toString('utf8');
-    return {
-        domain,
-        value,
-    };
-}
-const WELL_KNOWN_TYPE_URI_PREFIX = {
-    0x0: '',
-    0x1: 'http://www.',
-    0x2: 'http://www.',
-    0x3: 'http://',
-    0x4: 'https://',
-    0x5: 'tel:',
-    0x6: 'mailto:',
-    0x07: 'ftp://anonymous:anonymous@',
-    0x1d: 'file://',
-    0x08: 'ftp://ftp.',
-    0x09: 'ftps://',
-    0x0a: 'sftp://',
-    0x0b: 'smb://',
-    0x0c: 'nfs://',
-    0x0d: 'ftp://',
-    0x0e: 'dav://',
-    0x0f: 'news:',
-    0x10: 'telnet://',
-    0x11: 'imap:',
-    0x12: 'rtsp://',
-    0x13: 'urn:',
-    0x14: 'pop:',
-    0x15: 'sip:',
-    0x16: 'sips:',
-    0x17: 'tftp:',
-    0x18: 'btspp://',
-    0x19: 'btl2cap://',
-    0x1a: 'btgoep://',
-    0x1b: 'tcpobex://',
-    0x1c: 'irdaobex://',
-    0x1e: 'urn:epc:id:',
-    0x1f: 'urn:epc:tag:',
-    0x20: 'urn:epc:pat:',
-    0x21: 'urn:epc:raw:',
-    0x22: 'urn:epc:',
-};
-function parseMimeType(message) {
-    return Buffer.from(message.payload).toString('utf8');
+function parseNdefMessages(messages) {
+    return (messages || []).map(parseNdefMessage);
+}
+function parseNdefMessage(message) {
+    switch (message.tnf) {
+        case TNF.ABSOLUTE_URI:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'uri',
+                value: toAsciiString(message.payload),
+            };
+        case TNF.WELL_KNOWN_TYPE:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'wkt',
+                value: parseWellKnownType(message),
+            };
+        case TNF.EMPTY:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'empty',
+                value: {
+                    type: message.type,
+                    payload: message.payload,
+                },
+            };
+        case TNF.EXTERNAL:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'external',
+                value: paseExternalType(message),
+            };
+        case TNF.MIME_TYPE:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'mimetype',
+                value: parseMimeType(message),
+            };
+        case TNF.RFU:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'rfu',
+                value: {
+                    type: message.type,
+                    payload: message.payload,
+                },
+            };
+        case TNF.UNCHANGED:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'unchanged',
+                value: {
+                    type: message.type,
+                    payload: message.payload,
+                },
+            };
+        case TNF.UNKNOWN:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: 'unknown',
+                value: {
+                    type: message.type,
+                    payload: message.payload,
+                },
+            };
+        default:
+            return {
+                id: message.id,
+                type: message.type,
+                tnf: message.tnf,
+                value: {
+                    type: message.type,
+                    payload: message.payload,
+                },
+            };
+    }
+}
+function parseWellKnownType(message) {
+    if (arrayEquals(message.type.slice(), WellKnownType.URI)) {
+        const prefixCode = message.payload[0];
+        let prefix = WELL_KNOWN_TYPE_URI_PREFIX[prefixCode] || '';
+        return {
+            type: 'uri',
+            value: prefix + toAsciiString(message.payload.slice(1)),
+        };
+    }
+    else if (arrayEquals(message.type.slice(), WellKnownType.TEXT)) {
+        const encodingNumber = message.payload[0];
+        let encoding = 'utf8';
+        let languageSizeInBytes = 0;
+        if (typeof encodingNumber === 'number') {
+            // b0: encodage utf8 s’il vaut 0 et utf16 s’il vaut 1.
+            // b1: RFU (set to 0)
+            // b2-b7: la taille en octets de la langue (n)
+            // B8-B8+n-1: language
+            // Bn: message
+            const b0 = encodingNumber & 0b10000000;
+            encoding = b0 ? 'utf16le' : 'utf8';
+            languageSizeInBytes = encodingNumber & 0b00111111;
+        }
+        const text = message.payload.slice(languageSizeInBytes + 1);
+        const language = message.payload.slice(8, languageSizeInBytes + 1);
+        return {
+            type: 'text',
+            value: Buffer.from(text).toString(encoding),
+            encoding,
+            language: Buffer.from(language).toString(encoding)
+        };
+    }
+    //   else if (arrayEquals(message.type.slice(), WellKnownType.SMPART_POSTER)) {
+    //     return {
+    //       type: 'sp',
+    //       // TODO implement
+    //       payload: message.payload,
+    //     };
+    //   }
+    else {
+        return {
+            type: 'unknown',
+            value: {
+                type: message.type.slice(),
+                payload: message.payload,
+            },
+        };
+    }
+}
+function paseExternalType(message) {
+    const value = Buffer.from(message.payload).toString('utf8');
+    const domain = Buffer.from(message.type).toString('utf8');
+    return {
+        domain,
+        value,
+    };
+}
+const WELL_KNOWN_TYPE_URI_PREFIX = {
+    0x0: '',
+    0x1: 'http://www.',
+    0x2: 'http://www.',
+    0x3: 'http://',
+    0x4: 'https://',
+    0x5: 'tel:',
+    0x6: 'mailto:',
+    0x07: 'ftp://anonymous:anonymous@',
+    0x1d: 'file://',
+    0x08: 'ftp://ftp.',
+    0x09: 'ftps://',
+    0x0a: 'sftp://',
+    0x0b: 'smb://',
+    0x0c: 'nfs://',
+    0x0d: 'ftp://',
+    0x0e: 'dav://',
+    0x0f: 'news:',
+    0x10: 'telnet://',
+    0x11: 'imap:',
+    0x12: 'rtsp://',
+    0x13: 'urn:',
+    0x14: 'pop:',
+    0x15: 'sip:',
+    0x16: 'sips:',
+    0x17: 'tftp:',
+    0x18: 'btspp://',
+    0x19: 'btl2cap://',
+    0x1a: 'btgoep://',
+    0x1b: 'tcpobex://',
+    0x1c: 'irdaobex://',
+    0x1e: 'urn:epc:id:',
+    0x1f: 'urn:epc:tag:',
+    0x20: 'urn:epc:pat:',
+    0x21: 'urn:epc:raw:',
+    0x22: 'urn:epc:',
+};
+function parseMimeType(message) {
+    return Buffer.from(message.payload).toString('utf8');
+}
+function encodeWellKnownType(message) {
+    if (message.value.type == 'uri') {
+        //identify the prefix
+        const prefixesEntries = Object.entries(WELL_KNOWN_TYPE_URI_PREFIX);
+        let prefixByte = 0;
+        for (const [id, prefix] of prefixesEntries) {
+            if (id == '0x0') // Skip first as it is always recognized. (what about 0x1 vs 0x2?)
+                continue;
+            if (message.value.value.startsWith(prefix)) {
+                prefixByte = parseInt(id, 16);
+                break;
+            }
+        }
+        const lengthToSlice = WELL_KNOWN_TYPE_URI_PREFIX[prefixByte].length;
+        const slicedString = message.value.value.slice(lengthToSlice);
+        return [prefixByte, ...(asciiStringToByteBuffer(slicedString))];
+    }
+    else if (message.value.type === 'text') {
+        // b1: RFU (set to 0)
+        // b2-b7: la taille en octets de la langue (n)
+        // B8-B8+n-1: language
+        // Bn: message
+        let firstByte = message.value.encoding == 'utf16le' ? 0b10000000 : 0;
+        firstByte &= (message.value.language & 0b00111111);
+        const languageBytes = Buffer.from(message.value.language, message.value.encoding);
+        const textBytes = Buffer.from(message.value.value, message.value.encoding);
+        return [firstByte, ...languageBytes, ...textBytes];
+    }
+    else
+        return [...message.value.type, ...message.value.payload];
+}
+function encodeExternalType(message) {
+    return Array.from(Buffer.from(message.value.value, 'utf8'));
+}
+function encodeMimeType(message) {
+    return Array.from(Buffer.from(message.value, 'utf8'));
+}
+function encodeNDEFMessages(ndefRecords) {
+    return (ndefRecords || []).map(encodeNDEFMessage);
+}
+function encodeNDEFMessage(ndefRecord) {
+    switch (ndefRecord.tnf) {
+        case 'uri':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.ABSOLUTE_URI,
+                payload: Array.from(asciiStringToByteBuffer(ndefRecord.value))
+            };
+        case 'wkt':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.WELL_KNOWN_TYPE,
+                payload: encodeWellKnownType(ndefRecord),
+            };
+        case 'empty':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.EMPTY,
+                payload: ndefRecord.payload,
+            };
+        case 'external':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.EXTERNAL,
+                payload: encodeExternalType(ndefRecord),
+            };
+        case 'mimetype':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.MIME_TYPE,
+                payload: encodeMimeType(ndefRecord),
+            };
+        case 'rfu':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.RFU,
+                payload: ndefRecord.payload
+            };
+        case 'unchanged':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.UNCHANGED,
+                payload: ndefRecord.payload,
+            };
+        case 'unknown':
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: TNF.UNKNOWN,
+                payload: ndefRecord.payload,
+            };
+        default:
+            return {
+                id: ndefRecord.id,
+                type: ndefRecord.type,
+                tnf: Number(ndefRecord.tnf),
+                payload: ndefRecord.payload,
+            };
+    }
 }
 
 const debug = createDebugger(`@iotize/device-com-nfc.cordova`);
 
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-class PromiseQueue {
-    constructor() {
-        this.queue = Promise.resolve(true);
-    }
-    add(operation) {
-        return new Promise((resolve, reject) => {
-            this.queue = this.queue.then(operation).then(resolve).catch(reject);
-        });
-    }
-}
-class NFCComProtocol extends QueueComProtocol {
-    constructor(options = {
-        connect: {
-            timeout: 2000,
-        },
-        disconnect: {
-            timeout: 1000,
-        },
-        send: {
-            timeout: 1000,
-        },
-    }) {
-        super();
-        this._sendQueue = new PromiseQueue();
-        this.options = options;
-        if (typeof nfc == undefined) {
-            console.warn('NFC plugin has not been setup properly. Global variable NFC does not exist');
-        }
-    }
-    static iOSProtocol() {
-        return new NFCComProtocol({
-            connect: {
-                timeout: 10000, // bigger timer on connect as connect launches a reading session
-            },
-            disconnect: {
-                timeout: 1000,
-            },
-            send: {
-                timeout: 1000,
-            },
-        });
-    }
-    /**
-     * We force tag connection with nfc as we need to refresh tag
-     * @param options
-     * @returns
-     */
-    connect(options) {
-        this.connectionState = ConnectionState.CONNECTING; // Hack to force NFC tag connect call even if we are already connected
-        return super.connect(options);
-    }
-    /**
-     * Not used as we have rewrote "connect()" function
-     * @param options
-     * @returns
-     */
-    _connect(options) {
-        return defer(() => __awaiter(this, void 0, void 0, function* () {
-            debug('_connect', options);
-            try {
-                yield nfc.connect('android.nfc.tech.NfcV', this.options.connect.timeout);
-            }
-            catch (err) {
-                if (typeof err === 'string') {
-                    if (err === 'Tag connection failed') {
-                        throw NfcError.tagConnectionFailed();
-                    }
-                    else {
-                        throw NfcError.unknownError(err);
-                    }
-                }
-                throw err;
-            }
-        }));
-    }
-    _disconnect(options) {
-        return defer(() => __awaiter(this, void 0, void 0, function* () {
-            yield nfc.close();
-            this._sendQueue = new PromiseQueue();
-        }));
-    }
-    /**
-     * Not used
-     * @param options
-     * @returns
-     */
-    write(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error('Method not implemented.');
-        });
-    }
-    /**
-     * Not used
-     * @param options
-     * @returns
-     */
-    read() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error('Method not implemented.');
-        });
-    }
-    send(data, options) {
-        return defer(() => __awaiter(this, void 0, void 0, function* () {
-            return yield this._sendQueue.add(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const response = yield nfc.transceiveTap(bufferToHexString(data));
-                    if (typeof response != 'string') {
-                        throw NfcError.internalError(`Internal error. Plugin should respond a hexadecimal string`);
-                    }
-                    debug('NFC plugin response: ', response);
-                    return hexStringToBuffer(response);
-                }
-                catch (errString) {
-                    if (typeof errString === 'string') {
-                        const error = stringToError(errString);
-                        if (error.code === NfcError.ErrorCode.NotConnectedError ||
-                            error.code === NfcError.ErrorCode.TagLostError) {
-                            this._onConnectionLost(error);
-                        }
-                        throw error;
-                    }
-                    else {
-                        throw errString;
-                    }
-                }
-            }));
-        }));
-    }
-    _onConnectionLost(error) {
-        if (this.connectionState !== ConnectionState.DISCONNECTED) {
-            this.setConnectionState(ConnectionState.DISCONNECTED);
-        }
-    }
-}
-/**
- * Convert error string returned by the plugin into an error object
- * It only checks a few Android error string for now
- *
- * TODO complete implementation with other error types
- *
- * @param errString
- */
-function stringToError(errString) {
-    const errStringLc = errString.toLowerCase();
-    if (errStringLc.indexOf('tag was lost') >= 0) {
-        return NfcError.tagLostError();
-    }
-    else if (errStringLc.indexOf('not connected') >= 0) {
-        return NfcError.notConnectedError();
-    }
-    else {
-        return NfcError.unknownError(errString);
-    }
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class PromiseQueue {
+    constructor() {
+        this.queue = Promise.resolve(true);
+    }
+    add(operation) {
+        return new Promise((resolve, reject) => {
+            this.queue = this.queue.then(operation).then(resolve).catch(reject);
+        });
+    }
+}
+class NFCComProtocol extends QueueComProtocol {
+    constructor(options = {
+        connect: {
+            timeout: 2000,
+        },
+        disconnect: {
+            timeout: 1000,
+        },
+        send: {
+            timeout: 1000,
+        },
+    }) {
+        super();
+        this._sendQueue = new PromiseQueue();
+        this.options = options;
+        if (typeof nfc == undefined) {
+            console.warn('NFC plugin has not been setup properly. Global variable NFC does not exist');
+        }
+    }
+    static iOSProtocol() {
+        return new NFCComProtocol({
+            connect: {
+                timeout: 10000, // bigger timer on connect as connect launches a reading session
+            },
+            disconnect: {
+                timeout: 1000,
+            },
+            send: {
+                timeout: 1000,
+            },
+        });
+    }
+    /**
+     * We force tag connection with nfc as we need to refresh tag
+     * @param options
+     * @returns
+     */
+    connect(options) {
+        this.connectionState = ConnectionState.CONNECTING; // Hack to force NFC tag connect call even if we are already connected
+        return super.connect(options);
+    }
+    /**
+     * Not used as we have rewrote "connect()" function
+     * @param options
+     * @returns
+     */
+    _connect(options) {
+        return defer(() => __awaiter(this, void 0, void 0, function* () {
+            debug('_connect', options);
+            try {
+                yield nfc.connect('android.nfc.tech.NfcV', this.options.connect.timeout);
+            }
+            catch (err) {
+                if (typeof err === 'string') {
+                    if (err === 'Tag connection failed') {
+                        throw NfcError.tagConnectionFailed();
+                    }
+                    else {
+                        throw NfcError.unknownError(err);
+                    }
+                }
+                throw err;
+            }
+        }));
+    }
+    _disconnect(options) {
+        return defer(() => __awaiter(this, void 0, void 0, function* () {
+            yield nfc.close();
+            this._sendQueue = new PromiseQueue();
+        }));
+    }
+    /**
+     * Not used
+     * @param options
+     * @returns
+     */
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    /**
+     * Not used
+     * @param options
+     * @returns
+     */
+    read() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    send(data, options) {
+        return defer(() => __awaiter(this, void 0, void 0, function* () {
+            return yield this._sendQueue.add(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const response = yield nfc.transceiveTap(bufferToHexString(data));
+                    if (typeof response != 'string') {
+                        throw NfcError.internalError(`Internal error. Plugin should respond a hexadecimal string`);
+                    }
+                    debug('NFC plugin response: ', response);
+                    return hexStringToBuffer(response);
+                }
+                catch (errString) {
+                    if (typeof errString === 'string') {
+                        const error = stringToError(errString);
+                        if (error.code === NfcError.ErrorCode.NotConnectedError ||
+                            error.code === NfcError.ErrorCode.TagLostError) {
+                            this._onConnectionLost(error);
+                        }
+                        throw error;
+                    }
+                    else {
+                        throw errString;
+                    }
+                }
+            }));
+        }));
+    }
+    _onConnectionLost(error) {
+        if (this.connectionState !== ConnectionState.DISCONNECTED) {
+            this.setConnectionState(ConnectionState.DISCONNECTED);
+        }
+    }
+}
+/**
+ * Convert error string returned by the plugin into an error object
+ * It only checks a few Android error string for now
+ *
+ * TODO complete implementation with other error types
+ *
+ * @param errString
+ */
+function stringToError(errString) {
+    const errStringLc = errString.toLowerCase();
+    if (errStringLc.indexOf('tag was lost') >= 0) {
+        return NfcError.tagLostError();
+    }
+    else if (errStringLc.indexOf('not connected') >= 0) {
+        return NfcError.notConnectedError();
+    }
+    else {
+        return NfcError.unknownError(errString);
+    }
 }
 
-/**
- * We manage only on NDEF message with 3 records:
- * record 0 = URI; record 1 = AAR; record 2 = BLE MAC ADDRESS / BSSID; record 3: universal link
- */
-function parseTapNdefMessage(messages) {
-    let result = {};
-    if (messages.length >= 1) {
-        let asciiUri = messages[0].payload;
-        result.uri = toAsciiString(asciiUri);
-    }
-    if (messages.length >= 2) {
-        result.aar = toAsciiString(messages[1].payload);
-    }
-    if (messages.length >= 3) {
-        let payload3 = messages[2].payload;
-        let type = payload3[0];
-        let content = payload3.slice(1);
-        result.type = type;
-        switch (type) {
-            case TapNdefProtocolType.BLE:
-                result.macAddress = convertBytesToBLEAddress(content);
-                break;
-            case TapNdefProtocolType.WiFi:
-                result.ssid = toAsciiString(content);
-                break;
-        }
-    }
-    if (messages.length >= 4) {
-        result.name = toAsciiString(messages[3].payload);
-    }
-    return result;
-}
-var TapNdefProtocolType;
-(function (TapNdefProtocolType) {
-    TapNdefProtocolType[TapNdefProtocolType["WiFi"] = 32] = "WiFi";
-    TapNdefProtocolType[TapNdefProtocolType["BLE"] = 64] = "BLE";
-})(TapNdefProtocolType || (TapNdefProtocolType = {}));
-function convertBytesToBLEAddress(bytes) {
-    return bytes
-        .map((byte) => {
-        if (byte < 0) {
-            byte += 256;
-        }
-        let byteString = '0' + byte.toString(16).toUpperCase();
-        byteString = byteString.slice(-2);
-        return byteString;
-    })
-        .reverse()
-        .join(':');
+/**
+ * We manage only on NDEF message with 3 records:
+ * record 0 = URI; record 1 = AAR; record 2 = BLE MAC ADDRESS / BSSID; record 3: universal link
+ */
+function parseTapNdefMessage(messages) {
+    let result = {};
+    if (messages.length >= 1) {
+        let asciiUri = messages[0].payload;
+        result.uri = toAsciiString(asciiUri);
+    }
+    if (messages.length >= 2) {
+        result.aar = toAsciiString(messages[1].payload);
+    }
+    if (messages.length >= 3) {
+        let payload3 = messages[2].payload;
+        let type = payload3[0];
+        let content = payload3.slice(1);
+        result.type = type;
+        switch (type) {
+            case TapNdefProtocolType.BLE:
+                result.macAddress = convertBytesToBLEAddress(content);
+                break;
+            case TapNdefProtocolType.WiFi:
+                result.ssid = toAsciiString(content);
+                break;
+        }
+    }
+    if (messages.length >= 4) {
+        result.name = toAsciiString(messages[3].payload);
+    }
+    return result;
+}
+var TapNdefProtocolType;
+(function (TapNdefProtocolType) {
+    TapNdefProtocolType[TapNdefProtocolType["WiFi"] = 32] = "WiFi";
+    TapNdefProtocolType[TapNdefProtocolType["BLE"] = 64] = "BLE";
+})(TapNdefProtocolType || (TapNdefProtocolType = {}));
+function convertBytesToBLEAddress(bytes) {
+    return bytes
+        .map((byte) => {
+        if (byte < 0) {
+            byte += 256;
+        }
+        let byteString = '0' + byte.toString(16).toUpperCase();
+        byteString = byteString.slice(-2);
+        return byteString;
+    })
+        .reverse()
+        .join(':');
 }
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
-export { NFCComProtocol, NfcError, TNF, WellKnownType, parseNdefMessage, parseNdefMessages, parseTapNdefMessage };
+export { NFCComProtocol, NfcError, TNF, WellKnownType, encodeNDEFMessage, encodeNDEFMessages, parseNdefMessage, parseNdefMessages, parseTapNdefMessage };
 //# sourceMappingURL=iotize-device-com-nfc.cordova.js.map