refactor(CardReplaceActivity): 重构补卡流程并优化界面显示- 重新设计卡片信息展示布局，增加新卡卡地址、客户编号等字段 ...

zuojincheng

17 小时以前 0faae97cd2523f840c426da68464e577e01dfa80

 generallibrary/src/main/java/com/dayu/general/activity/CardReplaceActivity.kt

@@ -1,173 +1,556 @@
package com.dayu.general.activity

import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.view.LayoutInflater
import android.util.TypedValue
import android.view.View
import android.view.inputmethod.EditorInfo
import androidx.recyclerview.widget.LinearLayoutManager
import android.widget.RadioButton
import android.widget.Toast
import com.dayu.baselibrary.net.subscribers.SubscriberListener
import com.dayu.baselibrary.utils.MornyUtil
import com.dayu.baselibrary.utils.ToastUtil
import com.dayu.general.adapter.CardReplaceAdapter
import com.dayu.general.bean.net.CardReplaceInfo
import com.dayu.general.bean.net.CardReplaceResponse
import com.dayu.baselibrary.view.TipDialog
import com.dayu.baselibrary.view.TitleBar
import com.dayu.general.BaseApplication
import com.dayu.general.R
import com.dayu.general.bean.card.UserCard
import com.dayu.general.bean.net.CardInfoResult
import com.dayu.general.bean.net.CardInfoByClientResult
import com.dayu.general.bean.net.CardReplaceResult
import com.dayu.general.bean.net.PaymentMethod
import com.dayu.general.bean.net.PaymentMethodResponse
import com.dayu.general.databinding.ActivityCardReplaceBinding
import com.dayu.general.net.ApiManager
import com.dayu.general.net.BaseResponse
import com.scwang.smart.refresh.layout.api.RefreshLayout
import com.scwang.smart.refresh.layout.listener.OnRefreshLoadMoreListener
import com.dayu.general.tool.CardCommon
import com.dayu.general.tool.CardOperationType
import com.dayu.general.tool.NfcReadHelper

/**
 * 卡片补办Activity
 * @author: zuo
 * @desc: 补卡Activity
 * @since: 2025/6/17
 */
class CardReplaceActivity : BaseActivity() {

class CardReplaceActivity : BaseNfcActivity() {
    private lateinit var binding: ActivityCardReplaceBinding
    private var currentCardInfo: CardReplaceInfo? = null
    private lateinit var adapter: CardReplaceAdapter
    
    // 分页参数
    private var pageCurr: Int = 1
    private val pageSize: Int = 20
    private var hasMoreData: Boolean = true
    
    private var cardNumber: String? = null
    private var cardInfo: CardInfoResult? = null
    private var cardInfoByClient: CardInfoByClientResult? = null
    private var userCard: UserCard? = null
    private var cardNum: String? = null
    private var newCardNumber: String? = null // 新卡卡号

    // 支付方式相关属性
    private var paymentMethod: String = "现金"
    private var paymentId: Long = 0
    private var paymentMethodList: List<PaymentMethod> = listOf()

    companion object {
        /**
         * 启动补卡Activity
         */
        fun start(context: Context, clientNum: String) {
            val intent = Intent(context, CardReplaceActivity::class.java)
            intent.putExtra("cardNum", clientNum)
            context.startActivity(intent)
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityCardReplaceBinding.inflate(LayoutInflater.from(this))
        binding = ActivityCardReplaceBinding.inflate(layoutInflater)
        setContentView(binding.root)
        

        // 获取传递的clientNum参数
        cardNum = intent.getStringExtra("cardNum")

        initView()
        initRecyclerView()
        setupRefreshLayout()
        loadCardReplaceList(true)
        // 获取支付方式
        getPaymentMethods()

        // 无论是否有clientNum，都先显示读卡界面，等待用户刷新卡
        resetToReadingState()
    }
    
    /**
     * 初始化视图
     */

    private fun initView() {
        // 初始化标题栏
        binding.titleBar.setOnItemclickListner(com.dayu.baselibrary.view.TitleBar.ClickType_LEFT_IMAGE) { 
            finish() 
        // 设置TitleBar的返回按钮点击事件
        binding.titleBar.setOnItemclickListner(TitleBar.ClickType_LEFT_IMAGE) {
            finish()
        }
    }
    
    /**
     * 初始化RecyclerView
     */
    private fun initRecyclerView() {
        // 创建适配器
        adapter = CardReplaceAdapter(this)
        
        // 设置布局管理器和适配器
        binding.recyclerView.apply {
            layoutManager = LinearLayoutManager(this@CardReplaceActivity)
            adapter = this@CardReplaceActivity.adapter

        // 设置补卡按钮点击事件
        binding.btnReplace.setOnClickListener {
            performCardReplace()
        }
        
        // 设置卡片点击监听器 - 点击列表项时执行补办操作
        adapter.setOnItemClickListener { cardInfo ->
            currentCardInfo = cardInfo
            // 直接执行补办操作
            performCardReplace(cardInfo)
        }
    }
    
    /**
     * 设置刷新布局
     */
    private fun setupRefreshLayout() {
        binding.refreshLayout.setOnRefreshLoadMoreListener(object : OnRefreshLoadMoreListener {
            override fun onRefresh(refreshLayout: RefreshLayout) {
                // 下拉刷新，重置页码并重新加载数据
                pageCurr = 1
                hasMoreData = true
                loadCardReplaceList(true)
            }
            
            override fun onLoadMore(refreshLayout: RefreshLayout) {
                // 上拉加载更多
                if (hasMoreData) {
                    pageCurr++
                    loadCardReplaceList(false)
                } else {
                    // 没有更多数据时，结束加载更多
                    refreshLayout.finishLoadMoreWithNoMoreData()
                }
            }
        })
    }

    /**
     * 加载可补办卡片列表
     * 
     * @param isRefresh 是否为刷新操作（true: 刷新，false: 加载更多）
     * 获取支付方式列表
     */
    private fun loadCardReplaceList(isRefresh: Boolean = true) {
        // 构建查询参数
        val params = HashMap<String, Any>().apply {
            put("pageCurr", pageCurr)
            put("pageSize", pageSize)
        }

        // 调用API查询挂失卡片信息
    private fun getPaymentMethods() {
        ApiManager.getInstance().requestGetLoading(
            this,
            "sell/clientcard/getUnreplaced",
            CardReplaceResponse::class.java,
            params,
            object : SubscriberListener<BaseResponse<CardReplaceResponse>>() {
                override fun onNext(response: BaseResponse<CardReplaceResponse>) {
                    // 结束刷新或加载更多状态
                    finishRefreshOrLoadMore(isRefresh)
                    
            "sell/paymentmethod/get",
            PaymentMethodResponse::class.java,
            null,
            object : SubscriberListener<BaseResponse<PaymentMethodResponse>>() {
                override fun onNext(response: BaseResponse<PaymentMethodResponse>) {
                    if (response.success) {
                        val cardResponse = response.content
                        val cardList = cardResponse?.obj ?: emptyList()
                        
                        // 更新数据列表
                        if (isRefresh) {
                            adapter.setData(cardList)
                        } else {
                            adapter.addData(cardList)
                        }
                        
                        // 判断是否还有更多数据
                        hasMoreData = cardList.size >= pageSize
                        if (!hasMoreData && !isRefresh) {
                            binding.refreshLayout.finishLoadMoreWithNoMoreData()
                        // 获取支付方式列表
                        val paymentMethods = response.content?.obj ?: listOf()
                        if (paymentMethods.isNotEmpty()) {
                            paymentMethodList = paymentMethods
                            // 更新支付方式显示
                            updatePaymentMethodRadioGroup()
                        }
                    } else {
                        ToastUtil.show(response.msg)
                        Toast.makeText(
                            this@CardReplaceActivity,
                            "获取支付方式失败: ${response.msg}",
                            Toast.LENGTH_SHORT
                        ).show()
                    }
                }
                

                override fun onError(e: Throwable?) {
                    // 结束刷新或加载更多状态
                    finishRefreshOrLoadMore(isRefresh)
                    ToastUtil.show("查询失败: ${e?.message ?: "未知错误"}")
                    super.onError(e)
                    Toast.makeText(
                        this@CardReplaceActivity,
                        "获取支付方式失败: ${e?.message ?: "网络异常"}",
                        Toast.LENGTH_SHORT
                    ).show()
                }
            }
        )
    }
    

    /**
     * 结束刷新或加载更多状态
     * 更新支付方式RadioGroup
     */
    private fun finishRefreshOrLoadMore(isRefresh: Boolean) {
        if (isRefresh) {
            binding.refreshLayout.finishRefresh()
        } else {
            binding.refreshLayout.finishLoadMore()
    private fun updatePaymentMethodRadioGroup() {
        // 清空原有RadioButton
        binding.paymentMethodGroup.removeAllViews()

        // 动态添加RadioButton
        paymentMethodList.forEachIndexed { index, method ->
            val radioButton = RadioButton(this)
            radioButton.id = View.generateViewId() // 生成唯一ID
            radioButton.layoutParams = android.widget.LinearLayout.LayoutParams(
                0,
                resources.getDimensionPixelSize(R.dimen.dimen_40),
                1.0f
            )

            // 如果不是最后一个按钮，添加右边距
            if (index < paymentMethodList.size - 1) {
                (radioButton.layoutParams as android.widget.LinearLayout.LayoutParams).rightMargin =
                    resources.getDimensionPixelSize(R.dimen.dimen_15)
            }

            radioButton.text = method.name
            radioButton.background = resources.getDrawable(R.drawable.radio_selector)
            radioButton.buttonDrawable = null
            radioButton.gravity = android.view.Gravity.CENTER
            radioButton.setTextColor(resources.getColorStateList(R.color.radio_button_text_color))
            radioButton.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14f)

            // 添加到RadioGroup
            binding.paymentMethodGroup.addView(radioButton)

            // 默认选中第一个
            if (index == 0) {
                radioButton.isChecked = true
                paymentMethod = method.name
                paymentId = method.id
            }
        }

        // 设置支付方式选择监听
        binding.paymentMethodGroup.setOnCheckedChangeListener { group, checkedId ->
            // 根据选中的ID获取支付方式
            for (i in 0 until group.childCount) {
                val radioButton = group.getChildAt(i) as RadioButton
                if (radioButton.id == checkedId) {
                    paymentMethod = radioButton.text.toString()
                    paymentId = paymentMethodList[i].id
                    break
                }
            }
        }
    }
    

    /**
     * 执行卡片补办操作
     * 重置到读卡状态
     */
    private fun performCardReplace(cardInfo: CardReplaceInfo) {
        // 这里实现卡片补办的业务逻辑
        ToastUtil.show("选择了卡片进行补办：${cardInfo.cardNum}")
    private fun resetToReadingState() {
        binding.scrollReadCard.visibility = android.view.View.VISIBLE
        binding.cardInfoContainer.visibility = android.view.View.GONE
        binding.bottomButtonContainer.visibility = android.view.View.GONE
        cardNumber = null
        cardInfo = null
        cardInfoByClient = null
        newCardNumber = null
        binding.etCardCost.setText("")
        binding.etReturnAmount.setText("")
    }

    /**
     * 显示确认对话框
     */
    private fun showConfirmDialog(message: String, onConfirm: () -> Unit) {
        val confirmDialog = TipDialog(this, message) {
            onConfirm()
        }
        confirmDialog.show()
    }

    override fun onNfcBack(intent: Intent?) {
        intent?.let {
            // 处理正常的读卡操作
            handleNfcIntent(it)
        } ?: run {
            showConfirmDialog("NFC数据异常，请重新刷卡") {
            }
        }
    }

    /**
     * 处理NFC刷卡信息
     */
    private fun handleNfcIntent(intent: Intent) {
        try {
            // 检查intent中是否包含NFC Tag
            if (intent.getParcelableExtra<android.nfc.Tag>(android.nfc.NfcAdapter.EXTRA_TAG) == null) {
                showConfirmDialog("未检测到NFC卡片，请确保卡片已正确放置") {
                }
                return
            }

            val nfcAdapter = NfcReadHelper.getInstance(intent, this)
            val cardTypeAndCardNumber = nfcAdapter.getCardTypeAndCardNumber()
            if (cardTypeAndCardNumber.isNullOrBlank() || !cardTypeAndCardNumber.contains(",")) {
                showConfirmDialog("卡片信息读取失败，请重新刷卡") {
                }
                return
            }
            val parts = cardTypeAndCardNumber.split(",")
            if (parts.size < 2) {
                showConfirmDialog("卡片信息格式异常，请重新刷卡") {
                }
                return
            }
            val readCardNumber = parts[0]
            val cardType = parts[1]

            if (readCardNumber.isBlank()) {
                showConfirmDialog("卡号为空，无法进行操作，请重新刷卡") {
                }
                return
            }

            // 保存新卡卡号
            this.newCardNumber = readCardNumber

            when (cardType) {
                "00" -> {
                    // 白卡才可以补卡
                    if (cardNum != null) {
                        // 如果有clientNum，使用clientNum获取卡信息
                        getCardInfoByClientNum(cardNum!!)
                    } else {
                        showConfirmDialog("获取旧卡信息数据失败") {
                            resetToReadingState()
                        }
                    }
                }

                CardCommon.USER_CARD_TYPE_1,
                CardCommon.USER_CARD_TYPE_2,
                CardCommon.USER_CARD_TYPE_3 -> {
                    // 用户卡：解析卡内数据并调用接口
                    showConfirmDialog("用户卡不支持补卡") {
                        resetToReadingState()
                    }
                }

                else -> {

                }
            }

        } catch (e: Exception) {
            showConfirmDialog("读卡异常：${e.message}") {
            }
            e.printStackTrace()
        }
    }


    /**
     * 处理卡信息获取错误
     */
    private fun handleCardInfoError(code: String?, msg: String?) {
        val errorMessage: String = when (code) {
            "1001" -> {
                "该卡片未在系统中注册，无法进行补卡操作。"
            }

            else -> {
                when {
                    msg.isNullOrBlank() -> "获取卡信息失败，请重新刷卡重试。"
                    msg.contains("数据不存在") -> "该卡片未在系统中注册，无法进行补卡操作。"
                    msg.contains("网络") -> "网络连接异常，请检查网络连接后重新刷卡。"
                    msg.contains("超时") -> "网络请求超时，请重新刷卡重试。"
                    else -> "获取卡信息失败：$msg\n\n请重新刷卡重试。"
                }
            }
        }

        // 显示错误信息的对话框
        showConfirmDialog(errorMessage) {
            resetToReadingState()
        }
    }

    /**
     * 执行补卡操作
     */
    private fun performCardReplace() {
        // 验证输入
        val cardCostStr = binding.etCardCost.text.toString().trim()
        val returnAmountStr = binding.etReturnAmount.text.toString().trim()

        // 工本费验证（必填）
        if (cardCostStr.isEmpty()) {
            ToastUtil.show("请输入工本费")
            return
        }

        val cardCost = try {
            val cost = cardCostStr.toDouble()
            if (cost < 0) {
                ToastUtil.show("工本费不能为负数")
                return
            }
            cost
        } catch (e: NumberFormatException) {
            ToastUtil.show("请输入有效的工本费")
            return
        }

        // 返回金额验证（必填）
        if (returnAmountStr.isEmpty()) {
            ToastUtil.show("请输入返回金额")
            return
        }

        val returnAmount = try {
            val amount = returnAmountStr.toDouble()
            if (amount < 0) {
                ToastUtil.show("返回金额不能为负数")
                return
            }
            amount
        } catch (e: NumberFormatException) {
            ToastUtil.show("请输入有效的返回金额")
            return
        }

        callReplaceCardApi(cardCost, returnAmount)
    }

    /**
     * 调用补卡API接口
     */
    private fun callReplaceCardApi(cardCost: Double, returnAmount: Double) {
        if (newCardNumber.isNullOrBlank()) {
            ToastUtil.show("新卡卡号信息异常，请重新刷卡")
            return
        }

        val map = mutableMapOf<String, Any>()
        map["cardAddr"] = newCardNumber!! // 使用新卡卡号

        // 根据数据源选择cardNum参数
        val cardNum = when {
            cardInfo != null -> cardInfo!!.cardNum.toString()
            cardInfoByClient != null -> cardInfoByClient!!.cardNum
            else -> cardNumber ?: newCardNumber!!
        }
        map["cardNum"] = cardNum

        map["cardCost"] = cardCost
        map["returnAmount"] = returnAmount  // 使用返回金额
        map["paymentId"] = paymentId // 使用选中的支付方式ID
        map["paymentMethod"] = paymentMethod // 添加支付方式名称
        map["remarks"] = "补卡操作"  // 固定备注
        map["operator"] = BaseApplication.userId

        ApiManager.getInstance().requestPostLoading(
            this,
            "terminal/card/termReissue",
            CardReplaceResult::class.java,
            map,
            object : SubscriberListener<BaseResponse<CardReplaceResult>>() {
                override fun onNext(t: BaseResponse<CardReplaceResult>) {
                    if (t.success && t.content != null) {
                        // 补卡成功，跳转到写卡界面
                        startWriteCardActivity(
                            t.content!!,
                            cardCost,
                            returnAmount,
                            createUserCardFromData()
                        )
                    } else {
                        // 补卡失败
                        val errorMsg = if (t.msg.isNullOrBlank()) "补卡失败，请重试" else t.msg
                        showConfirmDialog("补卡失败：$errorMsg") {
                        }
                    }
                }

                override fun onError(e: Throwable?) {
                    super.onError(e)
                    showConfirmDialog("补卡请求失败: ${e?.message ?: "网络异常，请检查网络连接"}") {
                    }
                }
            }
        )
    }

    /**
     * 根据现有数据创建UserCard对象
     */
    private fun createUserCardFromData(): UserCard {
        return when {
            userCard != null -> userCard!!
            cardInfoByClient != null -> {
                // 从接口数据创建UserCard对象
                UserCard().apply {
                    // 这里可能需要根据实际需求设置更多属性
                    balance = MornyUtil.changeY2F(cardInfoByClient!!.money)
                    phoneNumber = cardInfoByClient!!.phone.toString()
                }
            }

            else -> UserCard() // 返回空的UserCard对象
        }
    }

    /**
     * 跳转到写卡界面进行卡内容更新
     */
    private fun startWriteCardActivity(
        replaceResult: CardReplaceResult,
        cardCost: Double,
        returnAmount: Double,
        userCard: UserCard
    ) {
        // 创建更新后的用户卡数据
        val updatedUserCard = UserCard().apply {
            // 复制原有属性
            cardType = userCard.cardType
            areaNumber = userCard.areaNumber
            userCode = userCard.userCode
            userCodeNumber = userCard.userCodeNumber
            phoneNumber = userCard.phoneNumber
            projectCode = userCard.projectCode
            surplusWater = userCard.surplusWater
            waterPrice = userCard.waterPrice
            electricPrice = userCard.electricPrice
            rechargeDate = userCard.rechargeDate

            // 使用返回的新余额
            balance = MornyUtil.changeY2F(replaceResult.balance.toString())
        }

        val intent = Intent(this, NfcWreatActivity::class.java).apply {
            putExtra("cardAddr", newCardNumber) // 使用新卡卡号
            putExtra("operationTypeCode", CardOperationType.ReplaceCard.code) // 使用补卡类型进行写卡
            putExtra("orderNumber", replaceResult.orderNo)
            putExtra("cardCost", cardCost)
            putExtra("returnAmount", returnAmount)  // 传递返回金额
            putExtra("paymentMethod", paymentMethod) // 传递支付方式
            putExtra("paymentId", paymentId) // 传递支付方式ID
            putExtra("userCard", updatedUserCard as java.io.Serializable)
        }
        startActivity(intent)
        finish()
    }

    /**
     * 根据客户编号获取卡信息
     */
    private fun getCardInfoByClientNum(cardNum: String) {
        val map = mutableMapOf<String, Any>()
        map["cardNum"] = cardNum

        ApiManager.getInstance().requestGetLoading(
            this,
            "terminal/card/getcardbycardnum",
            CardInfoByClientResult::class.java,
            map,
            object : SubscriberListener<BaseResponse<CardInfoByClientResult>>() {
                override fun onNext(t: BaseResponse<CardInfoByClientResult>) {
                    if (t.success) {
                        cardInfoByClient = t.content
                        t.content?.let { cardInfo ->
                            // 显示卡信息并切换到信息显示界面
                            showCardInfoFromClient(cardInfo)
                        }
                    } else {
                        showConfirmDialog("获取卡信息失败：${t.msg ?: "未知错误"}") {
                        }
                    }
                }

                override fun onError(e: Throwable?) {
                    super.onError(e)
                    showConfirmDialog("获取卡信息失败: ${e?.message ?: "网络异常，请检查网络连接"}") {
                    }
                }
            }
        )
    }

    /**
     * 显示从客户编号接口获取的卡信息
     */
    private fun showCardInfoFromClient(cardInfo: CardInfoByClientResult) {
        // 隐藏读卡提示，显示信息区域和底部按钮
        binding.scrollReadCard.visibility = android.view.View.GONE
        binding.cardInfoContainer.visibility = android.view.View.VISIBLE
        binding.bottomButtonContainer.visibility = android.view.View.VISIBLE

        // 显示新卡卡号（如果已读取到新卡）
        binding.tvCurrentCardAddress.text = newCardNumber ?: ""

        // 显示卡信息
        binding.tvUserName.text = cardInfo.clientName
        binding.tvPhone.text = cardInfo.phone.toString()
        
        // TODO: 调用补办卡片API
        // 显示卡号
        binding.tvCardNumber.text = cardInfo.cardNum ?: "--"
        
        // 显示客户编号
        binding.tvCustomerId.text = cardInfo.clientNum ?: "--"

        // 根据cardState字段显示状态
        val (statusText, statusColor) = when (cardInfo.cardState) {
            1 -> Pair("正常", android.graphics.Color.parseColor("#4CAF50")) // 绿色
            2 -> Pair("已注销", android.graphics.Color.parseColor("#FF5722")) // 深橙色
            3 -> Pair("已挂失", android.graphics.Color.parseColor("#FF9800")) // 橙色
            4 -> Pair("无效卡片", android.graphics.Color.parseColor("#F44336")) // 红色
            else -> Pair("未知状态", android.graphics.Color.parseColor("#9E9E9E")) // 灰色
        }
        binding.tvCardStatus.text = statusText
        binding.tvCardStatus.setTextColor(statusColor)

        // 显示余额
        binding.tvCardBalance.text = "${cardInfo.money}元"

        // 设置cardNumber用于后续API调用
        cardNumber = cardInfo.cardNum
    }
}