From d3a6ddbc379d8352eacede9b49dcbbc8106c8409 Mon Sep 17 00:00:00 2001 From: moon <56061215+MgKyawLay@users.noreply.github.com> Date: Tue, 12 May 2026 15:41:41 +0630 Subject: [PATCH] card reader setup --- .idea/misc.xml | 2 +- app/build.gradle.kts | 20 +- app/src/main/AndroidManifest.xml | 29 +- .../java/com/mob/utsmyanmar/MainActivity.kt | 2 + .../java/com/mob/utsmyanmar/MyApplication.kt | 13 + .../utsmyanmar/model/CardTransactionType.kt | 5 + .../com/mob/utsmyanmar/model/ProcessCode.kt | 39 + .../mob/utsmyanmar/model/SettlementType.kt | 6 + .../mob/utsmyanmar/model/TransResultStatus.kt | 29 + .../utsmyanmar/model/ecr/ECRResultStatus.kt | 7 + .../mob/utsmyanmar/ui/amount/AmountScreen.kt | 2 +- .../ui/cardwaiting/CardWaitingEvent.kt | 9 + .../ui/cardwaiting/CardWaitingScreen.kt | 93 ++ .../ui/cardwaiting/CardWaitingUiState.kt | 7 + .../ui/cardwaiting/CardWaitingViewModel.kt | 293 +++++ .../utsmyanmar/ui/navigation/AppNavGraph.kt | 39 +- .../mob/utsmyanmar/ui/navigation/Routes.kt | 1 + .../mob/utsmyanmar/utils/AppContextHolder.kt | 15 + .../com/mob/utsmyanmar/utils/CoreUtils.kt | 1037 +++++++++++++++++ .../com/mob/utsmyanmar/utils/ECRSetups.kt | 17 + .../com/mob/utsmyanmar/utils/ECRSetupsCMHL.kt | 24 + .../com/mob/utsmyanmar/utils/OldECRSetups.kt | 14 + .../viewmodel/CardReaderViewModel.kt | 152 +++ .../viewmodel/ProcessingTransaction.kt | 25 + .../utsmyanmar/viewmodel/SharedViewModel.kt | 476 ++++++++ .../viewmodel/TransProcessViewModel.kt | 346 ++++++ .../utsmyanmar/baselib/BaseApplication.java | 9 +- baselib/src/main/res/values/colors.xml | 4 +- build.gradle.kts | 3 +- gradle/libs.versions.toml | 11 +- .../results.bin | 1 + .../mpulib-1.2-runtime_dex/classes.dex | Bin 0 -> 22580 bytes .../results.bin | 1 + .../classes.dex | Bin 0 -> 367352 bytes .../results.bin | 1 + .../classes.dex | Bin 0 -> 367352 bytes .../results.bin | 1 + .../sunmiui-1.1.27-runtime_dex/classes.dex | Bin 0 -> 76564 bytes .../results.bin | 1 + .../sunmiui-1.1.27-runtime_dex/classes.dex | Bin 0 -> 76564 bytes .../src/main/java/com/kizzy/xpay/util/Sign.kt | 3 +- 41 files changed, 2723 insertions(+), 14 deletions(-) create mode 100644 app/src/main/java/com/mob/utsmyanmar/MyApplication.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/model/CardTransactionType.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/model/ProcessCode.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/model/SettlementType.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/model/TransResultStatus.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/model/ecr/ECRResultStatus.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingEvent.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingScreen.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingUiState.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingViewModel.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/utils/AppContextHolder.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/utils/CoreUtils.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/utils/ECRSetups.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/utils/ECRSetupsCMHL.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/utils/OldECRSetups.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/viewmodel/CardReaderViewModel.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/viewmodel/ProcessingTransaction.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/viewmodel/SharedViewModel.kt create mode 100644 app/src/main/java/com/mob/utsmyanmar/viewmodel/TransProcessViewModel.kt create mode 100644 mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/results.bin create mode 100644 mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/transformed/mpulib-1.2-runtime/mpulib-1.2-runtime_dex/classes.dex create mode 100644 paysdk-lib/build/.transforms/062ef812db3ec2ffd42a09209f2c2a5e/results.bin create mode 100644 paysdk-lib/build/.transforms/062ef812db3ec2ffd42a09209f2c2a5e/transformed/PayLib-release-1.4.64-runtime/PayLib-release-1.4.64-runtime_dex/classes.dex create mode 100644 paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/results.bin create mode 100644 paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/transformed/PayLib-release-1.4.64-runtime/PayLib-release-1.4.64-runtime_dex/classes.dex create mode 100644 sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/results.bin create mode 100644 sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/transformed/sunmiui-1.1.27-runtime/sunmiui-1.1.27-runtime_dex/classes.dex create mode 100644 sunmiui-lib/build/.transforms/b3f7de568906871cda6fe2f5fb4f398e/results.bin create mode 100644 sunmiui-lib/build/.transforms/b3f7de568906871cda6fe2f5fb4f398e/transformed/sunmiui-1.1.27-runtime/sunmiui-1.1.27-runtime_dex/classes.dex diff --git a/.idea/misc.xml b/.idea/misc.xml index 991a888..74dd639 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,7 +1,7 @@ - + diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 19a4a97..cdbb89a 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -1,6 +1,8 @@ plugins { alias(libs.plugins.android.application) alias(libs.plugins.kotlin.compose) + id("com.google.devtools.ksp") + id("com.google.dagger.hilt.android") } android { @@ -44,10 +46,12 @@ dependencies { implementation(libs.androidx.activity.compose) implementation(libs.androidx.compose.foundation) implementation(libs.androidx.compose.material3) + implementation(libs.androidx.compose.runtime) implementation(libs.androidx.compose.ui) implementation(libs.androidx.compose.ui.graphics) implementation(libs.androidx.compose.ui.tooling.preview) implementation(libs.androidx.core.ktx) + implementation(libs.androidx.hilt.navigation.compose) implementation(libs.androidx.lifecycle.runtime.ktx) implementation(libs.androidx.navigation.compose) testImplementation(libs.junit) @@ -57,4 +61,18 @@ dependencies { androidTestImplementation(libs.androidx.junit) debugImplementation(libs.androidx.compose.ui.test.manifest) debugImplementation(libs.androidx.compose.ui.tooling) -} \ No newline at end of file + implementation("com.google.dagger:hilt-android:2.59.2") + ksp(libs.hilt.android.compiler) + implementation(libs.rxjava) + implementation(libs.rxandroid) + // local libs + implementation(project(":baselib")) + implementation(project(":mpulib")) + implementation(project(":paylibs")) + implementation(project(":paysdk-lib")) + implementation(project(":qrgen-lib")) + implementation(project(":sunmiui-lib")) + implementation(project(":ecr")) + implementation(project(":xpay")) + implementation(project(":cmhl")) +} diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 4bee6fe..72b5544 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -2,7 +2,32 @@ + + + + + + + + + + + + + + + + + + + @@ -24,4 +49,4 @@ - \ No newline at end of file + diff --git a/app/src/main/java/com/mob/utsmyanmar/MainActivity.kt b/app/src/main/java/com/mob/utsmyanmar/MainActivity.kt index eac96a8..175edf1 100644 --- a/app/src/main/java/com/mob/utsmyanmar/MainActivity.kt +++ b/app/src/main/java/com/mob/utsmyanmar/MainActivity.kt @@ -7,7 +7,9 @@ import androidx.activity.enableEdgeToEdge import androidx.navigation.compose.rememberNavController import com.mob.utsmyanmar.ui.navigation.AppNavGraph import com.mob.utsmyanmar.ui.theme.MOBPOSTheme +import dagger.hilt.android.AndroidEntryPoint +@AndroidEntryPoint class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) diff --git a/app/src/main/java/com/mob/utsmyanmar/MyApplication.kt b/app/src/main/java/com/mob/utsmyanmar/MyApplication.kt new file mode 100644 index 0000000..d9dd889 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/MyApplication.kt @@ -0,0 +1,13 @@ +package com.mob.utsmyanmar + +import com.mob.utsmyanmar.utils.AppContextHolder +import com.utsmyanmar.baselib.BaseApplication +import dagger.hilt.android.HiltAndroidApp + +@HiltAndroidApp +class MyApplication : BaseApplication() { + override fun onCreate() { + super.onCreate() + AppContextHolder.init(this) + } +} diff --git a/app/src/main/java/com/mob/utsmyanmar/model/CardTransactionType.kt b/app/src/main/java/com/mob/utsmyanmar/model/CardTransactionType.kt new file mode 100644 index 0000000..dc45ff9 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/model/CardTransactionType.kt @@ -0,0 +1,5 @@ +package com.mob.utsmyanmar.model + +enum class CardTransactionType { + MPU, EMV, MAG, FALLBACK +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/model/ProcessCode.kt b/app/src/main/java/com/mob/utsmyanmar/model/ProcessCode.kt new file mode 100644 index 0000000..dd257f5 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/model/ProcessCode.kt @@ -0,0 +1,39 @@ +package com.mob.utsmyanmar.model + +object ProcessCode { + const val BALANCE_INQUIRY = "31" + + const val SALE_PURCHASE = "00" + + const val SALE_VOID = "02" + + const val PRE_AUTH_SALE = "30" + + const val PRE_AUTH_VOID = "30" + + const val PRE_AUTH_COMPLETE = "30" + + const val PRE_AUTH_COMPLETE_VOID = "30" + + const val CASH_ADVANCE = "01" // 01-MPU 17-TTIP + + const val FUND_TRANSFER = "61" + + const val PIN_CHANGE = "70" + + const val SETTLEMENT = "92" + + const val SIGN_ON = "95" + + const val CASH_DEPOSIT = "21" + + const val REFUND = "20" + + const val SMART = "00" + + const val SAVING = "10" + + const val CURRENT = "20" + + const val TO_ACCOUNT = "00" +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/model/SettlementType.kt b/app/src/main/java/com/mob/utsmyanmar/model/SettlementType.kt new file mode 100644 index 0000000..5501a2e --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/model/SettlementType.kt @@ -0,0 +1,6 @@ +package com.mob.utsmyanmar.model + +enum class SettlementType { + NORMAL, + CUT_OVER +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/model/TransResultStatus.kt b/app/src/main/java/com/mob/utsmyanmar/model/TransResultStatus.kt new file mode 100644 index 0000000..1ac3aaf --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/model/TransResultStatus.kt @@ -0,0 +1,29 @@ +package com.mob.utsmyanmar.model + +enum class TransResultStatus { + CLICK_CONFIRM, + SUCCESS, + FAIL, + OFFLINE_SUCCESS, + OFFLINE_FAILURE, + SECONDARY, + REVERSAL_PROCESS, + REVERSAL_PREPARE, + REVERSAL_SECONDARY, + REVERSAL_THIRD, + REVERSAL_FAIL, + REVERSAL_SUCCESS, + BEFORE_REVERSAL, + PIN_PAD_CANCEL, + PIN_PAD_CONFIRM, + PIN_PAD_ERROR, + PIN_MISMATCH, + PIN_MISMATCH_END, + REMOVED_CARD, + EMV_ERROR, + ERROR, + RETRY_AGAIN, + NEXT_SCREEN, + EMPTY_PIN, + NETWORK_ERROR +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/model/ecr/ECRResultStatus.kt b/app/src/main/java/com/mob/utsmyanmar/model/ecr/ECRResultStatus.kt new file mode 100644 index 0000000..626966c --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/model/ecr/ECRResultStatus.kt @@ -0,0 +1,7 @@ +package com.mob.utsmyanmar.model.ecr + +enum class ECRResultStatus { + USER_CANCEL, + TIME_OUT, + RESPONSE_RECEIVED +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/amount/AmountScreen.kt b/app/src/main/java/com/mob/utsmyanmar/ui/amount/AmountScreen.kt index daa1296..7ec23c6 100644 --- a/app/src/main/java/com/mob/utsmyanmar/ui/amount/AmountScreen.kt +++ b/app/src/main/java/com/mob/utsmyanmar/ui/amount/AmountScreen.kt @@ -137,7 +137,7 @@ fun AmountScreen( ) ) { Text( - text = "Next", + text = "Enter", fontSize = 20.sp, fontWeight = FontWeight.Bold ) diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingEvent.kt b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingEvent.kt new file mode 100644 index 0000000..6eca267 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingEvent.kt @@ -0,0 +1,9 @@ +package com.mob.utsmyanmar.ui.cardwaiting + +sealed interface CardWaitingEvent { + data object GoManualEntry : CardWaitingEvent + data object GoProcessingCard : CardWaitingEvent + data object GoTimeout : CardWaitingEvent + data object GoMain : CardWaitingEvent + data object GoBack : CardWaitingEvent +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingScreen.kt b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingScreen.kt new file mode 100644 index 0000000..6d41a0a --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingScreen.kt @@ -0,0 +1,93 @@ +package com.mob.utsmyanmar.ui.cardwaiting + +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.mob.utsmyanmar.ui.theme.White + +@Composable +fun CardWaitingScreen( + viewModel: CardWaitingViewModel, + onManualEntry: () -> Unit, + onProcessingCard: () -> Unit, + onTimeout: () -> Unit, + onBack: () -> Unit, + onMain: () -> Unit +) { + val uiState by viewModel.uiState.collectAsState() + + LaunchedEffect(viewModel) { + viewModel.events.collect { event -> + when (event) { + CardWaitingEvent.GoManualEntry -> onManualEntry() + CardWaitingEvent.GoProcessingCard -> onProcessingCard() + CardWaitingEvent.GoTimeout -> onTimeout() + CardWaitingEvent.GoMain -> onMain() + CardWaitingEvent.GoBack -> onBack() + } + } + } + + LaunchedEffect(viewModel) { + viewModel.onScreenResume() + } + + DisposableEffect(viewModel) { + onDispose { + viewModel.onScreenPause() + } + } + + BackHandler { + viewModel.onBackPressed() + } + + Column( + modifier = Modifier + .fillMaxSize() + .background(White) + .padding(24.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Card Capture", + fontSize = 22.sp, + fontWeight = FontWeight.Bold + ) + + Spacer(modifier = Modifier.height(40.dp)) + + Text( + text = uiState.alertMessage, + fontSize = 20.sp, + textAlign = TextAlign.Center + ) + + Spacer(modifier = Modifier.weight(1f)) + + Button( + onClick = viewModel::onManualEntryClick, + modifier = Modifier.fillMaxWidth() + ) { + Text("Manual Entry") + } + } +} diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingUiState.kt b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingUiState.kt new file mode 100644 index 0000000..3739754 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingUiState.kt @@ -0,0 +1,7 @@ +package com.mob.utsmyanmar.ui.cardwaiting + +data class CardWaitingUiState( + val alertMessage: String = "Please insert, tap, or swipe card", + val isLoading: Boolean = false, + val isFallback: Boolean = false +) \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingViewModel.kt b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingViewModel.kt new file mode 100644 index 0000000..3f63ef9 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/ui/cardwaiting/CardWaitingViewModel.kt @@ -0,0 +1,293 @@ +package com.mob.utsmyanmar.ui.cardwaiting + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import com.mob.utsmyanmar.model.CardTransactionType +import com.mob.utsmyanmar.model.ecr.ECRResultStatus +import com.mob.utsmyanmar.utils.CoreUtils +import com.mob.utsmyanmar.viewmodel.CardReaderViewModel +import com.mob.utsmyanmar.viewmodel.SharedViewModel +import com.sunmi.pay.hardware.aidl.AidlConstants +import com.utsmyanmar.checkxread.checkcard.CheckCardResultX +import com.utsmyanmar.checkxread.util.CardTypeX +import com.utsmyanmar.ecr.ECRHelper +import com.utsmyanmar.paylibs.utils.core_utils.SystemParamsOperation +import com.utsmyanmar.paylibs.utils.iso_utils.TransactionsType +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.channels.Channel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.receiveAsFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch + +class CardWaitingViewModel( + private val cardReadViewModel: CardReaderViewModel, + private val sharedViewModel: SharedViewModel +) : ViewModel() { + + companion object { + fun provideFactory( + cardReadViewModel: CardReaderViewModel, + sharedViewModel: SharedViewModel + ): ViewModelProvider.Factory { + return object : ViewModelProvider.Factory { + @Suppress("UNCHECKED_CAST") + override fun create(modelClass: Class): T { + return CardWaitingViewModel( + cardReadViewModel = cardReadViewModel, + sharedViewModel = sharedViewModel + ) as T + } + } + } + } + + private val _uiState = MutableStateFlow(CardWaitingUiState()) + val uiState = _uiState.asStateFlow() + + private val _events = Channel() + val events = _events.receiveAsFlow() + + private var retryCounter = 0 + private var fallbackCounter = 0 + private var fallbackEnabled = false + private var readerInitJob: Job? = null + + fun onScreenResume() { + retryCounter = 0 + fallbackCounter = SystemParamsOperation.getInstance().fallbackCounter + fallbackEnabled = SystemParamsOperation.getInstance().fallbackEnabled + + if (sharedViewModel.transactionsType.value == TransactionsType.REFUND) { + sharedViewModel.enableCardStatusIcon(false, false, false, false) + } else { + sharedViewModel.enableCardStatusIcon(true, true, true, false) + } + + val isFallback = sharedViewModel.getIsFallback().value == true + if (isFallback) { + _uiState.update { + it.copy( + alertMessage = "Fallback!\nPlease stripe!", + isFallback = true + ) + } + } + + startCardReadWhenReady(isFallback) + } + + fun onScreenPause() { + readerInitJob?.cancel() + stopCardReading() + } + + fun onBackPressed() { + if (sharedViewModel.isEcr.value == true) { + sharedViewModel.isEcr.postValue(false) + CoreUtils.getInstance(sharedViewModel).responseRejectMsg("Transaction cancelled") + sharedViewModel.isEcrFinished.postValue(true) + } + + stopCardReading() + + viewModelScope.launch { + _events.send(CardWaitingEvent.GoBack) + } + } + + fun onManualEntryClick() { + viewModelScope.launch { + _events.send(CardWaitingEvent.GoManualEntry) + } + } + + private fun startCardReadWhenReady(isFallback: Boolean) { + readerInitJob?.cancel() + readerInitJob = viewModelScope.launch { + if (cardReadViewModel.isReaderReady()) { + setupCardReadProcess(isFallback) + return@launch + } + + _uiState.update { + it.copy( + alertMessage = "Initializing card reader...", + isLoading = true + ) + } + + repeat(10) { + delay(300) + if (cardReadViewModel.isReaderReady()) { + _uiState.update { state -> + state.copy( + alertMessage = if (isFallback) { + "Fallback!\nPlease stripe!" + } else { + "Please insert, tap, or swipe card" + }, + isLoading = false + ) + } + setupCardReadProcess(isFallback) + return@launch + } + } + + _uiState.update { + it.copy( + alertMessage = "Card reader unavailable.\nPlease wait and try again.", + isLoading = false + ) + } + } + } + + private fun setupCardReadProcess(isFallback: Boolean) { + initCheckCard(isFallback) + } + + private fun initCheckCard(isFallback: Boolean) { + var allType = + AidlConstants.CardType.NFC.value or + AidlConstants.CardType.IC.value or + AidlConstants.CardType.MAGNETIC.value + + if (isFallback) { + allType = AidlConstants.CardType.MAGNETIC.value + } else if ( + SystemParamsOperation.getInstance().isMagStripeEnabled && + !SystemParamsOperation.getInstance().isNfcEnabled + ) { + allType = + AidlConstants.CardType.IC.value or + AidlConstants.CardType.MAGNETIC.value + } + + cardReadViewModel.startCheckXProcess( + allType, + 65, + object : CheckCardResultX { + override fun onSuccess(cardType: CardTypeX, isMPU: Boolean) { + when { + !isFallback && cardType == CardTypeX.MAG -> { + if (SystemParamsOperation.getInstance().isMagStripeEnabled) { + cardReadViewModel.setCardTransactionType(CardTransactionType.MAG) + } else { + _uiState.update { + it.copy(alertMessage = "Mag stripe not allowed") + } + setupCardReadProcess(false) + return + } + } + + isFallback && cardType == CardTypeX.MAG -> { + sharedViewModel.setEmvTrans(false) + cardReadViewModel.setCardTransactionType(CardTransactionType.FALLBACK) + } + + cardType == CardTypeX.IC || cardType == CardTypeX.NFC -> { + if (isMPU) { + sharedViewModel.setEmvTrans(false) + cardReadViewModel.setCardTransactionType(CardTransactionType.MPU) + } else { + cardReadViewModel.setCardData(cardType.value) + cardReadViewModel.setCardTransactionType(CardTransactionType.EMV) + } + } + } + + viewModelScope.launch { + _events.send(CardWaitingEvent.GoProcessingCard) + } + } + + override fun onError(code: Int, message: String) { + ecrActionCancel("Transaction cancelled") + + viewModelScope.launch { + _uiState.update { + it.copy( + alertMessage = message, + isLoading = false + ) + } + _events.send(CardWaitingEvent.GoMain) + } + } + + override fun onCommError() { + if (fallbackEnabled && retryCounter < fallbackCounter) { + _uiState.update { + it.copy( + alertMessage = "Card not detected!\nRemain Attempt - ${fallbackCounter - retryCounter}" + ) + } + retryCounter++ + setupCardReadProcess(false) + return + } + + if (retryCounter == fallbackCounter) { + _uiState.update { + it.copy(alertMessage = "Fallback!\nPlease stripe!") + } + setupCardReadProcess(true) + return + } + + ecrActionCancel("Transaction cancelled") + + viewModelScope.launch { + _uiState.update { + it.copy( + alertMessage = "Chip not detected!", + isLoading = false + ) + } + _events.send(CardWaitingEvent.GoMain) + } + } + } + ) + } + + private fun ecrActionCancel(msg: String) { + if (sharedViewModel.isEcr.value != true) { + return + } + + sharedViewModel.isEcr.postValue(false) + sharedViewModel.isEcrFinished.postValue(true) + + if (SystemParamsOperation.getInstance().isCMHLEnabled) { + ECRHelper.send( + CoreUtils.getInstance(sharedViewModel) + .generateCMHLResponse(ECRResultStatus.USER_CANCEL) + ) + + CoreUtils.getInstance(sharedViewModel).responseACKCMHL() + return + } + + CoreUtils.getInstance(sharedViewModel).responseRejectMsg(msg) + } + + private fun stopCardReading() { + sharedViewModel.setIsFallback(false) + cardReadViewModel.cancelCheckCard() + cardReadViewModel.resetOneTimeFlag() + cardReadViewModel.cancelCheckXProcess() + } + + override fun onCleared() { + super.onCleared() + readerInitJob?.cancel() + stopCardReading() + } +} diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/navigation/AppNavGraph.kt b/app/src/main/java/com/mob/utsmyanmar/ui/navigation/AppNavGraph.kt index 434dfef..20995b5 100644 --- a/app/src/main/java/com/mob/utsmyanmar/ui/navigation/AppNavGraph.kt +++ b/app/src/main/java/com/mob/utsmyanmar/ui/navigation/AppNavGraph.kt @@ -1,13 +1,19 @@ package com.mob.utsmyanmar.ui.navigation import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.hilt.navigation.compose.hiltViewModel import androidx.navigation.NavHostController import androidx.navigation.NavType import androidx.navigation.compose.NavHost import androidx.navigation.compose.composable import androidx.navigation.navArgument import com.mob.utsmyanmar.ui.amount.AmountScreen +import com.mob.utsmyanmar.ui.cardwaiting.CardWaitingScreen +import com.mob.utsmyanmar.ui.cardwaiting.CardWaitingViewModel import com.mob.utsmyanmar.ui.dashboard.DashboardScreen +import com.mob.utsmyanmar.viewmodel.CardReaderViewModel +import com.mob.utsmyanmar.viewmodel.SharedViewModel @Composable fun AppNavGraph( @@ -42,7 +48,38 @@ fun AppNavGraph( ) { backStackEntry -> AmountScreen( action = backStackEntry.arguments?.getString("action").orEmpty(), - onBackClick = { navController.popBackStack() } + onBackClick = { navController.popBackStack() }, + onCancelClick = { navController.popBackStack() }, + onNextClick = { + navController.navigate(Routes.CardWaiting.route) + } + ) + } + + composable(Routes.CardWaiting.route) { + val sharedViewModel: SharedViewModel = hiltViewModel() + val cardReaderViewModel: CardReaderViewModel = hiltViewModel() + val cardWaitingViewModel: CardWaitingViewModel = viewModel( + factory = CardWaitingViewModel.provideFactory( + cardReadViewModel = cardReaderViewModel, + sharedViewModel = sharedViewModel + ) + ) + + CardWaitingScreen( + viewModel = cardWaitingViewModel, + onManualEntry = {}, + onProcessingCard = {}, + onTimeout = { navController.popBackStack() }, + onBack = { navController.popBackStack() }, + onMain = { + navController.navigate(Routes.Dashboard.route) { + popUpTo(Routes.Dashboard.route) { + inclusive = false + } + launchSingleTop = true + } + } ) } } diff --git a/app/src/main/java/com/mob/utsmyanmar/ui/navigation/Routes.kt b/app/src/main/java/com/mob/utsmyanmar/ui/navigation/Routes.kt index e13a6df..766f8ed 100644 --- a/app/src/main/java/com/mob/utsmyanmar/ui/navigation/Routes.kt +++ b/app/src/main/java/com/mob/utsmyanmar/ui/navigation/Routes.kt @@ -5,4 +5,5 @@ sealed class Routes(val route: String) { data object Amount : Routes("amount/{action}") { fun createRoute(action: String): String = "amount/$action" } + data object CardWaiting : Routes("card_waiting") } diff --git a/app/src/main/java/com/mob/utsmyanmar/utils/AppContextHolder.kt b/app/src/main/java/com/mob/utsmyanmar/utils/AppContextHolder.kt new file mode 100644 index 0000000..336ea47 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/utils/AppContextHolder.kt @@ -0,0 +1,15 @@ +package com.mob.utsmyanmar.utils + +import android.content.Context + +object AppContextHolder { + private lateinit var appContext: Context + + fun init(context: Context) { + appContext = context.applicationContext + } + + fun get(): Context { + return appContext + } +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/utils/CoreUtils.kt b/app/src/main/java/com/mob/utsmyanmar/utils/CoreUtils.kt new file mode 100644 index 0000000..ca4187a --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/utils/CoreUtils.kt @@ -0,0 +1,1037 @@ +package com.mob.utsmyanmar.utils + +import android.annotation.SuppressLint +import android.util.Log +import com.kizzy.cmhl.EcrManager +import com.kizzy.cmhl.models.* +import com.mob.utsmyanmar.model.ProcessCode +import com.mob.utsmyanmar.model.ecr.ECRResultStatus +import com.mob.utsmyanmar.viewmodel.SharedViewModel +import com.utsmyanmar.ecr.ECRHelper +import com.utsmyanmar.ecr.ECRProcess +import com.utsmyanmar.ecr.data.RespType +import com.utsmyanmar.ecr.data.model.Transactions +import com.utsmyanmar.ecr.data.model.TransactionsResp +import com.utsmyanmar.paylibs.utils.POSUtil +import com.utsmyanmar.paylibs.utils.enums.TransMenu +import com.utsmyanmar.paylibs.utils.iso_utils.TransactionsType +import com.utsmyanmar.paylibs.utils.params.Params +import sunmi.sunmiui.utils.LogUtil +import java.text.SimpleDateFormat +import java.util.Calendar + +class CoreUtils( + private val sharedViewModel: SharedViewModel +) : OldECRSetups, ECRSetups, ECRSetupsCMHL { + + companion object { + private const val TAG = "CoreUtils" + + @Volatile + private var instance: CoreUtils? = null + + fun getInstance(sharedViewModel: SharedViewModel): CoreUtils { + return instance ?: synchronized(this) { + instance ?: CoreUtils(sharedViewModel).also { + instance = it + } + } + } + + fun reduceTrailingZeros(inputValue: Int): Int { + return try { + val reduced = inputValue.toString().dropLast(2) + reduced.ifEmpty { "1" }.toInt() + } catch (e: Exception) { + e.printStackTrace() + 1 + } + } + + fun convertToDecimalString(integer: Int): String { + return "%.2f".format(integer / 100.0) + } + } + + private fun ecrResponseAction(msg: String) { + LogUtil.d(TAG, "ECR Respond Message: $msg") + ECRHelper.send(msg.toByteArray()) + } + + fun logTrans(trans: Transactions) { + Log.d(TAG, "logTrans: amount : ${trans.AMT}") + Log.d(TAG, "logTrans: trace : ${trans.TRACE}") + Log.d(TAG, "logTrans: cardNo : ${trans.CARDNO}") + Log.d(TAG, "logTrans: refNo : ${trans.REFNUM}") + Log.d(TAG, "logTrans: approvalCode : ${trans.APPCODE}") + Log.d(TAG, "logTrans: cmd : ${trans.CMD}") + Log.d(TAG, "logTrans: type : ${trans.TYPE}") + } + + @SuppressLint("SimpleDateFormat") + fun coreResponseMsg(status: RespType): TransactionsResp { + val payDetail = sharedViewModel.payDetail.value + + val resp = TransactionsResp() + resp.DATE = SimpleDateFormat("dd-MM-yyyy").format(Calendar.getInstance().time) + resp.TIME = SimpleDateFormat("HH:mm").format(Calendar.getInstance().time) + resp.CMD = sharedViewModel.ecrCMD.value?.toString().orEmpty() + + if (sharedViewModel.transactionsType.value == TransactionsType.SETTLEMENT) { + resp.AMT = sharedViewModel.totalAmount.value + } + + if (payDetail != null) { + resp.RESP = payDetail.tradeAnswerCode + resp.TID = payDetail.terminalNo + resp.MID = payDetail.merchantNo + } else { + val pay = Params.newTrade(false).payDetail + resp.TID = pay.terminalNo + resp.MID = pay.merchantNo + resp.RESP = "-1" + } + + resp.STATUS = status + + if (status == RespType.Cancelled || status == RespType.Rejected) { + resp.RESP = "-1" + } + + return resp + } + + fun generateCMHLResponse(ecrResultStatus: ECRResultStatus): ByteArray { + val payDetail = sharedViewModel.payDetail.value + ?: return byteArrayOf() + + val transactionsType = sharedViewModel.transactionsType.value + val isApproved = + payDetail.tradeAnswerCode == "000" || payDetail.tradeAnswerCode == "00" + + return when (transactionsType) { + TransactionsType.SALE -> { + val response = when { + ecrResultStatus == ECRResultStatus.RESPONSE_RECEIVED && isApproved -> { + SaleResponse.Builder() + .setResponseCode(POSUtil.getInstance().responseCodeConverter(payDetail.tradeAnswerCode)) + .setAmount(POSUtil.getInstance().formatAmount(payDetail.amount)) + .setPan(payDetail.cardNo) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setReferenceNum(payDetail.referNo) + .setApprovalCode(payDetail.approvalCode) + .setInvoiceNumber(payDetail.invoiceNo) + .setStan(payDetail.voucherNo) + .setEntry(POSUtil.getInstance().getEntryCode(payDetail)) + .setCardType(POSUtil.getInstance().getCardType(payDetail)) + .setCurrency(payDetail.currencyCode) + .build() + } + + ecrResultStatus == ECRResultStatus.USER_CANCEL -> { + SaleResponse.Builder() + .setResponseCode("FF") + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + ecrResultStatus == ECRResultStatus.RESPONSE_RECEIVED -> { + SaleResponse.Builder() + .setResponseCode(POSUtil.getInstance().responseCodeConverter(payDetail.tradeAnswerCode)) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + else -> { + SaleResponse.Builder() + .setResponseCode("NR") + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + } + + EcrManager.buildPacket(response) + } + + TransactionsType.VOID -> { + val response = when { + ecrResultStatus == ECRResultStatus.RESPONSE_RECEIVED && isApproved -> { + VoidResponse.Builder() + .setResponseCode(POSUtil.getInstance().responseCodeConverter(payDetail.tradeAnswerCode)) + .setAmount(POSUtil.getInstance().formatAmount(payDetail.amount)) + .setVoucherNumber(payDetail.voucherNo) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setApprovalCode(payDetail.approvalCode) + .setReferenceNum(payDetail.referNo) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .setEntry(POSUtil.getInstance().getEntryCode(payDetail)) + .build() + } + + ecrResultStatus == ECRResultStatus.USER_CANCEL -> { + VoidResponse.Builder() + .setResponseCode("FF") + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + ecrResultStatus == ECRResultStatus.RESPONSE_RECEIVED -> { + VoidResponse.Builder() + .setResponseCode(POSUtil.getInstance().responseCodeConverter(payDetail.tradeAnswerCode)) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + else -> { + VoidResponse.Builder() + .setResponseCode("NR") + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + } + + EcrManager.buildPacket(response) + } + + TransactionsType.SETTLEMENT -> { + val response = SettlementResponse.Builder() + .setResponseCode(POSUtil.getInstance().responseCodeConverter(payDetail.tradeAnswerCode)) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .build() + + EcrManager.buildPacket(response) + } + + TransactionsType.WAVEPAY -> { + val response = if (payDetail.qrTransStatus == 1) { + QrPaymentResponse.Builder() + .setResponseCode("00") + .setAmount(POSUtil.getInstance().formatAmount(payDetail.amount)) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setApprovalCode(payDetail.qrTransId) + .setRrn(payDetail.qrReferNo) + .setPosEntryMode("011") + .setInvoiceNumber(payDetail.invoiceNo) + .setStan(payDetail.voucherNo) + .setPaymentType(payDetail.customerMobile) + .setCurrencyCode(payDetail.currencyCode) + .build() + } else { + QrPaymentResponse.Builder() + .setResponseCode("05") + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + EcrManager.buildPacket(response) + } + + TransactionsType.PRE_AUTH_SALE -> { + val response = if (isApproved) { + PreAuthResponse.Builder() + .setResponseCode(payDetail.tradeAnswerCode) + .setAmount(POSUtil.getInstance().formatAmount(payDetail.amount)) + .setPan(payDetail.cardNo) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setApprovalCode(payDetail.approvalCode) + .setInvoiceNumber(payDetail.invoiceNo) + .setStan(payDetail.voucherNo) + .setRrn(payDetail.referNo) + .setEntry(POSUtil.getInstance().getEntryCode(payDetail)) + .setCardType(POSUtil.getInstance().getCardType(payDetail)) + .build() + } else { + PreAuthResponse.Builder() + .setResponseCode(payDetail.tradeAnswerCode) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + EcrManager.buildPacket(response) + } + + TransactionsType.PRE_AUTH_COMPLETE -> { + val response = if (isApproved) { + PreAuthCompletionResponse.Builder() + .setResponseCode(payDetail.tradeAnswerCode) + .setAmount(POSUtil.getInstance().formatAmount(payDetail.amount)) + .setPan(payDetail.cardNo) + .setTid(payDetail.terminalNo) + .setMid(payDetail.merchantNo) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .setApprovalCode(payDetail.approvalCode) + .setInvoiceNumber(payDetail.invoiceNo) + .setStan(payDetail.voucherNo) + .setRrn(payDetail.referNo) + .setEntry(POSUtil.getInstance().getEntryCode(payDetail)) + .build() + } else { + PreAuthCompletionResponse.Builder() + .setResponseCode(payDetail.tradeAnswerCode) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + } + + EcrManager.buildPacket(response) + } + + else -> { + val response = SaleResponse.Builder() + .setResponseCode(payDetail.tradeAnswerCode) + .setTime(payDetail.tradeTime) + .setDate(payDetail.tradeDate) + .build() + + EcrManager.buildPacket(response) + } + } + } + + fun generateResponseMsg(): TransactionsResp { + val trans = sharedViewModel.ecrTrans.value + val payDetail = sharedViewModel.payDetail.value ?: return TransactionsResp() + + val resp = when { + payDetail.tradeAnswerCode == "00" || payDetail.tradeAnswerCode == "000" -> { + coreResponseMsg(RespType.Approved) + } + + payDetail.transactionType == TransactionsType.WAVEPAY.value && + payDetail.qrTransStatus == 1 -> { + coreResponseMsg(RespType.Approved).apply { + REFNUM = payDetail.qrReferNo + } + } + + payDetail.transactionType == TransactionsType.WAVEPAY.value && + payDetail.qrTransStatus == 2 -> { + coreResponseMsg(RespType.QrCode).apply { + REFNUM = payDetail.qrReferNo + QRDATA = sharedViewModel.qrData.value + } + } + + else -> { + coreResponseMsg(RespType.Declined) + } + } + + resp.AMT = payDetail.amount + resp.TRACE = payDetail.voucherNo + resp.TYPE = trans?.CMD?.name.orEmpty() + resp.EXPDATE = payDetail.expDate + + if (sharedViewModel.transactionsType.value != TransactionsType.SETTLEMENT) { + resp.ENTRYMODE = POSUtil.getInstance().getEntryType(payDetail.cardType) + resp.REFNUM = payDetail.referNo + resp.PAN = POSUtil.getInstance().getCardNumMasking(payDetail.cardNo) + } + + resp.BATCHNO = payDetail.batchNo + + if (!payDetail.icC55.isNullOrEmpty()) { + resp.APP = payDetail.appLabel + resp.TC = payDetail.arqC + resp.AID = payDetail.aid + } + + return resp + } + + fun responseRejectMsg(actionName: String) { + val trans = sharedViewModel.ecrTrans.value ?: return + + LogUtil.d(TAG, "Rejected action name :$actionName") + LogUtil.d(TAG, "Rejected trans type :${trans.TYPE}") + LogUtil.d(TAG, "Rejected trans cmd :${trans.CMD}") + + val resp = coreResponseMsg(RespType.Rejected) + resp.ERROR_MSG = actionName + resp.TYPE = trans.CMD?.name.orEmpty() + + val msg = ECRProcess.generateECRResponse(resp) + ecrResponseAction(msg) + } + + fun responseRejectMsg(trans: Transactions, actionName: String) { + LogUtil.d(TAG, "Rejected action name :$actionName") + LogUtil.d(TAG, "Rejected trans type :${trans.TYPE}") + LogUtil.d(TAG, "Rejected trans cmd :${trans.CMD}") + + val resp = coreResponseMsg(RespType.Rejected) + resp.ERROR_MSG = actionName + resp.TYPE = trans.CMD?.name.orEmpty() + + val msg = ECRProcess.generateECRResponse(resp) + ecrResponseAction(msg) + } + + fun responseACKCMHL() { + ECRHelper.send(byteArrayOf(0x06)) + } + + override fun setUpECRTest() { + ecrResponseAction("Connection Success!") + } + + override fun setUpECREchoTest() { + val resp = TransactionsResp() + resp.TYPE = "ECHO" + resp.STATUS = RespType.Approved + + val pay = Params.newTrade(false).payDetail + resp.TID = pay.terminalNo + resp.MID = pay.merchantNo + resp.RESP = "000" + + val msg = ECRProcess.generateECRResponse(resp) + ecrResponseAction(msg) + } + + override fun setupPingRequest(trans: PingRequest) { + val pingResponse = PingResponse.Builder() + .setResponseCode("00") + .build() + + val packet = EcrManager.buildPacket(pingResponse) + ECRHelper.send(packet) + } + + override fun setUpECRSale(trans: SaleRequest): Boolean { + return try { + LogUtil.d(TAG, "amount is ${trans.amount}") + + val amount = trans.amount?.toLongOrNull() + if (amount == null || amount <= 0) { + LogUtil.d(TAG, "Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue(amount.toString()) + sharedViewModel.transactionsType.postValue(TransactionsType.SALE) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_PURCHASE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRQR(trans: QrPaymentRequest): Boolean { + return try { + LogUtil.d(TAG, "amount is ${trans.amount}") + + val amount = trans.amount?.toLongOrNull() + if (amount == null || amount <= 0) { + LogUtil.d(TAG, "Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue(amount.toString()) + sharedViewModel.transactionsType.postValue(TransactionsType.WAVEPAY) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRQRVoid(trans: VoidQrPaymentRequest): Boolean { + return false + } + + override fun setUpECRVoid(trans: VoidRequest): Boolean { + return try { + if (trans.invoiceNumber.isNullOrEmpty()) { + LogUtil.d(TAG, "Trace field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.traceNo.postValue(trans.invoiceNumber) + sharedViewModel.transactionName.postValue("SALE") + sharedViewModel.transactionsType.postValue(TransactionsType.VOID) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuth(trans: PreAuthRequest): Boolean { + return try { + LogUtil.d(TAG, "amount is ${trans.amount}") + + val amount = trans.amount?.toLongOrNull() + if (amount == null || amount <= 0) { + LogUtil.d(TAG, "Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue(amount.toString()) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_SALE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_SALE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuthVoid(trans: PreAuthCancellationRequest): Boolean { + return try { + LogUtil.d(TAG, "approval code is ${trans.approvalCode}") + LogUtil.d(TAG, "reference num is ${trans.referenceNumber}") + + if (trans.approvalCode.isNullOrEmpty()) { + LogUtil.d(TAG, "Approval code field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(trans.referenceNumber) + sharedViewModel.approvalCode.postValue(trans.approvalCode) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_VOID) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuthComplete(trans: PreAuthCompletionRequest): Boolean { + return try { + LogUtil.d(TAG, "approval code is ${trans.approvalCode}") + LogUtil.d(TAG, "reference num is ${trans.referenceNumber}") + + if (trans.approvalCode.isNullOrEmpty()) { + LogUtil.d(TAG, "Approval code field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(trans.referenceNumber) + sharedViewModel.approvalCode.postValue(trans.approvalCode) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_COMPLETE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_COMPLETE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRSettlement(trans: SettlementRequest) { + // TODO: implement if needed + } + + override fun setUpECRSale(trans: Transactions): Boolean { + return try { + LogUtil.d(TAG, "amount is ${trans.AMT}") + + val amount = trans.AMT + if (amount == null || amount <= 0) { + responseRejectMsg("Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue(convertToDecimalString(amount)) + sharedViewModel.transactionsType.postValue(TransactionsType.SALE) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_PURCHASE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRQR(trans: Transactions): Boolean { + return try { + LogUtil.d(TAG, "amount is ${trans.AMT}") + + val amount = trans.AMT + if (amount == null || amount <= 0) { + responseRejectMsg("Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue(convertToDecimalString(amount)) + sharedViewModel.transactionsType.postValue(TransactionsType.WAVEPAY) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRVoid(trans: Transactions): Boolean { + return try { + if (trans.TRACE.isNullOrEmpty()) { + responseRejectMsg("Trace field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.traceNo.postValue(trans.TRACE) + sharedViewModel.transactionName.postValue("SALE") + sharedViewModel.transactionsType.postValue(TransactionsType.VOID) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRCashAdvance(trans: Transactions): Boolean { + return try { + val amount = trans.AMT + if (amount == null || amount <= 0) { + responseRejectMsg("Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.CASH_OUT) + sharedViewModel.processCode.postValue( + ProcessCode.CASH_ADVANCE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuth(trans: Transactions): Boolean { + return try { + val amount = trans.AMT + if (amount == null || amount <= 0) { + responseRejectMsg("Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_SALE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_SALE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuthVoid(trans: Transactions): Boolean { + return try { + if (trans.TRACE.isNullOrEmpty()) { + responseRejectMsg("Trace field is invalid!") + return false + } + + if (trans.REFNUM.isNullOrEmpty()) { + responseRejectMsg("Ref no field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(trans.REFNUM) + sharedViewModel.traceNo.postValue(trans.TRACE) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_VOID) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuthComplete(trans: Transactions): Boolean { + return try { + if (trans.REFNUM.isNullOrEmpty()) { + responseRejectMsg("Ref no field is invalid!") + return false + } + + if (trans.APPCODE.isNullOrEmpty()) { + responseRejectMsg("Approval code field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.rrNNo.postValue(trans.REFNUM) + sharedViewModel.approvalCode.postValue(trans.APPCODE) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_COMPLETE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_COMPLETE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRPreAuthCompleteVoid(trans: Transactions): Boolean { + return try { + if (trans.TRACE.isNullOrEmpty()) { + responseRejectMsg("Trace field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.traceNo.postValue(trans.TRACE) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.transactionName.postValue("PRE_AUTH_COMPLETE") + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_COMPLETE_VOID) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_COMPLETE_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRSale(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size == 1) { + ecrResponseAction("Amount field is empty!") + return false + } + + val amount = parts[1] + + if (POSUtil.getInstance().checkNumberField(amount)) { + ecrResponseAction("Invalid Amount Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.SALE) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_PURCHASE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRVoid(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size == 1) { + ecrResponseAction("Trace No field is empty!") + return false + } + + val traceNo = parts[1] + + if (POSUtil.getInstance().checkNumberField(traceNo)) { + ecrResponseAction("Invalid Trace Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.traceNo.postValue(traceNo) + sharedViewModel.transactionName.postValue("SALE") + sharedViewModel.transactionsType.postValue(TransactionsType.VOID) + sharedViewModel.processCode.postValue( + ProcessCode.SALE_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRCashAdvance(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size == 1) { + ecrResponseAction("Amount field is empty!") + return false + } + + val amount = parts[1] + + if (POSUtil.getInstance().checkNumberField(amount)) { + ecrResponseAction("Invalid Amount Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.CASH_OUT) + sharedViewModel.processCode.postValue( + ProcessCode.CASH_ADVANCE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRPreAuth(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size == 1) { + ecrResponseAction("Amount field is empty!") + return false + } + + val amount = parts[1] + + if (POSUtil.getInstance().checkNumberField(amount)) { + ecrResponseAction("Invalid Amount Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_SALE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_SALE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRPreAuthVoid(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size != 3) { + ecrResponseAction("Please input required field!") + return false + } + + val traceNo = parts[1] + val rrNNo = parts[2] + + if (POSUtil.getInstance().checkNumberField(traceNo)) { + ecrResponseAction("Invalid Trace Field!") + return false + } + + if (POSUtil.getInstance().checkNumberField(rrNNo)) { + ecrResponseAction("Invalid RRN Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(rrNNo) + sharedViewModel.traceNo.postValue(traceNo) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_VOID) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRPreAuthComplete(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size != 3) { + ecrResponseAction("Please input required field!") + return false + } + + val rrNNo = parts[1] + val approvalCode = parts[2] + + if (POSUtil.getInstance().checkNumberField(rrNNo)) { + ecrResponseAction("Invalid RRN Field!") + return false + } + + if (POSUtil.getInstance().checkApprovalField(approvalCode)) { + ecrResponseAction("Invalid Approval Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.rrNNo.postValue(rrNNo) + sharedViewModel.approvalCode.postValue(approvalCode) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_COMPLETE) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_COMPLETE + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRPreAuthCompleteVoid(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size == 1) { + ecrResponseAction("Trace No field is empty!") + return false + } + + val traceNo = parts[1] + + if (POSUtil.getInstance().checkNumberField(traceNo)) { + ecrResponseAction("Invalid Trace Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.traceNo.postValue(traceNo) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.transactionName.postValue("PRE_AUTH_COMPLETE") + sharedViewModel.transactionsType.postValue(TransactionsType.PRE_AUTH_COMPLETE_VOID) + sharedViewModel.processCode.postValue( + ProcessCode.PRE_AUTH_COMPLETE_VOID + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } + + override fun setUpECRSettlement() { + sharedViewModel.isEcr.postValue(true) + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.setTransMenu(TransMenu.SETTLEMENT) + sharedViewModel.transactionsType.postValue(TransactionsType.SETTLEMENT) + } + + override fun setUpECRRefund(trans: Transactions): Boolean { + return try { + if (trans.REFNUM.isNullOrEmpty()) { + responseRejectMsg("Ref no field is invalid!") + return false + } + + if (trans.CARDNO.isNullOrEmpty()) { + responseRejectMsg("Card no field is invalid!") + return false + } + + val amount = trans.AMT + if (amount == null || amount <= 0) { + responseRejectMsg("Amount field is invalid!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(trans.REFNUM) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.REFUND) + sharedViewModel.processCode.postValue( + ProcessCode.REFUND + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + true + } catch (e: Exception) { + false + } + } + + override fun setUpECRRefund(msg: String): Boolean { + val parts = msg.split("-") + + if (parts.size != 4) { + ecrResponseAction("Please input required field!") + return false + } + + val cardNo = parts[1] + val rrNNo = parts[2] + val amount = parts[3] + + if (POSUtil.getInstance().checkNumberField(cardNo)) { + ecrResponseAction("Invalid CardNo Field!") + return false + } + + if (POSUtil.getInstance().checkNumberField(rrNNo)) { + ecrResponseAction("Invalid RRN Field!") + return false + } + + if (POSUtil.getInstance().checkNumberField(amount)) { + ecrResponseAction("Invalid Amount Field!") + return false + } + + sharedViewModel.isEcrFinished.postValue(false) + sharedViewModel.isEcr.postValue(true) + sharedViewModel.rrNNo.postValue(rrNNo) + sharedViewModel.cardNo.postValue(cardNo) + sharedViewModel.amount.postValue("$amount.00") + sharedViewModel.transactionsType.postValue(TransactionsType.REFUND) + sharedViewModel.processCode.postValue( + ProcessCode.REFUND + ProcessCode.SMART + ProcessCode.TO_ACCOUNT + ) + + return true + } +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetups.kt b/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetups.kt new file mode 100644 index 0000000..35411ad --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetups.kt @@ -0,0 +1,17 @@ +package com.mob.utsmyanmar.utils + +import com.utsmyanmar.ecr.data.model.Transactions + +interface ECRSetups { + fun setUpECREchoTest() + fun setUpECRSale(trans: Transactions): Boolean + fun setUpECRQR(trans: Transactions): Boolean + fun setUpECRVoid(trans: Transactions): Boolean + fun setUpECRCashAdvance(trans: Transactions): Boolean + fun setUpECRPreAuth(trans: Transactions): Boolean + fun setUpECRPreAuthVoid(trans: Transactions): Boolean + fun setUpECRPreAuthComplete(trans: Transactions): Boolean + fun setUpECRPreAuthCompleteVoid(trans: Transactions): Boolean + fun setUpECRSettlement() + fun setUpECRRefund(trans: Transactions): Boolean +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetupsCMHL.kt b/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetupsCMHL.kt new file mode 100644 index 0000000..71c0745 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/utils/ECRSetupsCMHL.kt @@ -0,0 +1,24 @@ +package com.mob.utsmyanmar.utils + +import com.kizzy.cmhl.models.PingRequest +import com.kizzy.cmhl.models.PreAuthCancellationRequest +import com.kizzy.cmhl.models.PreAuthCompletionRequest +import com.kizzy.cmhl.models.PreAuthRequest +import com.kizzy.cmhl.models.QrPaymentRequest +import com.kizzy.cmhl.models.SaleRequest +import com.kizzy.cmhl.models.SettlementRequest +import com.kizzy.cmhl.models.VoidQrPaymentRequest +import com.kizzy.cmhl.models.VoidRequest + +interface ECRSetupsCMHL { + fun setUpECREchoTest() + fun setupPingRequest(trans: PingRequest) + fun setUpECRSale(trans: SaleRequest): Boolean + fun setUpECRQR(trans: QrPaymentRequest): Boolean + fun setUpECRQRVoid(trans: VoidQrPaymentRequest): Boolean + fun setUpECRVoid(trans: VoidRequest): Boolean + fun setUpECRPreAuth(trans: PreAuthRequest): Boolean + fun setUpECRPreAuthVoid(trans: PreAuthCancellationRequest): Boolean + fun setUpECRPreAuthComplete(trans: PreAuthCompletionRequest): Boolean + fun setUpECRSettlement(trans: SettlementRequest) +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/utils/OldECRSetups.kt b/app/src/main/java/com/mob/utsmyanmar/utils/OldECRSetups.kt new file mode 100644 index 0000000..7958be7 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/utils/OldECRSetups.kt @@ -0,0 +1,14 @@ +package com.mob.utsmyanmar.utils + +interface OldECRSetups { + fun setUpECRTest() + fun setUpECRSale(msg: String): Boolean + fun setUpECRVoid(msg: String): Boolean + fun setUpECRCashAdvance(msg: String): Boolean + fun setUpECRPreAuth(msg: String): Boolean + fun setUpECRPreAuthVoid(msg: String): Boolean + fun setUpECRPreAuthComplete(msg: String): Boolean + fun setUpECRPreAuthCompleteVoid(msg: String): Boolean + fun setUpECRSettlement() + fun setUpECRRefund(msg: String): Boolean +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/viewmodel/CardReaderViewModel.kt b/app/src/main/java/com/mob/utsmyanmar/viewmodel/CardReaderViewModel.kt new file mode 100644 index 0000000..92889a1 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/viewmodel/CardReaderViewModel.kt @@ -0,0 +1,152 @@ +package com.mob.utsmyanmar.viewmodel + + +import android.os.Handler +import android.os.Looper +import androidx.lifecycle.ViewModel +import com.mob.utsmyanmar.model.CardTransactionType +import com.utsmyanmar.checkxread.CheckXRead +import com.utsmyanmar.checkxread.checkcard.CheckCardResultX +import com.utsmyanmar.checkxread.model.CardDataX +import com.utsmyanmar.checkxread.readcard.ReadCardResultX +import com.utsmyanmar.checkxread.readcard.ReadCardX +import com.utsmyanmar.checkxread.sdk.SunmiSDK +import com.utsmyanmar.paylibs.model.PayDetail +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import javax.inject.Inject + +@HiltViewModel +class CardReaderViewModel @Inject constructor() : ViewModel() { + + companion object { + private val TAG = CardReaderViewModel::class.java.simpleName + } + + private val mainThreadHandler = Handler(Looper.getMainLooper()) + + private var oneTimeFlag = false + + private var cardTransactionType: CardTransactionType? = null + + /* + * UI States + */ + + private val _errorCode = MutableStateFlow("") + val errorCode = _errorCode.asStateFlow() + + private val _cardData = MutableStateFlow(null) + val cardData = _cardData.asStateFlow() + + private var _cardTypeData = MutableStateFlow(null) + val cardTypeData = _cardTypeData.asStateFlow() + + private val _payDetail = MutableStateFlow(null) + val payDetail = _payDetail.asStateFlow() + + private val _checkCardAlertMsg = + MutableStateFlow(null) + val checkCardAlertMsg = + _checkCardAlertMsg.asStateFlow() + + /* + * Transaction Type + */ + + fun setCardTransactionType( + cardTransactionType: CardTransactionType + ) { + this.cardTransactionType = cardTransactionType + } + + fun getCardTransactionType(): CardTransactionType? { + return cardTransactionType + } + + /* + * Check Card Process + */ + + fun startCheckXProcess( + allType: Int, + timeOut: Int, + cardResultX: CheckCardResultX + ) { + CheckXRead.getInstance() + .startCheckXProcess( + allType, + timeOut, + cardResultX + ) + } + + fun isReaderReady(): Boolean { + return SunmiSDK.getInstance().readCardOptV2 != null + } + + fun cancelCheckXProcess() { + CheckXRead.getInstance() + .cancelCheckXProcess() + } + + /* + * Read Card Process + */ + + fun startReadXProcess( + readCardX: ReadCardX, + readCardResultX: ReadCardResultX + ) { + CheckXRead.getInstance() + .startReadXProcess( + readCardX, + readCardResultX + ) + } + + /* + * Alert Message + */ + + fun setCheckCardAlertMsg( + msg: String, + isAutoHide: Boolean + ) { + _checkCardAlertMsg.value = msg + + if (isAutoHide) { + Handler(Looper.getMainLooper()).postDelayed({ + _checkCardAlertMsg.value = null + }, 5000) + } + } + + fun resetUI() { + _checkCardAlertMsg.value = null + } + + /* + * One Time Flag + */ + + fun resetOneTimeFlag() { + oneTimeFlag = false + } + + /* + * Cancel Card Checking + */ + + fun cancelCheckCard() { + if (isReaderReady()) { + SunmiSDK.getInstance() + .cancelCheckCard() + } + } + + fun setCardData(value: Int){ + _cardTypeData.value = value + } +} diff --git a/app/src/main/java/com/mob/utsmyanmar/viewmodel/ProcessingTransaction.kt b/app/src/main/java/com/mob/utsmyanmar/viewmodel/ProcessingTransaction.kt new file mode 100644 index 0000000..2ea907f --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/viewmodel/ProcessingTransaction.kt @@ -0,0 +1,25 @@ +package com.mob.utsmyanmar.viewmodel + +import com.mob.utsmyanmar.model.TransResultStatus +import com.utsmyanmar.paylibs.model.PayDetail +import com.utsmyanmar.paylibs.system.SingleLiveEvent + +interface ProcessingTransaction { + fun resetTransactionStatus() + + fun getTransStatus(): SingleLiveEvent + + fun startOnlineProcess() + + fun insertDB(payResult: PayDetail) + + fun processVoidDB(payResult: PayDetail) + + fun processPreVoidDb(payResult: PayDetail) + + fun processPreCompDb(payResult: PayDetail) + + fun processPreCompVoidDb(payResult: PayDetail) + + fun processRefundDB(payResult: PayDetail) +} \ No newline at end of file diff --git a/app/src/main/java/com/mob/utsmyanmar/viewmodel/SharedViewModel.kt b/app/src/main/java/com/mob/utsmyanmar/viewmodel/SharedViewModel.kt new file mode 100644 index 0000000..8b5fc58 --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/viewmodel/SharedViewModel.kt @@ -0,0 +1,476 @@ +package com.mob.utsmyanmar.viewmodel + +import android.graphics.Bitmap +import androidx.lifecycle.LiveData +import androidx.lifecycle.MutableLiveData +import androidx.lifecycle.ViewModel +import com.mob.utsmyanmar.model.SettlementType +import com.utsmyanmar.baselib.network.model.sirius.SiriusRequest +import com.utsmyanmar.baselib.network.model.sirius.SiriusResponse +import com.utsmyanmar.baselib.repo.Repository +import com.utsmyanmar.ecr.data.TransType +import com.utsmyanmar.ecr.data.model.Transactions +import com.utsmyanmar.paylibs.model.PayDetail +import com.utsmyanmar.paylibs.print.printx.PrintXReceipt +import com.utsmyanmar.paylibs.print.printx.PrintXStatus +import com.utsmyanmar.paylibs.system.SingleLiveEvent +import com.utsmyanmar.paylibs.utils.AccountType +import com.utsmyanmar.paylibs.utils.PrintStatus +import com.utsmyanmar.paylibs.utils.core_utils.SystemParamsOperation +import com.utsmyanmar.paylibs.utils.enums.HostType +import com.utsmyanmar.paylibs.utils.enums.TransMenu +import com.utsmyanmar.paylibs.utils.iso_utils.TransactionsType +import dagger.hilt.android.lifecycle.HiltViewModel +import io.reactivex.rxjava3.core.Observable +import sunmi.sunmiui.utils.LogUtil +import javax.inject.Inject + +@HiltViewModel +class SharedViewModel @Inject constructor( + private val repository: Repository +) : ViewModel() { + + companion object { + private const val TAG = "SharedViewModel" + } + + val transactionsType = SingleLiveEvent() + + val settlementType = SingleLiveEvent() + + val accountType = SingleLiveEvent() + + val amount = SingleLiveEvent() + + val totalAmount = SingleLiveEvent() + + val cardNo = SingleLiveEvent() + + val processCode = SingleLiveEvent() + + val payDetail = SingleLiveEvent() + + val printStatus = SingleLiveEvent() + + val merchantName = SingleLiveEvent() + + val transactionName = SingleLiveEvent() + + val payDetailList = SingleLiveEvent>() + + val isEcr = SingleLiveEvent() + + val traceNo = SingleLiveEvent() + + val rrNNo = SingleLiveEvent() + + val approvalCode = SingleLiveEvent() + + val isEcrFinished = SingleLiveEvent() + + val isEmv = SingleLiveEvent() + + private val settlementStatus = MutableLiveData() + + private val wavePayStatus = MutableLiveData() + + val sendMsg = SingleLiveEvent() + + val qrData = SingleLiveEvent() + + val qrRefNum = SingleLiveEvent() + + val ecrCMD = SingleLiveEvent() + + val _transMenu = SingleLiveEvent() + + val twoBtnLayout = MutableLiveData(0) + + val oneBtnLayout = MutableLiveData(8) + + private val reprintBtnLayout = MutableLiveData(8) + + val isReprint = SingleLiveEvent() + + var signBitmap: Bitmap? = null + + val hostType = SingleLiveEvent() + + private val printReceiptButtons = MutableLiveData(0) + + val printReceiptMsg = SingleLiveEvent() + + val reprintTransTypeMsg = SingleLiveEvent() + + val ecrTrans = SingleLiveEvent() + + val _manualEntryStatus = MutableLiveData() + + val fullVoidPreauthStatus = MutableLiveData() + + val partialVoidPreauthStatus = MutableLiveData() + + val printXStatus = SingleLiveEvent() + + private val _errorFragmentMsg = SingleLiveEvent() + + private val _successFragmentMsg = SingleLiveEvent() + + private val _currencyText = SingleLiveEvent() + + val tapCardStatus = MutableLiveData(1) + + val tapDeviceStatus = MutableLiveData(1) + + val insertCardStatus = MutableLiveData(1) + + val swipeCardStatus = MutableLiveData(0) + + val countDownTxt = MutableLiveData() + + val mmqrLoading = MutableLiveData() + + val isMMPay = MutableLiveData() + + val isWavePay = MutableLiveData() + + val mockData = SingleLiveEvent() + + val qrPayVisibility = MutableLiveData() + + val loadingView = MutableLiveData(8) + + val loadingMsg = SingleLiveEvent() + + private val isFallback = SingleLiveEvent() + + private val _isCardDataExist = SingleLiveEvent() + + private val _isAmountExist = SingleLiveEvent() + + private var mPayDetail = PayDetail() + + init { + setPrintStatus(PrintStatus.FIRST_PRINT) + isReprint.value = false + cardNo.value = "" + } + + fun setSettlementStatus(status: Boolean) { + settlementStatus.value = status + } + + fun getSettlementStatus(): MutableLiveData { + return settlementStatus + } + + fun setWavePayStatus(status: Boolean) { + wavePayStatus.value = status + } + + fun getWavePayStatus(): MutableLiveData { + return wavePayStatus + } + + fun setEmvTrans(status: Boolean) { + isEmv.value = status + } + + fun isEmvTrans(): SingleLiveEvent { + return isEmv + } + + private fun getPayDetail(): PayDetail { + return mPayDetail + } + + private fun cachePayDetail(payDetail: PayDetail) { + mPayDetail = payDetail + } + + fun setPrintReceiptButtons(visible: Boolean) { + printReceiptButtons.value = if (visible) 0 else 8 + } + + fun postPrintReceiptButtons(visible: Boolean) { + printReceiptButtons.postValue(if (visible) 0 else 8) + } + + fun getPrintReceiptButtons(): MutableLiveData { + return printReceiptButtons + } + + fun getReprintBtnLayout(): MutableLiveData { + return reprintBtnLayout + } + + fun setReprintBtnLayout(visible: Boolean) { + reprintBtnLayout.value = if (visible) 0 else 8 + } + + fun setPrintReceiptMsg(msg: String) { + printReceiptMsg.value = msg + } + + fun postPrintReceiptMsg(msg: String) { + printReceiptMsg.postValue(msg) + } + + fun setPrintStatus(printStatus: PrintStatus) { + this.printStatus.value = printStatus + } + + fun postPrintStatus(printStatus: PrintStatus) { + this.printStatus.postValue(printStatus) + } + + fun getPrintStatusEvent(): SingleLiveEvent { + return printStatus + } + + fun setIsFallback(status: Boolean) { + isFallback.value = status + } + + fun getIsFallback(): SingleLiveEvent { + return isFallback + } + + fun setCardDataExist(exist: Boolean) { + _isCardDataExist.value = exist + } + + fun getCardDataExist(): SingleLiveEvent { + return _isCardDataExist + } + + fun setAmountExist(exist: Boolean) { + _isAmountExist.value = exist + } + + fun getAmountExist(): SingleLiveEvent { + return _isAmountExist + } + + fun getManualEntryStatus(): MutableLiveData { + return _manualEntryStatus + } + + fun setManualEntryStatus(status: Boolean) { + _manualEntryStatus.value = status + } + + fun getErrorFragmentMsg(): SingleLiveEvent { + return _errorFragmentMsg + } + + fun set_errorFragmentMsg(msg: String) { + _errorFragmentMsg.value = msg + } + + fun getSuccessFragmentMsg(): SingleLiveEvent { + return _successFragmentMsg + } + + fun set_currencyText(msg: String) { + _currencyText.value = msg + } + + fun get_currencyText(): SingleLiveEvent { + return _currencyText + } + + fun set_successFragmentMsg(msg: String) { + _successFragmentMsg.value = msg + } + + fun getTransMenu(): SingleLiveEvent { + return _transMenu + } + + fun setTransMenu(transMenu: TransMenu?) { + _transMenu.value = transMenu + } + + fun loadingMsg(msg: String) { + loadingView.value = 0 + loadingMsg.value = msg + } + + fun dismissLoadingMsg() { + loadingView.value = 8 + loadingMsg.value = "" + } + + fun getParams(siriusRequest: SiriusRequest): Observable { + return repository.getParams(siriusRequest) + } + + private fun printReceipt(isMerchantCopy: Boolean) { + PrintXReceipt.getInstance() + .printSmileReceipt(payDetail.value, isMerchantCopy, object : PrintXStatus { + + override fun onSuccess() { + + if (isMerchantCopy) { + + if (!SystemParamsOperation.getInstance().demoStatus) { + if (SystemParamsOperation.getInstance().printISOStatus) { + PrintXReceipt.getInstance() + .printSmileISoReceipt(payDetail.value) + } + } + + postPrintStatus(PrintStatus.FIRST_PRINT_DONE) + + } else { + setPrintStatus(PrintStatus.SECOND_PRINT_DONE) + } + } + + override fun onFailure() { + LogUtil.d(TAG, "Print Status Result Failure!") + printXStatus.postValue(PrintStatus.EMPTY_PAPER_ROLL) + postPrintReceiptButtons(true) + } + }) + } + + fun startPrintReceipt(isFirstPrint: Boolean) { + + payDetail.value?.let { + cachePayDetail(it) + } + + PrintXReceipt.getInstance() + .printSmileReceipt(getPayDetail(), isFirstPrint, object : PrintXStatus { + + override fun onSuccess() { + + if (isFirstPrint) { + + if (!SystemParamsOperation.getInstance().demoStatus) { + if (SystemParamsOperation.getInstance().printISOStatus) { + PrintXReceipt.getInstance() + .printSmileISoReceipt(getPayDetail()) + } + } + + postPrintStatus(PrintStatus.FIRST_PRINT_DONE) + + if (isEcr.value == true && + SystemParamsOperation.getInstance() + .isAutoPrintCustomerCopy + ) { + printReceiptButtons.postValue(8) + } else { + printReceiptButtons.postValue(0) + } + + } else { + postPrintStatus(PrintStatus.SECOND_PRINT_DONE) + } + } + + override fun onFailure() { + LogUtil.d(TAG, "Print Status Result Failure!") + + if (isFirstPrint) { + setPrintStatus(PrintStatus.EMPTY_PAPER_ROLL_FIRST) + } else { + setPrintStatus(PrintStatus.EMPTY_PAPER_ROLL_SECOND) + } + + postPrintReceiptButtons(true) + } + }) + } + + fun startPrintProcess() { + + LogUtil.d(TAG, "Print status : ${getPrintStatusEvent().value}") + + when (getPrintStatusEvent().value) { + + PrintStatus.FIRST_PRINT -> { + printReceipt(true) + postPrintReceiptMsg("Printing Receipt for Merchant") + postPrintReceiptButtons(false) + } + + PrintStatus.SECOND_PRINT -> { + printReceipt(false) + postPrintReceiptMsg("Printing Receipt for Customer") + } + + PrintStatus.NOT_PRINT -> { + } + + else -> {} + } + } + + fun startPrintProcessSettlement() { + + val detail = payDetail.value ?: return + + PrintXReceipt.getInstance() + .printSmileSettlementReport(detail, object : PrintXStatus { + + override fun onSuccess() { + } + + override fun onFailure() { + } + }) + } + + fun getLastThreeTransactions(): LiveData> { + return repository.getLastThreeTransactions() + } + + fun getReversalTransaction(voucherNo: String): LiveData { + return repository.getReversalTransaction(voucherNo) + } + + fun updatePayDetail(payDetail: PayDetail) { + repository.updatePayDetail(payDetail) + } + + fun insertPayDetail(payDetail: PayDetail) { + repository.insertPayDetail(payDetail) + } + + fun enableCardStatusIcon( + tapCard: Boolean, + tapDevice: Boolean, + insertCard: Boolean, + swipeCard: Boolean + ) { + + tapCardStatus.value = if (tapCard) 1 else 0 + tapDeviceStatus.value = if (tapDevice) 1 else 0 + insertCardStatus.value = if (insertCard) 1 else 0 + swipeCardStatus.value = if (swipeCard) 1 else 0 + } + + fun resetParamsMain() { + + isEcrFinished.postValue(true) + isEcr.postValue(false) + + setAmountExist(false) + setCardDataExist(false) + setTransMenu(null) + } + + fun updateButtonStatus() { + setSettlementStatus( + SystemParamsOperation.getInstance().settlementStatus + ) + + setWavePayStatus( + SystemParamsOperation.getInstance().wavePayStatus + ) + } +} diff --git a/app/src/main/java/com/mob/utsmyanmar/viewmodel/TransProcessViewModel.kt b/app/src/main/java/com/mob/utsmyanmar/viewmodel/TransProcessViewModel.kt new file mode 100644 index 0000000..16b1edd --- /dev/null +++ b/app/src/main/java/com/mob/utsmyanmar/viewmodel/TransProcessViewModel.kt @@ -0,0 +1,346 @@ +package com.mob.utsmyanmar.viewmodel + +import android.text.TextUtils +import androidx.lifecycle.ViewModel +import com.mob.utsmyanmar.model.TransResultStatus +import com.utsmyanmar.baselib.repo.Repository +import com.utsmyanmar.paylibs.model.PayDetail +import com.utsmyanmar.paylibs.model.TradeData +import com.utsmyanmar.paylibs.network.ISOSocket +import com.utsmyanmar.paylibs.reversal.ReversalAction +import com.utsmyanmar.paylibs.reversal.ReversalListener +import com.utsmyanmar.paylibs.system.SystemDateTime +import com.utsmyanmar.paylibs.transactions.TransactionsOperation +import com.utsmyanmar.paylibs.transactions.TransactionsOperationListener +import com.utsmyanmar.paylibs.utils.PrintStatus +import com.utsmyanmar.paylibs.utils.core_utils.SystemParamsOperation +import com.utsmyanmar.paylibs.utils.iso_utils.TransactionsType +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import javax.inject.Inject + +@HiltViewModel +class TransProcessViewModel @Inject constructor( + private val repository: Repository +) : ViewModel(), ProcessingTransaction { + + companion object { + private const val RC_APPROVED_V1 = "00" + private const val RC_APPROVED_V2 = "000" + private const val TRY_SECONDARY = "TRY_SECONDARY" + } + + private var pan: String = "" + + private lateinit var tradeData: TradeData + + var payDetail: PayDetail? = null + + private var oldTransPayDetail: PayDetail? = null + + private var isSecondCall = false + private var isThirdCall = false + + /* + * States + */ + + private val _transResultStatus = + MutableStateFlow(null) + + val transResultStatus = + _transResultStatus.asStateFlow() + + private val _transType = + MutableStateFlow(null) + + val transType = + _transType.asStateFlow() + + private val _printStatus = + MutableStateFlow(PrintStatus.FIRST_PRINT) + + val printStatus = + _printStatus.asStateFlow() + + private val _payDetailResult = + MutableStateFlow(null) + + val payDetailResult = + _payDetailResult.asStateFlow() + + private val _errorMessage = + MutableStateFlow(null) + + val errorMessage = + _errorMessage.asStateFlow() + + /* + * Setup + */ + + fun setTradeData(tradeData: TradeData) { + this.tradeData = tradeData + payDetail = tradeData.payDetail + pan = payDetail?.cardNo ?: "" + } + + fun getTradeData(): TradeData { + return tradeData + } + + fun updatePayDetail(payDetail: PayDetail) { + this.payDetail = payDetail + + tradeData = TradeData().apply { + this.payDetail = payDetail + } + } + + fun setOldTransPayDetail(payDetail: PayDetail) { + oldTransPayDetail = payDetail + } + + /* + * Transaction + */ + + override fun startOnlineProcess() { + + TransactionsOperation.getInstance() + .getStartOperation( + tradeData, + transType.value + ) + .checkOperation(object : TransactionsOperationListener { + + override fun onSuccess(tradeData: TradeData) { + + val payDetailRes = + tradeData.payDetail + + if ( + TextUtils.equals( + payDetailRes.tradeAnswerCode, + RC_APPROVED_V1 + ) || + TextUtils.equals( + payDetailRes.tradeAnswerCode, + RC_APPROVED_V2 + ) + ) { + + payDetailRes.invoiceNo = + SystemParamsOperation + .getInstance() + .incrementInvoiceNum + + when (transType.value) { + + TransactionsType.VOID -> { + processVoidDB(payDetailRes) + } + + TransactionsType.REFUND -> { + processRefundDB(payDetailRes) + } + + TransactionsType.PRE_AUTH_VOID -> { + processPreVoidDb(payDetailRes) + } + + TransactionsType.PRE_AUTH_COMPLETE -> { + processPreCompDb(payDetailRes) + } + + TransactionsType.PRE_AUTH_COMPLETE_VOID -> { + processPreCompVoidDb(payDetailRes) + } + + else -> { + insertDB(payDetailRes) + } + } + + _payDetailResult.value = + payDetailRes + + _transResultStatus.value = + TransResultStatus.SUCCESS + + } else { + + _payDetailResult.value = + payDetailRes + + _transResultStatus.value = + TransResultStatus.FAIL + } + } + + override fun onReversal( + tradeData: TradeData + ) { + + _transResultStatus.value = + TransResultStatus.REVERSAL_PREPARE + + callReversal(tradeData) + } + + override fun onError(message: String) { + + if (message == TRY_SECONDARY) { + + _transResultStatus.value = + TransResultStatus.SECONDARY + + startOnlineProcess() + + } else { + + _errorMessage.value = message + + _transResultStatus.value = + TransResultStatus.ERROR + } + } + }) + } + + /* + * Database + */ + + override fun insertDB(payResult: PayDetail) { + + payDetail?.pinCipher = "" + + repository.insertPayDetail( + payDetail + ) + } + + override fun processVoidDB(payResult: PayDetail) { + + payDetail?.isCanceled = true + + payDetail?.let { + repository.updatePayDetail(it) + } + + repository.insertPayDetail( + updateCurrentDateAndTime(payResult) + ) + } + + override fun processRefundDB(payResult: PayDetail) { + + oldTransPayDetail?.apply { + isReturnGood = true + isCanceled = true + + repository.updatePayDetail(this) + } + + repository.insertPayDetail( + updateCurrentDateAndTime(payResult) + ) + } + + override fun processPreVoidDb(payResult: PayDetail) {} + override fun processPreCompDb(payResult: PayDetail) {} + override fun processPreCompVoidDb(payResult: PayDetail) {} + + /* + * Reversal + */ + + private fun callReversal(tradeData: TradeData) { + + payDetail = tradeData.payDetail + + ReversalAction.getInstance() + .setData(tradeData) + .enqueue() + .startReversal(object : ReversalListener { + + override fun onSuccessReversal() { + + _transResultStatus.value = + TransResultStatus.REVERSAL_SUCCESS + + payDetail?.let { + repository.insertPayDetail(it) + } + } + + override fun onNetworkFail(msg: String) { + + SystemParamsOperation + .getInstance() + .setSecondHostEnable(true) + + if ( + SystemParamsOperation + .getInstance() + .isSecondHostEnabled + ) { + + if (!isSecondCall) { + + _transResultStatus.value = + TransResultStatus.REVERSAL_SECONDARY + + ISOSocket.getInstance() + .switchIp() + + isSecondCall = true + + callReversal(tradeData) + + } else { + + _transResultStatus.value = + TransResultStatus.REVERSAL_FAIL + } + + } else { + + _transResultStatus.value = + TransResultStatus.REVERSAL_FAIL + } + } + + override fun onFailReversal(msg: String) { + + _transResultStatus.value = + TransResultStatus.REVERSAL_FAIL + } + }) + } + + /* + * Utils + */ + + private fun updateCurrentDateAndTime( + payDetail: PayDetail + ): PayDetail { + + payDetail.tradeDate = + SystemDateTime.getMMDD() + + payDetail.tradeTime = + SystemDateTime.getHHmmss() + + return payDetail + } + + override fun resetTransactionStatus() { + _transResultStatus.value = null + } + + override fun getTransStatus() = TODO() +} diff --git a/baselib/src/main/java/com/utsmyanmar/baselib/BaseApplication.java b/baselib/src/main/java/com/utsmyanmar/baselib/BaseApplication.java index 2bf3f31..1efb57b 100644 --- a/baselib/src/main/java/com/utsmyanmar/baselib/BaseApplication.java +++ b/baselib/src/main/java/com/utsmyanmar/baselib/BaseApplication.java @@ -98,13 +98,16 @@ public class BaseApplication extends Application { mPinPadOptV2 = sunmiPayKernel.mPinPadOptV2; mReadCardOptV2 = sunmiPayKernel.mReadCardOptV2; mSecurityOptV2 = sunmiPayKernel.mSecurityOptV2; - //init - - initTerminal(); PayLibsUtils.getInstance().initLib(mSecurityOptV2,mEMVOptV2,securityOpt,mReadCardOptV2); SunmiSDK.getInstance().initSDK(mReadCardOptV2,basicOptV2); + try { + initTerminal(); + } catch (Exception terminalInitException) { + terminalInitException.printStackTrace(); + } + } catch (Exception e) { e.printStackTrace(); diff --git a/baselib/src/main/res/values/colors.xml b/baselib/src/main/res/values/colors.xml index f5439cf..25b9949 100644 --- a/baselib/src/main/res/values/colors.xml +++ b/baselib/src/main/res/values/colors.xml @@ -4,7 +4,7 @@ #222222 #666666 #999999 - # + #DDDDDD #FEE135 #D0312D #FD5A52 @@ -19,4 +19,4 @@ #dddddd #FFFFFF - \ No newline at end of file + diff --git a/build.gradle.kts b/build.gradle.kts index 7548a4a..76f463a 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -4,6 +4,7 @@ plugins { alias(libs.plugins.android.library) apply false alias(libs.plugins.kotlin.android) apply false alias(libs.plugins.kotlin.compose) apply false - alias(libs.plugins.hilt.android) apply false alias(libs.plugins.kotlin.kapt) apply false + id("com.google.dagger.hilt.android") version "2.59.2" apply false + id("com.google.devtools.ksp") version "2.3.4" apply false } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 2e222ec..7563956 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,6 +1,7 @@ [versions] agp = "9.2.0" coreKtx = "1.18.0" +hiltAndroidCompiler = "2.59.2" junit = "4.13.2" junitVersion = "1.3.0" espressoCore = "3.7.0" @@ -11,10 +12,15 @@ composeBom = "2026.02.01" navigationCompose = "2.9.8" hilt = "2.57.1" foundation = "1.11.1" +runtime = "1.11.1" +rxandroid = "3.0.2" +rxjava = "3.1.12" +hiltNavigationCompose = "1.2.0" [libraries] androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" } androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "navigationCompose" } +hilt-android-compiler = { module = "com.google.dagger:hilt-android-compiler", version.ref = "hiltAndroidCompiler" } junit = { group = "junit", name = "junit", version.ref = "junit" } androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" } androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" } @@ -31,11 +37,14 @@ androidx-compose-material3 = { group = "androidx.compose.material3", name = "mat hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" } hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" } androidx-compose-foundation = { group = "androidx.compose.foundation", name = "foundation", version.ref = "foundation" } +androidx-compose-runtime = { group = "androidx.compose.runtime", name = "runtime", version.ref = "runtime" } +rxandroid = { module = "io.reactivex.rxjava3:rxandroid", version.ref = "rxandroid" } +rxjava = { module = "io.reactivex.rxjava3:rxjava", version.ref = "rxjava" } +androidx-hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version.ref = "hiltNavigationCompose" } [plugins] android-application = { id = "com.android.application", version.ref = "agp" } android-library = { id = "com.android.library", version.ref = "agp" } kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } -hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hilt" } kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" } diff --git a/mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/results.bin b/mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/results.bin new file mode 100644 index 0000000..c34496d --- /dev/null +++ b/mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/results.bin @@ -0,0 +1 @@ +o/mpulib-1.2-runtime diff --git a/mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/transformed/mpulib-1.2-runtime/mpulib-1.2-runtime_dex/classes.dex b/mpu-lib/build/.transforms/1dc9ee087b8688559ab13789bf87db3e/transformed/mpulib-1.2-runtime/mpulib-1.2-runtime_dex/classes.dex new file mode 100644 index 0000000000000000000000000000000000000000..9bb2ba00b65e45aa3182fd41efc5d6245c0fdac0 GIT binary patch literal 22580 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 z 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�p=bIlR4hz%Jr;e=%qaYxiDT)&JsV0RGuq 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 U;e&h=%x%mM%6Z24>4?r761SM literal 0 HcmV?d00001 diff --git a/paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/results.bin b/paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/results.bin new file mode 100644 index 0000000..c790d94 --- /dev/null +++ b/paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/results.bin @@ -0,0 +1 @@ +o/PayLib-release-1.4.64-runtime diff --git a/paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/transformed/PayLib-release-1.4.64-runtime/PayLib-release-1.4.64-runtime_dex/classes.dex b/paysdk-lib/build/.transforms/eb46e7d31217f72d46dae54cad665c07/transformed/PayLib-release-1.4.64-runtime/PayLib-release-1.4.64-runtime_dex/classes.dex new file mode 100644 index 0000000000000000000000000000000000000000..2dc28a97875dff9ac078cd889b27847d7b28a8f5 GIT binary patch literal 367352 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 z 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�p=bIlR4hz%Jr;e=%qaYxiDT)&JsV0RGuq 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 U;e&h=%x%mM%6Z24>4?r761SM literal 0 HcmV?d00001 diff --git a/sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/results.bin b/sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/results.bin new file mode 100644 index 0000000..800956c --- /dev/null +++ b/sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/results.bin @@ -0,0 +1 @@ +o/sunmiui-1.1.27-runtime diff --git a/sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/transformed/sunmiui-1.1.27-runtime/sunmiui-1.1.27-runtime_dex/classes.dex b/sunmiui-lib/build/.transforms/0761bc4d0c7f4f1381da14166fb53562/transformed/sunmiui-1.1.27-runtime/sunmiui-1.1.27-runtime_dex/classes.dex new file mode 100644 index 0000000000000000000000000000000000000000..a06cd2e1c6d14b0887b4a13fb8f123c548c715dc GIT binary patch literal 76564 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