From 698575606f8c5da4970fd2b7149946dbd72c03c1 Mon Sep 17 00:00:00 2001 From: Tangem Date: Tue, 22 Oct 2019 10:59:05 +0300 Subject: [PATCH] Updated on 2026-08-14 --- .../src/main/java/com/tangem/CardManager.kt | 30 ++++--- .../main/java/com/tangem/tasks/ScanTask.kt | 80 ++++++++++--------- .../src/main/java/com/tangem/tasks/Task.kt | 80 +++++++++---------- 3 files changed, 94 insertions(+), 96 deletions(-) diff --git a/tangem-card-new/src/main/java/com/tangem/CardManager.kt b/tangem-card-new/src/main/java/com/tangem/CardManager.kt index 8fc59eb08f..4db05ae717 100644 --- a/tangem-card-new/src/main/java/com/tangem/CardManager.kt +++ b/tangem-card-new/src/main/java/com/tangem/CardManager.kt @@ -3,7 +3,11 @@ package com.tangem import com.tangem.commands.CommandResponse import com.tangem.commands.CommandSerializer import com.tangem.commands.SignCommandData -import com.tangem.tasks.* +import com.tangem.crypto.initCrypto +import com.tangem.tasks.ScanEvent +import com.tangem.tasks.ScanTask +import com.tangem.tasks.Task +import com.tangem.tasks.TaskResult class CardManager( private val reader: CardReader, @@ -12,30 +16,30 @@ class CardManager( private val cardEnvironmentRepository = CardEnvironmentRepository(dataStorage) - fun scanCard(callback: (result: TaskResult) -> Unit) { + init { + initCrypto() + } + + fun scanCard(callback: (result: ScanEvent, cardEnvironment: CardEnvironment) -> Unit) { val task = ScanTask(cardManagerDelegate, reader) runTask(task, cardEnvironmentRepository.cardEnvironment, callback) } fun sign(signCommandData: SignCommandData, callback: (result: TaskResult) -> Unit) { - val task = SignTask(signCommandData, cardManagerDelegate, reader) - runTask(task, cardEnvironmentRepository.cardEnvironment, callback) +// val task = SignTask(signCommandData, cardManagerDelegate, reader) +// runTask(task, cardEnvironmentRepository.cardEnvironment, callback) } - fun runTask(task: Task, environment: CardEnvironment? = null, - callback: (result: TaskResult) -> Unit) { - task.run(environment ?: cardEnvironmentRepository.cardEnvironment) {result, returnedEnvironment -> - //TODO: environment is kept in Repository - cardEnvironmentRepository.cardEnvironment = returnedEnvironment - callback.invoke(result) - } + fun runTask(task: Task, environment: CardEnvironment? = null, + callback: (result: TaskEvent, cardEnvironment: CardEnvironment) -> Unit) { + task.run(environment ?: cardEnvironmentRepository.cardEnvironment, callback) } fun runCommand(commandSerializer: CommandSerializer, environment: CardEnvironment? = null, callback: (result: TaskResult) -> Unit) { - val task = BasicTask(commandSerializer, cardManagerDelegate, reader) - runTask(task, environment, callback) +// val task = BasicTask(commandSerializer, cardManagerDelegate, reader) +// runTask(task, environment, callback) } } \ No newline at end of file diff --git a/tangem-card-new/src/main/java/com/tangem/tasks/ScanTask.kt b/tangem-card-new/src/main/java/com/tangem/tasks/ScanTask.kt index edcba623d8..c4b552c12c 100644 --- a/tangem-card-new/src/main/java/com/tangem/tasks/ScanTask.kt +++ b/tangem-card-new/src/main/java/com/tangem/tasks/ScanTask.kt @@ -10,20 +10,12 @@ import com.tangem.crypto.verify sealed class ScanEvent { data class OnReadEvent(val result: ReadCardResponse) : ScanEvent() data class OnVerifyEvent(val verified: Boolean) : ScanEvent() - class OnUserCancelledEvent() : ScanEvent() + object OnUserCancelledEvent : ScanEvent() data class Failure(val error: TaskError) : ScanEvent() - data class Succcess(val result: Any) : ScanEvent() } -// -//sealed class ScanResult { -// data class ReadResult(val card: Card) : ScanResult() -// data class VerifyResult(val verified: Boolean) : ScanResult() -// data class Failure(val error: TaskError) : ScanResult() -//} - -class ScanTask(delegate: CardManagerDelegate? = null, reader: CardReader) : Task(delegate, reader) { +class ScanTask(delegate: CardManagerDelegate? = null, reader: CardReader) : Task(delegate, reader) { private lateinit var readCardData: ReadCardResponse private lateinit var challenge: ByteArray @@ -34,42 +26,52 @@ class ScanTask(delegate: CardManagerDelegate? = null, reader: Ca callback: (result: ScanEvent, cardEnvironment: CardEnvironment) -> Unit) { val readCommand = ReadCardCommand(cardEnvironment.pin1) - sendCommand(readCommand, cardEnvironment) { + sendCommand(readCommand, cardEnvironment) { readCommandEvent -> - if (it is CommandEvent.Success) { - readCardData = it.response as ReadCardResponse + when (readCommandEvent) { + is CommandEvent.Success -> { + readCardData = readCommandEvent.response as ReadCardResponse - callback(ScanEvent.OnReadEvent(readCardData), cardEnvironment) + callback(ScanEvent.OnReadEvent(readCardData), cardEnvironment) - if (readCardData.curve != null && readCardData.walletPublicKey != null) { - curve = readCardData.curve!! - walletPublickKey = readCardData.walletPublicKey!! - } else { - callback(ScanEvent.Failure(TaskError.CardError()), cardEnvironment) - } - - val checkWalletCommand = prepareCheckWalletCommand(cardEnvironment) - - sendCommand(checkWalletCommand, cardEnvironment) { checkWalletResult -> - delegate?.closeNfcPopup() - - if (checkWalletResult is CommandEvent.Success) { - val checkWalletResponse = checkWalletResult.response as CheckWalletResponse - val verified = verify(walletPublickKey, - challenge + checkWalletResponse.salt, - checkWalletResponse.walletSignature, - curve) - if (verified) { - callback(ScanEvent.OnVerifyEvent(true), cardEnvironment) - } else { - callback(ScanEvent.Failure(TaskError.VefificationFailed()), cardEnvironment) - } + if (readCardData.curve != null && readCardData.walletPublicKey != null) { + curve = readCardData.curve!! + walletPublickKey = readCardData.walletPublicKey!! + } else { + delegate?.closeNfcPopup() + callback(ScanEvent.Failure(TaskError.CardError()), cardEnvironment) } + val checkWalletCommand = prepareCheckWalletCommand(cardEnvironment) + sendCommand(checkWalletCommand, cardEnvironment) { checkWalletEvent -> + delegate?.closeNfcPopup() + + when (checkWalletEvent) { + is CommandEvent.Success -> { + val checkWalletResponse = checkWalletEvent.response as CheckWalletResponse + val verified = verify(walletPublickKey, + challenge + checkWalletResponse.salt, + checkWalletResponse.walletSignature, + curve) + if (verified) { + callback(ScanEvent.OnVerifyEvent(true), cardEnvironment) + } else { + callback(ScanEvent.Failure(TaskError.VefificationFailed()), cardEnvironment) + } + } + is CommandEvent.Failure -> + callback(ScanEvent.Failure(checkWalletEvent.taskError), cardEnvironment) + is CommandEvent.UserCancellation -> + callback(ScanEvent.OnUserCancelledEvent, cardEnvironment) + } + + } } - } else { - //TODO: Handle error + is CommandEvent.Failure -> + callback(ScanEvent.Failure(readCommandEvent.taskError), cardEnvironment) + is CommandEvent.UserCancellation -> + callback(ScanEvent.OnUserCancelledEvent, cardEnvironment) } } } diff --git a/tangem-card-new/src/main/java/com/tangem/tasks/Task.kt b/tangem-card-new/src/main/java/com/tangem/tasks/Task.kt index 8f98ef6d50..55683d9a6f 100644 --- a/tangem-card-new/src/main/java/com/tangem/tasks/Task.kt +++ b/tangem-card-new/src/main/java/com/tangem/tasks/Task.kt @@ -21,8 +21,8 @@ abstract class Task(protected val delegate: CardManagerDelegate? = null, priv abstract fun onRun(cardEnvironment: CardEnvironment, callback: (result: T, cardEnvironment: CardEnvironment) -> Unit) - protected fun sendCommand(commandSerializer: CommandSerializer, cardEnvironment: CardEnvironment, - callback: (result: CommandEvent) -> Unit) { + protected fun sendCommand(commandSerializer: CommandSerializer, cardEnvironment: CardEnvironment, + callback: (result: CommandEvent) -> Unit) { reader.sendApdu( commandSerializer.serialize(cardEnvironment).toBytes()) { responseApdu -> @@ -30,34 +30,21 @@ abstract class Task(protected val delegate: CardManagerDelegate? = null, priv when (responseApdu.status) { Status.ProcessCompleted, Status.Pin1Changed, Status.Pin2Changed, Status.PinsChanged -> { - val responseData = commandSerializer.deserialize(cardEnvironment, responseApdu) - - if (responseData == null) { - - } else { - callback( - CommandEvent.Success(responseData) - ) + try { + val responseData = commandSerializer.deserialize(cardEnvironment, responseApdu) + callback(CommandEvent.Success(responseData as T)) + } catch (error: TaskError) { + callback(CommandEvent.Failure(error)) } - } - Status.InvalidParams -> TODO() - Status.ErrorProcessingCommand -> TODO() - Status.InvalidState -> TODO() + Status.InvalidParams -> callback(CommandEvent.Failure(TaskError.InvalidParams())) + Status.ErrorProcessingCommand -> callback(CommandEvent.Failure(TaskError.ErrorProcessingCommand())) + Status.InvalidState -> callback(CommandEvent.Failure(TaskError.InvalidState())) - Status.InsNotSupported -> TODO() - Status.NeedEnctryption -> TODO() - Status.NeedPause -> TODO() + Status.InsNotSupported -> callback(CommandEvent.Failure(TaskError.InsNotSupported())) + Status.NeedEncryption -> callback(CommandEvent.Failure(TaskError.NeedEncryption())) + Status.NeedPause -> callback(CommandEvent.Failure(TaskError.NeedPause())) } - -// val parsedApdu = responseApdu.getTlvData() -// if (parsedApdu == null) callback.invoke(TaskResult.Error(CardError())) -// else if (!parsedApdu.statusCompleted()) { -// callback.invoke(TaskResult.Error(CardError(parsedApdu.status.code))) -// } else { -// val response = commandSerializer.deserialize(parsedApdu) -// callback.invoke(response) -// } } } } @@ -65,12 +52,18 @@ abstract class Task(protected val delegate: CardManagerDelegate? = null, priv sealed class TaskError : Exception() { class UnknownStatus(sw: Int) : TaskError() class MappingError : TaskError() + class ErrorProcessingCommand : TaskError() class InvalidState : TaskError() class InsNotSupported : TaskError() + class InvalidParams : TaskError() + class NeedEncryption : TaskError() + class NeedPause : TaskError() + class VefificationFailed : TaskError() class CardError : TaskError() class ReaderError() : TaskError() + class SerializeCommandError() : TaskError() } sealed class TaskResult { @@ -80,23 +73,22 @@ sealed class TaskResult { } - -class BasicTask( - private val commandSerializer: CommandSerializer, - delegate: CardManagerDelegate? = null, - reader: CardReader) : Task(delegate, reader) { - - override fun onRun(cardEnvironment: CardEnvironment, - callback: (result: TaskResult, cardEnvironment: CardEnvironment) -> Unit) { - sendCommand(commandSerializer, cardEnvironment) { - callback.invoke(it, updateEnvironment()) - } - } - - private fun updateEnvironment(): CardEnvironment { - //TODO: set logic of changing CardEnvironment when needed - return CardEnvironment() - } -} +//class BasicTask( +// private val commandSerializer: CommandSerializer, +// delegate: CardManagerDelegate? = null, +// reader: CardReader) : Task(delegate, reader) { +// +// override fun onRun(cardEnvironment: CardEnvironment, +// callback: (result: TaskResult, cardEnvironment: CardEnvironment) -> Unit) { +// sendCommand(commandSerializer, cardEnvironment) { +// callback.invoke(it, updateEnvironment()) +// } +// } +// +// private fun updateEnvironment(): CardEnvironment { +// //TODO: set logic of changing CardEnvironment when needed +// return CardEnvironment() +// } +//}