react-native-nfc-manager 4.0.0-beta.0 → 4.0.0-beta.10

package/src/NfcTech/{NfcVHandler.js → NfcVHandler.ts}

@@ -2,8 +2,11 @@ import {Platform} from 'react-native';
 import {callNative, NativeNfcManager} from '../NativeNfcManager';
 import {handleNativeException} from '../NfcError';
 
+type Byte = number;
+type ByteArray = Byte[];
+
 class NfcVHandler {
-  async transceive(bytes) {
+  async transceive(bytes: ByteArray): Promise<ByteArray> {
     if (!Array.isArray(bytes)) {
       throw new Error(
         'IsoDepHandler.transceive only takes input as a byte array',
@@ -13,14 +16,14 @@ class NfcVHandler {
     if (Platform.OS === 'ios') {
       const [flags, commandCode, ...data] = bytes;
       return handleNativeException(
-        new Promise((resolve, reject) => {
+        new Promise<ByteArray>((resolve, reject) => {
           NativeNfcManager.iso15693_sendRequest(
             {
                 flags,
                 commandCode,
                 data,
             },
-            (err, responseFlag, response) => {
+            (err: string | null, responseFlag: number, response: ByteArray) => {
               if (err) {
                 reject(err);
               } else {
@@ -29,10 +32,10 @@ class NfcVHandler {
             },
           );
         }),
-      );
+      ) as Promise<ByteArray>;
     }
 
-    return handleNativeException(callNative('transceive', [bytes]));
+    return handleNativeException(callNative('transceive', [bytes])) as Promise<ByteArray>;
   }
 }
 

package/src/__mocks__/{NativeNfcManager.js → NativeNfcManager.ts}

@@ -4,6 +4,9 @@ let _nextErrorMethod = null;
 const NativeNfcManager = {
   MIFARE_BLOCK_SIZE: 16,
   MIFARE_ULTRALIGHT_PAGE_SIZE: 4,
+  MIFARE_ULTRALIGHT_TYPE: 1,
+  MIFARE_ULTRALIGHT_TYPE_C: 2,
+  MIFARE_ULTRALIGHT_TYPE_UNKNOWN: -1,
   setNextError: (err, nativeMethodName = null) => {
     _nextError = err;
     _nextErrorMethod = nativeMethodName;
@@ -22,7 +25,7 @@ const NfcManagerEmitter = {
 };
 
 const callNative = jest.fn((...args) => {
-  const [methodName, ...rest] = args;
+  const [methodName] = args;
   if (_nextError && (!methodName || methodName === _nextErrorMethod)) {
     const err = _nextError;
     _nextError = null;

package/src/{index.js → index.ts}

@@ -1,5 +1,5 @@
 import {Platform} from 'react-native';
-import Ndef from '../ndef-lib';
+const Ndef = require('../ndef-lib');
 import {NfcEvents, NfcTech, NdefStatus} from './NfcManager';
 import {NfcAdapter, NfcManagerAndroid} from './NfcManagerAndroid';
 import {

package/android/src/main/java/community/revteltech/nfc/JsonConvert.java

@@ -1,141 +0,0 @@
-/**
- * Written by Andrzej Porebski Nov 14/2015
- * Copyright (c) 2015, Andrzej Porebski
- *
- * Modified by  YunJiang.Fang
- * Copyright (c) 2015, YunJiang.Fang
- */
-
-package community.revteltech.nfc;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.bridge.ReadableType;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.util.Iterator;
-
-public abstract class JsonConvert {
-    public static JSONObject reactToJSON(ReadableMap readableMap) throws JSONException {
-        JSONObject jsonObject = new JSONObject();
-        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
-        while(iterator.hasNextKey()){
-            String key = iterator.nextKey();
-            ReadableType valueType = readableMap.getType(key);
-            switch (valueType){
-                case Null:
-                    jsonObject.put(key,JSONObject.NULL);
-                    break;
-                case Boolean:
-                    jsonObject.put(key, readableMap.getBoolean(key));
-                    break;
-                case Number:
-                    try {
-                        jsonObject.put(key, readableMap.getInt(key));
-                    } catch(Exception e) {
-                        jsonObject.put(key, readableMap.getDouble(key));
-                    }
-                    break;
-                case String:
-                    jsonObject.put(key, readableMap.getString(key));
-                    break;
-                case Map:
-                    jsonObject.put(key, reactToJSON(readableMap.getMap(key)));
-                    break;
-                case Array:
-                    jsonObject.put(key, reactToJSON(readableMap.getArray(key)));
-                    break;
-            }
-        }
-
-        return jsonObject;
-    }
-
-    public static JSONArray reactToJSON(ReadableArray readableArray) throws JSONException {
-        JSONArray jsonArray = new JSONArray();
-        for(int i=0; i < readableArray.size(); i++) {
-            ReadableType valueType = readableArray.getType(i);
-            switch (valueType){
-                case Null:
-                    jsonArray.put(JSONObject.NULL);
-                    break;
-                case Boolean:
-                    jsonArray.put(readableArray.getBoolean(i));
-                    break;
-                case Number:
-                    try {
-                        jsonArray.put(readableArray.getInt(i));
-                    } catch(Exception e) {
-                        jsonArray.put(readableArray.getDouble(i));
-                    }
-                    break;
-                case String:
-                    jsonArray.put(readableArray.getString(i));
-                    break;
-                case Map:
-                    jsonArray.put(reactToJSON(readableArray.getMap(i)));
-                    break;
-                case Array:
-                    jsonArray.put(reactToJSON(readableArray.getArray(i)));
-                    break;
-            }
-        }
-        return jsonArray;
-    }
-
-    public static WritableMap jsonToReact(JSONObject jsonObject) throws JSONException {
-        WritableMap writableMap = Arguments.createMap();
-        Iterator iterator = jsonObject.keys();
-        while(iterator.hasNext()) {
-            String key = (String) iterator.next();
-            Object value = jsonObject.get(key);
-            if (value instanceof Float || value instanceof Double) {
-                writableMap.putDouble(key, jsonObject.getDouble(key));
-            } else if (value instanceof Number) {
-                writableMap.putInt(key, jsonObject.getInt(key));
-            } else if (value instanceof String) {
-                writableMap.putString(key, jsonObject.getString(key));
-            } else if (value instanceof JSONObject) {
-                writableMap.putMap(key,jsonToReact(jsonObject.getJSONObject(key)));
-            } else if (value instanceof JSONArray){
-                writableMap.putArray(key, jsonToReact(jsonObject.getJSONArray(key)));
-            } else if ("true".equals(value.toString()) || "false".equals(value.toString())){
-                writableMap.putBoolean(key, "true".equals(value.toString()));
-            } else if (value == JSONObject.NULL){
-                writableMap.putNull(key);
-            }
-        }
-
-        return writableMap;
-    }
-
-    public static WritableArray jsonToReact(JSONArray jsonArray) throws JSONException {
-        WritableArray writableArray = Arguments.createArray();
-        for(int i=0; i < jsonArray.length(); i++) {
-            Object value = jsonArray.get(i);
-            if (value instanceof Float || value instanceof Double) {
-                writableArray.pushDouble(jsonArray.getDouble(i));
-            } else if (value instanceof Number) {
-                writableArray.pushInt(jsonArray.getInt(i));
-            } else if (value instanceof String) {
-                writableArray.pushString(jsonArray.getString(i));
-            } else if (value instanceof JSONObject) {
-                writableArray.pushMap(jsonToReact(jsonArray.getJSONObject(i)));
-            } else if (value instanceof JSONArray){
-                writableArray.pushArray(jsonToReact(jsonArray.getJSONArray(i)));
-            } else if ("true".equals(value.toString()) || "false".equals(value.toString())){
-                writableArray.pushBoolean("true".equals(value.toString()));
-            } else if (value == JSONObject.NULL){
-                writableArray.pushNull();
-            }
-        }
-        return writableArray;
-    }
-}

package/android/src/main/java/community/revteltech/nfc/MifareUtil.java

@@ -1,84 +0,0 @@
-package community.revteltech.nfc;
-
-import android.app.Activity;
-import android.content.pm.PackageManager;
-import android.os.Build;
-
-import java.io.File;
-import java.util.*;
-import java.nio.charset.Charset;
-
-class MifareUtil {
-	/**
-	 * Checks if Mifare is supported on a device with some heuristics.
-	 * Will _try_ to detect if Mifare is supported on a device or not. Please note that it's not fool-proof: I've
-	 * seen on some older devices (Samsung Galaxy S4) the method returning true, while we can only detect it fails
-	 * when a tag is scanned. Unfortunately there's nothing to do about it. But still it's a good effort and a
-	 * better approach than blacklisting devices imho.
-	 *
-	 * Credits: ikarus23 (https://github.com/ikarus23/MifareClassicTool)
-	 * @see https://github.com/ikarus23/MifareClassicTool/blob/master/Mifare%20Classic%20Tool/app/src/main/java/de/syss/MifareClassicTool/Common.java#L588
-	 * @see https://github.com/ikarus23/MifareClassicTool/blob/master/INCOMPATIBLE_DEVICES.md
-	 *
-	 * @param  currentActivity  The activity (should be passed since this is a static utility method).
-	 * @return The fact if a device is supported or not.
-	 */
-	public static boolean isDeviceSupported(Activity currentActivity) {
-		if (currentActivity == null) {
-			return false;
-		}
-
-		if (!currentActivity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_NFC)) {
-			return false;
-		}
-
-		boolean foundViaFeatures = currentActivity.getPackageManager().hasSystemFeature("com.nxp.mifare");
-		if (!foundViaFeatures) {
-			return false;
-		}
-
-		// The following code is thanks to ikarus23's MifareClassicTool (https://github.com/ikarus23/MifareClassicTool)
-		// @see https://github.com/ikarus23/MifareClassicTool/blob/3eb37b0afa3f57f0d18f2fcdfcee2435b47886d8/Mifare%20Classic%20Tool/app/src/main/java/de/syss/MifareClassicTool/Common.java#L588
-
-		// Check if there is the NFC device "bcm2079x-i2c".
-		// Chips by Broadcom don't support MIFARE Classic.
-		// This could fail because on a lot of devices apps don't have
-		// the sufficient permissions.
-		// Another exception:
-		// The Lenovo P2 has a device at "/dev/bcm2079x-i2c" but is still
-		// able of reading/writing MIFARE Classic tags. I don't know why...
-		// https://github.com/ikarus23/MifareClassicTool/issues/152
-		boolean isLenovoP2 = Build.MANUFACTURER.equals("LENOVO")
-				&& Build.MODEL.equals("Lenovo P2a42");
-		File device = new File("/dev/bcm2079x-i2c");
-		if (!isLenovoP2 && device.exists()) {
-			return false;
-		}
-
-		// Check if there is the NFC device "pn544".
-		// The PN544 NFC chip is manufactured by NXP.
-		// Chips by NXP support MIFARE Classic.
-		device = new File("/dev/pn544");
-		if (device.exists()) {
-			return true;
-		}
-
-		// Check if there are NFC libs with "brcm" in their names.
-		// "brcm" libs are for devices with Broadcom chips. Broadcom chips
-		// don't support MIFARE Classic.
-		File libsFolder = new File("/system/lib");
-		File[] libs = libsFolder.listFiles();
-		for (File lib : libs) {
-			if (lib.isFile()
-					&& lib.getName().startsWith("libnfc")
-					&& lib.getName().contains("brcm")
-				// Add here other non NXP NFC libraries.
-			) {
-				return false;
-			}
-		}
-
-		// We don't have reason to believe that it's not supported, or we can't detect it right now (we should wait when a tag is connected and do then some heuristics)
-		return true;
-	}
-}

package/ios/NfcManager+Felica.mm

@@ -1,43 +0,0 @@
-#import "NfcManager.h"
-#import "React/RCTBridge.h"
-#import "React/RCTConvert.h"
-#import "React/RCTEventDispatcher.h"
-#import "React/RCTLog.h"
-
-@interface NfcManager (Felica)
-@end
-
-@implementation NfcManager (Felica)
-
-- (void)sendFelicaCommand:(NSArray *)bytes callback: (nonnull RCTResponseSenderBlock)callback
-{
-    if (@available(iOS 13.0, *)) {
-        if ([self tagSession] != nil) {
-            if ([self tagSession].connectedTag) {
-                id<NFCFeliCaTag> felicaTag = [[self tagSession].connectedTag asNFCFeliCaTag];
-                NSData *data = arrayToData(bytes);
-                NSLog(@"input bytes: %@", getHexString(data));
-                if (felicaTag) {
-                    [felicaTag sendFeliCaCommandPacket:data
-                               completionHandler:^(NSData *response, NSError *error) {
-                        if (error) {
-                            callback(@[getErrorMessage(error), [NSNull null]]);
-                        } else {
-                            callback(@[[NSNull null], dataToArray(response)]);
-                        }
-                    }];
-                    return;
-                } else {
-                    callback(@[@"not a felica tag", [NSNull null]]);
-                }
-            }
-            callback(@[@"Not connected", [NSNull null]]);
-        } else {
-            callback(@[@"Not even registered", [NSNull null]]);
-        }
-    } else {
-        callback(@[@"Not support in this device", [NSNull null]]);
-    }
-}
-
-@end