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

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

परिचय

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

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

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

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

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

आपको क्या सीखने को मिलेगा

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

आपको क्या करना होगा

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

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

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

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

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

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

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

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

• यूज़र इंटरफ़ेस (यूआई) कंट्रोलर
• मॉडल और 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 का पालन करता है. डेटा में बदलाव होने पर, फ़्रैगमेंट डेस्टिनेशन पर जाता है और व्यू मॉडल को बताता है कि यह काम पूरा हो गया है. इससे स्टेट वैरिएबल रीसेट हो जाता है.

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

private val _navigateToSleepQuality = MutableLiveData<SleepNight>()

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

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

fun doneNavigating() {
   _navigateToSleepQuality.value = null
}

4. Stop बटन के क्लिक हैंडलर में, onStopTracking(), SleepQualityFragment पर नेविगेशन ट्रिगर करें. फ़ंक्शन के आखिर में _navigateToSleepQuality वैरिएबल को सेट करें. यह launch{} ब्लॉक के अंदर मौजूद आखिरी आइटम होना चाहिए. ध्यान दें कि इस वैरिएबल को 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. अपने प्रोजेक्ट को क्लीन करें और फिर से बनाएं. इससे बाइंडिंग ऑब्जेक्ट से जुड़ी सभी गड़बड़ियां ठीक हो जाएंगी. अगर ऐसा नहीं होता है, तो कैश मेमोरी मिटाएं (File > Invalidate Caches / Restart) और अपने ऐप्लिकेशन को फिर से बनाएं.

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

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

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

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

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

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

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

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

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 पर टैप कर सकता है. हालांकि, वह बंद किए गए Button पर टैप नहीं कर सकता.

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

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

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

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

जब उपयोगकर्ता डेटाबेस मिटा दे, तब उसे 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 प्रोजेक्ट: TrackMySleepQualityFinal

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

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

नेविगेशन ट्रिगर करना

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

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

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

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

इस कोडलैब में शामिल अन्य विषय:

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

Udacity का कोर्स:

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

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

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

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

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

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

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

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

पहला सवाल

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

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

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

सवाल 2

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

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

मान लें कि 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() को कॉल करके सेट की जाती है. यह वैरिएबल, बूलियन वैल्यू दिखाता है. इससे पता चलता है कि संख्या 5 से बड़ी है या नहीं.
  
  खास तौर पर, 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 Fundamentals कोडलैब का लैंडिंग पेज देखें.