Condividi tramite

Grafica e animazione Android

  • Articolo

Android offre un framework molto ricco e diversificato per supportare grafica e animazioni 2D. Questo argomento presenta questi framework e illustra come creare grafica e animazioni personalizzate da usare in un'applicazione Xamarin.Android.

Panoramica

Nonostante l'esecuzione su dispositivi tradizionalmente dotati di potenza limitata, le applicazioni per dispositivi mobili più elevate hanno spesso un'esperienza utente sofisticata, completa di grafica e animazioni di alta qualità che offrono un aspetto intuitivo, reattivo e dinamico. Man mano che le applicazioni per dispositivi mobili sono sempre più sofisticate, gli utenti hanno iniziato a aspettarsi sempre di più dalle applicazioni.

Fortunatamente per noi, le moderne piattaforme per dispositivi mobili hanno framework molto potenti per creare animazioni sofisticate e grafica personalizzata mantenendo al tempo stesso facilità d'uso. In questo modo gli sviluppatori possono aggiungere un'interattività avanzata con un minimo sforzo.

I framework API dell'interfaccia utente in Android possono essere suddivisi approssimativamente in due categorie: Grafica e Animazione.

La grafica è suddivisa ulteriormente in approcci diversi per eseguire grafica 2D e 3D. La grafica 3D è disponibile tramite diversi framework predefiniti, ad esempio OpenGL ES (una versione specifica per dispositivi mobili di OpenGL) e framework di terze parti come MonoGame (un toolkit multipiattaforma compatibile con il toolkit XNA). Anche se la grafica 3D non rientra nell'ambito di questo articolo, esamineremo le tecniche di disegno 2D predefinite.

Android offre due API diverse per la creazione di grafica 2D. Uno è un approccio dichiarativo di alto livello e l'altro un'API di basso livello a livello di codice:

  • Risorse disegnabili: vengono usate per creare grafica personalizzata a livello di codice o (più in genere) incorporando le istruzioni di disegno nei file XML. Le risorse disegnabili vengono in genere definite come file XML che contengono istruzioni o azioni per Android per eseguire il rendering di un elemento grafico 2D.

  • Canvas : si tratta di un'API di basso livello che prevede il disegno direttamente su una bitmap sottostante. Fornisce un controllo molto granulare su ciò che viene visualizzato.

Oltre a queste tecniche grafiche 2D, Android offre anche diversi modi per creare animazioni:

  • Animazioni disegnabili: Android supporta anche animazioni frame-by-frame note come Animazioni disegnabili. Questa è l'API di animazione più semplice. Android carica in sequenza e visualizza le risorse disegnabili in sequenza (molto simile a un cartone animato).

  • Visualizza animazioni : le animazioni di visualizzazione sono l'API di animazione originale in Android e sono disponibili in tutte le versioni di Android. Questa API è limitata in quanto funzionerà solo con gli oggetti View e può eseguire solo trasformazioni semplici su tali viste. Le animazioni di visualizzazione vengono in genere definite nei file XML presenti nella /Resources/anim cartella .

  • Animazioni delle proprietà: Android 3.0 ha introdotto un nuovo set di API di animazione note come Animazioni delle proprietà. Queste nuove API hanno introdotto un sistema estendibile e flessibile che può essere usato per animare le proprietà di qualsiasi oggetto, non solo oggetti View. Questa flessibilità consente di incapsulare le animazioni in classi distinte che semplificano la condivisione del codice.

Le animazioni di visualizzazione sono più adatte per le applicazioni che devono supportare l'API precedente android 3.0 (livello API 11). In caso contrario, le applicazioni devono usare l'API Di animazione delle proprietà più recente per i motivi indicati in precedenza.

Tutti questi framework sono opzioni praticabili, tuttavia, laddove possibile, le preferenze devono essere date alle animazioni delle proprietà, poiché è un'API più flessibile da usare. Le animazioni delle proprietà consentono di incapsulare la logica di animazione in classi distinte che semplificano la condivisione del codice e semplificano la manutenzione del codice.

Accessibilità

Grafica e animazioni aiutano a rendere le app Android attraenti e divertenti da usare; Tuttavia, è importante ricordare che alcune interazioni si verificano tramite screenreader, dispositivi di input alternativi o con zoom assistito. Inoltre, alcune interazioni possono verificarsi senza funzionalità audio.

Le app sono più utilizzabili in queste situazioni se sono state progettate tenendo presente l'accessibilità: fornire suggerimenti e assistenza per la navigazione nell'interfaccia utente e garantire che siano presenti contenuti di testo o descrizioni per gli elementi pictoriali dell'interfaccia utente.

Per altre informazioni su come usare le API di accessibilità di Android, vedere la Guida all'accessibilità di Google.

Grafica 2D

Le risorse drawable sono una tecnica comune nelle applicazioni Android. Come per altre risorse, le risorse disegnabili sono dichiarative, definite nei file XML. Questo approccio consente una separazione pulita del codice dalle risorse. Ciò può semplificare lo sviluppo e la manutenzione perché non è necessario modificare il codice per aggiornare o modificare la grafica in un'applicazione Android. Tuttavia, mentre le risorse disegnabili sono utili per molti requisiti grafici semplici e comuni, non hanno la potenza e il controllo dell'API Canvas.

L'altra tecnica, usando l'oggetto Canvas , è molto simile ad altri framework API tradizionali, ad esempio System.Drawing o il disegno principale di iOS. L'uso dell'oggetto Canvas fornisce il maggior controllo della modalità di creazione della grafica 2D. È appropriato per le situazioni in cui una risorsa disegnabile non funzionerà o sarà difficile da usare. Ad esempio, potrebbe essere necessario disegnare un controllo dispositivo di scorrimento personalizzato il cui aspetto cambierà in base ai calcoli correlati al valore del dispositivo di scorrimento.

Esaminiamo prima di tutto le risorse disegnabili. Sono più semplici e coprono i casi di disegno personalizzati più comuni.

Risorse disegnabili

Le risorse disegnabili sono definite in un file XML nella directory /Resources/drawable. A differenza dell'incorporamento di PNG o JPEG, non è necessario fornire versioni specifiche della densità delle risorse drawable. In fase di esecuzione, un'applicazione Android caricherà queste risorse e userà le istruzioni contenute in questi file XML per creare grafica 2D. Android definisce diversi tipi di risorse disegnabili:

  • ShapeDrawable : oggetto drawable che disegna una forma geometrica primitiva e applica un set limitato di effetti grafici su tale forma. Sono molto utili per elementi come la personalizzazione dei pulsanti o l'impostazione dello sfondo di TextViews. Verrà illustrato un esempio di come usare un oggetto ShapeDrawable più avanti in questo articolo.

  • StateListDrawable: risorsa disegnabile che cambierà l'aspetto in base allo stato di un widget o di un controllo. Ad esempio, un pulsante può modificarne l'aspetto a seconda che venga premuto o meno.

  • LayerDrawable : questa risorsa disegnabile che impilate diverse altre disegnabili una sopra l'altra. Un esempio di LayerDrawable è illustrato nello screenshot seguente:

    Esempio di LayerDrawable

  • TransitionDrawable : si tratta di un layerDrawable ma con una differenza. TransitionDrawable è in grado di animare un livello visualizzato sopra l'altro.

  • LevelListDrawable: è molto simile a stateListDrawable in quanto visualizzerà un'immagine in base a determinate condizioni. Tuttavia, a differenza di StateListDrawable, LevelListDrawable visualizza un'immagine basata su un valore intero. Un esempio di LevelListDrawable consiste nel visualizzare il livello di forza di un segnale Wi-Fi. Man mano che cambia la forza del segnale Wi-Fi, il disegno che viene visualizzato cambierà di conseguenza.

  • ScaleDrawable ClipDrawable/: come suggerisce il nome, questi elementi drawable offrono funzionalità di ridimensionamento e ritaglio. ScaleDrawable ridimensiona un altro elemento Drawable , mentre ClipDrawable ritaglierà un altro elemento Drawable.

  • InsetDrawable : questo elemento drawable verrà applicato ai lati di un'altra risorsa disegnabile. Viene usato quando una visualizzazione richiede uno sfondo inferiore ai limiti effettivi della visualizzazione.

  • BitmapDrawable XML: questo file è un set di istruzioni, in XML, che devono essere eseguite su una bitmap effettiva. Alcune azioni che Android può eseguire sono l'associazione, il dithering e l'anti-aliasing. Uno degli usi molto comuni di questo è quello di affiancare una bitmap sullo sfondo di un layout.

Esempio di disegno

Di seguito viene illustrato un rapido esempio di come creare un elemento grafico 2D usando un oggetto ShapeDrawable. Un ShapeDrawable oggetto può definire una delle quattro forme di base: rettangolo, ovale, linea e anello. È anche possibile applicare effetti di base, ad esempio sfumatura, colore e dimensioni. Il codice XML seguente è un oggetto ShapeDrawable che può essere trovato nel progetto complementare AnimationsDemo (nel file Resources/drawable/shape_rounded_blue_rect.xml). Definisce un rettangolo con sfondo sfumato viola e angoli arrotondati:

<?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>

È possibile fare riferimento a questa risorsa disegnabile in modo dichiarativo in un layout o in un altro elemento Drawable, come illustrato nel codice XML seguente:

<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>

Le risorse disegnabili possono essere applicate anche a livello di codice. Il frammento di codice seguente illustra come impostare a livello di codice lo sfondo di un controllo TextView:

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

Per visualizzare l'aspetto desiderato, eseguire il progetto AnimationsDemo e selezionare la voce Shape Drawable dal menu principale. Verrà visualizzato un aspetto simile allo screenshot seguente:

Visualizzazione testo con sfondo personalizzato, disegnabile con sfumatura e angoli arrotondati

Per altre informazioni sugli elementi XML e sulla sintassi di Drawable Resources, vedere la documentazione di Google.

Uso dell'API Disegno canvas

I drawable sono potenti, ma hanno le loro limitazioni. Alcune cose non sono possibili o molto complesse (ad esempio: l'applicazione di un filtro a un'immagine scattata da una fotocamera nel dispositivo). Sarebbe molto difficile applicare la riduzione degli occhi rossi usando una risorsa disegnabile. L'API Canvas consente invece a un'applicazione di avere un controllo con granularità molto fine per modificare in modo selettivo i colori in una parte specifica dell'immagine.

Una classe comunemente usata con Canvas è la classe Paint . Questa classe contiene informazioni sul colore e sullo stile su come disegnare. Viene usato per fornire elementi di questo tipo di colore e trasparenza.

L'API Canvas usa il modello del pittore per disegnare grafica 2D. Le operazioni vengono applicate in livelli successivi l'uno sull'altro. Ogni operazione coprirà un'area della bitmap sottostante. Quando l'area si sovrappone a un'area dipinta in precedenza, la nuova vernice nasconderà parzialmente o completamente il vecchio. Questo è lo stesso modo in cui molte altre API di disegno, ad esempio System.Drawing e iOS Core Graphics funzionano.

Esistono due modi per ottenere un Canvas oggetto. Il primo modo prevede la definizione di un oggetto Bitmap e quindi la creazione di un'istanza di un Canvas oggetto con esso. Ad esempio, il frammento di codice seguente crea un nuovo canvas con una bitmap sottostante:

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

L'altro modo per ottenere un Canvas oggetto è il metodo di callback OnDraw fornito dalla classe di base View . Android chiama questo metodo quando decide che un oggetto View deve disegnare se stesso e passa un Canvas oggetto per l'uso di View.

La classe Canvas espone i metodi per fornire le istruzioni di disegno a livello di codice. Ad esempio:

  • Canvas.DrawPaint : riempie la bitmap dell'intera area di disegno con la vernice specificata.

  • Canvas.DrawPath : disegna la forma geometrica specificata utilizzando la vernice specificata.

  • Canvas.DrawText : disegna il testo sull'area di disegno con il colore specificato. Il testo viene disegnato nella posizione x,y .

Disegno con l'API Canvas

Ecco un esempio dell'API Canvas in azione. Il frammento di codice seguente illustra come disegnare una visualizzazione:

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

Questo codice precedente crea prima una vernice rossa e un oggetto paint verde. Riempie il contenuto dell'area di disegno con il rosso e quindi indica all'area di disegno un rettangolo verde pari al 25% della larghezza dell'area di disegno. Un esempio di questo problema può essere visualizzato nel progetto incluso nel AnimationsDemo codice sorgente per questo articolo. Avviando l'applicazione e selezionando la voce Disegno dal menu principale, si dovrebbe visualizzare una schermata simile alla seguente:

Schermo con vernice rossa e oggetti di vernice verde

Animazione

Gli utenti amano le cose che si spostano nelle applicazioni. Le animazioni sono un ottimo modo per migliorare l'esperienza utente di un'applicazione e aiutarla a distinguersi. Le animazioni migliori sono quelle che gli utenti non notano perché si sentono naturali. Android fornisce le tre API seguenti per le animazioni:

  • Animazione di visualizzazione: questa è l'API originale. Queste animazioni sono associate a una visualizzazione specifica e possono eseguire semplici trasformazioni sul contenuto della visualizzazione. A causa della semplicità, questa API è ancora utile per elementi come animazioni alfa, rotazioni e così via.

  • Animazione delle proprietà: le animazioni delle proprietà sono state introdotte in Android 3.0. Consentono a un'applicazione di animare quasi tutto. Le animazioni delle proprietà possono essere usate per modificare qualsiasi proprietà di qualsiasi oggetto, anche se tale oggetto non è visibile sullo schermo.

  • Animazione disegnabile: questa risorsa disegnabile speciale usata per applicare un effetto di animazione molto semplice ai layout.

In generale, l'animazione delle proprietà è il sistema preferito da usare perché è più flessibile e offre più funzionalità.

Visualizza animazioni

Le animazioni di visualizzazione sono limitate alle visualizzazioni e possono eseguire animazioni solo su valori come i punti iniziale e finale, le dimensioni, la rotazione e la trasparenza. Questi tipi di animazioni vengono in genere definiti animazioni tween. Le animazioni di visualizzazione possono essere definite in due modi, a livello di codice o tramite file XML. I file XML sono il modo preferito per dichiarare le animazioni di visualizzazione, in quanto sono più leggibili e più facili da gestire.

I file XML di animazione verranno archiviati nella /Resources/anim directory di un progetto Xamarin.Android. Questo file deve avere uno degli elementi seguenti come elemento radice :

  • alpha : animazione dissolvenza in dissolvenza o dissolvenza.

  • rotate : animazione di rotazione.

  • scale : animazione di ridimensionamento.

  • translate – Movimento orizzontale e/o verticale.

  • set : contenitore che può contenere uno o più degli altri elementi di animazione.

Per impostazione predefinita, tutte le animazioni in un file XML verranno applicate contemporaneamente. Per fare in modo che le animazioni vengano eseguite in sequenza, impostare l'attributo android:startOffset su uno degli elementi definiti in precedenza.

È possibile influire sulla frequenza di modifica in un'animazione usando un interpolatore. Un interpolatore consente l'accelerazione, la ripetizione o la decelerazione degli effetti di animazione. Il framework Android offre diversi interpolatori predefiniti, ad esempio (ma non limitati a):

  • AccelerateInterpolator / DecelerateInterpolator : questi interpolatori aumentano o riducono la frequenza di modifica in un'animazione.

  • BounceInterpolator – la modifica rimbalza alla fine.

  • LinearInterpolator : la frequenza delle modifiche è costante.

Il codice XML seguente mostra un esempio di file di animazione che combina alcuni di questi elementi:

<?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>

Questa animazione eseguirà tutte le animazioni contemporaneamente. La prima animazione in scala estende l'immagine orizzontalmente e la compatta verticalmente, quindi l'immagine verrà ruotata contemporaneamente a 45 gradi in senso antiorario e compattata, scomparendo dallo schermo.

L'animazione può essere applicata a livello di codice a una visualizzazione gonfiando l'animazione e quindi applicandola a una visualizzazione. Android fornisce la classe Android.Views.Animations.AnimationUtils helper che gonfia una risorsa di animazione e restituisce un'istanza di Android.Views.Animations.Animation. Questo oggetto viene applicato a una vista chiamando StartAnimation e passando l'oggetto Animation . Il frammento di codice seguente mostra un esempio di questo:

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

Ora che abbiamo una conoscenza fondamentale del funzionamento delle animazioni di visualizzazione, consente di passare alle animazioni delle proprietà.

Animazioni delle proprietà

Gli animatori di proprietà sono una nuova API introdotta in Android 3.0. Forniscono un'API più estendibile che può essere usata per animare qualsiasi proprietà in qualsiasi oggetto.

Tutte le animazioni delle proprietà vengono create dalle istanze della sottoclasse Animator . Le applicazioni non usano direttamente questa classe, ma usano una delle sottoclassi seguenti:

  • ValueAnimator : questa classe è la classe più importante nell'intera API di animazione delle proprietà. Calcola i valori delle proprietà che devono essere modificate. Non ViewAnimator aggiorna direttamente tali valori, ma genera eventi che possono essere utilizzati per aggiornare gli oggetti animati.

  • ObjectAnimator : questa classe è una sottoclasse di ValueAnimator . È progettato per semplificare il processo di animazione degli oggetti accettando un oggetto di destinazione e una proprietà da aggiornare.

  • AnimationSet : questa classe è responsabile dell'orchestrazione del modo in cui le animazioni vengono eseguite l'una rispetto all'altra. Le animazioni possono essere eseguite simultaneamente, in sequenza o con un ritardo specificato tra di essi.

Gli analizzatori sono classi speciali usate dagli animatori per calcolare i nuovi valori durante un'animazione. Android offre gli analizzatori seguenti:

Se la proprietà animata non è un colore o , int le applicazioni possono creare un floatanalizzatore personalizzato implementando l'interfaccia ITypeEvaluator . L'implementazione di analizzatori personalizzati esula dall'ambito di questo argomento.

Uso di ValueAnimator

Esistono due parti di qualsiasi animazione: calcolo di valori animati e quindi impostazione di tali valori sulle proprietà di un oggetto. ValueAnimator calcolerà solo i valori, ma non funzionerà direttamente sugli oggetti. Gli oggetti verranno invece aggiornati all'interno dei gestori eventi che verranno richiamati durante la durata dell'animazione. Questa progettazione consente di aggiornare diverse proprietà da un valore animato.

Per ottenere un'istanza di ValueAnimator , chiamare uno dei metodi factory seguenti:

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

Al termine dell'operazione, l'istanza ValueAnimator deve avere la durata impostata e quindi può essere avviata. L'esempio seguente illustra come animare un valore compreso tra 0 e 1 nell'intervallo di 1000 millisecondi:

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

Tuttavia, il frammento di codice precedente non è molto utile: l'animatore verrà eseguito ma non c'è alcuna destinazione per il valore aggiornato. La Animator classe genererà l'evento Update quando decide che è necessario informare i listener di un nuovo valore. Le applicazioni possono fornire un gestore eventi per rispondere a questo evento, come illustrato nel frammento di codice seguente:

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

Ora che si ha una conoscenza di ValueAnimator, è possibile ottenere altre informazioni su ObjectAnimator.

Uso di ObjectAnimator

ObjectAnimator è una sottoclasse di ViewAnimator che combina il motore di temporizzazione e il calcolo del valore di ValueAnimator con la logica necessaria per collegare i gestori eventi. Richiede ValueAnimator alle applicazioni di collegare in modo esplicito un gestore eventi, ObjectAnimator che si occuperà di questo passaggio per noi.

L'API per ObjectAnimator è molto simile all'API per ViewAnimator, ma richiede di fornire l'oggetto e il nome della proprietà da aggiornare. L'esempio seguente illustra un esempio di utilizzo ObjectAnimatordi :

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

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

Come si può notare dal frammento di codice precedente, ObjectAnimator può ridurre e semplificare il codice necessario per animare un oggetto.

Animazioni disegnabili

L'API di animazione finale è l'API di animazione disegnabile. Le animazioni disegnabili caricano una serie di risorse disegnabili una dopo l'altra e le visualizzano in sequenza, in modo simile a un cartone animato capovolto.

Le risorse disegnabili vengono definite in un file XML con un <animation-list> elemento come elemento radice e una serie di <item> elementi che definiscono ogni fotogramma nell'animazione. Questo file XML viene archiviato nella /Resource/drawable cartella dell'applicazione. Il codice XML seguente è un esempio di animazione disegnabile:

<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>

Questa animazione verrà eseguita attraverso sei fotogrammi. L'attributo android:duration dichiara per quanto tempo verrà visualizzato ogni fotogramma. Il frammento di codice successivo mostra un esempio di creazione di un'animazione drawable e l'avvio quando l'utente fa clic su un pulsante sullo schermo:

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

A questo punto sono state illustrate le basi delle API di animazione disponibili in un'applicazione Android.

Riepilogo

Questo articolo ha introdotto molti nuovi concetti e API per aggiungere alcuni elementi grafici a un'applicazione Android. In primo luogo, ha discusso le varie API grafiche 2D e ha illustrato come Android consente alle applicazioni di disegnare direttamente sullo schermo usando un oggetto Canvas. Sono state inoltre illustrate alcune tecniche alternative che consentono di creare grafica in modo dichiarativo usando i file XML. Poi abbiamo continuato a discutere della vecchia e nuova API per la creazione di animazioni in Android.