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

package/src/NativeReactNativeLiteCard.ts

@@ -0,0 +1,112 @@
+import {
+  TurboModuleRegistry,
+  type CodegenTypes,
+  type TurboModule,
+} from 'react-native';
+
+export type CallbackError = { code: number; message: string | null } | null;
+
+export type CardInfo = {
+  hasBackup: boolean;
+  isNewCard: boolean;
+  serialNum: string;
+  pinRetryCount: number;
+} | null;
+
+export type CallbackResult<T> = [
+  error: CallbackError | null,
+  data: T | null,
+  cardInfo: CardInfo | null
+];
+
+export type PromiseResult<T> = {
+  error: CallbackError | null;
+  data: T | null;
+  cardInfo: CardInfo | null;
+};
+
+export enum CardErrors {
+  InitChannel = 1000,
+  NotExistsNFC = 1001,
+  NotEnableNFC = 1002,
+  NotNFCPermission = 1003,
+
+  ConnectionFail = 2001,
+  InterruptError = 2002,
+  DeviceMismatch = 2003,
+  UserCancel = 2004,
+
+  PasswordWrong = 3001,
+  InputPasswordEmpty = 3002,
+  NotSetPassword = 3003,
+  InitPasswordError = 3004,
+  CardLock = 3005,
+  UpperErrorAutoReset = 3006,
+
+  ExecFailure = 4000,
+  InitializedError = 4001,
+  NotInitializedError = 4002,
+}
+
+type KeyValuePair = {
+  code: string;
+  message: string;
+};
+
+export interface Spec extends TurboModule {
+  getLiteInfo(
+    callback: (
+      error: CallbackError | null,
+      data: CardInfo | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  checkNFCPermission(
+    callback: (
+      error: CallbackError | null,
+      data: boolean | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  setMnemonic(
+    mnemonic: string,
+    pwd: string,
+    overwrite: boolean,
+    callback: (
+      error: CallbackError | null,
+      data: boolean | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  getMnemonicWithPin(
+    pwd: string,
+    callback: (
+      error: CallbackError | null,
+      data: string | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  changePin(
+    oldPin: string,
+    newPin: string,
+    callback: (
+      error: CallbackError | null,
+      data: boolean | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  reset(
+    callback: (
+      error: CallbackError | null,
+      data: boolean | null,
+      cardInfo: CardInfo | null
+    ) => void
+  ): void;
+  cancel(): void;
+  intoSetting(): void;
+
+  readonly onNFCActiveConnection: CodegenTypes.EventEmitter<KeyValuePair>;
+  readonly onNFCUIEvent: CodegenTypes.EventEmitter<KeyValuePair>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeLiteCard');

package/src/{index.ts → index.tsx}

@@ -1,40 +1,30 @@
-import {
-  Linking,
-  NativeEventEmitter,
-  NativeModules,
-  Platform,
-} from 'react-native';
-
-import type { CallbackResult, CardInfo, PromiseResult } from './types';
-
-const { OKLiteManager } = NativeModules;
+import { Linking, Platform } from 'react-native';
+import OKLiteManager from './NativeReactNativeLiteCard';
+import type {
+  CallbackResult,
+  CardInfo,
+  PromiseResult,
+} from './NativeReactNativeLiteCard';
 
 export type NfcConnectUiState = {
   code: number;
   message: string;
 };
-
 class OnekeyLite {
-  UiEventEmitter: NativeEventEmitter | null = null;
-
-  constructor() {
-    if (Platform.OS !== 'android') return;
-    this.UiEventEmitter = new NativeEventEmitter(OKLiteManager);
-  }
-
   addConnectListener(listener: (event: NfcConnectUiState) => void) {
     this.removeConnectListeners();
-    return this.UiEventEmitter?.addListener('nfc_ui_event', listener);
+    return OKLiteManager.onNFCUIEvent((event) => {
+      listener({
+        code: Number(event.code),
+        message: event.message,
+      });
+    });
   }
 
-  removeConnectListeners() {
-    return this.UiEventEmitter?.removeAllListeners('nfc_ui_event');
-  }
+  removeConnectListeners() {}
 
   addAccordListener() {
-    if (Platform.OS !== 'android') return;
-    const eventEmitter = new NativeEventEmitter(OKLiteManager);
-    return eventEmitter.addListener('nfc_active_connection', () => {});
+    return OKLiteManager.onNFCActiveConnection(() => {});
   }
 
   getLiteInfo() {
@@ -101,3 +91,4 @@ class OnekeyLite {
 
 const onekeyLite = new OnekeyLite();
 export default onekeyLite;
+export type * from './NativeReactNativeLiteCard';

package/LICENSE.md

@@ -1,51 +0,0 @@
-# ONEKEY STANDARD SOURCE LICENSE (O-SSL)
-
-This license governs use of the accompanying software. If you use the software,
-you accept this license. If you do not accept the license, do not use the
-software.
-
-## 1. Definitions
-
-The terms "reproduce," "reproduction" and "distribution" have the same meaning
-here as under Hong Kong copyright law.
-
-"You" means the licensee of the software.
-
-"Your company" means the company you worked for when you downloaded the
-software.
-
-"Reference use" means use of the software within your company as a reference,
-in read only form, for the sole purposes of debugging your products,
-maintaining your products, or enhancing the interoperability of your products
-with the software, and specifically excludes the right to distribute the
-software outside of your company.
-
-"Licensed patents" means any Licensor patent claims which read directly on the
-software as distributed by the Licensor under this license.
-
-## 2. Grant of Rights
-
-(A) Copyright Grant - Subject to the terms of this license, the Licensor grants
-you a non-transferable, non-exclusive, worldwide, royalty-free copyright
-license to reproduce the software for reference use.
-
-(B) Patent Grant - Subject to the terms of this license, the Licensor grants
-you a non-transferable, non-exclusive, worldwide, royalty-free patent license
-under licensed patents for reference use.
-
-## 3. Limitations
-
-(A) No Trademark License - This license does not grant you any rights to use
-the Licensor's name, logo, or trademarks.
-
-(B) If you begin patent litigation against the Licensor over patents that you
-think may apply to the software (including a cross-claim or counterclaim in
-a lawsuit), your license to the software ends automatically.
-
-(C) The software is licensed "as-is." You bear the risk of using it. The
-Licensor gives no express warranties, guarantees or conditions. You may have
-additional consumer rights under your local laws which this license cannot
-change. To the extent permitted under your local laws, the Licensor excludes
-the implied warranties of merchantability, fitness for a particular purpose and
-non-infringement.This license agreement is governed by the laws of Hong Kong, 
-and any disputes related to this license agreement shall be resolved in accordance with Hong Kong law.

package/android/src/main/java/so/onekey/app/wallet/lite/OKLiteManager.kt

@@ -1,431 +0,0 @@
-package so.onekey.app.wallet.lite
-
-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 com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.Channel
-import so.onekey.app.wallet.lite.nfc.NFCExceptions
-import so.onekey.app.wallet.lite.nfc.NfcUtils
-import so.onekey.app.wallet.lite.nfc.broadcast.NfcStatusChangeBroadcastReceiver
-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.Executors
-import java.util.concurrent.atomic.AtomicInteger
-
-
-public fun NFCScope(): CoroutineScope = CoroutineScope(SupervisorJob() + NFCDispatcher)
-private val NFCDispatcher = Executors.newFixedThreadPool(1).asCoroutineDispatcher()
-
-class OKLiteManager(private val context: ReactApplicationContext) :
-    ReactContextBaseJavaModule(context), LifecycleEventListener, CoroutineScope by NFCScope() {
-    companion object {
-        private val TAG = OKLiteManager::class.simpleName
-
-        // NFC UI 事件
-        private const val NFC_UI_EVENT = "nfc_ui_event"
-
-        // NFC 主动连接
-        private const val NFC_ACTIVE_CONNECTION = "nfc_active_connection"
-    }
-
-    @IntDef(NFCState.Dead, NFCState.Started)
-    annotation class NFCState {
-        companion object {
-            const val Dead = -1
-            const val Started = 0
-        }
-    }
-
-    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")
-                    }
-                    sendEvent(context, NFC_ACTIVE_CONNECTION, 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)
-                            }
-                            sendEvent(context, NFC_ACTIVE_CONNECTION, dataMap)
-                        }
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                        // 未知设备或连接失败
-                        val dataMap = Arguments.createMap().apply {
-                            putInt("code", -1)
-                            putString("type", "unknown")
-                        }
-                        sendEvent(context, NFC_ACTIVE_CONNECTION, dataMap)
-                    }
-                }
-            }
-        }
-    }
-
-    init {
-        context.addLifecycleEventListener(this)
-        context.addActivityEventListener(mActivityEventListener)
-    }
-
-    override fun getName() = "OKLiteManager"
-
-    override fun initialize() {
-        super.initialize()
-        Utils.init(context)
-        Utils.getActivityLifecycle()
-        Utils.getTopActivity()?.registerReceiver(
-            mNfcStateBroadcastReceiver,
-            NfcStatusChangeBroadcastReceiver.nfcBroadcastReceiverIntentFilter
-        )
-        Utils.getTopActivity()?.let {
-            launch(Dispatchers.IO) {
-                OneKeyLiteCard.startNfc(it as FragmentActivity) {}
-            }
-        }
-
-    }
-
-    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) {
-        }
-    }
-
-    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()
-            }
-        }
-    }
-
-    private fun sendEvent(
-        reactContext: ReactContext,
-        eventName: String,
-        params: WritableMap
-    ) {
-        reactContext
-            .getJSModule(RCTDeviceEventEmitter::class.java)
-            .emit(eventName, params)
-    }
-
-    @Throws(NFCExceptions::class)
-    private suspend fun acquireDevice(): IsoDep? {
-        // 展示连接 ui
-        sendEvent(context, NFC_UI_EVENT, 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
-            sendEvent(context, NFC_UI_EVENT, Arguments.createMap().also {
-                it.putInt("code", 2)
-                it.putString("message", "connected")
-            })
-        }
-        return receiveIsoDep
-    }
-
-    private fun releaseDevice() {
-        if (mShowDialogNumber.get() <= 0) return
-
-        mCurrentCardState = null
-        val decrementAndGet = mShowDialogNumber.decrementAndGet()
-
-        // 关闭连接结束 ui
-        sendEvent(context, NFC_UI_EVENT, Arguments.createMap().also {
-            it.putInt("code", 3)
-            it.putString("message", "close_connect_ui")
-        })
-
-        // 还有需要处理的 NFC 事件
-        if (decrementAndGet > 0) {
-            // 展示连接 ui
-            sendEvent(context, NFC_UI_EVENT, Arguments.createMap().also {
-                it.putInt("code", 1)
-                it.putString("message", "show_connect_ui")
-            })
-        }
-    }
-
-    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
-    }
-
-    @ReactMethod
-    fun cancel() {
-        if (mNFCConnectedChannel.isEmpty) {
-            mNFCConnectedChannel.trySend(null)
-        }
-    }
-
-    @ReactMethod
-    fun getLiteInfo(callback: Callback) {
-        launch {
-            Log.d(TAG, "getLiteInfo")
-            handleOperation(callback) { isoDep ->
-                Log.e(TAG, "getLiteInfo Obtain the device")
-                val cardInfo = OneKeyLiteCard.getCardInfo(isoDep)
-                Log.e(TAG, "getLiteInfo result $cardInfo")
-                cardInfo.createArguments()
-            }
-        }
-    }
-
-    @ReactMethod
-    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
-            }
-        }
-    }
-
-    @ReactMethod
-    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)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun changePin(oldPwd: String, newPwd: String, callback: Callback) {
-        launch {
-            Log.d(TAG, "changePin")
-            handleOperation(callback) { isoDep ->
-                Log.e(TAG, "changePin Obtain the device")
-                OneKeyLiteCard.changPin(mCurrentCardState, isoDep, oldPwd, newPwd)
-            }
-        }
-    }
-
-    @ReactMethod
-    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)
-    }
-
-    @ReactMethod
-    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
-            }
-        }
-    }
-
-    @ReactMethod
-    fun intoSetting() {
-        launch {
-            Log.d(TAG, "intoSetting")
-            Utils.getTopActivity()?.let {
-                NfcUtils.intentToNfcSetting(it)
-            }
-        }
-    }
-}

package/android/src/main/java/so/onekey/app/wallet/lite/OKLitePackage.kt

@@ -1,16 +0,0 @@
-package so.onekey.app.wallet.lite
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class OKLitePackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        listOf<NativeModule>(
-            OKLiteManager(reactContext),
-        )
-
-    override fun createViewManagers(reactContext: ReactApplicationContext) =
-        emptyList<ViewManager<*, *>>()
-}

package/ios/Classes/OKLiteManager.h

@@ -1,17 +0,0 @@
-//
-//  RNEventManager.h
-//  OneKeyWallet
-//
-//  Created by linleiqin on 2021/11/8.
-//
-
-#import <Foundation/Foundation.h>
-#import <React/RCTBridgeModule.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@interface OKLiteManager : NSObject <RCTBridgeModule>
-
-@end
-
-NS_ASSUME_NONNULL_END