合并提现记录到 unique RecordCash

2026-01-07 12:01:38 +08:00 · 2026-01-07 12:01:38 +08:00 · b73333f46f
parent ecaa1ae372
commit b73333f46f
11 changed files with 258 additions and 184 deletions
--- a/app/src/main/java/com/gamedog/vididin/beans/RecordCash.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/RecordCash.kt
@ -3,6 +3,7 @@ package com.gamedog.vididin.beans
 import com.ama.core.architecture.util.AndroidUtil
 import com.ama.core.architecture.util.DateUtil
 import com.gamedog.vididin.manager.WithdrawManager
+import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_ONGOING
 import com.viddin.videos.free.R


@ -11,7 +12,7 @@ const val RECORD_CASH_PLUS_GOLD_CONVERT: Int = 1
 const val RECORD_CASH_PLUS_BOX_TASK: Int = 2
 const val RECORD_CASH_PLUS_WITHDRAW_ONGOING: Int = 3
 const val RECORD_CASH_PLUS_WITHDRAW_FAIL: Int = 4
-const val RECORD_CASH_MINUS_WITHDRAW_SUCCESS: Int = 5
+const val RECORD_CASH_WITHDRAW: Int = 5
 const val RECORD_CASH_ZERO_WITHDRAW_SUCCESS: Int = 6

 abstract class BaseRecord {
@ -20,9 +21,18 @@ abstract class BaseRecord {
 }

 open class RecordCash (var recordType: Int = 0,
-                       var amountNum: Double = 0.0,
-                       var isSuccess: Boolean = false,
-                       var withdrawFailType: Int = 0) : BaseRecord()
+                       var amountNum: Double = 0.0,) : BaseRecord() {
+
+    // 提现相关的
+    var payOutReplyId: String = ""
+    var payOutReplyNo: String = ""
+    var withdrawState: Int = TRANSACTION_STATE_ONGOING    // 提现状态 1:提现中,2:提现成功,3:提现失败
+    var failReason: Int = WithdrawManager.INIT_OK
+    var withdrawFailType: Int = 0
+    var withdrawItemIndex: Int = 0
+    var withdrawItemSubIndex: Int = 0
+    var hasShowResultDialog: Boolean = false
+}

 class RecordCashShow: RecordCash() {
    var title: Int = 0
@ -36,7 +46,6 @@ fun RecordCash.toShowBean(): RecordCashShow {
    return RecordCashShow().apply {
        this@apply.uuid = this@toShowBean.uuid
        this@apply.dateMs = this@toShowBean.dateMs
-        this@apply.isSuccess = this@toShowBean.isSuccess
        this@apply.amountNum = this@toShowBean.amountNum
        this@apply.recordType = this@toShowBean.recordType

@ -69,7 +78,7 @@ fun RecordCash.toShowBean(): RecordCashShow {
                textColor = R.color.gray3
            }

-            RECORD_CASH_MINUS_WITHDRAW_SUCCESS -> {
+            RECORD_CASH_WITHDRAW -> {
                title = R.string.record_cash_title_withdraw_success
                description = R.string.record_cash_descr_withdraw_success
                iconRes = R.mipmap.icon_check
--- a/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt
+++ b/app/src/main/java/com/gamedog/vididin/beans/resp/WithDrawRespData.kt
@ -92,15 +92,16 @@ data class PayoutCheck(
 )


+/*
 data class WithdrawRecord (
-    var id: String = "",
-    var recordNo: String = "",
+    var payOutReplyId: String = "",
+    var payOutReplyNo: String = "",
    var cashNum: Double = 0.0,
    var operateMs: Long = 0L,
    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 withdrawItemIndex: Int = 0,
+    var withdrawItemSubIndex: Int = 0,
    var hasShowResultDialog: Boolean = false
-)
+)*/
--- a/app/src/main/java/com/gamedog/vididin/features/winrecords/WinRecordsActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/winrecords/WinRecordsActivity.kt
@ -12,9 +12,7 @@ import androidx.recyclerview.widget.LinearLayoutManager
 import com.ama.core.architecture.appBase.AppViewsEmptyViewModelActivity
 import com.ama.core.architecture.util.CommonItemDecoration
 import com.gamedog.vididin.VididinEvents
-import com.gamedog.vididin.VididinEvents.EVENT_ZERO_WITHDRAW_LIST_CHANGED
 import com.gamedog.vididin.beans.ZeroBuyResp
-import com.gamedog.vididin.beans.resp.WithdrawRecord
 import com.gamedog.vididin.features.zero.ZeroBuyViewModel
 import com.gamedog.vididin.features.zero.ZeroRecordAdapter
 import com.viddin.videos.free.R
--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawActivity.kt
@ -21,8 +21,9 @@ import com.gamedog.statisticreporter.StatisticUtil
 import com.gamedog.vididin.VidiConst
 import com.viddin.videos.free.R
 import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.beans.RECORD_CASH_WITHDRAW
+import com.gamedog.vididin.beans.RecordCash
 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.dialogs.WithdrawBindBankDialog
 import com.gamedog.vididin.features.withdraw.dialogs.WithdrawFailDialog
@ -172,12 +173,12 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {

                VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED -> {
                    try {
-                        val record = data.mData as WithdrawRecord
-                        if (record.itemIndex == 0) {
+                        val record = data.mData as RecordCash
+                        if (record.withdrawItemIndex == 0) {
                            showTransactionResultDialog(record)
                        }
                        updateUICashTotal()
-                        mItemViewList[record.itemIndex].updateProgressAndButUI()
+                        mItemViewList[record.withdrawItemIndex].updateProgressAndButUI()
                    } catch (e: Exception) {
                        e.printStackTrace()
                    }
@ -330,29 +331,28 @@ class WithDrawActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {
        }
    }

-    private fun showTransactionResultDialog(record: WithdrawRecord) {
-        if (!record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) {
-            when (record.state) {
+    private fun showTransactionResultDialog(record: RecordCash) {
+        if (!record.hasShowResultDialog && record.withdrawState != TRANSACTION_STATE_ONGOING) {
+            when (record.withdrawState) {
                TRANSACTION_STATE_SUCCESS -> {
-                    showSuccessDialog(record.cashNum)
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    showSuccessDialog(record.amountNum)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                }

                TRANSACTION_STATE_FAIL -> {
                    showFailDialog(WithdrawManager.instance().getFailHintStrRes(record.failReason))
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                }
            }
        }
    }

-    private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Double, timeMs: Long) {
-        val newRecord = WithdrawRecord().apply {
-            id = payoutReply.id!!
-            recordNo = payoutReply.record_no
-            cashNum = payCashNum
-            operateMs = timeMs
-            state = 1
+    private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Double, timeMsNow: Long) {
+        val newRecord = RecordCash(RECORD_CASH_WITHDRAW, payCashNum).apply {
+            payOutReplyId = payoutReply.id!!
+            payOutReplyNo = payoutReply.record_no
+            dateMs = timeMsNow
+            withdrawState = TRANSACTION_STATE_ONGOING
            failReason = 0
        }

--- a/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt
+++ b/app/src/main/java/com/gamedog/vididin/features/withdraw/WithDrawSubActivity.kt
@ -20,9 +20,10 @@ import com.ama.core.architecture.util.setOnClickBatch
 import com.gamedog.statisticreporter.StatisticUtil
 import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.VididinEvents
+import com.gamedog.vididin.beans.RECORD_CASH_WITHDRAW
+import com.gamedog.vididin.beans.RecordCash
 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.dialogs.WithdrawBindBankDialog
 import com.gamedog.vididin.features.withdraw.dialogs.WithdrawFailDialog
@ -35,6 +36,7 @@ import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_F
 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.gamedog.vididin.router.Router.WithdrawRecord
 import com.viddin.videos.free.R
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.launch
@ -108,16 +110,15 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {


    private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Double, timeMs: Long) {
-        val newRecord = WithdrawRecord().apply {
-            id = payoutReply.id!!
-            recordNo = payoutReply.record_no
-            cashNum = payCashNum
-            operateMs = timeMs
-            state = TRANSACTION_STATE_ONGOING
+        val newRecord = RecordCash(RECORD_CASH_WITHDRAW, payCashNum).apply {
+            payOutReplyId = payoutReply.id!!
+            payOutReplyNo = payoutReply.record_no
+            dateMs = timeMs
+            withdrawState = TRANSACTION_STATE_ONGOING
            failReason = 0

-            itemIndex = mCurItem.index
-            itemSubIndex = mSelectingIndex
+            withdrawItemIndex = mCurItem.index
+            withdrawItemSubIndex = mSelectingIndex
        }
        WithdrawManager.instance().saveNewRecord(newRecord)
    }
@ -253,8 +254,8 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {

                VididinEvents.EVENT_WITHDRAW_CHECK_RESULT_UPDATED -> {
                    try {
-                        val record = data.mData as WithdrawRecord
-                       if (record.itemIndex > 0) {
+                        val record = data.mData as RecordCash
+                       if (record.withdrawItemIndex > 0) {
                           showTransactionResultDialog(record)
                       }
                    } catch (e: Exception) {
@ -276,17 +277,17 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {
        updateUI()
    }

-    private fun showTransactionResultDialog(record: WithdrawRecord) {
-        if (!record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) {
-            when (record.state) {
+    private fun showTransactionResultDialog(record: RecordCash) {
+        if (!record.hasShowResultDialog && record.withdrawState != TRANSACTION_STATE_ONGOING) {
+            when (record.withdrawState) {
                TRANSACTION_STATE_SUCCESS -> {
-                    showSuccessDialog(record.cashNum)
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    showSuccessDialog(record.amountNum)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                }

                TRANSACTION_STATE_FAIL -> {
                    showFailDialog(WithdrawManager.instance().getFailHintStrRes(record.failReason))
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                }
            }
        }
--- a/app/src/main/java/com/gamedog/vididin/login/AccountManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/login/AccountManager.kt
@ -145,7 +145,7 @@ object AccountManager {
                if (getGold() >= costGoldNum) {
                    adjustGold(-1L * costGoldNum.toInt(), RecordGold(RECORD_GOLD_MINUS_CONVERT_2_CASH, -1L * costGoldNum.toInt()))
                    val adjustCashNum = couldCovertCashTotal * 0.1
-                    adjustCash(adjustCashNum, RecordCash(RECORD_CASH_PLUS_GOLD_CONVERT, adjustCashNum.toDouble(), true))
+                    adjustCash(adjustCashNum, RecordCash(RECORD_CASH_PLUS_GOLD_CONVERT, adjustCashNum.toDouble()))
                    AndroidUtil.showToast("Has convert $costGoldNum gold to $couldCovertCashTotal cash.")
                    return true
                }
--- a/app/src/main/java/com/gamedog/vididin/manager/RecordsManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/RecordsManager.kt
@ -2,6 +2,7 @@ package com.gamedog.vididin.manager

 import com.ama.core.architecture.util.SpUtil
 import com.gamedog.vididin.beans.BaseRecord
+import com.gamedog.vididin.beans.RECORD_CASH_WITHDRAW
 import com.gamedog.vididin.beans.RecordCash
 import com.gamedog.vididin.beans.RecordCashShow
 import com.gamedog.vididin.beans.RecordGold
@ -9,6 +10,8 @@ import com.gamedog.vididin.beans.RecordGoldShow
 import com.gamedog.vididin.beans.RecordZero
 import com.gamedog.vididin.beans.RecordZeroShow
 import com.gamedog.vididin.beans.toShowBean
+import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_ONGOING
+import com.gamedog.vididin.manager.WithdrawManager.Companion.TRANSACTION_STATE_SUCCESS
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@ -78,6 +81,38 @@ class RecordsManager private constructor() {
        return resultList.toList()
    }

+    fun getHasWithdrawSuccessCashCount(): Double {
+        return mCashHelper.getHasWithdrawSuccessCashCount()
+    }
+
+    fun getHasWithdrawSuccessCashCount(itemIndex: Int): Double {
+        return mCashHelper.getHasWithdrawSuccessCashCount(itemIndex)
+    }
+
+    fun getRecord(recordNo: String): RecordCash? {
+        return mCashHelper.getWithdrawRecord(recordNo)
+    }
+
+    fun updateRecordHasNotifyState(recordNo: String) {
+        return mCashHelper.updateRecordHasNotifyState(recordNo)
+    }
+
+    fun saveNewWithdrawRecord(recordNo: RecordCash) {
+        return mCashHelper.saveNewWithdrawRecord(recordNo)
+    }
+
+    fun withdrawUpdateRecord(recordNo: String, newState: Int, failType: Int) : Int {
+        return mCashHelper.updateRecord(recordNo, newState, failType)
+    }
+
+    fun getWithdrawRecordList(): List<RecordCash> {
+        return mCashHelper.getWithdrawRecordList()
+    }
+
+    fun getOngoingRecordList(): List<RecordCash> {
+        return mCashHelper.getOngoingRecordList()
+    }
+
 }


@ -89,6 +124,131 @@ class CashRecordHelper() : BaseRecordHelper<RecordCash>() {
    override fun loadRecordsFromSp(): List<RecordCash> {
        return SpUtil.instance().getList<RecordCash>(mSpKey)
    }
+
+    fun getHasWithdrawSuccessCashCount(): Double {
+        var count = 0.0
+        try {
+            mRecordLocker.lock()
+
+            for (record in mRecordList) {
+                if (record.recordType == RECORD_CASH_WITHDRAW && record.withdrawState == TRANSACTION_STATE_SUCCESS) {
+                    count += record.amountNum
+                }
+            }
+
+            // extra withdraw count from zeroBuy
+            count += ZeroManager.instance().getZeroHasWithdrawSuccessCashCount()
+        } finally {
+            mRecordLocker.unlock()
+        }
+        return count
+    }
+
+    fun getHasWithdrawSuccessCashCount(itemIndex: Int): Double {
+        var count = 0.0
+        try {
+            mRecordLocker.lock()
+
+            for (record in mRecordList) {
+                if (record.withdrawItemIndex == itemIndex
+                    && record.recordType == RECORD_CASH_WITHDRAW
+                    && record.withdrawState == TRANSACTION_STATE_SUCCESS) {
+                    count += record.amountNum
+                }
+            }
+        } finally {
+            mRecordLocker.unlock()
+        }
+        return count
+    }
+
+    fun getWithdrawRecord(recordNo: String): RecordCash? {
+        try {
+            mRecordLocker.lock()
+            mRecordList.forEachIndexed { index, record ->
+                if (record.payOutReplyNo == recordNo) {
+                    return record
+                }
+            }
+        } finally {
+            mRecordLocker.unlock()
+        }
+        return null
+    }
+
+    fun updateRecordHasNotifyState(recordNo: String) {
+        val recordBean: RecordCash? = getWithdrawRecord(recordNo)
+        recordBean?.let {
+            it.hasShowResultDialog = true
+            saveRecordList2Sp()
+        }
+    }
+
+    fun saveNewWithdrawRecord(newRecord: RecordCash) {
+        try {
+            mRecordLocker.lock()
+            mRecordList.add(newRecord)
+        } finally {
+            mRecordLocker.unlock()
+        }
+        saveRecordList2Sp()
+    }
+
+    fun updateRecord(recordNo: String, newState: Int, failType: Int): Int  {
+        var withdrawItemIndex = -1
+        try {
+            mRecordLocker.lock()
+            mRecordList.forEachIndexed { index, record ->
+                if (record.payOutReplyNo == recordNo) {
+                    if (record.withdrawState != newState) {
+                        withdrawItemIndex = record.withdrawItemIndex
+                        record.withdrawState = newState
+                        record.failReason = failType
+                    }
+                    return@forEachIndexed
+                }
+            }
+        } finally {
+            mRecordLocker.unlock()
+        }
+
+        if (withdrawItemIndex >= 0) {
+            saveRecordList2Sp()
+        }
+
+        return withdrawItemIndex
+    }
+
+    fun getWithdrawRecordList(): List<RecordCash> {
+        try {
+            mRecordLocker.lock()
+            val clonedList = mutableListOf<RecordCash>()
+            mRecordList.forEach {
+                if (it.recordType == RECORD_CASH_WITHDRAW) {
+                    clonedList.add(it)
+                }
+            }
+            return clonedList
+        } finally {
+            mRecordLocker.unlock()
+        }
+    }
+
+    fun getOngoingRecordList(): List<RecordCash> {
+        try {
+            mRecordLocker.lock()
+            val clonedList = mutableListOf<RecordCash>()
+            mRecordList.forEach {
+                if (it.recordType == RECORD_CASH_WITHDRAW && it.withdrawState == TRANSACTION_STATE_ONGOING) {
+                    clonedList.add(it)
+                }
+            }
+            return clonedList
+        } finally {
+            mRecordLocker.unlock()
+        }
+    }
+
 }

 class GoldRecordHelper() : BaseRecordHelper<RecordGold>() {
@ -109,16 +269,10 @@ class ZeroRecordHelper() : BaseRecordHelper<RecordZero>() {
 abstract class BaseRecordHelper<T: BaseRecord> {
    abstract val mSpKey: String
    private val mbgScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-    private val mRecordLocker = ReentrantLock()
-    private val mRecordList: MutableList<T> by lazy { loadRecordsFromSp().toMutableList() }
+    protected val mRecordLocker = ReentrantLock()
+    protected val mRecordList: MutableList<T> by lazy { loadRecordsFromSp().toMutableList() }


-    init {
-        /*mbgScope.launch {
-            mRecordList = loadRecordsFromSp().toMutableList()
-        }*/
-    }
-
    abstract fun loadRecordsFromSp() : List<T>


@ -126,7 +280,7 @@ abstract class BaseRecordHelper<T: BaseRecord> {
        return mRecordList.toList()
    }

-    private fun saveRecordList() {
+    protected fun saveRecordList2Sp() {
        mbgScope.launch {
            try {
                mRecordLocker.lock()
@ -134,7 +288,6 @@ abstract class BaseRecordHelper<T: BaseRecord> {
            } finally {
                mRecordLocker.unlock()
            }
-
        }
    }

@ -143,7 +296,7 @@ abstract class BaseRecordHelper<T: BaseRecord> {
            try {
                mRecordLocker.lock()
                mRecordList.add(dataBean)
-                saveRecordList()
+                saveRecordList2Sp()
            } finally {
                mRecordLocker.unlock()
            }
@ -163,7 +316,7 @@ abstract class BaseRecordHelper<T: BaseRecord> {
                    }
                }

-                saveRecordList()
+                saveRecordList2Sp()
            } finally {
                mRecordLocker.unlock()
            }
--- a/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/WithdrawManager.kt
@ -10,11 +10,9 @@ import com.ama.core.architecture.util.eventbus.NotifyMan
 import com.gamedog.statisticreporter.StatisticUtil
 import com.gamedog.vididin.VidiConst
 import com.gamedog.vididin.VididinEvents
-import com.gamedog.vididin.beans.RECORD_CASH_MINUS_WITHDRAW_SUCCESS
 import com.gamedog.vididin.beans.RecordCash
 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.core.login.login.AccountManager
 import com.gamedog.vididin.manager.WithdrawManager.Companion.STATE_NEED_WATCH_AD
 import com.gamedog.vididin.netbase.NetworkUtil
@ -25,17 +23,13 @@ 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 mBgScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

-    private val mRecordLocker = ReentrantLock()
-    private val mRecordList: MutableList<WithdrawRecord> by lazy {
-        SpUtil.instance().getList<WithdrawRecord>(SpUtil.KEY_WITHDRAW_HISTORY_LIST).toMutableList()
-    }
+

    private val mWithdrawItemList: MutableList<WithdrawItem> by lazy {
        val itemList = SpUtil.instance().getList<WithdrawItem>(SpUtil.KEY_WITHDRAW_ITEM_LIST).toMutableList()
@ -150,27 +144,11 @@ class WithdrawManager private constructor() {


    fun getHasWithdrawSuccessCashCount(): Double {
-        var count = 0.0
-        for (record in mRecordList) {
-            if (record.state == TRANSACTION_STATE_SUCCESS) {
-                count += record.cashNum
-            }
-        }
-
-        // extra withdraw count from zeroBuy
-        count += ZeroManager.instance().getZeroHasWithdrawSuccessCashCount()
-
-        return count
+        return RecordsManager.instance().getHasWithdrawSuccessCashCount()
    }

    fun getHasWithdrawSuccessCashCount(itemIndex: Int): Double {
-        var count = 0.0
-        for (record in mRecordList) {
-            if (record.state == TRANSACTION_STATE_SUCCESS && record.itemIndex == itemIndex) {
-                count += record.cashNum
-            }
-        }
-        return count
+        return RecordsManager.instance().getHasWithdrawSuccessCashCount(itemIndex)
    }

    fun addAdEarnForSubBean(itemIndex: Int, selectedSubIndex: Int, earnMoneyNum: Double) : Boolean {
@ -230,54 +208,20 @@ class WithdrawManager private constructor() {
        }
    }

-    fun saveRecordHasNotifyState(recordNo: String) {
-        val recordBean = getRecord(recordNo)
-        recordBean?.let {
-            it.hasShowResultDialog = true
-            saveRecords2Sp()
-        }
+    fun updateRecordHasNotifyState(recordNo: String) {
+        RecordsManager.instance().updateRecordHasNotifyState(recordNo)
    }

-    fun saveNewRecord(newRecord: WithdrawRecord) {
-        try {
-            mRecordLocker.lock()
-            mRecordList.add(newRecord)
-        } finally {
-            mRecordLocker.unlock()
-        }
-        saveRecords2Sp()
+    fun saveNewRecord(newRecord: RecordCash) {
+        RecordsManager.instance().saveNewWithdrawRecord(newRecord)
        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
-
-                        if (newState == STATE_HAS_WITHDRAWED) {
-                            checkIfItemFinishAndReset(record.itemIndex)
-                        }
-                    }
-                    return@forEachIndexed
-                }
-            }
-        } finally {
-            mRecordLocker.unlock()
-        }
-
-        if (needSaveSp) {
-            saveRecords2Sp()
+        val withdrawItemIndex = RecordsManager.instance().withdrawUpdateRecord(recordNo, newState, failType)
+        if (newState == STATE_HAS_WITHDRAWED && withdrawItemIndex >= 0) {
+            checkIfItemFinishAndReset(withdrawItemIndex)
        }
    }

@ -322,59 +266,31 @@ class WithdrawManager private constructor() {
    }


-    fun getClonedRecordList(): List<WithdrawRecord> {
-        try {
-            mRecordLocker.lock()
-            val clonedList = mutableListOf<WithdrawRecord>()
-            clonedList.addAll(mRecordList)
-            return clonedList
-        } finally {
-            mRecordLocker.unlock()
-        }
-        return emptyList()
+    fun getClonedRecordList(): List<RecordCash> {
+        return RecordsManager.instance().getWithdrawRecordList()
    }

-    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 getOngoingRecordList(): List<RecordCash> {
+        return RecordsManager.instance().getOngoingRecordList()
+    }
+
+    private fun getRecord(recordNo: String): RecordCash? {
+        return RecordsManager.instance().getRecord(recordNo)
    }


    private fun loopCheckTransactionState() {
-        var unCheckCount = 0
-        try {
-            mRecordLocker.lock()
-            mRecordList.forEach { record ->
-                if (record.state == TRANSACTION_STATE_ONGOING) {
-                    unCheckCount++
-                }
-            }
-        } finally {
-            mRecordLocker.unlock()
-        }
+        val ongoingList = getOngoingRecordList()

-
-        if (unCheckCount > 0) {
+        if (ongoingList.isNotEmpty()) {
            try {
-                mRecordLocker.lock()
-                mRecordList.forEachIndexed { index, record ->
-                    if (record.state == TRANSACTION_STATE_ONGOING) {
-                        mBgScope.launch {
-                            requestCheck(record.recordNo)
-                        }
+                ongoingList.forEachIndexed { index, record ->
+                    mBgScope.launch {
+                        requestCheck(record.payOutReplyNo)
                    }
                }
-            } finally {
-                mRecordLocker.unlock()
+            } catch (e: Exception) {
+                e.printStackTrace()
            }
        }
    }
@ -439,29 +355,25 @@ class WithdrawManager private constructor() {
        notifyWithdrawCheckResult(recordNo)
        val recordBean = getRecord(recordNo)
        recordBean?.let {
-            RecordsManager.instance().updateCashRecord(RecordCash(
-                RECORD_CASH_MINUS_WITHDRAW_SUCCESS, it.cashNum.toDouble(), true).apply { uuid = recordNo })
-
+            RecordsManager.instance().withdrawUpdateRecord(recordNo, TRANSACTION_STATE_SUCCESS, 0)
            updateFirstWithdraw01Task(it)
-
-
-            sendWithdrawResultStatistic(it.cashNum, true, 0)
+            sendWithdrawResultStatistic(it.amountNum, true, 0)
        }
    }

-    private fun updateFirstWithdraw01Task(recordBean: WithdrawRecord) {
-        if (recordBean.cashNum == 0.1 && !TaskManager.instance().newbieFirstWithdrawStatus().getStatusBean().hasClaimReward) {
+    private fun updateFirstWithdraw01Task(recordBean: RecordCash) {
+        if (recordBean.amountNum == 0.1 && !TaskManager.instance().newbieFirstWithdrawStatus().getStatusBean().hasClaimReward) {
            TaskManager.instance().newbieFirstWithdrawStatus().claimReward()
        }
    }

    private fun handleTransactionFailed(recordNo: String, failedType: Int) {
        updateRecord(recordNo, TRANSACTION_STATE_FAIL, failedType)
-        val recordBean = WithdrawManager.instance?.getRecord(recordNo)
-        recordBean?.let {
-            sendWithdrawResultStatistic(it.cashNum, false, failedType)
-        }
        notifyWithdrawCheckResult(recordNo)
+        val recordBean = getRecord(recordNo)
+        recordBean?.let {
+            sendWithdrawResultStatistic(it.amountNum, false, failedType)
+        }
    }

    private fun sendWithdrawResultStatistic(cashNum: Double, isSuccess: Boolean, failType: Int) {
--- a/app/src/main/java/com/gamedog/vididin/manager/ZeroManager.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/ZeroManager.kt
@ -267,7 +267,7 @@ class ZeroManager private constructor() {
            e.printStackTrace()
        }

-        RecordsManager.instance().appendCashRecord(RecordCash(RECORD_CASH_ZERO_WITHDRAW_SUCCESS, withdrawCashNum, true))
+        RecordsManager.instance().appendCashRecord(RecordCash(RECORD_CASH_ZERO_WITHDRAW_SUCCESS, withdrawCashNum))
    }

    fun startWithdrawProcess(activity: Activity, item: ZeroBuyItem) {
--- a/app/src/main/java/com/gamedog/vididin/manager/helpers/BoxTaskHelper.kt
+++ b/app/src/main/java/com/gamedog/vididin/manager/helpers/BoxTaskHelper.kt
@ -330,7 +330,7 @@ class BoxTaskHelper: BaseTaskHelper<TaskStateBoxRoot, BoxTaskRoot>() {
        try {
            val couldClaimCashNum = getCouldClaimCashNum()
            if (couldClaimCashNum > 0F) {
-                AccountManager.adjustCash(couldClaimCashNum, RecordCash(RECORD_CASH_PLUS_BOX_TASK, couldClaimCashNum.toDouble(), true))
+                AccountManager.adjustCash(couldClaimCashNum, RecordCash(RECORD_CASH_PLUS_BOX_TASK, couldClaimCashNum.toDouble()))
                mStateBean.boxList.forEachIndexed { index, box ->
                    if (getBoxStateEnum(index) == STATE_FINISH) {
                        box.hasClaimedReward = true
--- a/core/architecture/src/main/java/com/ama/core/architecture/util/SpUtil.kt
+++ b/core/architecture/src/main/java/com/ama/core/architecture/util/SpUtil.kt
@ -36,7 +36,7 @@ class SpUtil private constructor(spFileName: String) {
        const val KEY_ZEROBUY_WIN_ITEMS = "KEY_ZEROBUY_WIN_ITEMS"


-        const val KEY_WITHDRAW_HISTORY_LIST = "KEY_WITHDRAW_HISTORY_LIST"
+        //const val KEY_WITHDRAW_HISTORY_LIST = "KEY_WITHDRAW_HISTORY_LIST"
        const val KEY_WITHDRAW_ITEM_LIST = "KEY_WITHDRAW_ITEM_LIST"