GiftedHacker/tangem-app-android-audited
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Updated on 2026-08-14

Browse source
This commit is contained in:
Tangem 2023-03-27 17:47:53 +03:00
parent db1299b6af
commit 9d8611cee3
19 changed files with 146 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

17
app/src/main/java/com/tangem/tap/TapApplication.kt
View file

@ -22,10 +22,10 @@ import com.tangem.domain.common.LogConfig
import com.tangem.tap.common.IntentHandler
import com.tangem.tap.common.analytics.AnalyticsFactory
import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder
import com.tangem.tap.common.analytics.filters.TopUpFilter
import com.tangem.tap.common.analytics.handlers.amplitude.AmplitudeAnalyticsHandler
import com.tangem.tap.common.analytics.handlers.appsFlyer.AppsFlyerAnalyticsHandler
import com.tangem.tap.common.analytics.handlers.firebase.FirebaseAnalyticsHandler
import com.tangem.tap.common.analytics.topup.TopUpController
import com.tangem.tap.common.chat.ChatManager
import com.tangem.tap.common.feedback.AdditionalFeedbackInfo
import com.tangem.tap.common.feedback.FeedbackManager
@ -162,10 +162,15 @@ class TapApplication : Application(), ImageLoaderFactory {
}
private fun initTopUpController() {
val topUpController = store.state.globalState.topUpController
topUpController.walletStoresManagerProvider = { walletStoresManager }
topUpController.scanResponseProvider = { store.state.globalState.scanResponse }
walletCurrenciesManager.addListener(topUpController)
val topUpController = TopUpController(
scanResponseProvider = {
store.state.globalState.scanResponse
?: store.state.globalState.onboardingState.onboardingManager?.scanResponse
},
walletStoresManagerProvider = { walletStoresManager },
topupWalletStorage = preferencesStorage.toppedUpWalletStorage,
)
store.dispatch(GlobalAction.SetTopUpController(topUpController))
}
override fun newImageLoader(): ImageLoader {
@ -194,8 +199,6 @@ class TapApplication : Application(), ImageLoaderFactory {
factory.addHandlerBuilder(AppsFlyerAnalyticsHandler.Builder())
factory.addHandlerBuilder(FirebaseAnalyticsHandler.Builder())
factory.addFilter(TopUpFilter(preferencesStorage.toppedUpWalletStorage))
val buildData = AnalyticsHandlerBuilder.Data(
application = application,
config = config,

58
app/src/main/java/com/tangem/tap/common/analytics/converters/TopUpConverter.kt
View file

@ -1,67 +1,17 @@
package com.tangem.tap.common.analytics.converters
import com.tangem.common.Converter
import com.tangem.common.extensions.isZero
import com.tangem.domain.common.CardTypesResolver
import com.tangem.tap.common.analytics.events.AnalyticsParam
import com.tangem.tap.common.analytics.events.Basic
import com.tangem.tap.common.analytics.filters.TopUpFilter
import com.tangem.tap.domain.model.WalletDataModel
import java.math.BigDecimal
/**
[REDACTED_AUTHOR]
*/
class TopUpEventConverter : Converter<TopUpEventConverter.Data, Basic.ToppedUp?> {
class TopUpEventConverter : Converter<CardTypesResolver, Basic.ToppedUp?> {
override fun convert(value: Data): Basic.ToppedUp? {
val (cardTypesResolver, walletDataModels, userWalletIdValue, isToppedUpInPast) = value
val paramCardCurrency = ParamCardCurrencyConverter().convert(cardTypesResolver) ?: return null
override fun convert(value: CardTypesResolver): Basic.ToppedUp? {
val paramCardCurrency = ParamCardCurrencyConverter().convert(value) ?: return null
val cardBalanceState = BalanceCalculator(walletDataModels).calculate().toCardBalanceState()
val filterData = TopUpFilter.Data(
walletId = userWalletIdValue,
cardBalanceState = cardBalanceState,
isToppedUpInPast = isToppedUpInPast,
)
return Basic.ToppedUp(paramCardCurrency).apply {
this.filterData = filterData
}
return Basic.ToppedUp(paramCardCurrency)
}
private fun BigDecimal.toCardBalanceState(): AnalyticsParam.CardBalanceState = when {
isZero() -> AnalyticsParam.CardBalanceState.Empty
else -> AnalyticsParam.CardBalanceState.Full
}
data class Data(
val cardTypesResolver: CardTypesResolver,
val walletDataModels: List<WalletDataModel>,
val userWalletIdValue: String,
val isToppedUpInPast: Boolean,
)
}
private interface IBalanceCalculator {
fun calculate(): BigDecimal
}
private class BalanceCalculator(
private val walletDataModels: List<WalletDataModel>,
) : IBalanceCalculator {
override fun calculate(): BigDecimal {
val singleToken = walletDataModels
.filter { it.currency.isToken() }
.firstOrNull { it.isCardSingleToken }
val totalAmount = singleToken?.status?.amount
?: walletDataModels.calculateTotalCryptoAmount()
return totalAmount
}
private fun List<WalletDataModel>.calculateTotalCryptoAmount(): BigDecimal = this
.map { it.status.amount }
.reduce(BigDecimal::plus)
}

72
app/src/main/java/com/tangem/tap/common/analytics/filters/TopUpFilter.kt
View file

@ -1,72 +0,0 @@
package com.tangem.tap.common.analytics.filters
import com.tangem.common.extensions.guard
import com.tangem.core.analytics.AnalyticsEvent
import com.tangem.core.analytics.api.AnalyticsEventFilter
import com.tangem.core.analytics.api.AnalyticsHandler
import com.tangem.tap.common.analytics.events.AnalyticsParam
import com.tangem.tap.common.analytics.events.Basic
import com.tangem.tap.common.analytics.topup.log
import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
import com.tangem.tap.persistence.ToppedUpWalletStorage
import com.tangem.tap.store
/**
[REDACTED_AUTHOR]
*/
class TopUpFilter(
private val topupWalletStorage: ToppedUpWalletStorage,
) : AnalyticsEventFilter {
override fun canBeAppliedTo(event: AnalyticsEvent): Boolean = event is Basic.ToppedUp
override fun canBeSent(event: AnalyticsEvent): Boolean {
val data = event.filterData as? Data ?: return false
if (data.isToppedUpInPast) {
log("BasicTopUpFilter: [false]: sending is blocked")
val newWalletInfo = ToppedUpWalletStorage.Companion.TopupInfo(
walletId = data.walletId,
cardBalanceState = AnalyticsParam.CardBalanceState.Full,
)
topupWalletStorage.save(newWalletInfo)
return false
}
val topupInfo = topupWalletStorage.restore(data.walletId).guard {
log("BasicTopUpFilter: [false]: sending is blocked")
val topupInfo = ToppedUpWalletStorage.Companion.TopupInfo(
walletId = data.walletId,
cardBalanceState = data.cardBalanceState,
)
topupWalletStorage.save(topupInfo)
return false
}
if (topupInfo.isToppedUp) {
log("BasicTopUpFilter: [false]: sending is blocked")
return false
}
return if (!topupInfo.isToppedUp && data.isToppedUp) {
log("BasicTopUpFilter: [TRUE]: !topupInfo.isToppedUp && data.isToppedUp")
log("BasicTopUpFilter: [TRUE]: SEND")
store.dispatchDebugErrorNotification("Topped UP sent")
topupWalletStorage.save(topupInfo.copy(cardBalanceState = AnalyticsParam.CardBalanceState.Full))
true
} else {
log("BasicTopUpFilter: [false]: sending is blocked")
false
}
}
override fun canBeConsumedByHandler(handler: AnalyticsHandler, event: AnalyticsEvent): Boolean = true
data class Data(
val walletId: String,
val cardBalanceState: AnalyticsParam.CardBalanceState,
val isToppedUpInPast: Boolean,
) {
val isToppedUp: Boolean = cardBalanceState == AnalyticsParam.CardBalanceState.Full
}
}

141
app/src/main/java/com/tangem/tap/common/analytics/topup/TopUpController.kt
View file

@ -7,6 +7,7 @@ import com.tangem.domain.common.CardTypesResolver
import com.tangem.domain.common.ScanResponse
import com.tangem.domain.common.util.UserWalletId
import com.tangem.tap.common.analytics.converters.TopUpEventConverter
import com.tangem.tap.common.analytics.events.AnalyticsParam
import com.tangem.tap.common.extensions.copy
import com.tangem.tap.domain.model.UserWallet
import com.tangem.tap.domain.model.WalletDataModel
@ -17,9 +18,10 @@ import com.tangem.tap.domain.walletCurrencies.WalletCurrenciesManager
import com.tangem.tap.domain.walletStores.WalletStoresManager
import com.tangem.tap.features.wallet.models.Currency
import com.tangem.tap.features.wallet.redux.ProgressState
import com.tangem.tap.persistence.ToppedUpWalletStorage
import com.tangem.tap.scope
import kotlinx.coroutines.launch
import timber.log.Timber
import java.math.BigDecimal
/**
[REDACTED_AUTHOR]
@ -27,27 +29,18 @@ import timber.log.Timber
class TopUpController(
var scanResponseProvider: (() -> ScanResponse?)? = null,
var walletStoresManagerProvider: (() -> WalletStoresManager)? = null,
private val topupWalletStorage: ToppedUpWalletStorage,
) : WalletCurrenciesManager.Listener {
private var hadMissedDerivations: Boolean = false
private val addedCurrencies = mutableListOf<Currency>()
override fun willUpdate(userWallet: UserWallet, currency: Currency) {
}
override fun didUpdate(userWallet: UserWallet, currency: Currency) {
tryToNotify()
tryToSend()
}
override fun willCurrenciesAdd(userWallet: UserWallet, currenciesToAdd: List<Currency>) {
addedCurrencies.addAll(currenciesToAdd.distinct())
log("addCurrencies = [${addedCurrencies.joinToString()}]")
}
override fun willCurrenciesRemove(userWallet: UserWallet, currenciesToRemove: List<Currency>) {
}
override fun willCurrencyRemove(userWallet: UserWallet, currencyToRemove: Currency) {
}
fun walletStoresChanged(walletStores: List<WalletStoreModel>) {
@ -57,46 +50,34 @@ class TopUpController(
.filterIsInstance<WalletDataModel.MissedDerivation>()
hadMissedDerivations = missedDerivations.isNotEmpty()
log("walletStoresChanged: hadMissedDerivations = [${hadMissedDerivations}]")
}
fun scanToGetDerivations() {
hadMissedDerivations = true
log("scanAndUpdateCard: hadMissedDerivations = [${hadMissedDerivations}]")
}
fun addMissingDerivations(blockchains: List<BlockchainNetwork>) {
hadMissedDerivations = blockchains.isNotEmpty()
log("addMissingDerivations: hadMissedDerivations = [${hadMissedDerivations}]")
}
fun totalBalanceStateChanged(state: ProgressState) {
log("totalBalanceStateChanged = [${state.name}]")
if (state == ProgressState.Done) {
tryToNotify()
}
if (state == ProgressState.Done) tryToSend()
}
fun loadDataSuccess() {
log("loadDataSuccess")
tryToNotify()
tryToSend()
}
private fun tryToNotify() {
if (hadMissedDerivations) {
log("tryToNotify: FAILED: derivationsCheckIsScheduled")
return
}
private fun tryToSend() {
if (hadMissedDerivations) return
val scanResponse = scanResponseProvider?.invoke() ?: return
val userWalletId = UserWalletIdBuilder.scanResponse(scanResponse).build() ?: return
val walletStoresManager = walletStoresManagerProvider?.invoke() ?: return
scope.launch {
val walletDataModels = walletStoresManager.getSync(userWalletId).flatMap { it.walletsData }
if (walletDataModels.isEmpty()) {
log("tryToNotify: FAILED: walletDataModels.size = [0]")
return@launch
}
if (walletDataModels.isEmpty()) return@launch
val isCorrectStatus = walletDataModels.any {
it.status is WalletDataModel.Loading ||
it.status is WalletDataModel.NoAccount ||
@ -104,39 +85,70 @@ class TopUpController(
it.status is WalletDataModel.MissedDerivation ||
it.status.isErrorStatus
}
if (isCorrectStatus) {
log("tryToNotify: FAILED: by status")
if (isCorrectStatus) return@launch
val isToppedUpInPast = findToppedUpCurrenciesInPast(walletDataModels).isNotEmpty()
if (isToppedUpInPast) {
val newWalletInfo = ToppedUpWalletStorage.TopupInfo(
walletId = userWalletId.stringValue,
cardBalanceState = AnalyticsParam.CardBalanceState.Full,
)
topupWalletStorage.save(newWalletInfo)
return@launch
}
notify(userWalletId, walletDataModels, scanResponse.cardTypesResolver)
val cardBalanceState = BalanceCalculator(walletDataModels).calculate().toCardBalanceState()
send(userWalletId, cardBalanceState, scanResponse.cardTypesResolver)
}
}
private fun notify(
/**
* A UserWalletId registration should be after creating wallets
*/
fun registerEmptyWallet(scanResponse: ScanResponse) {
UserWalletIdBuilder.scanResponse(scanResponse).build()?.let {
topupWalletStorage.save(
ToppedUpWalletStorage.TopupInfo(
walletId = it.stringValue,
cardBalanceState = AnalyticsParam.CardBalanceState.Empty,
),
)
}
}
fun send(
scanResponse: ScanResponse,
cardBalanceState: AnalyticsParam.CardBalanceState,
) {
UserWalletIdBuilder.scanResponse(scanResponse).build()?.let {
send(it, cardBalanceState, scanResponse.cardTypesResolver)
}
}
fun send(
userWalletId: UserWalletId,
walletDataModels: List<WalletDataModel>,
cardBalanceState: AnalyticsParam.CardBalanceState,
cardTypesResolver: CardTypesResolver,
) {
val isToppedUpInPast = findToppedUpCurrenciesInPast(walletDataModels).isNotEmpty()
log("notify: currencies from manage tokens had toppedUp in the past = [${isToppedUpInPast}]")
val data = TopUpEventConverter.Data(
cardTypesResolver = cardTypesResolver,
walletDataModels = walletDataModels,
userWalletIdValue = userWalletId.stringValue,
isToppedUpInPast = isToppedUpInPast,
)
val event = TopUpEventConverter().convert(data).guard {
log("notify: TopUpEventConverter can't convert a data to an event")
val topupInfo = topupWalletStorage.restore(userWalletId.stringValue).guard {
val topupInfo = ToppedUpWalletStorage.TopupInfo(
walletId = userWalletId.stringValue,
cardBalanceState = cardBalanceState,
)
topupWalletStorage.save(topupInfo)
return
}
if (topupInfo.isToppedUp) return
log("notify: Analytics.send(event)")
Analytics.send(event)
if (!topupInfo.isToppedUp && cardBalanceState.isToppedUp()) {
topupWalletStorage.save(topupInfo.copy(cardBalanceState = AnalyticsParam.CardBalanceState.Full))
TopUpEventConverter().convert(cardTypesResolver)?.let {
Analytics.send(it)
}
}
}
private fun findToppedUpCurrenciesInPast(walletDataModels: List<WalletDataModel>): List<WalletDataModel> {
log("findToppedUpCurrenciesInPast: added new currencies = [${addedCurrencies.size}]")
val currenciesToppedUpInPast = addedCurrencies.copy()
.mapNotNull { currency ->
val foundCurrencyModel = walletDataModels
@ -149,8 +161,35 @@ class TopUpController(
return currenciesToppedUpInPast
}
private fun BigDecimal.toCardBalanceState(): AnalyticsParam.CardBalanceState = when {
isZero() -> AnalyticsParam.CardBalanceState.Empty
else -> AnalyticsParam.CardBalanceState.Full
}
private fun AnalyticsParam.CardBalanceState.isToppedUp(): Boolean = this == AnalyticsParam.CardBalanceState.Full
}
fun log(log: String) {
Timber.d("TopUp: %s", log)
private interface IBalanceCalculator {
fun calculate(): BigDecimal
}
private class BalanceCalculator(
private val walletDataModels: List<WalletDataModel>,
) : IBalanceCalculator {
override fun calculate(): BigDecimal {
val singleToken = walletDataModels
.filter { it.currency.isToken() }
.firstOrNull { it.isCardSingleToken }
val totalAmount = singleToken?.status?.amount
?: walletDataModels.calculateTotalCryptoAmount()
return totalAmount
}
private fun List<WalletDataModel>.calculateTotalCryptoAmount(): BigDecimal = this
.map { it.status.amount }
.reduce(BigDecimal::plus)
}

2
app/src/main/java/com/tangem/tap/common/redux/global/GlobalAction.kt
View file

@ -7,6 +7,7 @@ import com.tangem.common.core.TangemError
import com.tangem.datasource.config.ConfigManager
import com.tangem.datasource.config.models.ChatConfig
import com.tangem.domain.common.ScanResponse
import com.tangem.tap.common.analytics.topup.TopUpController
import com.tangem.tap.common.entities.FiatCurrency
import com.tangem.tap.common.feedback.FeedbackData
import com.tangem.tap.common.feedback.FeedbackManager
@ -88,6 +89,7 @@ sealed class GlobalAction : Action {
data class SetConfigManager(val configManager: ConfigManager) : GlobalAction()
data class SetWarningManager(val warningManager: WarningMessagesManager) : GlobalAction()
data class SetFeedbackManager(val feedbackManager: FeedbackManager) : GlobalAction()
data class SetTopUpController(val topUpController: TopUpController) : GlobalAction()
data class SendEmail(val feedbackData: FeedbackData) : GlobalAction()
data class OpenChat(val feedbackData: FeedbackData, val chatConfig: ChatConfig? = null) : GlobalAction()

4
app/src/main/java/com/tangem/tap/common/redux/global/GlobalMiddleware.kt
View file

@ -32,6 +32,7 @@ import com.tangem.tap.scope
import com.tangem.tap.store
import com.tangem.tap.tangemSdkManager
import com.tangem.tap.userTokensRepository
import com.tangem.tap.walletCurrenciesManager
import com.tangem.wallet.BuildConfig
import kotlinx.coroutines.launch
import org.rekotlin.Action
@ -194,6 +195,9 @@ private fun handleAction(action: Action, appState: () -> AppState?, dispatch: Di
}
}
}
is GlobalAction.SetTopUpController -> {
walletCurrenciesManager.addListener(action.topUpController)
}
}
}

1
app/src/main/java/com/tangem/tap/common/redux/global/GlobalReducer.kt
View file

@ -49,6 +49,7 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
globalState.copy(configManager = action.configManager)
}
is GlobalAction.SetWarningManager -> globalState.copy(warningManager = action.warningManager)
is GlobalAction.SetTopUpController -> globalState.copy(topUpController = action.topUpController)
is GlobalAction.UpdateWalletSignedHashes -> {
val card = globalState.scanResponse?.card ?: return globalState
val wallet = card.wallets

2
app/src/main/java/com/tangem/tap/common/redux/global/GlobalState.kt
View file

@ -29,7 +29,7 @@ data class GlobalState(
val exchangeManager: CurrencyExchangeManager = CurrencyExchangeManager.dummy(),
val userCountryCode: String? = null,
val userWalletsListManager: UserWalletsListManager? = null,
val topUpController: TopUpController = TopUpController(),
val topUpController: TopUpController? = null,
) : StateType
typealias CryptoCurrencyName = String

2
app/src/main/java/com/tangem/tap/domain/TapWalletManager.kt
View file

@ -66,7 +66,7 @@ class TapWalletManager {
.doOnSuccess {
Timber.d("Wallet stores fetched for ${userWallet.walletId}")
store.dispatchOnMain(WalletAction.LoadData.Success)
store.state.globalState.topUpController.loadDataSuccess()
store.state.globalState.topUpController?.loadDataSuccess()
}
.doOnFailure { error ->
val errorAction = when (error) {

10
app/src/main/java/com/tangem/tap/domain/walletCurrencies/WalletCurrenciesManager.kt
View file

@ -87,11 +87,11 @@ interface WalletCurrenciesManager {
* Interface definition for a callbacks
*/
interface Listener {
fun willUpdate(userWallet: UserWallet, currency: Currency)
fun didUpdate(userWallet: UserWallet, currency: Currency)
fun willCurrenciesAdd(userWallet: UserWallet, currenciesToAdd: List<Currency>)
fun willCurrenciesRemove(userWallet: UserWallet, currenciesToRemove: List<Currency>)
fun willCurrencyRemove(userWallet: UserWallet, currencyToRemove: Currency)
fun willUpdate(userWallet: UserWallet, currency: Currency) {}
fun didUpdate(userWallet: UserWallet, currency: Currency) {}
fun willCurrenciesAdd(userWallet: UserWallet, currenciesToAdd: List<Currency>) {}
fun willCurrenciesRemove(userWallet: UserWallet, currenciesToRemove: List<Currency>) {}
fun willCurrencyRemove(userWallet: UserWallet, currencyToRemove: Currency) {}
}
// For provider

18
app/src/main/java/com/tangem/tap/features/onboarding/products/note/redux/OnboardingNoteMiddleware.kt
View file

@ -6,7 +6,6 @@ import com.tangem.core.analytics.Analytics
import com.tangem.domain.common.extensions.withMainContext
import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
import com.tangem.tap.common.analytics.events.AnalyticsParam
import com.tangem.tap.common.analytics.events.Basic
import com.tangem.tap.common.analytics.events.Onboarding
import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
import com.tangem.tap.common.extensions.dispatchDialogShow
@ -98,7 +97,7 @@ private fun handleNoteAction(appState: () -> AppState?, action: Action, dispatch
onboardingManager.activationFinished(card.cardId)
postUi(DELAY_SDK_DIALOG_CLOSE) { store.dispatch(OnboardingNoteAction.Confetti.Show) }
}
else -> {}
else -> Unit
}
}
is OnboardingNoteAction.CreateWallet -> {
@ -111,11 +110,10 @@ private fun handleNoteAction(appState: () -> AppState?, action: Action, dispatch
val updatedResponse = scanResponse.copy(card = result.data.card)
onboardingManager.scanResponse = updatedResponse
onboardingManager.activationStarted(updatedResponse.card.cardId)
store.state.globalState.topUpController?.registerEmptyWallet(updatedResponse)
store.dispatch(OnboardingNoteAction.SetStepOfScreen(OnboardingNoteStep.TopUpWallet))
}
is CompletionResult.Failure -> {
// do nothing
}
is CompletionResult.Failure -> Unit
}
}
}
@ -160,15 +158,7 @@ private fun handleNoteAction(appState: () -> AppState?, action: Action, dispatch
}
is OnboardingNoteAction.Balance.Set -> {
if (action.balance.balanceIsToppedUp()) {
Analytics.send(
event = Basic.ToppedUp(
currency = AnalyticsParam.CardCurrency.SingleCurrency(
type = AnalyticsParam.CurrencyType.Blockchain(
blockchain = scanResponse.cardTypesResolver.getBlockchain(),
),
),
),
)
store.state.globalState.topUpController?.send(scanResponse, AnalyticsParam.CardBalanceState.Full)
store.dispatch(OnboardingNoteAction.SetStepOfScreen(OnboardingNoteStep.Done))
}
}

1
app/src/main/java/com/tangem/tap/features/onboarding/products/otherCards/redux/OnboardingOtherCardsMiddleware.kt
View file

@ -87,6 +87,7 @@ private fun handleOtherCardsAction(action: Action) {
val updatedCard = updatedResponse.card
onboardingManager.scanResponse = updatedResponse
onboardingManager.activationStarted(updatedCard.cardId)
store.state.globalState.topUpController?.registerEmptyWallet(updatedResponse)
val primaryBlockchain = updatedResponse.cardTypesResolver.getBlockchain()
val blockchainNetworks = if (primaryBlockchain != Blockchain.Unknown) {

17
app/src/main/java/com/tangem/tap/features/onboarding/products/twins/redux/TwinCardsMiddleware.kt
View file

@ -8,7 +8,6 @@ import com.tangem.domain.common.ScanResponse
import com.tangem.domain.common.extensions.withMainContext
import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
import com.tangem.tap.common.analytics.events.AnalyticsParam
import com.tangem.tap.common.analytics.events.Basic
import com.tangem.tap.common.analytics.events.Onboarding
import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
import com.tangem.tap.common.extensions.dispatchDialogShow
@ -206,6 +205,8 @@ private fun handle(action: Action, dispatch: DispatchFunction) {
is Result.Success -> {
Analytics.send(Onboarding.Twins.SetupFinished())
updateScanResponse(result.data)
store.state.globalState.topUpController?.registerEmptyWallet(result.data)
delay(DELAY_SDK_DIALOG_CLOSE)
withMainContext {
when (twinCardsState.mode) {
@ -262,18 +263,8 @@ private fun handle(action: Action, dispatch: DispatchFunction) {
}
is TwinCardsAction.Balance.Set -> {
if (action.balance.balanceIsToppedUp()) {
Analytics.send(
event = Basic.ToppedUp(
currency = AnalyticsParam.CardCurrency.SingleCurrency(
type = AnalyticsParam.CurrencyType.Blockchain(
blockchain = getScanResponse().cardTypesResolver.getBlockchain(),
),
),
),
)
scope.launch {
withMainContext { store.dispatch(TwinCardsAction.SetStepOfScreen(TwinCardsStep.Done)) }
}
store.state.globalState.topUpController?.send(getScanResponse(), AnalyticsParam.CardBalanceState.Full)
store.dispatchOnMain(TwinCardsAction.SetStepOfScreen(TwinCardsStep.Done))
}
}
is TwinCardsAction.ShowAddressInfoDialog -> {

21
app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
View file

@ -127,6 +127,7 @@ private fun handleWalletAction(action: Action, state: () -> AppState?, dispatch:
primaryCard = result.data.primaryCard,
)
onboardingManager.scanResponse = updatedResponse
store.state.globalState.topUpController?.registerEmptyWallet(updatedResponse)
val blockchainNetworks = if (DemoHelper.isDemoCardId(result.data.card.cardId)) {
DemoHelper.config.demoBlockchains
@ -145,9 +146,7 @@ private fun handleWalletAction(action: Action, state: () -> AppState?, dispatch:
startCardActivation(updatedResponse)
store.dispatch(OnboardingWalletAction.ResumeBackup)
}
is CompletionResult.Failure -> {
// do nothing
}
is CompletionResult.Failure -> Unit
}
}
}
@ -190,7 +189,7 @@ private fun handleWalletAction(action: Action, state: () -> AppState?, dispatch:
newAction?.let { store.dispatch(it) }
}
OnboardingWalletAction.OnBackPressed -> handleOnBackPressed(onboardingWalletState)
else -> {}
else -> Unit
}
}
@ -249,8 +248,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
is CompletionResult.Success -> {
store.dispatchOnMain(BackupAction.StartAddingBackupCards)
}
is CompletionResult.Failure -> {
}
is CompletionResult.Failure -> Unit
}
}
}
@ -267,8 +265,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
is CompletionResult.Success -> {
store.dispatchOnMain(BackupAction.AddBackupCard.Success)
}
is CompletionResult.Failure -> {
}
is CompletionResult.Failure -> Unit
}
}
}
@ -308,8 +305,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
is CompletionResult.Success -> {
store.dispatchOnMain(BackupAction.PrepareToWriteBackupCard(1))
}
is CompletionResult.Failure -> {
}
is CompletionResult.Failure -> Unit
}
}
}
@ -324,8 +320,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
store.dispatchOnMain(BackupAction.PrepareToWriteBackupCard(action.cardNumber + 1))
}
}
is CompletionResult.Failure -> {
}
is CompletionResult.Failure -> Unit
}
}
}
@ -375,7 +370,7 @@ private fun handleBackupAction(appState: () -> AppState?, action: BackupAction)
Analytics.send(Onboarding.Finished())
finishCardActivation(notActivatedCardIds)
}
else -> {}
else -> Unit
}
}

4
app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt
View file

@ -91,14 +91,14 @@ class MultiWalletMiddleware {
store.dispatch(NavigationAction.NavigateTo(AppScreen.OnboardingWallet))
}
is WalletAction.MultiWallet.AddMissingDerivations -> {
store.state.globalState.topUpController.addMissingDerivations(action.blockchains)
store.state.globalState.topUpController?.addMissingDerivations(action.blockchains)
}
is WalletAction.MultiWallet.ScanToGetDerivations -> {
val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
Timber.e("Unable to scan to get derivations, no user wallet selected")
return
}
store.state.globalState.topUpController.scanToGetDerivations()
store.state.globalState.topUpController?.scanToGetDerivations()
scanAndUpdateCard(selectedUserWallet, walletState)
}
else -> {}

2
app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt
View file

@ -184,7 +184,7 @@ class WalletMiddleware {
}
is WalletAction.UserWalletChanged -> Unit
is WalletAction.WalletStoresChanged -> {
store.state.globalState.topUpController.walletStoresChanged(action.walletStores)
store.state.globalState.topUpController?.walletStoresChanged(action.walletStores)
updateWalletStores(action.walletStores, walletState)
fetchTotalFiatBalance(action.walletStores)
findMissedDerivations(action.walletStores)

2
app/src/main/java/com/tangem/tap/features/wallet/ui/WalletFragment.kt
View file

@ -67,7 +67,7 @@ class WalletFragment : Fragment(R.layout.fragment_wallet), StoreSubscriber<Walle
private val totalBalanceWatcher = modelWatcher {
(WalletState::totalBalance) { totalBalance ->
totalBalance?.state?.let {
store.state.globalState.topUpController.totalBalanceStateChanged(it)
store.state.globalState.topUpController?.totalBalanceStateChanged(it)
}
}
}

14
app/src/main/java/com/tangem/tap/persistence/ToppedUpWalletStorage.kt
View file

@ -53,14 +53,14 @@ class ToppedUpWalletStorage(
}
}
data class TopupInfo(
val walletId: String,
val cardBalanceState: AnalyticsParam.CardBalanceState,
) {
val isToppedUp: Boolean = cardBalanceState == AnalyticsParam.CardBalanceState.Full
}
companion object {
private const val KEY = "userWalletsInfo"
data class TopupInfo(
val walletId: String,
val cardBalanceState: AnalyticsParam.CardBalanceState,
) {
val isToppedUp: Boolean = cardBalanceState == AnalyticsParam.CardBalanceState.Full
}
}
}

1
core/analytics/src/main/java/com/tangem/core/analytics/AnalyticsEvent.kt
View file

@ -8,5 +8,4 @@ open class AnalyticsEvent(
val event: String,
var params: Map<String, String> = mapOf(),
val error: Throwable? = null,
var filterData: Any? = null,
)