@utapza/expo-mifare-scanner 1.0.0

package/README.md

@@ -0,0 +1,177 @@
+# @utapza/expo-mifare-scanner
+
+Expo module for scanning MIFARE Classic NFC cards on Android.
+
+## Features
+
+- ✅ Scan MIFARE Classic cards
+- ✅ Read NDEF records
+- ✅ Read raw data from multiple sectors
+- ✅ Automatic JSON extraction
+- ✅ Simple async API
+- ✅ Automatic start/stop handling
+- ✅ Timeout support
+- ✅ Comprehensive error handling
+
+## Installation
+
+```bash
+npm install @utapza/expo-mifare-scanner
+```
+
+**Note**: This module requires a development build. It does not work in Expo Go.
+
+## Usage
+
+### Simple API (Recommended)
+
+```javascript
+import { readNfcTag } from '@utapza/expo-mifare-scanner';
+
+try {
+  // Start scanning, wait for tag, automatically stop
+  const cardData = await readNfcTag({ timeout: 10000 });
+  
+  console.log('Card UID:', cardData.uid);
+  console.log('Card Data:', cardData.data); // JSON string
+  console.log('Raw Data:', cardData.rawData); // Hex string
+  console.log('Timestamp:', cardData.timestamp);
+} catch (error) {
+  console.error('Scan failed:', error.message);
+  // Possible errors:
+  // - "NFC is not enabled on this device"
+  // - "NFC scan timed out after 10000ms"
+  // - "Failed to start NFC scanning"
+}
+```
+
+### Advanced API (Event-based)
+
+If you need more control, you can use the event-based API:
+
+```javascript
+import { 
+  startScanning, 
+  stopScanning, 
+  addCardScannedListener,
+  removeCardScannedListener,
+  isNfcEnabled 
+} from '@utapza/expo-mifare-scanner';
+
+// Check if NFC is enabled
+const enabled = await isNfcEnabled();
+
+if (enabled) {
+  // Set up listener
+  const subscription = addCardScannedListener((event) => {
+    console.log('Card scanned:', event);
+    // Stop scanning when done
+    stopScanning();
+  });
+
+  // Start scanning
+  await startScanning();
+
+  // Later, clean up
+  removeCardScannedListener(subscription);
+  await stopScanning();
+}
+```
+
+## API Reference
+
+### `readNfcTag(options?)`
+
+Simplified async function that handles the entire scan lifecycle.
+
+**Parameters:**
+- `options.timeout` (number, optional): Timeout in milliseconds. Default: 30000 (30 seconds)
+
+**Returns:** `Promise<CardData>`
+
+**CardData:**
+```typescript
+{
+  uid: string;        // Card UID (hex string)
+  data: string;       // Card data (JSON string or text)
+  rawData: string;    // Raw hex data
+  timestamp: number;  // Unix timestamp
+}
+```
+
+**Throws:**
+- `Error` if NFC is not enabled
+- `Error` if scan times out
+- `Error` if scanning fails to start
+- `Error` if module is not available (Expo Go)
+
+### `isNfcEnabled()`
+
+Check if NFC is enabled on the device.
+
+**Returns:** `Promise<boolean>`
+
+### `startScanning()`
+
+Start NFC scanning (for advanced use cases).
+
+**Throws:** `Error` if module is not available
+
+### `stopScanning()`
+
+Stop NFC scanning (for advanced use cases).
+
+### `addCardScannedListener(listener)`
+
+Add event listener for card scans (for advanced use cases).
+
+**Parameters:**
+- `listener` (function): Callback that receives `{ uid, data, rawData, timestamp }`
+
+**Returns:** Subscription object with `remove()` method
+
+### `removeCardScannedListener(subscription)`
+
+Remove event listener (for advanced use cases).
+
+## Requirements
+
+- Android device with NFC support
+- Development build (does not work in Expo Go)
+- NFC enabled on device
+- Expo SDK 54+
+
+## Development Build
+
+Since this uses custom native code, you need a development build:
+
+```bash
+# Install dependencies
+npm install
+
+# Generate native code
+npx expo prebuild --platform android
+
+# Build and run
+npx expo run:android
+```
+
+## How It Works
+
+1. **NDEF Reading**: First attempts to read NDEF records (standard NFC format)
+2. **MIFARE Reading**: If NDEF fails, reads multiple sectors from MIFARE Classic card
+3. **Data Extraction**: Automatically extracts JSON from the data
+4. **Auto-cleanup**: Automatically stops scanning after tag is discovered
+
+## Error Handling
+
+The module throws descriptive errors:
+
+- `"NFC is not enabled on this device"` - User needs to enable NFC
+- `"NFC scan timed out after Xms"` - No tag detected within timeout
+- `"Failed to start NFC scanning"` - System error starting scan
+- `"ExpoMifareScanner requires a development build"` - Running in Expo Go
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,41 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+group = 'expo.modules'
+version = '1.0.0'
+
+buildscript {
+  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir, "ExpoModulesCorePlugin.gradle")
+  if (expoModulesCorePlugin.exists()) {
+    apply from: expoModulesCorePlugin
+    applyKotlinExpoModulesCorePlugin()
+  }
+}
+
+android {
+  namespace "expo.modules.mifarescanner"
+  compileSdkVersion rootProject.ext.compileSdkVersion
+
+  defaultConfig {
+    minSdkVersion rootProject.ext.minSdkVersion
+    targetSdkVersion rootProject.ext.targetSdkVersion
+  }
+
+  lintOptions {
+    abortOnError false
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_17.majorVersion
+  }
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  implementation 'com.facebook.react:react-native'
+}

package/android/src/main/java/expo/modules/mifarescanner/MifareScanner.java

@@ -0,0 +1,404 @@
+package expo.modules.mifarescanner;
+
+import android.app.Activity;
+import android.nfc.NfcAdapter;
+import android.nfc.NdefMessage;
+import android.nfc.NdefRecord;
+import android.nfc.Tag;
+import android.nfc.tech.MifareClassic;
+import android.nfc.tech.Ndef;
+import android.util.Log;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MifareScanner {
+    private static final String TAG = "MifareScanner";
+    private NfcAdapter nfcAdapter;
+    private Activity currentActivity;
+    private boolean isScanning = false;
+    private NfcAdapter.ReaderCallback readerCallback;
+    private OnCardScannedListener listener;
+
+    public interface OnCardScannedListener {
+        void onCardScanned(String uid, String data, String rawData, long timestamp);
+    }
+
+    public MifareScanner(NfcAdapter adapter, Activity activity) {
+        this.nfcAdapter = adapter;
+        this.currentActivity = activity;
+        Log.d(TAG, "MifareScanner initialized");
+    }
+
+    public void setOnCardScannedListener(OnCardScannedListener listener) {
+        this.listener = listener;
+        Log.d(TAG, "Card scanned listener set");
+    }
+
+    public boolean isNfcEnabled() {
+        boolean enabled = nfcAdapter != null && nfcAdapter.isEnabled();
+        Log.d(TAG, "NFC enabled check: " + enabled);
+        return enabled;
+    }
+
+    public void startScanning() throws Exception {
+        if (isScanning) {
+            String errorMsg = "NFC scanning is already in progress";
+            Log.e(TAG, errorMsg);
+            throw new IllegalStateException(errorMsg);
+        }
+
+        if (nfcAdapter == null) {
+            String errorMsg = "NFC adapter is not available on this device";
+            Log.e(TAG, errorMsg);
+            throw new IllegalStateException(errorMsg);
+        }
+
+        if (currentActivity == null) {
+            String errorMsg = "Activity is not available. Make sure the app is in the foreground.";
+            Log.e(TAG, errorMsg);
+            throw new IllegalStateException(errorMsg);
+        }
+
+        if (!nfcAdapter.isEnabled()) {
+            String errorMsg = "NFC is not enabled on this device. Please enable NFC in settings.";
+            Log.e(TAG, errorMsg);
+            throw new IllegalStateException(errorMsg);
+        }
+
+        isScanning = true;
+        Log.d(TAG, "Starting MIFARE scanning - Discovery");
+
+        readerCallback = new NfcAdapter.ReaderCallback() {
+            @Override
+            public void onTagDiscovered(Tag tag) {
+                Log.d(TAG, "Tag discovered - Discovery");
+                handleTag(tag);
+            }
+        };
+
+        int flags = NfcAdapter.FLAG_READER_NFC_A |
+                    NfcAdapter.FLAG_READER_NFC_B;
+
+        try {
+            nfcAdapter.enableReaderMode(currentActivity, readerCallback, flags, null);
+            Log.d(TAG, "Reader mode enabled successfully - Discovery");
+        } catch (Exception e) {
+            isScanning = false;
+            String errorMsg = "Failed to enable NFC reader mode: " + e.getMessage();
+            Log.e(TAG, errorMsg, e);
+            throw new RuntimeException(errorMsg, e);
+        }
+    }
+
+    public void stopScanning() {
+        if (!isScanning) {
+            Log.d(TAG, "Not scanning, ignoring stop request");
+            return;
+        }
+
+        if (nfcAdapter != null && currentActivity != null) {
+            try {
+                nfcAdapter.disableReaderMode(currentActivity);
+                Log.d(TAG, "Reader mode disabled");
+            } catch (Exception e) {
+                Log.e(TAG, "Error disabling reader mode: " + e.getMessage(), e);
+            }
+        }
+
+        isScanning = false;
+        readerCallback = null;
+    }
+
+    private void handleTag(Tag tag) {
+        // Get UID from tag ID (this is the actual UID, not block 0)
+        String uid = bytesToHex(tag.getId());
+        Log.d(TAG, "Processing tag with UID: " + uid + " - Discovery");
+
+        String data = "";
+        String rawData = "";
+
+        // First, try to read NDEF records (if card supports NDEF)
+        Ndef ndef = Ndef.get(tag);
+        if (ndef != null) {
+            try {
+                ndef.connect();
+                Log.d(TAG, "NDEF detected, reading NDEF records - Reading");
+                
+                NdefMessage ndefMessage = ndef.getNdefMessage();
+                if (ndefMessage != null) {
+                    NdefRecord[] records = ndefMessage.getRecords();
+                    Log.d(TAG, "Found " + records.length + " NDEF records - Reading");
+                    
+                    List<String> textRecords = new ArrayList<>();
+                    StringBuilder allData = new StringBuilder();
+                    
+                    for (NdefRecord record : records) {
+                        if (record.getTnf() == NdefRecord.TNF_WELL_KNOWN) {
+                            byte[] type = record.getType();
+                            if (java.util.Arrays.equals(type, NdefRecord.RTD_TEXT)) {
+                                String text = parseTextRecord(record);
+                                if (text != null && !text.isEmpty()) {
+                                    textRecords.add(text);
+                                    allData.append(text);
+                                    Log.d(TAG, "Found text record: " + text.substring(0, Math.min(50, text.length())) + "... - Reading");
+                                }
+                            }
+                        }
+                        
+                        // Also try to read raw payload as string (might contain JSON)
+                        byte[] payload = record.getPayload();
+                        if (payload != null && payload.length > 0) {
+                            try {
+                                String payloadStr = new String(payload, StandardCharsets.UTF_8);
+                                if (payloadStr.trim().length() > 0) {
+                                    allData.append(payloadStr);
+                                    Log.d(TAG, "Found payload data: " + payloadStr.substring(0, Math.min(50, payloadStr.length())) + "... - Reading");
+                                }
+                            } catch (Exception e) {
+                                // Ignore encoding errors
+                            }
+                        }
+                    }
+                    
+                    if (allData.length() > 0) {
+                        data = allData.toString();
+                        rawData = bytesToHex(ndefMessage.toByteArray());
+                        Log.d(TAG, "NDEF data extracted: " + data.substring(0, Math.min(100, data.length())) + "... - Success");
+                    }
+                    
+                    ndef.close();
+                } else {
+                    Log.d(TAG, "No NDEF message found - Reading");
+                    ndef.close();
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error reading NDEF: " + e.getMessage(), e);
+                try {
+                    if (ndef.isConnected()) {
+                        ndef.close();
+                    }
+                } catch (IOException closeException) {
+                    Log.e(TAG, "Error closing NDEF: " + closeException.getMessage());
+                }
+            }
+        }
+
+        // If NDEF didn't work or returned empty, try MIFARE Classic direct reading
+        if (data.isEmpty()) {
+            MifareClassic mifare = null;
+            try {
+                mifare = MifareClassic.get(tag);
+                if (mifare != null) {
+                    Log.d(TAG, "MIFARE Classic detected, type: " + mifare.getType() + " - Discovery");
+                    
+                    try {
+                        mifare.connect();
+                        Log.d(TAG, "Connected to MIFARE card - Discovery");
+
+                        int sectorCount = mifare.getSectorCount();
+                        Log.d(TAG, "Card has " + sectorCount + " sectors - Reading");
+                        
+                        StringBuilder allBlocksData = new StringBuilder();
+                        List<Byte> allBytes = new ArrayList<>();
+                        
+                        // Try to read multiple sectors
+                        for (int sectorIndex = 0; sectorIndex < Math.min(sectorCount, 16); sectorIndex++) {
+                            try {
+                                Log.d(TAG, "Attempting authentication on sector " + sectorIndex + " - Authentication");
+                                
+                                // Try default key first
+                                boolean authenticated = mifare.authenticateSectorWithKeyA(
+                                    sectorIndex,
+                                    MifareClassic.KEY_DEFAULT
+                                );
+                                
+                                if (!authenticated) {
+                                    // Try key B
+                                    authenticated = mifare.authenticateSectorWithKeyB(
+                                        sectorIndex,
+                                        MifareClassic.KEY_DEFAULT
+                                    );
+                                }
+                                
+                                if (!authenticated) {
+                                    Log.d(TAG, "Failed to authenticate sector " + sectorIndex + " - Authentication failed");
+                                    continue;
+                                }
+
+                                Log.d(TAG, "Successfully authenticated sector " + sectorIndex + " - Authentication");
+
+                                int firstBlock = mifare.sectorToBlock(sectorIndex);
+                                int blockCount = mifare.getBlockCountInSector(sectorIndex);
+                                int lastBlock = firstBlock + blockCount - 1; // Sector trailer
+                                
+                                Log.d(TAG, "Sector " + sectorIndex + ": blocks " + firstBlock + " to " + lastBlock + " (trailer at " + lastBlock + ") - Reading");
+                                
+                                // Read all blocks in this sector (except the last one which is the sector trailer)
+                                for (int blockOffset = 0; blockOffset < blockCount - 1; blockOffset++) {
+                                    int blockNumber = firstBlock + blockOffset;
+                                    try {
+                                        byte[] blockData = mifare.readBlock(blockNumber);
+                                        String blockHex = bytesToHex(blockData);
+                                        
+                                        Log.d(TAG, "Block " + blockNumber + " hex: " + blockHex.substring(0, Math.min(32, blockHex.length())) + "... - Reading");
+                                        
+                                        // Check if block is all zeros or all same byte (likely empty)
+                                        boolean isEmpty = true;
+                                        byte firstByte = blockData[0];
+                                        for (byte b : blockData) {
+                                            if (b != 0 && b != firstByte) {
+                                                isEmpty = false;
+                                                break;
+                                            }
+                                        }
+                                        
+                                        if (isEmpty) {
+                                            Log.d(TAG, "Block " + blockNumber + " appears empty, skipping - Reading");
+                                            continue;
+                                        }
+                                        
+                                        // Collect bytes
+                                        for (byte b : blockData) {
+                                            allBytes.add(b);
+                                        }
+                                        
+                                        // Try to read as string, but be more careful
+                                        String blockStr = new String(blockData, StandardCharsets.UTF_8);
+                                        // Remove null characters and control characters
+                                        blockStr = blockStr.replaceAll("[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F]", "");
+                                        
+                                        // Check if it looks like readable text (has printable ASCII or JSON-like characters)
+                                        boolean hasReadableText = false;
+                                        int printableCount = 0;
+                                        for (char c : blockStr.toCharArray()) {
+                                            if (c >= 32 && c < 127) { // Printable ASCII
+                                                printableCount++;
+                                            }
+                                        }
+                                        
+                                        // If at least 50% is printable, consider it readable
+                                        if (blockStr.length() > 0 && printableCount > blockStr.length() / 2) {
+                                            hasReadableText = true;
+                                        }
+                                        
+                                        if (hasReadableText) {
+                                            allBlocksData.append(blockStr);
+                                            Log.d(TAG, "Block " + blockNumber + " readable text: " + blockStr.substring(0, Math.min(50, blockStr.length())) + "... - Reading");
+                                        } else {
+                                            Log.d(TAG, "Block " + blockNumber + " doesn't contain readable text (printable: " + printableCount + "/" + blockStr.length() + ") - Reading");
+                                        }
+                                        
+                                    } catch (IOException e) {
+                                        Log.e(TAG, "Error reading block " + blockNumber + ": " + e.getMessage());
+                                    }
+                                }
+                                
+                            } catch (Exception e) {
+                                Log.d(TAG, "Error processing sector " + sectorIndex + ": " + e.getMessage());
+                            }
+                        }
+
+                        mifare.close();
+                        Log.d(TAG, "MIFARE connection closed");
+
+                        // Convert collected bytes to hex
+                        byte[] allBytesArray = new byte[allBytes.size()];
+                        for (int i = 0; i < allBytes.size(); i++) {
+                            allBytesArray[i] = allBytes.get(i);
+                        }
+                        rawData = bytesToHex(allBytesArray);
+                        
+                        // Use the string data if we found any
+                        if (allBlocksData.length() > 0) {
+                            data = allBlocksData.toString().trim();
+                            // Try to find JSON in the data
+                            int jsonStart = data.indexOf("{");
+                            int jsonEnd = data.lastIndexOf("}");
+                            if (jsonStart >= 0 && jsonEnd > jsonStart) {
+                                data = data.substring(jsonStart, jsonEnd + 1);
+                                Log.d(TAG, "Found JSON in data: " + data.substring(0, Math.min(100, data.length())) + "... - Success");
+                            }
+                        } else if (allBytesArray.length > 0) {
+                            // Try to parse as JSON or text
+                            String fullData = new String(allBytesArray, StandardCharsets.UTF_8);
+                            fullData = fullData.replaceAll("[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F]", "");
+                            
+                            // Look for JSON
+                            int jsonStart = fullData.indexOf("{");
+                            int jsonEnd = fullData.lastIndexOf("}");
+                            if (jsonStart >= 0 && jsonEnd > jsonStart) {
+                                data = fullData.substring(jsonStart, jsonEnd + 1);
+                                Log.d(TAG, "Found JSON in raw bytes: " + data.substring(0, Math.min(100, data.length())) + "... - Success");
+                            } else {
+                                // Just use the cleaned string
+                                data = fullData.trim();
+                            }
+                        }
+                        
+                        Log.d(TAG, "MIFARE data extracted, length: " + data.length() + ", rawData length: " + rawData.length() + " - Success");
+
+                    } catch (IOException e) {
+                        Log.e(TAG, "Error reading MIFARE card: " + e.getMessage(), e);
+                        Log.d(TAG, "Tag handling failed - Failure");
+                        try {
+                            if (mifare != null && mifare.isConnected()) {
+                                mifare.close();
+                            }
+                        } catch (IOException closeException) {
+                            Log.e(TAG, "Error closing MIFARE connection: " + closeException.getMessage());
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error handling tag: " + e.getMessage(), e);
+                Log.d(TAG, "Tag handling failed - Failure");
+            }
+        }
+
+        // Send event to JavaScript
+        long timestamp = System.currentTimeMillis();
+        Log.d(TAG, "Sending onCardScanned event - Success");
+        if (listener != null) {
+            listener.onCardScanned(uid, data, rawData, timestamp);
+        }
+    }
+
+    private String parseTextRecord(NdefRecord record) {
+        try {
+            byte[] payload = record.getPayload();
+            if (payload == null || payload.length == 0) {
+                return null;
+            }
+            
+            // First byte contains language code length and encoding
+            boolean isUtf16 = (payload[0] & 0x80) != 0;
+            int languageCodeLength = payload[0] & 0x3F;
+            java.nio.charset.Charset textEncoding = isUtf16 ? StandardCharsets.UTF_16 : StandardCharsets.UTF_8;
+            
+            // Extract text
+            if (payload.length > languageCodeLength + 1) {
+                byte[] textBytes = new byte[payload.length - languageCodeLength - 1];
+                System.arraycopy(payload, languageCodeLength + 1, textBytes, 0, textBytes.length);
+                return new String(textBytes, textEncoding);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Error parsing text record: " + e.getMessage(), e);
+        }
+        return null;
+    }
+
+    private String bytesToHex(byte[] bytes) {
+        StringBuilder result = new StringBuilder();
+        for (byte b : bytes) {
+            result.append(String.format("%02x", b));
+        }
+        return result.toString();
+    }
+
+    public void updateActivity(Activity activity) {
+        this.currentActivity = activity;
+        Log.d(TAG, "Activity updated");
+    }
+}

package/android/src/main/java/expo/modules/mifarescanner/MifareScannerModule.kt

@@ -0,0 +1,71 @@
+package expo.modules.mifarescanner
+
+import android.app.Activity
+import android.nfc.NfcAdapter
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.events.EventsDefinition
+
+class MifareScannerModule : Module() {
+  private val TAG = "MifareScannerModule"
+  private var nfcAdapter: NfcAdapter? = null
+  private var currentActivity: Activity? = null
+  private var mifareScanner: MifareScanner? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoMifareScanner")
+
+    Events("onCardScanned")
+
+    OnCreate {
+      currentActivity = appContext.currentActivity
+      nfcAdapter = NfcAdapter.getDefaultAdapter(appContext.reactContext)
+      
+      if (nfcAdapter != null && currentActivity != null) {
+        mifareScanner = MifareScanner(nfcAdapter!!, currentActivity!!)
+        mifareScanner?.setOnCardScannedListener { uid, data, rawData, timestamp ->
+          sendEvent("onCardScanned", mapOf(
+            "uid" to uid,
+            "data" to data,
+            "rawData" to rawData,
+            "timestamp" to timestamp
+          ))
+        }
+      }
+    }
+
+    OnActivityEntersForeground {
+      currentActivity = appContext.currentActivity
+      mifareScanner?.updateActivity(currentActivity)
+    }
+
+    Function("startScanning") {
+      try {
+        if (mifareScanner == null) {
+          throw Exception("MIFARE scanner is not initialized. NFC adapter may not be available.")
+        }
+        mifareScanner.startScanning()
+      } catch (e: Exception) {
+        throw Exception("Failed to start NFC scanning: ${e.message}", e)
+      }
+    }
+
+    Function("stopScanning") {
+      try {
+        mifareScanner?.stopScanning()
+      } catch (e: Exception) {
+        // Log but don't throw - stopping is best effort
+        android.util.Log.e(TAG, "Error stopping scan: ${e.message}", e)
+      }
+    }
+
+    Function("isNfcEnabled") {
+      try {
+        mifareScanner?.isNfcEnabled() ?: false
+      } catch (e: Exception) {
+        android.util.Log.e(TAG, "Error checking NFC status: ${e.message}", e)
+        false
+      }
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1,44 @@
+const { withAndroidManifest } = require('@expo/config-plugins');
+
+/**
+ * Expo config plugin for ExpoMifareScanner
+ * Adds NFC permissions and features to AndroidManifest.xml
+ */
+const withMifareScanner = (config) => {
+  return withAndroidManifest(config, async (config) => {
+    const androidManifest = config.modResults;
+    const { manifest } = androidManifest;
+
+    // Ensure permissions array exists
+    if (!manifest['uses-permission']) {
+      manifest['uses-permission'] = [];
+    }
+
+    // Add NFC permission if not already present
+    const hasNfcPermission = manifest['uses-permission'].some(
+      (perm) => perm.$['android:name'] === 'android.permission.NFC'
+    );
+    if (!hasNfcPermission) {
+      manifest['uses-permission'].push({
+        $: { 'android:name': 'android.permission.NFC' },
+      });
+    }
+
+    // Add NFC feature if not already present
+    if (!manifest['uses-feature']) {
+      manifest['uses-feature'] = [];
+    }
+    const hasNfcFeature = manifest['uses-feature'].some(
+      (feat) => feat.$['android:name'] === 'android.hardware.nfc'
+    );
+    if (!hasNfcFeature) {
+      manifest['uses-feature'].push({
+        $: { 'android:name': 'android.hardware.nfc', 'android:required': 'false' },
+      });
+    }
+
+    return config;
+  });
+};
+
+module.exports = withMifareScanner;

package/expo-module.config.json

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

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@utapza/expo-mifare-scanner",
+  "version": "1.0.0",
+  "description": "Expo module for scanning MIFARE Classic cards",
+  "main": "src/index.js",
+  "keywords": [
+    "react-native",
+    "expo",
+    "mifare",
+    "nfc",
+    "expo-module"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/utapza/expo-mifare-scanner.git"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "expo-modules-core": "*"
+  },
+  "files": [
+    "src",
+    "android/src",
+    "android/build.gradle",
+    "expo-module.config.json",
+    "app.plugin.js",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.js

@@ -0,0 +1,167 @@
+import { requireNativeModule, EventEmitter } from 'expo-modules-core';
+
+// Import the native module
+let ExpoMifareScanner;
+let isExpoGo = false;
+try {
+  ExpoMifareScanner = requireNativeModule('ExpoMifareScanner');
+} catch (e) {
+  ExpoMifareScanner = null;
+  // Check if we're running in Expo Go (which doesn't support custom native modules)
+  try {
+    const { Constants } = require('expo-constants');
+    isExpoGo = Constants.executionEnvironment === 'storeClient';
+  } catch (constantsError) {
+    // If expo-constants is not available, we can't definitively detect Expo Go
+    // But the error message will still be helpful
+    isExpoGo = false;
+  }
+  
+  // Log a warning (not an error) - this is expected in Expo Go
+  if (isExpoGo) {
+    console.warn('ExpoMifareScanner: Custom native modules are not supported in Expo Go. Please use a development build.');
+  } else {
+    console.warn('ExpoMifareScanner: Native module not found. This feature requires a development build.');
+  }
+}
+
+const emitter = new EventEmitter(ExpoMifareScanner || {});
+
+export function addCardScannedListener(listener) {
+  return emitter.addListener('onCardScanned', listener);
+}
+
+export function removeCardScannedListener(subscription) {
+  if (subscription && subscription.remove) {
+    subscription.remove();
+  }
+}
+
+export async function startScanning() {
+  if (!ExpoMifareScanner) {
+    const errorMessage = isExpoGo 
+      ? 'ExpoMifareScanner requires a development build. Custom native modules are not supported in Expo Go.'
+      : 'ExpoMifareScanner native module not available. Please rebuild the app with a development build.';
+    throw new Error(errorMessage);
+  }
+  return await ExpoMifareScanner.startScanning();
+}
+
+export async function stopScanning() {
+  if (!ExpoMifareScanner) {
+    // Silently fail if module is not available (already stopped)
+    return;
+  }
+  return await ExpoMifareScanner.stopScanning();
+}
+
+export async function isNfcEnabled() {
+  if (!ExpoMifareScanner) {
+    return false;
+  }
+  return await ExpoMifareScanner.isNfcEnabled();
+}
+
+/**
+ * Read NFC tag - simplified async API
+ * Starts scanning, waits for tag discovery, automatically stops, and returns data
+ * 
+ * @param {Object} options - Optional configuration
+ * @param {number} options.timeout - Timeout in milliseconds (default: 30000 = 30 seconds)
+ * @returns {Promise<Object>} Promise that resolves with card data or rejects with error
+ * 
+ * @example
+ * try {
+ *   const cardData = await readNfcTag({ timeout: 10000 });
+ *   console.log('Card UID:', cardData.uid);
+ *   console.log('Card Data:', cardData.data);
+ * } catch (error) {
+ *   console.error('Scan failed:', error.message);
+ * }
+ */
+export async function readNfcTag(options = {}) {
+  const { timeout = 30000 } = options;
+
+  if (!ExpoMifareScanner) {
+    const errorMessage = isExpoGo 
+      ? 'ExpoMifareScanner requires a development build. Custom native modules are not supported in Expo Go.'
+      : 'ExpoMifareScanner native module not available. Please rebuild the app with a development build.';
+    throw new Error(errorMessage);
+  }
+
+  // Check if NFC is enabled
+  const nfcEnabled = await isNfcEnabled();
+  if (!nfcEnabled) {
+    throw new Error('NFC is not enabled on this device. Please enable NFC in settings.');
+  }
+
+  return new Promise((resolve, reject) => {
+    let scanSubscription = null;
+    let timeoutId = null;
+    let isResolved = false;
+
+    // Cleanup function
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (scanSubscription) {
+        removeCardScannedListener(scanSubscription);
+        scanSubscription = null;
+      }
+      // Stop scanning (best effort, don't wait for it)
+      if (ExpoMifareScanner) {
+        ExpoMifareScanner.stopScanning().catch(() => {
+          // Ignore errors when stopping
+        });
+      }
+    };
+
+    // Set up timeout
+    timeoutId = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(new Error(`NFC scan timed out after ${timeout}ms. Please try again.`));
+      }
+    }, timeout);
+
+    // Set up event listener
+    try {
+      scanSubscription = addCardScannedListener((event) => {
+        if (isResolved) {
+          return; // Already resolved/rejected
+        }
+
+        isResolved = true;
+        cleanup();
+
+        // Format the response
+        const cardData = {
+          uid: event.uid,
+          data: event.data,
+          rawData: event.rawData,
+          timestamp: event.timestamp,
+        };
+
+        resolve(cardData);
+      });
+
+      // Start scanning
+      startScanning().catch((error) => {
+        if (!isResolved) {
+          isResolved = true;
+          cleanup();
+          reject(new Error(`Failed to start NFC scanning: ${error.message}`));
+        }
+      });
+    } catch (error) {
+      if (!isResolved) {
+        isResolved = true;
+        cleanup();
+        reject(new Error(`Failed to set up NFC scan: ${error.message}`));
+      }
+    }
+  });
+}