@exxili/capacitor-nfc 0.0.10 → 0.0.12

package/README.md

@@ -9,32 +9,35 @@ A Capacitor plugin for reading and writing NFC tags on iOS and Android devices.
 
 ## Table of Contents
 
-- [Installation](#installation)
-- [iOS Setup](#ios-setup)
-- [Android Setup](#android-setup)
-- [Usage](#usage)
-  - [Reading NFC Tags](#reading-nfc-tags)
-  - [Writing NFC Tags](#writing-nfc-tags)
-- [API](#api)
-  - [Methods](#methods)
-    - [`isSupported()`](#issupported)
-    - [`startScan()`](#startscan)
-    - [`writeNDEF(options)`](#writendefoptions-ndefwriteoptionst-extends-string--number--uint8array--string)
-    - [`cancelWriteAndroid`](#cancelwriteandroid)
-  - [Listeners](#listeners)
-    - [`onRead(listener)`](#onreadlistener-data-ndefmessagestransformable--void)
-    - [`onError('listener)`](#onerrorlistener-error-nfcerror--void)
-    - [`onWrite(listener)`](#onwritelistener---void)
-  - [Interfaces](#interfaces)
-    - [`NDEFWriteOptions`](#ndefwriteoptions)
-    - [`NDEFWriteOptions`](#ndefmessagestransformable)
-    - [`NDEFMessages`](#ndefmessages)
-    - [`NDEFMessage`](#ndefmessage)
-    - [`NDEFRecord`](#ndefrecord)
-    - [`NFCError`](#nfcerror)
-- [Integration into a Capacitor App](#integration-into-a-capacitor-app)
-- [Example](#example)
-- [License](#license)
+- [Capacitor NFC Plugin (@exxili/capacitor-nfc)](#capacitor-nfc-plugin-exxilicapacitor-nfc)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [iOS Setup](#ios-setup)
+    - [1. Enable NFC Capability](#1-enable-nfc-capability)
+    - [2. Add Usage Description](#2-add-usage-description)
+  - [Android Setup](#android-setup)
+  - [Usage](#usage)
+    - [Reading NFC Tags](#reading-nfc-tags)
+    - [Writing NFC Tags](#writing-nfc-tags)
+  - [API](#api)
+    - [Methods](#methods)
+      - [`isSupported()`](#issupported)
+      - [`startScan()`](#startscan)
+      - [`cancelScan()`](#cancelscan)
+      - [`writeNDEF(options: NDEFWriteOptions<T extends string | number[] | Uint8Array = string>)`](#writendefoptions-ndefwriteoptionst-extends-string--number--uint8array--string)
+      - [`cancelWriteAndroid()`](#cancelwriteandroid)
+    - [Listeners](#listeners)
+      - [`onRead(listener: (data: NDEFMessagesTransformable) => void)`](#onreadlistener-data-ndefmessagestransformable--void)
+    - [Interfaces](#interfaces)
+      - [`NDEFWriteOptions`](#ndefwriteoptions)
+      - [`NDEFMessagesTransformable`](#ndefmessagestransformable)
+      - [`NDEFMessages`](#ndefmessages)
+      - [`NDEFMessage`](#ndefmessage)
+      - [`NDEFRecord`](#ndefrecord)
+      - [`NFCError`](#nfcerror)
+  - [Integration into a Capacitor App](#integration-into-a-capacitor-app)
+  - [Example](#example)
+  - [License](#license)
 
 ## Installation
 
@@ -95,20 +98,37 @@ import { NFC } from '@exxili/capacitor-nfc';
 To read NFC tags, you need to listen for `nfcTag` events. On iOS, you must also start the NFC scanning session using `startScan()`.
 
 ```typescript
-import {NFC, NDEFMessagesTransformable, NFCError} from '@exxili/capacitor-nfc';
+import { NFC, NDEFMessagesTransformable, NFCError } from '@exxili/capacitor-nfc';
 
-// Start NFC scanning
+// Start NFC scanning (iOS only)
 NFC.startScan().catch((error) => {
   console.error('Error starting NFC scan:', error);
 });
 
 // Listen for NFC tag detection
 NFC.onRead((data: NDEFMessagesTransformable) => {
-  console.log('Received NFC tag:', data.string());
+  // Text (T) and URI (U) records decoded; others best-effort UTF-8
+  const asString = data.string();
+  console.log('First record text payload:', asString.messages[0]?.records[0]?.payload);
+
+  // Raw bytes
+  const asUint8 = data.uint8Array();
+  console.log('First record raw bytes length:', asUint8.messages[0]?.records[0]?.payload.length);
+
+  // Access tag information (UID, tech types, etc.)
+  if (asString.tagInfo) {
+    console.log('Tag UID:', asString.tagInfo.uid);
+    console.log('Tag technologies:', asString.tagInfo.techTypes);
+    console.log('Tag type:', asString.tagInfo.type);
+    if (asString.tagInfo.maxSize) {
+      console.log('Max NDEF size:', asString.tagInfo.maxSize);
+    }
+    console.log('Is writable:', asString.tagInfo.isWritable);
+  }
 });
 
 // Handle NFC errors
-NFC.onError('nfcError', (error: NFCError) => {
+NFC.onError((error: NFCError) => {
   console.error('NFC Error:', error);
 });
 ```
@@ -123,9 +143,17 @@ import { NFC, NDEFWriteOptions, NFCError } from '@exxili/capacitor-nfc';
 const message: NDEFWriteOptions = {
   records: [
     {
-      type: 'T', // Text record type
+      type: 'T', // Well Known Text record. String payload will be encoded as: [status][lang='en'][UTF-8 text]
       payload: 'Hello, NFC!',
     },
+    {
+      type: 'U', // Well Known URI record. String payload encoded as: [0x00][URI bytes]
+      payload: 'https://example.com',
+    },
+    {
+      type: 'T',
+      payload: new Uint8Array([0x01, 0x65, 0x48, 0x69]), // Raw bytes preserved (DO NOT re-format)
+    },
   ],
 };
 
@@ -161,7 +189,7 @@ Returns if NFC is supported on the scanning device.
 
 #### `startScan()`
 
-Starts the NFC scanning session on ***iOS only***. Android devices are always in reading mode, so setting up the `nfcTag` listener is sufficient to handle tag reads on Android.
+Starts the NFC scanning session on **_iOS only_**. Android devices are always in reading mode, so setting up the `nfcTag` listener is sufficient to handle tag reads on Android.
 
 **Returns**: `Promise<void>`
 
@@ -175,17 +203,45 @@ NFC.startScan()
   });
 ```
 
-#### `writeNDEF(options: NDEFWriteOptions<T extends string | number[] | Uint8Array = string)`
+#### `cancelScan()`
+
+Immediately invalidates the active iOS CoreNFC reader session (if any). Useful when you want to abort a scan early instead of waiting for the user to cancel or for a tag detection timeout.
+
+Platform notes:
+
+- iOS: Actively ends the session. Calling `startScan()` again after the returned promise resolves is safe.
+- Android: No-op (Android is always passively listening via foreground dispatch; you generally just ignore future events or control UI state).
+
+```typescript
+await NFC.cancelScan(); // iOS: ends session; Android: no-op
+// Optionally restart
+await NFC.startScan();
+```
+
+**Returns**: `Promise<void>`
+
+#### `writeNDEF(options: NDEFWriteOptions<T extends string | number[] | Uint8Array = string>)`
 
 Writes an NDEF message to an NFC tag.
 
-Payload may be provided as a string, `Uint8Array`, or an array of numbers. The plugin will automatically convert the payload to a byte array for storage on the NFC tag.
+Payload may be provided as a string, `Uint8Array`, or an array of numbers.
+
+Automatic formatting rules (to aid interoperability):
+
+- Text (`type: 'T'` + string payload): encoded per NFC Forum RTD Text spec `[status][lang=en][UTF-8 text]`.
+- URI (`type: 'U'` + string payload): encoded as `[0x00][UTF-8 URI bytes]` (prefix compression not yet applied).
+- Any other `type` + string payload: UTF-8 bytes only (no extra framing).
+- `Uint8Array` or `number[]` payloads are treated as raw bytes and written verbatim (never altered).
+
+If you need full manual control of a Text or URI record, supply raw bytes (number[] / Uint8Array) and the plugin will not modify them.
+
+If you attempt to write zero records the promise rejects with `Error("At least one NDEF record is required")`.
 
 Android use: since Android has no default UI for reading and writing NFC tags, it is recommended that you add a UI indicator to your application when calling `writeNDEF` and remove it in the `nfcWriteSuccess` listener callback and the `nfcError` listener callback. This will prevent accidental writes to tags that your users intended to read from.
 
 **Parameters**:
 
-- `options: NDEFWriteOptions<T extends string | number[] | Uint8Array = string>` - The NDEF message to write.
+- `options: NDEFWriteOptions<T extends string | number[] | Uint8Array = string>` - The NDEF message to write. Must include at least one record.
 
 **Returns**: `Promise<void>`
 
@@ -209,24 +265,35 @@ Cancels an Android NFC write operation. Android does not have a native UI for NF
 
 Adds a listener for NFC tag detection events. Returns type `NDEFMessagesTransformable`, which returns the following methods to provide the payload:
 
-* `string()`: Returns `NDEFMessages<string>`, where all payloads are strings.
-* `base64()`: Returns `NDEFMessages<string>`, where all payloads are the base64-encoded payloads read from the NFC tag.
-* `uint8Array()`: Returns `NDEFMessages<Uint8Array>`, where all payloads are the `Uint8Array` bytes from the NFC tag.
-* `numberArray()`: Returns `NDEFMessages<number[]>`, where all payloads bytes from the NFC tag represented as a `number[]`.
+- `string()`: Returns `NDEFMessages<string>`, where all payloads are strings.
+- `base64()`: Returns `NDEFMessages<string>`, where all payloads are the base64-encoded payloads read from the NFC tag.
+- `uint8Array()`: Returns `NDEFMessages<Uint8Array>`, where all payloads are the `Uint8Array` bytes from the NFC tag.
+- `numberArray()`: Returns `NDEFMessages<number[]>`, where all payloads' bytes from the NFC tag are represented as a `number[]`.
 
 **Parameters**:
 
 - `listener: (data: NDEFMessagesTransformable) => void` - The function to call when an NFC tag is detected.
 
-**Returns**: `void`
+**Returns**: `() => void` Unsubscribe function to remove just this listener.
 
 ```typescript
-NFC.onRead((data: NDEFMessages) => {
-  console.log('Received NFC tag:', data);
+const offRead = NFC.onRead((data) => {
+  const textRecords = data.string(); // Decoded string representation
+  const base64Records = data.base64(); // Original base64 payloads
+  const bytesRecords = data.uint8Array(); // Uint8Array payloads
+  const numArrayRecords = data.numberArray(); // number[] representation
+  console.log(textRecords);
 });
+
+// Later (component unmount / cleanup)
+offRead();
 ```
 
-#### `onError(listener: (error: NFCError) => void)`
+> Tip: Register listeners once per screen/component and always dispose them when unmounting to avoid duplicate callbacks.
+
+````
+
+#### On Error
 
 Adds a listener for NFC error events.
 
@@ -234,29 +301,23 @@ Adds a listener for NFC error events.
 
 - `listener: (error: NFCError) => void` - The function to call when an NFC error occurs.
 
-**Returns**: `PluginListenerHandle`
-
-```typescript
-NFC.onError((error: NFCError) => {
-  console.error('NFC Error:', error);
-});
-```
+**Returns**: `() => void` Unsubscribe function.
 
-#### `onWrite(listener: () => void)`
+#### On Error
 
-Adds a listener for NFC write success events.
+Adds a listener for NFC error events.
 
 **Parameters**:
 
-- `listener: () => void` - The function to call when an NDEF message has been written successfully.
+- `listener: (error: NFCError) => void` - The function to call when an NFC error occurs.
 
-**Returns**: `PluginListenerHandle`
+**Returns**: `() => void` Unsubscribe function.
 
 ```typescript
-NFC.onWrite('nfcWriteSuccess', () => {
-  console.log('NDEF message written successfully.');
-});
-```
+const offError = NFC.onError(err => console.error('NFC Error:', err));
+// later
+offError();
+````
 
 ### Interfaces
 
@@ -274,17 +335,17 @@ interface NDEFWriteOptions<T extends string | number[] | Uint8Array = string> {
 
 Returned by `onRead` and includes the following methods to provide the payload:
 
-* `string()`: Returns `NDEFMessages<string>`, where all payloads are strings.
-* `base64()`: Returns `NDEFMessages<string>`, where all payloads are the base64-encoded payloads read from the NFC tag.
-* `uint8Array()`: Returns `NDEFMessages<Uint8Array>`, where all payloads are the `Uint8Array` bytes from the NFC tag.
-* `numberArray()`: Returns `NDEFMessages<number[]>`, where all payloads bytes from the NFC tag represented as a `number[]`.
+- `string()`: Returns `NDEFMessages<string>`, where all payloads are strings.
+- `base64()`: Returns `NDEFMessages<string>`, where all payloads are the base64-encoded payloads read from the NFC tag.
+- `uint8Array()`: Returns `NDEFMessages<Uint8Array>`, where all payloads are the `Uint8Array` bytes from the NFC tag.
+- `numberArray()`: Returns `NDEFMessages<number[]>`, where all payloads bytes from the NFC tag represented as a `number[]`.
 
 ```typescript
 interface NDEFMessagesTransformable {
-  base64: ()=> NDEFMessages;
-  uint8Array: ()=> NDEFMessages<Uint8Array>;
-  string: ()=> NDEFMessages;
-  numberArray: ()=> NDEFMessages<number[]>;
+  base64: () => NDEFMessages<string>; // Original base64 strings
+  uint8Array: () => NDEFMessages<Uint8Array>; // Raw bytes
+  string: () => NDEFMessages<string>; // Decoded (T & U handled, others UTF-8 best-effort)
+  numberArray: () => NDEFMessages<number[]>; // Raw bytes as number[]
 }
 ```
 
@@ -295,6 +356,40 @@ Data received from an NFC tag.
 ```typescript
 interface NDEFMessages {
   messages: NDEFMessage[];
+  tagInfo?: TagInfo;
+}
+```
+
+#### `TagInfo`
+
+Information about the NFC tag that was read.
+
+```typescript
+interface TagInfo {
+  /**
+   * The unique identifier of the tag (UID) as a hex string
+   */
+  uid: string;
+
+  /**
+   * The NFC tag technology types supported
+   */
+  techTypes: string[];
+
+  /**
+   * The maximum size of NDEF message that can be written to this tag (if applicable)
+   */
+  maxSize?: number;
+
+  /**
+   * Whether the tag is writable
+   */
+  isWritable?: boolean;
+
+  /**
+   * The tag type (e.g., "ISO14443-4", "MifareClassic", etc.)
+   */
+  type?: string;
 }
 ```
 
@@ -324,7 +419,7 @@ interface NDEFRecord<T = number[]> {
    */
   payload: T;
 }
-````
+```
 
 #### `NFCError`
 
@@ -363,54 +458,47 @@ To integrate this plugin into your Capacitor app:
 Here's a complete example of how to read and write NFC tags in your app:
 
 ```typescript
-import { NFC, NDEFMessages, NDEFWriteOptions, NFCError } from '@exxili/capacitor-nfc';
+import { NFC, NDEFWriteOptions, NFCError, NDEFMessagesTransformable } from '@exxili/capacitor-nfc';
 
-// Check if NFC is supported
+// Check if NFC is supported (optional gating logic)
 const { supported } = await NFC.isSupported();
+if (!supported) {
+  console.warn('NFC not supported on this device');
+}
 
-// Start NFC scanning -- iOS only
-NFC.startScan().catch((error) => {
-  console.error('Error starting NFC scan:', error);
-});
+// Start NFC scanning (needed on iOS only)
+NFC.startScan().catch((err) => console.error('Failed to start scan', err));
 
-// Listen for NFC tag detection
-NFC.onRead((data: NDEFMessages) => {
-  const stringMessages: NDEFMessage<string> = data.string();
-  const uint8ArrayMessages: NDEFMessage<Uint8Array> = data.uint8Array();
-  
-  // Print all Uint8Array payloads
-  console.log('Received NFC tag:', stringMessages.messages?.at(0)?.records?.at(0).payload);    // prints string[]
-  console.log('Received NFC tag:', uint8ArrayPayloads.messages?.at(0)?.records?.at(0).payload);    // prints Uint8Array[]
-});
+// Read listener returns a transformable wrapper
+const offRead = NFC.onRead((data: NDEFMessagesTransformable) => {
+  const textView = data.string(); // NDEFMessages<string>
+  const rawBytesView = data.uint8Array(); // NDEFMessages<Uint8Array>
 
-// Handle NFC errors
-NFC.onError((error: NFCError) => {
-  console.error('NFC Error:', error);
+  const firstText = textView.messages[0]?.records[0]?.payload;
+  const firstLength = rawBytesView.messages[0]?.records[0]?.payload.length;
+  console.log('First text record:', firstText);
+  console.log('First record byte length:', firstLength);
 });
 
-// Prepare an NDEF message to write
+// Error listener (covers read & write errors)
+const offError = NFC.onError((error: NFCError) => console.error('NFC Error:', error));
+
+// Prepare an NDEF message to write (auto-formats Text/URI if payload is string)
 const message: NDEFWriteOptions = {
   records: [
-    {
-      type: 'T', // Text record type
-      payload: 'Hello, NFC!',
-    },
+    { type: 'T', payload: 'Hello, NFC!' },
+    { type: 'U', payload: 'https://example.com' },
   ],
 };
 
-// Write NDEF message to NFC tag
-NFC.writeNDEF(message)
-  .then(() => {
-    console.log('Write initiated');
-  })
-  .catch((error) => {
-    console.error('Error writing to NFC tag:', error);
-  });
+await NFC.writeNDEF(message).catch((err) => console.error('Write failed', err));
 
-// Listen for write success
-NFC.onWrite('nfcWriteSuccess', () => {
-  console.log('NDEF message written successfully.');
-});
+const offWrite = NFC.onWrite(() => console.log('Write success'));
+
+// Later (cleanup)
+offRead();
+offError();
+offWrite();
 ```
 
 ## License

package/android/src/main/kotlin/com/exxili/capacitornfc/NFCPlugin.kt

@@ -1,5 +1,6 @@
 package com.exxili.capacitornfc
 
+import android.app.ActivityOptions
 import android.app.PendingIntent
 import android.content.Intent
 import android.content.IntentFilter
@@ -22,7 +23,10 @@ import android.nfc.tech.NfcB
 import android.nfc.tech.NfcBarcode
 import android.nfc.tech.NfcF
 import android.nfc.tech.NfcV
+import android.os.Build
+import android.os.Bundle
 import android.util.Log
+import androidx.annotation.RequiresApi
 import com.getcapacitor.JSArray
 import com.getcapacitor.JSObject
 import com.getcapacitor.Plugin
@@ -53,6 +57,7 @@ class NFCPlugin : Plugin() {
         NfcV::class.java.name
     ))
 
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
     public override fun handleOnNewIntent(intent: Intent?) {
         super.handleOnNewIntent(intent)
 
@@ -66,9 +71,9 @@ class NFCPlugin : Plugin() {
             writeMode = false
             recordsBuffer = null
         }
-        else if (ACTION_NDEF_DISCOVERED == intent.action) {
+    else if (ACTION_NDEF_DISCOVERED == intent.action || ACTION_TAG_DISCOVERED == intent.action || ACTION_TECH_DISCOVERED == intent.action) {
             Log.d("NFC", "READ MODE START")
-             handleReadTag(intent)
+            handleReadTag(intent)
         }
     }
 
@@ -115,8 +120,28 @@ class NFCPlugin : Plugin() {
             addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
         }
 
+        val pendingIntentFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_MUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
+        }
+
+        var activityOptionsBundle: Bundle? = null
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 35 (Android 15)
+            activityOptionsBundle = ActivityOptions.makeBasic().apply {
+                setPendingIntentCreatorBackgroundActivityStartMode(ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED)
+            }.toBundle()
+        }
+
         val pendingIntent =
-            PendingIntent.getActivity(this.activity, 0, intent, PendingIntent.FLAG_MUTABLE)
+            PendingIntent.getActivity(
+                this.activity,
+                0,
+                intent,
+                pendingIntentFlags,
+                activityOptionsBundle
+            )
 
         val intentFilter: Array<IntentFilter> =
             arrayOf(
@@ -139,6 +164,7 @@ class NFCPlugin : Plugin() {
         )
     }
 
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
     private fun handleWriteTag(intent: Intent) {
         val records = recordsBuffer?.toList<JSONObject>()
         if(records != null) {
@@ -284,32 +310,127 @@ class NFCPlugin : Plugin() {
         }
     }
 
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
     private fun handleReadTag(intent: Intent) {
         val jsResponse = JSObject()
-
         val ndefMessages = JSArray()
+
+        // Get tag information regardless of NDEF content
+        val tag: Tag? = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG, Tag::class.java)
+        val tagInfo = tag?.let { extractTagInfo(it) }
+
+        // Try to obtain raw NDEF messages first (ACTION_NDEF_DISCOVERED path)
         val receivedMessages = intent.getParcelableArrayExtra(
             EXTRA_NDEF_MESSAGES,
             NdefMessage::class.java
         )
 
-        receivedMessages?.also { rawMessages ->
-            for (message in rawMessages) {
-                val ndefRecords = JSArray()
-                for (record in message.records) {
-                    val rec = JSObject()
-                    rec.put("type", String(record.type, Charsets.UTF_8))
-                    rec.put("payload", Base64.getEncoder().encodeToString(record.payload))
-                    ndefRecords.put(rec)
+        if (receivedMessages != null && receivedMessages.isNotEmpty()) {
+            // Standard NDEF-discovered path
+            for (message in receivedMessages) {
+                ndefMessages.put(ndefMessageToJS(message))
+            }
+        } else {
+            // For ACTION_TAG_DISCOVERED or ACTION_TECH_DISCOVERED we may still have an NDEF tag.
+            var added = false
+            if (tag != null) {
+                val ndef = Ndef.get(tag)
+                if (ndef != null) {
+                    try {
+                        ndef.connect()
+                        // Prefer cached message to avoid additional IO if available
+                        val message: NdefMessage? = ndef.cachedNdefMessage ?: try {
+                            ndef.ndefMessage
+                        } catch (e: Exception) { null }
+                        if (message != null) {
+                            ndefMessages.put(ndefMessageToJS(message))
+                            added = true
+                        }
+                    } catch (e: Exception) {
+                        Log.w("NFC", "Failed to read NDEF message from TECH/TAG intent: ${e.message}")
+                    } finally {
+                        try { ndef.close() } catch (_: Exception) {}
+                    }
                 }
 
-                val msg = JSObject()
-                msg.put("records", ndefRecords)
-                ndefMessages.put(msg)
+                // If no NDEF message found, fallback to tag ID (legacy behavior)
+                if (!added) {
+                    val tagId = intent.getByteArrayExtra(NfcAdapter.EXTRA_ID) ?: tag.id
+                    val result = if (tagId != null) byteArrayToHexString(tagId) else ""
+                    val rec = JSObject()
+                    rec.put("type", "ID")
+                    rec.put("payload", Base64.getEncoder().encodeToString(result.toByteArray()))
+                    val ndefRecords = JSArray().apply { put(rec) }
+                    val msg = JSObject().apply { put("records", ndefRecords) }
+                    ndefMessages.put(msg)
+                }
             }
         }
 
         jsResponse.put("messages", ndefMessages)
+        // Always include tag information if available
+        if (tagInfo != null) {
+            jsResponse.put("tagInfo", tagInfo)
+        }
         this.notifyListeners("nfcTag", jsResponse)
     }
+
+    private fun extractTagInfo(tag: Tag): JSObject {
+        val tagInfo = JSObject()
+        
+        // Always include UID
+        val uid = byteArrayToHexString(tag.id)
+        tagInfo.put("uid", uid)
+        
+        // Include technology types
+        val techTypes = JSArray()
+        for (tech in tag.techList) {
+            techTypes.put(tech)
+        }
+        tagInfo.put("techTypes", techTypes)
+        
+        // Try to get NDEF-specific information
+        val ndef = Ndef.get(tag)
+        if (ndef != null) {
+            try {
+                ndef.connect()
+                tagInfo.put("maxSize", ndef.maxSize)
+                tagInfo.put("isWritable", ndef.isWritable)
+                tagInfo.put("type", ndef.type)
+            } catch (e: Exception) {
+                Log.w("NFC", "Failed to read NDEF tag info: ${e.message}")
+            } finally {
+                try { ndef.close() } catch (_: Exception) {}
+            }
+        }
+        
+        return tagInfo
+    }
+
+    private fun ndefMessageToJS(message: NdefMessage): JSObject {
+        val ndefRecords = JSArray()
+        for (record in message.records) {
+            val rec = JSObject()
+            rec.put("type", String(record.type, Charsets.UTF_8))
+            rec.put("payload", Base64.getEncoder().encodeToString(record.payload))
+            ndefRecords.put(rec)
+        }
+        val msg = JSObject()
+        msg.put("records", ndefRecords)
+        return msg
+    }
+
+    private fun byteArrayToHexString(inarray: ByteArray): String {
+        val hex = arrayOf("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F")
+        var out = ""
+
+        for (j in inarray.indices) {
+            val `in` = inarray[j].toInt() and 0xff
+            val i1 = (`in` shr 4) and 0x0f
+            out += hex[i1]
+            val i2 = `in` and 0x0f
+            out += hex[i2]
+        }
+        return out
+    }
 }