निगरानी का मतलब किसी ऑब्जेक्ट की उस क्षमता से है जिसके बारे में दूसरों को सूचना दी जा सकती है के डेटा में बदलाव कर सकता है. डेटा बाइंडिंग लाइब्रेरी से आपको ऑब्जेक्ट, फ़ील्ड या कलेक्शन को मॉनिटर किया जा सकता है.
डेटा बाइंडिंग के लिए किसी भी ऑब्जेक्ट का इस्तेमाल किया जा सकता है, लेकिन ऑब्जेक्ट में बदलाव करने से कुछ नहीं होता अपने-आप वह यूज़र इंटरफ़ेस (यूआई) अपडेट हो जाता है. अपना डेटा देने के लिए, डेटा बाइंडिंग का इस्तेमाल किया जा सकता है ऑब्जेक्ट द्वारा अन्य ऑब्जेक्ट को सूचित करने की क्षमता होती है—जिसे लिसनर कहते हैं—जब उनका डेटा बदलता है. मॉनिटर की जा सकने वाली क्लास तीन तरह की होती हैं: फ़ील्ड, कलेक्शन, और ऑब्जेक्ट को पूरा करता है.
जब इनमें से कोई एक मॉनिटर किया जा सकने वाला डेटा ऑब्जेक्ट, यूज़र इंटरफ़ेस (यूआई) और डेटा ऑब्जेक्ट बदलता है और यूज़र इंटरफ़ेस (यूआई) अपने-आप अपडेट होता है.
मॉनिटर किए जा सकने वाले फ़ील्ड
अगर आपकी क्लास में कुछ ही प्रॉपर्टी हैं, तो शायद यह काम न करे
ऐसी क्लास बनाएं जो
Observable
इंटरफ़ेस. इसमें
केस, आप सामान्य Observable
क्लास और
फ़ील्ड को मॉनिटर करने के लिए, बुनियादी डेटा वाली क्लास:
ObservableBoolean
ObservableByte
ObservableChar
ObservableShort
ObservableInt
ObservableLong
ObservableFloat
ObservableDouble
ObservableParcelable
ऑब्ज़र्वेबल फ़ील्ड होते हैं: मॉनिटर किए जा सकने वाले ऐसे ऑब्जेक्ट जिनमें एक सिंगल
फ़ील्ड में डालें. प्रिमिटिव वर्शन में बॉक्सिंग और अनबाॅक्सिंग से बचा जा सकता है
कार्रवाइयां. इस तरीके का इस्तेमाल करने के लिए, Java में public final
प्रॉपर्टी बनाएं
या Kotlin में रीड-ओनली प्रॉपर्टी, जैसा कि
नीचे दिया गया उदाहरण:
Kotlin
class User { val firstName = ObservableField<String>() val lastName = ObservableField<String>() val age = ObservableInt() }
Java
private static class User { public final ObservableField<String> firstName = new ObservableField<>(); public final ObservableField<String> lastName = new ObservableField<>(); public final ObservableInt age = new ObservableInt(); }
फ़ील्ड वैल्यू को ऐक्सेस करने के लिए,
set()
और
get()
ऐक्सेसर के तरीके
या Kotlin प्रॉपर्टी का इस्तेमाल करें
सिंटैक्स:
Kotlin
user.firstName = "Google" val age = user.age
Java
user.firstName.set("Google"); int age = user.age.get();
मॉनिटर किए जा सकने वाले कलेक्शन
कुछ ऐप्लिकेशन डेटा रखने के लिए डाइनैमिक स्ट्रक्चर का इस्तेमाल करते हैं. निगरानी किए जा सकने वाले कलेक्शन,
की मदद से इन स्ट्रक्चर को ऐक्सेस करने की अनुमति दें. कॉन्टेंट बनाने
ObservableArrayMap
क्लास
कुंजी तब काम आती है, जब वह कोई पहचान फ़ाइल हो, जैसे कि String
, जैसा कि
नीचे दिया गया उदाहरण:
Kotlin
ObservableArrayMap<String, Any>().apply { put("firstName", "Google") put("lastName", "Inc.") put("age", 17) }
Java
ObservableArrayMap<String, Object> user = new ObservableArrayMap<>(); user.put("firstName", "Google"); user.put("lastName", "Inc."); user.put("age", 17);
लेआउट में, आप स्ट्रिंग कुंजियों का इस्तेमाल करके मैप ढूंढ सकते हैं, जैसा कि नीचे दिया गया उदाहरण:
<data>
<import type="android.databinding.ObservableMap"/>
<variable name="user" type="ObservableMap<String, Object>"/>
</data>
…
<TextView
android:text="@{user.lastName}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:text="@{String.valueOf(1 + (Integer)user.age)}"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
ObservableArrayList
क्लास तब काम आती है, जब कुंजी एक पूर्णांक हो, जैसा कि यहां बताया गया है:
Kotlin
ObservableArrayList<Any>().apply { add("Google") add("Inc.") add(17) }
Java
ObservableArrayList<Object> user = new ObservableArrayList<>(); user.add("Google"); user.add("Inc."); user.add(17);
लेआउट में, इंडेक्स के ज़रिए सूची को ऐक्सेस किया जा सकता है, जैसा कि नीचे दिया गया उदाहरण:
<data>
<import type="android.databinding.ObservableList"/>
<import type="com.example.my.app.Fields"/>
<variable name="user" type="ObservableList<Object>"/>
</data>
…
<TextView
android:text='@{user[Fields.LAST_NAME]}'
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView
android:text='@{String.valueOf(1 + (Integer)user[Fields.AGE])}'
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
ऑब्ज़र्व किए जा सकने वाले ऑब्जेक्ट
Observable
इंटरफ़ेस को लागू करने वाली क्लास,
ऐसे लिसनर जो मॉनिटर किए जा सकने वाले प्रॉपर्टी में होने वाले बदलावों की सूचना पाना चाहते हैं
ऑब्जेक्ट है.
Observable
इंटरफ़ेस में, सुनने वालों को जोड़ने और हटाने का एक तरीका होता है. हालांकि,
तय करें कि सूचनाएं कब भेजी जाएं. विकास को आसान बनाने के लिए, डेटा
बाइंडिंग लाइब्रेरी
BaseObservable
क्लास, जिसमें
लिसनर रजिस्ट्रेशन मैकेनिज़्म लागू करता है. लागू करने वाली डेटा क्लास
प्रॉपर्टी में बदलाव होने पर, BaseObservable
इसकी सूचना देगा. ऐसा करें
इसके लिए, Bindable
एनोटेशन असाइन करें
गेटर को कॉल करें और
notifyPropertyChanged()
सेट अप करने के तरीके के बारे में ज़्यादा जानें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:
Kotlin
class User : BaseObservable() { @get:Bindable var firstName: String = "" set(value) { field = value notifyPropertyChanged(BR.firstName) } @get:Bindable var lastName: String = "" set(value) { field = value notifyPropertyChanged(BR.lastName) } }
Java
private static class User extends BaseObservable { private String firstName; private String lastName; @Bindable public String getFirstName() { return this.firstName; } @Bindable public String getLastName() { return this.lastName; } public void setFirstName(String firstName) { this.firstName = firstName; notifyPropertyChanged(BR.firstName); } public void setLastName(String lastName) { this.lastName = lastName; notifyPropertyChanged(BR.lastName); } }
डेटा बाइंडिंग, मॉड्यूल पैकेज में BR
नाम की एक क्लास जनरेट करती है, जिसमें यह शामिल होता है
डेटा बाइंडिंग के लिए इस्तेमाल किए जाने वाले संसाधनों के आईडी. Bindable
एनोटेशन
कंपाइलेशन के दौरान BR
क्लास फ़ाइल में एक एंट्री जनरेट करता है. अगर बेस क्लास
के डेटा क्लास में बदलाव नहीं किया जा सकता, इसलिए आप Observable
इंटरफ़ेस को लागू कर सकते हैं
इसका इस्तेमाल करके
PropertyChangeRegistry
का इस्तेमाल करें.
लाइफ़साइकल की जानकारी वाले ऑब्जेक्ट
आपके ऐप्लिकेशन के लेआउट, डेटा बाइंडिंग सोर्स से भी बाइंड कर सकते हैं. ये सोर्स अपने-आप यूज़र इंटरफ़ेस (यूआई) को डेटा में हुए बदलावों के बारे में सूचना देने के लिए. इस तरह, आपकी बाइंडिंग लाइफ़साइकल की जानकारी है और यह सिर्फ़ तब ट्रिगर होती है, जब स्क्रीन पर यूज़र इंटरफ़ेस (यूआई) दिखता है.
डेटा बाइंडिंग काम करता है
StateFlow
और
LiveData
. इसके बारे में ज़्यादा जानकारी पाने के लिए,
डेटा बाइंडिंग में LiveData
का इस्तेमाल करने पर, यूज़र इंटरफ़ेस (यूआई) को डेटा के बारे में सूचना देने के लिए, LiveData का इस्तेमाल करना देखें
बदलाव.
StateFlow का इस्तेमाल करें
अगर आपका ऐप्लिकेशन कोरूटीन के साथ Kotlin का इस्तेमाल करता है, तो
डेटा बाइंडिंग सोर्स के तौर पर StateFlow
ऑब्जेक्ट. StateFlow
ऑब्जेक्ट का इस्तेमाल करने के लिए
आपकी बाइंडिंग क्लास है, तो लाइफ़साइकल का मालिक तय करें, जो
StateFlow
ऑब्जेक्ट. इस उदाहरण में, गतिविधि को इस तरह से दिखाया गया है:
बाइंडिंग क्लास इंस्टैंशिएट होने के बाद, लाइफ़साइकल मालिक:
class ViewModelActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
// Inflate view and obtain an instance of the binding class.
val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)
// Specify the current activity as the lifecycle owner.
binding.lifecycleOwner = this
}
}
जैसा कि आर्किटेक्चर के बाइंड लेआउट व्यू में बताया गया है
कॉम्पोनेंट, डेटा बाइंडिंग
ViewModel
के साथ आसानी से काम करता है
ऑब्जेक्ट हैं. StateFlow
और ViewModel
को एक साथ इस्तेमाल करने के लिए, यह तरीका अपनाएं:
class ScheduleViewModel : ViewModel() {
private val _username = MutableStateFlow<String>("")
val username: StateFlow<String> = _username
init {
viewModelScope.launch {
_username.value = Repository.loadUserName()
}
}
}
अपने लेआउट में, ViewModel
ऑब्जेक्ट की प्रॉपर्टी और तरीके असाइन करें
बाइंडिंग एक्सप्रेशन का इस्तेमाल करके संबंधित व्यू, जैसा कि नीचे दिखाया गया है
उदाहरण:
<TextView
android:id="@+id/name"
android:text="@{viewmodel.username}" />
उपयोगकर्ता के नाम की वैल्यू बदलने पर, यूज़र इंटरफ़ेस अपने-आप अपडेट हो जाता है.
StateFlow की सहायता सुविधा बंद करें
Kotlin और AndroidX का इस्तेमाल करने वाले ऐप्लिकेशन के लिए, StateFlow
सहायता अपने-आप काम करती है
डेटा बाइंडिंग के साथ शामिल है. इसका मतलब है कि कोरूटीन डिपेंडेंसी
यह रेंज पहले से उपलब्ध न होने पर, आपके ऐप्लिकेशन में अपने-आप शामिल हो जाती है.
इस सुविधा से ऑप्ट आउट किया जा सकता है. इसके लिए, आपको अपने
build.gradle
फ़ाइल:
ग्रूवी
android { ... dataBinding { addKtx = false } }
Kotlin
android { ... dataBinding { addKtx = false } }
इसके अलावा, अपने प्रोजेक्ट में दुनिया भर में StateFlow
को बंद किया जा सकता है. इसके लिए,
gradle.properties
फ़ाइल पर लाने के लिए नीचे दी गई लाइन:
ग्रूवी
android.defaults.databinding.addKtx = false
Kotlin
android.defaults.databinding.addKtx = false
अन्य संसाधन
डेटा बाइंडिंग के बारे में ज़्यादा जानने के लिए, अतिरिक्त संसाधनों के लिए यहां देखें:
सैंपल
कोड लैब
ब्लॉग पोस्ट
आपके लिए सुझाव
- ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
- ViewModel के लिए सेव किया गया स्टेट मॉड्यूल
- आर्किटेक्चर कॉम्पोनेंट के लिए बाइंड लेआउट व्यू
- पेजिंग लाइब्रेरी की खास जानकारी