react-native-nfc-manager 4.0.0-beta.6 → 4.0.0-beta.8

package/ndef-lib/{util.js → util.ts}

@@ -2,8 +2,11 @@
 // Copyright 2013 Don Coleman
 //
 
+type Byte = number;
+type ByteArray = Byte[];
+
 // https://weblog.rogueamoeba.com/2017/02/27/javascript-correctly-converting-a-byte-array-to-a-utf-8-string/
-function _utf8ArrayToStr(data) {
+function _utf8ArrayToStr(data: ByteArray): string | null {
   const extraByteMap = [1, 1, 1, 1, 2, 2, 3, 0];
   var count = data.length;
   var str = '';
@@ -34,7 +37,7 @@ function _utf8ArrayToStr(data) {
 }
 
 // https://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
-function _toUTF8Array(str) {
+function _toUTF8Array(str: string): ByteArray {
   var out = [],
     p = 0;
   for (var i = 0; i < str.length; i++) {
@@ -64,7 +67,7 @@ function _toUTF8Array(str) {
   return out;
 }
 
-function stringToBytes(string) {
+function stringToBytes(string: string): ByteArray {
   return _toUTF8Array(string);
   // var bytes = Buffer(string).toJSON();
   // if (bytes.hasOwnProperty('data')) {
@@ -76,7 +79,7 @@ function stringToBytes(string) {
   // }
 }
 
-function bytesToString(bytes) {
+function bytesToString(bytes: string | ByteArray): string | null {
   if (typeof bytes === 'string') {
     return bytes;
   }
@@ -86,7 +89,7 @@ function bytesToString(bytes) {
 }
 
 // useful for readable version of Tag UID
-function bytesToHexString(bytes) {
+function bytesToHexString(bytes: ByteArray): string {
   var dec,
     hexstring,
     bytesAsHexString = '';
@@ -107,7 +110,7 @@ function bytesToHexString(bytes) {
 }
 
 // i must be <= 256
-function toHex(i) {
+function toHex(i: number): string {
   var hex;
 
   if (i < 0) {
@@ -122,8 +125,8 @@ function toHex(i) {
   return hex;
 }
 
-function toPrintable(i) {
-  if ((i >= 0x20) & (i <= 0x7f)) {
+function toPrintable(i: number): string {
+  if (i >= 0x20 && i <= 0x7f) {
     return String.fromCharCode(i);
   } else {
     return '.';
@@ -137,3 +140,5 @@ module.exports = {
   toHex: toHex,
   toPrintable: toPrintable,
 };
+
+export {};

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "react-native-nfc-manager",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.8",
   "description": "A NFC module for react native.",
-  "main": "src/index.js",
+  "main": "dist/src/index.js",
+  "types": "index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/whitedogg13/react-native-nfc-manager.git"
@@ -17,6 +18,7 @@
     "nfc"
   ],
   "files": [
+    "dist",
     "src",
     "ndef-lib",
     "index.d.ts",
@@ -32,12 +34,16 @@
     "url": "https://github.com/whitedogg13"
   },
   "jest": {
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "<rootDir>/example/"
+    ]
   },
   "babel": {
     "presets": [
       "@babel/preset-env",
-      "@babel/preset-react"
+      "@babel/preset-react",
+      "@babel/preset-typescript"
     ],
     "plugins": [
       "@babel/plugin-proposal-class-properties",
@@ -50,6 +56,7 @@
     "@babel/plugin-transform-runtime": "^7.12.10",
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-react": "^7.12.10",
+    "@babel/preset-typescript": "^7.27.1",
     "@expo/config-plugins": "~10.0.0",
     "@react-native-community/eslint-config": "^3.2.0",
     "@release-it/conventional-changelog": "^8.0.1",
@@ -58,13 +65,15 @@
     "jest": "^29.7.0",
     "jest-cli": "^29.7.0",
     "prettier": "^2.2.1",
-    "react": "^16.13.1",
-    "react-native": "^0.63.0",
+    "react": "^19.2.3",
+    "react-native": "^0.84.0",
     "release-it": "^17.5.0",
     "typescript": "^4.1.3"
   },
   "peerDependencies": {
-    "@expo/config-plugins": "*"
+    "@expo/config-plugins": "*",
+    "react": ">=18.2",
+    "react-native": ">=0.76"
   },
   "peerDependenciesMeta": {
     "@expo/config-plugins": {
@@ -72,9 +81,14 @@
     }
   },
   "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "jest -i",
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json",
+    "verify:package": "npm run build && node scripts/verify-package-contents.js",
+    "prepack": "npm run build",
     "release": "dotenv -- release-it --",
     "release:beta": "release-it --preRelease=beta --increment=prerelease"
   },

package/react-native-nfc-manager.podspec

@@ -13,7 +13,8 @@ Pod::Spec.new do |s|
   s.source = { git: package[:repository][:url] }
   # s.source_files = "ios/**/*.{h,m}"
   s.source_files    = "ios/**/*.{h,m,mm,swift}"
-  s.platform = :ios, "8.0"
+  s.swift_version   = "5.7"
+  s.platform = :ios, "15.1"
 
   # s.dependency "React-Core"
 
@@ -22,4 +23,4 @@ Pod::Spec.new do |s|
   }
 
   install_modules_dependencies(s)
-end
+end

package/specs/NativeNfcManager.ts

@@ -1,7 +1,19 @@
-import type {TurboModule} from 'react-native';
+import type {CodegenTypes, TurboModule} from 'react-native';
 import {TurboModuleRegistry} from 'react-native';
 
+export type SessionClosedEvent = {
+  error: string;
+};
+
+export type StateChangedEvent = {
+  state: string;
+};
+
 export interface Spec extends TurboModule {
+  readonly onDiscoverTag: CodegenTypes.EventEmitter<Object>;
+  readonly onDiscoverBackgroundTag: CodegenTypes.EventEmitter<Object>;
+  readonly onSessionClosed: CodegenTypes.EventEmitter<SessionClosedEvent>;
+  readonly onStateChanged: CodegenTypes.EventEmitter<StateChangedEvent>;
   isSupported(tech: string, callback: (err?: string, resp?: boolean) => void): void;
   isEnabled(callback: (err?: string, resp?: boolean) => void): void;
   start(callback: (err?: string) => void): void;
@@ -25,6 +37,7 @@ export interface Spec extends TurboModule {
   invalidateSession(callback: (err?: string) => void): void;
   invalidateSessionWithError(message: string, callback: (err?: string) => void): void;
   getNdefMessage(callback: (err?: string, tag?: Object) => void): void;
+  getCachedNdefMessage(callback: (err?: string, tag?: Object) => void): void;
   writeNdefMessage(bytes: number[], options: Object, callback: (err?: string) => void): void;
   makeReadOnly(callback: (err?: string) => void): void;
   setAlertMessage(message: string, callback: (err?: string) => void): void;
@@ -38,7 +51,7 @@ export interface Spec extends TurboModule {
   removeListeners: (count: number) => void;
   iso15693_getSystemInfo(requestFlag: number, callback: (err?: string, systemInfo?: Object) => void): void;
   iso15693_readSingleBlock(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
-  iso15693_readMultipleBlocks(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
+  iso15693_readMultipleBlocks(options: Object, callback: (err?: string, blocks?: number[][]) => void): void;
   iso15693_writeSingleBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_lockBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_writeAFI(options: Object, callback: (err?: string) => void): void;
@@ -47,11 +60,11 @@ export interface Spec extends TurboModule {
   iso15693_lockDSFID(options: Object, callback: (err?: string) => void): void;
   iso15693_resetToReady(options: Object, callback: (err?: string) => void): void;
   iso15693_select(options: Object, callback: (err?: string) => void): void;
-  iso15693_stayQuiet(options: Object, callback: (err?: string) => void): void;
+  iso15693_stayQuiet(callback: (err?: string) => void): void;
   iso15693_customCommand(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
   iso15693_sendRequest(options: Object, callback: (err?: string, responseFlag?: number, bytes?: number[]) => void): void;
   iso15693_extendedReadSingleBlock(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
-  iso15693_extendedReadMultipleBlocks(options: Object, callback: (err?: string, bytes?: number[]) => void): void;
+  iso15693_extendedReadMultipleBlocks(options: Object, callback: (err?: string, blocks?: number[][]) => void): void;
   iso15693_extendedWriteSingleBlock(options: Object, callback: (err?: string) => void): void;
   iso15693_extendedLockBlock(options: Object, callback: (err?: string) => void): void;
   goToNfcSetting(callback: (err?: string) => void): void;

package/src/NativeNfcManager.ts

@@ -0,0 +1,84 @@
+'use strict';
+import {NativeModules, NativeEventEmitter} from 'react-native';
+
+type NativeMethod = (...args: unknown[]) => void;
+type NativeEventSubscription = {remove: () => void};
+type CodegenEventEmitter = (
+  listener: (payload: unknown) => void,
+) => NativeEventSubscription;
+type NativeModule = Record<string, NativeMethod> & Record<string, unknown> & {
+  addListener: (eventType: string) => void;
+  removeListeners: (count: number) => void;
+  onDiscoverTag?: CodegenEventEmitter;
+  onDiscoverBackgroundTag?: CodegenEventEmitter;
+  onSessionClosed?: CodegenEventEmitter;
+  onStateChanged?: CodegenEventEmitter;
+};
+type NativeEmitterLike = {
+  addListener: (eventName: string, listener: (payload: unknown) => void) => NativeEventSubscription;
+};
+
+const reactNativeGlobal = global as typeof global & {
+  'RN$Bridgeless'?: boolean;
+  __turboModuleProxy?: unknown;
+};
+const isTurboModuleEnabled =
+  reactNativeGlobal['RN$Bridgeless'] === true ||
+  reactNativeGlobal.__turboModuleProxy != null;
+const nativeModules = NativeModules || {};
+const NativeNfcManager = (isTurboModuleEnabled
+  ? require('../specs/NativeNfcManager').default
+  : nativeModules.NfcManager) as NativeModule;
+
+const legacyNfcManagerEmitter: NativeEmitterLike =
+  typeof NativeEventEmitter === 'function'
+    ? new NativeEventEmitter(NativeNfcManager)
+    : {addListener: () => ({remove: () => {}})};
+
+const codegenEventEmitters: Record<string, CodegenEventEmitter | undefined> = {
+  NfcManagerDiscoverTag: NativeNfcManager.onDiscoverTag,
+  NfcManagerDiscoverBackgroundTag: NativeNfcManager.onDiscoverBackgroundTag,
+  NfcManagerSessionClosed: NativeNfcManager.onSessionClosed,
+  NfcManagerStateChanged: NativeNfcManager.onStateChanged,
+};
+
+const NfcManagerEmitter: NativeEmitterLike = {
+  addListener: (eventName, listener) => {
+    const codegenEmitter = codegenEventEmitters[eventName];
+    if (isTurboModuleEnabled && codegenEmitter) {
+      return codegenEmitter(listener);
+    }
+    return legacyNfcManagerEmitter.addListener(eventName, listener);
+  },
+};
+
+function callNative<T = unknown>(name: string, params: unknown[] = []): Promise<T> {
+  const nativeMethod = NativeNfcManager[name] as NativeMethod | undefined;
+
+  if (!nativeMethod) {
+    throw new Error(`no such native method: "${name}"`);
+  }
+
+  if (!Array.isArray(params)) {
+    throw new Error('params must be an array');
+  }
+
+  const createCallback = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: unknown) => void,
+  ) => (err: unknown, result: T) => {
+    if (err) {
+      reject(err);
+    } else {
+      resolve(result);
+    }
+  };
+
+  return new Promise((resolve, reject) => {
+    const callback = createCallback(resolve, reject);
+    const inputParams = [...params, callback];
+    nativeMethod(...inputParams);
+  });
+}
+
+export {NativeNfcManager, NfcManagerEmitter, callNative};

package/src/{NfcError.js → NfcError.ts}

@@ -7,22 +7,18 @@ export class InvalidParameter extends NfcErrorBase {}
 export class InvalidParameterLength extends NfcErrorBase {}
 export class ParameterOutOfBound extends NfcErrorBase {}
 export class RadioDisabled extends NfcErrorBase {}
-// transceive errors
 export class TagConnectionLost extends NfcErrorBase {}
 export class RetryExceeded extends NfcErrorBase {}
 export class TagResponseError extends NfcErrorBase {}
 export class SessionInvalidated extends NfcErrorBase {}
 export class TagNotConnected extends NfcErrorBase {}
 export class PacketTooLong extends NfcErrorBase {}
-// reader session errors
 export class UserCancel extends NfcErrorBase {}
 export class Timeout extends NfcErrorBase {}
 export class Unexpected extends NfcErrorBase {}
 export class SystemBusy extends NfcErrorBase {}
 export class FirstNdefInvalid extends NfcErrorBase {}
-// tag command configuration errors
 export class InvalidConfiguration extends NfcErrorBase {}
-// ndef reader session error
 export class TagNotWritable extends NfcErrorBase {}
 export class TagUpdateFailure extends NfcErrorBase {}
 export class TagSizeTooSmall extends NfcErrorBase {}
@@ -37,29 +33,25 @@ export const NfcErrorIOS = {
     invalidParameterLength: 4,
     parameterOutOfBound: 5,
     radioDisabled: 6,
-    // transceive errors
     tagConnectionLost: 100,
     retryExceeded: 101,
     tagResponseError: 102,
     sessionInvalidated: 103,
     tagNotConnected: 104,
     packetTooLong: 105,
-    // reader session errors
     userCancel: 200,
     timeout: 201,
     unexpected: 202,
     systemBusy: 203,
     firstNdefInvalid: 204,
-    // tag command configuration errors
     invalidConfiguration: 300,
-    // ndef reader session error
     tagNotWritable: 400,
     tagUpdateFailure: 401,
     tagSizeTooSmall: 402,
     zeroLengthMessage: 403,
   },
 
-  parse: (error) => {
+  parse: (error: string | UserCancel | unknown) => {
     if (typeof error === 'string') {
       const [domainError] = error.split(',');
 
@@ -70,7 +62,6 @@ export const NfcErrorIOS = {
         }
       }
     } else if (error instanceof UserCancel) {
-      // this is for backward capability only
       console.warn('API Deprecated: please use NfcError.UserCancel instead');
       return NfcErrorIOS.errCodes.userCancel;
     }
@@ -78,7 +69,7 @@ export const NfcErrorIOS = {
   },
 };
 
-export function buildNfcExceptionIOS(error) {
+export function buildNfcExceptionIOS(error: string) {
   const [domainError] = error.split(',');
 
   if (domainError) {
@@ -136,7 +127,7 @@ export function buildNfcExceptionIOS(error) {
   return new NfcErrorBase(error);
 }
 
-export function buildNfcExceptionAndroid(error) {
+export function buildNfcExceptionAndroid(error: string) {
   if (error === 'cancelled') {
     return new UserCancel();
   }
@@ -144,15 +135,14 @@ export function buildNfcExceptionAndroid(error) {
   return new NfcErrorBase(error);
 }
 
-export async function handleNativeException(
-  callNativePromise,
+export async function handleNativeException<T>(
+  callNativePromise: Promise<T>,
   ignoreError = false,
-) {
+): Promise<T | undefined> {
   try {
     return await callNativePromise;
   } catch (err) {
     if (!ignoreError) {
-      // the error from the native side will always be a string
       if (typeof err === 'string') {
         if (Platform.OS === 'ios') {
           throw buildNfcExceptionIOS(err);
@@ -161,7 +151,6 @@ export async function handleNativeException(
         }
       }
 
-      // unexpected condition, simply throws them out without conversion
       throw err;
     }
   }

package/src/{NfcManager.js → NfcManager.ts}

@@ -20,7 +20,7 @@ const NfcEvents = {
   DiscoverBackgroundTag: 'NfcManagerDiscoverBackgroundTag',
   SessionClosed: 'NfcManagerSessionClosed',
   StateChanged: 'NfcManagerStateChanged',
-};
+} as const;
 
 const NfcTech = {
   Ndef: 'Ndef',
@@ -35,7 +35,7 @@ const NfcTech = {
   Iso15693IOS: 'iso15693',
   FelicaIOS: 'felica',
   NdefFormatable: 'NdefFormatable',
-};
+} as const;
 
 const DEFAULT_REGISTER_TAG_EVENT_OPTIONS = {
   alertMessage: 'Please tap NFC tags',
@@ -43,29 +43,42 @@ const DEFAULT_REGISTER_TAG_EVENT_OPTIONS = {
   isReaderModeEnabled: false,
   readerModeFlags: 0,
   readerModeDelay: 250,
-};
+} as const;
+
+type NfcEventName = (typeof NfcEvents)[keyof typeof NfcEvents];
+type RegisterTagEventOptions = Partial<typeof DEFAULT_REGISTER_TAG_EVENT_OPTIONS>;
+type WriteNdefOptions = {reconnectAfterWrite?: boolean};
+type ClientEventCallback = ((payload: unknown) => void) | null;
+type NativeSubscriptionMap = Partial<Record<NfcEventName, {remove: () => void}>>;
+type ClientListenerMap = Partial<Record<NfcEventName, ClientEventCallback>>;
+type AsyncMethod = (...args: unknown[]) => Promise<unknown>;
 
 function NotImpl() {
   throw new Error('not implemented');
 }
 
-async function DoNothing() {
+async function DoNothing(..._args: unknown[]) {
   // allow derived class to not implment it
 }
 
 class NfcManagerBase {
+  _subscriptions: NativeSubscriptionMap;
+  _clientListeners: ClientListenerMap;
+  _ndefHandler: NdefHandler | null;
+  _nfcAHandler: NfcAHandler | null;
+  _nfcVHandler: NfcVHandler | null;
+  _isoDepHandler: IsoDepHandler | null;
+
   constructor() {
+    this._subscriptions = {};
+    this._clientListeners = {};
+    this._ndefHandler = null;
+    this._nfcAHandler = null;
+    this._nfcVHandler = null;
+    this._isoDepHandler = null;
     this._subscribeNativeEvents();
   }
 
-  hello(str) {
-    return NativeNfcManager.hello(str);
-  }
-
-  async echo(msg) {
-    return handleNativeException(callNative('echo', [msg]));
-  }
-
   async start() {
     return handleNativeException(callNative('start'));
   }
@@ -74,7 +87,7 @@ class NfcManagerBase {
     return handleNativeException(callNative('isSupported', [tech]));
   }
 
-  async registerTagEvent(options = {}) {
+  async registerTagEvent(options: RegisterTagEventOptions = {}) {
     const optionsWithDefault = {
       ...DEFAULT_REGISTER_TAG_EVENT_OPTIONS,
       ...options,
@@ -93,8 +106,10 @@ class NfcManagerBase {
     return handleNativeException(callNative('getTag'));
   }
 
-  setEventListener(name, callback) {
-    const allNfcEvents = Object.keys(NfcEvents).map((k) => NfcEvents[k]);
+  setEventListener(name: NfcEventName, callback: ClientEventCallback) {
+    const allNfcEvents = Object.keys(NfcEvents).map(
+      (k) => NfcEvents[k as keyof typeof NfcEvents],
+    );
     if (allNfcEvents.indexOf(name) === -1) {
       throw new Error('no such event');
     }
@@ -102,26 +117,26 @@ class NfcManagerBase {
     this._clientListeners[name] = callback;
   }
 
-  requestTechnology = NotImpl;
+  requestTechnology: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  restartTechnologyRequestIOS = NotImpl;
+  restartTechnologyRequestIOS: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  cancelTechnologyRequest = NotImpl;
+  cancelTechnologyRequest: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  getBackgroundTag = NotImpl;
+  getBackgroundTag: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  clearBackgroundTag = NotImpl;
+  clearBackgroundTag: AsyncMethod = async (..._args: unknown[]) => NotImpl();
 
-  setAlertMessage = DoNothing;
+  setAlertMessage: AsyncMethod = DoNothing;
 
-  getTimeout = DoNothing;
+  getTimeout: AsyncMethod = DoNothing;
 
-  async writeNdefMessage(bytes, options = {}) {
-    return handleNativeException(callNative('writeNdefMessage', [bytes, options]));
+  async writeNdefMessage(bytes: number[], options: WriteNdefOptions = {}) {
+    return this.ndefHandler.writeNdefMessage(bytes, options);
   }
 
   async getNdefMessage() {
-    return handleNativeException(callNative('getNdefMessage'));
+    return this.ndefHandler.getNdefMessage();
   }
 
   get ndefHandler() {
@@ -153,36 +168,36 @@ class NfcManagerBase {
   }
 
   get MIFARE_BLOCK_SIZE() {
-    return NativeNfcManager.MIFARE_BLOCK_SIZE;
+    return NativeNfcManager.MIFARE_BLOCK_SIZE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_PAGE_SIZE() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_PAGE_SIZE;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_PAGE_SIZE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE_C() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_C;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_C as unknown as number;
   }
   get MIFARE_ULTRALIGHT_TYPE_UNKNOWN() {
-    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_UNKNOWN;
+    return NativeNfcManager.MIFARE_ULTRALIGHT_TYPE_UNKNOWN as unknown as number;
   }
 
-  _onDiscoverTag = (tag) => {
+  _onDiscoverTag = (tag: unknown) => {
     const callback = this._clientListeners[NfcEvents.DiscoverTag];
     if (callback) {
       callback(tag);
     }
   };
 
-  _onDiscoverBackgroundTag = (tag) => {
+  _onDiscoverBackgroundTag = (tag: unknown) => {
     const callback = this._clientListeners[NfcEvents.DiscoverBackgroundTag];
     if (callback) {
       callback(tag);
     }
   };
 
-  _onSessionClosedIOS = (resp) => {
+  _onSessionClosedIOS = (resp: {error: string}) => {
     const callback = this._clientListeners[NfcEvents.SessionClosed];
     if (callback) {
       const error = buildNfcExceptionIOS(resp.error);
@@ -190,7 +205,7 @@ class NfcManagerBase {
     }
   };
 
-  _onStateChangedAndroid = (state) => {
+  _onStateChangedAndroid = (state: unknown) => {
     const callback = this._clientListeners[NfcEvents.StateChanged];
     if (callback) {
       callback(state);

package/src/{NfcManagerAndroid.js → NfcManagerAndroid.ts}

@@ -5,6 +5,12 @@ import {MifareUltralightHandlerAndroid} from './NfcTech/MifareUltralightHandlerA
 import {NdefFormatableHandlerAndroid} from './NfcTech/NdefFormatableHandlerAndroid';
 import {handleNativeException, buildNfcExceptionAndroid} from './NfcError';
 
+type RequestTechnologyOptions = Record<string, unknown>;
+type CancelTechnologyRequestOptions = {
+  throwOnError?: boolean;
+  delayMsAndroid?: number;
+};
+
 const NfcAdapter = {
   FLAG_READER_NFC_A: 0x1,
   FLAG_READER_NFC_B: 0x2,
@@ -15,15 +21,26 @@ const NfcAdapter = {
   FLAG_READER_NO_PLATFORM_SOUNDS: 0x100,
 };
 
-const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 class NfcManagerAndroid extends NfcManagerBase {
+  cleanUpTagRegistration: boolean;
+  _mifareClassicHandlerAndroid: MifareClassicHandlerAndroid | null;
+  _mifareUltralightHandlerAndroid: MifareUltralightHandlerAndroid | null;
+  _ndefFormatableHandlerAndroid: NdefFormatableHandlerAndroid | null;
+
   constructor() {
     super();
     this.cleanUpTagRegistration = false;
+    this._mifareClassicHandlerAndroid = null;
+    this._mifareUltralightHandlerAndroid = null;
+    this._ndefFormatableHandlerAndroid = null;
   }
 
-  requestTechnology = async (tech, options = {}) => {
+  requestTechnology = async (
+    tech: string | string[],
+    options: RequestTechnologyOptions = {},
+  ) => {
     try {
       if (typeof tech === 'string') {
         tech = [tech];
@@ -43,7 +60,7 @@ class NfcManagerAndroid extends NfcManagerBase {
     }
   };
 
-  cancelTechnologyRequest = async (options = {}) => {
+  cancelTechnologyRequest = async (options: CancelTechnologyRequestOptions = {}) => {
     const {throwOnError = false, delayMsAndroid = 1000} = options;
 
     try {
@@ -77,20 +94,20 @@ class NfcManagerAndroid extends NfcManagerBase {
   getLaunchTagEvent = () =>
     handleNativeException(callNative('getLaunchTagEvent'));
 
-  setNdefPushMessage = (bytes) => {
+  setNdefPushMessage = (_bytes: number[]) => {
     return Promise.reject('this api is deprecated');
   }
 
-  setTimeout = (timeout) =>
+  setTimeout = (timeout: number) =>
     handleNativeException(callNative('setTimeout', [timeout]));
 
   getTimeout = () => handleNativeException(callNative('getTimeout'));
 
-  connect = (techs) => handleNativeException(callNative('connect', [techs]));
+  connect = (techs: string[]) => handleNativeException(callNative('connect', [techs]));
 
   close = () => handleNativeException(callNative('close'));
 
-  transceive = (bytes) =>
+  transceive = (bytes: number[]) =>
     handleNativeException(callNative('transceive', [bytes]));
 
   getMaxTransceiveLength = () =>
@@ -123,7 +140,7 @@ class NfcManagerAndroid extends NfcManagerBase {
   // -------------------------------------
   get ndefFormatableHandlerAndroid() {
     if (!this._ndefFormatableHandlerAndroid) {
-      this._ndefFormatableHandlerAndroid = new NdefFormatableHandlerAndroid(this);
+      this._ndefFormatableHandlerAndroid = new NdefFormatableHandlerAndroid();
     }
     return this._ndefFormatableHandlerAndroid;
   }