Animasjon i Android: hvordan det fungerer. Vi studerer nyttige egenskaper og lager animasjoner på Android

I denne artikkelen vil vi se på hvordan du animerer grensesnittelementer i Android. Under grensesnittelementene i i dette tilfellet dette betyr alle etterkommere av View-klassen (en fullstendig liste over etterkommere finnes i dokumentasjonen til View-klassen). Animasjon er en enkel måte å gjøre en applikasjon mer livlig på :)

1. La oss starte med å lage en testside. La oss lage en enkel applikasjon med en knapp og et bilde midt på skjermen. Jeg vil ikke gi koden, det er enkelt, om noe, se på kildene (de er på slutten av artikkelen).

2. I /res/anim-katalogen, lag en fil anim.xml og skriv der
< set xmlns:android=" http : // schemas.android.com /apk/res/android " android:shareInterpolator=" false " > < alpha android:fromAlpha=" 0.0 " android:toAlpha=" 1.0 " android:duration=" 1000 " />
Dette er animasjonsbeskrivelsen som vi vil bruke på bildet vårt. Vi vil se på hva som skjer her mer detaljert nedenfor, men foreløpig kopierer vi det bare til en fil.

3. For å laste en animasjon fra xml-fil brukt statisk metode klasse AnimationUtils
loadAnimation(kontekstkontekst, int id), Hvor kontekst er den aktuelle konteksten, og id- identifikator for ressursen med animasjon. Metoden returnerer en forekomst av Animation-klassen.
Animasjon - en abstrakt klasse for å representere animasjon i en applikasjon.
For å bruke den, sendes den resulterende forekomsten av Animation-klassen til metoden
startAnimation( Animasjon animasjon) klasse View (og alle dens etterkommere).

4. La oss skrive til AnimationTestActivity.java-filen:
offentlig klasse AnimationTestActivity utvider Activity ( ImageView-bilde; Knappeknapp; Animasjonsanimasjon; @Override protected void onCreate(Bundle savedInstanceState) ( super .onCreate(savedInstanceState); setContentView(R.layout.main); image = (ImageView)findViewById(R. id.image); button = (Button )findViewById(R.id.button); anim = AnimationUtils.loadAnimation(this, R.anim.anim); // 1 button.setOnClickListener(new OnClickListener() ( @Override public void onClick(View v) ( image.startAnimation(anim); //2 ) )); ) )
1) Les filen med identifikatoren R.anim.anim (som tilsvarer filen /res/anim/anim.xml) og få en forekomst av Animation-klassen.
2) Ved å klikke på knappen bruker vi animasjon på bildet.

5. Du kan kjøre applikasjonen vår. Når du trykker på knappen, vil bildet forsvinne og så sakte begynne å komme tilbake.

6. La oss nå se nærmere på hvordan animasjon lages i en xml-fil.
Det er 4 typer animasjon:

• alfa(gjennomsiktighet, synlighet)


• skala(skalering)


• rotere(sving)


• oversette(bevege seg)

For å lage animasjon må vi beskrive de innledende og endelige tilstandene til objektet, og systemet vil selv bestemme hvordan det skal flyttes fra en tilstand til en annen. I vårt eksempel
< alpha android:fromAlpha=" 0.0 " android:toAlpha=" 1.0 " android:duration=" 1000 " />
vi beskriver alfa-animasjonen, det vil si at vi endrer synligheten til objektet. Still inn starttilstanden fromAlpha="0.0"(helt usynlig) og begrenset toAlpha="1.0"(fullt synlig). Angi varigheten av animasjonen duration="1000"(i millisekunder). Og alt annet, det vil si hvordan man endrer synligheten til et objekt for å gjøre det fra usynlig til synlig på et sekund, gjør systemet seg selv. Dette beregnes vha interpolasjon- i beregningsmatematikk, en metode for å finne mellomverdier av en mengde fra et eksisterende diskret sett med verdier. For hver animasjon kan du stille inn en interpolator
-AccelerateDecelerateInterpolator(@android:anim/accelerate_decelerate_int erpolator) - endringshastigheten er lav i begynnelsen og slutten, og akselererer i midten

-Accelerate Interpolator(@android:anim/accelerate_interpolator) - endringshastigheten starter lavt og akselererer deretter

-Forutse Interpolator(@android:anim/anticipate_interpolator) - endringer starter i motsatt retning, og går deretter kraftig fremover

-AntipateOvershoot Interpolator(@android:anim/anticipate_overshoot_inte rpolator) - endringer starter i motsatt retning, gå raskt fremover og fly over den endelige verdien, og gå deretter tilbake til den endelige verdien

-BounceInterpolator(@android:anim/bounce_interpolator) - endringshastigheten øker på slutten

- Cycle Interpolator(@android:anim/cycle_interpolator) - gjenta animasjonen et spesifisert antall ganger. Endringshastigheten følger en sinusbølge

- Decelerate Interpolator(@android:anim/decelerate_interpolator) - endringshastigheten avtar på slutten

-Lineær interpolator(@android:anim/linear_interpolator) - endringshastigheten er konstant

-Overshoot Interpolator(@android:anim/overshoot_interpolator) - endringer hopper fremover og flyr over den endelige verdien, og går deretter tilbake til den endelige verdien

Interpolatoren er spesifisert ved å bruke android:interpolator-attributtet. For eksempel
android:interpolator="@android:anim/cycl e_interpolator". Standard er LinearInterpolator.

7. Beskrivelse av start- og slutttilstander
1) alfa (gjennomsiktighet, synlighet)
- android:fromAlpha- innledende transparensverdi. 0,0 - helt gjennomsiktig (usynlig), 1,0 - helt ugjennomsiktig (synlig)
- android:toAlpha- endelig transparensverdi

2) skala
- android:fromXScale- innledende skalaverdi langs X-aksen (hvor gjeldende størrelse tilsvarer verdien 1,0)
- android:toXScale- endelig skalaverdi langs X-aksen
- android:fromYScale- innledende skalaverdi langs Y-aksen (hvor gjeldende størrelse tilsvarer verdien 1,0)
- android:toYScale- endelig skalaverdi langs Y-aksen
- android:pivotX- x-koordinaten til punktet, som forblir uendret etter skalering
- android:pivotY- y-koordinaten til punktet, som forblir uendret etter skalering

Mulige verdier for pivotX og pivotY:
i piksler i forhold til venstre (eller øverste for Y-koordinat) kant av elementet (for eksempel "5")
som en prosentandel i forhold til venstre (øverste) kant (for eksempel "5%")
som en prosentandel i forhold til venstre (øverste) kant av det overordnede elementet (for eksempel "5%p")

For eksempel, hvis pivotX=0, pivotY=0 (som tilsvarer øverste venstre hjørne av elementet), vil skalering endre størrelsen på elementet ned og til høyre. Hvis pivotX=50%, pivotY=50%, så er punktet i midten av elementet og størrelsen endres i alle retninger, mens sentrum forblir på ett punkt.

3) rotere (snu)
- android:fromDegrees- Innledende verdi av rotasjonsvinkelen (i grader, negativ verdi mulig)
- android:toDegrees- endelig verdi av rotasjonsvinkelen
- android:pivotX- x-koordinater til rotasjonssenteret.
- android:pivotY- y-koordinaten til rotasjonssenteret.
Mulige verdier for pivotX og pivotY som i skalaanimasjonen

4) oversette (flytte)
- android:fromXDelta- x-koordinat til startpunktet for bevegelse. Mulige verdier:
i piksler i forhold til den opprinnelige posisjonen (for eksempel "5")
som en prosentandel i forhold til bredden på elementet (for eksempel "5 %)"
som en prosentandel i forhold til bredden på det overordnede elementet (for eksempel "5%p")
- android:toXDelta- x-koordinaten til endepunktet for bevegelsen
- android:fromYDelta- y-koordinaten til startpunktet for bevegelsen
- android:toYDelta- y-koordinaten til bevegelsens endepunkt

8. Ytterligere alternativer
Det er også attributter som er felles for alle fire animasjonstyper, hvorav de mest nyttige er:
- android:varighet- animasjonsvarighet (i millisekunder)
- android:interpolator- definerer interpolatoren for animasjon
- android:repeatCount- antall ekstra animasjonsrepetisjoner. Nøyaktig flere, det vil si at animasjonen vil bli utført en gang uansett. Standardverdien er "0" - dette betyr at animasjonen kun vil bli utført én gang. En verdi på "1" betyr at animasjonen vil kjøre to ganger (en gang den viktigste og en gang den sekundære). Verdien "-1" eller "uendelig" betyr endeløs repetisjon.
- android:repeatMode- bestemmer oppførselen til animasjonen når den har nådd slutten, og repeatCount-parameteren ikke er lik 0. Det er to verdier: "restart" - animasjonen starter på nytt og "reverse" - animasjonen vil gå i omvendt rekkefølge .
- android:startOffset- forsinkelse før animasjonen starter (i millisekunder)

9. Kombinere flere animasjoner
Du kan bruke flere typer animasjoner på et element samtidig. Hvis vi for eksempel skriver:
< set xmlns:android=" http : // schemas.android.com /apk/res/android " > < alpha android:fromAlpha=" 0.0 " android:toAlpha=" 1.0 " android:duration=" 1000 " /> < rotate android:fromDegrees=" 0 " android:toDegrees=" 360 " android:pivotX=" 50% " android:pivotY=" 50% " android:duration=" 1000 " />
Bildet vil endre gjennomsiktighet på 1 sekund (fra helt gjennomsiktig til ugjennomsiktig) og samtidig rotere 360 ​​grader.

Animasjoner kan settes til forskjellige varigheter, for eksempel, la oss sette varighet=5000 for animasjonen roter. Nå vil bildet rotere mye saktere, og gjennomsiktigheten vil fortsatt endre seg på et sekund.

Ved bruk av startOffset, kan du gjøre animasjonene sekvensielle. Legg til roter-attributtet startOffset="1000"(det vil si at vi vil gjøre en forsinkelse lik varigheten av den første animasjonen). Nå vil bildet først bli synlig om 1 sekund, og deretter bare rotere 360 ​​grader.

Flere animasjoner kan kombineres til sett ved hjelp av taggen. En slik tag vil alltid være i filen og er root-taggen. Du kan angi følgende attributter for et sett:
- varighet(varighet), Repetering(repetisjonsmodus) - disse attributtene vil bli brukt på hver animasjon i settet
- interpolator- definerer animasjonsinterpolatoren og delinterpolator- om denne interpolatoren vil bli brukt for hver animasjon i settet (mulige verdier er "true" og "false")
- startOffset(forsinkelse) - forsinkelse for hele settet med animasjoner.
Dessverre kan ikke attributtet brukes på settet repeatCount, det vil si at det ikke vil fungere å gjenta et sett med animasjoner flere ganger.
Sett kan være av hvilken som helst hekking.

10. Lage animasjon uten xml
Animasjon kan lages uten å bruke xml, direkte i programkoden. For dette brukes Animasjons etterkommerklasser:
1) AlphaAnimation for å lage alfaanimasjon. Klassekonstruktøren ser ut
AlphaAnimation (flyt fra Alpha, flyt til Alpha) hvor fromAlpha og toAlpha er henholdsvis de innledende og endelige transparensverdiene (fra 0,0 til 1,0)

11. La oss lage en animasjon i koden som, når du trykker på en knapp, vil rotere bildet med en tilfeldig vinkel (fra 0 til 360) og forstørre det til en tilfeldig størrelse (ikke mer enn to ganger). For dette formålet la jeg til en annen knapp randomButton
randomButton.setOnClickListener(new OnClickListener() ( @Override public void onClick(View v) ( Random random = new Random (); //1 RotateAnimation rotate = new RotateAnimation (0, (float )random.nextInt(360), Animation. RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f); //2 rotate.setDuration(1000); //3 rotate.setRepeatMode(Animation.REVERSE); //4 rotate.setRepeatCount(1); //5 lang varighet = rotate.computeDurationHint(); //6 float size = random.nextFloat() + 1.0; //7 ScaleAnimation scale = new ScaleAnimation(1.0f, size, 1.0f, size, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELFATIVE_TO , 0.5f); //8 scale.setDuration(1000); scale.setStartOffset(duration); //9 AnimationSet set = new AnimationSet (false); //10 set.addAnimation(rotate); //11 set.addAnimation (skala); image.startAnimation(sett); //12 ) ));
1) Lag et tilfeldig objekt for å generere tilfeldige tall. Du kan lese mer om Random i dokumentasjonen; nå er vi interessert i int nextInt(int n)-metodene - å generere et heltall i området fra 0 til n. Og float nextFloat()-metoden - genererer et reelt tall fra 0 til 1.
2) Lag en rotasjonsanimasjon. Startvinkel = 0, sluttvinkel = et tilfeldig tall fra 0 til 360. Animation.RELATIVE_TO_SELF betyr at vi vil spesifisere rotasjonssenterpunktet i prosent i forhold til bredden på elementet. Ikke glem at verdien 1,0 tilsvarer 100 %, noe som betyr at 0,5f er 50 %. Dette betyr at rotasjonssenteret vil være i midten av bildet.
3) Sett animasjonens varighet til 1000 millisekunder (dette er 1 sekund)
4) Vi definerer repetisjonsmodusen som Animation.REVERSE, det vil si at når vi gjentar animasjonen, vil vi gå i motsatt rekkefølge.
5) Sett antall ekstra repetisjoner = 1. Dette betyr at animasjonen vil bli gjentatt to ganger, en gang i foroverrekkefølge og en gang i revers.
6) Long computeDurationHint()-metoden beregner hvor lenge animasjonen vil vare totalt. Det er en getDuration()-metode, men den returnerer ganske enkelt varighetsverdien som vi satte med setDuration()-metoden. I vårt tilfelle setter vi varighetsverdien til 1000 og getDuration()-metoden vil returnere 1000 og vil ikke ta hensyn til at animasjonen vil gjentas to ganger, noe som betyr at den faktisk vil vare i 2000 millisekunder. ComputeDurationHint()-metoden vil beregne varigheten med hensyn til gjenforsøk og forsinkelser.
7) Beregn den nye størrelsen på bildet. Verdien 1,0 er gjeldende bildeskala, så verdien 2,0 betyr at bildet er doblet. Vi genererer et tall fra 0,0 til 1,0 og legger til 1, noe som betyr at vi får et tall fra 1,0 til 2,0
8) Lag en skaleringsanimasjon fra gjeldende bildestørrelse til et tilfeldig generert tall fra 1,0 til 2,0
9) Sett en forsinkelse lik den totale varigheten av rotasjonsanimasjonen. Slik at den andre animasjonen starter umiddelbart etter slutten av den første
10) Lag et sett med animasjoner.
11) Legg til to opprettede animasjoner til settet
12) Bruk et sett med animasjoner på bildet

12. En annen interessant metode for animasjonsklassen
setAnimationListener(Animation.AnimationListener lytter)- setter en lytter for endringer i animasjonstilstand. Animation.AnimationListener-grensesnittet definerer følgende metoder:
onAnimationStart (animasjonsanimasjon)- ringer når animasjonen starter
onAnimationRestart (animasjonsanimasjon)- kalles når animasjonen gjentas
onAnimationEnd(animasjonsanimasjon)- kalt på slutten av animasjonen

For eksempel:
anim = AnimationUtils.loadAnimation(this, R.anim.anim); anim.setAnimationListener(new AnimationListener () ( @Override public void onAnimationEnd(Animation animation) ( Log.d("MY" , "animation end" ); ) @Override public void onAnimationRepeat(Animation animation) ( Log.d("MY) " , "animasjonsgjentakelse" ); ) @Overstyr offentlig ugyldighet påAnimationStart(Animasjonsanimasjon) ( Log.d("MY" , "animasjonsstart" ); ) ));
Vi gjør ikke noe nyttig når vi endrer animasjonstilstanden, vi skriver det bare til loggen.

Det er alt. Jeg har fortalt deg det grunnleggende, det er bedre å lære resten gjennom eksperimenter :)

Kilder kan lastes ned her

Betegnelse på metallrør. La oss se på betegnelsene til de vanligste metallrørledningene i henhold til GOST. Stålvann- og gassrør i henhold til GOST Betegnelsen på røret indikerer nominell diameter, lengde (ved bruk av rør med målt lengde) og veggtykkelse. La oss vurdere et eksempel på betegnelsen av et rør med en nominell diameter på 32 mm, en veggtykkelse på 2,8 mm, uten sinkbelegg: Rør 32x2,8 GOST Tilstedeværelsen av et sinkbelegg er indikert med bokstaven C, som er plassert etter ordet "Rør".

Om nødvendig er et merke som indikerer tilstedeværelsen av gjenger angitt i rørbetegnelsen. Merking av stålrør i henhold til GOST utføres på fabrikken etter produksjon og inneholder informasjon om størrelsen, stålkvaliteten som røret er laget av, samt produsentens varemerke. Størrelsen på bokstavene og tallene til merkevaren er direkte proporsjonal med størrelsen på produktet og kan påføres ved hjelp av flere metoder.

De vanligste er merkevarebygging og vannfast maling. Kontrolltyper og deres betegnelse i produktmerking er omtalt i tabellen (tabell); Neste element"" angir veggtykkelse i millimeter; Den fjerde verdien indikerer lengden på produktet i millimeter fra kutt til kutt, i dette tilfellet er det "".

Hvordan tyde markeringene til stålrør: diameter, stålkvalitet og andre indikatorer i henhold til GOST. Symbolene trykt på stålrøret gir omfattende informasjon om produkter.

Merking er et slags pass for et produkt, hvorfra det blir klart hvem, hvor og til hvilke formål det ble produsert. Denne artikkelen vil fortelle deg hvordan du korrekt dechiffrerer alle merkesymbolene på rør.

Merk. Merkingen av stål (og støpejern) rør er regulert av GOST nr. av året. Dette dokumentet definerer alle nyansene ved å bruke forklarende inskripsjoner, deres størrelser, avstander mellom tall osv.

Kalddeformerte sømløse stålrør GOST (sortiment) Denne standarden gjelder kaldformede sømløse rør generelt formål laget av karbon og legert stål. Diameter: 5 - mm. I rørsymboler er indeksen A eller B plassert foran stålkvaliteten. Rør produseres enten varmebehandlet eller uten varmebehandling.

Endene på rørene må kuttes i rette vinkler. Metoder for merking av stålrør: GOST-standarder, eksempler på dekoding symboler. Ved å lese tallene på produktet, kan en spesialist bestemme størrelsen på røret, dets type, stålkvalitet, styrke, produsent og noen andre parametere for produktet.

Merking av stålrør Spesielt formål inneholder tilleggsmerker. Spesialprodukter inkluderer: Rør laget av legert stålkvalitet. 4. REFERANSER Regulative og tekniske dokumenter. Betegnelse NTD. som lenken er gitt til. W s g -80 GOST yu S1 Varenummer. Endring nr. 2 GOST - 91 Elektrosveisede rettsveisede stålrør.

Sortiment vedtatt av Interstate Council for Standardization, Metrology and Certification ved korrespondanse (protokoll nr. 45- datert) Registrert av Bureau of IGU Standards No. De nasjonale standardiseringsorganene i følgende stater stemte for vedtakelse av endringen: BY, KG , RU, TJ [alfakoder 2 i henhold til MK (ISO)].

Salg og kjøp. Stålrørbetegnelse. Elektrisk sveisede stålrør med rett søm. Sortiment. GOST IPK Forlag med standarder. Statlig standard for Union of the USSR. Direkte søm elektrisk sveisede stålrør. Med ornament. Elektrisk sveisede stål linje-sveise smøremidler. Område. GOST Introduksjonsdato 1. Denne standarden etablerer en rekke elektrisk-sveisede stålrør med rett søm.

2. Dimensjonene på rørene skal samsvare med tabellen. 1. 3. I henhold til lengden på røret er de laget: av umålt lengde Betegnelse på den vitenskapelige og tekniske dokumentasjonen som det refereres til. Artikkelnummer. GOST

Kategorier Postnavigering

Ha en fin dag alle sammen. Jeg vil dedikere dette innlegget til emnet fragmenter for Android. Det er allerede oversettelser og noen artikler om Habré som nevner hvordan man begynner å jobbe med fragmenter for Android. For eksempel artikkel. Den inneholder en beskrivelse av hva fragmenter er og i hvilken versjon av Android de er tilgjengelige, så de som ennå ikke har fått til den kan lese den om de ønsker det, men jeg skal ikke gjenfortelle dette i innlegget mitt. Så jeg kommer rett til poenget.

Begynnelsen av arbeidet

La meg bare si kort at fragmenter er brukergrensesnittkomponenter som kan brukes ved å bruke aktivitetsklassen til å vise brukerdata, men de Livssyklus er ikke avhengig av ham. Funksjonaliteten som tilbys av fragmenter har bredere funksjonalitet for å jobbe med dem enn Activity, så bruken av dem er av ikke liten betydning for utviklere hvis de ønsker at applikasjonen deres skal ha et brukergrensesnitt som er mer moderne etter dagens standarder.

La oss nå komme til poenget med innlegget. Google-utviklere Fragmenter ble etter min mening utstyrt med utmerket støtte for animasjon for å vise selve fragmentet. Dette vil bli diskutert videre. Jeg søkte på Habr etter innlegg om dette emnet, men jeg fant ikke noe, så nå skal jeg dele kunnskapen min.

Opprette et prosjekt

La oss lage et lite prosjekt. Jeg har laget et prosjekt for min Samsung Nexus S, jeg har Android versjon 4.1.2 der, som er det jeg faktisk brukte (Api Level 16). Jeg kalte selve prosjektet FragmentsAnimationTest.

Til demonstrasjonen trenger vi hovedaktiviteten og dens layout, et par fragmenter, hver med sin egen layout, og et par xml-filer til for selve animasjonen, som jeg skal snakke om senere.

Applikasjonen vil se slik ut: ett av fragmentene vil vises på skjermen, veksling mellom dem vil gjøres ved å bruke vanlig knapp, og følgelig vil bytte av fragmenter i seg selv bli ledsaget av animasjonseffekter.

La oss først ordne elementene i hovedaktiviteten i filen activity_main.xml:

Fra koden kan du se at hovedoppsettet brukes - RelativeLayout, som er ganske praktisk når du arbeider med fragmenter; to standard FrameLayout-elementer er plassert i den - faktisk vil det være en beholder for fragmenter og en knapp som skal brukes å bytte fragmenter seg imellom. For nå skal alt være ekstremt enkelt.

La oss deretter gå videre til fragmentene våre. La oss lage markup for dem og klassene selv:
fragment1.xml

Fragment2.xml

For begge fragmentene er koden nesten den samme, den eneste forskjellen er teksten som vil vises i selve fragmentet for å identifisere det og bakgrunnsfargen slik at animasjonen er godt synlig.

Fragment1.java
offentlig klasse Fragment1 utvider Fragment ( @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) ( return inflater.inflate(R.layout.fragment_1, null); ) )

Fragment2.java
offentlig klasse Fragment2 utvider Fragment( @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) ( return inflater.inflate(R.layout.fragment_2, null); ) )

I timene skal også alt være klart hvis du er kjent med temaet for fragmentene. De indikerer ganske enkelt hvilken eksakt utelatelse som skal brukes når du viser et spesifikt fragment, og det er alt.

La oss nå komme til den deilige delen. La oss jobbe med hovedaktivitetsklassen, her er koden:
offentlig klasse MainActivity utvider Activity ( privat Fragment fragment2; privat Fragment fragment1; private FragmentTransaction ft; @Override protected void onCreate(Bundle savedInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); fragment1( new) ; fragment2 = new Fragment2(); ft = getFragmentManager().beginTransaction(); ft.setCustomAnimations(R.animator.slide_in_left, R.animator.slide_in_right); // ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN(); ft. R.id.fragCont, fragment1); ft.addToBackStack(null); ft.commit(); Button btn = (Button) findViewById(R.id.btn); btn.setOnClickListener(new OnClickListener() ( @Override public void onClick(View v) ( ft = getFragmentManager().beginTransaction(); ft.setCustomAnimations(R.animator.slide_in_left, R.animator.slide_in_right); // ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN); if(iblefragment1.isVisible ))( ft.replace(R.id.fragCont, fragment2); )else( ft.replace(R.id.fragCont, fragment1); ) ft.commit(); ) )); ) )

La oss se på hva som skjer i vår aktivitet. Først opprettes begge fragmentene, som, som allerede nevnt, vekselvis vil endre hverandre. Deretter indikerer vi med linjen ft = getFragmentManager().beginTransaction() at vi får en FragmentTransaction, som vi kan samhandle med fragmentene våre, men dette er alt i artikkelen som jeg nevnte tidligere. Før jeg går videre til analysen av følgende kode, vil jeg gjøre en liten digresjon.

Det er to alternativer for å lage animasjoner for å vise fragmenter:

• Den første metoden er å koble til standard animasjon ved å bruke setTransition(int transit)-metoden. FragmentTransaction-klassen har flere forhåndsdefinerte animasjoner.
• Den andre metoden er akkurat det som interesserer oss i dette emnet, implementeringen av tilpasset animasjon. Ferdig med setCustomAnimations()-metoden

La oss nå gå tilbake til å analysere koden vår. La oss se på neste linje ft.setCustomAnimations(R.animator.slide_in_left, R.animator.slide_in_right), her er animasjonen koblet til alle fragmenter som skal jobbes med til transaksjonen er fullført, opp til ft.commit() linje. Hva er det egentlig som skjer? setCustomAnimations sendes to parametere. Den første parameteren beskriver animasjonen for å vise fragmentet som vises, og den andre parameteren beskriver animasjonen for fragmentet som endres, dvs. fjernes fra enhetsskjermen. Det er viktig å nevne det denne metoden må kalles før fragmentene vises, ellers vil ikke animasjonen bli brukt.

Et par aksjekommentarer er slik at du kan prøve å leke med den forhåndsbeskrevne animasjonen, bare avkommenter dem og kommenter den forrige linjen - ft.setCustomAnimations(R.animator.slide_in_left, R.animator.slide_in_right), i begge tilfeller, selv om dette er ikke nødvendig.

La oss analysere aktivitetskoden til slutten og gå videre til å lage selve animasjonen.

Etter innstilling av animasjonen, vises fragmentet, legges til stabelen, og transaksjonen er fullført for å vise alle endringer. Deretter initialiserer vi knappen vår og fester en knapp-klikk-hendelseslytter til den, inni denne er det kode for å endre fragmenter. Når knappen trykkes, starter vi en transaksjon, kobler til animasjon og endrer fragmentet til det motsatte vist i for tiden. Koden er enkel, så den krever ingen dyp forklaring.

Lage animasjon

La oss gå videre til hoveddelen av emnet vårt. La oss lære hvordan du lager selve animasjonen. Måten vi lager animasjoner på her er litt annerledes enn hvordan vi er vant til å gjøre det i tidligere versjoner av Android. Gjennomføringen går som følger. Først må du opprette en animatormappe i mappen for applikasjonsressurser, den vil se slik ut - res/animator/. Her må vi legge inn xml-filer som skal beskrive nøyaktig hvordan animasjonen skal spilles av. La oss sette dem der:
slide_in_left.xml

Og slide_in_right.xml

La oss nå se på dem i detalj. Selve elementene i de visuelle effektene er beskrevet i objectAnimator-taggen; hver slik tag beskriver beskrivelsen av en ny animasjonseffekt. La oss nå se på selve attributtene. Det første attributtet i slide_in_left.xml-filen er interpolator, den har flere verdier, du kan lære mer om dem i Property Animation-dokumentasjonen. Interpolatoren er ansvarlig for gjengivelsen på en bestemt måte for en viss tid vårt fragment. Deretter har vi egenskapsnavn-attributtet, det indikerer hvilken egenskap til fragmentet vi vil endre under animasjonen; i vårt eksempel kommer y først, og valueType indikerer hvilken type parameter vi endrer. I boken Pro Android 4 denne situasjonen argumenteres av det faktum at hvis du ser på setX()-metoden i View-klassen, blir det klart at den tar en flyttypeverdi, det samme gjelder med setY()-metoden, derav floatType-verdien.

Deretter kommer de ikke uviktige attributtene valueFrom og valueTo, de indikerer fra hvilken verdi verdien skal endres i egenskapsnavn, i vårt første tilfelle er det y. Hvis verdiFrom-parameteren ikke er spesifisert, blir verdien tatt lik den gjeldende. I vårt tilfelle er valueFrom lik -1280, dette betyr at bevegelsen av fragmentet langs y-aksen vil starte fra verdien -1280, denne verdien ble valgt på grunn av det faktum at den er plassert utenfor enhetens skjerm og bevegelsen vil skje til y-verdien blir lik 0 for øvre venstre hjørne av fragmentet vårt i 1500 millisekunder. Og til slutt spesifiserer duration-attributtet nøyaktig hvor lenge den animerte effekten vår vil vare i millisekunder.

Og den siste nyansen som jeg vil beskrive. Når du ser på en av animasjonsbeskrivelsesfilene, kan du se sett-taggen, som inneholder alle animasjonseffektene; den tjener til å kombinere effekter eller skille dem. Slide_in_right.xml-filen bruker ordensattributtet i set-taggen, i vårt tilfelle har den verdien sammen, som betyr å spille av effektene samtidig, i motsetning til den er det verdien sekvensielt, som krever at effektene vises sekvensielt i animasjon, noe som er veldig praktisk i noen tilfeller.

Det er alt. Filen slide_in_right.xml gir et eksempel på hvordan du kan bruke andre egenskaper for animasjon, for eksempel alfakanalen. Håp denne artikkelen nyttig for de som bryr seg om hvordan applikasjonen deres vil se ut.

Som du selv forstår, kjære Habrausere, vil ikke skjermbilder kunne vise resultatet av arbeidet.

Litteraturen og kildene som ble brukt ved skriving av innlegget ble nevnt under selve artikkelen.

Android utvikling

Fra og med Android 4.4 har utviklere lagt til ekstra verktøyå lage animasjoner - Transitions Framework. Det var opprinnelig ment å lage animasjoner for å endre tilstanden til en applikasjon ved å manipulere flere visninger. Med utgivelsen av Android 5.0 ble settet med animasjoner tilgjengelig for bruk utvidet til å samsvare med Material Design-konseptet som ble introdusert på samme tid.

Transitions Framework lar deg lage raskt og smertefritt ulike animasjoner. Derfor, i prosessen med å jobbe med iFunny, var det umulig å ignorere dette verktøysettet. Leserne inviteres til spesielt tilfelle ved å bruke Transitions API - lage animasjon av overgangen mellom aktivitet med en "sømløs" effekt.

Fra et visuelt synspunkt kan overgangsanimasjonene mellom aktiviteter presentert i Transitions Framework deles inn i to typer: vanlige animasjoner og animasjoner med et felles element. Konseptet med animasjon med et felles element er demonstrert i en figur som er ærlig stjålet fra developer.android.com. 1. De vanlige elementene på den er avataren og kontaktens navn.

Ris. 1. Animasjon av overgang mellom Aktivitet med felles elementer

Men ingen liker lange introduksjoner, så la oss gå rett til historien om hvordan animasjonene ble laget av denne typen i iFunny-appen. Som et første eksempel, se på animasjonen vist i fig. 2. For å bruke det trenger vi Android-versjoner 5.0 og høyere.

Ris. 2. Animasjon av overgangen mellom Aktivitet på brukerautentiseringsskjermen

Fra brukerens synspunkt er det ikke noe uvanlig her: én skjerm, enkel animasjon. Men, som du kanskje har gjettet, "under panseret" er overgangen mellom to skjermer med ett felles element.

Det første trinnet for å lage en slik overgang er, merkelig nok, å velge nettopp dette elementet og bestemme plasseringen i oppsettet til begge aktivitetene. Etter dette må du legge til attributtet android:transitionName til beskrivelsen av hver visning som viser det valgte elementet, og også tildele dem en android:id hvis det mangler.

I vårt tilfelle er dette vanlige ImageViews i følgende form:

Det er to ting som er verdt å merke seg her viktige poeng. For det første må begge ImageViews settes til samme overgangsnavn, noe som er logisk. For det andre, siden vi bruker ImageView, må innholdet deres være det samme, siden bruk av to forskjellige ressurser kan føre til uventede konsekvenser (i det minste til blinking av den animerte visningen i begynnelsen og slutten av animasjonen).

I det andre trinnet må du legge til alternativer for den lanserte (andre) aktiviteten, noe som indikerer at en animasjon skal startes når den starter.

Merk. Med «andre» mener vi den lanserte aktiviteten, overgangen til denne må utføres, og med «først» mener vi den lanserte aktiviteten.

Dette gjøres som følger:

Bunt bunt = null; if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) ( View v = activity.findViewById(R.id.auth_logo); if (v != null) ( ActivityOptions options = ActivityOptions.makeSceneTransitionAnimation(activity) , v, activity.getString(R.string.email_auth_transition)); bundle = options.toBundle(); ) ) Intent intent = new Intent(activity, SecondActivity.class); if (bunt == null) ( activity.startActivity(intent); ) else ( activity.startActivity(intent, bundle); )
I følgende liste:

• R.id.auth_logo - ImageView fra den første aktiviteten, brukt i animasjon;
• aktivitet - første aktivitet;
• R.string.email_auth_transition - en etikett som tidligere var igjen i oppsettet til begge ImageViews;
• SecondActivity.class - andre aktivitet.

Og nå kan den oppmerksomme leseren bli forvirret: i introduksjonen snakket vi om å bruke API-nivå 19, i eksemplet var det API-nivå 21, og i listen ovenfor er det en begrensning på API-nivå 22. Dessverre, når du skriver koden, viste seg at overgangsanimasjoner med et felles element kan oppføre seg feil på telefoner med API-nivå 21. Dette viser seg i form av animasjonsbremsinger generelt og artefakter på den animerte View spesielt. Hvis du allerede er kjent med emnet, vet årsakene til denne oppførselen og/eller måter å løse problemet beskrevet på, fortell oss om det i kommentarene.

På det tredje trinnet er det nødvendig å beskrive overgangsanimasjonen, dvs. angi banen som krysses av den animerte visningen og transformasjonen av selve visningen. For dette vil vi skape egen fil projectName/src/main/res/transitions/email_auth_transition.xml med følgende innhold:

Litt teori. TransitionSet-taggen er ment å beskrive flere transformasjoner brukt på den animerte visningen samtidig. Parameteren transitionOrdering styrer rekkefølgen disse transformasjonene brukes i. I vårt tilfelle brukes de samtidig. Det finnes flere typer forhåndsbygde transformasjoner i Transitions Framework. MED full liste finner du på denne siden. Vi vil fokusere på to spesifikke: changeBounds og changeImageTransform.

Den første er for å transformere størrelsen på visningen. Den andre fungerer bare med ImageView og, sammen med den første, lar deg endre ikke bare størrelsen, men også formen på ImageView. Ved å bruke transformasjonsdataene får vi utdataanimasjonen for å endre bildestørrelsen, vist i fig. 2. Hvis du ikke spesifiserer bevegelsestypen til den animerte visningen, vil den bevege seg langs den korteste veien. La oss se på en mer interessant metode for transport i det andre eksemplet.

Det siste trinnet i å lage en animasjon er å erklære den i temaene for begge aktivitetene. For å gjøre dette, rediger beskrivelsen av temaene som følger (eller opprett nye i mappen projectName/src/main/res/values-v22/theme.xml):

Her:

• android:windowActivityTransitions muliggjør overgangsanimasjoner;
• android:windowSharedElementEnterTransition peker på en fil som beskriver animasjonen av overgangen fra den første aktiviteten til den andre;
• android:windowSharedElementExitTransition peker på en fil som beskriver overgangsanimasjonen når du går tilbake fra den andre aktiviteten til den første.

Det skal bemerkes at for OS-versjoner under 5.1 er det nødvendig å lage temaer med identiske stiler for å unngå de ganske forventede konsekvensene av at applikasjonen krasjer. La oss for eksempel legge dem i filen projectName/src/main/res/values/theme.xml: