Koltin33.Takeout订单界面观察者实现自动刷新(18)

最新推荐文章于 2022-03-29 22:10:42 发布

原创最新推荐文章于 2022-03-29 22:10:42 发布 · 256 阅读

0 ·

CC 4.0 BY-SA版权

Kotlin 专栏收录该内容

54 篇文章

订阅专栏

本文介绍了一个基于Android的应用中如何利用观察者模式实现数据变化时UI的实时更新。具体包括MyReceiver作为被观察者接收消息并通知OrderRvAdapter观察者进行UI刷新的过程。

MyReceiver.kt使用观察者模式(OrderRvAdapter是观察者，MyReceiver是被观察者，数据发生变化以后，发送消息通知观察者刷新UI

package com.example.takeout.utils

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.text.TextUtils
import android.util.Log
import cn.jpush.android.api.JPushInterface

class MyReceiver: BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        Log.e("order", "======================")
        val bundle: Bundle? = intent?.extras
        if(bundle!=null){
            val message:String? = bundle.getString(JPushInterface.EXTRA_MESSAGE)
//            Log.e("order", message)  //消息内容
            val extras:String? = bundle.getString(JPushInterface.EXTRA_EXTRA)
            if(!TextUtils.isEmpty(extras)){
                Log.e("order", extras)  //附加字段
                //方法一：通过mainactivity ---> orderFragment ---> OrderRvAdapter ---> 第二个条目的tvOrderType ---> 改变值40
                //方法二：使用观察者模式(OrderRvAdapter是观察者，MyReceiver是被观察者）
                OrderObservable.instance.newMsgComing(extras!!)

            }
        }
    }
}

OrderRvAdapter.kt观察者，继承Observer，实现update方法，在adapter初始化的时候观察者和被观察者建立绑定关系

package com.example.takeout.ui.adapter

import android.content.Context
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.example.takeout.R
import com.example.takeout.model.beans.Order
import com.example.takeout.utils.OrderObservable
import org.jetbrains.anko.find
import org.json.JSONObject
import java.util.*
import kotlin.collections.ArrayList

class OrderRvAdapter (val context: Context) : RecyclerView.Adapter<RecyclerView.ViewHolder>(),
    Observer {

    init {
        OrderObservable.instance.addObserver(this)  //让观察者和被观察者建立绑定关系
    }

    override fun update(o: Observable?, data: Any?) {
        //观察者的响应
        Log.e("order","观察者收到了消息，消息内容：" + data)
        //更新UI
        val jsonObj : JSONObject = JSONObject(data as String)
        val pushOrderId = jsonObj.getString("orderId")
        val pushType = jsonObj.getString("type")
        var index = -1
        for(i in 0 until orderList.size){
            val order = orderList.get(i)
            if(order.id.equals(pushOrderId)){
                order.type = pushType
                index = i
            }
        }
        if(index !=-1) {
            notifyItemChanged(index) //刷新单个条目，减少UI开销
        }
//        notifyDataSetChanged()
    }

    private var orderList: List<Order> = ArrayList<Order>()

    fun setOrderData(orders: List<Order>) {
        this.orderList = orders
        notifyDataSetChanged()
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
//        val itemView = View.inflate(context, R.layout.item_order_item, null)
        //TODO:没有填充满,原因是recycleview的孩子，测量模式是UNSPECIFY
        //通过返回值已经addview,如果attachToRoot使用true会再一次addView()，就会报错
        val itemView = LayoutInflater.from(context).inflate(R.layout.item_order_item,parent, false)
        return OrderItemHolder(itemView)
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        (holder as OrderItemHolder).bindData(orderList.get(position))
    }

    override fun getItemCount(): Int {
        return orderList.size
    }

    inner class OrderItemHolder(item: View) : RecyclerView.ViewHolder(item) {
        val tvSellerName: TextView
        val tvOrderType: TextView
        init {
            //findviewbyId tv_order_item_seller_name tv_order_item_type
            tvSellerName = item.find(R.id.tv_order_item_seller_name)
            tvOrderType = item.find(R.id.tv_order_item_type) //订单状态
//            item.setOnClickListener {
//                val intent: Intent =  Intent(context, OrderDetailActivity::class.java)
//                intent.putExtra("orderId", order.id)
//                intent.putExtra("type", order.type)
//                context.startActivity(intent)
//            }
        }

        fun bindData(order: Order) {
            tvSellerName.text = order.seller?.name ?: "aaaa"
            tvOrderType.text = order.type?.let { getOrderTypeInfo(it) }
        }
    }

    private fun getOrderTypeInfo(type: String): String {
        /**
         * 订单状态
         * 1 未支付 2 已提交订单 3 商家接单  4 配送中,等待送达 5已送达 6 取消的订单
         */
        //            public static final String ORDERTYPE_UNPAYMENT = "10";
        //            public static final String ORDERTYPE_SUBMIT = "20";
        //            public static final String ORDERTYPE_RECEIVEORDER = "30";
        //            public static final String ORDERTYPE_DISTRIBUTION = "40";
        //            public static final String ORDERTYPE_SERVED = "50";
        //            public static final String ORDERTYPE_CANCELLEDORDER = "60";

        var typeInfo = ""
        when (type) {
            OrderObservable.ORDERTYPE_UNPAYMENT -> typeInfo = "未支付"
            OrderObservable.ORDERTYPE_SUBMIT -> typeInfo = "已提交订单"
            OrderObservable.ORDERTYPE_RECEIVEORDER -> typeInfo = "商家接单"
            OrderObservable.ORDERTYPE_DISTRIBUTION -> typeInfo = "配送中"
            OrderObservable.ORDERTYPE_SERVED -> typeInfo = "已送达"
            OrderObservable.ORDERTYPE_CANCELLEDORDER -> typeInfo = "取消的订单"
        }
        return typeInfo
    }
}

OrderObservable.kt订单状态被观察者

package com.example.takeout.utils

import java.util.*

/**
 * 订单状态被观察者
 */
class OrderObservable private constructor() : Observable() {
    companion object {
        val instance = OrderObservable()

        /* 订单状态
       * 1 未支付 2 已提交订单 3 商家接单  4 配送中,等待送达 5已送达 6 取消的订单*/
        val ORDERTYPE_UNPAYMENT = "10"
        val ORDERTYPE_SUBMIT = "20"
        val ORDERTYPE_RECEIVEORDER = "30"
        val ORDERTYPE_DISTRIBUTION = "40"
        // 骑手状态：接单、取餐、送餐
        val ORDERTYPE_DISTRIBUTION_RIDER_RECEIVE = "43"
        val ORDERTYPE_DISTRIBUTION_RIDER_TAKE_MEAL = "46"
        val ORDERTYPE_DISTRIBUTION_RIDER_GIVE_MEAL = "48"

        val ORDERTYPE_SERVED = "50"
        val ORDERTYPE_CANCELLEDORDER = "60"
    }

    fun newMsgComing(extras: String) {
        //从广播接受者获取到最新消息
        //通知所有观察者，新消息来了
        setChanged()
        notifyObservers(extras)
    }
}