@onekeyfe/react-native-lite-card 0.1.2

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/com/onekeyfe/reactnativelitecard/keys/KeysNativeProvider.kt

@@ -0,0 +1,13 @@
+package so.onekey.app.wallet.lite.keys
+
+import android.content.Context
+
+class KeysNativeProvider {
+    companion object {
+        init {
+            System.loadLibrary("keys")
+        }
+    }
+
+    external fun getLiteSecureChannelInitParams(context: Context): String
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/Exceptions.kt

@@ -0,0 +1,58 @@
+package so.onekey.app.wallet.lite.nfc
+
+sealed class NFCExceptions(val code: Int, override val message: String? = null) : Exception(message) {
+    fun toJson(): String {
+        return """{"code":$code,"message":"$message"}"""
+    }
+
+    // 初始化异常
+    class InitChannelException(message: String? = null) : NFCExceptions(1000, message)
+
+    // 没有 NFC 设备
+    class NotExistsNFC(message: String? = null) : NFCExceptions(1001, message)
+
+    // 没有开启 NFC 设备
+    class NotEnableNFC(message: String? = null) : NFCExceptions(1002, message)
+
+    // 没有使用 NFC 的权限
+    class NotNFCPermission(message: String? = null) : NFCExceptions(1003, message)
+
+    // 连接失败
+    class ConnectionFailException(message: String? = null) : NFCExceptions(2001, message)
+
+    // 操作中断（可能是连接问题）
+    class InterruptException(message: String? = null) : NFCExceptions(2002, message)
+
+    // 连接设备不匹配
+    class DeviceMismatchException(message: String? = null) : NFCExceptions(2003, message)
+
+    // 用户主动取消
+    class UserCancelExceptions(message: String? = null) : NFCExceptions(2004, message)
+
+    // 密码错误
+    class PasswordWrongException(message: String? = null) : NFCExceptions(3001, message)
+
+    // 输入密码为空
+    class InputPasswordEmptyException(message: String? = null) : NFCExceptions(3002, message)
+
+    // 未设置过密码
+    class PasswordEmptyException(message: String? = null) : NFCExceptions(3003, message)
+
+    // 设置初始化密码错误
+    class InitPasswordException(message: String? = null) : NFCExceptions(3004, message)
+
+    // 密码重试次数太多已经锁死
+    class CardLockException(message: String? = null) : NFCExceptions(3005, message)
+
+    // 密码重试次数太多已经自动重制卡片
+    class UpperErrorAutoResetException(message: String? = null) : NFCExceptions(3006, message)
+
+    // 未知的命令执行失败
+    class ExecFailureException(message: String? = null) : NFCExceptions(4000, message)
+
+    // 已经备份过内容
+    class InitializedException(message: String? = null) : NFCExceptions(4001, message)
+
+    // 没有备份过内容
+    class NotInitializedException(message: String? = null) : NFCExceptions(4002, message)
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/NfcUtils.kt

@@ -0,0 +1,142 @@
+package so.onekey.app.wallet.lite.nfc
+
+import android.app.Activity
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.nfc.NfcAdapter
+import android.nfc.tech.*
+import android.os.Build
+import android.provider.Settings
+import so.onekey.app.wallet.lite.utils.MiUtil
+
+object NfcUtils {
+
+    @JvmField
+    var mNfcAdapter: NfcAdapter? = null
+
+    @JvmField
+    var mIntentFilter: Array<IntentFilter>? = null
+
+    @JvmField
+    var mPendingIntent: PendingIntent? = null
+
+    @JvmField
+    var mTechList: Array<Array<String>>? = null
+
+    private fun getPendingIntent(activity: Activity): PendingIntent? {
+        val intent = Intent(activity, activity.javaClass)
+        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        var flag = 0
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            flag = PendingIntent.FLAG_MUTABLE
+        } else {
+            flag = PendingIntent.FLAG_UPDATE_CURRENT
+        }
+        return PendingIntent.getActivity(activity, 0, intent, flag)
+    }
+
+    private fun getIntentFilters(): Array<IntentFilter> {
+        return arrayOf(
+            IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED, "*/*"),
+        )
+    }
+
+    private fun getTechLists(): Array<Array<String>> {
+        return arrayOf(
+            arrayOf(NfcA::class.java.name),
+            arrayOf(IsoDep::class.java.name)
+        )
+    }
+
+    @JvmStatic
+    fun init(activity: Activity): NfcAdapter? {
+        mNfcAdapter = NfcAdapter.getDefaultAdapter(activity)
+        mTechList = getTechLists()
+        mPendingIntent = getPendingIntent(activity)
+        mIntentFilter = getIntentFilters()
+        return mNfcAdapter
+    }
+
+    /**
+     * 判断手机是否具备NFC功能.
+     *
+     * @param context [Context]
+     * @return `true`: 具备 `false`: 不具备
+     */
+    fun isNfcExits(context: Context): Boolean {
+        val nfcAdapter = NfcAdapter.getDefaultAdapter(context)
+        return nfcAdapter != null
+    }
+
+    /**
+     * 判断手机NFC是否开启.
+     *
+     * OPPO A37m 发现必须同时开启NFC以及Android Beam才可以使用
+     * 20180108 发现OPPO单独打开NFC即可读取标签，不清楚是否是系统更新
+     *
+     * @param context [Context]
+     * @return `true`: 已开启 `false`: 未开启
+     */
+    fun isNfcEnable(context: Context): Boolean {
+        val nfcAdapter = NfcAdapter.getDefaultAdapter(context)
+        return nfcAdapter != null && nfcAdapter.isEnabled
+    }
+
+    /**
+     * 判断手机是否具备Android Beam.
+     *
+     * @param context [Context]
+     * @return `true`:具备 `false`:不具备
+     */
+    fun isAndroidBeamExits(context: Context): Boolean {
+        return Build.VERSION.SDK_INT < Build.VERSION_CODES.Q && isNfcExits(context)
+    }
+
+    /**
+     * 跳转至系统NFC设置界面.
+     *
+     * @param context [Context]
+     * @return `true` 跳转成功 <br></br> `false` 跳转失败
+     */
+    fun intentToNfcSetting(context: Context): Boolean {
+        if (isNfcExits(context)) {
+            return toIntent(context, Settings.ACTION_NFC_SETTINGS)
+        }
+        return false
+
+    }
+
+    /**
+     * 跳转至系统NFC Android Beam设置界面，同页面基本都有NFC开关.
+     *
+     * @param context [Context]
+     * @return `true` 跳转成功 <br></br> `false` 跳转失败
+     */
+    fun intentToNfcShare(context: Context): Boolean {
+        return if (isAndroidBeamExits(context)) {
+            toIntent(context, Settings.ACTION_NFCSHARING_SETTINGS)
+        } else false
+    }
+
+    /**
+     * 跳转方法.
+     *
+     * @param context [Context]
+     * @param action  意图
+     * @return 是否跳转成功 `true ` 成功<br></br>`false`失败
+     */
+    private fun toIntent(context: Context, action: String): Boolean {
+        try {
+            val intent = Intent(action)
+            context.startActivity(intent)
+        } catch (ex: Exception) {
+            ex.printStackTrace()
+            return false
+        }
+
+        return true
+    }
+
+}