Android-Grafiken und -Animationen

Artikel
07/13/2023

Android bietet ein sehr umfangreiches und vielfältiges Framework für die Unterstützung von 2D-Grafiken und -Animationen. In diesem Thema werden diese Frameworks vorgestellt und erläutert, wie Sie benutzerdefinierte Grafiken und Animationen für die Verwendung in einer Xamarin.Android-Anwendung erstellen.

Übersicht

Obwohl sie auf Geräten ausgeführt werden, die traditionell mit begrenzter Leistung arbeiten, verfügen die am höchsten bewerteten mobilen Anwendungen häufig über eine anspruchsvolle Benutzeroberfläche (User Experience, UX), komplett mit hochwertigen Grafiken und Animationen, die ein intuitives, reaktionsfähiges, dynamisches Gefühl bieten. Da mobile Anwendungen immer komplexer werden, haben Benutzer begonnen, immer mehr von Anwendungen zu erwarten.

Glücklicherweise für uns verfügen moderne mobile Plattformen über sehr leistungsfähige Frameworks zum Erstellen anspruchsvoller Animationen und benutzerdefinierter Grafiken bei gleichzeitiger Benutzerfreundlichkeit. Dadurch können Entwickler mit wenig Aufwand eine umfassende Interaktivität hinzufügen.

Ui-API-Frameworks in Android können grob in zwei Kategorien unterteilt werden: Grafik und Animation.

Grafiken werden weiter in verschiedene Ansätze für 2D- und 3D-Grafiken unterteilt. 3D-Grafiken sind über eine Reihe von integrierten Frameworks verfügbar, z. B. OpenGL ES (eine mobile spezifische Version von OpenGL) und Frameworks von Drittanbietern wie MonoGame (ein plattformübergreifendes Toolkit, das mit dem XNA-Toolkit kompatibel ist). Obwohl 3D-Grafiken nicht in den Rahmen dieses Artikels fallen, werden wir die integrierten 2D-Zeichnungstechniken untersuchen.

Android bietet zwei verschiedene APIs zum Erstellen von 2D-Grafiken. Eine ist ein allgemeiner deklarativer Ansatz und der andere eine programmgesteuerte Low-Level-API:

Drawable Resources : Diese werden verwendet, um benutzerdefinierte Grafiken entweder programmgesteuert oder (in der Regel) durch Einbetten von Zeichnungsanweisungen in XML-Dateien zu erstellen. Zeichnende Ressourcen werden in der Regel als XML-Dateien definiert, die Anweisungen oder Aktionen für Android zum Rendern einer 2D-Grafik enthalten.
Canvas : Dies ist eine API auf niedriger Ebene, bei der direkt auf einer zugrunde liegenden Bitmap gezeichnet wird. Es bietet eine sehr differenzierte Kontrolle über das Angezeigte.

Zusätzlich zu diesen 2D-Grafiktechniken bietet Android auch verschiedene Möglichkeiten zum Erstellen von Animationen:

Zeichnungsfähige Animationen – Android unterstützt auch Frame-by-Frame-Animationen, die als Drawable Animation bezeichnet werden. Dies ist die einfachste Animations-API. Android lädt und zeigt drawable-Ressourcen sequenziell an (ähnlich wie bei einem Cartoon).
Animationen anzeigen – Animationen anzeigen sind die ursprünglichen Animations-API in Android und sind in allen Android-Versionen verfügbar. Diese API ist insofern eingeschränkt, als sie nur mit View-Objekten funktioniert und nur einfache Transformationen für diese Ansichten ausführen kann. Anzeigeanimationen werden in der Regel in XML-Dateien definiert, die /Resources/anim sich im Ordner befinden.
Eigenschaftenanimationen : Android 3.0 hat einen neuen Satz von Animations-API eingeführt, der als Eigenschaftenanimationen bezeichnet wird. Diese neuen APIs haben ein erweiterbares und flexibles System eingeführt, das verwendet werden kann, um die Eigenschaften jedes Objekts zu animieren, nicht nur View-Objekte. Diese Flexibilität ermöglicht es, Animationen in unterschiedlichen Klassen zu kapseln, was die Codefreigabe erleichtert.

Anzeigenanimationen eignen sich besser für Anwendungen, die die älteren APIs vor Android 3.0 unterstützen müssen (API-Ebene 11). Andernfalls sollten Anwendungen aus den oben genannten Gründen die neueren Eigenschaftenanimations-API verwenden.

Alle diese Frameworks sind praktikable Optionen, aber nach Möglichkeit sollten Eigenschaftenanimationen bevorzugt werden, da es eine flexiblere API für die Arbeit ist. Eigenschaftenanimationen ermöglichen die Kapselung von Animationslogik in unterschiedlichen Klassen, was die Codefreigabe vereinfacht und die Codewartung vereinfacht.

Zugriff

Grafiken und Animationen helfen, Android-Apps attraktiv und lustig zu machen; Es ist jedoch wichtig, daran zu denken, dass einige Interaktionen über Bildschirmleser, alternative Eingabegeräte oder mit unterstütztem Zoom erfolgen. Außerdem können einige Interaktionen ohne Audiofunktionen auftreten.

Apps sind in diesen Situationen besser verwendbar, wenn sie unter Berücksichtigung der Barrierefreiheit entworfen wurden: Bereitstellen von Hinweisen und Navigationshilfen in der Benutzeroberfläche und Sicherstellen, dass Textinhalte oder Beschreibungen für bildliche Elemente der Benutzeroberfläche vorhanden sind.

Weitere Informationen zur Verwendung der Barrierefreiheits-APIs von Android finden Sie im Leitfaden zur Barrierefreiheit von Google.

2D-Grafiken

Drawable Resources sind eine beliebte Technik in Android-Anwendungen. Wie bei anderen Ressourcen sind drawable Resources deklarativ – sie werden in XML-Dateien definiert. Dieser Ansatz ermöglicht eine sauber Trennung von Code und Ressourcen. Dies kann die Entwicklung und Wartung vereinfachen, da es nicht erforderlich ist, code zu ändern, um die Grafiken in einer Android-Anwendung zu aktualisieren oder zu ändern. Drawable Resources ist zwar für viele einfache und allgemeine Grafikanforderungen nützlich, aber es fehlt ihnen an der Leistung und Kontrolle der Canvas-API.

Die andere Technik, die das Canvas-Objekt verwendet, ist anderen herkömmlichen API-Frameworks wie System.Drawing oder der Core Drawing von iOS sehr ähnlich. Die Verwendung des Canvas-Objekts bietet die größte Kontrolle darüber, wie 2D-Grafiken erstellt werden. Es eignet sich für Situationen, in denen eine drawable-Ressource nicht funktioniert oder schwierig zu arbeiten ist. Beispielsweise kann es erforderlich sein, ein benutzerdefiniertes Schiebereglersteuerelement zu zeichnen, dessen Darstellung sich basierend auf Berechnungen im Zusammenhang mit dem Wert des Schiebereglers ändert.

Sehen wir uns zunächst drawable Resources an. Sie sind einfacher und decken die gängigsten benutzerdefinierten Zeichnungsfälle ab.

Drawable Resources

Drawable Resources werden in einer XML-Datei im Verzeichnis /Resources/drawabledefiniert. Im Gegensatz zum Einbetten von PNG- oder JPEG-Dateien ist es nicht erforderlich, dichtespezifische Versionen von Drawable Resources bereitzustellen. Zur Laufzeit lädt eine Android-Anwendung diese Ressourcen und verwendet die Anweisungen in diesen XML-Dateien, um 2D-Grafiken zu erstellen. Android definiert verschiedene Arten von drawable Resources:

ShapeDrawable : Dies ist ein Drawable-Objekt, das eine primitive geometrische Form zeichnet und eine begrenzte Anzahl grafischer Effekte auf diese Form anwendet. Sie sind sehr nützlich für Dinge wie das Anpassen von Schaltflächen oder das Festlegen des Hintergrunds von TextViews. Ein Beispiel für die Verwendung eines ShapeDrawable finden Sie weiter unten in diesem Artikel.
StateListDrawable : Dies ist eine drawable-Ressource, die die Darstellung basierend auf dem Zustand eines Widgets/Steuerelements ändert. Beispielsweise kann sich die Darstellung einer Schaltfläche ändern, je nachdem, ob sie gedrückt wird oder nicht.
LayerDrawable : Diese drawable-Ressource, die mehrere andere Zeichnungsarten übereinander stapelt. Im folgenden Screenshot wird ein Beispiel für eine LayerDrawable-Datei gezeigt:
TransitionDrawable : Dies ist ein LayerDrawable,aber mit einem Unterschied. Ein TransitionDrawable kann eine Ebene animieren, die über einer anderen angezeigt wird.
LevelListDrawable : Dies ist einer StateListDrawable sehr ähnlich, da ein Bild basierend auf bestimmten Bedingungen angezeigt wird. Im Gegensatz zu stateListDrawable zeigt LevelListDrawable jedoch ein Bild basierend auf einem ganzzahligen Wert an. Ein Beispiel für eine LevelListDrawable wäre die Anzeige der Stärke eines WLAN-Signals. Wenn sich die Stärke des WLAN-Signals ändert, ändert sich das zeichenbare Signal, das angezeigt wird, entsprechend.
ScaleDrawable/ClipDrawable : Wie der Name schon sagt, bieten diese Drawables sowohl Skalierungs- als auch Clippingfunktionen. ScaleDrawable skaliert ein anderes Drawable, während ClipDrawable ein anderes Drawable ausschneiden wird.
InsetDrawable : Dieses Drawable wendet Einsets auf den Seiten einer anderen Drawable-Ressource an. Sie wird verwendet, wenn eine Ansicht einen Hintergrund benötigt, der kleiner als die tatsächlichen Begrenzungen der Ansicht ist.
XML BitmapDrawable : Diese Datei ist eine Reihe von Anweisungen in XML, die für eine tatsächliche Bitmap ausgeführt werden sollen. Einige Aktionen, die Android ausführen kann, sind Kacheln, Dithering und Antialiasing. Eine der häufigsten Verwendungen ist das Kacheln einer Bitmap über den Hintergrund eines Layouts.

Drawable-Beispiel

Sehen wir uns ein kurzes Beispiel für das Erstellen einer 2D-Grafik mit einem an ShapeDrawable. Ein ShapeDrawable kann eine der vier grundlegenden Formen definieren: Rechteck, Oval, Linie und Ring. Es ist auch möglich, grundlegende Effekte wie Farbverlauf, Farbe und Größe anzuwenden. Der folgende XML-Code befindet ShapeDrawable sich im Begleitprojekt AnimationDemo (in der Datei Resources/drawable/shape_rounded_blue_rect.xml). Es definiert ein Rechteck mit einem violetten Farbverlaufshintergrund und abgerundeten Ecken:

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

Wir können deklarativ auf diese Drawable-Ressource in einem Layout oder einem anderen Drawable verweisen, wie im folgenden XML-Code gezeigt:

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

Drawable Resources können auch programmgesteuert angewendet werden. Der folgende Codeausschnitt zeigt, wie Sie den Hintergrund einer TextView programmgesteuert festlegen:

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

Um zu sehen, wie dies aussehen würde, führen Sie das Projekt AnimationEnDemo aus, und wählen Sie im Menü Standard das Element Shape Drawable aus. Es sollte etwas ähnliches wie der folgende Screenshot angezeigt werden:

Weitere Informationen zu den XML-Elementen und der Syntax von Drawable Resources finden Sie in der Dokumentation von Google.

Verwenden der Canvas-Zeichnungs-API

Drawables sind leistungsstark, weisen jedoch ihre Einschränkungen auf. Bestimmte Dinge sind entweder nicht möglich oder sehr komplex (z. B. anwenden eines Filters auf ein Bild, das von einer Kamera auf dem Gerät aufgenommen wurde). Es wäre sehr schwierig, die Red-Eye-Reduzierung mithilfe einer drawable-Ressource anzuwenden. Stattdessen ermöglicht die Canvas-API einer Anwendung eine sehr fein abgeständerte Steuerung, um Farben in einem bestimmten Teil des Bilds selektiv zu ändern.

Eine Klasse, die häufig mit canvas verwendet wird, ist die Paint-Klasse . Diese Klasse enthält Farb- und Stilinformationen zum Zeichnen. Es wird verwendet, um Dinge wie Eine Farbe und Transparenz zu bieten.

Die Canvas-API verwendet das Modell des Malers , um 2D-Grafiken zu zeichnen. Vorgänge werden in aufeinander folgenden Ebenen übereinander angewendet. Jeder Vorgang deckt einen Bereich der zugrunde liegenden Bitmap ab. Wenn der Bereich einen zuvor bemalten Bereich überlappt, verdeckt die neue Farbe die alte teilweise oder vollständig. Dies ist die gleiche Weise wie viele andere Zeichnungs-APIs wie System.Drawing und die Kerngrafiken von iOS.

Es gibt zwei Möglichkeiten, ein Canvas -Objekt abzurufen. Die erste Möglichkeit besteht darin, ein Bitmap-Objekt zu definieren und dann ein Canvas -Objekt damit zu instanziieren. Der folgende Codeausschnitt erstellt beispielsweise eine neue Canvas mit einer zugrunde liegenden Bitmap:

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

Die andere Möglichkeit, ein Canvas Objekt abzurufen, ist die OnDraw-Rückrufmethode , die die View-Basisklasse bereitgestellt wird. Android ruft diese Methode auf, wenn es entscheidet, dass eine Ansicht sich selbst zeichnen muss, und übergibt ein Canvas Objekt, damit die Ansicht funktioniert.

Die Canvas-Klasse macht Methoden verfügbar, um die Zeichnungsanweisungen programmgesteuert bereitzustellen. Beispiel:

Canvas.DrawPaint : Füllt die Bitmap der gesamten Canvas mit der angegebenen Farbe aus.
Canvas.DrawPath : Zeichnet die angegebene geometrische Form mit der angegebenen Farbe.
Canvas.DrawText : Zeichnet den Text auf der Canvas mit der angegebenen Farbe. Der Text wird an der Position x,y gezeichnet.

Zeichnen mit der Canvas-API

Hier sehen Sie ein Beispiel für die Canvas-API in Aktion. Der folgende Codeausschnitt zeigt, wie eine Ansicht gezeichnet wird:

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

Mit diesem obigen Code werden zunächst eine rote Farbe und ein grünes Paint-Objekt erstellt. Es füllt den Inhalt der Canvas mit rot auf und weist dann die Canvas an, ein grünes Rechteck zu zeichnen, das 25 % der Breite der Canvas beträgt. Ein Beispiel hierfür finden Sie in AnimationsDemo einem Projekt, das im Quellcode für diesen Artikel enthalten ist. Wenn Sie die Anwendung starten und im Menü Standard das Element Zeichnung auswählen, sollten Sie einen Bildschirm ähnlich dem folgenden anzeigen:

Animation

Benutzer mögen Dinge, die sich in ihren Anwendungen bewegen. Animationen sind eine hervorragende Möglichkeit, die Benutzererfahrung einer Anwendung zu verbessern und dabei zu helfen, sich hervorzuheben. Die besten Animationen sind diejenigen, die Benutzer nicht bemerken, weil sie sich natürlich fühlen. Android stellt die folgenden drei APIs für Animationen bereit:

Animation anzeigen : Dies ist die ursprüngliche API. Diese Animationen sind an eine bestimmte Ansicht gebunden und können einfache Transformationen für den Inhalt der Ansicht ausführen. Aufgrund der Einfachheit ist diese API immer noch nützlich für Alphaanimationen, Drehungen usw.
Eigenschaftenanimation : Eigenschaftenanimationen wurden in Android 3.0 eingeführt. Sie ermöglichen es einer Anwendung, fast alles zu animieren. Eigenschaftenanimationen können verwendet werden, um jede Eigenschaft eines beliebigen Objekts zu ändern, auch wenn dieses Objekt auf dem Bildschirm nicht sichtbar ist.
Zeichnungsfähige Animation : Dies ist eine spezielle Drawable-Ressource, die verwendet wird, um einen sehr einfachen Animationseffekt auf Layouts anzuwenden.

Im Allgemeinen ist die Animation von Eigenschaften das bevorzugte System, da sie flexibler ist und mehr Funktionen bietet.

Animationen anzeigen

Anzeigeanimationen sind auf Ansichten beschränkt und können Animationen nur für Werte wie Start- und Endpunkte, Größe, Drehung und Transparenz ausführen. Diese Arten von Animationen werden in der Regel als Tweenanimationen bezeichnet. Anzeigeanimationen können auf zwei Arten definiert werden: programmgesteuert im Code oder mithilfe von XML-Dateien. XML-Dateien sind die bevorzugte Methode zum Deklarieren von Ansichtsanimationen, da sie besser lesbar und einfacher zu verwalten sind.

Die XML-Animationsdateien werden im /Resources/anim Verzeichnis eines Xamarin.Android-Projekts gespeichert. Diese Datei muss eines der folgenden Elemente als Stammelement aufweisen:

alpha – Eine Einblend- oder Ausblendanimation.
rotate – Eine Drehungsanimation.
scale – Eine Animation zum Ändern der Größe.
translate – Eine horizontale und/oder vertikale Bewegung.
set – Ein Container, der eines oder mehrere der anderen Animationselemente enthalten kann.

Standardmäßig werden alle Animationen in einer XML-Datei gleichzeitig angewendet. Legen Sie das Attribut für eines der android:startOffset oben definierten Elemente fest, damit Animationen sequenziell ausgeführt werden.

Es ist möglich, die Änderungsrate in einer Animation mithilfe eines Interpolators zu beeinflussen. Ein Interpolator ermöglicht es, Animationseffekte zu beschleunigen, zu wiederholen oder zu verlangsamen. Das Android-Framework bietet standardmäßig mehrere Interpolatoren, z. B. (aber nicht beschränkt auf):

AccelerateInterpolator / DecelerateInterpolator – Diese Interpolatoren erhöhen oder verringern die Änderungsrate in einer Animation.
BounceInterpolator – die Änderung springt am Ende.
LinearInterpolator – die Rate der Änderungen ist konstant.

Der folgende XML-Code zeigt ein Beispiel für eine Animationsdatei, die einige dieser Elemente kombiniert:

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

Diese Animation führt alle Animationen gleichzeitig aus. Mit der ersten Skalierungsanimation wird das Bild horizontal gestreckt und vertikal verkleinert, und dann wird das Bild gleichzeitig um 45 Grad gegen den Uhrzeigersinn gedreht und verkleinert, wodurch es vom Bildschirm verschwindet.

Die Animation kann programmgesteuert auf eine Ansicht angewendet werden, indem die Animation aufgeblasen und dann auf eine Ansicht angewendet wird. Android stellt die Hilfsklasse Android.Views.Animations.AnimationUtils bereit, die eine Animationsressource aufblähen und eine instance von Android.Views.Animations.Animationzurückgibt. Dieses Objekt wird auf eine Ansicht angewendet, indem das Animation -Objekt aufgerufen StartAnimation und übergeben wird. Der folgende Codeausschnitt zeigt ein Beispiel dafür:

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

Nachdem wir nun über ein grundlegendes Verständnis der Funktionsweise von Ansichtsanimationen verfügen, können Sie zu Eigenschaftenanimationen wechseln.

Eigenschaftenanimationen

Eigenschaftenanimatoren sind eine neue API, die in Android 3.0 eingeführt wurde. Sie bieten eine erweiterbarere API, die verwendet werden kann, um jede Eigenschaft für ein beliebiges Objekt zu animieren.

Alle Eigenschaftenanimationen werden von Instanzen der Animator-Unterklasse erstellt. Anwendungen verwenden diese Klasse nicht direkt, sondern eine ihrer Unterklassen:

ValueAnimator : Diese Klasse ist die wichtigste Klasse in der gesamten Eigenschaftenanimations-API. Es berechnet die Werte von Eigenschaften, die geändert werden müssen. Die ViewAnimator aktualisiert diese Werte nicht direkt, sondern löst Ereignisse aus, die zum Aktualisieren animierter Objekte verwendet werden können.
ObjectAnimator : Diese Klasse ist eine Unterklasse von ValueAnimator . Es soll den Prozess der Animierung von Objekten vereinfachen, indem ein Zielobjekt und eine Zu aktualisierende Eigenschaft akzeptiert werden.
AnimationSet : Diese Klasse ist dafür verantwortlich, zu orchestrieren, wie Animationen in Relation zueinander ausgeführt werden. Animationen können gleichzeitig, sequenziell oder mit einer angegebenen Verzögerung zwischen ihnen ausgeführt werden.

Evaluatoren sind spezielle Klassen, die von Animatoren verwendet werden, um die neuen Werte während einer Animation zu berechnen. Android bietet standardmäßig die folgenden Auswertungen:

IntEvaluator : Berechnet Werte für ganzzahlige Eigenschaften.
FloatEvaluator : Berechnet Werte für Float-Eigenschaften.
ArgbEvaluator : Berechnet Werte für Farbeigenschaften.

Wenn es sich bei der animierten Eigenschaft nicht um eine float- int oder -Farbe handelt, können Anwendungen eine eigene Auswertung erstellen, indem sie die ITypeEvaluator Schnittstelle implementieren. (Die Implementierung benutzerdefinierter Evaluatoren geht über den Rahmen dieses Themas hinaus.)

Verwenden von ValueAnimator

Animationen bestehen aus zwei Teilen: Das Berechnen animierter Werte und das anschließende Festlegen dieser Werte für Eigenschaften für ein Objekt. ValueAnimator berechnet nur die Werte, aber es wird nicht direkt für Objekte ausgeführt. Stattdessen werden Objekte in Ereignishandlern aktualisiert, die während der Lebensdauer der Animation aufgerufen werden. Dieses Design ermöglicht es, mehrere Eigenschaften aus einem animierten Wert zu aktualisieren.

Sie erhalten eine instance vonValueAnimator, indem Sie eine der folgenden Factorymethoden aufrufen:

ValueAnimator.OfInt
ValueAnimator.OfFloat
ValueAnimator.OfObject

Danach muss die Dauer des ValueAnimator instance festgelegt sein, und dann kann er gestartet werden. Das folgende Beispiel zeigt, wie Sie einen Wert von 0 bis 1 über eine Zeitspanne von 1000 Millisekunden animieren:

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

Der obige Codeausschnitt ist jedoch nicht sehr nützlich– der Animator wird ausgeführt, aber es gibt kein Ziel für den aktualisierten Wert. Die Animator -Klasse löst das Update-Ereignis aus, wenn sie entscheidet, dass listener über einen neuen Wert informiert werden müssen. Anwendungen können einen Ereignishandler bereitstellen, um auf dieses Ereignis zu reagieren, wie im folgenden Codeausschnitt gezeigt:

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

Nachdem wir nun über ein Verständnis von ValueAnimatorverfügen, erfahren Sie mehr über .ObjectAnimator

Verwenden von ObjectAnimator

ObjectAnimator ist eine Unterklasse von, ViewAnimator die die Timing-Engine und die Wertberechnung von mit der Logik kombiniert, die ValueAnimator zum Verknüpfen von Ereignishandlern erforderlich ist. Erfordert ValueAnimator , dass Anwendungen explizit einen Ereignishandler verknüpfen – ObjectAnimator übernimmt diesen Schritt für uns.

Die API für ObjectAnimator ist der API für ViewAnimatorsehr ähnlich, erfordert jedoch, dass Sie das -Objekt und den Namen der zu aktualisierenden Eigenschaft angeben. Das folgende Beispiel zeigt ein Beispiel für die Verwendung ObjectAnimatorvon :

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

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

Wie Sie aus dem vorherigen Codeausschnitt sehen können, ObjectAnimator kann der Code, der zum Animieren eines Objekts erforderlich ist, reduziert und vereinfacht werden.

Zeichnungsfähige Animationen

Die endgültige Animations-API ist die Api für zeichnungsfähige Animationen. Zeichnungsfähige Animationen laden eine Reihe von Drawable-Ressourcen nacheinander und zeigen sie sequenziell an, ähnlich wie bei einem Flip-it-Cartoon.

Drawable-Ressourcen werden in einer XML-Datei definiert, die ein <animation-list> Element als Stammelement und eine Reihe von <item> Elementen enthält, die jeden Frame in der Animation definieren. Diese XML-Datei wird im /Resource/drawable Ordner der Anwendung gespeichert. Der folgende XML-Code ist ein Beispiel für eine zeichnungsfähige Animation:

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

Diese Animation wird durch sechs Frames ausgeführt. Das android:duration Attribut gibt an, wie lange die einzelnen Frames angezeigt werden. Der nächste Codeausschnitt zeigt ein Beispiel für das Erstellen einer Zeichnungsanimation und deren Starten, wenn der Benutzer auf eine Schaltfläche auf dem Bildschirm klickt:

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

An diesem Punkt haben wir die Grundlagen der Animations-APIs behandelt, die in einer Android-Anwendung verfügbar sind.

Zusammenfassung

In diesem Artikel wurden viele neue Konzepte und APIs vorgestellt, mit denen Sie einer Android-Anwendung einige Grafiken hinzufügen können. Zuerst wurden die verschiedenen 2D-Grafik-APIs erläutert und gezeigt, wie Android es Anwendungen ermöglicht, mithilfe eines Canvas-Objekts direkt auf den Bildschirm zu zeichnen. Wir haben auch einige alternative Techniken gesehen, mit denen Grafiken deklarativ mithilfe von XML-Dateien erstellt werden können. Anschließend haben wir die alten und neuen APIs zum Erstellen von Animationen in Android erläutert.