इस पेज का अनुवाद Cloud Translation API से किया गया है.

लेआउट और बाइंडिंग एक्सप्रेशन

एक्सप्रेशन भाषा की मदद से ऐसे एक्सप्रेशन लिखे जा सकते हैं जो भेजे गए इवेंट को हैंडल करते हैं व्यू के हिसाब से. डेटा बाइंडिंग लाइब्रेरी, ज़रूरी क्लास अपने-आप जनरेट करती है व्यू को डेटा ऑब्जेक्ट से बाइंड करने के लिए.

डेटा बाइंडिंग लेआउट फ़ाइलें थोड़ी अलग हैं और इनके रूट टैग से शुरू होती हैं layout, इसके बाद data एलिमेंट, और view रूट एलिमेंट. यह व्यू एलिमेंट वह होता है जो आपका रूट किसी ऐसी लेआउट फ़ाइल में होता है जो बाइंड नहीं होती. यह कोड एक नमूना लेआउट फ़ाइल दिखाता है:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"/>
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.lastName}"/>
   </LinearLayout>
</layout>

data में मौजूद user वैरिएबल ऐसी प्रॉपर्टी के बारे में बताता है जिसका इस्तेमाल यह लेआउट:

<variable name="user" type="com.example.User" />

लेआउट के अंदर के एक्सप्रेशन एट्रिब्यूट प्रॉपर्टी में, इसका इस्तेमाल करके लिखे जाते हैं @{} सिंटैक्स. नीचे दिए गए उदाहरण में, TextView टेक्स्ट user वैरिएबल की firstName प्रॉपर्टी:

<TextView android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@{user.firstName}" />

डेटा ऑब्जेक्ट

मान लें कि आपके पास User इकाई की जानकारी देने के लिए एक प्लेन ऑब्जेक्ट है:

Kotlin

data class User(val firstName: String, val lastName: String)

Java


public class User {
  public final String firstName;
  public final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
}

इस तरह के ऑब्जेक्ट में ऐसा डेटा होता है जो कभी नहीं बदलता. ऐप्लिकेशन में आम तौर पर, ऐसा डेटा जिसे एक बार पढ़ा जाता है और उसके बाद कभी नहीं बदलता. इसका इस्तेमाल करके, एक ऐसा ऑब्जेक्ट जो कंवेंशन के सेट का पालन करता है, जैसे कि Java प्रोग्रामिंग भाषा, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

Kotlin

// Not applicable in Kotlin.
data class User(val firstName: String, val lastName: String)

Java

public class User {
  private final String firstName;
  private final String lastName;
  public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
  }
  public String getFirstName() {
      return this.firstName;
  }
  public String getLastName() {
      return this.lastName;
  }
}

डेटा बाइंडिंग के हिसाब से, ये दोनों क्लास एक जैसी हैं. कॉन्टेंट बनाने एक्सप्रेशन @{user.firstName} का इस्तेमाल android:text एट्रिब्यूट पुरानी क्लास में firstName फ़ील्ड को ऐक्सेस करता है और बाद वाली क्लास में getFirstName() तरीका इस्तेमाल किया जाएगा. इसका यह भी समाधान किया गया है कि firstName(), अगर वह तरीका मौजूद है.

बाइंडिंग डेटा

हर लेआउट फ़ाइल के लिए, एक बाइंडिंग क्लास जनरेट होती है. डिफ़ॉल्ट रूप से, क्लास, लेआउट फ़ाइल के नाम पर आधारित होती है, जो पास्कल केस में बदली जाती है. इसमें इसमें Binding सफ़िक्स जोड़ा गया है. उदाहरण के लिए, पिछला लेआउट फ़ाइल नाम है activity_main.xml, इसलिए संबंधित जनरेट की गई बाइंडिंग क्लास है ActivityMainBinding.

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

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)

    binding.user = User("Test", "User")
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
   User user = new User("Test", "User");
   binding.setUser(user);
}

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

Kotlin

val binding: ActivityMainBinding = ActivityMainBinding.inflate(getLayoutInflater())

Java

ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());

अगर किसी दस्तावेज़ में डेटा बाइंडिंग आइटम का इस्तेमाल किया जा रहा है, तो Fragment, ListView या RecyclerView अडैप्टर का इस्तेमाल करना चाहिए, तो बेहतर होगा कि inflate() बाइंडिंग क्लास के तरीके या DataBindingUtil क्लास के तौर पर नीचे दिए गए कोड के उदाहरण में दिखाया गया है:

Kotlin

val listItemBinding = ListItemBinding.inflate(layoutInflater, viewGroup, false)
// or
val listItemBinding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false)

Java

ListItemBinding binding = ListItemBinding.inflate(layoutInflater, viewGroup, false);
// or
ListItemBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.list_item, viewGroup, false);

एक्सप्रेशन लैंग्वेज

सामान्य सुविधाएं

एक्सप्रेशन की भाषा, मैनेज किए जा रहे कोड में मिले एक्सप्रेशन की तरह काफ़ी दिखती है. आपने लोगों तक पहुंचाया मुफ़्त में एक्सप्रेशन की भाषा में, इन ऑपरेटर और कीवर्ड का इस्तेमाल कर सकता है:

गणितीय: + - / * %
स्ट्रिंग जोड़ने की प्रोसेस: +
लॉजिकल: && ||
बाइनरी: & | ^
एकरी: + - ! ~
शिफ़्ट: >> >>> <<
तुलना: == > < >= <= (< को < से एस्केप किया जाना चाहिए)
instanceof
इसके हिसाब से ग्रुप किया गया है: ()
लिटरल वैल्यू, जैसे कि वर्ण, स्ट्रिंग, न्यूमेरिक, null
कास्ट करें
मेथड कॉल
फ़ील्ड का ऐक्सेस
कलेक्शन का ऐक्सेस: []
टर्नरी ऑपरेटर: ?:

यहां कुछ उदाहरण दिए गए हैं:

android:text="@{String.valueOf(index + 1)}"
android:visibility="@{age > 13 ? View.GONE : View.VISIBLE}"
android:transitionName='@{"image_" + id}'

कार्रवाइयां मौजूद नहीं हैं

इस्तेमाल किए जा सकने वाले एक्सप्रेशन सिंटैक्स में ये कार्रवाइयां मौजूद नहीं हैं प्रबंधित कोड में:

this
super
new
अश्लील सामान्य बातचीत

शून्य कोलेसिंग ऑपरेटर

शून्य कोलेसिंग ऑपरेटर (??) null नहीं होने पर बायां ऑपरेंड चुनता है या दाएं, अगर पूर्वज null है, तो:

android:text="@{user.displayName ?? user.lastName}"

यह फ़ंक्शन इनके बराबर है:

android:text="@{user.displayName != null ? user.displayName : user.lastName}"

प्रॉपर्टी रेफ़रंस

एक्सप्रेशन इन फ़ॉर्मैट का इस्तेमाल करके, क्लास में किसी प्रॉपर्टी का रेफ़रंस दे सकता है, जो फ़ील्ड, गैटर, और ObservableField ऑब्जेक्ट:

android:text="@{user.lastName}"

शून्य पॉइंटर के अपवादों से बचें

जनरेट किया गया डेटा बाइंडिंग कोड, null वैल्यू की अपने-आप जांच करता है और इससे बचा जाता है शून्य पॉइंटर के लिए अपवाद. उदाहरण के लिए, @{user.name} एक्सप्रेशन में, अगर user खाली है और user.name को null की डिफ़ॉल्ट वैल्यू असाइन की गई है. अगर आपको रेफ़रंस user.age, जहां उम्र की सीमा int है, तब डेटा बाइंडिंग, 0 की डिफ़ॉल्ट वैल्यू.

रेफ़रंस देखें

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

android:text="@{exampleText.text}"

नीचे दिए गए उदाहरण में, TextView व्यू में EditText व्यू का रेफ़रंस दिया गया है एक जैसा लेआउट:

<EditText
    android:id="@+id/example_text"
    android:layout_height="wrap_content"
    android:layout_width="match_parent"/>
<TextView
    android:id="@+id/example_output"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@{exampleText.text}"/>

कलेक्शन

आपके पास सामान्य कलेक्शन को ऐक्सेस करने का विकल्प होता है. जैसे- अरे, सूचियां, स्पार्स लिस्ट, और सुविधा के लिए, [] ऑपरेटर का इस्तेमाल करके मैप.

<data>
    <import type="android.util.SparseArray"/>
    <import type="java.util.Map"/>
    <import type="java.util.List"/>
    <variable name="list" type="List&lt;String>"/>
    <variable name="sparse" type="SparseArray&lt;String>"/>
    <variable name="map" type="Map&lt;String, String>"/>
    <variable name="index" type="int"/>
    <variable name="key" type="String"/>
</data>
...
android:text="@{list[index]}"
...
android:text="@{sparse[index]}"
...
android:text="@{map[key]}"

object.key नोटेशन का इस्तेमाल करके, मैप में कोई वैल्यू भी देखी जा सकती है. इसके लिए उदाहरण के लिए, पिछले उदाहरण में @{map[key]} को इससे बदला जा सकता है @{map.key}.

स्ट्रिंग की लिटरल वैल्यू

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

android:text='@{map["firstName"]}'

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

android:text="@{map[`firstName`]}"

संसाधन

एक्सप्रेशन, ऐप्लिकेशन के रिसॉर्स का रेफ़रंस इस सिंटैक्स से दे सकता है:

android:padding="@{large? @dimen/largePadding : @dimen/smallPadding}"

फ़ॉर्मैट स्ट्रिंग और बहुवचन का मूल्यांकन करने के लिए पैरामीटर दें:

android:text="@{@string/nameFormat(firstName, lastName)}"
android:text="@{@plurals/banana(bananaCount)}"

आप प्रॉपर्टी रेफ़रंस और व्यू पास कर सकते हैं रेफ़रंस:

android:text="@{@string/example_resource(user.lastName, exampleText.text)}"

जब बहुवचन में कई पैरामीटर लगते हैं, तो सभी पैरामीटर पास करें:


  Have an orange
  Have %d oranges

android:text="@{@plurals/orange(orangeCount, orangeCount)}"

कुछ संसाधनों के लिए, अलग-अलग तरह के आकलन की ज़रूरत होती है, जैसा कि यहां दिखाया गया है तालिका:

टाइप	सामान्य रेफ़रंस	एक्सप्रेशन का रेफ़रंस
`String[]`	`@array`	`@stringArray`
`int[]`	`@array`	`@intArray`
`TypedArray`	`@array`	`@typedArray`
`Animator`	`@animator`	`@animator`
`StateListAnimator`	`@animator`	`@stateListAnimator`
`color int`	`@color`	`@color`
`ColorStateList`	`@color`	`@colorStateList`

इवेंट मैनेज करना

डेटा बाइंडिंग की मदद से, ऐसे एक्सप्रेशन मैनेज किए जा सकते हैं जिन्हें भेजा गया हो से मिलती-जुलती हैं—उदाहरण के लिए, onClick() तरीका. इवेंट के एट्रिब्यूट के नाम, लिसनर तरीके के नाम से तय किए जाते हैं, अपवाद के साथ. उदाहरण के लिए, View.OnClickListener के पास तरीका onClick() है, इसलिए इस इवेंट का एट्रिब्यूट android:onClick है.

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

कक्षा	लिसनर सेटर	एट्रिब्यूट
`SearchView`	`setOnSearchClickListener(View.OnClickListener)`	`android:onSearchClick`
`ZoomControls`	`setOnZoomInClickListener(View.OnClickListener)`	`android:onZoomIn`
`ZoomControls`	`setOnZoomOutClickListener(View.OnClickListener)`	`android:onZoomOut`

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

मेथड रेफ़रंस: आपके एक्सप्रेशन में, ये काम किए जा सकते हैं रेफ़रंस के ऐसे तरीके जो लिसनर वाले तरीके के हस्ताक्षर के मुताबिक होते हैं. टास्क कब शुरू होगा एक्सप्रेशन से मेथड के रेफ़रंस का आकलन किया जाता है, तो डेटा बाइंडिंग, मेथड को रैप करता है लिसनर में, रेफ़रंस और मालिक ऑब्जेक्ट सेट करता है. साथ ही, उस लिसनर को टारगेट व्यू. अगर एक्सप्रेशन का आकलन null में होता है, तो डेटा बाइंडिंग काम नहीं करती लिसनर बनाएं और इसके बजाय, null लिसनर सेट करें.
लिसनर बाइंडिंग: ये लैम्डा एक्सप्रेशन हैं, जो उनका आकलन तब किया जाता है, जब इवेंट घटता है. डेटा बाइंडिंग हमेशा एक लिसनर, जिसे यह व्यू पर सेट करता है. इवेंट के भेजे जाने के बाद, लिसनर, लैम्डा एक्सप्रेशन का आकलन करता है.

तरीकों के बारे में जानकारी

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

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

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

Kotlin

class MyHandlers {
    fun onClickFriend(view: View) { ... }
}

Java

public class MyHandlers {
    public void onClickFriend(View view) { ... }
}

बाइंडिंग एक्सप्रेशन, क्लिक लिसनर को onClickFriend() तरीका:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
   <data>
       <variable name="handlers" type="com.example.MyHandlers"/>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <TextView android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@{user.firstName}"
           android:onClick="@{handlers::onClickFriend}"/>
   </LinearLayout>
</layout>

लिसनर बाइंडिंग

लिसनर बाइंडिंग, बाइंडिंग एक्सप्रेशन हैं. ये किसी इवेंट के होने पर चलते हैं. वे मेथड के रेफ़रंस की तरह ही होते हैं, लेकिन उनसे आपको आर्बिट्रेरी डेटा बाइंडिंग चलाने का विकल्प मिलता है व्यंजक. यह सुविधा Gradle के लिए 'Android Gradle प्लग इन' के साथ उपलब्ध है वर्शन 2.0 और उसके बाद के वर्शन.

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

Kotlin

class Presenter {
    fun onSaveClick(task: Task){}
}

Java

public class Presenter {
    public void onSaveClick(Task task){}
}

क्लिक इवेंट को onSaveClick() तरीके से इस तरह बाइंड किया जा सकता है:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable name="task" type="com.android.example.Task" />
        <variable name="presenter" type="com.android.example.Presenter" />
    </data>
    <LinearLayout android:layout_width="match_parent" android:layout_height="match_parent">
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:onClick="@{() -> presenter.onSaveClick(task)}" />
    </LinearLayout>
</layout>

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

पिछले उदाहरण में, onClick(View) को पास किया गया view पैरामीटर परिभाषित नहीं है. लिसनर बाइंडिंग, लिसनर पैरामीटर के लिए दो विकल्प देते हैं: आपके पास सभी पैरामीटर को अनदेखा करने या सभी पैरामीटर को नाम देने का विकल्प है. अगर आप चाहें पैरामीटर को नाम देने के लिए, तो आप उन्हें अपने एक्सप्रेशन में इस्तेमाल कर सकते हैं. उदाहरण के लिए, आपके पिछले एक्सप्रेशन को इस तरह लिख सकता है:

android:onClick="@{(view) -> presenter.onSaveClick(task)}"

अगर आपको एक्सप्रेशन में पैरामीटर का इस्तेमाल करना है, तो यह तरीका अपनाएं:

Kotlin

class Presenter {
    fun onSaveClick(view: View, task: Task){}
}

Java

public class Presenter {
    public void onSaveClick(View view, Task task){}
}

android:onClick="@{(theView) -> presenter.onSaveClick(theView, task)}"

साथ ही, एक से ज़्यादा पैरामीटर के साथ लैम्डा एक्सप्रेशन का इस्तेमाल किया जा सकता है:

Kotlin

class Presenter {
    fun onCompletedChanged(task: Task, completed: Boolean){}
}

Java

public class Presenter {
    public void onCompletedChanged(Task task, boolean completed){}
}

<CheckBox android:layout_width="wrap_content" android:layout_height="wrap_content"
      android:onCheckedChanged="@{(cb, isChecked) -> presenter.completeChanged(task, isChecked)}" />

आप जिस इवेंट को सुन रहे हैं, अगर वह void नहीं है, तो आपका एक्सप्रेशन से भी उसी तरह की वैल्यू मिलनी चाहिए. उदाहरण के लिए, अगर आपको हालाँकि, खास आपके लिए (लॉन्ग क्लिक) इवेंट होल्ड करने के लिए, आपके एक्सप्रेशन को बूलियन.

Kotlin

class Presenter {
    fun onLongClick(view: View, task: Task): Boolean { }
}

Java

public class Presenter {
    public boolean onLongClick(View view, Task task) { }
}

android:onLongClick="@{(theView) -> presenter.onLongClick(theView, task)}"

अगर null ऑब्जेक्ट की वजह से एक्सप्रेशन का आकलन नहीं किया जा सकता, तो डेटा बाइंडिंग दिखाता है उस टाइप के लिए डिफ़ॉल्ट वैल्यू, जैसे कि रेफ़रंस टाइप के लिए null, रेफ़रंस फ़ाइल के टाइप के लिए 0 int या boolean के लिए false.

अगर आपको किसी विधेय के साथ एक्सप्रेशन का इस्तेमाल करने की ज़रूरत है, तो उदाहरण के लिए, टर्नरी—void का इस्तेमाल सिंबल के तौर पर किया जा सकता है:

android:onClick="@{(v) -> v.isVisible() ? doSomething() : void}"

मुश्किल लिसनर से बचें

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

इंपोर्ट, वैरिएबल, और शामिल

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

इंपोर्ट

इंपोर्ट की मदद से, अपनी लेआउट फ़ाइल में क्लास का रेफ़रंस दिया जा सकता है, जैसा कि मैनेज किए जा रहे कोड में होता है. data एलिमेंट में, शून्य या उससे ज़्यादा import एलिमेंट का इस्तेमाल किया जा सकता है. कॉन्टेंट बनाने उदाहरण के तौर पर दिया गया यह कोड, View क्लास को लेआउट फ़ाइल में इंपोर्ट करता है:

<data>
    <import type="android.view.View"/>
</data>

View क्लास को इंपोर्ट करके, बाइंडिंग एक्सप्रेशन का इस्तेमाल करके इसका रेफ़रंस दिया जा सकता है. नीचे दिए गए उदाहरण में VISIBLE और View क्लास के GONE कॉन्सटेंट:

<TextView
   android:text="@{user.lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:visibility="@{user.isAdult ? View.VISIBLE : View.GONE}"/>

उपनामों का प्रकार

क्लास के नाम में गड़बड़ी होने पर, किसी एक क्लास का नाम बदलकर उपनाम. नीचे दिए गए उदाहरण में,View Vista के लिए com.example.real.estate पैकेज:

<import type="android.view.View"/>
<import type="com.example.real.estate.View"
        alias="Vista"/>

इसके बाद, com.example.real.estate.View और View को रेफ़रंस के लिए Vista का इस्तेमाल किया जा सकता है लेआउट फ़ाइल में android.view.View का रेफ़रंस दें.

अन्य क्लास इंपोर्ट करें

इंपोर्ट किए गए टाइप को वैरिएबल और एक्सप्रेशन में टाइप रेफ़रंस के तौर पर इस्तेमाल किया जा सकता है. कॉन्टेंट बनाने नीचे दिए गए उदाहरण में, वैरिएबल के टाइप के तौर पर इस्तेमाल किए गए User और List दिखाए गए हैं:

<data>
    <import type="com.example.User"/>
    <import type="java.util.List"/>
    <variable name="user" type="User"/>
    <variable name="userList" type="List&lt;User>"/>
</data>

किसी एक्सप्रेशन का कोई हिस्सा कास्ट करने के लिए, इंपोर्ट किए गए टाइप का इस्तेमाल किया जा सकता है. नीचे दिए गए उदाहरण के तौर पर, connection प्रॉपर्टी को User टाइप में कास्ट किया जाता है:

<TextView
   android:text="@{((User)(user.connection)).lastName}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

स्टैटिक फ़ील्ड और मेथड का रेफ़रंस देते समय, इंपोर्ट किए गए टाइप का इस्तेमाल भी किया जा सकता है व्यंजक. यह कोड, MyStringUtils क्लास और रेफ़रंस को इंपोर्ट करता है इसकी capitalize विधि:

<data>
    <import type="com.example.MyStringUtils"/>
    <variable name="user" type="com.example.User"/>
</data>
…
<TextView
   android:text="@{MyStringUtils.capitalize(user.lastName)}"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

मैनेज किए जा रहे कोड की तरह ही, java.lang.* अपने-आप इंपोर्ट हो जाता है.

वैरिएबल

data एलिमेंट में एक से ज़्यादा variable एलिमेंट का इस्तेमाल किया जा सकता है. हर variable एलिमेंट ऐसी प्रॉपर्टी के बारे में बताता है जिसे इस्तेमाल किए जाने वाले लेआउट पर सेट किया जा सकता है बाइंडिंग एक्सप्रेशन में. यहां दिए गए उदाहरण में बताया गया है user, image, और note वैरिएबल:

<data>
    <import type="android.graphics.drawable.Drawable"/>
    <variable name="user" type="com.example.User"/>
    <variable name="image" type="Drawable"/>
    <variable name="note" type="String"/>
</data>

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

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

जनरेट की गई बाइंडिंग क्लास में हर एक के लिए सेटर और गैटर होता है वैरिएबल. वैरिएबल सेटर तक डिफ़ॉल्ट प्रबंधित कोड मान लेते हैं इसे कॉल किया जाता है—पहचान फ़ाइलों के लिए null, int के लिए 0, और रेफ़रंस के लिए false boolean वगैरह

बाइंडिंग एक्सप्रेशन में इस्तेमाल करने के लिए, context नाम का एक खास वैरिएबल जनरेट किया गया है . context का मान यह है रूट व्यू से Context ऑब्जेक्ट getContext() तरीका. कॉन्टेंट बनाने context वैरिएबल को उसके साथ किसी साफ़ वैरिएबल एलान से बदल दिया गया है नाम.

इसमें शामिल है

वैरिएबल को शामिल किए गए लेआउट की बाइंडिंग में पास किया जा सकता है. लेआउट को बदलने के लिए, किसी एट्रिब्यूट में ऐप्लिकेशन नेमस्पेस और वैरिएबल के नाम का इस्तेमाल किया है. कॉन्टेंट बनाने नीचे दिए गए उदाहरण में दिखाया गया है कि name.xml और user वैरिएबल के वैरिएबल contact.xml लेआउट फ़ाइलें:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:bind="http://schemas.android.com/apk/res-auto">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <LinearLayout
       android:orientation="vertical"
       android:layout_width="match_parent"
       android:layout_height="match_parent">
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </LinearLayout>
</layout>

डेटा बाइंडिंग, मर्ज एलिमेंट के डायरेक्ट चाइल्ड के तौर पर काम नहीं करती है. उदाहरण के लिए, यह लेआउट काम नहीं करता:

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:bind="http://schemas.android.com/apk/res-auto">
   <data>
       <variable name="user" type="com.example.User"/>
   </data>
   <merge><!-- Doesn't work -->
       <include layout="@layout/name"
           bind:user="@{user}"/>
       <include layout="@layout/contact"
           bind:user="@{user}"/>
   </merge>
</layout>

अन्य संसाधन

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

लेआउट और बाइंडिंग एक्सप्रेशन

डेटा ऑब्जेक्ट

Kotlin

Java

Kotlin

Java

बाइंडिंग डेटा

Kotlin

Java

Kotlin

Java

Kotlin

Java

एक्सप्रेशन लैंग्वेज

सामान्य सुविधाएं

कार्रवाइयां मौजूद नहीं हैं

शून्य कोलेसिंग ऑपरेटर

प्रॉपर्टी रेफ़रंस

शून्य पॉइंटर के अपवादों से बचें

रेफ़रंस देखें

कलेक्शन

स्ट्रिंग की लिटरल वैल्यू

संसाधन

इवेंट मैनेज करना

तरीकों के बारे में जानकारी

Kotlin

Java

लिसनर बाइंडिंग

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

मुश्किल लिसनर से बचें

इंपोर्ट, वैरिएबल, और शामिल

इंपोर्ट

उपनामों का प्रकार

अन्य क्लास इंपोर्ट करें

वैरिएबल

इसमें शामिल है

अन्य संसाधन

सैंपल

कोड लैब

ब्लॉग पोस्ट