Android Kotlin से जुड़े बुनियादी बातें 02.4: डेटा बाइंडिंग की बुनियादी बातें

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

परिचय

इस कोर्स के पिछले कोडलैब में, आप व्यू के रेफ़रंस पाने के लिए findViewById() फ़ंक्शन का इस्तेमाल करते थे. जब आपके ऐप्लिकेशन में व्यू के क्रम मुश्किल होते हैं, तब findViewById() महंगा होता है और यह ऐप्लिकेशन के काम करने की रफ़्तार कम कर देता है. ऐसा इसलिए होता है, क्योंकि Android, व्यू के क्रम से गुज़रता है. यह तब तक शुरू होता है, जब तक कि उपयोगकर्ता अपनी पसंद का व्यू नहीं ढूंढ लेता. सबसे अच्छी बात यह है कि #39; एक बेहतर तरीका है.

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

इस कोडलैब में आप findViewById() की ज़रूरत को खत्म करने के लिए, डेटा बाइंडिंग का इस्तेमाल करने का तरीका जानेंगे. किसी व्यू से सीधे डेटा ऐक्सेस करने के लिए, आप डेटा बाइंडिंग का इस्तेमाल करने का तरीका भी सीख सकते हैं.

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

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

• गतिविधि क्या होती है और onCreate() में लेआउट की मदद से गतिविधि सेट अप करने का तरीका जानें.
• टेक्स्ट व्यू बनाना और टेक्स्ट व्यू में दिखने वाले टेक्स्ट को सेट करना.
• किसी व्यू का रेफ़रंस पाने के लिए findViewById() का इस्तेमाल करना.
• किसी व्यू के लिए एक बेसिक एक्सएमएल लेआउट बनाना और उसमें बदलाव करना.

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

• findViewById() को लागू न किए जाने वाले कॉल खत्म करने के लिए, डेटा बाइंडिंग लाइब्रेरी का इस्तेमाल कैसे करें.
• सीधे एक्सएमएल से ऐप्लिकेशन का डेटा ऐक्सेस करने का तरीका.

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

• findViewById() के बजाय डेटा बाइंडिंग का इस्तेमाल करने के लिए और लेआउट एक्सएमएल फ़ाइलों से सीधे डेटा ऐक्सेस करने के लिए, ऐप्लिकेशन में बदलाव करें.

इस कोडलैब में, आप aboutMe ऐप्लिकेशन से शुरू करते हैं और डेटा बाइंडिंग का इस्तेमाल करके ऐप्लिकेशन को बदलते हैं. आपका काम पूरा हो जाने पर ऐप्लिकेशन बिल्कुल वैसा ही दिखेगा!

aboutMe ऐप्लिकेशन क्या करता है:

• जब उपयोगकर्ता ऐप्लिकेशन खोलता है, तो ऐप्लिकेशन कोई नाम, उपनाम डालने के लिए फ़ील्ड, हो गया बटन, स्टार इमेज, और स्क्रोल किया जा सकने वाला टेक्स्ट दिखाता है.
• उपयोगकर्ता कोई दूसरा नाम डाल सकता है और हो गया बटन पर टैप कर सकता है. बदलाव किए जा सकने वाले फ़ील्ड और बटन को ऐसे टेक्स्ट व्यू से बदल दिया जाता है जिसमें डाला गया निकनेम दिखता है.
  
  
  

आप पिछले कोडलैब में बनाए गए कोड का इस्तेमाल कर सकते हैं या GitHub से AboutMeDataBinding-Starter कोड डाउनलोड कर सकते हैं.

कोड के पिछले कोड में लिखा गया कोड, व्यू के रेफ़रंस पाने के लिए findViewById() फ़ंक्शन का इस्तेमाल करता है.

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

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

एक समाधान ऐसा ऑब्जेक्ट बनाना है जिसमें हर व्यू के लिए रेफ़रंस शामिल हो. Binding ऑब्जेक्ट के नाम से इस ऑब्जेक्ट का इस्तेमाल आपके पूरे ऐप्लिकेशन के लिए किया जा सकता है. इस तकनीक को डेटा बाइंडिंग कहा जाता है. आपके ऐप्लिकेशन के लिए बाइंडिंग ऑब्जेक्ट बन जाने के बाद, आप बाइंडिंग ऑब्जेक्ट के ज़रिए व्यू और दूसरे डेटा को ऐक्सेस कर सकते हैं. इसके लिए, आपको व्यू हैरारकी को पार करने या डेटा खोजने की ज़रूरत नहीं होगी.

डेटा बाइंडिंग के ये फ़ायदे हैं:

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

इस टास्क में, आप डेटा बाइंडिंग सेट अप करते हैं. साथ ही, findViewById() पर कॉल को बाइंडिंग ऑब्जेक्ट से बदलने के लिए डेटा बाइंडिंग का इस्तेमाल करते हैं.

पहला चरण: डेटा बाइंडिंग चालू करना

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

1. अगर आपके पास पिछले कोडलैब से aboutMe ऐप्लिकेशन नहीं है, तो GitHub से AboutMeDataBinding-Starter कोड पाएं. इसे Android Studio में खोलें.
2. build.gradle (Module: app) फ़ाइल खोलें.
3. android सेक्शन में, क्लोज़िंग ब्रेस से पहले, dataBinding सेक्शन जोड़ें और enabled को true पर सेट करें.

dataBinding {
    enabled = true
}

4. जब कहा जाए, तब प्रोजेक्ट को सिंक करें. अगर आपको नहीं कहा जाता है, तो फ़ाइल > Gradle फ़ाइलों के साथ प्रोजेक्ट सिंक करें चुनें.
5. आप ऐप्लिकेशन चला सकते हैं, लेकिन आपको कोई बदलाव नहीं दिखेगा.

दूसरा चरण: लेआउट फ़ाइल को, डेटा बाइंडिंग के साथ इस्तेमाल करने के लिए बदलना

डेटा बाइंडिंग के साथ काम करने के लिए, आपको अपने एक्सएमएल लेआउट को <layout> टैग से रैप करना होगा. ऐसा इसलिए है, क्योंकि रूट क्लास अब व्यू ग्रुप नहीं है, बल्कि यह एक लेआउट है, जिसमें व्यू ग्रुप और व्यू शामिल हैं. इसके बाद बाइंडिंग ऑब्जेक्ट, लेआउट और उसमें मौजूद व्यू के बारे में जान सकता है.

1. activity_main.xml फ़ाइल खोलें.
2. टेक्स्ट टैब पर स्विच करें.
3. <layout></layout> को <LinearLayout> के सबसे बाहरी टैग के तौर पर जोड़ें.

<layout>
   <LinearLayout ... >
   ...
   </LinearLayout>
</layout>

4. कोड इंडेंटेशन को ठीक करने के लिए, Code > Reformat code चुनें.
   
   किसी लेआउट के नेमस्पेस का एलान, सबसे बाहरी टैग में होना चाहिए.

5. <LinearLayout> से नेमस्पेस के एलान को काटें और उन्हें <layout> टैग में चिपकाएं. आपका ओपनिंग <layout> टैग नीचे दिखाए गए तरीके से दिखना चाहिए. साथ ही, <LinearLayout> टैग में सिर्फ़ व्यू प्रॉपर्टी होनी चाहिए.

<layout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto">

6. अपना ऐप्लिकेशन बनाएं और चलाएं, ताकि इस बात की पुष्टि हो सके कि आपने सही तरीके से ऐसा किया है.

तीसरा चरण: मुख्य गतिविधि में बाइंडिंग ऑब्जेक्ट बनाना

मुख्य ऑब्जेक्ट में बाइंडिंग ऑब्जेक्ट का रेफ़रंस जोड़ें, ताकि आप व्यू को ऐक्सेस करने के लिए इसका इस्तेमाल कर सकें:

1. MainActivity.kt फ़ाइल खोलें.
2. onCreate() से पहले, सबसे ऊपर के लेवल पर, बाइंडिंग ऑब्जेक्ट के लिए वैरिएबल बनाएं. आम तौर पर, इस वैरिएबल को binding कहा जाता है.
   
   खास तरह की कंपाइलर, खास तौर पर इस मुख्य गतिविधि के लिए, binding, ActivityMainBinding क्लास का टाइप बनाता है. नाम, लेआउट फ़ाइल के नाम से लिया जाता है, यानी, activity_main + Binding.

private lateinit var binding: ActivityMainBinding

3. अगर Android Studio से पूछा जाए, तो ActivityMainBinding इंपोर्ट करें. अगर आपको सूचना नहीं मिलती है, तो ActivityMainBinding पर क्लिक करें और Alt+Enter (Mac पर Option+Enter) पर क्लिक करके, कक्षा को इंपोर्ट करें. (कीबोर्ड के ज़्यादा शॉर्टकट जानने के लिए, कीबोर्ड शॉर्टकट देखें.)
   
   import स्टेटमेंट वही होना चाहिए जो नीचे दिखाया गया है.

import com.example.android.aboutme.databinding.ActivityMainBinding

इसके बाद, आप मौजूदा setContentView() फ़ंक्शन को ऐसे निर्देश से बदल दें जो ये काम करता है:

• बाइंडिंग ऑब्जेक्ट बनाता है.
• activity_main फ़ंक्शन को MainActivity से जोड़ने के लिए, DataBindingUtil क्लास के setContentView() फ़ंक्शन का इस्तेमाल करता है. यह setContentView() फ़ंक्शन, व्यू के लिए कुछ डेटा बाइंडिंग सेट अप का भी ध्यान रखता है.

4. onCreate() में, setContentView() कॉल को कोड की इस पंक्ति से बदलें.

binding = DataBindingUtil.setContentView(this, R.layout.activity_main)

5. DataBindingUtil इंपोर्ट करें.

import androidx.databinding.DataBindingUtil

चौथा चरण: सभी कॉल को ढूंढने के लिए बाइंडिंग ऑब्जेक्ट का इस्तेमाल करके, ViewViewById()

अब आप findViewById() पर किए गए सभी कॉल को उन ऑब्जेक्ट के रेफ़रंस से बदल सकते हैं जो बाइंडिंग ऑब्जेक्ट में हैं. बाइंडिंग ऑब्जेक्ट बनाए जाने पर, कंपाइलर लेआउट में व्यू के आईडी से बाइंडिंग ऑब्जेक्ट में व्यू के नाम जनरेट करता है और उन्हें ऊंट के केस में बदल देता है. उदाहरण के लिए, बाइंडिंग ऑब्जेक्ट में done_button, doneButton है, nickname_edit, nicknameEdit बन जाता है, और nickname_text nicknameText हो जाता है.

1. onCreate() में, done_button का पता लगाने वाले कोड को ऐसे ऑब्जेक्ट से बदलें जो बाइंडिंग ऑब्जेक्ट में बटन का रेफ़रंस देता हो. इसकी जगह, findViewById() इस्तेमाल करें.
   
   यह कोड बदलें: findViewById<Button>(R.id.done_button)
   को इनके साथ बदलें: binding.doneButton

onCreate() में क्लिक लिसनर को सेट करने के लिए, आपके पूरे हो चुके कोड को कुछ इस तरह दिखने चाहिए.

binding.doneButton.setOnClickListener {
   addNickname(it)
}

2. addNickname() फ़ंक्शन में findViewById() पर किए जाने वाले सभी कॉल के लिए ऐसा ही करें.
   findViewById<View>(R.id.id_view) की सभी घटनाओं को binding.idView से बदलें. नीचे बताए गए तरीके से ऐसा करें:
   

• editText और nicknameTextView वैरिएबल के साथ-साथ findViewById() की परिभाषाएं भी मिटाएं. इससे आपको गड़बड़ियां मिलेंगी.
• nicknameText (nicknameEdit), और doneButton व्यू को binding ऑब्जेक्ट से (मिटाए गए) वैरिएबल के बजाय nicknameText पाकर गड़बड़ियां ठीक करें.
• view.visibility को binding.doneButton.visibility से बदलें. पास किए गए view के बजाय binding.doneButton का इस्तेमाल करने से, कोड बेहतर बन जाता है.
  
  नतीजे इस कोड के हिसाब से है:

binding.nicknameText.text = binding.nicknameEdit.text
binding.nicknameEdit.visibility = View.GONE
binding.doneButton.visibility = View.GONE
binding.nicknameText.visibility = View.VISIBLE

• फ़ंक्शनलिटी में कोई बदलाव नहीं हुआ है. इसके अलावा, अब आप view पैरामीटर को हटा सकते हैं. साथ ही, इस फ़ंक्शन में binding.doneButton का इस्तेमाल करने के लिए, view के सभी इस्तेमाल अपडेट कर सकते हैं.

3. nicknameText के लिए String होना ज़रूरी है, और nicknameEdit.text का मान Editable होता है. डेटा बाइंडिंग का इस्तेमाल करते समय, Editable को String में साफ़ तौर पर बदलना ज़रूरी है.

binding.nicknameText.text = binding.nicknameEdit.text.toString()

4. आप इंपोर्ट किए गए इंपोर्ट मिटा सकते हैं.
5. apply{} का इस्तेमाल करके, फ़ंक्शन को Kotlin में बदलें.

binding.apply {
   nicknameText.text = nicknameEdit.text.toString()
   nicknameEdit.visibility = View.GONE
   doneButton.visibility = View.GONE
   nicknameText.visibility = View.VISIBLE
}

6. अपना ऐप्लिकेशन बनाएं और चलाएं...वह पहले की तरह ही दिखना और काम करना चाहिए.

सलाह: अगर बदलाव करने के बाद आपको कंपाइलर की गड़बड़ियां दिखती हैं, तो Create > Clean Project के बाद बिल्ड > प्रोजेक्ट फिर से बनाएं चुनें. ऐसा करने से, आम तौर पर जनरेट की गई फ़ाइलें अपडेट हो जाती हैं. नहीं तो, पूरी तरह से क्लीनअप करने के लिए फ़ाइल >कैश मेमोरी/रीस्टार्ट करें को चुनें.

सलाह: आपने पहले ऐसे Resources ऑब्जेक्ट के बारे में सीखा था जो ऐप्लिकेशन में मौजूद सभी संसाधनों के रेफ़रंस देता है. आप व्यू को रेफ़र करते समय Binding ऑब्जेक्ट को एक जैसे फ़ैशन में देख सकते हैं; हालांकि, Binding ऑब्जेक्ट बहुत बेहतर है.

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

इस उदाहरण के लिए, स्ट्रिंग रिसॉर्स का इस्तेमाल करके नाम और निकनेम सेट करने के बजाय, आप नाम और निकनेम के लिए एक डेटा क्लास बनाते हैं. आप डेटा बाइंडिंग का इस्तेमाल करके, व्यू क्लास को व्यू के लिए उपलब्ध कराते हैं.

पहला चरण: MyName डेटा क्लास बनाना

1. Android Studio में, java डायरेक्ट्री में MyName.kt फ़ाइल खोलें. अगर आपके पास यह फ़ाइल #3 नहीं है, तो नई Kotlin फ़ाइल बनाएं और MyName.kt को कॉल करें.
2. नाम और निकनेम के लिए डेटा क्लास तय करें. डिफ़ॉल्ट वैल्यू के तौर पर खाली स्ट्रिंग का इस्तेमाल करें.

data class MyName(var name: String = "", var nickname: String = "")

दूसरा चरण: लेआउट में डेटा जोड़ना

activity_main.xml फ़ाइल में, नाम को फ़िलहाल किसी स्ट्रिंग रिसॉर्स से TextView में सेट किया गया है. आपको डेटा क्लास में मौजूद डेटा के रेफ़रंस के साथ, नाम का रेफ़रंस बदलना होगा.

1. activity_main.xml को टेक्स्ट टैब में खोलें.
2. लेआउट के सबसे ऊपर, <layout> और <LinearLayout> टैग के बीच, <data></data> टैग डालें. यहां आप व्यू को डेटा से कनेक्ट करेंगे.

<data>
  
</data>

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

3. <data> टैग में, <variable> टैग जोड़ें.
4. वैरिएबल को "myName" का नाम देने के लिए, name पैरामीटर जोड़ें. type पैरामीटर जोड़ें और टाइप को MyName डेटा क्लास के पूरी तरह क्वालिफ़ाइड नाम (पैकेज का नाम + वैरिएबल का नाम) पर सेट करें.

<variable
       name="myName"
       type="com.example.android.aboutme.MyName" />

अब, नाम के लिए स्ट्रिंग रिसॉर्स का इस्तेमाल करने के बजाय, myName वैरिएबल का रेफ़रंस दिया जा सकता है.

5. android:text="@string/name" को नीचे दिए गए कोड से बदलें.

@={} कर्ली ब्रैकेट में मौजूद डेटा पाने के लिए डायरेक्टिव है.

myName उस myName वैरिएबल का रेफ़रंस देता है जिसे आपने पहले तय किया था, जो myName डेटा क्लास को पॉइंट करता है और क्लास से name प्रॉपर्टी फ़ेच करता है.

android:text="@={myName.name}"

तीसरा चरण: डेटा बनाना

अब आपके पास अपनी लेआउट फ़ाइल में डेटा का रेफ़रंस है. इसके बाद, आप असली डेटा बनाते हैं.

1. MainActivity.kt फ़ाइल खोलें.
2. onCreate() के ऊपर, एक निजी वैरिएबल बनाएं. इसे कन्वेंशन के हिसाब से myName भी कहा जाता है. वैरिएबल को नाम में पास करने वाले, MyName डेटा क्लास का एक इंस्टेंस असाइन करें.

private val myName: MyName = MyName("Aleks Haecky")

3. onCreate() में, लेआउट फ़ाइल में myName वैरिएबल की वैल्यू को अभी-अभी बताए गए myName वैरिएबल की वैल्यू पर सेट करें. आप सीधे एक्सएमएल में वैरिएबल ऐक्सेस कर सकते हैं. आपको इसे बाइंडिंग ऑब्जेक्ट के ज़रिए ऐक्सेस करना होगा.

binding.myName = myName

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

चौथा चरण: TextView में निकनेम के लिए डेटा क्लास का इस्तेमाल करना

आखिरी चरण में, TextView में भी निकनेम के लिए डेटा क्लास का इस्तेमाल करना होगा.

1. activity_main.xml खोलें.
2. nickname_text टेक्स्ट व्यू में, text प्रॉपर्टी जोड़ें. जैसा कि नीचे दिखाया गया है, डेटा क्लास में nickname का रेफ़रंस दें.

android:text="@={myName.nickname}"

3. ActivityMain में,
   nicknameText.text = nicknameEdit.text.toString()
   को कोड से बदलें, ताकि myName वैरिएबल में कोई दूसरा नाम सेट किया जा सके.

myName?.nickname = nicknameEdit.text.toString()

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

4. निकनेम सेट करने के बाद invalidateAll() जोड़ें, ताकि यूज़र इंटरफ़ेस (यूआई) को अपडेट किए गए बाइंडिंग ऑब्जेक्ट में वैल्यू के साथ रीफ़्रेश किया जा सके.

binding.apply {
   myName?.nickname = nicknameEdit.text.toString()
   invalidateAll()
   ...
}

5. अपना ऐप्लिकेशन बनाएं और चलाएं. हो सकता है कि यह पहले की तरह ही काम करे.

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

findViewById() में कॉल बदलने के लिए डेटा बाइंडिंग का इस्तेमाल करने का तरीका:

1. build.gradle फ़ाइल के 'Android सेक्शन' में डेटा बाइंडिंग चालू करें:
   dataBinding { enabled = true }
2. अपने एक्सएमएल लेआउट में <layout> को रूट व्यू के तौर पर इस्तेमाल करें.
3. बाइंडिंग वैरिएबल तय करें:
   private lateinit var binding: ActivityMainBinding
4. setContentView:
   binding = DataBindingUtil.setContentView(this, R.layout.activity_main) की जगह पर, MainActivity में बाइंडिंग ऑब्जेक्ट बनाएं
5. बाइंडिंग ऑब्जेक्ट को व्यू के रेफ़रंस से findViewById() पर कॉल करें. उदाहरण के लिए:
   findViewById<Button>(R.id.done_button) ⇒ binding.doneBuटन(
   उदाहरण के तौर पर, एक्सएमएल में व्यू का नाम केस की मदद से ऊंट के केस का नाम और #39; id से जनरेट होता है.)

डेटा से व्यू को जोड़ने के चरण:

1. अपने डेटा के लिए डेटा क्लास बनाना.
2. <layout> टैग में <data> ब्लॉक जोड़ें.
3. <variable> का नाम बताएं और डेटा टाइप डालें.

<data>
   <variable
       name="myName"
       type="com.example.android.aboutme.MyName" />
</data>

4. MainActivity में, डेटा क्लास के इंस्टेंस वाला एक वैरिएबल बनाएं. उदाहरण के लिए:
   private val myName: MyName = MyName("Aleks Haecky")

5. बाइंडिंग ऑब्जेक्ट में, वैरिएबल को अभी-अभी बनाए गए वैरिएबल पर सेट करें:
   binding.myName = myName

6. एक्सएमएल में, व्यू के कॉन्टेंट को उस वैरिएबल पर सेट करें जिसे आपने <data> ब्लॉक में बताया था. डेटा क्लास में डेटा ऐक्सेस करने के लिए, डॉट नोटेशन का इस्तेमाल करें.
   android:text="@={myName.name}"

Udcity कोर्स:

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

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

• डेटा बाइंडिंग लाइब्रेरी
• बाइंडिंग क्लास जनरेट करना
• डेटा बाइंडिंग के साथ शुरू करना
• लेआउट और बाइंडिंग एक्सप्रेशन

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

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

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

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

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

पहला सवाल

आप findViewById() के लिए एक्सप्लिसिट और इंप्लिसिट कॉल को कम क्यों करना चाहते हैं?

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

दूसरा सवाल

आप डेटा बाइंडिंग के बारे में कैसे बताएंगे?

उदाहरण के लिए, यहां डेटा बाइंडिंग के बारे में कुछ बातें बताई गई हैं:

• डेटा बाइंडिंग के बारे में एक बड़ी बात यह है कि एक ऐसा ऑब्जेक्ट बनाया जाए जो कंपाइल के समय रिमोट जानकारी के दो हिस्सों को आपस में कनेक्ट/मैप/बाइंड करता हो, ताकि आपको रनटाइम के दौरान डेटा न ढूँढना पड़े.
• इन बाइंडिंग को दिखाने वाले ऑब्जेक्ट को बाइंडिंग ऑब्जेक्ट कहा जाता है.
• बाइंडिंग ऑब्जेक्ट, कंपाइलर बनाता है.

तीसरा सवाल

इनमें से किस वजह से डेटा बाइंडिंग का फ़ायदा नहीं मिलता?

• कोड छोटा, पढ़ने में आसान, और बनाए रखने में आसान होता है.
• डेटा और व्यू साफ़ तौर पर अलग-अलग होते हैं.
• Android सिस्टम हर व्यू पाने के लिए व्यू हैरारकी को सिर्फ़ एक बार पार करता है.
• findViewById() को कॉल करने से कंपाइल वाली गड़बड़ी जनरेट होती है.
• व्यू ऐक्सेस करने के लिए टाइप टाइप की सुरक्षा.

चौथा सवाल

<layout> टैग का फ़ंक्शन क्या है?

• इसे लेआउट में, रूट व्यू के साथ रैप करें.
• किसी लेआउट में सभी व्यू के लिए बाइंडिंग बनाई जाती हैं.
• यह एक्सएमएल लेआउट में टॉप-लेवल व्यू दिखाता है, जो डेटा बाइंडिंग का इस्तेमाल करता है.
• किसी वैरिएबल को डेटा क्लास में बाइंड करने के लिए, आप <layout> में <data> टैग का इस्तेमाल कर सकते हैं.

पांचवां सवाल

एक्सएमएल लेआउट में, बाउंड डेटा को रेफ़र करने का सही तरीका क्या है?

• android:text="@={myDataClass.property}"
• android:text="@={myDataClass}"
• android:text="@={myDataClass.property.toString()}"
• android:text="@={myDataClass.bound_data.property}"

अगला लेसन शुरू करें: 3.1: फ़्रैगमेंट बनाएं

इस कोर्स में दिए गए दूसरे कोडलैब के लिंक के लिए, Android Kotlin की बुनियादी बातें कोडलैब का लैंडिंग पेज देखें.