react-native-nfc-manager 4.0.0-beta.1 → 4.0.0-beta.11

package/ios/RNNfcSessionDelegateProxy.swift

@@ -0,0 +1,104 @@
+import CoreNFC
+import Foundation
+
+@objcMembers
+@objc(RNNfcSessionDelegateProxy)
+public class RNNfcSessionDelegateProxy: NSObject, NFCNDEFReaderSessionDelegate, NFCTagReaderSessionDelegate {
+    public func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
+        NSLog("readerSession:didDetectNDEFs")
+        if let firstMessage = messages.first {
+            RNNfcBridgeUtil.emitEvent("NfcManagerDiscoverTag", body: ["ndefMessage": RNNfcManager.convertNdefMessage(firstMessage)])
+        } else {
+            RNNfcBridgeUtil.emitEvent("NfcManagerDiscoverTag", body: ["ndefMessage": []])
+        }
+    }
+
+    public func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
+        NSLog("readerSession:didInvalidateWithError: (%@)", (error as NSError).localizedDescription)
+        guard RNNfcManager.isCurrentNdefSession(session) else {
+            return
+        }
+        let invalidationCallback = RNNfcManager.takeSessionInvalidationCallback()
+        RNNfcManager.resetSessionsState()
+        RNNfcManager.resetRequestState()
+        invalidationCallback?([])
+        RNNfcBridgeUtil.emitEvent("NfcManagerSessionClosed", body: ["error": RNNfcSwiftUtil.errorMessage(from: error as NSError)])
+    }
+
+    @available(iOS 13.0, *)
+    public func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
+        NSLog("NFCTag didDetectTags")
+        guard let requestedTypes = RNNfcManager.pendingTechnologyRequestTypes(for: session) else {
+            return
+        }
+
+        for tag in tags {
+            let tagType = techName(for: tag)
+            var matchedRequestType: String?
+            for requestType in requestedTypes {
+                if tagType == requestType || requestType == "Ndef" {
+                    matchedRequestType = requestType
+                    break
+                }
+            }
+
+            guard let matchedRequestType else {
+                continue
+            }
+
+            session.connect(to: tag) { error in
+                if error != nil {
+                    guard RNNfcManager.isCurrentTagSession(session) else {
+                        return
+                    }
+                    NSLog("NFCTag restarting polling")
+                    session.restartPolling()
+                    return
+                }
+
+                guard let callback = RNNfcManager.takeTechnologyRequestCallback(for: session) else {
+                    return
+                }
+                callback([NSNull(), matchedRequestType])
+            }
+            return
+        }
+    }
+
+    @available(iOS 13.0, *)
+    public func tagReaderSession(_ session: NFCTagReaderSession, didInvalidateWithError error: Error) {
+        NSLog("NFCTag didInvalidateWithError")
+
+        guard RNNfcManager.isCurrentTagSession(session) else {
+            return
+        }
+
+        let callback = RNNfcManager.takeTechnologyRequestCallback(for: session)
+        let invalidationCallback = RNNfcManager.takeSessionInvalidationCallback()
+        RNNfcManager.resetSessionsState()
+        RNNfcManager.resetRequestState()
+        callback?([RNNfcSwiftUtil.errorMessage(from: error as NSError)])
+        invalidationCallback?([])
+        RNNfcBridgeUtil.emitEvent("NfcManagerSessionClosed", body: ["error": RNNfcSwiftUtil.errorMessage(from: error as NSError)])
+    }
+
+    @available(iOS 13.0, *)
+    public func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
+        NSLog("NFCTag didBecomeActive")
+    }
+
+    private func techName(for tag: NFCTag) -> String {
+        switch tag {
+        case .miFare:
+            return "mifare"
+        case .feliCa:
+            return "felica"
+        case .iso15693:
+            return "iso15693"
+        case .iso7816:
+            return "IsoDep"
+        @unknown default:
+            return "unknown"
+        }
+    }
+}

package/ios/RNNfcSwiftUtil.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+@objc(RNNfcSwiftUtil)
+public class RNNfcSwiftUtil: NSObject {
+    @objc(hexStringFromData:)
+    public static func hexString(from data: Data) -> String {
+        var output = String()
+        output.reserveCapacity(data.count * 2)
+        for byte in data {
+            output += String(format: "%02X", byte)
+        }
+        return output
+    }
+
+    @objc(errorMessageFromError:)
+    public static func errorMessage(from error: NSError) -> String {
+        if let underlyingError = error.userInfo[NSUnderlyingErrorKey] as? NSError {
+            return "\(error.domain):\(error.code),\(underlyingError.domain):\(underlyingError.code)"
+        }
+
+        return "\(error.domain):\(error.code)"
+    }
+
+    @objc(dataFromNumberArray:)
+    public static func data(from numberArray: [NSNumber]) -> Data {
+        let bytes = numberArray.map { $0.uint8Value }
+        return Data(bytes)
+    }
+
+    @objc(numberArrayFromData:)
+    public static func numberArray(from data: Data) -> [NSNumber] {
+        return data.map { NSNumber(value: Int($0)) }
+    }
+}

package/ndef-lib/{constants.js → constants.ts}

@@ -67,3 +67,5 @@ const constants = {
 };
 
 module.exports = constants;
+
+export {};

package/ndef-lib/{index.js → index.ts}

@@ -14,20 +14,29 @@ const uriHelper = require('./ndef-uri');
 const wifiSimpleHelper = require('./ndef-wifi-simple');
 const stringifier = require('./stringifier');
 
+type Byte = number;
+type ByteArray = Byte[];
+type NdefRecord = {
+  tnf: number;
+  type: string | ByteArray;
+  id: ByteArray;
+  payload: ByteArray;
+};
+
 const PrimitiveRecord = {
-  emptyRecord() {
+  emptyRecord(): NdefRecord {
     return createNdefRecord(constants.TNF_EMPTY, [], [], []);
   },
 
-  absoluteUriRecord(uri, payload = [], id = []) {
+  absoluteUriRecord(uri: string, payload: string | ByteArray = [], id: string | ByteArray = []): NdefRecord {
     return createNdefRecord(constants.TNF_ABSOLUTE_URI, uri, id, payload);
   },
 
-  mimeMediaRecord(mimeType, payload, id = []) {
+  mimeMediaRecord(mimeType: string, payload: string | ByteArray, id: string | ByteArray = []): NdefRecord {
     return createNdefRecord(constants.TNF_MIME_MEDIA, mimeType, id, payload);
   },
 
-  externalTypeRecord(externalType, payload, id = []) {
+  externalTypeRecord(externalType: string, payload: string | ByteArray, id: string | ByteArray = []): NdefRecord {
     return createNdefRecord(
       constants.TNF_EXTERNAL_TYPE,
       externalType,
@@ -38,7 +47,7 @@ const PrimitiveRecord = {
 };
 
 const WellKnownRecord = {
-  textRecord(text, languageCode, id = []) {
+  textRecord(text: string, languageCode?: string, id: string | ByteArray = []): NdefRecord {
     return createNdefRecord(
       constants.TNF_WELL_KNOWN,
       constants.RTD_TEXT,
@@ -47,7 +56,7 @@ const WellKnownRecord = {
     );
   },
 
-  uriRecord(uri, id = []) {
+  uriRecord(uri: string, id: string | ByteArray = []): NdefRecord {
     return createNdefRecord(
       constants.TNF_WELL_KNOWN,
       constants.RTD_URI,
@@ -56,8 +65,8 @@ const WellKnownRecord = {
     );
   },
 
-  smartPoster(ndefRecords, id = []) {
-    let payload = [];
+  smartPoster(ndefRecords: NdefRecord[] | ByteArray, id: string | ByteArray = []): NdefRecord {
+    let payload: ByteArray = [];
 
     if (ndefRecords) {
       // make sure we have an array of something like NDEF records before encoding
@@ -65,10 +74,10 @@ const WellKnownRecord = {
         ndefRecords[0] instanceof Object &&
         ndefRecords[0].hasOwnProperty('tnf')
       ) {
-        payload = encodeNdefMessage(ndefRecords);
+        payload = encodeNdefMessage(ndefRecords as NdefRecord[]);
       } else {
         // assume the caller has already encoded the NDEF records into a byte array
-        payload = ndefRecords;
+        payload = ndefRecords as ByteArray;
       }
     } else {
       console.log('WARNING: Expecting an array of NDEF records');
@@ -84,7 +93,7 @@ const WellKnownRecord = {
 };
 
 const ExtraTypeRecord = {
-  androidApplicationRecord(packageName, id = []) {
+  androidApplicationRecord(packageName: string, id: string | ByteArray = []): NdefRecord {
     return PrimitiveRecord.externalTypeRecord(
       'android.com:pkg',
       packageName,
@@ -92,7 +101,7 @@ const ExtraTypeRecord = {
     );
   },
 
-  wifiSimpleRecord: function (credentials, id = []) {
+  wifiSimpleRecord: function (credentials: {ssid: string; networkKey: string; authType?: ByteArray}, id: string | ByteArray = []): NdefRecord {
     let payload = wifiSimpleHelper.encodePayload(credentials);
     return PrimitiveRecord.mimeMediaRecord(constants.MIME_WFA_WSC, payload, id);
   },
@@ -120,3 +129,5 @@ const NDEF = {
 };
 
 module.exports = NDEF;
+
+export {};

package/ndef-lib/{ndef-text.js → ndef-text.ts}

@@ -1,8 +1,11 @@
 var util = require('./util');
 
+type Byte = number;
+type ByteArray = Byte[];
+
 // decode text bytes from ndef record payload
 // @returns a string
-function decode(data) {
+function decode(data: ByteArray): string | null {
   var languageCodeLength = data[0] & 0x3f; // 6 LSBs
   // languageCode = data.slice(1, 1 + languageCodeLength),
   // utf16 = (data[0] & 0x80) !== 0; // assuming UTF-16BE
@@ -15,7 +18,7 @@ function decode(data) {
 
 // encode text payload
 // @returns an array of bytes
-function encode(text, lang, encoding) {
+function encode(text: string, lang?: string, encoding?: unknown): ByteArray {
   // ISO/IANA language code, but we're not enforcing
   if (!lang) {
     lang = 'en';
@@ -31,3 +34,5 @@ module.exports = {
   encodePayload: encode,
   decodePayload: decode,
 };
+
+export {};

package/ndef-lib/{ndef-uri.js → ndef-uri.ts}

@@ -1,9 +1,12 @@
 const util = require('./util');
 const protocols = require('./constants').RTD_URI_PROTOCOLS;
 
+type Byte = number;
+type ByteArray = Byte[];
+
 // decode a URI payload bytes
 // @returns a string
-function decode(data) {
+function decode(data: ByteArray): string {
   var prefix = protocols[data[0]];
   if (!prefix) {
     // 36 to 255 should be ""
@@ -14,8 +17,8 @@ function decode(data) {
 
 // shorten a URI with standard prefix
 // @returns an array of bytes
-function encode(uri) {
-  var prefix, protocolCode, encoded;
+function encode(uri: string): ByteArray {
+  var prefix: string | undefined, protocolCode, encoded;
 
   // check each protocol, unless we've found a match
   // "urn:" is the one exception where we need to keep checking
@@ -42,3 +45,5 @@ module.exports = {
   encodePayload: encode,
   decodePayload: decode,
 };
+
+export {};

package/ndef-lib/{ndef-wifi-simple.js → ndef-wifi-simple.ts}

@@ -1,5 +1,26 @@
 var util = require('./util');
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type WifiCredentials = {
+  ssid: string;
+  networkKey: string;
+  authType?: ByteArray;
+};
+
+type Tlv = {
+  type: ByteArray;
+  length: ByteArray;
+  value: ByteArray;
+};
+
+type DecodedWifiCredentials = {
+  ssid?: string | null;
+  networkKey?: string | null;
+  authType?: ByteArray;
+};
+
 const CREDENTIAL_FIELD_ID = [0x10, 0x0e];
 const SSID_FIELD_ID = [0x10, 0x45];
 const AUTH_TYPE_FIELD_ID = [0x10, 0x03];
@@ -10,14 +31,14 @@ const AUTH_TYPES = {
   WPA2_PSK: [0x00, 0x20],
 };
 
-function _getLengthBytes(valueBytes) {
+function _getLengthBytes(valueBytes: ByteArray): ByteArray {
   if (valueBytes.length > 255) {
     return [Math.floor(valueBytes.length / 256), valueBytes.length % 256];
   }
   return [0x0, valueBytes.length];
 }
 
-function _arrayEqual(arr1, arr2) {
+function _arrayEqual(arr1: ByteArray, arr2: ByteArray): boolean {
   if (arr1.length !== arr2.length) {
     return false;
   }
@@ -31,7 +52,7 @@ function _arrayEqual(arr1, arr2) {
   return true;
 }
 
-function _getNextTLV(bytes) {
+function _getNextTLV(bytes: ByteArray): Tlv {
   const type = bytes.slice(0, 2);
   const length = bytes.slice(2, 4);
   const value = bytes.slice(4, 4 + (length[0] * 256 + length[1]));
@@ -43,8 +64,8 @@ function _getNextTLV(bytes) {
 }
 
 // @returns an string of wifi credentials
-function decode(bytes) {
-  let result = {};
+function decode(bytes: ByteArray): DecodedWifiCredentials {
+  let result: DecodedWifiCredentials = {};
 
   while (bytes.length > 0) {
     let {type, value} = _getNextTLV(bytes);
@@ -73,13 +94,13 @@ function decode(bytes) {
 
 // encode wifi object payload
 // @returns an array of bytes
-function encode({ssid, networkKey, authType = AUTH_TYPES.WPA2_PSK}) {
+function encode({ssid, networkKey, authType = AUTH_TYPES.WPA2_PSK}: WifiCredentials): ByteArray {
   if (typeof ssid !== 'string' || typeof networkKey !== 'string') {
     throw new Error('');
   }
 
-  ssid = util.stringToBytes(ssid);
-  networkKey = util.stringToBytes(networkKey);
+  const ssidBytes = util.stringToBytes(ssid);
+  const networkKeyBytes = util.stringToBytes(networkKey);
 
   // build seperated TLV
   const authTypeTLV = [
@@ -88,12 +109,12 @@ function encode({ssid, networkKey, authType = AUTH_TYPES.WPA2_PSK}) {
     authType.length,
     ...authType,
   ];
-  const ssidTLV = [...SSID_FIELD_ID, 0x0, ssid.length, ...ssid];
+  const ssidTLV = [...SSID_FIELD_ID, 0x0, ssidBytes.length, ...ssidBytes];
   const networkKeyTLV = [
     ...NETWORK_KEY_FIELD_ID,
     0x0,
-    networkKey.length,
-    ...networkKey,
+    networkKeyBytes.length,
+    ...networkKeyBytes,
   ];
 
   // build credential TLV
@@ -112,3 +133,5 @@ module.exports = {
   decodePayload: decode,
   authTypes: AUTH_TYPES,
 };
+
+export {};

package/ndef-lib/{ndef.js → ndef.ts}

@@ -1,6 +1,30 @@
 const util = require('./util');
 
-function createNdefRecord(tnf, type, id, payload) {
+type Byte = number;
+type ByteArray = Byte[];
+
+type TnfHeader = {
+  mb: boolean;
+  me: boolean;
+  cf: boolean;
+  sr: boolean;
+  il: boolean;
+  tnf: number;
+};
+
+type NdefRecord = {
+  tnf: number;
+  type: string | ByteArray;
+  id: ByteArray;
+  payload: ByteArray;
+};
+
+function createNdefRecord(
+  tnf: number,
+  type: string | ByteArray,
+  id: string | ByteArray,
+  payload: string | ByteArray,
+): NdefRecord {
   if (
     tnf === undefined ||
     type === undefined ||
@@ -25,16 +49,19 @@ function createNdefRecord(tnf, type, id, payload) {
     payload = util.stringToBytes(payload);
   }
 
+  const idBytes = id as ByteArray;
+  const payloadBytes = payload as ByteArray;
+
   return {
-    tnf: tnf,
-    type: type,
-    id: id,
-    payload: payload,
+    tnf,
+    type,
+    id: idBytes,
+    payload: payloadBytes,
   };
 }
 
-function encodeNdefMessage(ndefRecords) {
-  const encodeTnf = ({mb, me, cf, sr, il, tnf}) => {
+function encodeNdefMessage(ndefRecords: NdefRecord[]): ByteArray {
+  const encodeTnf = ({mb, me, cf, sr, il, tnf}: TnfHeader): number => {
     let value = tnf;
 
     if (mb) {
@@ -114,8 +141,8 @@ function encodeNdefMessage(ndefRecords) {
   return encoded;
 }
 
-function decodeNdefMessage(ndefBytes) {
-  const decodeTnf = (tnf_byte) => ({
+function decodeNdefMessage(ndefBytes: ByteArray | Uint8Array): NdefRecord[] {
+  const decodeTnf = (tnf_byte: number): TnfHeader => ({
     mb: (tnf_byte & 0x80) !== 0,
     me: (tnf_byte & 0x40) !== 0,
     cf: (tnf_byte & 0x20) !== 0,
@@ -124,18 +151,17 @@ function decodeNdefMessage(ndefBytes) {
     tnf: tnf_byte & 0x7,
   });
 
-  // ndefBytes can be an array of bytes e.g. [0x03, 0x31, 0xd1] or a Buffer
-  let bytes;
-  if (ndefBytes instanceof Array) {
-    bytes = ndefBytes.slice(0);
+  // Buffer extends Uint8Array; copy only the supplied view before parsing.
+  let bytes: ByteArray;
+  if (Array.isArray(ndefBytes) || ndefBytes instanceof Uint8Array) {
+    bytes = Array.from(ndefBytes);
   } else {
     throw new Error(
-      'ndef.decodeMessage requires a Buffer or an Array of bytes',
+      'ndef.decodeMessage requires a Buffer, Uint8Array, or an Array of bytes',
     );
   }
 
-  bytes = bytes.slice(0); // clone since parsing is destructive
-  let ndef_message = [],
+  let ndef_message: NdefRecord[] = [],
     tnf_byte,
     header,
     type_length = 0,
@@ -146,23 +172,23 @@ function decodeNdefMessage(ndefBytes) {
     payload = [];
 
   while (bytes.length) {
-    tnf_byte = bytes.shift();
+    tnf_byte = bytes.shift() as number;
     header = decodeTnf(tnf_byte);
 
-    type_length = bytes.shift();
+    type_length = bytes.shift() as number;
 
     if (header.sr) {
-      payload_length = bytes.shift();
+      payload_length = bytes.shift() as number;
     } else {
       // next 4 bytes are length
       payload_length =
-        ((0xff & bytes.shift()) << 24) |
-        ((0xff & bytes.shift()) << 16) |
-        ((0xff & bytes.shift()) << 8) |
-        (0xff & bytes.shift());
+        ((0xff & (bytes.shift() as number)) << 24) |
+        ((0xff & (bytes.shift() as number)) << 16) |
+        ((0xff & (bytes.shift() as number)) << 8) |
+        (0xff & (bytes.shift() as number));
     }
 
-    id_length = header.il ? bytes.shift() : 0;
+    id_length = header.il ? (bytes.shift() as number) : 0;
 
     record_type = bytes.splice(0, type_length);
     id = bytes.splice(0, id_length);
@@ -178,7 +204,7 @@ function decodeNdefMessage(ndefBytes) {
   return ndef_message;
 }
 
-function equalToRecordType(record, tnf, type) {
+function equalToRecordType(record: NdefRecord, tnf: number, type: string): boolean {
   if (record.tnf === tnf) {
     if (Array.isArray(record.type)) {
       return util.bytesToString(record.type) === type;
@@ -195,3 +221,5 @@ module.exports = {
   decodeNdefMessage,
   equalToRecordType,
 };
+
+export {};

package/ndef-lib/{stringifier.js → stringifier.ts}

@@ -1,19 +1,34 @@
 const ndef = require('./ndef');
 const constants = require('./constants');
 
+type Byte = number;
+type ByteArray = Byte[];
+
+type NdefRecord = {
+  tnf: number;
+  type: string | ByteArray;
+  payload: ByteArray;
+  id?: ByteArray;
+};
+
 // Convert NDEF records and messages to strings
 // This works OK for demos, but real code proably needs
 // a custom implementation. It would be nice to make
 // smarter record objects that can print themselves
 let stringifier = {
-  stringify: function (data, separator) {
+  stringify: function (data: NdefRecord | NdefRecord[] | ByteArray, separator?: string): string {
     if (Array.isArray(data)) {
+      const records: NdefRecord[] =
+        typeof data[0] === 'number'
+          ? ndef.decodeMessage(data as ByteArray)
+          : (data as NdefRecord[]);
+
       if (typeof data[0] === 'number') {
         // guessing this message bytes
-        data = ndef.decodeMessage(data);
+        data = records;
       }
 
-      return stringifier.printRecords(data, separator);
+      return stringifier.printRecords(records, separator);
     } else {
       return stringifier.printRecord(data, separator);
     }
@@ -22,7 +37,7 @@ let stringifier = {
   // @message - NDEF Message (array of NDEF Records)
   // @separator - line separator, optional, defaults to \n
   // @returns string with NDEF Message
-  printRecords: function (message, separator) {
+  printRecords: function (message: NdefRecord[], separator?: string) {
     if (!separator) {
       separator = '\n';
     }
@@ -40,7 +55,7 @@ let stringifier = {
   // @record - NDEF Record
   // @separator - line separator, optional, defaults to \n
   // @returns string with NDEF Record
-  printRecord: function (record, separator) {
+  printRecord: function (record: NdefRecord, separator?: string): string {
     let result = '';
 
     if (!separator) {
@@ -65,7 +80,7 @@ let stringifier = {
       case constants.TNF_ABSOLUTE_URI:
         result += 'Absolute URI';
         result += separator;
-        result += s(record.type); // the URI is the type
+        result += s(record.type);
         result += separator;
         result += s(record.payload); // might be binary
         break;
@@ -86,7 +101,7 @@ let stringifier = {
     return result;
   },
 
-  printWellKnown: function (record, separator) {
+  printWellKnown: function (record: NdefRecord, separator?: string): string {
     let result = '';
 
     if (record.tnf !== constants.TNF_WELL_KNOWN) {
@@ -120,8 +135,8 @@ let stringifier = {
     return result;
   },
 
-  tnfToString: function (tnf) {
-    let value = tnf;
+  tnfToString: function (tnf: number): string | number {
+    let value: string | number = tnf;
 
     switch (tnf) {
       case constants.TNF_EMPTY:
@@ -153,7 +168,7 @@ let stringifier = {
   },
 };
 
-function s(bytes) {
+function s(bytes: string | ByteArray): string {
   if (typeof bytes === 'string') {
     return bytes;
   }
@@ -164,3 +179,5 @@ function s(bytes) {
 }
 
 module.exports = stringifier;
+
+export {};