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

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;
         }
     }
 }