व्यू बाइंडिंग   Android Jetpack का हिस्सा.

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

ज़्यादातर मामलों में, व्यू बाइंडिंग findViewById की जगह ले लेती है.

सेटअप

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

Groovy

android {
    ...
    buildFeatures {
        viewBinding true
    }
}

Kotlin

android {
    ...
    buildFeatures {
        viewBinding = true
    }
}

अगर आपको बाइंडिंग क्लास जनरेट करते समय किसी लेआउट फ़ाइल को अनदेखा करना है, तो उस लेआउट फ़ाइल के रूट व्यू में tools:viewBindingIgnore="true" एट्रिब्यूट जोड़ें:

<LinearLayout
        ...
        tools:viewBindingIgnore="true" >
    ...
</LinearLayout>

इस्तेमाल

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

उदाहरण के लिए, result_profile.xml नाम की लेआउट फ़ाइल देखें, जिसमें यह शामिल है:

<LinearLayout ... >
    <TextView android:id="@+id/name" />
    <ImageView android:cropToPadding="true" />
    <Button android:id="@+id/button"
        android:background="@drawable/rounded_button" />
</LinearLayout>

जनरेट की गई बाइंडिंग क्लास को ResultProfileBinding कहा जाता है. इस क्लास में दो फ़ील्ड हैं: TextView, जिसका नाम name है और Button, जिसका नाम button है. लेआउट में मौजूद ImageView का कोई आईडी नहीं है. इसलिए, बाइंडिंग क्लास में इसका कोई रेफ़रंस नहीं है.

हर बाइंडिंग क्लास में एक getRoot() तरीका भी शामिल होता है. इससे, उससे जुड़ी लेआउट फ़ाइल के रूट व्यू का डायरेक्ट रेफ़रंस मिलता है. इस उदाहरण में, ResultProfileBinding क्लास में मौजूद getRoot() तरीका, LinearLayout रूट व्यू दिखाता है.

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

गतिविधियों में व्यू बाइंडिंग का इस्तेमाल करना

किसी गतिविधि के साथ इस्तेमाल करने के लिए, बाइंडिंग क्लास का इंस्टेंस सेट अप करें. इसके लिए, गतिविधि के onCreate() तरीके में यह तरीका अपनाएं:

  1. जनरेट की गई बाइंडिंग क्लास में शामिल स्टैटिक inflate() मेथड को कॉल करें. इससे गतिविधि के लिए, बाइंडिंग क्लास का एक इंस्टेंस बनता है.
  2. getRoot() तरीके को कॉल करके या Kotlin प्रॉपर्टी सिंटैक्स का इस्तेमाल करके, रूट व्यू का रेफ़रंस पाएं.
  3. रूट व्यू को setContentView() पर पास करें, ताकि इसे स्क्रीन पर ऐक्टिव व्यू बनाया जा सके.

इन चरणों को यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

private lateinit var binding: ResultProfileBinding

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ResultProfileBinding.inflate(layoutInflater)
    val view = binding.root
    setContentView(view)
}

Java

private ResultProfileBinding binding;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    binding = ResultProfileBinding.inflate(getLayoutInflater());
    View view = binding.getRoot();
    setContentView(view);
}

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

Kotlin

binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }

Java

binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
    viewModel.userClicked()
});

फ़्रैगमेंट में व्यू बाइंडिंग का इस्तेमाल करना

फ़्रैगमेंट के साथ इस्तेमाल करने के लिए, बाइंडिंग क्लास का इंस्टेंस सेट अप करें. इसके लिए, फ़्रैगमेंट के onCreateView() तरीके में जाकर, यह तरीका अपनाएं:

  1. जनरेट की गई बाइंडिंग क्लास में शामिल स्टैटिक inflate() मेथड को कॉल करें. इससे फ़्रैगमेंट के लिए, बाइंडिंग क्लास का एक इंस्टेंस बनता है.
  2. getRoot() तरीके को कॉल करके या Kotlin प्रॉपर्टी सिंटैक्स का इस्तेमाल करके, रूट व्यू का रेफ़रंस पाएं.
  3. onCreateView() तरीके से रूट व्यू को वापस लाएं, ताकि उसे स्क्रीन पर ऐक्टिव व्यू बनाया जा सके.

Kotlin

private var _binding: ResultProfileBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!

override fun onCreateView(
    inflater: LayoutInflater,
    container: ViewGroup?,
    savedInstanceState: Bundle?
): View? {
    _binding = ResultProfileBinding.inflate(inflater, container, false)
    val view = binding.root
    return view
}

override fun onDestroyView() {
    super.onDestroyView()
    _binding = null
}

Java

private ResultProfileBinding binding;

@Override
public View onCreateView (LayoutInflater inflater,
                          ViewGroup container,
                          Bundle savedInstanceState) {
    binding = ResultProfileBinding.inflate(inflater, container, false);
    View view = binding.getRoot();
    return view;
}

@Override
public void onDestroyView() {
    super.onDestroyView();
    binding = null;
}

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

Kotlin

binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }

Java

binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
    viewModel.userClicked()
});

अलग-अलग कॉन्फ़िगरेशन के लिए हिंट देना

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

# in res/layout/example.xml

<TextView android:id="@+id/user_bio" />

# in res/layout-land/example.xml

<EditText android:id="@+id/user_bio" />

इस मामले में, हो सकता है कि जनरेट की गई क्लास, TextView टाइप का फ़ील्ड userBio दिखाए. ऐसा इसलिए, क्योंकि TextView एक सामान्य बेस क्लास है. तकनीकी सीमाओं की वजह से, व्यू बाइंडिंग कोड जनरेटर इसका पता नहीं लगा सकता. इसलिए, वह इसके बजाय View फ़ील्ड जनरेट करता है. इसके लिए, फ़ील्ड को बाद में binding.userBio as TextView के साथ कास्ट करना होगा.

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

# in res/layout/example.xml (unchanged)

<TextView android:id="@+id/user_bio" />

# in res/layout-land/example.xml

<EditText android:id="@+id/user_bio" tools:viewBindingType="TextView" />

एक और उदाहरण के तौर पर, मान लें कि आपके पास दो लेआउट हैं. इनमें से एक में BottomNavigationView और दूसरे में NavigationRailView है. दोनों क्लास, NavigationBarView को एक्सटेंड करती हैं. इसमें लागू करने से जुड़ी ज़्यादातर जानकारी होती है. अगर आपके कोड को यह जानने की ज़रूरत नहीं है कि मौजूदा लेआउट में कौनसा सबक्लास मौजूद है, तो दोनों लेआउट में जनरेट किए गए टाइप को NavigationBarView पर सेट करने के लिए, tools:viewBindingType का इस्तेमाल किया जा सकता है:

# in res/layout/navigation_example.xml

<BottomNavigationView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />

# in res/layout-w720/navigation_example.xml

<NavigationRailView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />

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

  • वैल्यू, android.view.View से इनहेरिट की गई क्लास होनी चाहिए.
  • वैल्यू, उस टैग की सुपर क्लास होनी चाहिए जिस पर उसे रखा गया है. उदाहरण के लिए, ये वैल्यू काम नहीं करतीं:

      <TextView tools:viewBindingType="ImageView" /> <!-- ImageView is not related to TextView. -->
      <TextView tools:viewBindingType="Button" /> <!-- Button is not a superclass of TextView. -->
    
  • फ़ाइनल टाइप, सभी कॉन्फ़िगरेशन में एक जैसा होना चाहिए.

findViewById से अंतर

findViewById का इस्तेमाल करने के मुकाबले, व्यू बाइंडिंग के कई अहम फ़ायदे हैं:

  • Null safety: व्यू बाइंडिंग, व्यू के डायरेक्ट रेफ़रंस बनाती है. इसलिए, अमान्य व्यू आईडी की वजह से null pointer exception का जोखिम नहीं होता. इसके अलावा, जब कोई व्यू किसी लेआउट के सिर्फ़ कुछ कॉन्फ़िगरेशन में मौजूद होता है, तो बाइंडिंग क्लास में उसके रेफ़रंस वाले फ़ील्ड को @Nullable से मार्क किया जाता है.
  • टाइप सेफ़्टी: हर बाइंडिंग क्लास में मौजूद फ़ील्ड के टाइप, एक्सएमएल फ़ाइल में रेफ़र किए गए व्यू से मैच करते हैं. इसका मतलब है कि क्लास कास्ट एक्सेप्शन का कोई जोखिम नहीं है.

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

डेटा बाइंडिंग के साथ तुलना

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

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

दूसरी ओर, डेटा बाइंडिंग की तुलना में व्यू बाइंडिंग की ये सीमाएं हैं:

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

अन्य संसाधन

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

ब्लॉग

वीडियो