react-native-nfc-manager 4.0.0-beta.1 → 4.0.0-beta.11

package/index.d.ts

@@ -64,18 +64,48 @@ declare module 'react-native-nfc-manager' {
   type TNF = 0x0 | 0x01 | 0x02 | 0x03 | 0x04 | 0x05 | 0x06 | 0x07;
 
   export interface NdefRecord {
-    id?: number[];
+    /** Android returns a hex string; iOS returns a byte array. */
+    id?: number[] | string;
     tnf: TNF;
     type: number[] | string;
-    payload: any[];
+    payload: number[];
   }
 
   export interface TagEvent {
-    ndefMessage: NdefRecord[];
+    /** Absent when no NDEF message is available; do not assume an empty array. */
+    ndefMessage?: NdefRecord[];
     maxSize?: number;
     type?: string;
     techTypes?: string[];
     id?: string;
+    /** Android NDEF tag metadata. */
+    isWritable?: boolean;
+    /** Android may return null when this capability cannot be determined. */
+    canMakeReadOnly?: boolean | null;
+    /** Android NFC-A discovery metadata; bytes are unsigned (0–255). */
+    atqa?: number[];
+    /** Android NFC-A discovery metadata. */
+    sak?: number;
+    /** Android NFC-V discovery metadata; unsigned byte (0–255). */
+    dsfid?: number;
+    /** Android NFC-V discovery metadata; unsigned byte (0–255). */
+    responseFlags?: number;
+    /** Android ISO-DEP discovery metadata; bytes are unsigned (0–255). */
+    hiLayerResponse?: number[];
+    /** iOS tag technology name. */
+    tech?: string;
+    /** iOS FeliCa metadata. */
+    idm?: string;
+    systemCode?: string;
+    /** iOS ISO 7816 metadata. */
+    initialSelectedAID?: string;
+    /** iOS ISO 7816 or Android ISO-DEP discovery metadata. */
+    historicalBytes?: number[];
+    /** iOS ISO 7816 metadata. */
+    applicationData?: number[];
+    /** iOS ISO 15693 metadata. */
+    icManufacturerCode?: number;
+    icSerialNumber?: number[];
   }
 
   export interface RegisterTagEventOpts {
@@ -87,12 +117,12 @@ declare module 'react-native-nfc-manager' {
   }
 
   export interface CancelTechReqOpts {
-    throwOnError?: boolean = false;
-    delayMsAndroid?: number = 1000;
+    throwOnError?: boolean;
+    delayMsAndroid?: number;
   }
 
   interface NdefHandler {
-    writeNdefMessage: (bytes: number[] , options?: { reconnectAfterWrite: boolean }) => Promise<void>;
+    writeNdefMessage: (bytes: number[] , options?: { reconnectAfterWrite?: boolean }) => Promise<void>;
     getNdefMessage: () => Promise<TagEvent | null>;
     makeReadOnly: () => Promise<void>;
     getNdefStatus: () => Promise<{
@@ -115,38 +145,36 @@ declare module 'react-native-nfc-manager' {
   }
 
   interface MifareClassicHandlerAndroid {
-    mifareClassicSectorToBlock: (sector: number) => Promise<ArrayLike<number>>;
-    mifareClassicReadBlock: (
-      block: ArrayLike<number>,
-    ) => Promise<ArrayLike<number>>;
+    mifareClassicGetBlockCountInSector: (sector: number) => Promise<number>;
+    mifareClassicSectorToBlock: (sector: number) => Promise<number>;
+    mifareClassicReadBlock: (block: number) => Promise<number[]>;
+    mifareClassicReadSector: (sector: number) => Promise<number[]>;
     mifareClassicWriteBlock: (
-      block: ArrayLike<number>,
-      simpliArr: any[],
-    ) => Promise<void>;
+      block: number,
+      data: number[],
+    ) => Promise<boolean>;
     mifareClassicIncrementBlock: (
-      block: ArrayLike<number>,
-      data: number,
-    ) => Promise<void>;
+      block: number,
+      value: number,
+    ) => Promise<boolean>;
     mifareClassicDecrementBlock: (
-      block: ArrayLike<number>,
-      data: number,
-    ) => Promise<void>;
-    mifareClassicTransferBlock: (
-      block: ArrayLike<number>,
-    ) => Promise<void>;
+      block: number,
+      value: number,
+    ) => Promise<boolean>;
+    mifareClassicTransferBlock: (block: number) => Promise<boolean>;
     mifareClassicGetSectorCount: () => Promise<number>;
     mifareClassicAuthenticateA: (
       sector: number,
       keys: number[],
-    ) => Promise<void>;
+    ) => Promise<boolean>;
     mifareClassicAuthenticateB: (
       sector: number,
       keys: number[],
-    ) => Promise<void>;
+    ) => Promise<boolean>;
   }
 
   interface MifareUltralightHandlerAndroid {
-    mifareUltralightReadPages: (offset: number) => Promise<ArrayLike<number>>;
+    mifareUltralightReadPages: (offset: number) => Promise<number[]>;
     mifareUltralightWritePage: (
       offset: number,
       data: number[],
@@ -154,13 +182,13 @@ declare module 'react-native-nfc-manager' {
   }
 
   interface NdefFormatableHandlerAndroid {
-    formatNdef: (bytes: number[], options?: { readOnly: boolean }) => Promise<void>;
+    formatNdef: (bytes: number[], options?: {readOnly?: boolean}) => Promise<void>;
   }
 
   /** [iOS ONLY] */
   interface Iso15693HandlerIOS {
     getSystemInfo: (
-      requestFloags: number,
+      requestFlags: number,
     ) => Promise<{
       dsfid: number;
       afi: number;
@@ -189,6 +217,8 @@ declare module 'react-native-nfc-manager' {
     lockDSFID: (params: {flags: number}) => Promise<void>;
     resetToReady: (params: {flags: number}) => Promise<void>;
     select: (params: {flags: number}) => Promise<void>;
+    stayQuiet: () => Promise<void>;
+    /** @deprecated Use stayQuiet instead. */
     stayQuite: () => Promise<void>;
     customCommand: (params: {
       flags: number;
@@ -223,15 +253,17 @@ declare module 'react-native-nfc-manager' {
   type OnDiscoverTag = (evt: TagEvent) => void;
   type OnSessionClosed = (error?: NfcError.NfcErrorBase) => void;
   type OnStateChanged = (evt: {state: string}) => void;
-  type OnNfcEvents = OnDiscoverTag | OnSessionClosed | OnStateChanged;
 
   interface NfcManager {
     start(): Promise<void>;
-    isSupported(): Promise<boolean>;
+    isSupported(tech?: NfcTech | ''): Promise<boolean>;
     isEnabled(): Promise<boolean>;
     registerTagEvent(options?: RegisterTagEventOpts): Promise<void>;
     unregisterTagEvent(): Promise<void>;
-    setEventListener(name: NfcEvents, callback: OnNfcEvents | null): void;
+    setEventListener(name: NfcEvents.DiscoverTag, callback: OnDiscoverTag | null): void;
+    setEventListener(name: NfcEvents.DiscoverBackgroundTag, callback: OnDiscoverTag | null): void;
+    setEventListener(name: NfcEvents.SessionClosed, callback: OnSessionClosed | null): void;
+    setEventListener(name: NfcEvents.StateChanged, callback: OnStateChanged | null): void;
     requestTechnology(
       tech: NfcTech | NfcTech[],
       options?: RegisterTagEventOpts,
@@ -241,6 +273,17 @@ declare module 'react-native-nfc-manager' {
     getBackgroundTag: () => Promise<TagEvent | null>;
     clearBackgroundTag: () => Promise<void>;
     setAlertMessage: (alertMessage: string) => Promise<void>;
+    writeNdefMessage: (
+      bytes: number[],
+      options?: {reconnectAfterWrite?: boolean},
+    ) => Promise<void>;
+    getNdefMessage: () => Promise<TagEvent | null>;
+
+    readonly MIFARE_BLOCK_SIZE: number;
+    readonly MIFARE_ULTRALIGHT_PAGE_SIZE: number;
+    readonly MIFARE_ULTRALIGHT_TYPE: number;
+    readonly MIFARE_ULTRALIGHT_TYPE_C: number;
+    readonly MIFARE_ULTRALIGHT_TYPE_UNKNOWN: number;
 
     /**
      * common tech handler getters for both iOS / Android
@@ -253,12 +296,13 @@ declare module 'react-native-nfc-manager' {
     /**
      * iOS only
      */
+    /** @deprecated Use getBackgroundTag instead. */
     getBackgroundNdef: () => Promise<NdefRecord[] | null>;
     setAlertMessageIOS: (alertMessage: string) => Promise<void>;
     invalidateSessionIOS: () => Promise<void>;
-    invalidateSessionWithErrorIOS: (errorMessage: string) => Promise<void>;
-    isSessionAvailableIOS: () => Promise<Boolean>;
-    isTagSessionAvailableIOS: () => Promise<Boolean>;
+    invalidateSessionWithErrorIOS: (errorMessage?: string) => Promise<void>;
+    isSessionAvailableIOS: () => Promise<boolean>;
+    isTagSessionAvailableIOS: () => Promise<boolean>;
     sendMifareCommandIOS: (bytes: number[]) => Promise<number[]>;
     sendFelicaCommandIOS: (bytes: number[]) => Promise<number[]>;
     sendCommandAPDUIOS: (
@@ -284,6 +328,9 @@ declare module 'react-native-nfc-manager' {
     transceive(bytes: number[]): Promise<number[]>;
     getMaxTransceiveLength(): Promise<number>;
     setTimeout(timeout: number): Promise<void>;
+    getTimeout(): Promise<number|void>;
+    /** @deprecated Android Beam is no longer supported. */
+    setNdefPushMessage(bytes: number[]): Promise<never>;
     connect: (techs: NfcTech[]) => Promise<void>;
     close: () => Promise<void>;
     mifareClassicHandlerAndroid: MifareClassicHandlerAndroid;
@@ -373,7 +420,7 @@ declare module 'react-native-nfc-manager' {
       encodePayload: (
         text: string,
         lang?: ISOLangCode,
-        encoding?: any,
+        encoding?: unknown,
       ) => NdefRecord;
       decodePayload: (data: Uint8Array) => string;
     };
@@ -386,38 +433,55 @@ declare module 'react-native-nfc-manager' {
       decodePayload: (data: Uint8Array) => WifiSimpleCredentials;
     };
     util: {
-      stringToBytes: (string: string) => any[];
-      bytesToString: (bytes: any) => string;
-      bytesToHexString: (bytes: any) => string;
-      toHex: (i: any) => any;
-      toPrintable: (i: any) => string;
+      stringToBytes: (string: string) => number[];
+      bytesToString: (bytes: string | number[]) => string;
+      bytesToHexString: (bytes: number[]) => string;
+      toHex: (i: number) => string;
+      toPrintable: (i: number) => string;
     };
     isType(record: NdefRecord, tnf: TNF, type: string): boolean;
     stringify(data: number[], separator: string): string;
     encodeMessage(records: NdefRecord[]): number[];
-    decodeMessage(bytes: number[]): NdefRecord[];
-    textRecord(text: string, lang?: ISOLangCode, encoding?: any): NdefRecord;
-    uriRecord(uri: URI, id?: any): NdefRecord;
-    wifiSimpleRecord(credentials: WifiSimpleCredentials, id?: any): NdefRecord;
+    decodeMessage(bytes: number[] | Uint8Array): NdefRecord[];
+    textRecord(text: string, lang?: ISOLangCode, encoding?: unknown): NdefRecord;
+    uriRecord(uri: URI, id?: string | number[]): NdefRecord;
+    wifiSimpleRecord(credentials: WifiSimpleCredentials, id?: string | number[]): NdefRecord;
     androidApplicationRecord(pkgName: string): NdefRecord;
     record(
       tnf: TNF,
       type: string,
-      id: string | any[],
-      payload: string | any[],
+      id: string | number[],
+      payload: string | number[],
     ): NdefRecord;
   };
 
   export const NfcErrorIOS: {
     errCodes: {
       unknown: -1;
+      unsupportedFeature: 1;
+      securityViolation: 2;
+      invalidParameter: 3;
+      invalidParameterLength: 4;
+      parameterOutOfBound: 5;
+      radioDisabled: 6;
+      tagConnectionLost: 100;
+      retryExceeded: 101;
+      tagResponseError: 102;
+      sessionInvalidated: 103;
+      tagNotConnected: 104;
+      packetTooLong: 105;
       userCancel: 200;
       timeout: 201;
       unexpected: 202;
       systemBusy: 203;
       firstNdefInvalid: 204;
+      invalidConfiguration: 300;
+      tagNotWritable: 400;
+      tagUpdateFailure: 401;
+      tagSizeTooSmall: 402;
+      zeroLengthMessage: 403;
     };
-    parse(errorString: string): number;
+    parse(error: string | NfcError.UserCancel): number;
   }
 
   export namespace NfcError {

package/ios/NfcManager.h

@@ -15,19 +15,15 @@
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <NativeNfcManagerSpec/NativeNfcManagerSpec.h>
-// @interface NfcManager : NSObject <NativeNfcManagerSpec, NFCNDEFReaderSessionDelegate, NFCTagReaderSessionDelegate> {
-@interface NfcManager : RCTEventEmitter <NativeNfcManagerSpec, RCTBridgeModule, NFCNDEFReaderSessionDelegate, NFCTagReaderSessionDelegate> {
+@interface NfcManager : NativeNfcManagerSpecBase <NativeNfcManagerSpec> {
 
 }
 #else
-@interface NfcManager : RCTEventEmitter <RCTBridgeModule, NFCNDEFReaderSessionDelegate, NFCTagReaderSessionDelegate> {
+@interface NfcManager : RCTEventEmitter <RCTBridgeModule> {
 
 }
 #endif
 
-@property (strong, nonatomic) NFCNDEFReaderSession * _Nullable session;
-@property (strong, nonatomic) NFCTagReaderSession * _Nullable tagSession;
-
 + (BOOL)application:(nonnull UIApplication *)application
     continueUserActivity:(nonnull NSUserActivity *)userActivity
       restorationHandler:
@@ -38,8 +34,3 @@
         #endif
 
 @end
-
-extern NSString* _Nonnull getHexString(NSData * _Nonnull);
-extern NSString* _Nonnull getErrorMessage(NSError * _Nonnull);
-extern NSData * _Nonnull arrayToData(NSArray * _Nonnull);
-extern NSArray * _Nonnull dataToArray(NSData * _Nonnull);