@onekeyfe/react-native-lite-card 1.0.18 → 1.1.2

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 @onekeyfe
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# @onekeyfe/react-native-lite-card
+
+lite card
+
+## Installation
+
+
+```sh
+npm install @onekeyfe/react-native-lite-card
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from '@onekeyfe/react-native-lite-card';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/ReactNativeLiteCard.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeLiteCard"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/onekeyfe-react-native-lite-card.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}", "keys/**/*.{h,c,m,mm,swift,cpp}"
+  s.vendored_framework = "ios/GPChannelSDKCore.xcframework"
+  s.private_header_files = "ios/**/*.h"
+
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -1,6 +1,7 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["LiteCard_kotlinVersion"]
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeLiteCard_' + name]
+  }
 
   repositories {
     google()
@@ -8,63 +9,34 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.0.2"
+    classpath "com.android.tools.build:gradle:8.7.2"
     // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["LiteCard_" + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["LiteCard_" + name]).toInteger()
-}
-
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeLiteCard_" + name]).toInteger()
 }
 
 android {
-  if (supportsNamespace()) {
-    namespace "so.onekey.app.wallet.lite"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  externalNativeBuild {
-    cmake {
-        path "src/main/cpp/CMakeLists.txt"
-    }
-  }
+  namespace "com.onekeyfe.reactnativelitecard"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
 
+  buildFeatures {
+    buildConfig true
   }
 
   buildTypes {
@@ -81,6 +53,15 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
 }
 
 repositories {
@@ -91,12 +72,8 @@ repositories {
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
+  implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation 'com.google.code.gson:gson:2.10.1'
   implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 }
-

package/android/gradle.properties

@@ -1,5 +1,5 @@
-LiteCard_kotlinVersion=2.1.20
-LiteCard_minSdkVersion=21
-LiteCard_targetSdkVersion=35
-LiteCard_compileSdkVersion=35
-LiteCard_ndkversion=26.1.10909125
+ReactNativeLiteCard_kotlinVersion=2.0.21
+ReactNativeLiteCard_minSdkVersion=24
+ReactNativeLiteCard_targetSdkVersion=34
+ReactNativeLiteCard_compileSdkVersion=35
+ReactNativeLiteCard_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="so.onekey.app.wallet.lite">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/main/java/com/onekeyfe/reactnativelitecard/ReactNativeLiteCardModule.kt

@@ -0,0 +1,420 @@
+package com.onekeyfe.reactnativelitecard
+
+import android.content.Intent
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.nfc.tech.IsoDep
+import android.util.Log
+import androidx.annotation.IntDef
+import androidx.fragment.app.FragmentActivity
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import so.onekey.app.wallet.lite.nfc.NFCExceptions
+import so.onekey.app.wallet.lite.nfc.NfcUtils
+import so.onekey.app.wallet.lite.onekeyLite.OneKeyLiteCard
+import so.onekey.app.wallet.lite.onekeyLite.entitys.CardState
+import so.onekey.app.wallet.lite.utils.NfcPermissionUtils
+import so.onekey.app.wallet.lite.utils.Utils
+import java.util.concurrent.atomic.AtomicInteger
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.WritableMap
+import so.onekey.app.wallet.lite.nfc.broadcast.NfcStatusChangeBroadcastReceiver
+import java.util.concurrent.Executors.newFixedThreadPool
+
+private val NFCDispatcher = newFixedThreadPool(1).asCoroutineDispatcher()
+public fun NFCScope(): CoroutineScope = CoroutineScope(SupervisorJob() + NFCDispatcher)
+
+@ReactModule(name = ReactNativeLiteCardModule.NAME)
+class ReactNativeLiteCardModule(reactContext: ReactApplicationContext) :
+  NativeReactNativeLiteCardSpec(reactContext), LifecycleEventListener, CoroutineScope by NFCScope() {
+
+  companion object {
+    const val NAME = "ReactNativeLiteCard"
+    private val TAG = ReactNativeLiteCardModule::class.simpleName
+  }
+
+  @IntDef(NFCState.Dead, NFCState.Started)
+  annotation class NFCState {
+    companion object {
+      const val Dead = -1
+      const val Started = 0
+    }
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  private val mNFCConnectedChannel = Channel<IsoDep?>(1)
+  private var lastIsoDep: IsoDep? = null
+  private val mNFCState = AtomicInteger(NFCState.Dead)
+  private val mShowDialogNumber = AtomicInteger(0)
+  private var mCurrentCardState: CardState? = null
+
+  private val mActivityEventListener = object : BaseActivityEventListener() {
+    override fun onNewIntent(intent: Intent) {
+      super.onNewIntent(intent)
+      val action = intent.action
+      if (action == null) {
+        return
+      }
+      if ((action == NfcAdapter.ACTION_NDEF_DISCOVERED)
+        || action == NfcAdapter.ACTION_TECH_DISCOVERED
+        || action == NfcAdapter.ACTION_TAG_DISCOVERED
+      ) {
+        val tags = intent.getParcelableExtra<Tag>(NfcAdapter.EXTRA_TAG)
+        val isoDep: IsoDep? = IsoDep.get(tags)
+        if (isoDep == null) {
+          // 未知设备
+          val dataMap = Arguments.createMap().apply {
+            putString("type", "unknown")
+          }
+          emitOnNFCActiveConnection(dataMap)
+          Log.d(TAG, "Unknown device")
+          return
+        }
+
+        Log.d(TAG, isoDep.toString())
+        launch(Dispatchers.IO) {
+          mNFCConnectedChannel.trySend(isoDep)
+          try {
+            // 处理主动触发 NFC
+            delay(100)
+            if (!mNFCConnectedChannel.isEmpty) {
+              Log.e(TAG, "There is no way to use NFC")
+//                            mNFCConnectedChannel.receive()
+              val startRequest = OneKeyLiteCard.initRequest(isoDep)
+              val dataMap = Arguments.createMap().apply {
+                putInt("code", -1)
+                putString("type", "OneKey_Lite")
+                putString("serialNum", startRequest.serialNum)
+                putBoolean("isNewCard", startRequest.isNewCard)
+                putBoolean("hasBackup", startRequest.hasBackup)
+              }
+              emitOnNFCActiveConnection(dataMap)
+            }
+          } catch (e: Exception) {
+            e.printStackTrace()
+            // 未知设备或连接失败
+            val dataMap = Arguments.createMap().apply {
+              putInt("code", -1)
+              putString("type", "unknown")
+            }
+            emitOnNFCActiveConnection(dataMap)
+            emitOnNFCActiveConnection(dataMap)
+          }
+        }
+      }
+    }
+  }
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+    reactContext.addActivityEventListener(mActivityEventListener)
+  }
+
+  private fun releaseDevice() {
+    if (mShowDialogNumber.get() <= 0) return
+
+    mCurrentCardState = null
+    val decrementAndGet = mShowDialogNumber.decrementAndGet()
+
+    // 关闭连接结束 ui
+    emitOnNFCUIEvent(Arguments.createMap().also {
+      it.putInt("code", 3)
+      it.putString("message", "close_connect_ui")
+    })
+
+    // 还有需要处理的 NFC 事件
+    if (decrementAndGet > 0) {
+      // 展示连接 ui
+      emitOnNFCUIEvent(Arguments.createMap().also {
+        it.putInt("code", 1)
+        it.putString("message", "show_connect_ui")
+      })
+    }
+  }
+
+  @Throws(NFCExceptions::class)
+  private suspend fun acquireDevice(): IsoDep? {
+    // 展示连接 ui
+    emitOnNFCUIEvent(Arguments.createMap().also {
+      it.putInt("code", 1)
+      it.putString("message", "show_connect_ui")
+    })
+    mShowDialogNumber.incrementAndGet()
+    val tryReceiveResult = mNFCConnectedChannel.tryReceive()
+
+    fun IsoDep?.isSafeConnected(): Boolean {
+      return runCatching { this?.isConnected ?: false }.getOrDefault(false)
+    }
+    var receiveIsoDep: IsoDep? = null
+
+    if (tryReceiveResult.isSuccess) {
+      receiveIsoDep = tryReceiveResult.getOrNull()
+      if (!receiveIsoDep.isSafeConnected()) {
+        receiveIsoDep = null
+      }
+    }
+
+    if (receiveIsoDep == null && lastIsoDep.isSafeConnected()) {
+      receiveIsoDep = lastIsoDep
+    }
+    if (receiveIsoDep == null) {
+      receiveIsoDep = mNFCConnectedChannel.receive()
+    }
+
+    lastIsoDep = receiveIsoDep
+    if (receiveIsoDep == null) {
+      // 取消连接
+      releaseDevice()
+    } else {
+      val initChannelRequest = OneKeyLiteCard.initRequest(receiveIsoDep)
+
+      mCurrentCardState = initChannelRequest
+
+      // 展示连接结束 ui
+      emitOnNFCUIEvent(Arguments.createMap().also {
+        it.putInt("code", 2)
+        it.putString("message", "connected")
+      })
+    }
+    return receiveIsoDep
+  }
+
+  private suspend fun <T> handleOperation(
+    callback: Callback?,
+    execute: (isoDep: IsoDep) -> T
+  ) {
+    val topActivity = Utils.getTopActivity() ?: return
+    NfcPermissionUtils.checkPermission(topActivity) {
+      try {
+        Log.d(TAG, "NFC permission check success")
+        val isoDep = acquireDevice() ?: return
+        val executeResult = execute(isoDep)
+        callback?.invoke(null, executeResult, mCurrentCardState.createArguments())
+      } catch (e: NFCExceptions) {
+        Log.e(TAG, "NFC device execute error", e)
+        callback?.invoke(e.createArguments(), null, mCurrentCardState.createArguments())
+      } finally {
+        releaseDevice()
+      }
+      return
+    }
+    // 没有 NFC 使用权限
+    Log.d(TAG, "NFC device not permission")
+    callback?.invoke(NFCExceptions.NotNFCPermission().createArguments(), null, null)
+  }
+
+  private fun CardState?.createArguments(): WritableMap {
+    val map = Arguments.createMap()
+    if (this == null) return map
+    map.putBoolean("hasBackup", this.hasBackup)
+    map.putBoolean("isNewCard", this.isNewCard)
+    map.putString("serialNum", this.serialNum)
+    map.putInt("pinRetryCount", this.pinRetryCount)
+    return map
+  }
+
+  private fun NFCExceptions?.createArguments(): WritableMap {
+    val map = Arguments.createMap()
+    if (this == null) return map
+    map.putInt("code", this.code)
+    map.putString("message", this.message)
+    return map
+  }
+
+  override fun getLiteInfo(callback: Callback?) {
+    launch {
+      Log.d(TAG, "getLiteInfo")
+      handleOperation<Any>(callback) { isoDep ->
+        Log.e(TAG, "getLiteInfo Obtain the device")
+        val cardInfo = OneKeyLiteCard.getCardInfo(isoDep)
+        Log.e(TAG, "getLiteInfo result $cardInfo")
+        cardInfo.createArguments()
+      }
+    }
+  }
+
+  override fun checkNFCPermission(callback: Callback?) {
+    val topActivity = Utils.getTopActivity()
+    if (topActivity == null) {
+      callback?.invoke(NFCExceptions.InitializedException().createArguments(), null, null)
+      return
+    }
+    val isNfcExists = NfcUtils.isNfcExits(topActivity)
+    if (!isNfcExists) {
+      // 没有 NFC 设备
+      Log.d(TAG, "NFC device not found")
+      callback?.invoke(NFCExceptions.NotExistsNFC().createArguments(), null, null)
+      return
+    }
+
+    val isNfcEnable = NfcUtils.isNfcEnable(topActivity)
+    if (!isNfcEnable) {
+      // 没有打开 NFC 开关
+      Log.d(TAG, "NFC device not enable")
+      callback?.invoke(NFCExceptions.NotEnableNFC().createArguments(), null, null)
+      return
+    }
+    NfcPermissionUtils.checkPermission(topActivity) {
+      callback?.invoke(null, null, null)
+      return
+    }
+    // 没有 NFC 使用权限
+    Log.d(TAG, "NFC device not permission")
+    callback?.invoke(NFCExceptions.NotNFCPermission().createArguments(), null, null)
+  }
+
+  override fun setMnemonic(
+    mnemonic: String?,
+    pwd: String?,
+    overwrite: Boolean,
+    callback: Callback?
+  ) {
+    launch {
+      handleOperation(callback) { isoDep ->
+        Log.e(TAG, "setMnemonic Obtain the device")
+        val isSuccess =
+          OneKeyLiteCard.setMnemonic(
+            mCurrentCardState,
+            isoDep,
+            mnemonic,
+            pwd,
+            overwrite
+          )
+        if (!isSuccess) throw NFCExceptions.ExecFailureException()
+        Log.e(TAG, "setMnemonic result success")
+        true
+      }
+    }
+  }
+
+  override fun getMnemonicWithPin(
+    pwd: String,
+    callback: Callback?
+  ) {
+    launch {
+      Log.d(TAG, "getMnemonicWithPin")
+      handleOperation(callback) { isoDep ->
+        Log.e(TAG, "getMnemonicWithPin Obtain the device")
+        OneKeyLiteCard.getMnemonicWithPin(mCurrentCardState, isoDep, pwd)
+      }
+    }
+  }
+
+  override fun changePin(
+    oldPin: String,
+    newPin: String,
+    callback: Callback?
+  ) {
+    launch {
+      Log.d(TAG, "changePin")
+      handleOperation(callback) { isoDep ->
+        Log.e(TAG, "changePin Obtain the device")
+        OneKeyLiteCard.changPin(mCurrentCardState, isoDep, oldPin, newPin)
+      }
+    }
+  }
+
+  override fun reset(callback: Callback?) {
+    launch {
+      Log.d(TAG, "reset")
+      handleOperation(callback) { isoDep ->
+        Log.e(TAG, "reset Obtain the device")
+        val isSuccess = OneKeyLiteCard.reset(isoDep)
+        if (!isSuccess) throw NFCExceptions.ExecFailureException()
+        Log.e(TAG, "reset result success")
+        true
+      }
+    }
+  }
+
+  override fun cancel() {
+    if (mNFCConnectedChannel.isEmpty) {
+      mNFCConnectedChannel.trySend(null)
+    }
+  }
+
+  override fun intoSetting() {
+    launch {
+      Log.d(TAG, "intoSetting")
+      Utils.getTopActivity()?.let {
+        NfcUtils.intentToNfcSetting(it)
+      }
+    }
+  }
+
+  private val mNfcStateBroadcastReceiver by lazy {
+    object : NfcStatusChangeBroadcastReceiver() {
+      override fun onCardPayMode() {
+        super.onCardPayMode()
+      }
+
+      override fun onNfcOff() {
+        super.onNfcOff()
+      }
+
+      override fun onNfcOn() {
+        super.onNfcOn()
+        Utils.getTopActivity()?.let {
+          launch(Dispatchers.IO) {
+            OneKeyLiteCard.startNfc(it as FragmentActivity) {}
+          }
+        }
+      }
+
+      override fun onNfcTurningOff() {
+        super.onNfcTurningOff()
+      }
+
+      override fun onNfcTurningOn() {
+        super.onNfcTurningOn()
+      }
+    }
+  }
+
+
+  override fun onHostResume() {
+    Utils.getTopActivity()?.let {
+      launch(Dispatchers.IO) {
+        if (it !is FragmentActivity) return@launch
+        try {
+          OneKeyLiteCard.startNfc(it) {
+            mNFCState.set(NFCState.Started)
+
+            Log.d(TAG, "NFC starting success")
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "startNfc failed", e)
+        }
+      }
+    }
+  }
+
+  override fun onHostPause() {
+    Utils.getTopActivity()?.let {
+      launch(Dispatchers.IO) {
+        try {
+          OneKeyLiteCard.stopNfc(it as FragmentActivity)
+          mNFCState.set(NFCState.Dead)
+          Log.d(TAG, "NFC 已关闭")
+        } catch (e: Exception) {
+          Log.e(TAG, "stopNfc failed", e)
+        }
+      }
+    }
+  }
+
+  override fun onHostDestroy() {
+    try {
+      Utils.getTopActivity()?.unregisterReceiver(mNfcStateBroadcastReceiver)
+    } catch (ignore: Exception) {
+    }
+  }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/ReactNativeLiteCardPackage.kt

@@ -0,0 +1,33 @@
+package com.onekeyfe.reactnativelitecard
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class ReactNativeLiteCardPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == ReactNativeLiteCardModule.NAME) {
+      ReactNativeLiteCardModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[ReactNativeLiteCardModule.NAME] = ReactModuleInfo(
+        ReactNativeLiteCardModule.NAME,
+        ReactNativeLiteCardModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/{so/onekey/app/wallet/lite → com/onekeyfe/reactnativelitecard}/onekeyLite/OnekeyLiteCard.kt

@@ -102,11 +102,11 @@ object OneKeyLiteCard {
 
     @Throws(NFCExceptions::class)
     fun setMnemonic(
-        cardState: CardState?,
-        isoDep: IsoDep,
-        mnemonic: String,
-        pwd: String,
-        overwrite: Boolean = false
+      cardState: CardState?,
+      isoDep: IsoDep,
+      mnemonic: String?,
+      pwd: String?,
+      overwrite: Boolean = false
     ): Boolean {
         if (cardState == null) throw NFCExceptions.ConnectionFailException()
 
@@ -146,7 +146,7 @@ object OneKeyLiteCard {
             }
         }
 
-        return mCardConnection?.backupData(mnemonic) == true
+        return mCardConnection?.backupData(mnemonic ?: "") == true
     }
 
     @Throws(NFCExceptions::class)
@@ -233,4 +233,4 @@ object OneKeyLiteCard {
             }
         }
     }
-}
+}