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

package/README.md

@@ -1,7 +1,7 @@
 # react-native-nfc-manager
 
 [![npm version](https://img.shields.io/npm/v/react-native-nfc-manager.svg?style=flat)](https://www.npmjs.com/package/react-native-nfc-manager)
-[![build](https://api.travis-ci.org/whitedogg13/react-native-nfc-manager.svg?branch=master)](https://travis-ci.org/whitedogg13/react-native-nfc-manager)
+[![CI](https://github.com/revtel/react-native-nfc-manager/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/revtel/react-native-nfc-manager/actions/workflows/ci.yml)
 [![issues](https://img.shields.io/github/issues/whitedogg13/react-native-nfc-manager.svg?style=flat)](https://github.com/whitedogg13/react-native-nfc-manager/issues)
 
 Bring NFC feature to React Native. Inspired by [phonegap-nfc](https://github.com/chariotsolutions/phonegap-nfc) and [react-native-ble-manager](https://github.com/innoveit/react-native-ble-manager)
@@ -15,7 +15,11 @@ Made with ❤️ by [whitedogg13](https://github.com/whitedogg13) and [revteltec
 ## Version Notes
 
 - `v3` only supports legacy architecture (`v3.x.y`).
-- `v4` supports new architecture (still in beta, `v4.0.0-beta.x`) .
+- `v4` targets the New Architecture and remains beta (`v4.0.0-beta.x`). Its support floor is React Native 0.76 with the New Architecture enabled; React Native 0.82 and newer are New Architecture only.
+
+## Support Policy
+
+- See [Support Policy](./docs/SUPPORT_POLICY.md) for official React Native version window, architecture targets, and verification matrix.
 
 ## Table of Contents
 
@@ -28,6 +32,7 @@ Made with ❤️ by [whitedogg13](https://github.com/whitedogg13) and [revteltec
 7. [API](#api)
 8. [App demo](#appdemo)
 9. [Learn](#learn)
+10. [Development Example](#development-example)
 
 ## Installation
 
@@ -36,6 +41,9 @@ Made with ❤️ by [whitedogg13](https://github.com/whitedogg13) and [revteltec
 ```shell
 npm i --save react-native-nfc-manager
 ```
+
+To evaluate the v4 beta, install an explicit `4.0.0-beta.x` version rather than relying on the default npm tag.
+
 ### iOS
 
 This library use native-modules, so you will need to do `pod install` for iOS:
@@ -43,6 +51,9 @@ This library use native-modules, so you will need to do `pod install` for iOS:
 ```shell
 cd ios && pod install && cd ..
 ```
+
+Minimum Swift language version for iOS native sources is **Swift 5.7**.
+
 ### Android
 
 It should be properly auto-linked, so you don't need to do anything.
@@ -197,6 +208,28 @@ export default App;
 
 Check the full documentation that contains `examples`, `faq` and other topics like `Expo` in our [Wiki](https://github.com/revtel/react-native-nfc-manager/wiki)
 
+## Development Example
+
+<a name="development-example"></a>
+
+For local library development and physical-device NFC testing, use the React Native 0.84 New Architecture example app in [`example/`](./example). See [example/README.md](./example/README.md).
+
+The example Jest suite mocks the native module and verifies application interactions only. It does not verify NFC hardware. Android and iOS compiler builds and physical-device checks are separate release gates.
+
+### Build (TypeScript)
+
+This project now uses a TypeScript build flow and emits distributable JavaScript to [`dist/`](./dist):
+
+```shell
+npm run build
+```
+
+For package publishing, `prepack` runs the build automatically.
+
+### Routine CI
+
+Routine CI uses Node.js 22 and runs dependency installation, the TypeScript build, lint, root Jest tests, and type checking. It deliberately does not run Android or iOS builds.
+
 ## Nfc Compatibility
 
 <a name="nfccompatibility"></a>
@@ -215,6 +248,8 @@ Check the full documentation that contains `examples`, `faq` and other topics li
 | `Iso15693IOS`     | ❌      | ✅   |
 | `FelicaIOS`       | ❌      | ✅   |
 
+This table describes the intended platform API availability. It is not a record of the devices, OS versions, or tag technologies verified for a particular release; see the [Support Policy](./docs/SUPPORT_POLICY.md) for evidence labels and limitations.
+
 ## Usage concept
 
 <a name="usageconcept"></a>
@@ -293,4 +328,3 @@ We have a full featured NFC utility app using this library available for downloa
 We have published a React Native NFC course with [newline.co](https://www.newline.co/), check it out!
 - Free course (1 hour) about basic NFC setup and concept [here](https://www.youtube.com/watch?v=rAS-DvNUFck)
 - Full course (3 hours) for more (NDEF, Deep Linking, NTAG password protection, signature with UID) [here](https://www.newline.co/courses/newline-guide-to-nfcs-with-react-native)
-

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

@@ -0,0 +1,419 @@
+package community.revteltech.nfc;
+
+import static community.revteltech.nfc.NfcErrorCodes.*;
+
+import android.nfc.TagLostException;
+import android.nfc.tech.MifareClassic;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
+
+import java.util.Locale;
+
+class MifareClassicHandler {
+    private MifareClassicHandler() {
+    }
+
+    static void putConstants(java.util.Map<String, Object> constants) {
+        constants.put("MIFARE_BLOCK_SIZE", MifareClassic.BLOCK_SIZE);
+    }
+
+    static void authenticate(
+            TagTechnologyRequest techRequest,
+            char type,
+            int sector,
+            ReadableArray key,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = (MifareClassic) techRequest.getTechHandle();
+            if (mifareTag == null || mifareTag.getType() == MifareClassic.TYPE_UNKNOWN) {
+                callback.invoke("mifareClassicAuthenticate fail: TYPE_UNKNOWN");
+                return;
+            } else if (sector >= mifareTag.getSectorCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicAuthenticate fail: invalid sector %d (max %d)",
+                        sector,
+                        mifareTag.getSectorCount()
+                );
+                callback.invoke(msg);
+                return;
+            } else if (key.size() != 6) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicAuthenticate fail: invalid key (needs length 6 but has %d characters)",
+                        key.size()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            boolean result;
+            if (type == 'A') {
+                result = mifareTag.authenticateSectorWithKeyA(sector, rnArrayToBytes(key));
+            } else {
+                result = mifareTag.authenticateSectorWithKeyB(sector, rnArrayToBytes(key));
+            }
+
+            if (!result) {
+                callback.invoke("mifareClassicAuthenticate fail: AUTH_FAIL");
+                return;
+            }
+
+            callback.invoke(null, true);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicAuthenticate fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicAuthenticate fail: " + ex);
+        }
+    }
+
+    static void getBlockCountInSector(
+            TagTechnologyRequest techRequest,
+            int sectorIndex,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicGetBlockCountInSector");
+            if (mifareTag == null) {
+                return;
+            }
+            if (sectorIndex >= mifareTag.getSectorCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicGetBlockCountInSector fail: invalid sector %d (max %d)",
+                        sectorIndex,
+                        mifareTag.getSectorCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            callback.invoke(null, mifareTag.getBlockCountInSector(sectorIndex));
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicGetBlockCountInSector fail: " + ex);
+        }
+    }
+
+    static void getSectorCount(TagTechnologyRequest techRequest, Callback callback) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicGetSectorCount");
+            if (mifareTag == null) {
+                return;
+            }
+
+            callback.invoke(null, mifareTag.getSectorCount());
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicGetSectorCount fail: " + ex);
+        }
+    }
+
+    static void sectorToBlock(
+            TagTechnologyRequest techRequest,
+            int sectorIndex,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicSectorToBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (sectorIndex >= mifareTag.getSectorCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicSectorToBlock fail: invalid sector %d (max %d)",
+                        sectorIndex,
+                        mifareTag.getSectorCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            callback.invoke(null, mifareTag.sectorToBlock(sectorIndex));
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicSectorToBlock fail: " + ex);
+        }
+    }
+
+    static void readBlock(
+            TagTechnologyRequest techRequest,
+            int blockIndex,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicReadBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (blockIndex >= mifareTag.getBlockCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicReadBlock fail: invalid block %d (max %d)",
+                        blockIndex,
+                        mifareTag.getBlockCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            byte[] buffer = mifareTag.readBlock(blockIndex);
+            WritableArray result = bytesToRnArray(buffer);
+            callback.invoke(null, result);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicReadBlock fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicReadBlock fail: " + ex);
+        }
+    }
+
+    static void readSector(
+            TagTechnologyRequest techRequest,
+            int sectorIndex,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicReadSector");
+            if (mifareTag == null) {
+                return;
+            }
+            if (sectorIndex >= mifareTag.getSectorCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicReadSector fail: invalid sector %d (max %d)",
+                        sectorIndex,
+                        mifareTag.getSectorCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            WritableArray result = Arguments.createArray();
+            int blocks = mifareTag.getBlockCountInSector(sectorIndex);
+            for (int i = 0; i < blocks; i++) {
+                byte[] buffer = mifareTag.readBlock(mifareTag.sectorToBlock(sectorIndex) + i);
+                appendBytesToRnArray(result, buffer);
+            }
+
+            callback.invoke(null, result);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicReadSector fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicReadSector fail: " + ex);
+        }
+    }
+
+    static void writeBlock(
+            TagTechnologyRequest techRequest,
+            int blockIndex,
+            ReadableArray block,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicWriteBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (blockIndex >= mifareTag.getBlockCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicWriteBlock fail: invalid block %d (max %d)",
+                        blockIndex,
+                        mifareTag.getBlockCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+            if (block.size() != MifareClassic.BLOCK_SIZE) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicWriteBlock fail: invalid block size %d (should be %d)",
+                        block.size(),
+                        MifareClassic.BLOCK_SIZE
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            byte[] buffer = rnArrayToBytes(block);
+            mifareTag.writeBlock(blockIndex, buffer);
+            callback.invoke(null, true);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicWriteBlock fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicWriteBlock fail: " + ex);
+        }
+    }
+
+    static void incrementBlock(
+            TagTechnologyRequest techRequest,
+            int blockIndex,
+            int value,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicIncrementBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (blockIndex >= mifareTag.getBlockCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicIncrementBlock fail: invalid block %d (max %d)",
+                        blockIndex,
+                        mifareTag.getBlockCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            mifareTag.increment(blockIndex, value);
+            callback.invoke(null, true);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicIncrementBlock fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicIncrementBlock fail: " + ex);
+        }
+    }
+
+    static void decrementBlock(
+            TagTechnologyRequest techRequest,
+            int blockIndex,
+            int value,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicDecrementBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (blockIndex >= mifareTag.getBlockCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicDecrementBlock fail: invalid block %d (max %d)",
+                        blockIndex,
+                        mifareTag.getBlockCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            mifareTag.decrement(blockIndex, value);
+            callback.invoke(null, true);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicDecrementBlock fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicDecrementBlock fail: " + ex);
+        }
+    }
+
+    static void transferBlock(
+            TagTechnologyRequest techRequest,
+            int blockIndex,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareClassic mifareTag = getValidMifareClassic(techRequest, callback, "mifareClassicTransferBlock");
+            if (mifareTag == null) {
+                return;
+            }
+            if (blockIndex >= mifareTag.getBlockCount()) {
+                String msg = String.format(
+                        Locale.US,
+                        "mifareClassicTransferBlock fail: invalid block %d (max %d)",
+                        blockIndex,
+                        mifareTag.getBlockCount()
+                );
+                callback.invoke(msg);
+                return;
+            }
+
+            mifareTag.transfer(blockIndex);
+            callback.invoke(null, true);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareClassicTransferBlock fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareClassicTransferBlock fail: " + ex);
+        }
+    }
+
+    private static MifareClassic getValidMifareClassic(TagTechnologyRequest techRequest, Callback callback, String opName) {
+        MifareClassic mifareTag = (MifareClassic) techRequest.getTechHandle();
+        if (mifareTag == null || mifareTag.getType() == MifareClassic.TYPE_UNKNOWN) {
+            callback.invoke(opName + " fail: TYPE_UNKNOWN");
+            return null;
+        }
+        return mifareTag;
+    }
+
+    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) {
+        return appendBytesToRnArray(Arguments.createArray(), bytes);
+    }
+
+    private static WritableArray appendBytesToRnArray(WritableArray value, byte[] bytes) {
+        for (byte aByte : bytes) {
+            value.pushInt((aByte & 0xFF));
+        }
+        return value;
+    }
+}

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

@@ -0,0 +1,84 @@
+package community.revteltech.nfc;
+
+import static community.revteltech.nfc.NfcErrorCodes.*;
+
+import android.nfc.TagLostException;
+import android.nfc.tech.MifareUltralight;
+
+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 MifareUltralightHandler {
+    private MifareUltralightHandler() {
+    }
+
+    static void putConstants(java.util.Map<String, Object> constants) {
+        constants.put("MIFARE_ULTRALIGHT_PAGE_SIZE", MifareUltralight.PAGE_SIZE);
+        constants.put("MIFARE_ULTRALIGHT_TYPE", MifareUltralight.TYPE_ULTRALIGHT);
+        constants.put("MIFARE_ULTRALIGHT_TYPE_C", MifareUltralight.TYPE_ULTRALIGHT_C);
+        constants.put("MIFARE_ULTRALIGHT_TYPE_UNKNOWN", MifareUltralight.TYPE_UNKNOWN);
+    }
+
+    static void readPages(
+            TagTechnologyRequest techRequest,
+            int pageOffset,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            MifareUltralight techHandle = (MifareUltralight) techRequest.getTechHandle();
+            byte[] resultBytes = techHandle.readPages(pageOffset);
+            WritableArray resultRnArray = bytesToRnArray(resultBytes);
+            callback.invoke(null, resultRnArray);
+        } catch (TagLostException ex) {
+            callback.invoke("mifareUltralight fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareUltralight fail: " + ex);
+        }
+    }
+
+    static void writePage(
+            TagTechnologyRequest techRequest,
+            int pageOffset,
+            ReadableArray rnArray,
+            Callback callback
+    ) {
+        if (techRequest == null) {
+            callback.invoke(ERR_NO_TECH_REQ);
+            return;
+        }
+
+        try {
+            byte[] bytes = rnArrayToBytes(rnArray);
+            MifareUltralight techHandle = (MifareUltralight) techRequest.getTechHandle();
+            techHandle.writePage(pageOffset, bytes);
+            callback.invoke();
+        } catch (TagLostException ex) {
+            callback.invoke("mifareUltralight fail: TAG_LOST");
+        } catch (Exception ex) {
+            callback.invoke("mifareUltralight fail: " + ex);
+        }
+    }
+
+    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;
+    }
+}