react-native-nfc-manager 4.0.0-beta.7 → 4.0.0-beta.9

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

@@ -0,0 +1,130 @@
+package community.revteltech.nfc;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReactApplicationContext;
+
+/**
+ * Temporary Android-side holder for iOS-only API stubs required by the shared RN spec.
+ *
+ * TODO: Remove this class after splitting platform specs so Android no longer needs iOS methods.
+ */
+@Deprecated
+abstract class NfcManagerIOSStubBase extends NativeNfcManagerSpec {
+    NfcManagerIOSStubBase(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public void setAlertMessage(String message, Callback callback) {
+    }
+
+    @Override
+    public void isSessionAvailable(Callback callback) {
+    }
+
+    @Override
+    public void isTagSessionAvailable(Callback callback) {
+    }
+
+    @Override
+    public void sendMifareCommand(ReadableArray bytes, Callback callback) {
+    }
+
+    @Override
+    public void sendCommandAPDU(ReadableMap payload, Callback callback) {
+    }
+
+    @Override
+    public void sendCommandAPDUBytes(ReadableArray bytes, Callback callback) {
+    }
+
+    @Override
+    public void sendFelicaCommand(ReadableArray bytes, Callback callback) {
+    }
+
+    @Override
+    public void restartTechnologyRequest(Callback callback) {
+    }
+
+    @Override
+    public void invalidateSession(Callback callback) {
+    }
+
+    @Override
+    public void invalidateSessionWithError(String message, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_getSystemInfo(double requestFlag, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_readSingleBlock(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_readMultipleBlocks(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_writeSingleBlock(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_lockBlock(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_writeAFI(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_lockAFI(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_writeDSFID(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_lockDSFID(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_resetToReady(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_select(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_stayQuiet(Callback callback) {
+    }
+
+    @Override
+    public void iso15693_customCommand(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_sendRequest(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_extendedReadSingleBlock(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_extendedReadMultipleBlocks(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_extendedWriteSingleBlock(ReadableMap options, Callback callback) {
+    }
+
+    @Override
+    public void iso15693_extendedLockBlock(ReadableMap options, Callback callback) {
+    }
+}

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

@@ -0,0 +1,258 @@
+package community.revteltech.nfc;
+
+import static community.revteltech.nfc.NfcErrorCodes.*;
+
+import android.nfc.tech.IsoDep;
+import android.nfc.tech.MifareClassic;
+import android.nfc.tech.MifareUltralight;
+import android.nfc.tech.NfcA;
+import android.nfc.tech.NfcB;
+import android.nfc.tech.NfcF;
+import android.nfc.tech.NfcV;
+import android.nfc.tech.TagTechnology;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
+
+class NfcTechIoRouter {
+    private static final String LOG_TAG = "ReactNativeNfcManager";
+
+    private NfcTechIoRouter() {
+    }
+
+    static void setTimeout(
+            TagTechnologyRequest techRequest,
+            int timeout,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            String tech = techRequest.getTechType();
+            TagTechnology baseTechHandle = techRequest.getTechHandle();
+            switch (tech) {
+                case "NfcA": {
+                    NfcA techHandle = (NfcA) baseTechHandle;
+                    techHandle.setTimeout(timeout);
+                    callback.invoke();
+                    return;
+                }
+                case "NfcF": {
+                    NfcF techHandle = (NfcF) baseTechHandle;
+                    techHandle.setTimeout(timeout);
+                    callback.invoke();
+                    return;
+                }
+                case "IsoDep": {
+                    IsoDep techHandle = (IsoDep) baseTechHandle;
+                    techHandle.setTimeout(timeout);
+                    callback.invoke();
+                    return;
+                }
+                case "MifareClassic": {
+                    MifareClassic techHandle = (MifareClassic) baseTechHandle;
+                    techHandle.setTimeout(timeout);
+                    callback.invoke();
+                    return;
+                }
+                case "MifareUltralight": {
+                    MifareUltralight techHandle = (MifareUltralight) baseTechHandle;
+                    techHandle.setTimeout(timeout);
+                    callback.invoke();
+                    return;
+                }
+            }
+
+            Log.d(LOG_TAG, "setTimeout not supported");
+            callback.invoke(ERR_API_NOT_SUPPORT);
+        } catch (Exception ex) {
+            Log.d(LOG_TAG, ex.toString());
+            callback.invoke(ex.toString());
+        }
+    }
+
+    static void getTimeout(
+            TagTechnologyRequest techRequest,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            String tech = techRequest.getTechType();
+            TagTechnology baseTechHandle = techRequest.getTechHandle();
+            switch (tech) {
+                case "NfcA": {
+                    NfcA techHandle = (NfcA) baseTechHandle;
+                    callback.invoke(null, techHandle.getTimeout());
+                    return;
+                }
+                case "NfcF": {
+                    NfcF techHandle = (NfcF) baseTechHandle;
+                    callback.invoke(null, techHandle.getTimeout());
+                    return;
+                }
+                case "IsoDep": {
+                    IsoDep techHandle = (IsoDep) baseTechHandle;
+                    callback.invoke(null, techHandle.getTimeout());
+                    return;
+                }
+                case "MifareClassic": {
+                    MifareClassic techHandle = (MifareClassic) baseTechHandle;
+                    callback.invoke(null, techHandle.getTimeout());
+                    return;
+                }
+                case "MifareUltralight": {
+                    MifareUltralight techHandle = (MifareUltralight) baseTechHandle;
+                    callback.invoke(null, techHandle.getTimeout());
+                    return;
+                }
+            }
+
+            Log.d(LOG_TAG, "getTimeout not supported");
+            callback.invoke(ERR_API_NOT_SUPPORT);
+        } catch (Exception ex) {
+            Log.d(LOG_TAG, ex.toString());
+            callback.invoke(ex.toString());
+        }
+    }
+
+    static void transceive(
+            TagTechnologyRequest techRequest,
+            ReadableArray rnArray,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            String tech = techRequest.getTechType();
+            byte[] bytes = rnArrayToBytes(rnArray);
+            TagTechnology baseTechHandle = techRequest.getTechHandle();
+
+            switch (tech) {
+                case "NfcA": {
+                    NfcA techHandle = (NfcA) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "NfcB": {
+                    NfcB techHandle = (NfcB) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "NfcF": {
+                    NfcF techHandle = (NfcF) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "NfcV": {
+                    NfcV techHandle = (NfcV) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "IsoDep": {
+                    IsoDep techHandle = (IsoDep) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "MifareClassic": {
+                    MifareClassic techHandle = (MifareClassic) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+                case "MifareUltralight": {
+                    MifareUltralight techHandle = (MifareUltralight) baseTechHandle;
+                    callback.invoke(null, bytesToRnArray(techHandle.transceive(bytes)));
+                    return;
+                }
+            }
+
+            Log.d(LOG_TAG, "transceive not supported");
+            callback.invoke(ERR_API_NOT_SUPPORT);
+        } catch (Exception ex) {
+            Log.d(LOG_TAG, "transceive fail: " + ex);
+            callback.invoke(ERR_TRANSCEIVE_FAIL);
+        }
+    }
+
+    static void getMaxTransceiveLength(
+            TagTechnologyRequest techRequest,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            String tech = techRequest.getTechType();
+            TagTechnology baseTechHandle = techRequest.getTechHandle();
+            switch (tech) {
+                case "NfcA": {
+                    NfcA techHandle = (NfcA) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+                case "NfcB": {
+                    NfcB techHandle = (NfcB) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+                case "NfcF": {
+                    NfcF techHandle = (NfcF) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+                case "NfcV": {
+                    NfcV techHandle = (NfcV) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+                case "IsoDep": {
+                    IsoDep techHandle = (IsoDep) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+                case "MifareUltralight": {
+                    MifareUltralight techHandle = (MifareUltralight) baseTechHandle;
+                    callback.invoke(null, techHandle.getMaxTransceiveLength());
+                    return;
+                }
+            }
+
+            Log.d(LOG_TAG, "getMaxTransceiveLength not supported");
+            callback.invoke(ERR_API_NOT_SUPPORT);
+        } catch (Exception ex) {
+            Log.d(LOG_TAG, "getMaxTransceiveLength fail");
+            callback.invoke(ex.toString());
+        }
+    }
+
+    private static byte[] rnArrayToBytes(ReadableArray rArray) {
+        byte[] bytes = new byte[rArray.size()];
+        for (int i = 0; i < rArray.size(); i++) {
+            bytes[i] = (byte) (rArray.getInt(i) & 0xff);
+        }
+        return bytes;
+    }
+
+    private static WritableArray bytesToRnArray(byte[] bytes) {
+        WritableArray value = Arguments.createArray();
+        for (byte aByte : bytes) {
+            value.pushInt((aByte & 0xFF));
+        }
+        return value;
+    }
+}

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

@@ -33,19 +33,25 @@ class TagTechnologyRequest {
     }
 
     void invokePendingCallbackWithError(String err) {
-        if (mJsCallback != null) {
-            mJsCallback.invoke(err);
-            mJsCallback = null;
+        Callback callback = takePendingCallback();
+        if (callback != null) {
+            callback.invoke(err);
         }
     }
 
     void invokePendingCallback(String connectedTech) {
-        if (mJsCallback != null) {
-            mJsCallback.invoke(null, connectedTech);
-            mJsCallback = null;
+        Callback callback = takePendingCallback();
+        if (callback != null) {
+            callback.invoke(null, connectedTech);
         }
     }
 
+    private Callback takePendingCallback() {
+        Callback callback = mJsCallback;
+        mJsCallback = null;
+        return callback;
+    }
+
     TagTechnology getTechHandle() {
         return mTech;
     }
@@ -122,9 +128,15 @@ class TagTechnologyRequest {
 
     void close() {
         try {
-            mTech.close();
+            if (mTech != null) {
+                mTech.close();
+            }
         } catch (Exception ex) {
             Log.d(LOG_TAG, "fail to close tech");
+        } finally {
+            mTag = null;
+            mTech = null;
+            mTechType = null;
         }
     }
 }

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

@@ -1,16 +1,30 @@
 package community.revteltech.nfc;
 
+import android.app.Activity;
+import android.content.pm.PackageManager;
 import android.nfc.NdefMessage;
 import android.nfc.NdefRecord;
 import android.nfc.Tag;
 import android.nfc.tech.Ndef;
+import android.os.Build;
 import android.util.Log;
+
+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.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 
 public class Util {
@@ -18,6 +32,128 @@ public class Util {
     static final String TAG = "NfcPlugin";
     final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
 
+    // region React-JSON Conversion
+
+    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;
+    }
+
+    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;
+    }
+
+    static WritableMap jsonToReact(JSONObject jsonObject) throws JSONException {
+        WritableMap writableMap = Arguments.createMap();
+        Iterator<String> iterator = jsonObject.keys();
+        while(iterator.hasNext()) {
+            String key = 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;
+    }
+
+    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;
+    }
+
+    // endregion
+
+    // region NFC Conversion
+
     static JSONObject ndefToJSON(Ndef ndef) {
         JSONObject json = new JSONObject();
 
@@ -67,6 +203,15 @@ public class Util {
         return json;
     }
 
+    static WritableMap tagToReact(Tag tag) {
+        try {
+            JSONObject json = tagToJSON(tag);
+            return jsonToReact(json);
+        } catch (JSONException ex) {
+            return null;
+        }
+    }
+
     static String translateType(String type) {
         String translation;
         switch (type) {
@@ -139,4 +284,60 @@ public class Util {
         return json;
     }
 
+    // endregion
+
+    // region Device Capability
+
+    /**
+     * 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:
+     * on some older devices this can still return true while actual read/write later fails when a tag is scanned.
+     *
+     * 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
+     */
+    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;
+        }
+
+        boolean isLenovoP2 = Build.MANUFACTURER.equals("LENOVO")
+                && Build.MODEL.equals("Lenovo P2a42");
+        File device = new File("/dev/bcm2079x-i2c");
+        if (!isLenovoP2 && device.exists()) {
+            return false;
+        }
+
+        device = new File("/dev/pn544");
+        if (device.exists()) {
+            return true;
+        }
+
+        File libsFolder = new File("/system/lib");
+        File[] libs = libsFolder.listFiles();
+        if (libs != null) {
+            for (File lib : libs) {
+                if (lib.isFile()
+                        && lib.getName().startsWith("libnfc")
+                        && lib.getName().contains("brcm")) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    // endregion
+
 }