@digitalshieldfe/react-native-backup-card-sdk 0.1.4 → 0.1.6

package/android/build.gradle

@@ -15,7 +15,6 @@ buildscript {
   }
 
   repositories {
-    mavenLocal()
     google()
     mavenCentral()
   }
@@ -33,6 +32,33 @@ apply plugin: "kotlin-android"
 
 apply plugin: "com.facebook.react"
 
+react {
+  jsRootDir = file("../src/")
+  libraryName = "BackupCardSdkSpec"
+  codegenJavaPackageName = "com.ziancube.reactnativebackupcardsdk"
+}
+
+// Kotlin/Java TurboModule uses BackupCardSdkSpec-generated.cpp (JavaTurboModule).
+// BackupCardSdkSpecJSI-generated.cpp targets a C++ module class that is not implemented
+// and conflicts with BackupCardSdkSpecJSI.h from the same codegen run.
+def patchBackupCardCodegen = tasks.register("patchBackupCardCodegen") {
+  doLast {
+    def jsiCpp =
+        file(
+            "${layout.buildDirectory.get()}/generated/source/codegen/jni/react/renderer/components/BackupCardSdkSpec/BackupCardSdkSpecJSI-generated.cpp"
+        )
+    if (jsiCpp.exists()) {
+      jsiCpp.delete()
+    }
+  }
+}
+
+tasks.configureEach { task ->
+  if (task.name == "generateCodegenArtifactsFromSchema") {
+    task.finalizedBy(patchBackupCardCodegen)
+  }
+}
+
 android {
   namespace "com.ziancube.reactnativebackupcardsdk"
 
@@ -41,31 +67,6 @@ android {
   defaultConfig {
     minSdkVersion getExtOrDefault("minSdkVersion")
     targetSdkVersion getExtOrDefault("targetSdkVersion")
-    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-    consumerProguardFiles "consumer-rules.pro"
-
-    externalNativeBuild {
-      cmake {
-        cppFlags(
-            "",
-            "-std=c++11",
-            "-frtti",
-            "-fexceptions",
-            "-DHAVE_ENDIAN_H"
-        )
-
-        arguments(
-            "-DANDROID_TOOLCHAIN=clang",
-            "-DANDROID_STL=c++_static",
-            "-DANDROID_ARM_MODE=arm",
-            "-DANDROID_PLATFORM=android-19"
-        )
-      }
-    }
-
-    ndk {
-      abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86'
-    }
   }
 
   buildFeatures {
@@ -75,10 +76,6 @@ android {
   buildTypes {
     release {
       minifyEnabled false
-      proguardFiles(
-          getDefaultProguardFile("proguard-android-optimize.txt"),
-          "proguard-rules.pro"
-      )
     }
   }
 
@@ -87,28 +84,15 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_11
-    targetCompatibility JavaVersion.VERSION_11
-  }
-
-  externalNativeBuild {
-    cmake {
-      path = file("src/main/jni/CMakeLists.txt")
-    }
-  }
-
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
-    }
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
   }
 }
 
 dependencies {
-  implementation("androidx.appcompat:appcompat:1.6.1")
-  implementation("com.google.android.material:material:1.12.0")
+  implementation(files("libs/backupcardsdk.aar"))
+  // Transitive deps of backupcardsdk (not bundled inside the AAR)
+  implementation("androidx.appcompat:appcompat:1.7.1")
+  implementation("com.google.android.material:material:1.13.0")
   implementation("com.facebook.react:react-android")
-  testImplementation("junit:junit:4.13.2")
-  androidTestImplementation("androidx.test.ext:junit:1.1.5")
-  androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
 }

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,2 @@
-<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.NFC" />
-    <uses-feature android:name="android.hardware.nfc" android:required="false" />
-</manifest>
+</manifest>

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/BackupCardSdkModule.kt

@@ -1,6 +1,8 @@
 package com.ziancube.reactnativebackupcardsdk
 
+import android.app.Activity
 import android.content.Intent
+import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.BaseActivityEventListener
 import com.facebook.react.bridge.Promise
@@ -12,7 +14,12 @@ import com.facebook.react.bridge.LifecycleEventListener
 import com.ziancube.backupcardsdk.ApduLogger
 import com.ziancube.backupcardsdk.BackupCardSdk
 import com.ziancube.backupcardsdk.NfcTouchListener
+import com.ziancube.backupcardsdk.CardOperationResult
 import com.ziancube.backupcardsdk.CardInfo
+import com.ziancube.backupcardsdk.NfcWaitTimeoutException
+import com.ziancube.reactnativebackupcardsdk.nfc.NfcExceptions
+import com.ziancube.reactnativebackupcardsdk.nfc.NfcUtils
+import com.ziancube.reactnativebackupcardsdk.utils.NfcPermissionUtils
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -21,47 +28,73 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
-fun CardInfo.toWritableMap(): WritableMap {
-  val map = Arguments.createMap()
-  map.putString("serialNumber", serialNumber)
-  map.putInt("pinRetryCount", pinRetryCount ?: -1)
-  map.putBoolean("isNewCard", isNewCard ?: false)
-  return map
-}
-
-fun ReadableArray.toByteArray(): ByteArray {
-  val bytes = ByteArray(size())
-  for (i in 0 until size()) {
-    bytes[i] = getInt(i).toByte()
-  }
-  return bytes
-}
-
-fun ByteArray?.toWritableArrayOrNull(): WritableArray? {
-  if (this == null) return null
-  val array = Arguments.createArray()
-  for (b in this) {
-    array.pushInt(b.toInt() and 0xFF)
-  }
-  return array
-}
-
-
 class BackupCardSdkModule(val reactContext: ReactApplicationContext) :
         NativeBackupCardSdkSpec(reactContext) ,LifecycleEventListener
 {
-  private lateinit var backupCardSdk: BackupCardSdk
+  private var backupCardSdk: BackupCardSdk? = null
+  private var boundActivity: Activity? = null
   private val tag = "BackupCardSdkModule"
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+  private val apduLogger =
+          object : ApduLogger {
+            override fun log(message: String, isSent: Boolean, isSuccess: Boolean) {
+              val params =
+                      Arguments.createMap()
+                              .apply {
+                                putString("message", message)
+                                putBoolean("isSent", isSent)
+                                putBoolean("isSuccess", isSuccess)
+                              }
+                              .copy()
+              runCatching { emitOnApduLog(params) }
+                .onFailure { Log.w(tag, "Dropped apduLog event: JS callback is not ready", it) }
+            }
+          }
+
+  private val nfcTouchListener =
+          object : NfcTouchListener {
+            override fun onTouch(isBackupCard: Boolean) {
+              val params =
+                      Arguments.createMap()
+                              .apply { putBoolean("isBackupCard", isBackupCard) }
+                              .copy()
+              runCatching { emitOnNfcTouch(params) }
+                .onFailure { Log.w(tag, "Dropped nfcTouch event: JS callback is not ready", it) }
+            }
+          }
+
+  private fun ensureBackupCardSdk(activity: Activity?): BackupCardSdk? {
+    if (activity == null) return null
+    if (backupCardSdk != null && boundActivity === activity) return backupCardSdk
+
+    runCatching { backupCardSdk?.release() }
+      .onFailure { Log.e(tag, "Failed to release previous BackupCardSdk", it) }
+
+    boundActivity = activity
+    backupCardSdk = runCatching { BackupCardSdk(activity, apduLogger, nfcTouchListener) }
+      .onFailure { Log.e(tag, "Failed to initialize BackupCardSdk", it) }
+      .getOrNull()
+    return backupCardSdk
+  }
+
   override fun invalidate() {
     super.invalidate()
+    backupCardSdk?.cancelWaitForCardTag()
+    backupCardSdk?.release()
+    backupCardSdk = null
+    boundActivity = null
     scope.cancel()
   }
   private val mActivityEventListener =
           object : BaseActivityEventListener() {
             override fun onNewIntent(intent: Intent) {
               super.onNewIntent(intent)
-              backupCardSdk.handleIntent(intent)
+              runCatching {
+                backupCardSdk?.handleIntent(intent)
+              }.onFailure {
+                Log.e(tag, "Crash while handling NFC intent", it)
+              }
             }
           }
 
@@ -69,37 +102,76 @@ class BackupCardSdkModule(val reactContext: ReactApplicationContext) :
     super.initialize()
     Utils.init(reactContext)
     Utils.getActivityLifecycle()
-    val activity = Utils.getTopActivity()
-    if (activity == null) {
-      return
-    }
-    val apduLogger =
-            object : ApduLogger {
-              override fun log(message: String, isSent: Boolean, isSuccess: Boolean) {
-                val params =
-                        Arguments.createMap()
-                                .apply {
-                                  putString("message", message)
-                                  putBoolean("isSent", isSent)
-                                  putBoolean("isSuccess", isSuccess)
-                                }
-                                .copy()
-                emitOnApduLog(params)
-              }
-            }
-    val nfcTouchListener =
-            object : NfcTouchListener {
-              override fun onTouch(isBackupCard: Boolean) {
-                val params =
-                        Arguments.createMap()
-                                .apply { putBoolean("isBackupCard", isBackupCard) }
-                                .copy()
-                emitOnNfcTouch(params)
-              }
-            }
-    backupCardSdk = BackupCardSdk(activity, apduLogger, nfcTouchListener)
     reactContext.addActivityEventListener(mActivityEventListener)
     reactContext.addLifecycleEventListener(this)
+    ensureBackupCardSdk(Utils.getTopActivity())
+  }
+
+  private fun CardInfo.toCardInfoMap(): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("serialNumber", serialNumber)
+    map.putInt("pinRetryCount", pinRetryCount ?: -1)
+    map.putBoolean("isNewCard", isNewCard ?: false)
+    val backup = isBackup
+    if (backup != null) {
+      map.putBoolean("isBackup", backup)
+    } else {
+      map.putNull("isBackup")
+    }
+    return map
+  }
+
+  private fun putOperationData(map: WritableMap, data: Any?) {
+    when (data) {
+      null -> map.putNull("data")
+      is Boolean -> map.putBoolean("data", data)
+      is Int -> map.putInt("data", data)
+      is Long -> map.putDouble("data", data.toDouble())
+      is Double -> map.putDouble("data", data)
+      is Float -> map.putDouble("data", data.toDouble())
+      is String -> map.putString("data", data)
+      is ByteArray -> map.putArray("data", data.asWritableArrayOrNull())
+      else -> map.putNull("data")
+    }
+  }
+
+  private fun CardOperationResult<*>.toCardOperationResultMap(): WritableMap {
+    val map = Arguments.createMap()
+    val cardError = error
+    val info = cardInfo
+    if (cardError != null) {
+      val errorMap = Arguments.createMap()
+      errorMap.putInt("code", cardError.code)
+      errorMap.putString("message", cardError.message)
+      map.putMap("error", errorMap)
+    } else {
+      map.putNull("error")
+    }
+    if (info != null) {
+      map.putMap("cardInfo", info.toCardInfoMap())
+    } else {
+      map.putNull("cardInfo")
+    }
+    map.putInt("resultCode", resultCode)
+    putOperationData(map, data)
+    return map
+  }
+
+  private fun ReadableArray.asByteArray(): ByteArray {
+    val bytes = ByteArray(size())
+    for (i in 0 until size()) {
+      bytes[i] = getInt(i).toByte()
+    }
+    return bytes
+  }
+
+  private fun ByteArray?.asWritableArrayOrNull(): WritableArray? {
+    if (this == null) return null
+    val array = Arguments.createArray()
+    for (b in this) {
+      array.pushInt(b.toInt() and 0xFF)
+    }
+    return array
   }
 
   companion object {
@@ -108,44 +180,125 @@ class BackupCardSdkModule(val reactContext: ReactApplicationContext) :
 
   override fun getCardInfo(promise: Promise) =
         promise.launchSuspend(
-                block = { backupCardSdk.getCardInfo() },
-                transform = { info -> info?.toWritableMap() }
+                block = {
+                  val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                          ?: throw IllegalStateException("No foreground activity available")
+                  sdk.getCardInfo()
+                },
+                transform = { info -> info?.toCardInfoMap() }
         )
 
+  override fun cancelNfcWait() {
+    backupCardSdk?.cancelWaitForCardTag()
+  }
+
+  override fun checkNFCPermission(promise: Promise) {
+    val activity = Utils.getTopActivity()
+    if (activity == null) {
+      promise.rejectNfc(NfcExceptions.InitializedException("No foreground activity"))
+      return
+    }
+    if (!NfcUtils.isNfcExits(activity)) {
+      promise.rejectNfc(NfcExceptions.NotExistsNFC())
+      return
+    }
+    if (!NfcUtils.isNfcEnable(activity)) {
+      promise.rejectNfc(NfcExceptions.NotEnableNFC())
+      return
+    }
+    var granted = false
+    NfcPermissionUtils.checkPermission(activity) { granted = true }
+    if (granted) {
+      promise.resolve(true)
+    } else {
+      promise.rejectNfc(NfcExceptions.NotNFCPermission())
+    }
+  }
+
+  override fun intoSetting() {
+    val activity = Utils.getTopActivity() ?: return
+    NfcUtils.intentToNfcSetting(activity)
+  }
+
+  private fun Promise.rejectNfc(exception: NfcExceptions) {
+    val userInfo =
+            Arguments.createMap()
+                    .apply {
+                      putInt("code", exception.code)
+                      putString("message", exception.message ?: "")
+                    }
+                    .copy()
+    reject("NFC_ERROR", exception.message, null, userInfo)
+  }
+
     override fun resetCard(promise: Promise) =
       promise.launchSuspend(
-          block = { backupCardSdk.resetCard() },
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.resetCard()
+          },
           transform = { result -> result }
       )
 
-      override fun activateCard(pwd: String, promise: Promise) =
+      override fun activateCard(pwd: String, serialNumber: String, promise: Promise) =
         promise.launchSuspend(
-          block = { backupCardSdk.activateCard(pwd) },
-          transform = { result -> result }
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.activateCard(pwd, serialNumber)
+          },
+          transform = { result -> result.toCardOperationResultMap() }
         )
 
       override fun changePin(oldPin: String, newPin: String, promise: Promise) =
         promise.launchSuspend(
-          block = { backupCardSdk.changePin(oldPin, newPin) },
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.changePin(oldPin, newPin)
+          },
           transform = { result -> result }
         )
 
       override fun checkSlotEmpty(slotId: Double, pwd: String, promise: Promise) =
         promise.launchSuspend(
-          block = { backupCardSdk.checkSlotEmpty(slotId.toInt(), pwd) },
-          transform = { result -> result }
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.checkSlotEmpty(slotId.toInt(), pwd)
+          },
+          transform = { result -> result.toCardOperationResultMap() }
         )
 
       override fun writeSlot(slotIndex: Double, data: ReadableArray, pwd: String, promise: Promise) =
         promise.launchSuspend(
-          block = { backupCardSdk.writeSlot(slotIndex.toInt(), data.toByteArray(), pwd) },
-          transform = { result -> result }
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.writeSlot(slotIndex.toInt(), data.asByteArray(), pwd)
+          },
+          transform = { result -> result.toCardOperationResultMap() }
         )
 
       override fun readSlot(slotIndex: Double, pwd: String, promise: Promise) =
         promise.launchSuspend(
-          block = { backupCardSdk.readSlot(slotIndex.toInt(), pwd) },
-          transform = { result -> result.toWritableArrayOrNull() }
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.readSlot(slotIndex.toInt(), pwd)
+          },
+          transform = { result -> result.toCardOperationResultMap() }
+        )
+
+      override fun deleteSlot(slotIndex: Double, pwd: String, promise: Promise) =
+        promise.launchSuspend(
+          block = {
+            val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+                    ?: throw IllegalStateException("No foreground activity available")
+            sdk.deleteSlot(slotIndex.toInt(), pwd)
+          },
+          transform = { result -> result.toCardOperationResultMap() }
         )
 
 
@@ -154,7 +307,12 @@ class BackupCardSdkModule(val reactContext: ReactApplicationContext) :
           dispatcher: CoroutineDispatcher = Dispatchers.IO,
           block: suspend () -> T,
           transform: (T) -> R,
-          errorCode: (Throwable) -> String = { "E_UNEXPECTED" }
+          errorCode: (Throwable) -> String = { throwable ->
+            when (throwable) {
+              is NfcWaitTimeoutException -> "NFC_WAIT_TIMEOUT"
+              else -> "E_UNEXPECTED"
+            }
+          }
   ) {
     scope.launch {
       try {
@@ -170,14 +328,26 @@ class BackupCardSdkModule(val reactContext: ReactApplicationContext) :
   }
 
   override fun onHostResume() {
-    backupCardSdk.onActivityResumed()
+    runCatching {
+      val sdk = ensureBackupCardSdk(Utils.getTopActivity())
+      sdk?.onActivityResumed()
+      if (sdk != null) {
+        Log.i(tag, "NFC foreground dispatch enabled automatically on app resume.")
+      } else {
+        Log.w(tag, "Skipped NFC foreground dispatch: no foreground activity.")
+      }
+    }.onFailure {
+      Log.e(tag, "Failed to enable NFC foreground dispatch on resume", it)
+    }
   }
 
   override fun onHostPause() {
-    backupCardSdk.onActivityPaused()
+    runCatching { backupCardSdk?.onActivityPaused() }
+      .onFailure { Log.e(tag, "Failed to disable NFC foreground dispatch on pause", it) }
   }
 
   override fun onHostDestroy() {
-    backupCardSdk.onActivityDestroyed()
+    runCatching { backupCardSdk?.onActivityDestroyed() }
+      .onFailure { Log.e(tag, "Failed to cleanup NFC on destroy", it) }
   }
 }

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/BackupCardSdkPackage.kt

@@ -22,7 +22,7 @@ class BackupCardSdkPackage : BaseReactPackage() {
         name = BackupCardSdkModule.NAME,
         className = BackupCardSdkModule.NAME,
         canOverrideExistingModule = false,
-        needsEagerInit = false,
+        needsEagerInit = true,
         isCxxModule = false,
         isTurboModule = true
       )

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/nfc/NfcExceptions.kt

@@ -0,0 +1,11 @@
+package com.ziancube.reactnativebackupcardsdk.nfc
+
+sealed class NfcExceptions(val code: Int, override val message: String? = null) : Exception(message) {
+  class InitializedException(message: String? = null) : NfcExceptions(4001, message)
+
+  class NotExistsNFC(message: String? = null) : NfcExceptions(1001, message)
+
+  class NotEnableNFC(message: String? = null) : NfcExceptions(1002, message)
+
+  class NotNFCPermission(message: String? = null) : NfcExceptions(1003, message)
+}

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/nfc/NfcUtils.kt

@@ -0,0 +1,30 @@
+package com.ziancube.reactnativebackupcardsdk.nfc
+
+import android.content.Context
+import android.content.Intent
+import android.nfc.NfcAdapter
+import android.provider.Settings
+
+object NfcUtils {
+  fun isNfcExits(context: Context): Boolean {
+    return NfcAdapter.getDefaultAdapter(context) != null
+  }
+
+  fun isNfcEnable(context: Context): Boolean {
+    val nfcAdapter = NfcAdapter.getDefaultAdapter(context)
+    return nfcAdapter != null && nfcAdapter.isEnabled
+  }
+
+  fun intentToNfcSetting(context: Context): Boolean {
+    if (!isNfcExits(context)) {
+      return false
+    }
+    return try {
+      context.startActivity(Intent(Settings.ACTION_NFC_SETTINGS))
+      true
+    } catch (ex: Exception) {
+      ex.printStackTrace()
+      false
+    }
+  }
+}

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/utils/MiUtil.kt

@@ -0,0 +1,74 @@
+package com.ziancube.reactnativebackupcardsdk.utils
+
+import android.app.AppOpsManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
+import androidx.annotation.IntDef
+import androidx.annotation.RequiresApi
+
+object MiUtil {
+  private const val TAG = "BackupCardSdkMiUtil"
+
+  @IntDef(
+          value =
+                  [
+                    PermissionResult.PERMISSION_GRANTED,
+                    PermissionResult.PERMISSION_DENIED,
+                    PermissionResult.PERMISSION_ASK,
+                    PermissionResult.PERMISSION_UNKNOWN,
+                  ]
+  )
+  @Retention(AnnotationRetention.SOURCE)
+  annotation class PermissionResult {
+    companion object {
+      const val PERMISSION_GRANTED = 0
+      const val PERMISSION_DENIED = -1
+      const val PERMISSION_ASK = 1
+      const val PERMISSION_UNKNOWN = 2
+    }
+  }
+
+  @PermissionResult
+  @RequiresApi(Build.VERSION_CODES.KITKAT)
+  fun checkNfcPermission(context: Context): Int {
+    try {
+      val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+      val pkg = context.applicationContext.packageName
+      val uid = context.applicationInfo.uid
+      val appOpsClass = Class.forName(AppOpsManager::class.java.name)
+      val checkOpNoThrowMethod =
+              appOpsClass.getDeclaredMethod(
+                      "checkOpNoThrow",
+                      Integer.TYPE,
+                      Integer.TYPE,
+                      String::class.java,
+              )
+      val invoke = checkOpNoThrowMethod.invoke(appOps, 10016, uid, pkg) ?: return PermissionResult.PERMISSION_UNKNOWN
+      return when (invoke.toString()) {
+        "0" -> PermissionResult.PERMISSION_GRANTED
+        "1" -> PermissionResult.PERMISSION_DENIED
+        "5" -> PermissionResult.PERMISSION_ASK
+        else -> PermissionResult.PERMISSION_UNKNOWN
+      }
+    } catch (e: Exception) {
+      Log.d(TAG, "check nfc permission fail: ${e.message}")
+    }
+    return PermissionResult.PERMISSION_UNKNOWN
+  }
+
+  fun intentToAppSetting(context: Context): Boolean {
+    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+    intent.data = Uri.fromParts("package", context.packageName, null)
+    return try {
+      context.startActivity(intent)
+      true
+    } catch (e: Exception) {
+      Log.d(TAG, "open app setting fail: ${e.message}")
+      false
+    }
+  }
+}

package/android/src/main/java/com/ziancube/reactnativebackupcardsdk/utils/NfcPermissionUtils.kt

@@ -0,0 +1,23 @@
+package com.ziancube.reactnativebackupcardsdk.utils
+
+import android.app.Activity
+import android.os.Build
+
+object NfcPermissionUtils {
+  inline fun checkPermission(activity: Activity, doNext: () -> Unit): Int {
+    return if ("xiaomi".equals(Build.MANUFACTURER, ignoreCase = true)) {
+      checkMiuiPermission(activity, doNext)
+    } else {
+      doNext.invoke()
+      0
+    }
+  }
+
+  inline fun checkMiuiPermission(activity: Activity, doNext: () -> Unit): Int {
+    when (MiUtil.checkNfcPermission(activity)) {
+      MiUtil.PermissionResult.PERMISSION_GRANTED -> doNext.invoke()
+      else -> {}
+    }
+    return MiUtil.checkNfcPermission(activity)
+  }
+}