Sdílet prostřednictvím

Grafika a animace Androidu

  • Článek

Android poskytuje velmi bohatou a různorodou architekturu pro podporu 2D grafiky a animací. Toto téma představuje tyto architektury a popisuje, jak vytvořit vlastní grafiku a animace pro použití v aplikaci Xamarin.Android.

Přehled

I když běží na zařízeních, která mají tradičně omezený výkon, mají nejvyšší hodnocené mobilní aplikace často sofistikované uživatelské prostředí (UX), doplněné o vysoce kvalitní grafiku a animace, které poskytují intuitivní, responzivní a dynamické chování. S tím, jak mobilní aplikace získávají více a sofistikovanějších aplikací, uživatelé začali od aplikací očekávat více a více.

Moderní mobilní platformy mají pro nás naštěstí velmi výkonné architektury pro vytváření sofistikovaných animací a vlastních grafických prvků při zachování snadného použití. Díky tomu můžou vývojáři přidávat bohatou interaktivitu s velmi malým úsilím.

Rozhraní API uživatelského rozhraní v Androidu je možné zhruba rozdělit do dvou kategorií: Grafika a animace.

Grafika se dále dělí na různé přístupy pro 2D a 3D grafiku. 3D grafika je dostupná prostřednictvím řady integrovaných architektur, jako je OpenGL ES (mobilní verze OpenGL) a rozhraní třetích stran, jako je MonoGame (multiplatformní sada nástrojů kompatibilní se sadou nástrojů XNA). I když 3D grafika není v rámci tohoto článku, prozkoumáme integrované 2D techniky kreslení.

Android poskytuje dvě různé rozhraní API pro vytváření 2D grafiky. Jedním z nich je deklarativní přístup vysoké úrovně a druhý programový rozhraní API nízké úrovně:

  • Nakreslené prostředky – slouží k vytváření vlastních grafik buď prostřednictvím kódu programu, nebo (obvykle) vložením pokynů výkresu do souborů XML. Kreslicí prostředky jsou obvykle definovány jako soubory XML, které obsahují pokyny nebo akce pro Android k vykreslení 2D grafiky.

  • Plátno – toto je rozhraní API nízké úrovně, které zahrnuje kreslení přímo na podkladovém rastrovém obrázku. Poskytuje velmi jemně odstupňovanou kontrolu nad tím, co se zobrazí.

Kromě těchto 2D grafických technik nabízí Android také několik různých způsobů vytváření animací:

  • Nakreslitelné animace – Android také podporuje animace snímků po rámečku označované jako Kreslitelná animace. Toto je nejjednodušší animační rozhraní API. Android postupně načítá a zobrazuje kreslené prostředky v sekvenci (podobně jako kreslená kresba).

  • Zobrazit animace – Zobrazení animací jsou původní animační rozhraní API v Androidu a jsou k dispozici ve všech verzích Androidu. Toto rozhraní API je omezené tím, že bude fungovat pouze s objekty View a může v těchto zobrazeních provádět pouze jednoduché transformace. Animace zobrazení jsou obvykle definovány v souborech XML nalezených /Resources/anim ve složce.

  • Animace vlastností – Android 3.0 zavedl novou sadu animačních rozhraní API označovaných jako animace vlastností. Toto nové rozhraní API zavedlo rozšiřitelný a flexibilní systém, který lze použít k animaci vlastností libovolného objektu, nejen k zobrazení objektů. Tato flexibilita umožňuje zapouzdření animací v různých třídách, které usnadňují sdílení kódu.

Zobrazení animací jsou vhodnější pro aplikace, které musí podporovat starší rozhraní API před Androidem 3.0 (úroveň rozhraní API 11). Jinak by aplikace měly používat novější rozhraní API pro animaci vlastností z důvodů uvedených výše.

Všechny tyto architektury jsou proveditelné možnosti, ale pokud je to možné, přednost by měly být předány animacím vlastností, protože je flexibilnější rozhraní API pro práci s. Animace vlastností umožňují zapouzdření logiky animace v různých třídách, které usnadňují sdílení kódu a zjednodušují údržbu kódu.

Usnadnění

Grafika a animace pomáhají, aby aplikace pro Android byly atraktivní a zábavné pro použití; je však důležité si uvědomit, že některé interakce probíhají prostřednictvím čtečky obrazovky, alternativních vstupních zařízení nebo s asistovaným přiblížením. K některým interakcím může také dojít bez zvukových funkcí.

Aplikace jsou v těchto situacích lépe použitelné, pokud byly navrženy s ohledem na přístupnost: poskytují nápovědu a navigaci v uživatelském rozhraní a zajišťují, aby byl textový obsah nebo popisy pro obrázky prvků uživatelského rozhraní.

Další informace o využití rozhraní API pro usnadnění přístupu pro Android najdete v Průvodci přístupností od Googlu.

2D grafika

Nakreslitelné prostředky jsou oblíbenou technikou v aplikacích pro Android. Stejně jako u jiných prostředků jsou kreslitelné prostředky deklarativní – definují se v souborech XML. Tento přístup umožňuje čisté oddělení kódu od prostředků. To může zjednodušit vývoj a údržbu, protože není nutné měnit kód pro aktualizaci nebo změnu grafiky v aplikaci pro Android. I když jsou kreslitelné prostředky užitečné pro mnoho jednoduchých a běžných grafických požadavků, chybí jim výkon a řízení rozhraní API plátna.

Další technika použití objektu Plátno je velmi podobná jiným tradičním rozhraním API, jako je System.Drawing nebo základní výkres iOS. Použití objektu Canvas poskytuje největší kontrolu nad vytvářením 2D grafiky. Je vhodné v situacích, kdy nakreslený zdroj nebude fungovat nebo bude obtížné s ním pracovat. Může být například nutné nakreslit vlastní ovládací prvek posuvníku, jehož vzhled se změní na základě výpočtů souvisejících s hodnotou posuvníku.

Pojďme se nejprve podívat na nakreslitelné zdroje. Jsou jednodušší a pokrývají nejběžnější vlastní případy kreslení.

Nakreslitelné zdroje

Kreslení zdroje jsou definovány v souboru XML v adresáři /Resources/drawable. Na rozdíl od vkládání png nebo JPEG není nutné poskytovat verze zdrojů s hustotou specifické pro hustotu. Za běhu načte aplikace pro Android tyto prostředky a pomocí pokynů obsažených v těchto souborech XML vytvoří 2D grafiku. Android definuje několik různých typů nakreslených zdrojů:

  • ShapeDrawable – Jedná se o nakreslený objekt, který nakreslí primitivní geometrický obrazec a na tento obrazec použije omezenou sadu grafických efektů. Jsou velmi užitečné pro věci, jako je přizpůsobení tlačítek nebo nastavení pozadí TextViews. Ukážeme si příklad použití ShapeDrawable později v tomto článku.

  • StateListDrawable – Jedná se o nakreslený prostředek, který změní vzhled na základě stavu widgetu nebo ovládacího prvku. Tlačítko může například změnit vzhled v závislosti na tom, jestli je stisknuto nebo ne.

  • LayerDrawable – Tento nakreslený prostředek, který bude naskládat několik dalších kreslitelných objektů jeden nad druhým. Příklad vrstvyDrawable je znázorněn na následujícím snímku obrazovky:

    Příklad LayerDrawable

  • TransitionDrawable – Jedná se o vrstvuDrawable, ale s jedním rozdílem. TransitionDrawable dokáže animovat jednu vrstvu, která se zobrazuje nad jinou vrstvou.

  • LevelListDrawable – To je velmi podobné StateListDrawable v tom, že zobrazí obrázek na základě určitých podmínek. Na rozdíl od StateListDrawable však LevelListDrawable zobrazí obrázek založený na celočíselné hodnotě. Příkladem LevelListDrawable by bylo zobrazení síly signálu WiFi. S tím, jak se mění síla signálu Wi-Fi, se odpovídajícím způsobem změní nakreslený zobrazený signál.

  • ScaleDrawable ClipDrawable/ – jak jejich název napovídá, tyto kreslené možnosti poskytují funkce škálování i výřezu. ScaleDrawable bude škálovat další Drawable , zatímco ClipDrawable vystřiží další Drawable.

  • InsetDrawable – Tento kreslený bude používat sady na stranách jiného nakreslitelného prostředku. Používá se, když zobrazení potřebuje pozadí, které je menší než skutečné hranice zobrazení.

  • XML BitmapDrawable – Tento soubor je sada instrukcí v JAZYCE XML, které mají být provedeny na skutečném rastrovém obrázku. Některé akce, které může Android provádět, jsou vázání, dithering a anti-aliasing. Jedním z velmi běžných použití je dlaždice rastrového obrázku na pozadí rozložení.

Nakreslený příklad

Pojďme se podívat na rychlý příklad vytvoření 2D grafiky ShapeDrawablepomocí . A ShapeDrawable může definovat jeden ze čtyř základních obrazců: obdélník, ovál, čára a prstenec. Je také možné použít základní efekty, jako je přechod, barva a velikost. Následující kód XML je ShapeDrawable soubor, který lze najít v doprovodném projektu AnimationsDemo (v souboru Resources/drawable/shape_rounded_blue_rect.xml). Definuje obdélník s fialovým přechodovým pozadím a zaoblenými rohy:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
<!-- Specify a gradient for the background -->
<gradient android:angle="45"
          android:startColor="#55000066"
          android:centerColor="#00000000"
          android:endColor="#00000000"
          android:centerX="0.75" />

<padding android:left="5dp"
          android:right="5dp"
          android:top="5dp"
          android:bottom="5dp" />

<corners android:topLeftRadius="10dp"
          android:topRightRadius="10dp"
          android:bottomLeftRadius="10dp"
          android:bottomRightRadius="10dp" />
</shape>

Na tento nakreslený zdroj můžeme odkazovat deklarativním způsobem v rozložení nebo jiném kreslení, jak je znázorněno v následujícím xml:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="#33000000">
    <TextView android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:layout_centerInParent="true"
              android:background="@drawable/shape_rounded_blue_rect"
              android:text="@string/message_shapedrawable" />
</RelativeLayout>

Nakreslitelné prostředky lze použít také programově. Následující fragment kódu ukazuje, jak programově nastavit pozadí objektu TextView:

TextView tv = FindViewById<TextView>(Resource.Id.shapeDrawableTextView);
tv.SetBackgroundResource(Resource.Drawable.shape_rounded_blue_rect);

Pokud chcete zjistit, jak by to vypadalo, spusťte projekt AnimationsDemo a v hlavní nabídce vyberte položku Nakreslitelný obrazec. Měli bychom vidět něco podobného jako na následujícím snímku obrazovky:

Textové zobrazení s vlastním pozadím, nakreslené přechodem a zaoblenými rohy

Další podrobnosti o elementech XML a syntaxi Drawable Resources najdete v dokumentaci Společnosti Google.

Použití rozhraní API pro kreslení plátna

Kreslicí nástroje jsou výkonné, ale mají svá omezení. Některé věci buď nejsou možné, nebo jsou velmi složité (například použití filtru na fotku pořízenou fotoaparátem na zařízení). Bylo by velmi obtížné použít redukci červených očí pomocí nakresleného zdroje. Místo toho rozhraní API plátna umožňuje aplikaci mít velmi jemně odstupňovaný ovládací prvek pro selektivní změnu barev v určité části obrázku.

Jedna třída, která se běžně používá s plátnem, je třída Malování. Tato třída obsahuje barevné a stylové informace o tom, jak kreslit. Používá se k poskytování takových barev a průhlednosti.

Rozhraní API plátna používá model malíře k kreslení 2D grafiky. Operace se používají v po sobě jdoucích vrstvách. Každá operace pokryje určitou oblast podkladového rastrového obrázku. Když se tato oblast překrývá dříve namalovanou oblastí, nová barva bude částečně nebo úplně zakrýt starou oblast. To je stejný způsob, jakým funguje mnoho dalších rozhraní API kreslení, jako je System.Drawing a iOS Core Graphics.

Objekt lze získat Canvas dvěma způsoby. První způsob zahrnuje definování bitmapového objektu a následné vytvoření instance objektu Canvas s ním. Například následující fragment kódu vytvoří nové plátno s podkladovým rastrovým obrázkem:

Bitmap bitmap = Bitmap.CreateBitmap(100, 100, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(b);

Druhý způsob, jak získat Canvas objekt je onDraw callback metoda, která je poskytována View základní třídy. Android volá tuto metodu, když se rozhodne, že zobrazení se musí nakreslit a předá objekt Canvas , se kterým může zobrazení pracovat.

Třída Canvas zveřejňuje metody, které programově poskytují pokyny pro kreslení. Příklad:

Kreslení pomocí rozhraní API plátna

Tady je příklad rozhraní API plátna v akci. Následující fragment kódu ukazuje, jak nakreslit zobrazení:

public class MyView : View
{
    protected override void OnDraw(Canvas canvas)
    {
        base.OnDraw(canvas);
        Paint green = new Paint {
            AntiAlias = true,
            Color = Color.Rgb(0x99, 0xcc, 0),
        };
        green.SetStyle(Paint.Style.FillAndStroke);

        Paint red = new Paint {
            AntiAlias = true,
            Color = Color.Rgb(0xff, 0x44, 0x44)
        };
        red.SetStyle(Paint.Style.FillAndStroke);

        float middle = canvas.Width * 0.25f;
        canvas.DrawPaint(red);
        canvas.DrawRect(0, 0, middle, canvas.Height, green);
    }
}

Tento kód výše nejprve vytvoří červenou barvu a zelený objekt barvy. Vyplní obsah plátna červenou barvou a pak dá plátnu pokyn, aby nakreslil zelený obdélník, který je 25 % šířky plátna. Příklad toho je vidět v AnimationsDemo projektu, který je součástí zdrojového kódu pro tento článek. Spuštěním aplikace a výběrem položky Kreslení z hlavní nabídky bychom měli zobrazit obrazovku podobnou této:

Obrazovka s červenou barvou a zelenými objekty barvy

Animace

Uživatelé se podobají tomu, co se ve svých aplikacích přesouvá. Animace představují skvělý způsob, jak vylepšit uživatelské prostředí aplikace a pomoci jí vyniknout. Nejlepší animace jsou ty, které si uživatelé nevšimnou, protože se cítí přirozeně. Android poskytuje pro animace následující tři rozhraní API:

  • Zobrazit animaci – toto je původní rozhraní API. Tyto animace jsou svázané s konkrétním zobrazením a můžou provádět jednoduché transformace v obsahu zobrazení. Vzhledem k jednoduchosti je toto rozhraní API stále užitečné pro věci, jako jsou alfa animace, otočení atd.

  • Animace vlastností – animace vlastností byly zavedeny v Androidu 3.0. Umožňují aplikaci animovat téměř cokoli. Animace vlastností lze použít ke změně jakékoli vlastnosti libovolného objektu, i když tento objekt není na obrazovce viditelný.

  • Nakreslitelná animace – jedná se o speciální nakreslený prostředek, který se používá k použití velmi jednoduchého animačního efektu na rozložení.

Obecně platí, že animace vlastností je upřednostňovaným systémem, který se používá, protože je flexibilnější a nabízí více funkcí.

Zobrazení animací

Animace zobrazení jsou omezené na zobrazení a můžou provádět animace jenom u hodnot, jako jsou počáteční a koncové body, velikost, otočení a průhlednost. Tyto typy animací se obvykle označují jako doplnění animací. Animace zobrazení lze definovat dvěma způsoby – programově v kódu nebo pomocí souborů XML. Soubory XML jsou upřednostňovaným způsobem deklarace animací, protože jsou čitelnější a snadněji udržovatelné.

Soubory XML animace budou uloženy v /Resources/anim adresáři projektu Xamarin.Android. Tento soubor musí mít jako kořenový prvek jeden z následujících prvků:

  • alpha – Animace prolnutí nebo prolnutí.

  • rotate – Animace otočení.

  • scale – Změna velikosti animace.

  • translate – vodorovný nebo svislý pohyb.

  • set – Kontejner, který může obsahovat jeden nebo více dalších animačních prvků.

Ve výchozím nastavení se všechny animace v souboru XML použijí současně. Pokud chcete, aby animace probíhaly postupně, nastavte android:startOffset atribut na jeden z prvků definovaných výše.

Rychlost změny animace je možné ovlivnit pomocí interpolátoru. Interpolátor umožňuje akceleraci, opakování nebo zpomalení animačních efektů. Rozhraní Android poskytuje několik interpolátorů, například (ale nikoli pouze):

  • AccelerateInterpolator / DecelerateInterpolator – tyto interpolátory zvyšují nebo snižují četnost změn v animaci.

  • BounceInterpolator – změna se odrazí na konci.

  • LinearInterpolator – míra změn je konstantní.

Následující xml ukazuje příklad souboru animace, který kombinuje některé z těchto prvků:

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android=http://schemas.android.com/apk/res/android
     android:shareInterpolator="false">

    <scale android:interpolator="@android:anim/accelerate_decelerate_interpolator"
           android:fromXScale="1.0"
           android:toXScale="1.4"
           android:fromYScale="1.0"
           android:toYScale="0.6"
           android:pivotX="50%"
           android:pivotY="50%"
           android:fillEnabled="true"
           android:fillAfter="false"
           android:duration="700" />

    <set android:interpolator="@android:anim/accelerate_interpolator">
        <scale android:fromXScale="1.4"
               android:toXScale="0.0"
               android:fromYScale="0.6"
               android:toYScale="0.0"
               android:pivotX="50%"
               android:pivotY="50%"
               android:fillEnabled="true"
               android:fillBefore="false"
               android:fillAfter="true"
               android:startOffset="700"
               android:duration="400" />

        <rotate android:fromDegrees="0"
                android:toDegrees="-45"
                android:toYScale="0.0"
                android:pivotX="50%"
                android:pivotY="50%"
                android:fillEnabled="true"
                android:fillBefore="false"
                android:fillAfter="true"
                android:startOffset="700"
                android:duration="400" />
    </set>
</set>

Tato animace provede všechny animace současně. První animace měřítka roztáhne obrázek vodorovně a zmenší ho svisle a obrázek bude současně otočen o 45 stupňů proti směru hodinových ručiček a zmenšení, zmizí z obrazovky.

Animaci lze použít na zobrazení prostřednictvím kódu programu tak, že nafouknete animaci a pak ji použijete v zobrazení. Android poskytuje pomocnou třídu Android.Views.Animations.AnimationUtils , která nafoukne animační prostředek a vrátí instanci Android.Views.Animations.Animation. Tento objekt se použije v zobrazení voláním StartAnimation a předáním objektu Animation . Následující fragment kódu ukazuje příklad:

Animation myAnimation = AnimationUtils.LoadAnimation(Resource.Animation.MyAnimation);
ImageView myImage = FindViewById<ImageView>(Resource.Id.imageView1);
myImage.StartAnimation(myAnimation);

Když teď máme základní znalosti o fungování animací zobrazení, můžeme přejít na animace vlastností.

Animace vlastností

Animátory vlastností jsou nové rozhraní API, které bylo zavedeno v Androidu 3.0. Poskytují rozšiřitelné rozhraní API, které lze použít k animaci jakékoli vlastnosti u libovolného objektu.

Všechny animace vlastností jsou vytvořeny instancemi podtřídy Animatoru . Aplikace tuto třídu přímo nepoužívají, místo toho používají jednu z těchto podtříd:

  • ValueAnimator – Tato třída je nejdůležitější třídou v celém rozhraní API animace vlastností. Vypočítá hodnoty vlastností, které je potřeba změnit. Tyto ViewAnimator hodnoty neaktualizuje přímo. Místo toho vyvolává události, které lze použít k aktualizaci animovaných objektů.

  • ObjectAnimator – Tato třída je podtřídou ValueAnimator třídy . Účelem je zjednodušit proces animace objektů přijetím cílového objektu a vlastnosti k aktualizaci.

  • AnimationSet – Tato třída zodpovídá za orchestraci způsobu spouštění animací ve vztahu k sobě navzájem. Animace se můžou spouštět současně, postupně nebo se zadanou prodlevou mezi nimi.

Vyhodnocovače jsou speciální třídy, které používají animátory k výpočtu nových hodnot během animace. Android nabízí následující vyhodnocovače:

Pokud vlastnost, která je animované, není floatnebo int barva, aplikace mohou vytvořit vlastní vyhodnocovače implementací ITypeEvaluator rozhraní. (Implementace vlastních vyhodnocovačů přesahuje rozsah tohoto tématu.)

Použití ValueAnimatoru

Animace má dvě části: výpočet animovaných hodnot a nastavení těchto hodnot u vlastností u některého objektu. ValueAnimator vypočítá pouze hodnoty, ale nebude pracovat s objekty přímo. Místo toho se objekty aktualizují uvnitř obslužných rutin událostí, které budou vyvolány během životnosti animace. Tento návrh umožňuje aktualizaci několika vlastností z jedné animované hodnoty.

Instanci získáte ValueAnimator voláním jedné z následujících metod továrny:

  • ValueAnimator.OfInt
  • ValueAnimator.OfFloat
  • ValueAnimator.OfObject

Po dokončení ValueAnimator musí mít instance nastavenou dobu trvání a pak může být spuštěna. Následující příklad ukazuje, jak animovat hodnotu od 0 do 1 přes rozsah 1000 milisekund:

ValueAnimator animator = ValueAnimator.OfInt(0, 100);
animator.SetDuration(1000);
animator.Start();

Samotný fragment kódu výše ale není moc užitečný – animátor se spustí, ale pro aktualizovanou hodnotu neexistuje žádný cíl. Třída Animator vyvolá událost Update, když se rozhodne, že je nutné informovat naslouchací procesy o nové hodnotě. Aplikace mohou poskytnout obslužnou rutinu události, která bude reagovat na tuto událost, jak je znázorněno v následujícím fragmentu kódu:

MyCustomObject myObj = new MyCustomObject();
myObj.SomeIntegerValue = -1;

animator.Update += (object sender, ValueAnimator.AnimatorUpdateEventArgs e) =>
{
    int newValue = (int) e.Animation.AnimatedValue;
    // Apply this new value to the object being animated.
    myObj.SomeIntegerValue = newValue;
};

Teď, když jsme porozuměli ValueAnimator, pojďme se dozvědět více o ObjectAnimator.

Použití ObjectAnimatoru

ObjectAnimator je podtřída ViewAnimator , která kombinuje časovací modul a výpočet hodnoty ValueAnimator s logikou potřebnou k připojení obslužných rutin událostí. Vyžaduje ValueAnimator , aby aplikace explicitně provedou připojení obslužné rutiny události – ObjectAnimator postará se o tento krok za nás.

Rozhraní API pro ObjectAnimator je velmi podobné rozhraní API pro ViewAnimator, ale vyžaduje, abyste zadali objekt a název vlastnosti k aktualizaci. Následující příklad ukazuje příklad použití ObjectAnimator:

MyCustomObject myObj = new MyCustomObject();
myObj.SomeIntegerValue = -1;

ObjectAnimator animator = ObjectAnimator.OfFloat(myObj, "SomeIntegerValue", 0, 100);
animator.SetDuration(1000);
animator.Start();

Jak vidíte z předchozího fragmentu kódu, ObjectAnimator může snížit a zjednodušit kód, který je nezbytný k animaci objektu.

Nakreslitelné animace

Posledním animačním rozhraním API je nakreslený animační rozhraní API. Nakreslené animace načítají řadu kreslených prostředků jeden za druhým a zobrazují je postupně, podobně jako překlopení kreslený.

Nakreslené prostředky jsou definovány v souboru XML, který má <animation-list> element jako kořenový element, a řadu <item> prvků, které definují každý rámec v animaci. Tento soubor XML je uložen ve /Resource/drawable složce aplikace. Následující xml je příkladem nakreslené animace:

<animation-list xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:drawable="@drawable/asteroid01" android:duration="100" />
  <item android:drawable="@drawable/asteroid02" android:duration="100" />
  <item android:drawable="@drawable/asteroid03" android:duration="100" />
  <item android:drawable="@drawable/asteroid04" android:duration="100" />
  <item android:drawable="@drawable/asteroid05" android:duration="100" />
  <item android:drawable="@drawable/asteroid06" android:duration="100" />
</animation-list>

Tato animace bude probíhat přes šest snímků. Atribut android:duration deklaruje, jak dlouho se bude každý rámec zobrazovat. Následující fragment kódu ukazuje příklad vytvoření animace Drawable a jeho spuštění, když uživatel klikne na tlačítko na obrazovce:

AnimationDrawable _asteroidDrawable;

protected override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);
    SetContentView(Resource.Layout.Main);

    _asteroidDrawable = (Android.Graphics.Drawables.AnimationDrawable)
    Resources.GetDrawable(Resource.Drawable.spinning_asteroid);

    ImageView asteroidImage = FindViewById<ImageView>(Resource.Id.imageView2);
    asteroidImage.SetImageDrawable((Android.Graphics.Drawables.Drawable) _asteroidDrawable);

    Button asteroidButton = FindViewById<Button>(Resource.Id.spinAsteroid);
    asteroidButton.Click += (sender, e) =>
    {
        _asteroidDrawable.Start();
    };
}

V tuto chvíli jsme probrali základy animačních rozhraní API dostupných v aplikaci pro Android.

Shrnutí

Tento článek představil spoustu nových konceptů a rozhraní API, které vám pomůžou přidat do aplikace pro Android grafiku. Nejprve jsme probrali různé 2D grafické rozhraní API a ukázali, jak Android umožňuje aplikacím kreslit přímo na obrazovku pomocí objektu Plátno. Viděli jsme také některé alternativní techniky, které umožňují deklarativní vytváření grafiky pomocí souborů XML. Pak jsme se zabývali starým a novým rozhraním API pro vytváření animací v Androidu.