Inhoud

• Hoe je eerste Android-fragment te bouwen
• Lay-outs, weergaven en code toevoegen
• De code
• Gebruik fragmenten met veelvouden instanties
• Afsluitende opmerkingen
• Android ontwikkeling:

Opmerking: in dit artikel wordt ervan uitgegaan dat u bekend bent met de basisprincipes van Android-ontwikkeling en Java. U zou al in staat moeten zijn om basislay-outs te maken en weergaven te gebruiken, bij klikken en findViewByID. Als je die concepten begrijpt, ben je klaar om fragmenten te leren gebruiken!

Fragmenten zijn een krachtige functie van een goede Android UI waarmee u app-ontwerp op een modulaire manier kunt benaderen. Dit zijn verschillende weergaven die volledige lay-outs kunnen bevatten en die worden geleverd met hun eigen bijbehorende Java-code. Door uw gebruikersinterface op deze manier op te splitsen, kunt u meer logische lay-outs maken die gemakkelijker te begrijpen zijn voor uw gebruikers. U kunt ze aanvullende informatie en bedieningselementen geven zonder dat ze de activiteit hoeven te verlaten.

Zie ook: Probleemloze fragmenten: De navigatie-architectuurcomponent van Android gebruiken

Fragmenten geven u aanzienlijk meer opties in uw app-ontwerp en kunnen de gebruikerservaring aanzienlijk verbeteren

Wat meer is, is dat fragmenten werken als klassen en objecten waarin je er meerdere kunt hebben instanties van hetzelfde fragment. Dat betekent dat u dezelfde lay-out steeds opnieuw kunt gebruiken zonder code te herschrijven, of zelfs twee verschillende versies naast elkaar te tonen.

Kortom, terwijl dit nog is een andere iets om te leren als het gaat om de schijnbaar eindeloze takenlijst van Android-apps, het is iets dat je aanzienlijk meer opties in je app-ontwerp kan geven en de gebruikerservaring aanzienlijk kan verbeteren - waardoor het meer dan de moeite waard is om de tijd te leren kennen .

Hoe je eerste Android-fragment te bouwen

Dus, wat zouden we kunnen doen met fragmenten die op geen enkele andere manier logisch zouden zijn?

Misschien hebben we een lijst met bestanden - misschien is dit een fotogalerij - en willen we een beschrijving tonen en de gebruiker de optie geven om te verwijderen of te delen. Dat soort dingen. We kunnen ze elke keer naar een nieuwe 'Beschrijving'-pagina sturen door een afzonderlijke activiteit te gebruiken, maar als je fragmenten gebruikt, kunnen we ze op één pagina bewaren die minder schokkend is.

Open Android Studio en maak een lijst met willekeurige afbeeldingen in activity_main.xml. Ik gebruik foto's van Dragon Ball Super omdat ik een nerd ben en dat is wat ik op mijn pc heb liggen ...

Nu gaan we ons eerste fragment maken.

Om dit te doen, ga je naar Bestand> Nieuw> Fragment. MainActivity.java moet aan de linkerkant worden geselecteerd wanneer u dit doet, en u kiest nu een ‘leeg’ fragment. U kunt vervolgens een naam kiezen voor u, de nieuwe creatie, die we ‘Beschrijving’ zullen noemen. Verwijder het vinkje uit de twee vakken eronder - dat hebben we nu niet nodig.

Zodra dit is gebeurd, zul je merken dat je nu niet alleen een nieuw java-bestand met de naam Description.java hebt, maar ook een nieuw lay-outbestand met de naam fragment_description.xml - net alsof je een nieuwe klasse hebt gemaakt! Dit betekent dat u de code die bij uw nieuwe fragment hoort, in een afzonderlijk Java-bestand plaatst.

Lay-outs, weergaven en code toevoegen

Het goede nieuws is dat het heel gemakkelijk is om weergaven en een lay-out toe te voegen wanneer we fragmenten gebruiken. We doen dit op dezelfde manier als we normaal zouden doen door fragment_timer.xml te bewerken.

Laten we weer een lineaire lay-out gebruiken en deze keer enkele besturingselementen en beschrijvende tekst toevoegen. Je kunt hier voorlopig alles plaatsen.

Dus nu is de volgende vraag: hoe zorg je ervoor dat dit daadwerkelijk in je app verschijnt?

U kunt dit doen door het fragment aan de activiteit toe te voegen, net zoals bij elke andere weergave. Ga dus naar activity_main.xml en voeg de weergave toe zodat deze een deel van het scherm in beslag neemt - misschien onderaan.

Als je het wilt doen zoals ik deed, gebruikte ik een verticale lineaire lay-out en gaf alle afbeeldingen een gewicht van 1 en het fragment een gewicht van 2.

U zult merken dat in het voorbeeld niet het werkelijke fragment wordt weergegeven, maar alleen een tijdelijke aanduiding. Merk ook op dat ik de naam van het fragment in de XML moest opnemen, zodat Android weet waar het te vinden is. Je hebt ook een ID nodig voor elk fragment.

De code

Zoals besproken, gaat de code die we nodig hebben om fragmenten te gebruiken in zijn eigen Java-bestand. In dit geval is dat het bestand Description.java.

Als u deze pagina bekijkt, ziet u dat er een constructor is (net als in elke klasse die een object maakt) en een methode met de naam onCreateView. Die methode is waar de xml wordt gebruikt om die weergave op te blazen en het is ook het equivalent van uw gebruikelijke onCreate methode in een standaardactiviteit.

Voor het grootste deel kun je dingen doen zoals je normaal hier zou doen. findViewByID werkt en u kunt dit gebruiken om tekst enz. te wijzigen, maar u moet de referentie iets anders krijgen. Wijzig de regel die luidt:

terugblazen. opblazen (R.layout.fragment_description, container, false);

Naar:

Bekijk v = inflater.inflate (R.layout.fragment_description, container, false);

En gebruik dan:

v.findViewByID.

Nu hebt u toegang tot uw weergaven zoals u normaal zou doen:

public View onCreateView (LayoutInflater inflater, ViewGroup container, Bundle saveInstanceState) {View v = inflater.inflate (R.layout.fragment_description, container, false); Knop okButton = v.findViewById (R.id.OK) ;; Knop shareButton = v.findViewById (R.id.Delen); okButton.setOnClickListener (nieuwe View.OnClickListener () {public void onClick (View v) {Toast.makeText(getActivity (), "OK!", Toast.LENGTH_LONG ).tonen(); }}); shareButton.setOnClickListener (nieuwe View.OnClickListener () {public void onClick (View v) {Toast.makeText(getActivity (), "Sharing ...", Toast.LENGTH_LONG ).tonen(); }}); terugkeer v; }}

Gebruik fragmenten met veelvouden instanties

U kunt zien dat het veel eenvoudiger is om een ​​gestroomlijnde gebruikersinterface en code te maken wanneer we fragmenten gebruiken. In plaats van lay-outs-binnen-lay-outs te gebruiken en vervolgens met veel klikken te jongleren, allemaal binnen een enkel Java-bestand. Wat meer is, is dat u met deze ‘modulaire’ benadering deze weergave kunt gebruiken voor alle activiteiten en zelfs in menu's en andere dynamische locaties.

Maar het echt coole deel is het feit dat je meerdere exemplaren van ditzelfde fragment allemaal tegelijkertijd kunt hebben.

Om dit te doen is eenvoudig: u voegt gewoon meer dan één weergave toe en blaast op met exact dezelfde code.

Hopelijk kun je nu beginnen te zien wat de kracht is van het gebruik van fragmenten: stel je voor dat je een Recycler View (een schuiflijst) met afbeeldingen hebt, elk met de details en bedieningselementen eronder. Het is niet nodig om elke keer een hele nieuwe lay-out te maken en u kunt de weergaven verbergen totdat de gebruiker op de foto heeft geklikt!

Wat meer is, is dat u ook programmatisch nieuwe fragmenten kunt genereren. Het enige dat u nodig hebt, is dat het fragment in uw lay-out past - zoals een frame-lay-out (die ik zal noemen) fragmentTarget) en dan kunt u het volgende doen:

Fragment toegevoegdFragment = nieuw Description (); FragmentTransaction transaction = getSupportFragmentManager (). BeginTransaction (); transaction.replace (R.id.fragmentTarget, toegevoegdFragment); transaction.addToBackStack (null); transaction.commit ();

Zorg ervoor dat u de benodigde klassen importeert. U wordt gevraagd wanneer u fragmenten in uw code probeert te gebruiken. Zorg er alleen voor dat u de bovenste optie kiest die 'v4' zegt.

Het is belangrijk om fragmenten programmatisch toe te voegen, omdat dit betekent dat we een dynamische lijst met afbeeldingen (die we hebben gedownload, die zich in een specifieke map enz. Bevinden) kunnen genereren en de details onmiddellijk voor ons laten verschijnen.

In dit nieuwe voorbeeld is het tweede fragment dus programmatisch toegevoegd.

Ten slotte kan het zijn dat je het uiterlijk van je fragmenten wilt veranderen, afhankelijk van waar ze zich bevinden. Het goede nieuws is dat u dit gemakkelijk kunt doen door een ID als een bundel door te geven wanneer u het fragment maakt en vervolgens die waarde aan het andere uiteinde te extraheren.

Gebruik in MainActivity.java:

Bundelbundel = nieuwe bundel (); bundle.putInt ("ID", 1); addedFragment.setArguments (bundel);

En voeg vervolgens in de Description.java toe:

int eyeD = 0; Bundle bundle = this.getArguments (); if (bundle! = null) {eyeD = bundle.getInt ("ID", 0); } schakelaar (eyeD) {case 1:…

U kunt dan bijvoorbeeld uw app ertoe brengen om verschillende notities voor elke afbeelding te tonen.

Afsluitende opmerkingen

Dus dat is hoe je fragmenten gebruikt. Hopelijk begrijp je de basis en deze post heeft je voldoende begrip gegeven dat je kunt doorgaan en de rest kunt uitzoeken. Wat nog belangrijker is, ik hoop dat het u enkele mogelijke toepassingen van fragmenten heeft laten zien en het potentieel dat ze bieden voor slimmer app-ontwerp.

Als je een ander voorbeeld van fragmenten in actie wilt zien, bekijk dan zeker mijn recente bericht over het maken van een aangepast opstartprogramma!

Android ontwikkeling:

• Hoe maak je een VR-app voor Android in slechts 7 minuten
• Bouw je eigen Action for Google Assistant
• Root Android: Alles wat u moet weten!
• Anatomie van een app: een inleiding tot de levenscyclus van activiteiten
• Android Jetpack: wat betekenen de recente aankondigingen voor de ondersteuningsbibliotheek van Android?