react-native-nfc-manager 3.13.2 → 3.13.5

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) {
@@ -941,8 +1034,12 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
             return;
         }
 
-        currentActivity.startActivity(new Intent(Settings.ACTION_NFC_SETTINGS));
-        callback.invoke();
+        try {
+            currentActivity.startActivity(new Intent(Settings.ACTION_NFC_SETTINGS));
+            callback.invoke(null, true);
+        } catch (Exception ex) {
+            callback.invoke(null, false);
+        }
     }
 
     @ReactMethod

package/index.d.ts

@@ -123,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 {
@@ -256,7 +271,7 @@ declare module 'react-native-nfc-manager' {
     /**
      * Android only
      */
-    goToNfcSetting(): Promise<any>;
+    goToNfcSetting(): Promise<boolean>;
     getLaunchTagEvent(): Promise<TagEvent | null>;
     transceive(bytes: number[]): Promise<number[]>;
     getMaxTransceiveLength(): Promise<number>;

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.2",
+  "version": "3.13.5",
   "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/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};