react-native-nfc-manager 3.11.3 → 3.13.0

package/README.md

@@ -32,9 +32,9 @@ For Android, it should be properly auto-linked, so you don't need to do anything
 
 Please see [here](setup.md)
 
-### Android 12
+### **Android 12**
 
-To support Android 12, you will need to update `compileSdkVersion` in your `android/build.gradle` like this:
+We start to support Android 12 from `v3.11.1`, and you will need to update `compileSdkVersion` to `31`, otherwise the build will fail:
 
 ```
 buildscript {
@@ -47,17 +47,15 @@ buildscript {
 }
 ```
 
-The reason for this is because Android puts new limitation on [PendingIntent](https://developer.android.com/reference/android/app/PendingIntent#FLAG_MUTABLE):
+The reason for this is because Android puts new limitation on [PendingIntent](https://developer.android.com/reference/android/app/PendingIntent#FLAG_MUTABLE) which says `Starting with Build.VERSION_CODES.S, it will be required to explicitly specify the mutability of PendingIntents`
 
-> Starting with Build.VERSION_CODES.S, it will be required to explicitly specify the mutability of PendingIntents
+> The original issue is [here](https://github.com/revtel/react-native-nfc-manager/issues/469)
 
-The original issue is [here](https://github.com/revtel/react-native-nfc-manager/issues/469)
+BTW, if you don't care about **Android 12** for now, you can use **`v3.11.0`** as a short term solution.
 
-## Also See
+### **[Demo App] NfcOpenReWriter**
 
-### [Demo App] NfcOpenReWriter
-
-We have a full featured NFC utility app available for download.
+We have a full featured NFC utility app using this library available for download.
 
 <a href='https://apps.apple.com/tw/app/nfc-rewriter/id1551243964' target='_blank'>
 <img alt="react-native-nfc-rewriter" src="./images/Apple-App-Store-Icon.png" width="250">
@@ -71,19 +69,73 @@ We have a full featured NFC utility app available for download.
 
 It also open sourced in this repo: [React Native NFC ReWriter App](https://github.com/revtel/react-native-nfc-rewriter)
 
-## Basic Usage
+## Usage
 
-If all you want to do is to read `NDEF` data, you can use this example:
+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:
 
 ```javascript
-import NfcManager, {NfcEvents} from 'react-native-nfc-manager';
+import React from 'react';
+import {View, Text, TouchableOpacity, StyleSheet} from 'react-native';
+import NfcManager, {NfcTech} from 'react-native-nfc-manager';
 
 // Pre-step, call this before any NFC operations
-async function initNfc() {
-  await NfcManager.start();
+NfcManager.start();
+
+function App() {
+  async function readNdef() {
+    try {
+      // register for the NFC tag with NDEF in it
+      await NfcManager.requestTechnology(NfcTech.Ndef);
+      // the resolved tag object will contain `ndefMessage` property
+      const tag = await NfcManager.getTag();
+      console.warn('Tag found', tag);
+    } catch (ex) {
+      console.warn('Oops!', ex);
+    } finally {
+      // stop the nfc scanning
+      NfcManager.cancelTechnologyRequest();
+    }
+  }
+
+  return (
+    <View style={styles.wrapper}>
+      <TouchableOpacity onPress={readNdef}>
+        <Text>Scan a Tag</Text>
+      </TouchableOpacity>
+    </View>
+  );
 }
 
-function readNdef() {
+const styles = StyleSheet.create({
+  wrapper: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});
+
+export default App;
+```
+
+Pleaes notice when running above codes, iOS and Android has different behaviors:
+
+- iOS will pop up a system scanning UI
+- Android provides **NO** system scanning UI
+
+Regarding the system scannning UI, both platforms should be able to scan your NFC tags succesfully and print out its content.
+
+### Old Style (registerTagEvent) To Scan NFC Tags
+
+There's an alterntaive style to scan NFC tags through `NfcManager.registerTagEvent`, like this:
+
+```javascript
+import NfcManager, {NfcTech} from 'react-native-nfc-manager';
+
+// The following function resolves to a NFC Tag object using old event listener approach.
+// You can call it like this:
+//    `const nfcTag = await listenToNfcEventOnce()`
+
+function listenToNfcEventOnce() {
   const cleanUp = () => {
     NfcManager.setEventListener(NfcEvents.DiscoverTag, null);
     NfcManager.setEventListener(NfcEvents.SessionClosed, null);
@@ -95,8 +147,7 @@ function readNdef() {
     NfcManager.setEventListener(NfcEvents.DiscoverTag, (tag) => {
       tagFound = tag;
       resolve(tagFound);
-      NfcManager.setAlertMessageIOS('NDEF tag found');
-      NfcManager.unregisterTagEvent().catch(() => 0);
+      NfcManager.unregisterTagEvent();
     });
 
     NfcManager.setEventListener(NfcEvents.SessionClosed, () => {
@@ -111,120 +162,102 @@ function readNdef() {
 }
 ```
 
-Anything else, ex: write NDEF, send custom command, please read next section.
+As you can see, the above approach is more verbose and hard-to-read, so we recommend using `NfcManager.requestTechnology` instead of `NfcManager.registerTagEvent` in your application.
+
+## Advanced Usage Concept
+
+In higher level, there're 4 steps to use this library:
+
+1. request your particular NFC technologies through `NfcManager.requestTechnology`, for example:
+
+   - `Ndef`
+   - `NfcA`
+   - `NfcB` (Android-only)
+   - `NfcF` (Android-only)
+   - `NfcV` (Android-only)
+   - `IsoDep`
+   - `MifareClassic` (Android-only)
+   - `MifareUltralight` (Android-only)
+   - `MifareIOS` (ios-only)
+   - `Iso15693IOS` (ios-only)
+   - `FelicaIOS` (ios-only)
+
+2. select the proper NFC technology handler, which is implemented as getter in main `NfcManager` object, for example:
 
-## Advanced Usage
+   - `ndefHandler` (for `Ndef` tech)
+   - `nfcAHandler` (for `NfcA` tech)
+   - `isoDepHandler` (for `IsoDep` tech)
+   - `iso15693HandlerIOS` (for `Iso15693IOS` tech)
+   - `mifareClassicHandlerAndroid` (for `mifareClassic` tech)
+   - `mifareUltralightHandlerAndroid` (for `mifareUltralight` tech)
+   - ... and so on
 
-In high level, there're 3 steps to perform advanced NFC operations:
+3. call specific methods on the NFC technology handler (for example `NfcManager.ndefHandler.writeNdefMessage`). To view all available methods for some tech handler, check out the [API List](index.d.ts)
 
-1. request your specific NFC technology
-2. select the proper NFC technology handler, which is implemented as getter in main `NfcManager` object, including:
-   - ndefHandler
-   - nfcAHandler
-   - isoDepHandler
-   - iso15693HandlerIOS
-   - mifareClassicHandlerAndroid
-   - mifareUltralightHandlerAndroid
-3. call specific methods on the NFC technology handler
-4. clean up your tech registration
+4. clean up your tech registration through `NfcManager.cancelTechnology`
+
+## Advanced Usage Example: NDEF-Writing
 
 For example, here's an example to write NDEF:
 
 ```javascript
 import NfcManager, {NfcTech, Ndef} from 'react-native-nfc-manager';
 
-// Pre-step, call this before any NFC operations
-async function initNfc() {
-  await NfcManager.start();
-}
-
 async function writeNdef({type, value}) {
   let result = false;
 
   try {
-    // Step 1
-    await NfcManager.requestTechnology(NfcTech.Ndef, {
-      alertMessage: 'Ready to write some NDEF',
-    });
+    // STEP 1
+    await NfcManager.requestTechnology(NfcTech.Ndef);
 
     const bytes = Ndef.encodeMessage([Ndef.textRecord('Hello NFC')]);
 
     if (bytes) {
-      await NfcManager.ndefHandler // Step2
-        .writeNdefMessage(bytes); // Step3
-
-      if (Platform.OS === 'ios') {
-        await NfcManager.setAlertMessageIOS('Successfully write NDEF');
-      }
+      await NfcManager.ndefHandler // STEP 2
+        .writeNdefMessage(bytes); // STEP 3
+      result = true;
     }
-
-    result = true;
   } catch (ex) {
     console.warn(ex);
+  } finally {
+    // STEP 4
+    NfcManager.cancelTechnologyRequest();
   }
 
-  // Step 4
-  NfcManager.cancelTechnologyRequest().catch(() => 0);
   return result;
 }
 ```
 
-## Advanced: Mifare Ultralight usage
+## Advanced Usage Example: Mifare Ultralight
 
-Here's an example to read a Mifare Ultralight tag:
+Here's another example to read a Mifare Ultralight tag:
 
 ```javascript
-import NfcManager, {NfcTech} from 'react-native-nfc-manager';
-
-// Pre-step, call this before any NFC operations
-async function initNfc() {
-  await NfcManager.start();
-}
-
 async function readMifare() {
+  let mifarePages = [];
+
   try {
-    // 0. Request Mifare technology
+    // STEP 1
     let reqMifare = await NfcManager.requestTechnology(
       NfcTech.MifareUltralight,
     );
-    if (reqMifare !== 'MifareUltralight') {
-      throw new Error(
-        '[NFC Read] [ERR] Mifare technology could not be requested',
-      );
-    }
-
-    // 1. Get NFC Tag information
-    const nfcTag = await NfcManager.getTag();
-    console.log('[NFC Read] [INFO] Tag: ', nfcTag);
 
-    // 2. Read pages
     const readLength = 60;
-    let mifarePages = [];
     const mifarePagesRead = await Promise.all(
       [...Array(readLength).keys()].map(async (_, i) => {
-        const pageOffset = i * 4; // 4 Pages are read at once, so offset should be in steps with length 4
-        let pages = await NfcManager.mifareUltralightHandlerAndroid.mifareUltralightReadPages(
-          pageOffset,
-        );
+        const pages = await NfcManager.mifareUltralightHandlerAndroid // STEP 2
+          .mifareUltralightReadPages(i * 4); // STEP 3
         mifarePages.push(pages);
-        console.log(`[NFC Read] [INFO] Mifare Page: ${pageOffset}`, pages);
-        //await wait(500); // If Mifare Chip is to slow
       }),
     );
-
-    // 3. Success
-    console.log('[NFC Read] [INFO] Success reading Mifare');
-
-    // 4. Cleanup
-    _cleanup();
   } catch (ex) {
-    console.warn('[NFC Read] [ERR] Failed Reading Mifare: ', ex);
-    _cleanup();
+    console.warn(ex);
+  } finally {
+    // STEP 4
+    NfcManager.cancelTechnologyRequest();
   }
-}
 
-function _cleanup() {
-  NfcManager.cancelTechnologyRequest().catch(() => 0);
+  return mifarePages;
 }
 ```
 
@@ -254,6 +287,8 @@ After installing this npm package, add the [config plugin](https://docs.expo.io/
 
 Next, rebuild your app as described in the ["Adding custom native code"](https://docs.expo.io/workflow/customizing/) guide.
 
+> Notice: This Config Plugin will ensure the minimum Android SDK version is 31.
+
 #### Props
 
 The plugin provides props for extra customization. Every time you change the props or plugins, you'll need to rebuild (and `prebuild`) the native app. If no extra properties are added, defaults will be used.
@@ -280,4 +315,3 @@ The plugin provides props for extra customization. Every time you change the pro
   }
 }
 ```
-

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

@@ -266,6 +266,36 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
         }
     }
 
+    @ReactMethod
+    public void formatNdef(ReadableArray rnArray, ReadableMap options, Callback callback) {
+        boolean readOnly = options.getBoolean("readOnly");
+
+        synchronized(this) {
+            if (techRequest != null) {
+                try {
+                    NdefFormatable ndef = (NdefFormatable)techRequest.getTechHandle();
+                    if (ndef == null) {
+                        callback.invoke(ERR_API_NOT_SUPPORT);
+                    } else {
+                        byte[] bytes = rnArrayToBytes(rnArray);
+                        NdefMessage msg = new NdefMessage(bytes);
+                        if (readOnly) {
+                            ndef.formatReadOnly(msg);
+                        } else {
+                            ndef.format(msg);
+                        }
+                        callback.invoke();
+                    }
+                } catch (Exception ex) {
+                    Log.d(LOG_TAG, ex.toString());
+                    callback.invoke(ex.toString());
+                }
+            } else {
+                callback.invoke(ERR_NO_TECH_REQ);
+            }
+        }
+    }
+
     private void mifareClassicAuthenticate(char type, int sector, ReadableArray key, Callback callback) {
         if (techRequest != null) {
             try {
@@ -987,6 +1017,16 @@ class NfcManager extends ReactContextBaseJavaModule implements ActivityEventList
         callback.invoke(null, isForegroundEnabled);
     }
 
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep: Required for RN built in Event Emitter Calls.
+    }
+
     @Override
     public void onHostResume() {
         Log.d(LOG_TAG, "onResume");

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

@@ -11,6 +11,7 @@ import android.nfc.tech.NfcV;
 import android.nfc.tech.NfcF;
 import android.nfc.tech.MifareClassic;
 import android.nfc.tech.MifareUltralight;
+import android.nfc.tech.NdefFormatable;
 import android.nfc.tech.IsoDep;
 import android.util.Log;
 import com.facebook.react.bridge.*;
@@ -76,6 +77,8 @@ class TagTechnologyRequest {
                 mTech = MifareClassic.get(tag);
             } else if (techType.equals("MifareUltralight")) {
                 mTech = MifareUltralight.get(tag);
+            } else if (techType.equals("NdefFormatable")) {
+                mTech = NdefFormatable.get(tag);
             }
 
             if (mTech == null) {

package/app.plugin.js

@@ -85,6 +85,14 @@ function withNfc(config, props = {}) {
   config = withIosNfcEntitlement(config);
   config = withIosNfcSelectIdentifiers(config, {selectIdentifiers});
   config = withIosNfcSystemCodes(config, {systemCodes});
+
+  // We start to support Android 12 from v3.11.1, and you will need to update compileSdkVersion to 31,
+  // otherwise the build will fail:
+  config = AndroidConfig.Version.withBuildScriptExtMinimumVersion(config, {
+    name: 'compileSdkVersion',
+    minVersion: 31,
+  });
+
   if (nfcPermission !== false) {
     config = withIosPermission(config, props);
     config = AndroidConfig.Permissions.withPermissions(config, [

package/index.d.ts

@@ -22,6 +22,7 @@ declare module 'react-native-nfc-manager' {
     MifareIOS = 'mifare',
     Iso15693IOS = 'iso15693',
     FelicaIOS = 'felica',
+    NdefFormatable = 'NdefFormatable',
   }
 
   export enum NdefStatus {
@@ -47,6 +48,17 @@ declare module 'react-native-nfc-manager' {
     Select = 1 << 4,
     Address = 1 << 5,
     Option = 1 << 6,
+    CommandSpecificBit8 = 1 << 7,
+  }
+
+  export enum Nfc15693ResponseFlagIOS {
+    Error = 1 << 0,
+    ResponseBufferValid = 1 << 1,
+    FinalResponse = 1 << 2,
+    ProtocolExtension = 1 << 3,
+    BlockSecurityStatusBit5 = 1 << 4,
+    BlockSecurityStatusBit6 = 1 << 5,
+    WaitTimeExtension = 1 << 6,
   }
 
   type TNF = 0x0 | 0x01 | 0x02 | 0x03 | 0x04 | 0x05 | 0x06 | 0x07;
@@ -93,6 +105,10 @@ declare module 'react-native-nfc-manager' {
     transceive: (bytes: number[]) => Promise<number[]>;
   }
 
+  interface NfcVHandler {
+    transceive: (bytes: number[]) => Promise<number[]>;
+  }
+
   interface IsoDepHandler {
     transceive: (bytes: number[]) => Promise<number[]>;
   }
@@ -121,6 +137,10 @@ declare module 'react-native-nfc-manager' {
     ) => Promise<void>;
   }
 
+  interface NdefFormatableHandlerAndroid {
+    formatNdef: (bytes: number[], options?: { readOnly: boolean }) => Promise<void>;
+  }
+
   /** [iOS ONLY] */
   interface Iso15693HandlerIOS {
     getSystemInfo: (
@@ -159,6 +179,11 @@ declare module 'react-native-nfc-manager' {
       customCommandCode: number;
       customRequestParameters: number[];
     }) => Promise<number[]>;
+    sendRequest: (params: {
+      flags: number;
+      commandCode: number;
+      data: number[];
+    }) => Promise<[number, number[]]>;
     extendedReadSingleBlock: (params: {
       flags: number;
       blockNumber: number;
@@ -201,6 +226,7 @@ declare module 'react-native-nfc-manager' {
      */
     ndefHandler: NdefHandler;
     nfcAHandler: NfcAHandler;
+    nfcVHandler: NfcVHandler;
     isoDepHandler: IsoDepHandler;
 
     /**
@@ -236,6 +262,7 @@ declare module 'react-native-nfc-manager' {
     setTimeout(timeout: number): Promise<void>;
     mifareClassicHandlerAndroid: MifareClassicHandlerAndroid;
     mifareUltralightHandlerAndroid: MifareUltralightHandlerAndroid;
+    ndefFormatableHandlerAndroid: NdefFormatableHandlerAndroid;
   }
 
   const nfcManager: NfcManager;

package/ios/NfcManager.m

@@ -1174,6 +1174,39 @@ RCT_EXPORT_METHOD(iso15693_customCommand:(NSDictionary *)options callback:(nonnu
     }
 }
 
+RCT_EXPORT_METHOD(iso15693_sendRequest:(NSDictionary *)options callback:(nonnull RCTResponseSenderBlock)callback)
+{
+    if (@available(iOS 14.0, *)) {
+        if (!tagSession || !tagSession.connectedTag) {
+            callback(@[@"Not connected", [NSNull null]]);
+            return;
+        }
+        
+        id<NFCISO15693Tag> tag = [tagSession.connectedTag asNFCISO15693Tag];
+        if (!tag) {
+            callback(@[@"incorrect tag type", [NSNull null]]);
+            return;
+        }
+        
+        NSInteger flags = [[options objectForKey:@"flags"] integerValue];
+        NSInteger commandCode = [[options objectForKey:@"commandCode"] integerValue];
+        NSData *data = [self arrayToData:[options mutableArrayValueForKey:@"data"]];
+        
+        [tag sendRequestWithFlag:flags
+                     commandCode:commandCode
+                            data:data
+               completionHandler:^(NFCISO15693ResponseFlag responseFlag, NSData *resp, NSError *error) {
+            if (error) {
+                callback(@[getErrorMessage(error), [NSNull null]]);
+                return;
+            }
+            callback(@[[NSNull null], [NSNumber numberWithLong:responseFlag], [NfcManager dataToArray:resp]]);
+        }];
+    } else {
+        callback(@[@"Not support in this device", [NSNull null]]);
+    }
+}
+
 RCT_EXPORT_METHOD(iso15693_extendedReadSingleBlock:(NSDictionary *)options callback:(nonnull RCTResponseSenderBlock)callback)
 {
     if (@available(iOS 13.0, *)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nfc-manager",
-  "version": "3.11.3",
+  "version": "3.13.0",
   "description": "A NFC module for react native.",
   "main": "src/index.js",
   "repository": {
@@ -62,7 +62,7 @@
     "typescript": "^4.1.3"
   },
   "dependencies": {
-    "@expo/config-plugins": "^3.0.6"
+    "@expo/config-plugins": "^4.0.16"
   },
   "scripts": {
     "lint": "eslint .",

package/src/NfcManager.js

@@ -7,6 +7,7 @@ import {
 } from './NativeNfcManager';
 import {NdefHandler, NdefStatus} from './NfcTech/NdefHandler';
 import {NfcAHandler} from './NfcTech/NfcAHandler';
+import {NfcVHandler} from './NfcTech/NfcVHandler';
 import {IsoDepHandler} from './NfcTech/IsoDepHandler';
 import {
   handleNativeException,
@@ -33,6 +34,7 @@ const NfcTech = {
   MifareIOS: 'mifare',
   Iso15693IOS: 'iso15693',
   FelicaIOS: 'felica',
+  NdefFormatable: 'NdefFormatable',
 };
 
 const DEFAULT_REGISTER_TAG_EVENT_OPTIONS = {
@@ -124,6 +126,13 @@ class NfcManagerBase {
     return this._nfcAHandler;
   }
 
+  get nfcVHandler() {
+    if (!this._nfcVHandler) {
+      this._nfcVHandler = new NfcVHandler();
+    }
+    return this._nfcVHandler;
+  }
+
   get isoDepHandler() {
     if (!this._isoDepHandler) {
       this._isoDepHandler = new IsoDepHandler();

package/src/NfcManagerAndroid.js

@@ -2,6 +2,7 @@ import {callNative} from './NativeNfcManager';
 import {NfcManagerBase} from './NfcManager';
 import {MifareClassicHandlerAndroid} from './NfcTech/MifareClassicHandlerAndroid';
 import {MifareUltralightHandlerAndroid} from './NfcTech/MifareUltralightHandlerAndroid';
+import {NdefFormatableHandlerAndroid} from './NfcTech/NdefFormatableHandlerAndroid';
 import {handleNativeException, buildNfcExceptionAndroid} from './NfcError';
 
 const NfcAdapter = {
@@ -111,6 +112,16 @@ class NfcManagerAndroid extends NfcManagerBase {
     return this._mifareUltralightHandlerAndroid;
   }
 
+  // -------------------------------------
+  // (android) NfcTech.NdefFormatable API
+  // -------------------------------------
+  get ndefFormatableHandlerAndroid() {
+    if (!this._ndefFormatableHandlerAndroid) {
+      this._ndefFormatableHandlerAndroid = new NdefFormatableHandlerAndroid(this);
+    }
+    return this._ndefFormatableHandlerAndroid;
+  }
+
   // -------------------------------------
   // Android private
   // -------------------------------------

package/src/NfcManagerIOS.js

@@ -8,6 +8,7 @@ import {
 } from './NfcManager';
 import {
   Nfc15693RequestFlagIOS,
+  Nfc15693ResponseFlagIOS,
   Iso15693HandlerIOS,
 } from './NfcTech/Iso15693HandlerIOS';
 import {handleNativeException} from './NfcError';
@@ -30,6 +31,8 @@ class NfcManagerIOS extends NfcManagerBase {
     for (const t of tech) {
       if (t === NfcTech.NfcA) {
         techList.push(NfcTech.MifareIOS);
+      } else if (t === NfcTech.NfcV) {
+        techList.push(NfcTech.Iso15693IOS);
       } else {
         techList.push(t);
       }
@@ -145,4 +148,4 @@ class NfcManagerIOS extends NfcManagerBase {
   }
 }
 
-export {NfcManagerIOS, Nfc15693RequestFlagIOS};
+export {NfcManagerIOS, Nfc15693RequestFlagIOS, Nfc15693ResponseFlagIOS};

package/src/NfcTech/Iso15693HandlerIOS.js

@@ -8,6 +8,17 @@ const Nfc15693RequestFlagIOS = {
   Select: 1 << 4,
   Address: 1 << 5,
   Option: 1 << 6,
+  CommandSpecificBit8: 1 << 7,
+};
+
+const Nfc15693ResponseFlagIOS = {
+  Error: 1 << 0,
+  ResponseBufferValid: 1 << 1,
+  FinalResponse: 1 << 2,
+  ProtocolExtension: 1 << 3,
+  BlockSecurityStatusBit5: 1 << 4,
+  BlockSecurityStatusBit6: 1 << 5,
+  WaitTimeExtension: 1 << 6
 };
 
 class Iso15693HandlerIOS {
@@ -87,6 +98,15 @@ class Iso15693HandlerIOS {
     );
   }
 
+  // https://developer.apple.com/documentation/corenfc/nfciso15693tag/3551933-sendrequestwithflag?language=objc
+  sendRequest({flags, commandCode, data}) {
+    return handleNativeException(
+      callNative('iso15693_sendRequest', [
+        {flags, commandCode, data},
+      ]),
+    );
+  }
+
   extendedReadSingleBlock({flags, blockNumber}) {
     return handleNativeException(
       callNative('iso15693_extendedReadSingleBlock', [{flags, blockNumber}]),
@@ -108,4 +128,4 @@ class Iso15693HandlerIOS {
   }
 }
 
-export {Nfc15693RequestFlagIOS, Iso15693HandlerIOS};
+export {Nfc15693RequestFlagIOS, Nfc15693ResponseFlagIOS, Iso15693HandlerIOS};

package/src/NfcTech/NdefFormatableHandlerAndroid.js

@@ -0,0 +1,16 @@
+import {callNative} from '../NativeNfcManager';
+import {handleNativeException} from '../NfcError';
+
+class NdefFormatableHandlerAndroid {
+  async formatNdef(bytes, options={}) {
+    const defaultOptions = { readOnly: false };
+    return handleNativeException(
+        callNative('formatNdef', [
+            bytes, 
+            {...defaultOptions, ...options}
+        ])
+    );
+  }
+}
+
+export {NdefFormatableHandlerAndroid};

package/src/NfcTech/NfcVHandler.js

@@ -0,0 +1,39 @@
+import {Platform} from 'react-native';
+import {callNative, NativeNfcManager} from '../NativeNfcManager';
+import {handleNativeException} from '../NfcError';
+
+class NfcVHandler {
+  async transceive(bytes) {
+    if (!Array.isArray(bytes)) {
+      throw new Error(
+        'IsoDepHandler.transceive only takes input as a byte array',
+      );
+    }
+
+    if (Platform.OS === 'ios') {
+      const [flags, commandCode, ...data] = bytes;
+      return handleNativeException(
+        new Promise((resolve, reject) => {
+          NativeNfcManager.iso15693_sendRequest(
+            {
+                flags,
+                commandCode,
+                data,
+            },
+            (err, responseFlag, response) => {
+              if (err) {
+                reject(err);
+              } else {
+                resolve([responseFlag, ...response]);
+              }
+            },
+          );
+        }),
+      );
+    }
+
+    return handleNativeException(callNative('transceive', [bytes]));
+  }
+}
+
+export {NfcVHandler};

package/src/index.js

@@ -4,6 +4,7 @@ import {NfcEvents, NfcTech, NdefStatus} from './NfcManager';
 import {NfcAdapter, NfcManagerAndroid} from './NfcManagerAndroid';
 import {
   Nfc15693RequestFlagIOS,
+  Nfc15693ResponseFlagIOS,
   NfcManagerIOS,
 } from './NfcManagerIOS';
 import * as NfcError from './NfcError';
@@ -26,6 +27,7 @@ export {
   NfcEvents,
   NfcAdapter,
   Nfc15693RequestFlagIOS,
+  Nfc15693ResponseFlagIOS,
   Ndef,
   NdefStatus,
   NfcError,