react-native-nfc-manager 3.13.1 → 3.13.4

package/README.md

@@ -69,6 +69,12 @@ We have a full featured NFC utility app using this library available for downloa
 
 It also open sourced in this repo: [React Native NFC ReWriter App](https://github.com/revtel/react-native-nfc-rewriter)
 
+## Learn
+
+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)
+
 ## Usage
 
 The simplest (and most common) use case for this library is to read `NFC` tags containing `NDEF`, which can be achieved via the following codes:

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

@@ -536,6 +536,99 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
         }
     }
 
+    @ReactMethod
+    public void mifareClassicIncrementBlock(int blockIndex, int value, Callback callback) {
+        synchronized(this) {
+            if (techRequest != null) {
+                try {
+                    MifareClassic mifareTag = (MifareClassic) techRequest.getTechHandle();
+                    if (mifareTag == null || mifareTag.getType() == MifareClassic.TYPE_UNKNOWN) {
+                        // Not a mifare card, fail
+                        callback.invoke("mifareClassicIncrementBlock fail: TYPE_UNKNOWN");
+                        return;
+                    } else if (blockIndex >= mifareTag.getBlockCount()) {
+                        // Check if in range
+                        String msg = String.format("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.toString());
+                }
+            } else {
+                callback.invoke(ERR_NO_TECH_REQ);
+            }
+        }
+    }
+
+    @ReactMethod
+    public void mifareClassicDecrementBlock(int blockIndex, int value, Callback callback) {
+        synchronized(this) {
+            if (techRequest != null) {
+                try {
+                    MifareClassic mifareTag = (MifareClassic) techRequest.getTechHandle();
+                    if (mifareTag == null || mifareTag.getType() == MifareClassic.TYPE_UNKNOWN) {
+                        // Not a mifare card, fail
+                        callback.invoke("mifareClassicDecrementBlock fail: TYPE_UNKNOWN");
+                        return;
+                    } else if (blockIndex >= mifareTag.getBlockCount()) {
+                        // Check if in range
+                        String msg = String.format("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.toString());
+                }
+            } else {
+                callback.invoke(ERR_NO_TECH_REQ);
+            }
+        }
+    }
+
+    @ReactMethod
+    public void mifareClassicTransferBlock(int blockIndex, Callback callback) {
+        synchronized(this) {
+            if (techRequest != null) {
+                try {
+                    MifareClassic mifareTag = (MifareClassic) techRequest.getTechHandle();
+                    if (mifareTag == null || mifareTag.getType() == MifareClassic.TYPE_UNKNOWN) {
+                        // Not a mifare card, fail
+                        callback.invoke("mifareClassicTransferBlock fail: TYPE_UNKNOWN");
+                        return;
+                    } else if (blockIndex >= mifareTag.getBlockCount()) {
+                        // Check if in range
+                        String msg = String.format("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.toString());
+                }
+            } else {
+                callback.invoke(ERR_NO_TECH_REQ);
+            }
+        }
+    }
+
     @ReactMethod
     public void mifareUltralightReadPages(int pageOffset, Callback callback) {
         synchronized(this) {
@@ -971,11 +1064,11 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
 
     @ReactMethod
     private void registerTagEvent(ReadableMap options, Callback callback) {
-        this.isReaderModeEnabled = options.getBoolean("isReaderModeEnabled");
-        this.readerModeFlags = options.getInt("readerModeFlags");
-        this.readerModeDelay = options.getInt("readerModeDelay");
+        isReaderModeEnabled = options.getBoolean("isReaderModeEnabled");
+        readerModeFlags = options.getInt("readerModeFlags");
+        readerModeDelay = options.getInt("readerModeDelay");
 
-        Log.d(LOG_TAG, "registerTag");
+        Log.d(LOG_TAG, "registerTagEvent");
         isForegroundEnabled = true;
 
         // capture all mime-based dispatch NDEF
@@ -1002,18 +1095,23 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
 
     @ReactMethod
     private void unregisterTagEvent(Callback callback) {
-        Log.d(LOG_TAG, "registerTag");
-        isForegroundEnabled = false;
-        intentFilters.clear();
+        Log.d(LOG_TAG, "unregisterTagEvent");
         if (isResumed) {
             enableDisableForegroundDispatch(false);
         }
+
+        intentFilters.clear();
+        isForegroundEnabled = false;
+        isReaderModeEnabled = false;
+        readerModeFlags = 0;
+        readerModeDelay = 0;
+
         callback.invoke();
     }
 
     @ReactMethod
     private void hasTagEventRegistration(Callback callback) {
-        Log.d(LOG_TAG, "isSessionAvailable");
+        Log.d(LOG_TAG, "isSessionAvailable: " + isForegroundEnabled);
         callback.invoke(null, isForegroundEnabled);
     }
 
@@ -1061,25 +1159,36 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
                     }
 
                     if (enable) {
-                        Log.i(LOG_TAG, "enableReaderMode");
+                        Log.i(LOG_TAG, "enableReaderMode: " + readerModeFlags);
                         Bundle readerModeExtras = new Bundle();
                         readerModeExtras.putInt(NfcAdapter.EXTRA_READER_PRESENCE_CHECK_DELAY, readerModeDelay * 1000);
                         nfcAdapter.enableReaderMode(currentActivity, new NfcAdapter.ReaderCallback() {
                             @Override
                             public void onTagDiscovered(Tag tag) {
-                                manager.tag = tag;
-                                Log.d(LOG_TAG, "readerMode onTagDiscovered");
-                                WritableMap nfcTag = null;
-                                // if the tag contains NDEF, we want to report the content
-                                if (Arrays.asList(tag.getTechList()).contains(Ndef.class.getName())) {
-                                    Ndef ndef = Ndef.get(tag);
-                                    nfcTag = ndef2React(ndef, new NdefMessage[] { ndef.getCachedNdefMessage() });
-                                } else {
-                                    nfcTag = tag2React(tag);
-                                }
-
-                                if (nfcTag != null) {
-                                    sendEvent("NfcManagerDiscoverTag", nfcTag);
+                                synchronized (this) {
+                                    manager.tag = tag;
+                                    Log.d(LOG_TAG, "readerMode onTagDiscovered");
+                                    WritableMap nfcTag = null;
+                                    // if the tag contains NDEF, we want to report the content
+                                    if (Arrays.asList(tag.getTechList()).contains(Ndef.class.getName())) {
+                                        Ndef ndef = Ndef.get(tag);
+                                        nfcTag = ndef2React(ndef, new NdefMessage[] { ndef.getCachedNdefMessage() });
+                                    } else {
+                                        nfcTag = tag2React(tag);
+                                    }
+
+                                    if (nfcTag != null) {
+                                        sendEvent("NfcManagerDiscoverTag", nfcTag);
+                                        if (techRequest!= null && !techRequest.isConnected()) {
+                                            boolean result = techRequest.connect(tag);
+                                            if (result) {
+                                                techRequest.getPendingCallback().invoke(null, techRequest.getTechType());
+                                            } else {
+                                                // this indicates that we get a NFC tag, but none of the user required tech is matched
+                                                techRequest.getPendingCallback().invoke(null, null);
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }, readerModeFlags, readerModeExtras);

package/index.d.ts

@@ -88,6 +88,7 @@ declare module 'react-native-nfc-manager' {
 
   export interface CancelTechReqOpts {
     throwOnError?: boolean = false;
+    delayMsAndroid?: number = 1000;
   }
 
   interface NdefHandler {
@@ -122,11 +123,26 @@ declare module 'react-native-nfc-manager' {
       block: ArrayLike<number>,
       simpliArr: any[],
     ) => Promise<void>;
+    mifareClassicIncrementBlock: (
+      block: ArrayLike<number>,
+      data: number,
+    ) => Promise<void>;
+    mifareClassicDecrementBlock: (
+      block: ArrayLike<number>,
+      data: number,
+    ) => Promise<void>;
+    mifareClassicTransferBlock: (
+      block: ArrayLike<number>,
+    ) => Promise<void>;
     mifareClassicGetSectorCount: () => Promise<number>;
     mifareClassicAuthenticateA: (
       sector: number,
       keys: number[],
     ) => Promise<void>;
+    mifareClassicAuthenticateB: (
+      sector: number,
+      keys: number[],
+    ) => Promise<void>;
   }
 
   interface MifareUltralightHandlerAndroid {

package/ios/NfcManager.m

@@ -286,8 +286,12 @@ RCT_EXPORT_METHOD(requestTechnology: (NSArray *)techs options: (NSDictionary *)o
 {
     if (@available(iOS 13.0, *)) {
         if (tagSession == nil && session == nil) {
+            NFCPollingOption pollFlags = NFCPollingISO14443 | NFCPollingISO15693;
+            if ([techs containsObject:@"felica"]) {
+                pollFlags |= NFCPollingISO18092;
+            }
             tagSession = [[NFCTagReaderSession alloc]
-                         initWithPollingOption:(NFCPollingISO14443 | NFCPollingISO15693) delegate:self queue:dispatch_get_main_queue()];
+                          initWithPollingOption:pollFlags delegate:self queue:dispatch_get_main_queue()];
             tagSession.alertMessage = [options objectForKey:@"alertMessage"];
             [tagSession beginSession];
             techRequestTypes = techs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nfc-manager",
-  "version": "3.13.1",
+  "version": "3.13.4",
   "description": "A NFC module for react native.",
   "main": "src/index.js",
   "repository": {

package/react-native-nfc-manager.podspec

@@ -14,5 +14,9 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m}"
   s.platform = :ios, "8.0"
 
-  s.dependency "React"
+  s.dependency "React-Core"
+
+  s.xcconfig = {
+    'OTHER_LDFLAGS': '-weak_framework CoreNFC',
+  }
 end

package/src/NfcManagerAndroid.js

@@ -15,6 +15,8 @@ const NfcAdapter = {
   FLAG_READER_NO_PLATFORM_SOUNDS: 0x100,
 };
 
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
 class NfcManagerAndroid extends NfcManagerBase {
   constructor() {
     super();
@@ -42,12 +44,13 @@ class NfcManagerAndroid extends NfcManagerBase {
   };
 
   cancelTechnologyRequest = async (options = {}) => {
-    const {throwOnError = false} = options;
+    const {throwOnError = false, delayMsAndroid = 1000} = options;
 
     try {
       await callNative('cancelTechnologyRequest');
 
-      if (!this.cleanUpTagRegistration) {
+      if (this.cleanUpTagRegistration) {
+        await delay(delayMsAndroid);
         await this.unregisterTagEvent();
         this.cleanUpTagRegistration = false;
       }

package/src/NfcTech/MifareClassicHandlerAndroid.js

@@ -67,6 +67,48 @@ class MifareClassicHandlerAndroid {
       callNative('mifareClassicWriteBlock', [block, data]),
     );
   }
+
+  async mifareClassicIncrementBlock(block, value) {
+    if (
+      !value ||
+      Number.isNaN(value)) {
+      throw new Error(
+        `value should be a number`,
+      );
+    }
+
+    return handleNativeException(
+      callNative('mifareClassicIncrementBlock', [block, value]),
+    );
+  }
+
+  async mifareClassicDecrementBlock(block, value) {
+    if (
+      !value ||
+      Number.isNaN(value)) {
+      throw new Error(
+        `value should be a number`,
+      );
+    }
+
+    return handleNativeException(
+      callNative('mifareClassicDecrementBlock', [block, value]),
+    );
+  }
+  async mifareClassicTransferBlock(block) {
+    if (
+      !block ||
+      Number.isNaN(block)) {
+      throw new Error(
+        `block should be a number`,
+      );
+    }
+
+    return handleNativeException(
+      callNative('mifareClassicTransferBlock', [block]),
+    );
+  }
+
 }
 
 export {MifareClassicHandlerAndroid};