Cum să adăugați View Binding la un proiect Android Gradle

Majoritatea dezvoltatorilor de Android sunt probabil familiarizați cu clasicul findViewById() metodă. Transmiteți-i un ID al uneia dintre vizualizările din aspectul dvs. XML și va returna o referință la versiunea umflată a acelei vizualizări. Totuși, presupunând că ați trecut ID-ul corect și că vizualizarea există de fapt. findViewById() nu are încorporate verificări pentru a vă împiedica să încercați să preluați o vizualizare pe care nu o puteți prelua. Introduceți View Binding.

În loc de a folosi findViewById() pe fiecare vizualizare dorită, View Binding generează automat o clasă de legare pentru fiecare format XML. Fiecare vizualizare cu un ID este adăugată automat la clasă, astfel încât să le puteți referi direct.

Adăugarea View Binding la un proiect Android Gradle este foarte simplă.

Configurare Gradle

Legarea vizualizării este activată la nivel de modul în Gradle. Dacă aveți mai multe module, va trebui să le activați individual pentru fiecare.

În android blocați la nivelul dvs. de modul build.gradle, adăugați opțiunea pentru a activa Legarea vizualizării.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Poate exista un avertisment despre accesul ilegal, dar acesta este o eroare de scame și poate fi ignorat în siguranță.

Sincronizați proiectul și View Binding va fi activată. Este atât de ușor.

Folosind View Binding

Există câteva modalități de a utiliza View Binding, dar înainte de a se întâmpla ceva, haideți să vorbim despre modul în care sunt generate clasele de legare.

Sintaxa numelui clasei

Să presupunem că aveți un format XML numit some_layout.xml. Clasa de legare corespunzătoare va fi numită SomeLayoutBinding. Acest model este valabil pentru toate fișierele.

Fiecare cuvânt (separat prin liniuțe de subliniere în numele fișierului) va fi scris cu majuscule, iar liniuțele de subliniere vor fi eliminate. „Legarea” este apoi adăugată la sfârșit.

Instanțierea cu vizualizarea existentă

Dacă ați umflat deja fișierul de aspect și aveți o referință la rădăcina aspectului, puteți spune clasei de legare View să folosească aspectul existent.

Kotlin:

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

Java:

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

De exemplu, dacă doriți să utilizați clasa de legare într-un Fragment, ar arăta cam așa.

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.
 }
}

Java:

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);
 }
}

Instanciarea cu New View

Clasa de legare se poate ocupa și de umflarea aspectului pentru tine.

Kotlin:

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

Java:

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

Această metodă este utilă atât în ​​fragmente, cât și în activități.

Un Exemplu Fragment ar arăta ceva ca următorul.

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
 }
}

Java:

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();
 }
}

Un Exemplu Activitate ar arăta ceva ca următorul.

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)
 }
}

Java:

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());
 }
}

Vederi de referință

Acum că clasa de legare View este configurată și gata de utilizare, este timpul să o folosiți efectiv.

Să spunem conținutul some_layout.xml sunt ceva de genul următor:

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

Există o mulțime de ID-uri acolo pentru a face referire în cod. Dar atâta timp cât aveți clasa de legare instanțiată, referirea va fi ușoară.

În Kotlin, vizualizările sunt referite prin variabile care se potrivesc cu ID-urile lor, cu unele modificări. Linerele de subliniere sunt eliminate și șirul rezultat este acoperit cu cămilă. De exemplu, pentru a face referire some_frame_layout din cod, ai folosi binding.someFrameLayout. The someFrameLayout variabila va fi o instanță a FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

În Java, vizualizările sunt referite prin metode getter care se potrivesc cu ID-urile lor, cu un format similar cu Kotlin. De exemplu, pentru a face referire some_frame_layout, ai folosi binding.getSomeFrameLayout(). Metoda va returna o instanță a FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

Referințele View sunt, de asemenea, aplatizate în legare. Referire inner_imageview este la fel cu referirea some_frame_layout.

Concluzie

După cum sunt sigur că puteți vedea, View Binding în Android este atât ușor de implementat, cât și ușor de utilizat. În multe cazuri, este mai ușor de utilizat decât findViewById().

Pentru mai multe detalii despre implementarea View Binding, împreună cu câteva exemple, consultați documentația oficială Google.