Android Kotlin की बुनियादी जानकारी 06.3: बटन की स्थितियां कंट्रोल करने के लिए, LiveData का इस्तेमाल करना

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

परिचय

इस कोडलैब में यह बताया गया है कि नेविगेशन को लागू करने के लिए, ViewModel और फ़्रैगमेंट को एक साथ कैसे इस्तेमाल करना चाहिए. याद रखें कि लक्ष्य यह है कि ViewModel में नेविगेट करने के लिए कब का तर्क दिया जाए, लेकिन फ़्रैगमेंट और नेविगेशन फ़ाइल में पाथ तय करें. इस लक्ष्य को पाने के लिए, आप व्यू मॉडल, फ़्रैगमेंट, LiveData, और ऑब्ज़र्वर का इस्तेमाल करें.

कोडलैब तब खत्म होता है, जब कम से कम कोड के साथ बटन की स्थितियों को सही तरीके से ट्रैक करने का बढ़िया तरीका मिलता है. इससे, हर बटन को सिर्फ़ तब चालू और क्लिक किया जा सकता है, जब उपयोगकर्ता को उस बटन पर टैप करने की ज़रूरत हो.

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

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

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

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

• डेटाबेस में मौजूद नींद की क्वालिटी के मौजूदा रिकॉर्ड को अपडेट करने का तरीका.
• बटन की स्थिति को ट्रैक करने के लिए LiveData का इस्तेमाल कैसे करें.
• किसी इवेंट के जवाब में स्नैकबार दिखाने का तरीका.

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

• क्वालिटी रेटिंग इकट्ठा करने, डेटाबेस में रेटिंग जोड़ने, और नतीजे दिखाने के लिए, ट्रैकरMySleepquality ऐप्लिकेशन को बढ़ाएं.
• स्नैकबार को दिखाने के लिए, LiveData का इस्तेमाल करें.
• बटन चालू और बंद करने के लिए, LiveData का इस्तेमाल करें.

इस कोडलैब में, आप स्लीप-क्वालिटी की रिकॉर्डिंग और TrackingMySleepquality ऐप्लिकेशन का फ़ाइनल यूज़र इंटरफ़ेस (यूआई) बनाते हैं.

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

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

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

उपयोगकर्ता का फ़्लो इस तरह होता है:

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

यह ऐप्लिकेशन, आसान आर्किटेक्चर का इस्तेमाल करता है, जैसा कि पूरी आर्किटेक्चर के संदर्भ में दिखाया गया है. ऐप्लिकेशन सिर्फ़ इन कॉम्पोनेंट का इस्तेमाल करता है:

• यूज़र इंटरफ़ेस (यूआई) कंट्रोलर
• मॉडल और LiveData देखें
• रूम डेटाबेस

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

पहला चरण: कोड की जांच करना

1. शुरू करने के लिए, पिछले कोडलैब के आखिर से अपने कोड का इस्तेमाल करें या स्टार्टर कोड डाउनलोड करें.
2. अपने स्टार्टर कोड में, SleepQualityFragment की जाँच करें. यह क्लास, लेआउट को इनफ़्लेट करता है और ऐप्लिकेशन को ऐक्सेस करता है. साथ ही, binding.root दिखाता है.
3. डिज़ाइन एडिटर में navigation.xml खोलें. हम देखते हैं कि SleepTrackerFragment से SleepQualityFragment तक के लिए नेविगेशन पाथ है. साथ ही, SleepQualityFragment से SleepTrackerFragment तक वापस जाता है.
   
   
   
   
4. navigation.xml के कोड की जांच करें. खास तौर पर, <argument> नाम sleepNightKey देखें.
   
   
   जब उपयोगकर्ता SleepTrackerFragment से SleepQualityFragment, पर जाता है, तो ऐप्लिकेशन उस रात के लिए SleepQualityFragment को sleepNightKey पास करता है जिसे अपडेट करना है.

दूसरा चरण: नींद की क्वालिटी के हिसाब से ट्रैकिंग के लिए नेविगेशन जोड़ना

नेविगेशन ग्राफ़ में SleepTrackerFragment से SleepQualityFragment तक के पाथ और फिर से शामिल हैं. हालांकि, एक फ़्रैगमेंट से दूसरे फ़्रैगमेंट पर नेविगेशन लागू करने वाले क्लिक हैंडलर को अभी तक कोड नहीं किया गया है. अब आप उस कोड को ViewModel में जोड़ सकते हैं.

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

1. SleepTrackerViewModel खोलें. आपको नेविगेशन जोड़ना होगा, ताकि जब उपयोगकर्ता रोकें बटन पर टैप करें, तब ऐप्लिकेशन SleepQualityFragment पर नेविगेट करके क्वालिटी रेटिंग इकट्ठा करे.
2. SleepTrackerViewModel में, एक LiveData बनाएं. यह तब बदलता है, जब आप ऐप्लिकेशन को SleepQualityFragment पर नेविगेट करना चाहते हैं. LiveData का ViewModel पाने लायक वर्शन दिखाने के लिए, एनकैप्लेशन का इस्तेमाल करें.
   
   आप इस कोड को क्लास के टॉप लेवल के किसी भी लेवल पर कहीं भी रख सकते हैं.
   

private val _navigateToSleepQuality = MutableLiveData<SleepNight>()

val navigateToSleepQuality: LiveData<SleepNight>
   get() = _navigateToSleepQuality

3. एक doneNavigating() फ़ंक्शन जोड़ें जो नेविगेशन को ट्रिगर करने वाले वैरिएबल को रीसेट करता है.
   

fun doneNavigating() {
   _navigateToSleepQuality.value = null
}

4. रोकें बटन onStopTracking() के लिए क्लिक हैंडलर में, SleepQualityFragment के लिए नेविगेशन ट्रिगर करें. फ़ंक्शन के आखिर में, launch{} ब्लॉक में आखिरी चीज़ के तौर पर _navigateToSleepQuality वैरिएबल सेट करें. ध्यान दें कि यह वैरिएबल night पर सेट है. जब इस वैरिएबल की वैल्यू होती है, तो ऐप्लिकेशन SleepQualityFragment पर जाता है. यह रात में भी चलता है.
   

_navigateToSleepQuality.value = oldNight

5. SleepTrackerFragment को _navigateToSleepQuality की निगरानी करनी होगी, ताकि ऐप्लिकेशन को पता चल सके कि कब नेविगेट करना है. SleepTrackerFragment के onCreateView() में, navigateToSleepQuality() के लिए ऑब्ज़र्वर जोड़ें. ध्यान दें कि इसके लिए आयात करना अस्पष्ट है और आपको androidx.lifecycle.Observer आयात करना होगा.
   

sleepTrackerViewModel.navigateToSleepQuality.observe(this, Observer {
})

6. ऑब्ज़र्वर ब्लॉक में, नेविगेट करें और मौजूदा रात के आईडी के साथ पास करें. इसके बाद doneNavigating() को कॉल करें. अगर आपका डेटा साफ़ नहीं है, तो androidx.navigation.fragment.findNavController को इंपोर्ट करें.
   

night ->
night?.let {
   this.findNavController().navigate(
           SleepTrackerFragmentDirections
                   .actionSleepTrackerFragmentToSleepQualityFragment(night.nightId))
   sleepTrackerViewModel.doneNavigating()
}

7. अपना ऐप्लिकेशन बनाएं और चलाएं. शुरू करें पर टैप करें. इसके बाद, बंद करें पर टैप करें, जो आपको SleepQualityFragment स्क्रीन पर ले जाएगा. वापस जाने के लिए, सिस्टम के 'वापस जाएं' बटन का इस्तेमाल करें.

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

पहला चरण: ViewModel और ViewModelFactory बनाना

1. sleepquality पैकेज में, SleepqualityViewModel.kt बनाएं या खोलें.
2. एक SleepQualityViewModel क्लास बनाएं, जो sleepNightKey और डेटाबेस को आर्ग्युमेंट के तौर पर लेता हो. SleepTrackerViewModel की तरह ही, आपको database को फ़ैक्ट्री से पास करना होगा. आपको नेविगेशन से sleepNightKey में भी पास करना होगा.
   

class SleepQualityViewModel(
       private val sleepNightKey: Long = 0L,
       val database: SleepDatabaseDao) : ViewModel() {
}

3. SleepQualityViewModel क्लास के अंदर, Job और uiScope तय करें, और onCleared() को ओवरराइड करें.
   

private val viewModelJob = Job()
private val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob)

override fun onCleared() {
   super.onCleared()
   viewModelJob.cancel()
}

4. ऊपर दिए गए पैटर्न का इस्तेमाल करके, SleepTrackerFragment पर वापस जाने के लिए, _navigateToSleepTracker का एलान करें. navigateToSleepTracker और doneNavigating() लागू करें.
   

private val _navigateToSleepTracker = MutableLiveData<Boolean?>()

val navigateToSleepTracker: LiveData<Boolean?>
   get() = _navigateToSleepTracker

fun doneNavigating() {
   _navigateToSleepTracker.value = null
}

5. नींद से जुड़ी सभी इमेज इस्तेमाल करने के लिए, एक क्लिक हैंडलर onSetSleepQuality() बनाएं.
   
   पिछले कोडलैब के समान कोरूटीन पैटर्न का इस्तेमाल करें:

• uiScope में कोरूटीन लॉन्च करें और I/O डिस्पैचर पर स्विच करें.
• sleepNightKey का इस्तेमाल करके tonight पाएं.
• नींद की क्वालिटी सेट करें.
• डेटाबेस अपडेट करें.
• नेविगेशन ट्रिगर करें.

ध्यान दें कि नीचे दिया गया कोड सैंपल, क्लिक हैंडलर में काम करता है, न कि किसी दूसरे तरीके से डेटाबेस ऑपरेशन करने का.

fun onSetSleepQuality(quality: Int) {
        uiScope.launch {
            // IO is a thread pool for running operations that access the disk, such as
            // our Room database.
            withContext(Dispatchers.IO) {
                val tonight = database.get(sleepNightKey) ?: return@withContext
                tonight.sleepQuality = quality
                database.update(tonight)
            }

            // Setting this state variable to true will alert the observer and trigger navigation.
            _navigateToSleepTracker.value = true
        }
    }

5. sleepquality पैकेज में, SleepQualityViewModelFactory.kt बनाएं या खोलें और जैसा बताया गया है उसी हिसाब से SleepQualityViewModelFactory क्लास जोड़ें. यह क्लास उसी बॉयलरप्लेट कोड के वर्शन का इस्तेमाल करती है जिसे आप पहले देख चुके हैं. आगे बढ़ने से पहले कोड की जांच करें.

class SleepQualityViewModelFactory(
       private val sleepNightKey: Long,
       private val dataSource: SleepDatabaseDao) : ViewModelProvider.Factory {
   @Suppress("unchecked_cast")
   override fun <T : ViewModel?> create(modelClass: Class<T>): T {
       if (modelClass.isAssignableFrom(SleepQualityViewModel::class.java)) {
           return SleepQualityViewModel(sleepNightKey, dataSource) as T
       }
       throw IllegalArgumentException("Unknown ViewModel class")
   }
}

दूसरा चरण: SleepqualityFragment अपडेट करना

1. SleepQualityFragment.kt खोलें.
2. onCreateView() में, application पाने के बाद, आपको नेविगेशन के साथ मिलने वाला arguments पाना होगा. ये तर्क SleepQualityFragmentArgs में हैं. आपको उन्हें बंडल से निकालना होगा.

val arguments = SleepQualityFragmentArgs.fromBundle(arguments!!)

3. इसके बाद, dataSource पाएं.

val dataSource = SleepDatabase.getInstance(application).sleepDatabaseDao

4. dataSource और sleepNightKey पास करने वाली एक फ़ैक्ट्री बनाएं.

val viewModelFactory = SleepQualityViewModelFactory(arguments.sleepNightKey, dataSource)

5. ViewModel का रेफ़रंस पाएं.

val sleepQualityViewModel =
       ViewModelProviders.of(
               this, viewModelFactory).get(SleepQualityViewModel::class.java)

6. बाइंडिंग ऑब्जेक्ट में ViewModel जोड़ें. (अगर आपको बाइंडिंग ऑब्जेक्ट में कोई गड़बड़ी दिखती है, तो उसे अभी अनदेखा करें.)

binding.sleepQualityViewModel = sleepQualityViewModel

7. ऑब्ज़र्वर जोड़ें. जब कहा जाए, तब androidx.lifecycle.Observer इंपोर्ट करें.

sleepQualityViewModel.navigateToSleepTracker.observe(this, Observer {
   if (it == true) { // Observed state is true.
       this.findNavController().navigate(
               SleepQualityFragmentDirections.actionSleepQualityFragmentToSleepTrackerFragment())
       sleepQualityViewModel.doneNavigating()
   }
})

तीसरा चरण: लेआउट फ़ाइल अपडेट करना और ऐप्लिकेशन चलाना

1. fragment_sleep_quality.xml लेआउट फ़ाइल खोलें. <data> ब्लॉक में, SleepQualityViewModel के लिए कोई वैरिएबल जोड़ें.

 <data>
       <variable
           name="sleepQualityViewModel"
           type="com.example.android.trackmysleepquality.sleepquality.SleepQualityViewModel" />
   </data>

2. नींद की क्वालिटी से जुड़ी छह इमेज में से हर एक के लिए, नीचे दिए गए क्लिक हैंडलर जैसा कुछ जोड़ें. इमेज की क्वालिटी रेटिंग से मिलान करें.

android:onClick="@{() -> sleepQualityViewModel.onSetSleepQuality(5)}"

3. अपने प्रोजेक्ट को साफ़ करें और फिर से बनाएं. इसे बाइंडिंग ऑब्जेक्ट से जुड़ी किसी भी गड़बड़ी को ठीक कर दिया जाएगा. नहीं तो, कैश मेमोरी मिटाएं (फ़ाइल > कैश मेमोरी अमान्य करें / रीस्टार्ट करें) और अपना ऐप्लिकेशन फिर से बनाएं.

जारी रखने से पहले, पक्का करें कि ऐप्लिकेशन में कोई गड़बड़ी न हो और अब आप नींद की क्वालिटी को रिकॉर्ड कर सकें.

बधाई हो! आपने कोरूटीन का इस्तेमाल करके अभी-अभी एक पूरा Room डेटाबेस ऐप्लिकेशन बनाया है.

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

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

पहला चरण: बटन की स्थितियां अपडेट करना

बटन को इस स्थिति में सेट करने का सुझाव दिया जाता है कि शुरुआत में ही, शुरू करें बटन चालू हो जाए. इसका मतलब है कि इस पर क्लिक किया जा सकता है.

उपयोगकर्ता के शुरू करें पर टैप करने के बाद, रोकें बटन चालू हो जाता है और शुरू करें नहीं. डेटाबेस में डेटा होने पर ही हटाएं बटन चालू होता है.

1. fragment_sleep_tracker.xml लेआउट फ़ाइल खोलें.
2. हर बटन में android:enabled प्रॉपर्टी जोड़ें. android:enabled प्रॉपर्टी एक बूलियन वैल्यू है, जिससे पता चलता है कि बटन चालू है या नहीं. (चालू बटन पर टैप किया जा सकता है; बंद किया गया बटन #39;t. टैप कर सकता है.) प्रॉपर्टी को एक स्टेट वैरिएबल की वैल्यू दें, जिसे आप एक पल में परिभाषित करेंगे.

start_button:

android:enabled="@{sleepTrackerViewModel.startButtonVisible}"

stop_button:

android:enabled="@{sleepTrackerViewModel.stopButtonVisible}"

clear_button:

android:enabled="@{sleepTrackerViewModel.clearButtonVisible}"

3. SleepTrackerViewModel खोलें और तीन संबंधित वैरिएबल बनाएं. हर वैरिएबल को एक ट्रांसफ़ॉर्मेशन असाइन करें, जो उसकी जांच करता हो.

• जब tonight null हो, तो शुरू करें बटन को चालू किया जाना चाहिए.
• जब tonight null न हो, तब रोकें बटन चालू होना चाहिए.
• हटाएं बटन को सिर्फ़ तभी चालू करना चाहिए, जब nights और इस तरह डेटाबेस में नींद की रातें हों.

val startButtonVisible = Transformations.map(tonight) {
   it == null
}
val stopButtonVisible = Transformations.map(tonight) {
   it != null
}
val clearButtonVisible = Transformations.map(nights) {
   it?.isNotEmpty()
}

4. अपना ऐप्लिकेशन चलाएं और बटन की मदद से जांच करें.

सलाह: बंद किए गए व्यू को दिखाने का तरीका सेट करना

enabled और visibility एट्रिब्यूट, दोनों एक जैसे नहीं हैं. enabled एट्रिब्यूट सिर्फ़ यह तय करता है कि View चालू है या नहीं, न कि View दिख रहा है या नहीं.

& की कोटेशन का मतलब अलग-अलग है. उपयोगकर्ता किसी चालू EditText में टेक्स्ट में बदलाव कर सकते हैं, लेकिन बंद किए गए EditText में नहीं. उपयोगकर्ता किसी चालू की गई Button पर टैप कर सकता है, लेकिन बंद किए गए किसी विकल्प पर टैप #39; नहीं कर सकता.

डिफ़ॉल्ट रूप से एक बंद स्टाइल पर View लागू किया जाता है, ताकि यह दिखाया जा सके कि View चालू नहीं है.

हालांकि, अगर View में background एट्रिब्यूट या textColor एट्रिब्यूट है, तो View दिखाए जाने पर, उन एट्रिब्यूट की वैल्यू का इस्तेमाल किया जाता है. भले ही, View बंद हो.

यह तय करने के लिए कि चालू और बंद की गई स्थितियों के लिए किस रंग का इस्तेमाल करना है, टेक्स्ट के रंग के लिए ColorStateList और बैकग्राउंड के रंग के लिए StateListDrawable इस्तेमाल करें.

चरण 2: उपयोगकर्ता को सूचित करने के लिए स्नैकबार का इस्तेमाल करना

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

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

1. SleepTrackerViewModel में, एन्क्रिप्ट (सुरक्षित) किया गया इवेंट बनाएं.
   

private var _showSnackbarEvent = MutableLiveData<Boolean>()

val showSnackBarEvent: LiveData<Boolean>
   get() = _showSnackbarEvent

2. इसके बाद, doneShowingSnackbar() लागू करें.
   

fun doneShowingSnackbar() {
   _showSnackbarEvent.value = false
}

3. SleepTrackerFragment के onCreateView() में, ऑब्ज़र्वर जोड़ें:
   

sleepTrackerViewModel.showSnackBarEvent.observe(this, Observer { })

4. ऑब्ज़र्वर ब्लॉक में, स्नैकबार दिखाएं और इवेंट को तुरंत रीसेट करें.

   if (it == true) { // Observed state is true.
       Snackbar.make(
               activity!!.findViewById(android.R.id.content),
               getString(R.string.cleared_message),
               Snackbar.LENGTH_SHORT // How long to display the message.
       ).show()
       sleepTrackerViewModel.doneShowingSnackbar()
   }

5. SleepTrackerViewModel में, onClear() तरीके में इवेंट ट्रिगर करें. ऐसा करने के लिए, launch ब्लॉक में इवेंट वैल्यू को true पर सेट करें:

_showSnackbarEvent.value = true

6. अपना ऐप्लिकेशन बनाएं और चलाएं!

Android Studio प्रोजेक्ट: TrackMySleepीEnd

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

• ViewModel और ViewModelFactory बनाएं और डेटा स्रोत सेट अप करें.
• नेविगेशन ट्रिगर करें. समस्याओं को अलग करने के लिए, क्लिक हैंडलर को व्यू मॉडल में और नेविगेशन को फ़्रैगमेंट में रखें.
• स्थिति में होने वाले बदलावों को ट्रैक करने और उनका जवाब देने के लिए, LiveData के साथ एनकैप्सुलेशन का इस्तेमाल करें.
• LiveData के साथ बदलावों का इस्तेमाल करें.
• सिंगलटन डेटाबेस बनाएं.
• डेटाबेस ऑपरेशन के लिए कोरूटीन सेट अप करें.

ट्रिगर करना

आप किसी नेविगेशन फ़ाइल में फ़्रैगमेंट के बीच नेविगेशन के संभावित पाथ तय करते हैं. एक फ़्रैगमेंट से दूसरे फ़्रैगमेंट पर नेविगेशन ट्रिगर करने के कुछ तरीके हैं. इनमें से आम वजह यहां दी गई हैं:

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

android:Enabled एट्रिब्यूट सेट करना

• android:enabled एट्रिब्यूट को TextView में बताया गया है और यह Button के साथ-साथ सभी सब-क्लास को इनहेरिट करता है.
• android:enabled एट्रिब्यूट से यह तय होता है कि View चालू है या नहीं. & की कोटेशन का मतलब अलग-अलग है. उदाहरण के लिए, चालू नहीं किए गए EditText से उपयोगकर्ता शामिल टेक्स्ट में बदलाव नहीं कर सकते. साथ ही, गैर-चालू Button उपयोगकर्ता को बटन पर टैप करने से रोकता है.
• enabled और visibility एट्रिब्यूट, दोनों एक जैसे नहीं हैं.
• आप बदलावों वाले मैप का इस्तेमाल करके, किसी दूसरे ऑब्जेक्ट या वैरिएबल की स्थिति के आधार पर, बटन के enabled एट्रिब्यूट की वैल्यू सेट कर सकते हैं.

इस कोडलैब में शामिल अन्य पॉइंट:

• उपयोगकर्ता को सूचनाएं ट्रिगर करने के लिए, उसी तकनीक का इस्तेमाल किया जा सकता है जिसका इस्तेमाल नेविगेशन को ट्रिगर करने के लिए किया जाता है.
• आप उपयोगकर्ता को सूचना देने के लिए Snackbar का इस्तेमाल कर सकते हैं.

Udcity कोर्स:

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

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

• नेविगेशन
• बैक अप और अप नेविगेशन डिज़ाइन करना
• Snackbar

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

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

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

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

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

पहला सवाल

आपके ऐप्लिकेशन को एक फ़्रैगमेंट से अगले फ़्रैगमेंट पर ट्रिगर करने के लिए, LiveData वैल्यू का इस्तेमाल करें. इससे, यह पता चलता है कि नेविगेशन को ट्रिगर करना है या नहीं.

लाल फ़्रैगमेंट से नीले फ़्रैगमेंट तक नेविगेशन को ट्रिगर करने के लिए, gotoBlueFragment वैल्यू LiveData वैल्यू इस्तेमाल करने का तरीका क्या है? लागू होने वाले सभी विकल्प चुनें:

• ViewModel में, LiveData वैल्यू gotoBlueFragment तय करें.
• RedFragment में, gotoBlueFragment वैल्यू पर नज़र रखें. जहां सही हो वहां observe{} कोड पर जाकर BlueFragment पर जाएं. इसके बाद, gotoBlueFragment का मान रीसेट करें. इससे पता चलेगा कि नेविगेशन पूरा हो गया है.
• पक्का करें कि आपका कोड उस वैल्यू पर gotoBlueFragment वैरिएबल सेट करता हो जो ऐप्लिकेशन को RedFragment से BlueFragment तक जाने के लिए नेविगेशन को ट्रिगर करता है.
• पक्का करें कि आपका कोड उस View के लिए onClick हैंडलर तय करता है जिस पर उपयोगकर्ता BlueFragment पर जाने के लिए क्लिक करता है. यहां onClick हैंडलर goToBlueFragment वैल्यू की निगरानी करता है.

सवाल 2

आप LiveData का इस्तेमाल करके यह बदल सकते हैं कि Button चालू है (क्लिक करने लायक) या नहीं. आप यह कैसे पक्का करेंगे कि आपका ऐप्लिकेशन UpdateNumber बटन को इस तरह बदले कि:

• अगर myNumber की वैल्यू पांच से ज़्यादा है, तो बटन चालू होगा.
• अगर myNumber पांच के बराबर या उससे कम है, तो बटन चालू नहीं होता है.

मान लें कि UpdateNumber बटन वाले लेआउट में, NumbersViewModel का <data> वैरिएबल शामिल है, जैसा कि यहां दिखाया गया है:

<data>
   <variable
       name="NumbersViewModel"
       type="com.example.android.numbersapp.NumbersViewModel" />
</data>

मान लें कि लेआउट फ़ाइल में मौजूद बटन का आईडी यह है:

android:id="@+id/update_number_button"

आपको और क्या करना है? लागू होने वाले सभी विकल्प चुनें.

• NumbersViewModel क्लास में, संख्या दिखाने वाला एक LiveData वैरिएबल, myNumber तय करें. साथ ही, वह वैरिएबल डालें जिसकी वैल्यू को myNumber वैरिएबल पर Transform.map() को कॉल करके सेट किया जाता है. इससे यह बूलियन पता चलता है कि संख्या पांच से ज़्यादा है या नहीं.
  
  खास तौर पर, ViewModel में यह कोड जोड़ें:

val myNumber: LiveData<Int>

val enableUpdateNumberButton = Transformations.map(myNumber) {
   myNumber > 5
}

• एक्सएमएल लेआउट में, update_number_button button के android:enabled एट्रिब्यूट को NumberViewModel.enableUpdateNumbersButton पर सेट करें.

android:enabled="@{NumbersViewModel.enableUpdateNumberButton}"

• NumbersViewModel क्लास का इस्तेमाल करने वाले Fragment में, बटन के enabled एट्रिब्यूट में ऑब्ज़र्वर जोड़ें.
  
  खास तौर पर, Fragment में यह कोड जोड़ें:

// Observer for the enabled attribute
viewModel.enabled.observe(this, Observer<Boolean> { isEnabled ->
   myNumber > 5
})

• लेआउट फ़ाइल में, update_number_button button के android:enabled एट्रिब्यूट को "Observable" पर सेट करें.

अगले लेसन पर जाएं: 7.1 RecyclerView की बुनियादी बातें

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