Hoe u View Binding kunt toevoegen aan een Android Gradle-project

De meeste Android-ontwikkelaars zijn waarschijnlijk bekend met de klassieker findViewById() methode. Geef het een ID door van een van de weergaven in uw XML-lay-out en het retourneert een verwijzing naar de opgeblazen versie van die weergave. Dat gaat er allemaal van uit dat je de juiste ID hebt doorgegeven en dat de weergave daadwerkelijk bestaat. findViewById() heeft geen ingebouwde controles om te voorkomen dat u probeert een weergave op te halen die u niet kunt ophalen. Ga naar Weergavebinding.

In plaats van gebruiken findViewById() voor elke gewenste weergave genereert View Binding automatisch een bindingsklasse voor elke lay-out-XML. Elke weergave met een ID wordt automatisch aan de klas toegevoegd, zodat u er rechtstreeks naar kunt verwijzen.

Het toevoegen van View Binding aan een Android Gradle-project is supereenvoudig.

Gradle-opstelling

View Binding is ingeschakeld op moduleniveau in Gradle. Als u meerdere modules heeft, moet u deze voor elke module afzonderlijk inschakelen.

In de android blok op uw moduleniveau build.gradle, voeg de optie toe om View Binding in te schakelen.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Er kan een waarschuwing zijn over illegale toegang, maar dat is een pluisjesbug en kan veilig worden genegeerd.

Synchroniseer het project en View Binding wordt ingeschakeld. Het is zo makkelijk.

Weergavebinding gebruiken

Er zijn een paar manieren om View Binding te gebruiken, maar voordat dat gebeurt, laten we het hebben over hoe de bindingsklassen worden gegenereerd.

Syntaxis van klassenaam

Stel dat u een lay-out-XML hebt met de naam some_layout.xml. De overeenkomstige bindingsklasse wordt genoemd SomeLayoutBinding. Dat patroon geldt voor alle bestanden.

Elk woord (gescheiden door onderstrepingstekens in de bestandsnaam) krijgt een hoofdletter en de onderstrepingstekens worden verwijderd. "Binding" wordt dan aan het einde toegevoegd.

Instantiëren met bestaande weergave

Als u het lay-outbestand al hebt opgeblazen en u een verwijzing naar de hoofdmap van de lay-out hebt, kunt u de bindingsklasse View vertellen om de bestaande lay-out te gebruiken.

Kotlin:

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

Java:

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

Als u bijvoorbeeld de bindingsklasse in een Fragment wilt gebruiken, zou het er ongeveer zo uitzien.

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

Instantiëren met nieuwe weergave

De bindingsklasse kan ook voor u zorgen voor het opblazen van de lay-out.

Kotlin:

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

Java:

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

Deze methode is nuttig in zowel fragmenten als activiteiten.

Een voorbeeld Fragment zou er ongeveer als volgt uit zien.

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

Een voorbeeld Activiteit zou er ongeveer als volgt uit zien.

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

Verwijzen naar weergaven

Nu de View-bindingsklasse is ingesteld en klaar voor gebruik, is het tijd om deze daadwerkelijk te gebruiken.

Laten we zeggen dat de inhoud van de some_layout.xml zijn zoiets als het volgende:

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

Er zijn veel ID's waarnaar in code kan worden verwezen. Maar zolang je de bindende klasse hebt geïnstantieerd, zal het verwijzen gemakkelijk zijn.

In Kotlin wordt naar weergaven verwezen door variabelen die overeenkomen met hun ID's, met enkele wijzigingen. Onderstrepingstekens worden verwijderd en de resulterende string is voorzien van een kameelomhulsel. Bijvoorbeeld om te verwijzen some_frame_layout van code die je zou gebruiken binding.someFrameLayout. De someFrameLayout variabele zal een exemplaar van FrameLayout zijn.

val someFrameLayout: FrameLayout = binding.someFrameLayout

In Java wordt naar views verwezen door gettermethoden die overeenkomen met hun ID's, met een vergelijkbaar formaat als Kotlin. Bijvoorbeeld om te verwijzen some_frame_layout, je zou gebruiken binding.getSomeFrameLayout(). De methode retourneert een exemplaar van FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

Ook de View-referenties zijn afgevlakt in de band. Verwijzingen inner_imageview is hetzelfde als verwijzen some_frame_layout.

Conclusie

Zoals u ongetwijfeld kunt zien, is View Binding in Android zowel eenvoudig te implementeren als gemakkelijk te gebruiken. In veel gevallen is het gemakkelijker te gebruiken dan findViewById().

Voor meer details over het implementeren van View Binding, samen met enkele voorbeelden, bekijk de officiële documentatie van Google.