diff --git a/app/src/main/java/com/gamedog/vididin/VididinEvents.kt b/app/src/main/java/com/gamedog/vididin/VididinEvents.kt index 97c03ab..9a5ba6d 100644 --- a/app/src/main/java/com/gamedog/vididin/VididinEvents.kt +++ b/app/src/main/java/com/gamedog/vididin/VididinEvents.kt @@ -47,6 +47,7 @@ object VididinEvents { // Withdraw related const val EVENT_WITHDRAW_SUB_ITEM_PROGRESS_UPDATED = 500 const val EVENT_WITHDRAW_SELECTED_SUB_ITEM_CHANGED = 501 + const val EVENT_WITHDRAW_CHECK_RESULT_UPDATED = 502 } \ No newline at end of file diff --git a/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt b/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt index 3067b6e..66e7f78 100644 --- a/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt +++ b/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt @@ -1,5 +1,7 @@ package com.gamedog.vididin.beans.resp +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_ONGOING + data class WithDrawRespData ( var items: MutableList? = null, @@ -95,6 +97,10 @@ data class WithdrawRecord ( var recordNo: String = "", var cashNum: Float = 0F, var operateMs: Long = 0L, - var state: Int = 1, // 提现状态 1:提现中,2:提现成功,3:提现失败 + var state: Int = TRANSACTION_STATE_ONGOING, // 提现状态 1:提现中,2:提现成功,3:提现失败 var failReason: Int = 0, // TODO - define various fail reasons + + var itemIndex: Int = 0, + var itemSubIndex: Int = 0, + var hasShowResultDialog: Boolean = false ) \ No newline at end of file diff --git a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt index a8d0f3e..3c7b5fa 100644 --- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt +++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt @@ -8,13 +8,10 @@ import androidx.lifecycle.Lifecycle import androidx.lifecycle.lifecycleScope import androidx.lifecycle.repeatOnLifecycle import com.ama.core.architecture.appBase.AppViewsEmptyViewModelActivity -import com.ama.core.architecture.util.SpUtil import com.ama.core.architecture.util.setOnClickBatch import com.gamedog.vididin.VidiConst import com.vididin.real.money.game.R import com.gamedog.vididin.VididinEvents -import com.gamedog.vididin.beans.WatchAdNotifyBean -import com.gamedog.vididin.beans.resp.PayoutCheck import com.gamedog.vididin.beans.resp.PayoutReply import com.gamedog.vididin.beans.resp.WithdrawRecord import com.gamedog.vididin.core.login.login.AccountManager @@ -23,6 +20,10 @@ import com.gamedog.vididin.features.withdraw.dialogs.WithdrawFailDialog import com.gamedog.vididin.features.withdraw.dialogs.WithdrawInfoConfirmDialog import com.gamedog.vididin.features.withdraw.dialogs.WithdrawSuccessDialog import com.gamedog.vididin.features.withdraw.widget.WithDrawItemView +import com.gamedog.vididin.manager.WithdrawManager +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_FAIL +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_ONGOING +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_SUCCESS import com.gamedog.vididin.netbase.Result import com.gamedog.vididin.router.Router import dagger.hilt.android.AndroidEntryPoint @@ -37,9 +38,6 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity() { private val viewModel: WithdrawViewModel by viewModels() private val mItemViewList: MutableList = mutableListOf() - private val mRecordList: MutableList by lazy { - SpUtil.instance().getList(SpUtil.KEY_WITHDRAW_HISTORY_LIST).toMutableList() - } override fun inflateViewBinding(inflater: LayoutInflater) = ViewBinding.inflate(inflater) @@ -132,15 +130,27 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity() { } VididinEvents.EVENT_AD_WATCHED_FOR_WITHDRAW_SMALL -> { - val notifyData: WatchAdNotifyBean = data.mData as WatchAdNotifyBean - //requestInit(notifyData.extraData) + /*val notifyData: WatchAdNotifyBean = data.mData as WatchAdNotifyBean + requestInit(notifyData.extraData)*/ + } + + VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED -> { + try { + val record = data.mData as WithdrawRecord + if (record.itemIndex == 0) { + showTransactionResultDialog(record) + } + } catch (e: Exception) { + e.printStackTrace() + } } } - }, VididinEvents.Event_Account_Cash_Changed, VididinEvents.EVENT_AD_WATCHED_FOR_WITHDRAW_SMALL) + }, VididinEvents.Event_Account_Cash_Changed, + VididinEvents.EVENT_AD_WATCHED_FOR_WITHDRAW_SMALL, + VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED,) - - checkTransactionState() + readTransactionsAndShowResult() } @@ -244,66 +254,12 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity() { viewModel.withdrawPayout(initUUID, payItemId, payCashNum) } - private fun requestCheck(recordNo: String, cashNum: Float) { - lifecycleScope.launch { - repeatOnLifecycle(Lifecycle.State.STARTED) { - viewModel.CheckResult.collect { result -> - when (result) { - is Result.Loading -> { - - } - is Result.Success -> { - val checkResult = result.data?.data - var errHintRes = 0 - - when (checkResult?.error) { - 0 -> { - when (checkResult.status) { - // 提现状态 1:提现中,2:提现成功,3:提现失败 - 1 -> { - - } - 2 -> { - showSuccessDialog(cashNum) - updateRecord(recordNo, checkResult) - } - 3 -> { - errHintRes = R.string.withdraw_normal_fail - updateRecord(recordNo, checkResult) - } - } - } - - 1 -> { - errHintRes = R.string.withdraw_normal_fail - } - - 2 -> { - errHintRes = R.string.withdraw_fail_version_toolow - } - } - - if (errHintRes > 0) { - showFailDialog(errHintRes) - } - } - is Result.Error -> { - showFailDialog(R.string.withdraw_fail_unkown_error) - } - } - } - } - } - - viewModel.withdrawCheck(recordNo) - } - private fun showSuccessDialog(cashNum: Float) { WithdrawSuccessDialog(this@WithDrawActivity, cashNum).show() } - private fun showFailDialog(errorHintRes: Int) { - WithdrawFailDialog(this@WithDrawActivity, errorHintRes).show() + private fun showFailDialog(failType: Int) { + WithdrawFailDialog(this@WithDrawActivity, failType).show() } private fun gotoWithdrawSubActivity(selectedIndex: Int) { @@ -313,9 +269,30 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity() { // ------------------------ new added -------------------------// - // WithdrawRecord - @Synchronized + private fun readTransactionsAndShowResult() { + val recordList = WithdrawManager.instance().getClonedRecordList() + recordList.forEach { + showTransactionResultDialog(it) + } + } + + private fun showTransactionResultDialog(record: WithdrawRecord) { + if (record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) { + when (record.state) { + TRANSACTION_STATE_SUCCESS -> { + showSuccessDialog(record.cashNum) + WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo) + } + + TRANSACTION_STATE_FAIL -> { + showFailDialog(record.failReason) + WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo) + } + } + } + } + private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Float, timeMs: Long) { val newRecord = WithdrawRecord().apply { id = payoutReply.id!! @@ -325,53 +302,8 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity() { state = 1 failReason = 0 } - mRecordList.add(newRecord) - SpUtil.instance().putList(SpUtil.KEY_WITHDRAW_HISTORY_LIST, mRecordList) - - checkTransactionState() - } - - @Synchronized - private fun updateRecord(recordNo: String, payCheck: PayoutCheck) { - var needSaveSp = false - mRecordList.forEachIndexed { index, record -> - if (record.recordNo == recordNo) { - if (record.state != payCheck.status) { - needSaveSp =true - record.state = payCheck.status - } - return@forEachIndexed - } - } - - if (needSaveSp) { - SpUtil.instance().putList(SpUtil.KEY_WITHDRAW_HISTORY_LIST, mRecordList) - } - } - - @Synchronized - private fun checkTransactionState() { - var unCheckCount = 0 - mRecordList.forEach { record -> - if (record.state == FINAL_STATE_ONGING) { - unCheckCount++ - } - } - - if (unCheckCount > 0) { - mRecordList.forEachIndexed { index, record -> - if (record.state == FINAL_STATE_ONGING) { - requestCheck(record.recordNo, record.cashNum) - } - } - - binding.root.postDelayed(object : Runnable { - override fun run() { - checkTransactionState() - } - }, CHECK_DURATION) - } + WithdrawManager.instance().saveNewRecord(newRecord) } diff --git a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt index 80ccb2b..34daa31 100644 --- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt +++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt @@ -3,7 +3,11 @@ package com.gamedog.vididin.features.withdraw import android.app.Activity import android.content.Intent import android.view.LayoutInflater +import androidx.activity.viewModels import androidx.core.view.isVisible +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.lifecycleScope +import androidx.lifecycle.repeatOnLifecycle import androidx.recyclerview.widget.LinearLayoutManager import com.ama.core.architecture.appBase.AppViewsEmptyViewModelActivity import com.ama.core.architecture.util.AndroidUtil @@ -13,20 +17,32 @@ import com.ama.core.architecture.util.setOnClickBatch import com.gamedog.vididin.VidiConst import com.gamedog.vididin.VididinEvents import com.gamedog.vididin.beans.WatchAdNotifyBean +import com.gamedog.vididin.beans.resp.PayoutReply +import com.gamedog.vididin.beans.resp.WithdrawRecord import com.gamedog.vididin.core.login.login.AccountManager +import com.gamedog.vididin.features.withdraw.WithDrawActivity.Companion.INIT_ACTIVE import com.gamedog.vididin.features.withdraw.dialogs.WithdrawBindBankDialog +import com.gamedog.vididin.features.withdraw.dialogs.WithdrawFailDialog import com.gamedog.vididin.features.withdraw.dialogs.WithdrawInfoConfirmDialog +import com.gamedog.vididin.features.withdraw.dialogs.WithdrawSuccessDialog import com.gamedog.vididin.manager.WithdrawItemBean import com.gamedog.vididin.manager.WithdrawManager +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_FAIL +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_ONGOING +import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_SUCCESS import com.gamedog.vididin.router.Router import com.vididin.real.money.game.R import dagger.hilt.android.AndroidEntryPoint +import kotlinx.coroutines.launch +import kotlin.getValue import com.vididin.real.money.game.databinding.ActivityWithdrawSubBinding as ViewBinding @AndroidEntryPoint class WithDrawSubActivity : AppViewsEmptyViewModelActivity() { + private val viewModel: WithdrawViewModel by viewModels() + private lateinit var mCurItem: WithdrawItemBean private var mSelectingIndex: Int = 0 private var mType: Int = 0 @@ -75,8 +91,124 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity() { } } - private fun requestInit(cashNum: Float) { + @Synchronized + private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Float, timeMs: Long) { + val newRecord = WithdrawRecord().apply { + id = payoutReply.id!! + recordNo = payoutReply.record_no + cashNum = payCashNum + operateMs = timeMs + state = 1 + failReason = 0 + itemIndex = mCurItem.index + itemSubIndex = mSelectingIndex + } + WithdrawManager.instance().saveNewRecord(newRecord) + } + + private fun requestInit(withdrawNum: Float) { + lifecycleScope.launch { + repeatOnLifecycle(Lifecycle.State.STARTED) { + viewModel.InitData.collect { result -> + when (result) { + is com.gamedog.vididin.netbase.Result.Loading -> { + + } + is com.gamedog.vididin.netbase.Result.Success -> { + val reqInitBean = result.data.data + + reqInitBean?.let { + var errorHintRes = 0 + + if (it.error == 0 && !it.uuid.isNullOrEmpty() && !it.items.isNullOrEmpty()) { + val itemId = if (withdrawNum <= VidiConst.WITHDRAW_SMALL_NUM) 0 else 1 + val withDrawItem = it.items?.get(itemId)!! + if (withDrawItem.status == INIT_ACTIVE) { + requestPayout(it.uuid!!, withDrawItem.id, withdrawNum) + } else { + errorHintRes = R.string.withdraw_fail_reach_day_limit + } + + } else { + // 0成功，1失败，2签名验证失败，3客户端版本过低，4 ts长度错误 + when (it.error) { + 3-> errorHintRes = R.string.withdraw_fail_version_toolow + } + } + + if (errorHintRes > 0) { + showFailDialog(errorHintRes) + } + } + + } + is com.gamedog.vididin.netbase.Result.Error -> { + showFailDialog(R.string.withdraw_fail_unkown_error) + } + } + } + } + } + + viewModel.withdrawInit() + } + + private fun requestPayout(initUUID: String, payItemId: Int, payCashNum: Float) { + val currentTimeMs = System.currentTimeMillis() + + lifecycleScope.launch { + repeatOnLifecycle(Lifecycle.State.STARTED) { + viewModel.PayoutResult.collect { result -> + when (result) { + is com.gamedog.vididin.netbase.Result.Loading -> { + } + is com.gamedog.vididin.netbase.Result.Success -> { + var errHintRes = 0 + + when (result.data?.data?.error) { + /* 错误码， + 0成功，1失败，2签名验证失败，3客户端版本过低，4uuid错误，5所在地国家或地区不在提现限制内，6提现金额不符对应的产品id，7提现产品id不对，8达到提现金额限制，9提现次数超过限制，10今日没有提现机会，11提现账号达到次数限制，12身份审核条件不满足，不能提现，13巴西提现参数 document_type 错误， + 14巴西提现参数 document_id 错误，15 巴西提现参数 AccountType 错误，16 巴西提现参数 Name 错误，17巴西提现参数 Account 和 DocumentId 不同，18巴西提现参数account_type为CPF时 对应的 account 错误，19巴西提现参数account_type为CNPJ时 对应的 account 错误，20巴西提现参数 account_type 错误， + 21巴西提现参数 document_type 错误，22巴西提现参数account_type为CPF时 对应的 document_id 错误，23巴西提现参数account_type为CNPJ时 对应的 document_id 错误，24 ts长度错误，25 没提0.1就提现其它的 + */ + 0 -> { + saveNewRecord(result.data.data!!, payCashNum, currentTimeMs) + } + 5-> { + errHintRes = R.string.withdraw_fail_region_restricit + } + 8-> { + errHintRes = R.string.withdraw_fail_amount_limit + } + 9-> { + errHintRes = R.string.withdraw_fail_amount_limit + } + } + + if (errHintRes > 0) { + showFailDialog(errHintRes) + } + } + is com.gamedog.vididin.netbase.Result.Error -> { + showFailDialog(R.string.withdraw_fail_unkown_error) + } + } + } + } + } + + + viewModel.withdrawPayout(initUUID, payItemId, payCashNum) + } + + + private fun showSuccessDialog(cashNum: Float) { + WithdrawSuccessDialog(this, cashNum).show() + } + + private fun showFailDialog(errorHintRes: Int) { + WithdrawFailDialog(this, errorHintRes).show() } private fun handleSubItemClicked(itemIndex: Int) { @@ -107,10 +239,22 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity() { VididinEvents.EVENT_WITHDRAW_SELECTED_SUB_ITEM_CHANGED -> { updateUI() } + + VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED -> { + try { + val record = data.mData as WithdrawRecord + if (record.itemIndex > 0) { + showTransactionResultDialog(record) + } + } catch (e: Exception) { + e.printStackTrace() + } + } } }, VididinEvents.EVENT_AD_WATCHED_FOR_WITHDRAW_BIG, VididinEvents.EVENT_WITHDRAW_SUB_ITEM_PROGRESS_UPDATED, - VididinEvents.EVENT_WITHDRAW_SELECTED_SUB_ITEM_CHANGED) + VididinEvents.EVENT_WITHDRAW_SELECTED_SUB_ITEM_CHANGED, + VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED ) mCurItem = WithdrawManager.instance().getItem(mType) @@ -121,6 +265,22 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity() { updateUI() } + private fun showTransactionResultDialog(record: WithdrawRecord) { + if (record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) { + when (record.state) { + TRANSACTION_STATE_SUCCESS -> { + showSuccessDialog(record.cashNum) + WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo) + } + + TRANSACTION_STATE_FAIL -> { + showFailDialog(record.failReason) + WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo) + } + } + } + } + private fun handleAdWatched(adNotifyBean: WatchAdNotifyBean) { val withdrawItemBean = adNotifyBean.extraData if (WithdrawManager.instance().addAdEarnForSubBean(withdrawItemBean.index, diff --git a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawViewModel.kt b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawViewModel.kt index 33de979..17ade99 100644 --- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawViewModel.kt +++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithdrawViewModel.kt @@ -14,6 +14,7 @@ import com.gamedog.vididin.beans.resp.PayInit import com.gamedog.vididin.beans.resp.PayoutCheckData import com.gamedog.vididin.beans.resp.PayoutData import com.gamedog.vididin.core.login.login.AccountManager +import com.gamedog.vididin.manager.WithdrawManager import com.gamedog.vididin.netbase.NetworkUtil import com.gamedog.vididin.netbase.Result import kotlinx.coroutines.flow.MutableStateFlow @@ -108,16 +109,7 @@ class WithdrawViewModel : ViewModel() { private fun T.applyInitFields(): T { - apply { - platform = "Android" - deviceid = DeviceUtil.generateDeviceId() - version = AndroidUtil.getAppVersionInfo() - ip = NetUtil.getLocalIpAddress() - ts = (System.currentTimeMillis()/1000).toString() - val signOrigin = "${VidiConst.WITHDRAW_MD5KEY}platform=${platform}deviceid=${deviceid}version=${version}ip=${ip}ts=$ts" - sign = MD5Util.md5ForWithDraw(signOrigin) - } - return this + return WithdrawManager.instance().applyInitFields(this) } } \ No newline at end of file diff --git a/app/src/main/java/com/gamedog/vididin/features/withdraw/dialogs/WithdrawFailDialog.kt b/app/src/main/java/com/gamedog/vididin/features/withdraw/dialogs/WithdrawFailDialog.kt index edc8c06..d67746e 100644 --- a/app/src/main/java/com/gamedog/vididin/features/withdraw/dialogs/WithdrawFailDialog.kt +++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/dialogs/WithdrawFailDialog.kt @@ -4,11 +4,13 @@ package com.gamedog.vididin.features.withdraw.dialogs import android.app.Activity import com.ama.core.architecture.util.setOnClickBatch import com.ama.core.architecture.widget.BindingDialog +import com.gamedog.vididin.manager.WithdrawManager.Companion.FAIL_TYPE_APP_VERSION_LOW import com.vididin.real.money.game.databinding.DialogWithdrawFailBinding as ViewBinding import com.gamedog.vididin.router.Router +import com.vididin.real.money.game.R -class WithdrawFailDialog(context: Activity, private val errorHintRes: Int) : BindingDialog(context, ViewBinding::inflate) { +class WithdrawFailDialog(context: Activity, private val failType: Int) : BindingDialog(context, ViewBinding::inflate) { init { build() @@ -39,7 +41,13 @@ class WithdrawFailDialog(context: Activity, private val errorHintRes: Int) : Bin } } - tvReason.setText(errorHintRes) + var failTextRes = R.string.withdraw_normal_fail + when (failType) { + FAIL_TYPE_APP_VERSION_LOW -> { + failTextRes = R.string.withdraw_fail_version_toolow + } + } + tvReason.setText(failTextRes) } } diff --git a/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt b/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt index b8748d4..8c8675f 100644 --- a/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt +++ b/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt @@ -2,14 +2,36 @@ package com.gamedog.vididin.manager import com.ama.core.architecture.util.AndroidUtil import com.ama.core.architecture.util.DateUtil +import com.ama.core.architecture.util.DeviceUtil +import com.ama.core.architecture.util.MD5Util +import com.ama.core.architecture.util.NetUtil import com.ama.core.architecture.util.SpUtil import com.ama.core.architecture.util.eventbus.NotifyMan +import com.gamedog.vididin.VidiConst import com.gamedog.vididin.VididinEvents +import com.gamedog.vididin.beans.req.PayInitReq +import com.gamedog.vididin.beans.req.PayoutCheckReq +import com.gamedog.vididin.beans.resp.WithdrawRecord +import com.gamedog.vididin.features.withdraw.WithDrawActivity.Companion.FINAL_STATE_ONGING import com.gamedog.vididin.manager.WithdrawManager.Companion.STATE_NEED_WATCH_AD +import com.gamedog.vididin.netbase.NetworkUtil +import com.gamedog.vididin.netbase.Result +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import java.util.concurrent.locks.ReentrantLock class WithdrawManager private constructor() { + private val backgroundScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) + + private val mRecordLocker = ReentrantLock() + private val mRecordList: MutableList by lazy { + SpUtil.instance().getList(SpUtil.KEY_WITHDRAW_HISTORY_LIST).toMutableList() + } private val mItemList: MutableList by lazy { val itemList = SpUtil.instance().getList(SpUtil.KEY_WITHDRAW_ITEM_LIST).toMutableList() @@ -20,15 +42,25 @@ class WithdrawManager private constructor() { itemList } - companion object { const val EACH_SUB_ITEM_CASH_NUM: Float = 1F + // subBean 状态 const val STATE_NEED_WATCH_AD: Int = 0 const val STATE_COULD_WITHDRAW: Int = 1 const val STATE_WITHDRAWING: Int = 2 const val STATE_HAS_WITHDRAWED: Int = 3 + // 提现交易状态 提现状态 1:提现中,2:提现成功,3:提现失败 + const val TRANSACTION_STATE_ONGOING : Int = 1 + const val TRANSACTION_STATE_SUCCESS : Int = 2 + const val TRANSACTION_STATE_FAIL : Int = 3 + + + // 提现失败分类(自定义) + const val FAIL_TYPE_UNKNOWN : Int = 1 + const val FAIL_TYPE_APP_VERSION_LOW : Int = 2 + @Volatile private var instance: WithdrawManager? = null @@ -41,6 +73,12 @@ class WithdrawManager private constructor() { } } + init { + loopCheckTransactionState() + } + + + private fun generateItemList(): MutableList { val itemList = mutableListOf() itemList.add(WithdrawItemBean(0, 10F, AndroidUtil.randomInt(50, 70), generateSubItemList(10F))) @@ -127,6 +165,201 @@ class WithdrawManager private constructor() { } } + fun saveRecordHasNotifyState(recordNo: String) { + val recordBean = getRecord(recordNo) + recordBean?.let { + it.hasShowResultDialog = true + saveRecords2Sp() + } + } + + fun saveNewRecord(newRecord: WithdrawRecord) { + try { + mRecordLocker.lock() + mRecordList.add(newRecord) + } finally { + mRecordLocker.unlock() + } + saveRecords2Sp() + loopCheckTransactionState() + } + + private fun saveRecords2Sp() { + SpUtil.instance().putList(SpUtil.KEY_WITHDRAW_HISTORY_LIST,getClonedRecordList()) + } + + fun updateRecord(recordNo: String, newState: Int, failType: Int = 0) { + var needSaveSp = false + try { + mRecordLocker.lock() + mRecordList.forEachIndexed { index, record -> + if (record.recordNo == recordNo) { + if (record.state != newState) { + needSaveSp =true + record.state = newState + record.failReason = failType + } + return@forEachIndexed + } + } + } finally { + mRecordLocker.unlock() + } + + + if (needSaveSp) { + saveRecords2Sp() + } + } + + fun getClonedRecordList(): List { + try { + mRecordLocker.lock() + val clonedList = mutableListOf() + clonedList.addAll(mRecordList) + return clonedList + } finally { + mRecordLocker.unlock() + } + return emptyList() + } + + private fun getRecord(recordNo: String): WithdrawRecord? { + try { + mRecordLocker.lock() + mRecordList.forEachIndexed { index, record -> + if (record.recordNo == recordNo) { + return record + } + } + } finally { + mRecordLocker.unlock() + } + return null + } + + + private fun loopCheckTransactionState() { + var unCheckCount = 0 + try { + mRecordLocker.lock() + mRecordList.forEach { record -> + if (record.state == FINAL_STATE_ONGING) { + unCheckCount++ + } + } + } finally { + mRecordLocker.unlock() + } + + + if (unCheckCount > 0) { + try { + mRecordLocker.lock() + mRecordList.forEachIndexed { index, record -> + if (record.state == FINAL_STATE_ONGING) { + doTransactionCheck(record.recordNo, record.cashNum) + } + } + } finally { + mRecordLocker.unlock() + } + } + } + + private fun doTransactionCheck(recordNo: String, cashNum: Float) { + backgroundScope.launch { + performNetworkRequest(recordNo) + } + } + + private suspend fun performNetworkRequest(recordNo: String) { + val requestParam = applyInitFields(PayoutCheckReq()).apply { + record_no = recordNo + } + + val reqResult = NetworkUtil.callApi { + NetworkUtil.apiservice().withdrawCheck(requestParam) + } + + when (reqResult) { + is Result.Loading -> { + + } + + is Result.Success -> { + val checkResult = reqResult.data.data + var failedType = 0 + + when (checkResult?.error) { + 0 -> { + when (checkResult.status) { + // 提现状态 1:提现中,2:提现成功,3:提现失败 + 1 -> { + delay(10000) + loopCheckTransactionState() + } + 2 -> { + handleTransactionSuccess(recordNo) + } + 3 -> { + failedType = FAIL_TYPE_UNKNOWN + } + } + } + + 1 -> { + failedType = FAIL_TYPE_UNKNOWN + } + + 2 -> { + failedType = FAIL_TYPE_APP_VERSION_LOW + } + } + + if (failedType > 0) { + handleTransactionFailed(recordNo, failedType) + } + } + + is Result.Error -> { + + } + } + } + + private fun handleTransactionSuccess(recordNo: String) { + updateRecord(recordNo, TRANSACTION_STATE_SUCCESS) + notifyWithdrawCheckResult(recordNo) + } + + private fun handleTransactionFailed(recordNo: String, failedType: Int) { + updateRecord(recordNo, TRANSACTION_STATE_FAIL, failedType) + notifyWithdrawCheckResult(recordNo) + } + + private fun notifyWithdrawCheckResult(recordNo: String) { + val recordBean = getRecord(recordNo) + recordBean.let { + NotifyMan.instance().sendEvent(VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED, NotifyMan.NotifyData(it)) + } + } + + fun applyInitFields(dataBean: T): T { + dataBean.apply { + platform = "Android" + deviceid = DeviceUtil.generateDeviceId() + version = AndroidUtil.getAppVersionInfo() + ip = NetUtil.getLocalIpAddress() + ts = (System.currentTimeMillis()/1000).toString() + val signOrigin = "${VidiConst.WITHDRAW_MD5KEY}platform=${platform}deviceid=${deviceid}version=${version}ip=${ip}ts=$ts" + sign = MD5Util.md5ForWithDraw(signOrigin) + } + return dataBean + } + + + }