Sådan tilføjes View Binding til et Android Gradle-projekt

De fleste Android-udviklere kender nok klassikeren findViewById() metode. Giv det et ID for en af ​​visningerne i dit XML-layout, og det vil returnere en reference til den oppustede version af den visning. Det er alt sammen forudsat, at du har bestået det rigtige ID, og ​​at visningen faktisk eksisterer. findViewById() har ingen checks indbygget for at forhindre dig i at forsøge at hente en visning, du ikke kan hente. Gå ind i Vis Binding.

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

Det er super enkelt at tilføje View Binding til et Android Gradle-projekt.

Gradle opsætning

View Binding er aktiveret på modulniveau i Gradle. Hvis du har flere moduler, skal du aktivere det individuelt for hvert enkelt.

I android blok på dit modulniveau build.gradle, tilføj muligheden for at aktivere Vis Binding.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Der kan være en advarsel om ulovlig adgang, men det er en fnugfejl og kan sikkert ignoreres.

Synkroniser projektet, og View Binding vil blive aktiveret. Så nemt er det.

Brug af View Binding

Der er et par måder at bruge View Binding på, men før noget af det sker, lad os tale om, hvordan bindingsklasserne genereres.

Syntaks for klassenavn

Lad os sige, at du har et layout-XML navngivet some_layout.xml. Dens tilsvarende bindende klasse vil blive navngivet SomeLayoutBinding. Det mønster gælder for alle filer.

Hvert ord (adskilt af understregninger i filnavnet) vil blive skrevet med stort, og understregningerne vil blive fjernet. "Binding" bliver derefter tilføjet til slutningen.

Instantiering med eksisterende visning

Hvis du allerede har oppustet layoutfilen, og du har en reference til roden af ​​layoutet, kan du bede View-bindingsklassen bruge det eksisterende layout.

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 ville bruge bindingsklassen i et Fragment, ville det se sådan ud.

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å sørge for at puste layoutet op for dig.

Kotlin:

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

Java:

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

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

An eksempel Fragment ville ligne følgende.

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 ville ligne følgende.

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

Referencevisninger

Nu hvor View-bindingsklassen er sat op og klar til brug, er det tid til rent faktisk at bruge den.

Lad os sige indholdet af some_layout.xml er noget i stil med følgende:

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

Der er en masse ID'er der at referere til i kode. Men så længe du har den bindende klasse instansieret, vil det være nemt at referere.

I Kotlin refereres visninger af variabler, der matcher deres id'er, med nogle ændringer. Understregninger fjernes, og den resulterende streng er kamelbelagt. For eksempel til reference some_frame_layout fra kode, du ville bruge binding.someFrameLayout. Det someFrameLayout variabel vil være en forekomst af FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

I Java refereres visninger af getter-metoder, der matcher deres id'er, med et lignende format som Kotlin. For eksempel til reference some_frame_layout, du ville bruge binding.getSomeFrameLayout(). Metoden returnerer en forekomst af FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

View-referencerne er også fladtrykte i bindingen. Referencer inner_imageview er det samme som at referere some_frame_layout.

Konklusion

Som jeg er sikker på du kan se, er View Binding i Android både nem at implementere og nem at bruge. I mange tilfælde er det nemmere at bruge end findViewById().

For flere detaljer om implementering af View Binding, sammen med nogle eksempler, tjek Googles officielle dokumentation.