एंड्रॉइड ग्रैडल प्रोजेक्ट में व्यू बाइंडिंग कैसे जोड़ें

अधिकांश एंड्रॉइड डेवलपर संभवतः क्लासिक से परिचित हैं findViewById() तरीका। इसे अपने XML लेआउट में किसी एक दृश्य की आईडी दें और यह उस दृश्य के बढ़े हुए संस्करण का एक संदर्भ लौटाएगा। हालाँकि, यह माना जा रहा है कि आपने सही आईडी पार कर ली है और दृश्य वास्तव में मौजूद है। findViewById() आपको उस दृश्य को पुनः प्राप्त करने का प्रयास करने से रोकने के लिए कोई चेक नहीं बनाया गया है जिसे आप पुनः प्राप्त नहीं कर सकते। व्यू बाइंडिंग दर्ज करें।

के बजाय का उपयोग करने का findViewById() आपके इच्छित प्रत्येक दृश्य पर, व्यू बाइंडिंग स्वचालित रूप से प्रत्येक लेआउट XML के लिए एक बाइंडिंग क्लास उत्पन्न करता है। आईडी वाला प्रत्येक दृश्य स्वचालित रूप से कक्षा में जोड़ा जाता है, ताकि आप उन्हें सीधे संदर्भित कर सकें।

एंड्रॉइड ग्रैडल प्रोजेक्ट में व्यू बाइंडिंग जोड़ना बेहद सरल है।

ग्रैडल सेटअप

ग्रैडल में मॉड्यूल स्तर पर व्यू बाइंडिंग सक्षम है। यदि आपके पास एकाधिक मॉड्यूल हैं, तो आपको प्रत्येक के लिए इसे अलग-अलग सक्षम करना होगा।

में android अपने मॉड्यूल-स्तर पर ब्लॉक करें build.gradle, व्यू बाइंडिंग को सक्षम करने का विकल्प जोड़ें।

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

अवैध पहुंच के बारे में चेतावनी हो सकती है, लेकिन यह एक लिंट बग है और इसे सुरक्षित रूप से अनदेखा किया जा सकता है।

प्रोजेक्ट को सिंक करें और व्यू बाइंडिंग सक्षम हो जाएगी। इट्स दैट ईजी।

व्यू बाइंडिंग का उपयोग करना

व्यू बाइंडिंग का उपयोग करने के कुछ तरीके हैं, लेकिन ऐसा कुछ भी होने से पहले, आइए इस बारे में बात करें कि बाइंडिंग कक्षाएं कैसे उत्पन्न होती हैं।

कक्षा का नाम सिंटैक्स

मान लें कि आपके पास एक लेआउट XML नाम है some_layout.xml. इसके अनुरूप बाइंडिंग क्लास का नाम दिया जाएगा SomeLayoutBinding. यह पैटर्न सभी फ़ाइलों के लिए लागू है।

प्रत्येक शब्द (फ़ाइल नाम में अंडरस्कोर द्वारा अलग किया गया) को बड़े अक्षरों में लिखा जाएगा, और अंडरस्कोर हटा दिया जाएगा। "बाइंडिंग" फिर अंत में जुड़ जाता है।

मौजूदा दृश्य के साथ त्वरितकरण

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

Kotlin:

val binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */)

जावा:

SomeLayoutBinding binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */);

उदाहरण के लिए, यदि आप फ्रैगमेंट में बाइंडिंग क्लास का उपयोग करना चाहते हैं, तो यह कुछ इस तरह दिखेगा।

Kotlin:

classSomeFragment : Fragment(R.layout.some_layout) {
//Lazy initialization means bind() won't be called until "binding" is referenced.
private val binding by lazy { SomeLayoutBinding.bind(view) }
override fun onViewCreated(view: View, savedInstanceState: Bundle?){
super.onViewCreated(view, savedInstanceState)

//Once this method is called, you can start using the binding.
 }
}

जावा:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
publicSomeFragment(){
super(R.layout.some_layout);
 }
@Override
publicvoidonViewCreated(View view, Bundle savedInstanceState){
super.onViewCreated(view, savedInstanceState);

//Initialize the binding.
 binding = SomeLayoutBinding.bind(view);
 }
}

नए दृश्य के साथ त्वरितकरण

बाइंडिंग क्लास आपके लिए लेआउट को बढ़ाने का भी ख्याल रख सकता है।

Kotlin:

val binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */)

जावा:

SomeLayoutBinding binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */);

यह विधि फ़्रैगमेंट और एक्टिविटी दोनों में उपयोगी है।

एक उदाहरण टुकड़ा निम्नलिखित जैसा कुछ दिखाई देगा.

Kotlin:

classSomeFragment : Fragment() {
private val binding by lazy { SomeLayoutBinding.inflate(LayoutInflater.from(requireContext())) }
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?){
//The "root" of the binding class is the root of its layout.
return binding.root
 }
}

जावा:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
@Override
publicvoidonCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){
//Initialize the binding.
 binding = SomeLayoutBinding.inflate(inflater);
//The "getRoot()" method of the binding class returns the root of the layout.
return binding.getRoot();
 }
}

एक उदाहरण गतिविधि निम्नलिखित जैसा कुछ दिखाई देगा.

Kotlin:

classSomeActivity : AppCompatActivity() {
private val binding by lazy { SomeLayoutBinding.inflate(layoutInflater) }
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.root)
 }
}

जावा:

publicclassSomeActivityextendsAppCompatActivity{
private SomeLayoutBinding binding = null;
@Override
protectedvoidonCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
//Instantiate the binding.
 binding = SomeLayoutBinding.inflate(getLayoutInflater());
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.getRoot());
 }
}

संदर्भ दृश्य

अब जब व्यू बाइंडिंग क्लास स्थापित हो गई है और उपयोग के लिए तैयार है, तो वास्तव में इसका उपयोग करने का समय आ गया है।

मान लीजिए कि इसकी सामग्री है some_layout.xml कुछ इस प्रकार हैं:

 android:
 ...>
 android:
 ...
 />
 android:
 ...
 />
 android:
 ...>
 android:
 ...
 />
LinearLayout>
LinearLayout>

कोड में संदर्भ के लिए वहां बहुत सारी आईडी हैं। लेकिन जब तक आपके पास बाइंडिंग क्लास तत्काल चालू है, संदर्भ देना आसान होगा।

कोटलिन में, दृश्यों को कुछ बदलावों के साथ, उनकी आईडी से मेल खाने वाले वेरिएबल्स द्वारा संदर्भित किया जाता है। अंडरस्कोर हटा दिए जाते हैं और परिणामी स्ट्रिंग को कैमल-केस्ड कर दिया जाता है। उदाहरण के लिए, संदर्भ के लिए some_frame_layout कोड से, आप उपयोग करेंगे binding.someFrameLayout. someFrameLayout वेरिएबल फ़्रेमलेआउट का एक उदाहरण होगा।

val someFrameLayout: FrameLayout = binding.someFrameLayout

जावा में, व्यू को कोटलिन के समान प्रारूप के साथ, उनकी आईडी से मेल खाने वाले गेटर तरीकों द्वारा संदर्भित किया जाता है। उदाहरण के लिए, संदर्भ के लिए some_frame_layout, आप उपयोग करेंगे binding.getSomeFrameLayout(). विधि फ़्रेमलेआउट का एक उदाहरण लौटाएगी।

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

दृश्य संदर्भ भी बाइंडिंग में समतल हैं। संदर्भित inner_imageview संदर्भ के समान ही है some_frame_layout.

निष्कर्ष

जैसा कि मुझे यकीन है कि आप देख सकते हैं, एंड्रॉइड में व्यू बाइंडिंग को लागू करना और उपयोग करना दोनों आसान है। कई मामलों में, इसका उपयोग करना आसान है findViewById().

कुछ उदाहरणों के साथ व्यू बाइंडिंग को लागू करने के बारे में अधिक जानकारी के लिए, Google का आधिकारिक दस्तावेज़ देखें.