दो तरफ़ा डेटा बाइंडिंग

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

<CheckBox
    android:id="@+id/rememberMeCheckBox"
    android:checked="@{viewmodel.rememberMe}"
    android:onCheckedChanged="@{viewmodel.rememberMeChanged}"
/>

दो-तरफ़ा डेटा बाइंडिंग, इस प्रोसेस का शॉर्टकट देता है:

<CheckBox
    android:id="@+id/rememberMeCheckBox"
    android:checked="@={viewmodel.rememberMe}"
/>

@={} नोटेशन, जिसमें महत्वपूर्ण रूप से "=" शामिल होता है साइन, डेटा रिसीव करता है प्रॉपर्टी में किए गए बदलावों को देखना और उपयोगकर्ता के अपडेट को एक साथ सुनना भी शामिल है.

बैकिंग डेटा में हुए बदलावों पर प्रतिक्रिया देने के लिए, अपना लेआउट Observable का लागू करने वाला वैरिएबल, आम तौर पर BaseObservable और किसी @Bindable व्याख्या, जैसा कि इसमें दिखाया गया है यहां दिया गया कोड स्निपेट जोड़ें:

class LoginViewModel : BaseObservable {
    // val data = ...

    @Bindable
    fun getRememberMe(): Boolean {
        return data.rememberMe
    }

    fun setRememberMe(value: Boolean) {
        // Avoids infinite loops.
        if (data.rememberMe != value) {
            data.rememberMe = value

            // React to the change.
            saveData()

            // Notify observers of a new value.
            notifyPropertyChanged(BR.remember_me)
        }
    }
}

public class LoginViewModel extends BaseObservable {
    // private Model data = ...

    @Bindable
    public Boolean getRememberMe() {
        return data.rememberMe;
    }

    public void setRememberMe(Boolean value) {
        // Avoids infinite loops.
        if (data.rememberMe != value) {
            data.rememberMe = value;

            // React to the change.
            saveData();

            // Notify observers of a new value.
            notifyPropertyChanged(BR.remember_me);
        }
    }
}

बाइंड होने लायक प्रॉपर्टी के गैटर तरीके को getRememberMe() कहा जाता है. इसलिए, प्रॉपर्टी से जुड़ा सेटर तरीका अपने-आप नाम का इस्तेमाल करता है setRememberMe().

BaseObservable और @Bindable का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, इनके साथ काम करें मॉनिटर किए जा सकने वाले डेटा ऑब्जेक्ट.

कस्टम एट्रिब्यूट इस्तेमाल करके दो-तरफ़ा डेटा बाइंडिंग

यह प्लैटफ़ॉर्म सबसे आम दो-तरफ़ा एट्रिब्यूट और लिसनर बदलें, ताकि इनका इस्तेमाल किया जा सके में जोड़ा जा सकता है. अगर आपको कस्टम पैरामीटर के साथ दो-तरफ़ा डेटा बाइंडिंग का इस्तेमाल करना है, तो विशेषताओं के साथ काम करना है, तो आपको @InverseBindingAdapter और @InverseBindingMethod एनोटेशन.

उदाहरण के लिए, अगर आपको "time" एट्रिब्यूट पर दो-तरफ़ा डेटा बाइंडिंग चालू करनी है MyView नाम के कस्टम व्यू में, नीचे दिए गए चरणों को पूरा करें:

1. उस तरीके के बारे में बताएं जो शुरुआती वैल्यू सेट करता है और वैल्यू के अपडेट होने पर @BindingAdapter का इस्तेमाल करके किए गए बदलाव:

   Kotlin

   @BindingAdapter("time")
   @JvmStatic fun setTime(view: MyView, newValue: Time) {
       // Important to break potential infinite loops.
       if (view.time != newValue) {
           view.time = newValue
       }
   }

   Java

   @BindingAdapter("time")
   public static void setTime(MyView view, Time newValue) {
       // Important to break potential infinite loops.
       if (view.time != newValue) {
           view.time = newValue;
       }
   }

2. का उपयोग करके दृश्य से मान पढ़ने वाली विधि एनोटेट करें @InverseBindingAdapter:

   Kotlin

   @InverseBindingAdapter("time")
   @JvmStatic fun getTime(view: MyView) : Time {
       return view.getTime()
   }

   Java

   @InverseBindingAdapter("time")
   public static Time getTime(MyView view) {
       return view.getTime();
   }

इस स्थिति में, डेटा बाइंडिंग को यह पता होता है कि डेटा में बदलाव होने पर क्या करना है (यह तरीका @BindingAdapter) और उन्हें जब दृश्य विशेषता बदलती है (यह InverseBindingListener). हालांकि, इससे यह पता नहीं चलता कि एट्रिब्यूट कब या कैसे बदलता है.

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

@BindingAdapter("app:timeAttrChanged")
@JvmStatic fun setListeners(
        view: MyView,
        attrChange: InverseBindingListener
) {
    // Set a listener for click, focus, touch, etc.
}

@BindingAdapter("app:timeAttrChanged")
public static void setListeners(
        MyView view, final InverseBindingListener attrChange) {
    // Set a listener for click, focus, touch, etc.
}

लिसनर में, पैरामीटर के तौर पर InverseBindingListener शामिल होता है. आप डेटा बाइंडिंग सिस्टम को यह बताने के लिए InverseBindingListener कि एट्रिब्यूट में बदल दिया गया है. इसके बाद, सिस्टम एनोटेट किए गए तरीके को कॉल करना शुरू कर सकता है @InverseBindingAdapter वगैरह.

मुमकिन है कि इस लिसनर में, लिसनर के साथ-साथ कुछ सामान्य लॉजिक का इस्तेमाल किया गया हो एकतरफ़ा डेटा बाइंडिंग के लिए. उदाहरण के लिए, टेक्स्ट एट्रिब्यूट के लिए अडैप्टर देखें बदलें, TextViewBindingAdapter.

ग्राहक में बदलने वाले लोगों की संख्या

अगर कोई वैरिएबल, जो किसी View ऑब्जेक्ट से जुड़ा है दिखाने से पहले, फ़ॉर्मैट करने, अनुवाद करने या किसी और तरह से बदलने की ज़रूरत होती है, Converter ऑब्जेक्ट का इस्तेमाल किया जा सकता है.

उदाहरण के लिए, तारीख दिखाने वाला EditText ऑब्जेक्ट लें:

<EditText
    android:id="@+id/birth_date"
    android:text="@={Converter.dateToString(viewmodel.birthDate)}"
/>

viewmodel.birthDate एट्रिब्यूट में Long टाइप की वैल्यू शामिल है, इसलिए इसके लिए ज़रूरी है का इस्तेमाल करके फ़ॉर्मैट किया जा सकता है.

चूंकि दो-तरफ़ा व्यंजक का उपयोग किया जा रहा है, इसलिए एक विलोम भी होना चाहिए कन्वर्टर किया जा सकता है, ताकि लाइब्रेरी को उपयोगकर्ता से मिली स्ट्रिंग को वापस बदलने का तरीका पता चल सके करना है, इस मामले में Long. यह प्रक्रिया @InverseMethod एनोटेशन कन्वर्ज़न कर सकते हैं और इस एनोटेशन में व्युत्क्रम का संदर्भ दे सकते हैं कन्वर्टर. इस कॉन्फ़िगरेशन का एक उदाहरण नीचे दिए गए कोड में दिखता है snippet:

object Converter {
    @InverseMethod("stringToDate")
    @JvmStatic fun dateToString(
        view: EditText, oldValue: Long,
        value: Long
    ): String {
        // Converts long to String.
    }

    @JvmStatic fun stringToDate(
        view: EditText, oldValue: String,
        value: String
    ): Long {
        // Converts String to long.
    }
}

public class Converter {
    @InverseMethod("stringToDate")
    public static String dateToString(EditText view, long oldValue,
            long value) {
        // Converts long to String.
    }

    public static long stringToDate(EditText view, String oldValue,
            String value) {
        // Converts String to long.
    }
}

दो-तरफ़ा डेटा बाइंडिंग का इस्तेमाल करने वाले अनंत लूप

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

इस कारण, संभव अनंत लूप को उनकी तुलना करके @BindingAdapter का इस्तेमाल करके एनोटेट किए गए तरीकों में नई और पुरानी वैल्यू.

दो-तरफ़ा विशेषताएं

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