@onekeyfe/react-native-lite-card 1.0.0

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

@@ -0,0 +1,399 @@
+package so.onekey.app.wallet
+
+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.nfc.NFCExceptions
+import so.onekey.app.wallet.nfc.NfcUtils
+import so.onekey.app.wallet.nfc.broadcast.NfcStatusChangeBroadcastReceiver
+import so.onekey.app.wallet.onekeyLite.OneKeyLiteCard
+import so.onekey.app.wallet.onekeyLite.entitys.CardState
+import so.onekey.app.wallet.utils.NfcPermissionUtils
+import so.onekey.app.wallet.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 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 == 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()
+        if (!mNFCConnectedChannel.isEmpty) {
+            mNFCConnectedChannel.tryReceive()
+        }
+        val receiveIsoDep = mNFCConnectedChannel.receive()
+        mCurrentCardState = null
+        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()
+        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) {
+            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 getCardName(callback: Callback) = launch {
+        Log.d(TAG, "getCardName")
+        handleOperation(callback) { isoDep ->
+            Log.e(TAG, "getCardName Obtain the device")
+            val cardName = OneKeyLiteCard.getCardName(isoDep)
+            Log.e(TAG, "getCardName result $cardName")
+            cardName
+        }
+    }
+
+    @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 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/OKLitePackage.kt

@@ -0,0 +1,16 @@
+package so.onekey.app.wallet
+
+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/android/src/main/java/so/onekey/app/wallet/keys/KeysNativeProvider.kt

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

package/android/src/main/java/so/onekey/app/wallet/nfc/Exceptions.kt

@@ -0,0 +1,58 @@
+package so.onekey.app.wallet.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/so/onekey/app/wallet/nfc/NfcUtils.kt

@@ -0,0 +1,151 @@
+package so.onekey.app.wallet.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.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 ("Smartisan".equals(Build.MANUFACTURER, true)) {
+            if (intentToNfcShare(context)) {
+                return true
+            }
+        }
+        if ("xiaomi".equals(Build.MANUFACTURER, true)) {
+            MiUtil.intentToAppSetting(context)
+            return true
+        }
+        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
+    }
+
+}

package/android/src/main/java/so/onekey/app/wallet/nfc/broadcast/NfcStatusChangeBroadcastReceiver.kt

@@ -0,0 +1,56 @@
+package so.onekey.app.wallet.nfc.broadcast
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.nfc.NfcAdapter
+import android.util.Log
+
+open class NfcStatusChangeBroadcastReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        if (NfcAdapter.ACTION_ADAPTER_STATE_CHANGED == action) {
+            val state =
+                    intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE, NfcAdapter.STATE_OFF)
+
+            Log.e(TAG, "nfc state broadcast receiver, state is $state")
+            when (state) {
+                NfcAdapter.STATE_OFF -> onNfcOff()
+                NfcAdapter.STATE_ON -> onNfcOn()
+                NfcAdapter.STATE_TURNING_OFF -> onNfcTurningOff()
+                NfcAdapter.STATE_TURNING_ON -> onNfcTurningOn()
+                5 -> onCardPayMode() //samsumg return 5 that minds card pay mode
+                else -> onNfcOff()
+            }
+        }
+    }
+
+    protected open fun onNfcTurningOn() {
+
+    }
+
+    protected open fun onNfcTurningOff() {
+
+    }
+
+    protected open fun onNfcOn() {
+
+    }
+
+    protected open fun onNfcOff() {
+
+    }
+
+    protected open fun onCardPayMode() {
+
+    }
+
+    companion object {
+        val TAG: String = NfcStatusChangeBroadcastReceiver::class.java.simpleName
+
+        val nfcBroadcastReceiverIntentFilter: IntentFilter
+            get() = IntentFilter("android.nfc.action.ADAPTER_STATE_CHANGED")
+    }
+}