@wimetrix/nfc-serial-reader 1.0.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+	root: true,
+	extends: ["universe/native", "universe/web"],
+	ignorePatterns: ["build"],
+};

package/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

package/.nvmrc

@@ -0,0 +1 @@
+lts/*

package/.prettierignore

@@ -0,0 +1,13 @@
+# Ignore artifacts:
+build
+coverage
+node_modules
+dist
+build
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+trace
+tsconfig.vitest-temp.json
+android
+ios

package/README.md

@@ -0,0 +1,95 @@
+# NFC Serial Reader
+
+This module allows reading NFC tags using a serial connection to an RFID reader.
+
+## Installation
+
+To install run:
+
+```bash
+pnpm add nfc-box-reader
+```
+
+or
+
+```bash
+npm install nfc-box-reader
+```
+
+or
+
+```bash
+yarn add nfc-box-reader
+```
+
+## Usage
+
+NFC serial reader module provides the following API:
+
+### `connectNFCSerialReader`
+
+This connects to the NFC reader on the given serial port and specified baud rate, starts reading in
+the background and returns a boolean indicating if the connection was successful.
+
+```typescript
+import { connectNFCSerialReader } from "nfc-box-reader";
+
+const connected = await connectNFCSerialReader("/dev/ttyS0", 9600);
+```
+
+### `addNFCReadListener`
+
+> Note: This function should be called after `connectNFCSerialReader` has been called.
+
+This adds a listener to the NFC reader, the listener will be called every time a new tag is read.
+
+```typescript
+import { addNFCReadListener } from "nfc-box-reader";
+
+addNFCReadListener((card) => {
+	console.log(`Card Type: ${card.cardType}`);
+	console.log(`Card ID: ${card.cardId}`);
+});
+```
+
+The payload of the listener is an object with the following properties:
+
+- `cardType`: The type of the card, this is either "TAG" and "WORKER". These are the only two
+  supported card types, if the card type is not one of these two values, then the card type
+  is returned as "UNKNOWN".
+- `cardId`: The ID of the card which is an integer value.
+
+This returns a function that can be called to remove the listener.
+
+### `disconnectNFCSerialReader`
+
+This disconnects the NFC reader, stops reading and returns a boolean indicating if the
+disconnection was successful.
+
+```typescript
+import { disconnectNFCSerialReader } from "nfc-box-reader";
+
+const disconnected = await disconnectNFCSerialReader();
+```
+
+### `listSerialPorts`
+
+This returns a list of available serial ports on the device (the options that can be passed to
+`connectNFCSerialReader`).
+
+```typescript
+import { listSerialPorts } from "nfc-box-reader";
+
+const ports = await listSerialPorts();
+```
+
+### `listBaudRates`
+
+This returns a list of available baud rates that can be passed to `connectNFCSerialReader`.
+The baud rates are hardcoded to the following values: `[9600, 19200, 38400, 57600, 115200]`.
+
+```typescript
+import { listBaudRates } from "nfc-box-reader";
+
+const baudRates = listBaudRates();
+```

package/android/build.gradle

@@ -0,0 +1,58 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.nfcserialreader'
+version = '0.0.1'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+	useDefaultAndroidSdkVersions()
+} else {
+	buildscript {
+		// Simple helper that allows the root project to override versions declared by this library.
+		ext.safeExtGet = { prop, fallback ->
+			rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+		}
+	}
+	project.android {
+		compileSdkVersion safeExtGet("compileSdkVersion", 34)
+		defaultConfig {
+			minSdkVersion safeExtGet("minSdkVersion", 21)
+			targetSdkVersion safeExtGet("targetSdkVersion", 34)
+		}
+	}
+}
+
+android {
+	namespace "expo.modules.nfcserialreader"
+	defaultConfig {
+		versionCode 1
+		versionName "0.0.1"
+	}
+	sourceSets {
+        main {
+            jniLibs.srcDirs = ['src/main/jniLibs']
+        }
+    }
+	lintOptions {
+		abortOnError false
+	}
+}
+
+repositories {
+	flatDir {
+		dirs 'libs'
+	}
+}
+
+dependencies {
+	implementation fileTree(dir: 'libs', include: ['*.jar'])
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/nfcserialreader/NFCReaderService.kt

@@ -0,0 +1,166 @@
+package expo.modules.nfcserialreader
+
+import android.util.Log
+import com.liang.rfid.Reader;
+import java.io.File
+
+class NFCReaderService(
+    module: NFCSerialReaderModule,
+) {
+    val nfcSerialReaderModule = module
+    var reader: Reader? = null
+    val key: ByteArray =
+        byteArrayOf(
+            0xFF.toByte(),
+            0xFF.toByte(),
+            0xFF.toByte(),
+            0xFF.toByte(),
+            0xFF.toByte(),
+            0xFF.toByte(),
+        )
+    val readerArgOne = 0x05.toByte()
+    val readerArgTwo = 0x03.toByte()
+    val readerArgThree = 0x00.toByte()
+    val hexChars = "0123456789ABCDEF".toCharArray()
+    val cardTypes =
+        mapOf(
+            0 to "TAG",
+            5 to "WORKER",
+        )
+    companion object {
+        private const val TAG = "NFCSerialReader"
+    }
+
+    // Extend the ByteArray class to add new function to convert byte array to hex string
+    fun ByteArray.toHex(): String {
+        val result = StringBuffer()
+
+        forEach {
+            val octet = it.toInt()
+            val firstIndex = (octet and 0xF0).ushr(4)
+            val secondIndex = octet and 0x0F
+            result.append(hexChars[firstIndex])
+            result.append(hexChars[secondIndex])
+        }
+
+        return result.toString()
+    }
+
+    fun connect(
+        serialPort: String,
+        baudRate: Int,
+    ): Boolean {
+        if (reader != null) {
+            Log.i(TAG, "Reader is already connected to $serialPort at $baudRate baud rate")
+            return true
+        }
+
+        try {
+            Log.i(TAG, "Connecting to the reader at $serialPort with $baudRate baud rate")
+            reader = Reader.getInstance(serialPort, baudRate)
+            Log.i(
+                TAG,
+                "Successfully connected to the reader at $serialPort with $baudRate baud rate",
+            )
+
+            // Start reading from the reader
+            Thread {
+                while (true) {
+                    // If the reader is null, then we break the loop and stop reading
+                    // This ensures that we stop reading when the reader is disconnected
+                    if (reader == null) break
+                    read()
+                    Thread.sleep(1000)
+                }
+            }.start()
+
+            return true
+        } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "Failed to connect to the reader at $serialPort with $baudRate baud rate: $e",
+            )
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    fun disconnect(): Boolean {
+        if (reader == null) {
+            Log.i(TAG, "Reader is already disconnected")
+            return true
+        }
+
+        try {
+            Log.i(TAG, "Disconnecting from the reader")
+            reader?.close()
+            reader = null
+            Log.i(TAG, "Successfully disconnected from the reader")
+            return true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to disconnect from the reader: $e")
+            e.printStackTrace()
+            return false
+        }
+    }
+
+    fun read() {
+        try {
+            val readData = ByteArray(48)
+            val errorCode = ByteArray(1)
+            val result =
+                reader?.Iso14443a_Read(
+                    readerArgOne,
+                    readerArgTwo,
+                    readerArgThree,
+                    key,
+                    readData,
+                    errorCode,
+                )
+
+            // If the result is not 0, then there was no card to read, so we early return
+            if (result != 0) return
+
+            // Extract the card ID from the read data using bitwise operations
+            val cardId =
+                ((readData[3].toInt() and 0xFF) shl 24) or
+                    ((readData[2].toInt() and 0xFF) shl 16) or
+                    ((readData[1].toInt() and 0xFF) shl 8) or
+                    (readData[0].toInt() and 0xFF)
+
+            // Convert the read data to a hex string
+            val hexData = readData.toHex()
+
+            // Extract the card type from the read data
+            val cardType = hexData.substring(9, 10).toInt(16)
+
+            // Translate the card type to a human-readable string
+            val cardTypeString = cardTypes[cardType] ?: "UNKNOWN"
+
+            // If card type is 0, which
+            val finalCardId =
+                if (cardType == 0) {
+                    hexData.substring(0, 8) // string
+                } else {
+                    cardId.toString() // convert int to string
+                }
+
+            Log.i(
+                TAG,
+                "Read card of type $cardType translated to $cardTypeString with raw ID $cardId, final ID $finalCardId"
+            )
+
+            // Send the event to the JS side with the card ID and card type
+            nfcSerialReaderModule.sendEvent(
+                "onRead",
+                mapOf(
+                    "cardId" to finalCardId,
+                    "cardType" to cardTypeString,
+                ),
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to read from the reader, got error: $e")
+            e.printStackTrace()
+        }
+    }
+}

package/android/src/main/java/expo/modules/nfcserialreader/NFCSerialReaderModule.kt

@@ -0,0 +1,64 @@
+package expo.modules.nfcserialreader
+
+import android.util.Log
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+
+class NFCSerialReaderModule : Module() {
+    companion object {
+        private const val TAG = "NFCSerialReaderModule"
+    }
+
+    val nfcReader = NFCReaderService(this@NFCSerialReaderModule)
+    val serialPorts = mutableListOf<String>()
+
+    // Get list of available serial ports on the device
+    fun listSerialPorts(): List<String> {
+        if (serialPorts.isEmpty()) {
+            val devDirectory = File("/dev")
+
+            if (devDirectory.exists() && devDirectory.isDirectory) {
+                val files = devDirectory.listFiles()
+
+                if (files != null) {
+                    for (file in files) {
+                        if (file.name.startsWith("tty")) {
+                            serialPorts.add(file.absolutePath)
+                        }
+                    }
+                }
+            } else {
+                Log.e(TAG, "Error Listing Serial Ports! /dev Directory does not exist!")
+            }
+        }
+
+        return serialPorts
+    }
+
+    // Pre-defined baud rates
+    fun listBaudRates() = listOf(9600, 19200, 38400, 57600, 115200)
+
+    override fun definition() =
+        ModuleDefinition {
+            Name("NFCSerialReader")
+
+            Events("onRead")
+
+            Function("connect") { serialPort: String, baudRate: Int ->
+                nfcReader.connect(serialPort, baudRate)
+            }
+
+            Function("listSerialPorts") {
+                listSerialPorts()
+            }
+
+            Function("listBaudRates") {
+                listBaudRates()
+            }
+
+            Function("disconnect") {
+                nfcReader.disconnect()
+            }
+        }
+}

package/cspell.json

@@ -0,0 +1,21 @@
+{
+	"ignorePaths": [
+		".git",
+		".vscode",
+		".vscode-insiders",
+		"**/*.apk",
+		"android",
+		"build",
+		"dist",
+		"ios",
+		"node_modules",
+		"package-lock.json",
+		"pnpm-lock.yaml",
+		"public",
+		"trace",
+		"tsconfig.vitest-temp.json",
+		"vscode-extension",
+		"yarn.lock"
+	],
+	"words": ["nfcserialreader", "RFID", "rssi", "UHF"]
+}

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+	"platforms": ["android"],
+	"android": {
+		"modules": ["expo.modules.nfcserialreader.NFCSerialReaderModule"]
+	}
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@wimetrix/nfc-serial-reader",
+	"version": "1.0.0",
+	"description": "This module allows reading NFC tags using a serial connection to an RFID reader.",
+	"main": "build/index.js",
+	"types": "build/index.d.ts",
+	"scripts": {
+		"build": "expo-module build",
+		"clean": "expo-module clean",
+		"lint": "expo-module lint",
+		"test": "expo-module test",
+		"expo-module": "expo-module",
+		"open:ios": "xed example/ios",
+		"open:android": "open -a \"Android Studio\" example/android"
+	},
+	"keywords": [
+		"react-native",
+		"expo",
+		"nfc-serial-reader",
+		"nfc-box-reader",
+		"NFCSerialReader"
+	],
+	"license": "MIT",
+	"devDependencies": {
+		"@types/react": "^18.0.25",
+		"expo-module-scripts": "^3.5.2",
+		"expo-modules-core": "^1.12.24"
+	},
+	"peerDependencies": {
+		"expo": "*",
+		"react": "*",
+		"react-native": "*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/WiMetrixDev/nfc-serial-reader"
+	},
+	"packageManager": "yarn@4.5.0"
+}

package/prettier.config.cjs

@@ -0,0 +1,7 @@
+/** @type {import('prettier').Config} */
+const config = {
+	useTabs: true,
+	singleAttributePerLine: true,
+};
+
+module.exports = config;

package/src/NFCSerialReaderModule.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from "expo-modules-core";
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule("NFCSerialReader");

package/src/index.ts

@@ -0,0 +1,39 @@
+import { EventEmitter, NativeModulesProxy } from "expo-modules-core";
+
+import NFCSerialReaderModule from "./NFCSerialReaderModule";
+
+import type { Subscription } from "expo-modules-core";
+
+export function connectNFCSerialReader(
+	serialPort: string,
+	baudRate: number
+): boolean {
+	return NFCSerialReaderModule.connect(serialPort, baudRate);
+}
+
+export function listSerialPorts(): string[] {
+	return NFCSerialReaderModule.listSerialPorts();
+}
+
+export function listBaudRates(): number[] {
+	return NFCSerialReaderModule.listBaudRates();
+}
+
+export function disconnectNFCSerialReader(): boolean {
+	return NFCSerialReaderModule.disconnect();
+}
+
+const emitter = new EventEmitter(
+	NFCSerialReaderModule ?? NativeModulesProxy.NFCSerialReader
+);
+
+export type NFCReadEventPayload = {
+	cardType: "TAG" | "WORKER" | "UNKNOWN";
+	cardId: string;
+};
+
+export function addNFCReadListener(
+	listener: (event: NFCReadEventPayload) => void
+): Subscription {
+	return emitter.addListener<NFCReadEventPayload>("onRead", listener);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+	"extends": "expo-module-scripts/tsconfig.base",
+	"compilerOptions": {
+		"outDir": "./build"
+	},
+	"include": ["./src"],
+	"exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}