合并提现记录到 unique RecordCash

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 amountNum: Double = 0.0,) : BaseRecord() {
-                       var isSuccess: Boolean = false,
+
-                       var withdrawFailType: Int = 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

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 payOutReplyId: String = "",
-    var recordNo: 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 withdrawItemIndex: Int = 0,
-    var itemSubIndex: Int = 0,
+    var withdrawItemSubIndex: Int = 0,
     var hasShowResultDialog: Boolean = false
-)
+)*/

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

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
+                        val record = data.mData as RecordCash
-                        if (record.itemIndex == 0) {
+                        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) {
+    private fun showTransactionResultDialog(record: RecordCash) {
-        if (!record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) {
+        if (!record.hasShowResultDialog && record.withdrawState != TRANSACTION_STATE_ONGOING) {
-            when (record.state) {
+            when (record.withdrawState) {
                 TRANSACTION_STATE_SUCCESS -> {
-                    showSuccessDialog(record.cashNum)
+                    showSuccessDialog(record.amountNum)
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    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) {
+    private fun saveNewRecord(payoutReply: PayoutReply, payCashNum: Double, timeMsNow: Long) {
-        val newRecord = WithdrawRecord().apply {
+        val newRecord = RecordCash(RECORD_CASH_WITHDRAW, payCashNum).apply {
-            id = payoutReply.id!!
+            payOutReplyId = payoutReply.id!!
-            recordNo = payoutReply.record_no
+            payOutReplyNo = payoutReply.record_no
-            cashNum = payCashNum
+            dateMs = timeMsNow
-            operateMs = timeMs
+            withdrawState = TRANSACTION_STATE_ONGOING
-            state = 1
             failReason = 0
         }
 

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 {
+        val newRecord = RecordCash(RECORD_CASH_WITHDRAW, payCashNum).apply {
-            id = payoutReply.id!!
+            payOutReplyId = payoutReply.id!!
-            recordNo = payoutReply.record_no
+            payOutReplyNo = payoutReply.record_no
-            cashNum = payCashNum
+            dateMs = timeMs
-            operateMs = timeMs
+            withdrawState = TRANSACTION_STATE_ONGOING
-            state = TRANSACTION_STATE_ONGOING
             failReason = 0
 
-            itemIndex = mCurItem.index
+            withdrawItemIndex = mCurItem.index
-            itemSubIndex = mSelectingIndex
+            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
+                        val record = data.mData as RecordCash
-                       if (record.itemIndex > 0) {
+                       if (record.withdrawItemIndex > 0) {
                            showTransactionResultDialog(record)
                        }
                     } catch (e: Exception) {
@@ -276,17 +277,17 @@ class WithDrawSubActivity : AppViewsEmptyViewModelActivity<ViewBinding>() {
         updateUI()
     }
 
-    private fun showTransactionResultDialog(record: WithdrawRecord) {
+    private fun showTransactionResultDialog(record: RecordCash) {
-        if (!record.hasShowResultDialog && record.state != TRANSACTION_STATE_ONGOING) {
+        if (!record.hasShowResultDialog && record.withdrawState != TRANSACTION_STATE_ONGOING) {
-            when (record.state) {
+            when (record.withdrawState) {
                 TRANSACTION_STATE_SUCCESS -> {
-                    showSuccessDialog(record.cashNum)
+                    showSuccessDialog(record.amountNum)
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                 }
 
                 TRANSACTION_STATE_FAIL -> {
                     showFailDialog(WithdrawManager.instance().getFailHintStrRes(record.failReason))
-                    WithdrawManager.instance().saveRecordHasNotifyState(record.recordNo)
+                    WithdrawManager.instance().updateRecordHasNotifyState(record.payOutReplyNo)
                 }
             }
         }

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
                 }

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()
+    protected val mRecordLocker = ReentrantLock()
-    private val mRecordList: MutableList<T> by lazy { loadRecordsFromSp().toMutableList() }
+    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()
             }

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
+        return RecordsManager.instance().getHasWithdrawSuccessCashCount()
-        for (record in mRecordList) {
-            if (record.state == TRANSACTION_STATE_SUCCESS) {
-                count += record.cashNum
-            }
-        }
-
-        // extra withdraw count from zeroBuy
-        count += ZeroManager.instance().getZeroHasWithdrawSuccessCashCount()
-
-        return count
     }
 
     fun getHasWithdrawSuccessCashCount(itemIndex: Int): Double {
-        var count = 0.0
+        return RecordsManager.instance().getHasWithdrawSuccessCashCount(itemIndex)
-        for (record in mRecordList) {
-            if (record.state == TRANSACTION_STATE_SUCCESS && record.itemIndex == itemIndex) {
-                count += record.cashNum
-            }
-        }
-        return count
     }
 
     fun addAdEarnForSubBean(itemIndex: Int, selectedSubIndex: Int, earnMoneyNum: Double) : Boolean {
@@ -230,54 +208,20 @@ class WithdrawManager private constructor() {
         }
     }
 
-    fun saveRecordHasNotifyState(recordNo: String) {
+    fun updateRecordHasNotifyState(recordNo: String) {
-        val recordBean = getRecord(recordNo)
+        RecordsManager.instance().updateRecordHasNotifyState(recordNo)
-        recordBean?.let {
-            it.hasShowResultDialog = true
-            saveRecords2Sp()
-        }
     }
 
-    fun saveNewRecord(newRecord: WithdrawRecord) {
+    fun saveNewRecord(newRecord: RecordCash) {
-        try {
+        RecordsManager.instance().saveNewWithdrawRecord(newRecord)
-            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
+        val withdrawItemIndex = RecordsManager.instance().withdrawUpdateRecord(recordNo, newState, failType)
-        try {
+        if (newState == STATE_HAS_WITHDRAWED && withdrawItemIndex >= 0) {
-            mRecordLocker.lock()
+            checkIfItemFinishAndReset(withdrawItemIndex)
-            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()
         }
     }
 
@@ -322,59 +266,31 @@ class WithdrawManager private constructor() {
     }
 
 
-    fun getClonedRecordList(): List<WithdrawRecord> {
+    fun getClonedRecordList(): List<RecordCash> {
-        try {
+        return RecordsManager.instance().getWithdrawRecordList()
-            mRecordLocker.lock()
-            val clonedList = mutableListOf<WithdrawRecord>()
-            clonedList.addAll(mRecordList)
-            return clonedList
-        } finally {
-            mRecordLocker.unlock()
-        }
-        return emptyList()
     }
 
-    private fun getRecord(recordNo: String): WithdrawRecord? {
+    private fun getOngoingRecordList(): List<RecordCash> {
-        try {
+        return RecordsManager.instance().getOngoingRecordList()
-            mRecordLocker.lock()
+    }
-            mRecordList.forEachIndexed { index, record ->
+
-                if (record.recordNo == recordNo) {
+    private fun getRecord(recordNo: String): RecordCash? {
-                    return record
+        return RecordsManager.instance().getRecord(recordNo)
-                }
-            }
-        } finally {
-            mRecordLocker.unlock()
-        }
-        return null
     }
 
 
     private fun loopCheckTransactionState() {
-        var unCheckCount = 0
+        val ongoingList = getOngoingRecordList()
-        try {
-            mRecordLocker.lock()
-            mRecordList.forEach { record ->
-                if (record.state == TRANSACTION_STATE_ONGOING) {
-                    unCheckCount++
-                }
-            }
-        } finally {
-            mRecordLocker.unlock()
-        }
 
-
+        if (ongoingList.isNotEmpty()) {
-        if (unCheckCount > 0) {
             try {
-                mRecordLocker.lock()
+                ongoingList.forEachIndexed { index, record ->
-                mRecordList.forEachIndexed { index, record ->
+                    mBgScope.launch {
-                    if (record.state == TRANSACTION_STATE_ONGOING) {
+                        requestCheck(record.payOutReplyNo)
-                        mBgScope.launch {
-                            requestCheck(record.recordNo)
-                        }
                     }
                 }
-            } finally {
+            } catch (e: Exception) {
-                mRecordLocker.unlock()
+                e.printStackTrace()
             }
         }
     }
@@ -439,29 +355,25 @@ class WithdrawManager private constructor() {
         notifyWithdrawCheckResult(recordNo)
         val recordBean = getRecord(recordNo)
         recordBean?.let {
-            RecordsManager.instance().updateCashRecord(RecordCash(
+            RecordsManager.instance().withdrawUpdateRecord(recordNo, TRANSACTION_STATE_SUCCESS, 0)
-                RECORD_CASH_MINUS_WITHDRAW_SUCCESS, it.cashNum.toDouble(), true).apply { uuid = recordNo })
-
             updateFirstWithdraw01Task(it)
-
+            sendWithdrawResultStatistic(it.amountNum, true, 0)
-
-            sendWithdrawResultStatistic(it.cashNum, true, 0)
         }
     }
 
-    private fun updateFirstWithdraw01Task(recordBean: WithdrawRecord) {
+    private fun updateFirstWithdraw01Task(recordBean: RecordCash) {
-        if (recordBean.cashNum == 0.1 && !TaskManager.instance().newbieFirstWithdrawStatus().getStatusBean().hasClaimReward) {
+        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) {

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) {

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

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"