सामान्य पुनर्नवीनीकरण देखें या बॉयलरप्लेट कोड कैसे नहीं लिखें

हम सभी आवेदन लिखते हैं और हम सभी की सूची है। और सबसे स्पष्ट समाधान RecyclerView है। कार्यान्वयन स्वयं जटिल नहीं है और RecyclerView पर एक गाइड लिखना अब प्रासंगिक नहीं है। लेकिन एक बात है। हर बार जब हमें एक सूची की आवश्यकता होती है, तो हम एक वर्ग बनाते हैं, उसमें टेम्पलेट विधियों को लिखते हैं, टेम्पलेट कक्षाएं बनाते हैं। जब हमारे पास 2-3 सूचियां हैं, तो इसमें कुछ भी गलत नहीं है। लेकिन जब उनमें से 10 या उससे अधिक हैं, तो आप ऐसा नहीं करना चाहते हैं।

और एक समस्या का सामना करना पड़ा, मैंने खोजना शुरू किया। कोटलिन पर एक बहुत ही दिलचस्प कार्यान्वयन मिला। मुझे यह पसंद आया, लेकिन इसमें कुछ तत्वों की कमी थी। कुछ घंटे बिताने के बाद, मैं इसे अंतिम रूप देने में सक्षम था और अब एडेप्टर के कार्यान्वयन में कई लाइनें लगती हैं। और यहाँ मैं इसे आपके साथ साझा करना चाहता हूं।

पहली चीज जो हमें करने की ज़रूरत है वह है एक एडेप्टर।

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

यहाँ क्या हो रहा है? हम एक पैरामीटर एडेप्टर बनाते हैं और उसमें मूल टेम्पलेट विधियों को फिर से परिभाषित करते हैं। हम इंटरफ़ेस को एक पैरामीटर बाइंडर इंटरफ़ेस बनाते हैं, जिसे हमारे ViewHolder को लागू करना होगा। अमूर्त getLayoutId () विधि में, हम अपना लेआउट सेट करेंगे।

हम अपने 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 } } } 

और यह है कि इस एडॉप्टर के टुकड़े में कार्यान्वयन कैसे दिखाई देगा।

 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 } 

सब कुछ शांत, सुविधाजनक, तेज है। लगभग इसी रूप में, मैंने इसे लागू किया। लेकिन फिर मैंने सोचा, क्लिक करने योग्य तत्वों के बारे में क्या। और यहाँ मेरा निर्णय है।

सबसे पहले, एक इंटरफ़ेस बनाएँ

 interface OnItemClickListener<T> { fun onClickItem(data: T) } 

और इसे हमारे बाइंडर इंटरफ़ेस में पास करें

 internal interface Binder<T> { fun bind(data: T, listener: OnItemClickListener<T>?) } 

और एडॉप्टर में, एक अतिरिक्त निर्माता बनाएँ:

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

अंत में हमारे पास क्या है, एक एडाप्टर जो 3 लाइनों में बनाया गया है और सभी प्रकार के तत्वों के लिए एक सार्वभौमिक इंटरफ़ेस है। अगर हमें क्लिकों को संसाधित करने की आवश्यकता नहीं है, तो हम बस श्रोता को कंस्ट्रक्टर के पास नहीं भेजेंगे। लेकिन यह सब नहीं है।

क्या होगा अगर हम अपने एडेप्टर में DiffUtils.Callback बाँधना चाहते हैं।

 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 } 

यह हमारे डिफ्यूटल के लिए बेस क्लास जैसा दिखता है। हमारे एडेप्टर में एक विधि जोड़ें

 private var diffUtil: GenericItemDiff<T>? = null fun setDiffUtilCallback(diffUtilImpl: GenericItemDiff<T>) { diffUtil = diffUtilImpl } 

और एडॉप्टर मेथड अपडेट को थोड़ा संशोधित करें ()

  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() } } 

और इसलिए हम अपने डिफ्यूटल को लागू करते हैं

 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 } 

नतीजतन, हमारे पास टेम्पलेट कोड का एक सरल और काफी लचीला कार्यान्वयन है। कई ViewHolders के साथ एडेप्टर के सुविधाजनक कार्यान्वयन। एक जगह केंद्रीकृत तर्क।

यहां आप सोर्स कोड देख सकते हैं ।

और यहां आप मूल संस्करण देख सकते हैं ।