Todos nós escrevemos aplicativos e todos temos listas. E a solução mais óbvia é o RecyclerView. A implementação em si não é complicada e escrever um guia no RecyclerView não é mais relevante. Mas há uma coisa. Toda vez que precisamos de uma lista, criamos uma classe, prescrevemos métodos de modelo nela, criamos classes de modelo. Quando temos 2-3 listas, não há nada de errado nisso. Mas quando houver 10 ou mais, você não deseja mais fazer isso.
E diante de um problema, comecei a pesquisar. Encontrou uma implementação muito interessante no Kotlin. Eu gostei, mas faltam alguns elementos. Depois de algumas horas, consegui finalizá-lo e agora a implementação do adaptador leva várias linhas. E aqui eu quero compartilhar com você.
A primeira coisa que precisamos fazer é criar um adaptador.
abstract class GenericAdapter<T> : RecyclerView.Adapter<RecyclerView.ViewHolder> { private var itemList = mutableListOf<T>() constructor() override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder { return getViewHolder( LayoutInflater.from(parent.context) .inflate(viewType, parent, false) , viewType ) } override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) { (holder as Binder<T>).bind(itemList[position], itemClickListener) } override fun getItemCount(): Int = itemList.size override fun getItemViewType(position: Int): Int = getLayoutId(position, itemList[position]) fun update(items: List<T>) { itemList = items.toMutableList() notifyDataSetChanged() } protected abstract fun getLayoutId(position: Int, obj: T): Int protected open fun getViewHolder(view: View, viewType: Int): RecyclerView.ViewHolder { return ViewHolderFactory.create(view, viewType) } internal interface Binder<T> { fun bind(data: T) } }
O que está acontecendo aqui? Criamos um adaptador parametrizado e redefinimos os métodos básicos de modelo nele. Criamos para a interface uma interface Binder parametrizada, que nosso ViewHolder terá que implementar. No método abstrato getLayoutId (), definiremos nosso layout.
Depois de criarmos uma fábrica para o nosso ViewHolder.
object ViewHolderFactory { fun create(view: View, viewType: Int): RecyclerView.ViewHolder { return when (viewType) { R.layout.item_data -> DataViewHolder(view) R.layout.item_other_data -> OtherDataViewHolder(view) else -> throw Exception("Wrong view type") } } class DataViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView), GenericAdapter.Binder<Data> { override fun bind(data: Data) { itemView.apply { dateTextView.text = data.dateTitle } } class OtherDataViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView), GenericAdapter.Binder<OtherData> { override fun bind(data: OtherData) { itemView.apply { dateTextView.text = data.dateTitle } } }
E é assim que a implementação desse adaptador no fragmento será exibida.
private lateinit var adapter GenericAdapter<Data> protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); adapter = dataAdapter } private val dataAdapter = object : GenericAdapter<Data>() { override fun getLayoutId(position: Int, obj: Data): Int = R.layout.item_data }
Tudo é legal, conveniente, rápido. Aproximadamente neste formulário, encontrei esta implementação. Mas então pensei: e quanto aos elementos clicáveis. E aqui está a minha decisão.
Primeiro, crie uma interface
interface OnItemClickListener<T> { fun onClickItem(data: T) }
E passá-lo para a nossa interface do fichário
internal interface Binder<T> { fun bind(data: T, listener: OnItemClickListener<T>?) }
E no adaptador, crie um construtor adicional:
private var itemClickListener: OnItemClickListener<T>? = null constructor(listener: OnItemClickListener<T>) { itemClickListener = listener } class DataViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView), GenericAdapter.Binder<Data> { override fun bind(data: Data, listener: OnItemClickListener<Data>?) { itemView.apply { dateTextView.text = data.dateTitle setOnClickListener { listener?.onClickItem(data) } } }
No final, temos um adaptador criado em 3 linhas e uma interface universal para todos os tipos de elementos. Se não precisamos processar cliques, simplesmente não transmitimos o ouvinte ao construtor. Mas isso não é tudo.
E se quisermos vincular o DiffUtils.Callback ao nosso adaptador.
class GenericDiffUtil<T>( private val oldItems: List<T>, private val newItems: List<T>, private val itemDiff: GenericItemDiff<T> ) : DiffUtil.Callback() { override fun getOldListSize() = oldItems.size override fun getNewListSize() = newItems.size override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int) = itemDiff.isSame(oldItems, newItems, oldItemPosition, newItemPosition) override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int) = itemDiff.isSameContent(oldItems, newItems, oldItemPosition, newItemPosition) } interface GenericItemDiff<T> { fun isSame( oldItems: List<T>, newItems: List<T>, oldItemPosition: Int, newItemPosition: Int ): Boolean fun isSameContent( oldItems: List<T>, newItems: List<T>, oldItemPosition: Int, newItemPosition: Int ): Boolean }
É assim que a classe base de nossos DiffUtils se parece. Adicione um método ao nosso adaptador
private var diffUtil: GenericItemDiff<T>? = null fun setDiffUtilCallback(diffUtilImpl: GenericItemDiff<T>) { diffUtil = diffUtilImpl }
E modifique levemente a atualização do método do adaptador ()
fun update(items: List<T>) { if (diffUtil != null) { val result = DiffUtil.calculateDiff(GenericDiffUtil(itemList, items, diffUtil!!)) itemList.clear() itemList.addAll(items) result.dispatchUpdatesTo(this) } else { itemList = items.toMutableList() notifyDataSetChanged() } }
E assim implementamos nossos DiffUtils
adapter.setDiffUtilCallback(dataDiffUtil) private val dataDiffUtil = object : GenericItemDiff<Data> { override fun isSame( oldItems: List<Data>, newItems: List<Data>, oldItemPosition: Int, newItemPosition: Int ): Boolean { val oldData = oldItems[oldItemPosition] val newData = newItems[newItemPosition] return oldData.id == newData.id } override fun isSameContent( oldItems: List<Data>, newItems: List<Data>, oldItemPosition: Int, newItemPosition: Int ): Boolean { val oldData = oldItems[oldItemPosition] val newData = newItems[newItemPosition] return oldData.name == newData.name && oldData.content == newData.content }
Como resultado, temos uma implementação simples e bastante flexível do código do modelo. Implementação conveniente de adaptadores com vários ViewHolders. Lógica centralizada em um só lugar.
Aqui você pode ver o código fonte .
E aqui você pode ver a versão original .