मॉनिटर किए जा सकने वाले डेटा ऑब्जेक्ट के साथ काम करना

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

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

जब इनमें से कोई एक मॉनिटर किया जा सकने वाला डेटा ऑब्जेक्ट, यूज़र इंटरफ़ेस (यूआई) और डेटा ऑब्जेक्ट बदलता है और यूज़र इंटरफ़ेस (यूआई) अपने-आप अपडेट होता है.

मॉनिटर किए जा सकने वाले फ़ील्ड

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

ऑब्ज़र्वेबल फ़ील्ड होते हैं: मॉनिटर किए जा सकने वाले ऐसे ऑब्जेक्ट जिनमें एक सिंगल फ़ील्ड में डालें. प्रिमिटिव वर्शन में बॉक्सिंग और अनबाॅक्सिंग से बचा जा सकता है कार्रवाइयां. इस तरीके का इस्तेमाल करने के लिए, 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&lt;String, Object&gt;"/>
</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&lt;Object&gt;"/>
</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

अन्य संसाधन

डेटा बाइंडिंग के बारे में ज़्यादा जानने के लिए, अतिरिक्त संसाधनों के लिए यहां देखें:

सैंपल

कोड लैब

ब्लॉग पोस्ट