Slik legger du til View Binding til et Android Gradle-prosjekt

De fleste Android-utviklere er nok kjent med klassikeren findViewById() metode. Gi den en ID for en av visningene i XML-layouten din, og den vil returnere en referanse til den oppblåste versjonen av den visningen. Det er alt forutsatt at du har bestått riktig ID, og ​​at visningen faktisk eksisterer. findViewById() har ingen sjekker innebygd for å hindre deg i å prøve å hente en visning du ikke kan hente. Gå inn i Vis Binding.

I stedet for å bruke findViewById() på hver View du ønsker, genererer View Binding automatisk en bindingsklasse for hver layout-XML. Hver visning med en ID legges automatisk til klassen, slik at du kan referere dem direkte.

Å legge til View Binding til et Android Gradle-prosjekt er superenkelt.

Gradle oppsett

View Binding er aktivert på modulnivå i Gradle. Hvis du har flere moduler, må du aktivere det individuelt for hver enkelt.

I android blokk på modulnivået ditt build.gradle, legg til alternativet for å aktivere Vis binding.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Det kan være en advarsel om ulovlig tilgang, men det er en lo-feil og kan trygt ignoreres.

Synkroniser prosjektet og View Binding vil bli aktivert. Så enkelt er det.

Bruke View Binding

Det er noen få måter å bruke View Binding på, men før noe av det skjer, la oss snakke om hvordan bindingsklassene genereres.

Syntaks for klassenavn

La oss si at du har en layout-XML som heter some_layout.xml. Dens tilsvarende bindingsklasse vil bli navngitt SomeLayoutBinding. Det mønsteret gjelder for alle filer.

Hvert ord (atskilt med understrek i filnavnet) vil bli skrevet med stor bokstav, og understrekingen vil bli fjernet. "Binding" blir deretter lagt til på slutten.

Instantiering med eksisterende visning

Hvis du allerede har blåst opp layoutfilen og du har en referanse til roten av oppsettet, kan du gi Vis-bindingsklassen beskjed om å bruke det eksisterende oppsettet.

Kotlin:

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

Java:

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

Hvis du for eksempel ønsker å bruke bindingsklassen i et fragment, vil det se omtrent slik ut.

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

Instantiering med New View

Bindingsklassen kan også ta seg av å blåse opp oppsettet for deg.

Kotlin:

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

Java:

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

Denne metoden er nyttig i både fragmenter og aktiviteter.

An eksempel Fragment vil se omtrent slik ut.

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

An eksempel aktivitet vil se omtrent slik ut.

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

Refererer til visninger

Nå som View-bindingsklassen er satt opp og klar til bruk, er det på tide å faktisk bruke den.

La oss si innholdet i some_layout.xml er noe sånt som følgende:

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

Det er mange IDer der å referere til i kode. Men så lenge du har den bindende klassen instansiert, vil det være enkelt å referere.

I Kotlin refereres visninger av variabler som samsvarer med ID-ene deres, med noen endringer. Understreking fjernes og den resulterende strengen er kamelhylstret. For eksempel for å referere some_frame_layout fra kode, du ville brukt binding.someFrameLayout. De someFrameLayout variabel vil være en forekomst av FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

I Java refereres visninger av getter-metoder som samsvarer med ID-ene deres, med et lignende format som Kotlin. For eksempel for å referere some_frame_layout, du ville brukt binding.getSomeFrameLayout(). Metoden vil returnere en forekomst av FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

Vis-referansene er også flatet ut i bindingen. Refererer inner_imageview er det samme som å referere some_frame_layout.

Konklusjon

Som jeg er sikker på at du kan se, er View Binding i Android både enkel å implementere og enkel å bruke. I mange tilfeller er det enklere å bruke enn findViewById().

For mer informasjon om implementering av View Binding, sammen med noen eksempler, sjekk ut Googles offisielle dokumentasjon.