Android Kotlin से जुड़े बुनियादी बातें 07.1: RecyclerView की बुनियादी बातें

यह कोडलैब Android Kotlin के बुनियादी कोर्स में शामिल है. अगर आप कोडलैब के क्रम में काम करते हैं, तो आपको इस कोर्स का ज़्यादा से ज़्यादा फ़ायदा मिलेगा. सभी कोर्स कोडलैब Android Kotlin से जुड़े बेसिक कोडलैब के लैंडिंग पेज पर दिए गए हैं.

यह कोडलैब एक सीरीज़ का हिस्सा है. यह आपको सोने के समय का ट्रैकर ऐप्लिकेशन बनाने में मदद करता है. यह ऐप्लिकेशन, RecyclerView में नींद से जुड़ा डेटा दिखाता है. हमारा सुझाव है कि आप सभी कोडलैब को क्रम में रखें, क्योंकि ये सिलसिलेवार तरीके से टास्क पूरे करते हैं.

इस सीरीज़ में कोडलैब इस तरह हैं:

• 7.1 RecyclerView की बुनियादी बातें
• 7.2 DiffUtil और RecyclerView के साथ डेटा बाइंडिंग
• 7.3 RecyclerView के साथ GridLayout
• 7.4 RecyclerView आइटम के साथ इंटरैक्ट करना
• RecyclerView में 7.5 हेडर

परिचय

यह कोडलैब आपको आइटम की सूचियां दिखाने के लिए RecyclerView के इस्तेमाल का तरीका बताता है. कोडलैब की पिछली सीरीज़ में मौजूद, स्लीप-ट्रैकर ऐप्लिकेशन पर काम करने के तरीके के बारे में जानने के लिए, सुझाए गए आर्किटेक्चर के साथ RecyclerView का इस्तेमाल करें.

आपको क्या पता होना चाहिए

आपको इनके बारे में पता होना चाहिए:

• किसी ऐक्टिविटी, फ़्रैगमेंट, और व्यू का इस्तेमाल करके बेसिक यूज़र इंटरफ़ेस (यूआई) बनाना.
• फ़्रैगमेंट के बीच नेविगेट करना और फ़्रैगमेंट के बीच डेटा पास करने के लिए, safeArgs का इस्तेमाल करना.
• व्यू मॉडल, व्यू मॉडल फ़ैक्ट्री, ट्रांसफ़ॉर्मेशन, और LiveData और उनके ऑब्ज़र्वर का इस्तेमाल करना.
• Room डेटाबेस बनाना, डीएओ बनाना, और इकाइयां तय करना.
• डेटाबेस टास्क और लंबे समय तक चलने वाले अन्य टास्क के लिए कोरूटीन का इस्तेमाल करना.

आप इन चीज़ों के बारे में जानेंगे

• आइटम की सूची दिखाने के लिए, Adapter और ViewHolder के साथ RecyclerView का इस्तेमाल कैसे करें.

आप क्या कर पाएंगे!

• नींद से जुड़ा डेटा दिखाने के लिए, RecyclerView का इस्तेमाल करें

अहम जानकारी: इस कोडलैब के स्टार्टर ऐप्लिकेशन में ऐसे लेआउट, रिसॉर्स, और उपयोगिताएं हैं जो पिछले कोडलैब के आखिरी TestMySleepquality ऐप्लिकेशन का हिस्सा नहीं हैं. इस कोडलैब के ज़रिए काम करने के लिए, दिए गए स्टार्टर कोड का इस्तेमाल करें.

अगर आपने पिछले कोडलैब के ज़रिए काम किया था, तो आपको यह कोडलैब (कोड बनाना सीखना) आसानी से समझ में आ जाएगा. स्टार्टर ऐप्लिकेशन, स्क्रोल किए जाने वाले टेक्स्ट व्यू में सुलाने वाली रात का डेटा दिखाता है. जैसा कि आपने पिछले कोडलैब में बनाया था. हालांकि, इस कोडलैब के स्टार्टर ऐप्लिकेशन में अतिरिक्त एसेट और सुविधाएं शामिल हैं, ताकि रीसाइकल करने वाले व्यू को लागू करने के लिए सीधे तौर पर आपके काम की ज़रूरत न हो. इस लेसन के लिए स्टार्टर ऐप्लिकेशन डाउनलोड करके इस्तेमाल करना न भूलें.

इस कोडलैब में, आप ऐप्लिकेशन का एक RecyclerView हिस्सा बनाते हैं, जो नींद की क्वालिटी को ट्रैक करता है. यह ऐप्लिकेशन समय के साथ आपकी नींद से जुड़ा डेटा सेव करने के लिए, Room डेटाबेस का इस्तेमाल करता है.

स्टार्टर के तौर पर स्लीप ट्रैकर वाले ऐप्लिकेशन में दो स्क्रीन होती हैं, जिन्हें फ़्रैगमेंट से दिखाया जाता है, जैसा कि नीचे दी गई इमेज में दिखाया गया है.

बाईं ओर दिखाई गई पहली स्क्रीन पर, ट्रैकिंग शुरू और बंद करने के लिए बटन दिए गए हैं. यह स्क्रीन उपयोगकर्ता का # डेटा भी दिखाती है. हटाएं बटन, उपयोगकर्ता के लिए ऐप्लिकेशन के ज़रिए इकट्ठा किया गया सारा डेटा हमेशा के लिए मिटा देता है. दाईं ओर दिखाई गई दूसरी स्क्रीन, अच्छी क्वालिटी वाली रेटिंग चुनने के लिए है.

यह ऐप्लिकेशन, यूज़र इंटरफ़ेस (यूआई) कंट्रोलर, ViewModel, और LiveData के साथ आसान आर्किटेक्चर का इस्तेमाल करता है. यह ऐप्लिकेशन नींद से जुड़े डेटा को लगातार बेहतर बनाने के लिए, Room डेटाबेस का भी इस्तेमाल करता है.

पहली स्क्रीन पर दी गई नींद की रातों की सूची काम करती है, लेकिन पूरी तरह से नहीं. यह ऐप्लिकेशन, टेक्स्ट व्यू के लिए टेक्स्ट स्ट्रिंग और क्वालिटी के लिए नंबर बनाने के लिए, मुश्किल फ़ॉर्मैटर का इस्तेमाल करता है. साथ ही, यह डिज़ाइन स्केल नहीं करता है. इस कोडलैब में इन सभी समस्याओं को ठीक करने के बाद, आखिरी ऐप्लिकेशन में भी वही सुविधाएं होती हैं और मुख्य स्क्रीन कुछ इस तरह दिखती है:

डेटा की सूची या ग्रिड दिखाना, Android के सबसे सामान्य यूज़र इंटरफ़ेस (यूआई) टास्क में से एक है. सूचियां आसान से बहुत जटिल होती हैं. टेक्स्ट व्यू की सूची में शॉपिंग सूची जैसा आसान डेटा दिख सकता है. एक जटिल सूची, जैसे कि छुट्टियों के डेस्टिनेशन की व्याख्या की गई सूची, उपयोगकर्ता को हेडर के साथ स्क्रोल करने वाले ग्रिड में कई जानकारी दिखा सकती है.

इन सभी इस्तेमाल के उदाहरणों के लिए, Android RecyclerView का विजेट उपलब्ध कराता है.

RecyclerView का सबसे बड़ा फ़ायदा यह है कि यह बड़ी सूचियों के लिए काफ़ी असरदार होता है:

• डिफ़ॉल्ट रूप से, RecyclerView सिर्फ़ उन आइटम को प्रोसेस करने या ड्रॉ करने के लिए काम करता है जो अभी स्क्रीन पर दिख रहे हैं. उदाहरण के लिए, अगर आपकी सूची में हज़ार एलिमेंट हैं, लेकिन सिर्फ़ 10 एलिमेंट दिखते हैं, तो RecyclerView सिर्फ़ 10 आइटम बनाने के लिए स्क्रीन पर काम करता है. जब उपयोगकर्ता स्क्रोल करता है, तो RecyclerView यह पता लगाता है कि स्क्रीन पर किस तरह के नए आइटम होने चाहिए. साथ ही, वह उन आइटम को दिखाने के लिए ज़रूरी काम करता है.
• जब कोई आइटम स्क्रीन पर स्क्रोल किया जाता है, तो आइटम को देखे जाने की संख्या रिसाइकल हो जाती है. इसका मतलब है कि आइटम को उस नए कॉन्टेंट से भर दिया गया है जो स्क्रीन पर स्क्रोल करता है. RecyclerView की मदद से प्रोसेस करने में काफ़ी समय बचता है. साथ ही, इससे सूचियां आसानी से स्क्रोल होती हैं.
• जब किसी आइटम में बदलाव होता है, तो पूरी सूची को हटाने के बजाय RecyclerView उस आइटम को अपडेट कर सकता है. मुश्किल आइटम की सूची दिखाने से यह काफ़ी कारगर साबित होता है!

नीचे दिए गए क्रम में, आप देख सकते हैं कि एक व्यू, डेटा से भरा गया है, ABC. वह व्यू, स्क्रीन से स्क्रोल होने के बाद, RecyclerView नए डेटा XYZ के लिए व्यू का दोबारा इस्तेमाल करता है.

अडैप्टर पैटर्न

अगर आप कभी भी अलग-अलग इलेक्ट्रिक सॉकेट का इस्तेमाल करने वाले देशों के बीच जाते हैं, तो आपको शायद अडैप्टर का इस्तेमाल करके अपने डिवाइसों को आउटलेट में प्लग करने का तरीका पता होगा. अडैप्टर आपको एक प्रकार के प्लग को दूसरे में बदलने की सुविधा देता है, जो वाकई एक इंटरफ़ेस को दूसरे में बदल रहा है.

सॉफ़्टवेयर इंजीनियरिंग में अडैप्टर पैटर्न किसी ऑब्जेक्ट को दूसरे एपीआई के साथ काम करने में मदद करता है. RecyclerView, अडैप्टर के ज़रिए ऐप्लिकेशन के डेटा को RecyclerView में बदल सकता है. इसके लिए, ऐप्लिकेशन के डेटा को स्टोर और प्रोसेस करने के तरीके में बदलाव नहीं करना पड़ता. स्लीप-ट्रैकर ऐप्लिकेशन के लिए, आप एक ऐसा अडैप्टर बनाते हैं जो Room डेटाबेस के डेटा को ViewModel में बदल देता है. इसे ViewModel को बदले बिना दिखाना होता है.

RecyclerView को लागू करना

RecyclerView में अपना डेटा दिखाने के लिए, आपको इन चीज़ों की ज़रूरत होगी:

• दिखाई जाने वाली जानकारी.
• आपकी लेआउट फ़ाइल में तय किया गया RecyclerView इंस्टेंस, ताकि व्यू के कंटेनर के तौर पर काम किया जा सके.
• डेटा के एक आइटम के लिए लेआउट.
  अगर सूची के सभी आइटम एक जैसे दिखते हैं, तो आप उन सभी के लिए एक ही लेआउट का इस्तेमाल कर सकते हैं, लेकिन यह ज़रूरी नहीं है. आइटम का लेआउट फ़्रैगमेंट's लेआउट से अलग बनाया जाना चाहिए, ताकि एक बार में एक आइटम व्यू बनाया जा सके और उसे डेटा से भरा जा सके.
• एक लेआउट मैनेजर.
  लेआउट मैनेजर, किसी व्यू में यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट के संगठन (लेआउट) को मैनेज करता है.
• व्यू होल्डर.
  व्यू होल्डर, ViewHolder क्लास को बढ़ाता है. इसमें एक आइटम को दिखाने के लिए, आइटम के लेआउट से जुड़ी व्यू की जानकारी होती है. व्यू होल्डर ऐसी जानकारी भी जोड़ते हैं जिसका इस्तेमाल RecyclerView, व्यू को स्क्रीन पर एक से दूसरी जगह ले जाने के लिए करता है.
• अडैप्टर.
  अडैप्टिवर, आपके डेटा को RecyclerView से कनेक्ट करता है. यह डेटा को इस तरह से अपनाता है, ताकि इसमें ViewHolder को दिखाया जा सके. स्क्रीन पर डेटा दिखाने के लिए RecyclerView, अडैप्टर का इस्तेमाल करता है.

इस टास्क में, आप अपनी लेआउट फ़ाइल में RecyclerView जोड़ते हैं और Adapter सेट अप करते हैं. इससे, RecyclerView को आपकी नींद के डेटा का पता चल जाएगा.

पहला चरण: LayoutManager के साथ RecyclerView जोड़ना

इस कदम में, आप fragment_sleep_tracker.xml फ़ाइल में ScrollView को RecyclerView से बदल सकते हैं.

1. GitHub से RecyclerViewFundamentals-Starter ऐप्लिकेशन डाउनलोड करें.
2. ऐप्लिकेशन बनाएं और चलाएं. ध्यान दें कि डेटा को आसान टेक्स्ट के रूप में कैसे दिखाया जाता है.
3. Android Studio में डिज़ाइन टैब में fragment_sleep_tracker.xml लेआउट फ़ाइल खोलें.
4. कॉम्पोनेंट ट्री पैनल में मौजूद, ScrollView को मिटाएं. ऐसा करने से, ScrollView के अंदर का TextView/#39; भी मिट जाता है.
5. पैलेट पैनल में बाईं ओर स्क्रोल करके, अलग-अलग तरह के कॉम्पोनेंट की सूची पर जाएं और कंटेनर खोजें. इसके बाद, उसे चुनें.
6. RecyclerView पैलेट पैनल से कॉम्पोनेंट ट्री पैनल में खींचें और छोड़ें. RecyclerView को ConstraintLayout के अंदर रखें.

7. अगर एक डायलॉग खुलता है, जिसमें यह पूछा जाता है कि क्या आप डिपेंडेंसी जोड़ना चाहते हैं, तो OK पर क्लिक करें, ताकि Android Studio आपकी Gradle फ़ाइल में recyclerview डिपेंडेंसी जोड़ सके. इसमें कुछ सेकंड लग सकते हैं. इसके बाद, आपका ऐप्लिकेशन सिंक हो जाएगा.

8. मॉड्यूल build.gradle फ़ाइल खोलें, आखिर तक स्क्रोल करें, और नई डिपेंडेंसी को नोट करें जो नीचे दिए गए कोड से मिलती-जुलती है:

implementation 'androidx.recyclerview:recyclerview:1.0.0'

9. fragment_sleep_tracker.xml पर वापस जाएं.
10. टेक्स्ट टैब में, नीचे दिखाया गया RecyclerView कोड देखें:

<androidx.recyclerview.widget.RecyclerView
   android:layout_width="match_parent"
   android:layout_height="match_parent" />

11. RecyclerView को sleep_list का id दें.

android:id="@+id/sleep_list"

12. स्क्रीन के बाकी हिस्से को ConstraintLayout के अंदर ले जाने के लिए, RecyclerView को सही जगह पर रखें. ऐसा करने के लिए, RecyclerView के ऊपरी हिस्से को शुरू करें बटन, RecyclerView के निचले हिस्से में हटाएं बटन, और हर साइड को माता-पिता तक सीमित करें. नीचे दिए गए कोड का इस्तेमाल करके, लेआउट एडिटर या एक्सएमएल में लेआउट की चौड़ाई और ऊंचाई को 0 dp पर सेट करें:

    android:layout_width="0dp"
    android:layout_height="0dp"
    app:layout_constraintBottom_toTopOf="@+id/clear_button"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toBottomOf="@+id/stop_button"

13. RecyclerView एक्सएमएल में एक लेआउट मैनेजर जोड़ें. हर RecyclerView को एक लेआउट मैनेजर की ज़रूरत होती है, जो आइटम को सूची में रखने का तरीका बताता है. Android, LinearLayoutManager देता है, जो डिफ़ॉल्ट रूप से पूरी चौड़ाई वाली पंक्तियों की वर्टिकल सूची के आइटम बताता है.

app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"

14. डिज़ाइन टैब पर स्विच करें और देखें कि जोड़े गए कंस्ट्रेंट की वजह से, RecyclerView के लिए उपलब्ध जगह को भर दिया गया है.

दूसरा चरण: लिस्ट आइटम लेआउट और टेक्स्ट व्यू होल्डर बनाना

RecyclerView सिर्फ़ एक कंटेनर है. इस चरण में, RecyclerView में दिखाने के लिए आइटम का लेआउट और इन्फ़्रास्ट्रक्चर बनाया जाता है.

RecyclerView को जल्द से जल्द काम करने लायक बनाने के लिए, सबसे पहले एक आसान सूची आइटम का इस्तेमाल करें जो सिर्फ़ नींद की क्वालिटी को संख्या के तौर पर दिखाता है. इसके लिए, आपके पास एक व्यू होल्डर होना चाहिए: TextItemViewHolder. डेटा के लिए आपको एक व्यू, TextView की भी ज़रूरत होगी. (बाद के चरण में, आप व्यू होल्डर और नींद का पूरा डेटा रखने के तरीके के बारे में ज़्यादा जानें.)

1. text_item_view.xml नाम की लेआउट फ़ाइल बनाएं. इससे कोई फ़र्क नहीं पड़ता कि आप रूट एलिमेंट के रूप में क्या इस्तेमाल करते हैं, क्योंकि आप टेंप्लेट कोड की जगह #39 बदल देंगे.
2. text_item_view.xml में दिए गए सभी कोड मिटाएं.
3. शुरू और आखिर में 16dp पैडिंग वाला TextView और 24sp का टेक्स्ट साइज़ जोड़ें. चौड़ाई को माता-पिता से मिलाने दें और कॉन्टेंट को ऊंचाई से रैप करें. यह व्यू RecyclerView में दिखता है. इसलिए, आपको व्यू को ViewGroup में नहीं रखना होगा.

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:textSize="24sp"
    android:paddingStart="16dp"
    android:paddingEnd="16dp"
    android:layout_width="match_parent"       
    android:layout_height="wrap_content" />

4. Util.kt खोलें. स्क्रोल करके आखिर तक जाएं और नीचे दी गई #&33; परिभाषा को जोड़ें, जिससे TextItemViewHolder क्लास बनती है. आखिरी क्लोज़ ब्रैकेट के बाद, कोड को फ़ाइल के सबसे नीचे रखें. कोड Util.kt में जाता है, क्योंकि यह व्यू होल्डर कुछ समय के लिए होता है और इसे बाद में बदल दिया जाता है.

class TextItemViewHolder(val textView: TextView): RecyclerView.ViewHolder(textView)

5. अगर आपसे कहा जाए, तो android.widget.TextView और androidx.recyclerview.widget.RecyclerView इंपोर्ट करें.

तीसरा चरण: SleepNightAdapter बनाना

RecyclerView लागू करने का मुख्य काम अडैप्टर बनाना है. आपके पास आइटम व्यू के लिए एक आसान व्यू होल्डर और हर आइटम के लिए एक लेआउट है. अब आप अडैप्टर बना सकते हैं. अडैप्टर, व्यू होल्डर बनाता है और उसे दिखाने के लिए RecyclerView को डेटा से भर देता है.

1. sleeptracker पैकेज में, SleepNightAdapter नाम की एक नई Kotlin क्लास बनाएं.
2. SleepNightAdapter क्लास को RecyclerView.Adapter बढ़ाएं. क्लास को SleepNightAdapter कहा जाता है, क्योंकि यह SleepNight ऑब्जेक्ट को किसी ऐसी चीज़ के हिसाब से अपनाता है जिसे RecyclerView इस्तेमाल कर सके. अडैप्टर को यह जानने की ज़रूरत है कि कौनसा व्यू होल्डर इस्तेमाल करना चाहिए, इसलिए TextItemViewHolder से गुज़रें. संकेत दिए जाने पर ज़रूरी कॉम्पोनेंट इंपोर्ट करें और फिर आपको #39; गड़बड़ी दिखेगी, क्योंकि ऐसा करना ज़रूरी है.

class SleepNightAdapter: RecyclerView.Adapter<TextItemViewHolder>() {}

3. SleepNightAdapter लेवल के सबसे ऊपर के लेवल पर, डेटा को होल्ड करने के लिए listOf SleepNight वैरिएबल बनाएं.

var data =  listOf<SleepNight>()

4. SleepNightAdapter में, getItemCount() में नींद की सूची का साइज़ बदलने के लिए, data बदलें. RecyclerView को यह जानने की ज़रूरत होती है कि अडैप्टर के पास दिखाने के लिए कितने आइटम हैं. getItemCount() को कॉल करके ऐसा किया जा सकता है.

override fun getItemCount() = data.size

5. SleepNightAdapter में, onBindViewHolder() फ़ंक्शन को बदलें, जैसा कि नीचे दिखाया गया है.
   
   onBindViewHolder() फ़ंक्शन को RecyclerView कॉल करता है, ताकि वह सूची में दिए गए आइटम के डेटा को बताई गई जगह पर दिखा सके. इसलिए, onBindViewHolder() तरीके को दो आर्ग्युमेंट की ज़रूरत होती है: व्यू होल्डर और बाइंड करने के लिए डेटा की पोज़िशन. इस ऐप्लिकेशन के लिए, होल्डर TextItemViewHolder है और रैंक सूची में पोज़िशन है.

override fun onBindViewHolder(holder: TextItemViewHolder, position: Int) {
}

6. onBindViewHolder() के अंदर, डेटा में किसी खास जगह पर एक आइटम के लिए वैरिएबल बनाएं.

 val item = data[position]

7. आपने ViewHolder की प्रॉपर्टी बनाई है, जिसमें textView नाम की प्रॉपर्टी है. onBindViewHolder() के अंदर textView के text को, नींद की क्वालिटी के नंबर पर सेट करें. यह कोड सिर्फ़ नंबरों की सूची दिखाता है, लेकिन इस आसान उदाहरण से यह पता लगाया जा सकता है कि अडैप्टर, व्यू होल्डर और स्क्रीन पर कैसे डेटा भेजता है.

holder.textView.text = item.sleepQuality.toString()

8. SleepNightAdapter में, onCreateViewHolder() को ओवरराइड और लागू करें. इसे तब कॉल किया जाता है, जब RecyclerView को किसी आइटम को दिखाने के लिए व्यू होल्डर की ज़रूरत होती है.
   
   यह फ़ंक्शन दो पैरामीटर लेता है और ViewHolder दिखाता है. parent पैरामीटर, व्यू व्यू वाला होल्डर होता है. इसमें हमेशा RecyclerView होता है. viewType पैरामीटर का इस्तेमाल तब किया जाता है, जब एक ही RecyclerView में कई व्यू होते हैं. उदाहरण के लिए, अगर आप एक ही RecyclerView में टेक्स्ट व्यू, इमेज, और वीडियो की सूची डालते हैं, तो onCreateViewHolder() फ़ंक्शन को यह जानने की ज़रूरत होगी कि किस तरह के व्यू का इस्तेमाल करना है.

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TextItemViewHolder {
}

9. onCreateViewHolder() में LayoutInflater का इंस्टेंस बनाएं.
   
   लेआउट इन्फ़्लर को एक्सएमएल लेआउट से व्यू बनाने का तरीका पता है. context में, व्यू को सही तरीके से इनफ़्लेट करने का तरीका बताया गया है. रीसाइकलर व्यू के लिए अडैप्टर में, आप हमेशा parent व्यू ग्रुप के संदर्भ में पास करते हैं, जो RecyclerView है.

val layoutInflater = LayoutInflater.from(parent.context)

10. onCreateViewHolder() में, layoutinflater को बढ़ाने के लिए कहकर view बनाएं.
    
    व्यू के लिए एक्सएमएल लेआउट में पास और व्यू के लिए parent व्यू ग्रुप. तीसरा, बूलियन, आर्ग्युमेंट attachToRoot है. इस आर्ग्युमेंट का false होना ज़रूरी है, क्योंकि RecyclerView इस आइटम को आपके व्यू'के समय में, व्यू व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) में जोड़ता है.

val view = layoutInflater
       .inflate(R.layout.text_item_view, parent, false) as TextView

11. onCreateViewHolder() में, view से बनाया गया TextItemViewHolder दिखाएं.

return TextItemViewHolder(view)

12. अडैप्टर को RecyclerView को यह जानकारी देनी होगी कि data को कब बदला गया, क्योंकि RecyclerView को डेटा के बारे में कुछ नहीं पता. यह सिर्फ़ व्यू होल्डर के बारे में जानता है, जो अडैप्टर इसे देता है.
    
    RecyclerView को यह बताने के लिए कि डेटा कब दिखेगा, तब SleepNightAdapter क्लास के ऊपर data वैरिएबल में एक कस्टम सेटर जोड़ें, जो #33 है. सेटर में, data को एक नई वैल्यू दें. इसके बाद, नए डेटा की मदद से सूची को फिर से बनाना शुरू करने के लिए, notifyDataSetChanged() को कॉल करें.
    

var data =  listOf<SleepNight>()
   set(value) {
       field = value
       notifyDataSetChanged()
   }

ध्यान दें: जब notifyDataSetChanged() को कॉल किया जाता है, तो RecyclerView सिर्फ़ बदले गए आइटम को ही नहीं, बल्कि पूरी सूची को फिर से दिखाता है. यह आसान है और यह अभी काम करता है. कोडलैब की इस सीरीज़ में, आप बाद में इस कोड को बेहतर बनाते हैं.

चौथा चरण: अडैप्टर के बारे में RecyclerView के बारे में बताना

व्यू होल्डर पाने के लिए RecyclerView को अडैप्टर के बारे में जानना होगा.

1. SleepTrackerFragment.kt खोलें.
2. onCreateview() में अडैप्टर बनाएं. ViewModel कोड बनाने के बाद और return स्टेटमेंट से पहले, यह कोड डालें.

val adapter = SleepNightAdapter()

3. adapter को RecyclerView से जोड़ें.

binding.sleepList.adapter = adapter

4. binding ऑब्जेक्ट को अपडेट करने के लिए, अपने प्रोजेक्ट को साफ़ करके फिर से बनाएं.
   
   अगर आपको अब भी binding.sleepList या binding.FragmentSleepTrackerBinding के आस-पास गड़बड़ियां दिख रही हैं, तो कैश मेमोरी को अमान्य करें और रीस्टार्ट करें. (फ़ाइल > कैश मेमोरी / रीस्टार्ट करना अमान्य करें चुनें.)
   
   अगर आप अभी ऐप्लिकेशन चलाते हैं, तो कोई गड़बड़ी नहीं होगी. हालांकि, आपने शुरू करें पर टैप करने के बाद, बंद करें पर टैप करके कोई डेटा नहीं देखा.

कदम 5: अडैप्टर में डेटा पाना

अब तक आपके पास एक अडैप्टर है. साथ ही, आप अडैप्टर से RecyclerView में डेटा पाने का तरीका भी जान सकते हैं. अब आपको ViewModel से अडैप्टर में डेटा पाना होगा.

1. SleepTrackerViewModel खोलें.
2. nights वैरिएबल ढूंढें, जिसमें नींद से जुड़ी सभी रातें सेव होती हैं. यह वही डेटा होता है जो दिखाता है. nights वैरिएबल, getAllNights() को डेटाबेस पर कॉल करके सेट किया जाता है.
3. private को nights से हटाएं, क्योंकि आप एक ऐसा ऑब्ज़र्वर बनाएंगे जिसे इस वैरिएबल को ऐक्सेस करना होगा. आपका एलान कुछ ऐसा दिखना चाहिए:

val nights = database.getAllNights()

4. database पैकेज में, SleepDatabaseDao खोलें.
5. getAllNights() फ़ंक्शन ढूंढें. ध्यान दें कि यह फ़ंक्शन LiveData के रूप में SleepNight की वैल्यू की सूची दिखाता है. इसका मतलब है कि nights वैरिएबल में LiveData है, जिसे Room अपडेट करता है. साथ ही, आप nights में बदलाव होने के बारे में जानने के लिए उसे देख सकते हैं.
6. SleepTrackerFragment खोलें.
7. onCreateView() में, adapter बनाने के नीचे, nights वैरिएबल पर ऑब्ज़र्वर बनाएं.
   
   फ़्रैगमेंट की #/लाइफ़साइकल के मालिक के तौर पर viewLifecycleOwner सप्लाई करके, आप यह पक्का कर सकते हैं कि यह ऑब्ज़र्वर सिर्फ़ तब चालू हो, जब RecyclerView स्क्रीन पर हो.

sleepTrackerViewModel.nights.observe(viewLifecycleOwner, Observer {
   })

8. ऑब्ज़र्वर के अंदर, जब भी आपको गैर-शून्य वैल्यू (nights के लिए) मिलती है, तो अडैप्टर को # और 39;s data असाइन करें. यह, ऑब्ज़र्वर के लिए पूरा किया गया कोड है और डेटा सेट करता है:

sleepTrackerViewModel.nights.observe(viewLifecycleOwner, Observer {
   it?.let {
       adapter.data = it
   }
})

9. अपना कोड बनाएं और चलाएं.
   
   अगर आपका अडैप्टर काम कर रहा है, तो आपको नींद की क्वालिटी वाले नंबर सूची के तौर पर दिखेंगे. बाईं ओर दिया गया स्क्रीनशॉट शुरू करें पर टैप करने के बाद -1 दिखाता है. अगर आप बंद करें पर टैप करते हैं और क्वालिटी रेटिंग चुनते हैं, तो दाईं ओर दिया गया स्क्रीनशॉट, नींद की क्वालिटी का अपडेट किया गया नंबर दिखाता है.

चरण 6: जानें कि व्यू होल्डर कैसे रीसाइकल किए जाते हैं

व्यू व्यू होल्डर को RecyclerView रीसाइकल करता है, जिसका मतलब है कि वे उनका फिर से इस्तेमाल करते हैं. जब व्यू, स्क्रीन से स्क्रोल होता है, तब RecyclerView उस व्यू के लिए दोबारा इस्तेमाल करता है जो स्क्रीन पर स्क्रोल करने वाला है.

ये व्यू होल्डर रिसाइकल किए गए होते हैं. इसलिए, पक्का करें कि किसी व्यू होल्डर पर सेट किए गए पिछले आइटम को onBindViewHolder() अपने हिसाब से सेट या रीसेट करे.

उदाहरण के लिए, आप उन व्यू होल्डर में टेक्स्ट के रंग को सेट कर सकते हैं जिनकी क्वालिटी रेटिंग 1 से कम या उसके बराबर है. साथ ही, जो आपकी नींद को खराब करती हैं.

1. SleepNightAdapter क्लास में, यह कोड onBindViewHolder() के आखिर में जोड़ें.

if (item.sleepQuality <= 1) {
   holder.textView.setTextColor(Color.RED) // red
}

2. ऐप्लिकेशन चलाएं.
3. नींद की क्वालिटी का कुछ डेटा जोड़ें और नंबर लाल रंग का होगा.
4. अच्छी क्वालिटी की रेटिंग के लिए तब तक ज़्यादा रेटिंग दें, जब तक आपको स्क्रीन पर लाल रंग का हाई नंबर न दिखे.
   
   जब RecyclerView, व्यू होल्डर का फिर से इस्तेमाल करता है, तब अच्छी क्वालिटी की रेटिंग के लिए यह लाल व्यू के किसी एक मालिक का फिर से इस्तेमाल करता है. हाई रेटिंग को लाल रंग में गलती से दिखाया गया है.

5. इसे ठीक करने के लिए, अगर रंग एक से कम या बराबर नहीं है, तो रंग को सेट करने के लिए else स्टेटमेंट जोड़ें.
   
   दोनों शर्तों को साफ़ तौर पर दिखाने पर, व्यू होल्डर हर आइटम के लिए सही टेक्स्ट का इस्तेमाल करेगा.

if (item.sleepQuality <= 1) {
   holder.textView.setTextColor(Color.RED) // red
} else {
   // reset
   holder.textView.setTextColor(Color.BLACK) // black
}

6. ऐप्लिकेशन चलाएं और अंकों का रंग हमेशा सही होना चाहिए.

बधाई हो! अब आपके पास पूरी तरह से बुनियादी RecyclerView सुविधा है.

इस टास्क में, आप सादे व्यू वाले व्यक्ति को बदल देते हैं. इसमें, आप नींद से जुड़ी नींद के लिए ज़्यादा डेटा दिखा सकते हैं.

आपने ViewHolder के लिए जो ViewHolder जोड़ा था वह TextItemViewHolder में, सिर्फ़ TextView को रैप कर देता है.

class TextItemViewHolder(val textView: TextView): RecyclerView.ViewHolder(textView)

इसलिए, RecyclerView सीधे TextView का इस्तेमाल क्यों नहीं करता? कोड की एक लाइन में कई फ़ंक्शन उपलब्ध हैं. ViewHolder, आइटम के व्यू और मेटाडेटा के बारे में RecyclerView में उसकी जगह के बारे में बताता है. सूची को स्क्रोल करने पर व्यू को सही जगह पर रखने और Adapter में आइटम जोड़े या हटाए जाने पर ऐनिमेट किए गए व्यू जैसी दिलचस्प चीज़ें करने के लिए, RecyclerView इस फ़ंक्शन पर निर्भर करता है.

अगर RecyclerView को ViewHolder में सेव किए गए व्यू ऐक्सेस करने की ज़रूरत है, तो व्यू होल्डर's itemView प्रॉपर्टी का इस्तेमाल करके ऐसा किया जा सकता है. RecyclerView जब किसी आइटम को स्क्रीन पर दिखाने के लिए बाध्य करता है, तो बॉर्डर की तरह किसी व्यू के आस-पास सजावट करते समय और सुलभता को लागू करने के लिएitemView का इस्तेमाल करता है.

पहला चरण: आइटम का लेआउट बनाना

इस चरण में, आप एक आइटम के लिए लेआउट फ़ाइल बनाते हैं. इन लेआउट में, नींद की क्वालिटी के लिए ImageView वाला ConstraintLayout, नींद की लंबाई के लिए TextView, और टेक्स्ट के तौर पर क्वालिटी के लिए TextView शामिल है. आपने पहले # लेआउट बनाया है, इसलिए दिए गए एक्सएमएल कोड को कॉपी करें और चिपकाएं.

1. एक नई लेआउट रिसॉर्स फ़ाइल बनाएं और इसे list_item_sleep_night नाम दें.
2. फ़ाइल में मौजूद सभी कोड को नीचे दिए गए कोड से बदलें. इसके बाद, उन लेआउट की जानकारी पाएं जिन्हें आपने अभी-अभी बनाया है.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="wrap_content">

   <ImageView
       android:id="@+id/quality_image"
       android:layout_width="@dimen/icon_size"
       android:layout_height="60dp"
       android:layout_marginStart="16dp"
       android:layout_marginTop="8dp"
       android:layout_marginBottom="8dp"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       tools:srcCompat="@drawable/ic_sleep_5" />

   <TextView
       android:id="@+id/sleep_length"
       android:layout_width="0dp"
       android:layout_height="20dp"
       android:layout_marginStart="8dp"
       android:layout_marginTop="8dp"
       android:layout_marginEnd="16dp"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toEndOf="@+id/quality_image"
       app:layout_constraintTop_toTopOf="@+id/quality_image"
       tools:text="Wednesday" />

   <TextView
       android:id="@+id/quality_string"
       android:layout_width="0dp"
       android:layout_height="20dp"
       android:layout_marginTop="8dp"
       app:layout_constraintEnd_toEndOf="@+id/sleep_length"
       app:layout_constraintHorizontal_bias="0.0"
       app:layout_constraintStart_toStartOf="@+id/sleep_length"
       app:layout_constraintTop_toBottomOf="@+id/sleep_length"
       tools:text="Excellent!!!" />
</androidx.constraintlayout.widget.ConstraintLayout>

3. Android Studio में डिज़ाइन टैब पर जाएं. डिज़ाइन व्यू में, आपका लेआउट नीचे बाईं ओर दिए गए स्क्रीनशॉट जैसा दिखता है. ब्लूप्रिंट व्यू में, यह दाईं ओर के स्क्रीनशॉट की तरह दिखता है.

दूसरा चरण: ViewHolder बनाना

1. SleepNightAdapter.kt खोलें.
2. ViewHolder नाम की SleepNightAdapter के अंदर एक क्लास बनाएं और उसे RecyclerView.ViewHolder बढ़ाएं.

class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView){}

3. ViewHolder के अंदर, व्यू के रेफ़रंस पाएं. आपको उस व्यू के लिए रेफ़रंस चाहिए जिसे ViewHolder अपडेट करेगा. हर बार जब आप इस ViewHolder को बाइंड करते हैं, तो आपको इमेज और टेक्स्ट, दोनों व्यू ऐक्सेस करने होते हैं. (आप बाद में डेटा बाइंडिंग का इस्तेमाल करने के लिए इस कोड को कन्वर्ट करते हैं.)

val sleepLength: TextView = itemView.findViewById(R.id.sleep_length)
val quality: TextView = itemView.findViewById(R.id.quality_string)
val qualityImage: ImageView = itemView.findViewById(R.id.quality_image)

तीसरा चरण: SleepNightAdapter में ViewHolder का इस्तेमाल करना

1. SleepNightAdapter की परिभाषा में, TextItemViewHolder के बजाय, उस SleepNightAdapter.ViewHolder का इस्तेमाल करें जो आपने अभी-अभी बनाया है.

class SleepNightAdapter: RecyclerView.Adapter<SleepNightAdapter.ViewHolder>() {

onCreateViewHolder() अपडेट करें:

2. ViewHolder लौटाने के लिए, onCreateViewHolder() का हस्ताक्षर बदलें.
3. लेआउट लेआउट को बदलकर, सही लेआउट रिसॉर्स का इस्तेमाल करें. list_item_sleep_night.
4. TextView के लिए कास्ट निकालें.
5. TextItemViewHolder लौटाने के बजाय, ViewHolder दिखाएं.
   
   यहां अपडेट किया गया onCreateViewHolder() फ़ंक्शन दिया गया है:

    override fun onCreateViewHolder(
            parent: ViewGroup, viewType: Int): ViewHolder {
        val layoutInflater = 
            LayoutInflater.from(parent.context)
        val view = layoutInflater
                .inflate(R.layout.list_item_sleep_night, 
                         parent, false)
        return ViewHolder(view)
    }

onBindViewHolder() अपडेट करें:

6. onBindViewHolder() के हस्ताक्षर में बदलाव करें, ताकि TextItemViewHolder के बजाय, holder पैरामीटर का इस्तेमाल ViewHolder हो सके.
7. onBindViewHolder() के अंदर, item को छोड़कर बाकी सभी कोड मिटा दें.
8. val res के बारे में बताएं, जो इस व्यू के resources का रेफ़रंस देता है.

val res = holder.itemView.context.resources

9. sleepLength टेक्स्ट व्यू के टेक्स्ट को अवधि पर सेट करें. नीचे दिया गया कोड कॉपी करें. स्टार्टर फ़ॉर्मैट में दिए गए फ़ॉर्मैटिंग फ़ंक्शन को ##39; कहा जाता है.

holder.sleepLength.text = convertDurationToFormatted(item.startTimeMilli, item.endTimeMilli, res)

10. यह गड़बड़ी दिखाता है, क्योंकि convertDurationToFormatted() के बारे में बताना ज़रूरी है. Util.kt को खोलें और कोड और उससे जुड़े इंपोर्ट की टिप्पणी को बंद करें. (Code > टिप्पणी के साथ टिप्पणी चुनें.)
11. क्वालिटी को सेट करने के लिए, onBindViewHolder() में वापस convertNumericQualityToString() का इस्तेमाल करें.

holder.quality.text= convertNumericQualityToString(item.sleepQuality, res)

12. हो सकता है कि आपको ये फ़ंक्शन, मैन्युअल तरीके से इंपोर्ट करने पड़ें.

import com.example.android.trackmysleepquality.convertDurationToFormatted
import com.example.android.trackmysleepquality.convertNumericQualityToString

13. क्वालिटी के लिए सही आइकॉन सेट करें. स्टार्टर कोड में आपको नया ic_sleep_active आइकॉन दिया गया है.

holder.qualityImage.setImageResource(when (item.sleepQuality) {
   0 -> R.drawable.ic_sleep_0
   1 -> R.drawable.ic_sleep_1
   2 -> R.drawable.ic_sleep_2
   3 -> R.drawable.ic_sleep_3
   4 -> R.drawable.ic_sleep_4
   5 -> R.drawable.ic_sleep_5
   else -> R.drawable.ic_sleep_active
})

14. यहां अपडेट किया गया onBindViewHolder() फ़ंक्शन पूरा हो गया है, जिसमें ViewHolder का पूरा डेटा सेट किया गया है:

   override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = data[position]
        val res = holder.itemView.context.resources
        holder.sleepLength.text = convertDurationToFormatted(item.startTimeMilli, item.endTimeMilli, res)
        holder.quality.text= convertNumericQualityToString(item.sleepQuality, res)
        holder.qualityImage.setImageResource(when (item.sleepQuality) {
            0 -> R.drawable.ic_sleep_0
            1 -> R.drawable.ic_sleep_1
            2 -> R.drawable.ic_sleep_2
            3 -> R.drawable.ic_sleep_3
            4 -> R.drawable.ic_sleep_4
            5 -> R.drawable.ic_sleep_5
            else -> R.drawable.ic_sleep_active
        })
    }

15. अपना ऐप्लिकेशन चलाएं. आपका डिसप्ले, नीचे दिए गए स्क्रीनशॉट की तरह दिखना चाहिए. साथ ही, नींद की क्वालिटी और नींद की क्वालिटी के बारे में बताने वाला टेक्स्ट दिखना चाहिए.

आपका RecyclerView पूरा हो गया है! आपने Adapter और ViewHolder को लागू करने का तरीका सीखा. साथ ही, RecyclerView Adapter की सूची दिखाने के लिए, उन्हें एक साथ रखा.

अब तक मौजूद आपके कोड से, अडैप्टर और व्यू होल्डर बनाने की प्रोसेस का पता चलता है. हालांकि, आप इस कोड को बेहतर बना सकते हैं. दिखाने के लिए कोड और व्यू होल्डर को मैनेज करने के लिए कोड, दोनों को मिला दिया जाता है. साथ ही, onBindViewHolder() को ViewHolder अपडेट करने के बारे में पूरी जानकारी दी जाती है.

प्रोडक्शन ऐप्लिकेशन में आपके पास एक से ज़्यादा व्यू होल्डर, ज़्यादा कॉम्प्लेक्स अडैप्टर, और कई डेवलपर बदलाव कर सकते हैं. आपको अपना कोड इस तरह बनाना चाहिए कि किसी व्यू होल्डर से जुड़ी सारी चीज़ें सिर्फ़ व्यू होल्डर में हों.

पहला चरण: onBindViewHolder() देखना

इस कदम में, आप कोड को फिर से ध्यान में रखते हैं और सभी व्यू होल्डर फ़ंक्शन को ViewHolder में ले जाते हैं. इस रीफ़ैक्टर का मकसद यह बदलना नहीं है कि ऐप्लिकेशन, उपयोगकर्ता को कैसा दिखेगा और डेवलपर के लिए कोड पर काम करना आसान और सुरक्षित बनाता है. सबसे अच्छी बात यह है कि Android Studio में ऐसे टूल मौजूद हैं जिनसे आपको मदद मिल सकती है.

1. SleepNightAdapter में, onBindViewHolder() के लिए वैरिएबल item के बारे में बताने के लिए स्टेटमेंट के अलावा सब कुछ चुनें.
2. दायां क्लिक करके फ़ैक्टर; एक्स्ट्रैक्ट > फ़ंक्शन चुनें.
3. bind फ़ंक्शन को नाम दें और सुझाए गए पैरामीटर स्वीकार करें. ठीक है पर क्लिक करें.
   
   bind() फ़ंक्शन को onBindViewHolder() के नीचे रखा गया है.

    private fun bind(holder: ViewHolder, item: SleepNight) {
        val res = holder.itemView.context.resources
        holder.sleepLength.text = convertDurationToFormatted(item.startTimeMilli, item.endTimeMilli, res)
        holder.quality.text = convertNumericQualityToString(item.sleepQuality, res)
        holder.qualityImage.setImageResource(when (item.sleepQuality) {
            0 -> R.drawable.ic_sleep_0
            1 -> R.drawable.ic_sleep_1
            2 -> R.drawable.ic_sleep_2
            3 -> R.drawable.ic_sleep_3
            4 -> R.drawable.ic_sleep_4
            5 -> R.drawable.ic_sleep_5
            else -> R.drawable.ic_sleep_active
        })
    }

4. कर्सर को bind() के holder पैरामीटर के holder शब्द पर रखें. इंटेंट मेन्यू खोलने के लिए, Alt+Enter (Mac पर Option+Enter) दबाएं. पैरामीटर को पाने वाले में बदलें को चुनें, ताकि इसे ऐसे एक्सटेंशन फ़ंक्शन में बदला जा सके जिसमें यह हस्ताक्षर है:

private fun ViewHolder.bind(item: SleepNight) {...}

5. bind() फ़ंक्शन को काटें और ViewHolder में चिपकाएं.
6. bind() को सार्वजनिक करें.
7. ज़रूरी होने पर, अडैप्टर में bind() इंपोर्ट करें.
8. अब यह ViewHolder में है, इसलिए आप हस्ताक्षर के ViewHolder हिस्से को हटा सकते हैं. यह ViewHolder क्लास में bind() फ़ंक्शन का फ़ाइनल कोड है.

fun bind(item: SleepNight) {
   val res = itemView.context.resources
   sleepLength.text = convertDurationToFormatted(
           item.startTimeMilli, item.endTimeMilli, res)
   quality.text = convertNumericQualityToString(
           item.sleepQuality, res)
   qualityImage.setImageResource(when (item.sleepQuality) {
       0 -> R.drawable.ic_sleep_0
       1 -> R.drawable.ic_sleep_1
       2 -> R.drawable.ic_sleep_2
       3 -> R.drawable.ic_sleep_3
       4 -> R.drawable.ic_sleep_4
       5 -> R.drawable.ic_sleep_5
       else -> R.drawable.ic_sleep_active
   })
}

दूसरा चरण: onCreateViewHolder को रीफ़ैक्टर करना

फ़िलहाल, अडैप्टर में onCreateViewHolder() तरीका ViewHolder के लेआउट रिसॉर्स से व्यू को बढ़ाता है. हालांकि, अडैप्टर को इनफ़्लेट करने की कोई ज़रूरत नहीं होती. साथ ही, ViewHolder की मदद से क्या किया जा सकता है. बढ़ोतरी ViewHolder में होनी चाहिए.

1. onCreateViewHolder() में, फ़ंक्शन के मुख्य हिस्से में मौजूद सभी कोड चुनें.
2. दायां क्लिक करके फ़ैक्टर; एक्स्ट्रैक्ट > फ़ंक्शन चुनें.
3. from फ़ंक्शन को नाम दें और सुझाए गए पैरामीटर स्वीकार करें. ठीक है पर क्लिक करें.
4. कर्सर को from फ़ंक्शन के लिए रखें. इंटेंट मेन्यू खोलने के लिए, Alt+Enter (Mac पर Option+Enter) दबाएं.
5. कंपैनियन ऑब्जेक्ट पर ले जाएं को चुनें. from() फ़ंक्शन को कंपैनियन ऑब्जेक्ट में होना चाहिए, ताकि उसे ViewHolder क्लास पर कॉल किया जा सके, न कि ViewHolder इंस्टेंस पर.
6. companion ऑब्जेक्ट को ViewHolder क्लास में ले जाएं.
7. from() को सार्वजनिक करें.
8. onCreateViewHolder(), ViewHolder क्लास में from() को कॉल करने का नतीजा देने के लिए, return स्टेटमेंट बदलें.
   
   आपके पूरे onCreateViewHolder() और from() वाले तरीके, नीचे दिए गए कोड जैसे दिखने चाहिए. साथ ही, आपका कोड बिना किसी गड़बड़ी के बनाया और चलना चाहिए.

    override fun onCreateViewHolder(parent: ViewGroup, viewType: 
Int): ViewHolder {
        return ViewHolder.from(parent)
    }

companion object {
   fun from(parent: ViewGroup): ViewHolder {
       val layoutInflater = LayoutInflater.from(parent.context)
       val view = layoutInflater
               .inflate(R.layout.list_item_sleep_night, parent, false)
       return ViewHolder(view)
   }
}

9. ViewHolder क्लास का हस्ताक्षर बदलें, ताकि कंस्ट्रक्टर निजी हो. अब from() एक ऐसा तरीका है जो नया ViewHolder इंस्टेंस दिखाता है. इसलिए, अब ViewHolder के कंस्ट्रक्टर को कॉल करने की कोई वजह नहीं है.

class ViewHolder private constructor(itemView: View) : RecyclerView.ViewHolder(itemView){

10. ऐप्लिकेशन को चलाएं. आपके ऐप्लिकेशन को पहले की तरह बनाना और चलाना चाहिए. फिर से पुष्टि करने के बाद, आपको मनचाहा नतीजा मिलेगा.

Android Studio प्रोजेक्ट: RecyclerViewFundamentals

• डेटा की सूची या ग्रिड दिखाना, Android के सबसे सामान्य यूज़र इंटरफ़ेस (यूआई) टास्क में से एक है. RecyclerView को बहुत बड़ी सूचियों को दिखाते समय भी बेहतर तरीके से काम करने के लिए डिज़ाइन किया गया है.
• RecyclerView सिर्फ़ उन आइटम को प्रोसेस करने या ड्रॉ करने के लिए ज़रूरी काम करता है जो फ़िलहाल स्क्रीन पर दिख रहे हैं.
• जब कोई आइटम स्क्रीन से स्क्रोल होता है, तो उसके व्यू रिसाइकल हो जाते हैं. इसका मतलब है कि आइटम को उस नए कॉन्टेंट से भर दिया गया है जो स्क्रीन पर स्क्रोल करता है.
• सॉफ़्टवेयर इंजीनियरिंग में अडैप्टर पैटर्न किसी ऑब्जेक्ट को दूसरे एपीआई के साथ काम करने में मदद करता है. RecyclerView, ऐप्लिकेशन डेटा को ऐसी किसी चीज़ में बदल सकता है जो उसे दिखा सके. इसके लिए, ऐप्लिकेशन के डेटा को स्टोर करने और प्रोसेस करने के तरीके में बदलाव करने की ज़रूरत नहीं होती है.

RecyclerView में अपना डेटा दिखाने के लिए, आपको इन चीज़ों की ज़रूरत होगी:

• RecyclerView
  RecyclerView का इंस्टेंस बनाने के लिए, लेआउट फ़ाइल में <RecyclerView> एलिमेंट तय करें.
• LayoutManager
  RecyclerView, RecyclerView में आइटम के लेआउट को व्यवस्थित करने के लिए LayoutManager का इस्तेमाल करता है, जैसे कि उन्हें ग्रिड या लीनियर सूची में रखना.
  
  लेआउट फ़ाइल में <RecyclerView> में, app:layoutManager एट्रिब्यूट को लेआउट मैनेजर (जैसे LinearLayoutManager या GridLayoutManager) पर सेट करें.
  
  आप प्रोग्राम के हिसाब से RecyclerView के लिए LayoutManager भी सेट कर सकते हैं. (यह तकनीक बाद के कोडलैब में दी गई है.)
  
• हर आइटम के लिए लेआउट
  एक्सएमएल लेआउट वाली फ़ाइल में, डेटा के एक आइटम के लिए लेआउट बनाएं.
• अडैप्टर
  डेटा तैयार करने वाला अडैप्टर बनाएं. साथ ही, यह भी बताएं कि यह ViewHolder में कैसा दिखेगा. अडैप्टर को RecyclerView से जोड़ें.
  
  जब RecyclerView चलता है, तो यह स्क्रीन पर डेटा दिखाने का तरीका जानने के लिए अडैप्टर का इस्तेमाल करता है.
  
  आइटम के नंबर को वापस करने के लिए, अडैप्टर के लिए आपको नीचे दिए गए तरीके इस्तेमाल करने होंगे:
  – getItemCount() सूची में दिए गए किसी आइटम के लिए ViewHolder लौटाने के लिए
  . onCreateViewHolder(). सूची में दिए गए किसी आइटम के व्यू के हिसाब से डेटा को ऑप्टिमाइज़ करने के लिए
  – onBindViewHolder().
• ViewHolder
  ViewHolder में आइटम के #&360 लेआउट से एक आइटम दिखाने के लिए व्यू की जानकारी होती है.
• अडैप्टर में onBindViewHolder() तरीका, डेटा को व्यू के हिसाब से अपनाता है. आप हमेशा इस तरीके को बदलते हैं. आम तौर पर, onBindViewHolder() किसी आइटम के लेआउट को इनफ़्लेट करता है और डेटा को लेआउट में व्यू में रखता है.
• RecyclerView को डेटा के बारे में कुछ नहीं पता है, इसलिए Adapter को उस डेटा में बदलाव होने पर RecyclerView को बताना होगा. डेटा में हुए बदलाव के बारे में Adapter को बताने के लिए, notifyDataSetChanged() का इस्तेमाल करें.

Udcity कोर्स:

• Kotlin के साथ Android ऐप्लिकेशन डेवलप करना

Android डेवलपर दस्तावेज़:

• RecyclerView की मदद से सूची बनाना
• RecyclerView
• Adapter
• RecyclerView.ViewHolder
• ज़रूरत के हिसाब से ढल जाने वाला पैटर्न
• LayoutManager
• LinearLayoutManager

इस सेक्शन में उन छात्र-छात्राओं के लिए गृहकार्य की असाइनमेंट की सूची दी गई है जो इस कोडलैब के ज़रिए एक शिक्षक की देखरेख में कोर्स में काम कर रहे हैं. यह क्रिएटर का काम #33 पर निर्भर करता है:

• अगर ज़रूरी हो, तो होमवर्क असाइन करें.
• छात्र-छात्राओं को होमवर्क के असाइनमेंट सबमिट करने के तरीके के बारे में बताएं.
• होमवर्क असाइनमेंट को ग्रेड दें.

शिक्षक इन सुझावों का इस्तेमाल जितनी चाहें उतनी कम या ज़्यादा कर सकते हैं. साथ ही, उन्हें अपने हिसाब से कोई भी होमवर्क असाइन करना चाहिए.

अगर आप इस कोडलैब के ज़रिए खुद काम कर रहे हैं, तो बेझिझक इन होमवर्क असाइनमेंट का इस्तेमाल करें.

इन सवालों के जवाब दें

पहला सवाल

RecyclerView, आइटम कैसे दिखाता है? लागू होने वाले सभी विकल्प चुनें.

▢, आइटम को सूची या ग्रिड में दिखाता है.

▢ स्क्रोल करने पर वर्टिकल या हॉरिज़ॉन्टल रूप से स्क्रोल होता है.

▢ टैबलेट जैसे बड़े डिवाइस पर तिरछी स्क्रोल करता है.

▢ कस्टम लेआउट की अनुमति तब देता है, जब इस्तेमाल के उदाहरण के लिए, सूची या ग्रिड काफ़ी नहीं हो.

दूसरा सवाल

RecyclerView के इस्तेमाल के क्या फ़ायदे हैं? लागू होने वाले सभी विकल्प चुनें.

▢ कुशलता से बड़ी सूचियां दिखाता है.

▢ डेटा को अपने-आप अपडेट करता है.

▢ किसी आइटम को अपडेट करने, मिटाने या सूची में जोड़े जाने पर रीफ़्रेश की ज़रूरत को कम कर देता है.

▢ उस व्यू का फिर से इस्तेमाल करता है जो स्क्रीन पर स्क्रोल किया जाता है और स्क्रीन पर स्क्रोल होने वाला अगला आइटम दिखाता है.

तीसरा सवाल

अडैप्टर इस्तेमाल करने की कुछ वजहें क्या हैं? लागू होने वाले सभी विकल्प चुनें.

▢ चिंताओं को अलग करने की सुविधा से, कोड को बदलना और उसकी जांच करना आसान हो जाता है.

▢ RecyclerView दिखाए जा रहे डेटा में कोई बदलाव नहीं करेगा.

▢ डेटा प्रोसेसिंग लेयर को, डेटा दिखाए जाने के तरीके से जुड़ी चिंता करने की ज़रूरत नहीं है.

▢ ऐप्लिकेशन ज़्यादा तेज़ चलेगा.

चौथा सवाल

ViewHolder के बारे में इनमें से कौनसी बात सही है? लागू होने वाले सभी विकल्प चुनें.

▢ ViewHolder लेआउट को एक्सएमएल लेआउट फ़ाइलों में परिभाषित किया जाता है.

▢ डेटासेट में हर इकाई के लिए एक ViewHolder है.

▢ आपकी RecyclerView में एक से ज़्यादा ViewHolder हो सकते हैं.

▢ Adapter को ViewHolder से बाइंड करता है.

अगला लेसन शुरू करें: 7.2: RecyclerView के साथ DiffUtil और डेटा बाइंडिंग

यह कोडलैब एक सीरीज़ का हिस्सा है. यह आपको सोने के समय का ट्रैकर ऐप्लिकेशन बनाने में मदद करता है. यह ऐप्लिकेशन, RecyclerView में नींद से जुड़ा डेटा दिखाता है. हमारा सुझाव है कि आप सभी कोडलैब को क्रम में रखें, क्योंकि ये सिलसिलेवार तरीके से टास्क पूरे करते हैं.

इस सीरीज़ में कोडलैब इस तरह हैं:

• 7.1 RecyclerView की बुनियादी बातें
• 7.2 DiffUtil और RecyclerView के साथ डेटा बाइंडिंग
• 7.3 RecyclerView के साथ GridLayout
• 7.4 RecyclerView आइटम के साथ इंटरैक्ट करना
• RecyclerView में 7.5 हेडर