Abschnittseinführung:

Im vorherigen Abschnitt haben wir die Android-Property-Animation vorläufig kennengelernt. Ich glaube, du bist nicht mehr nur halb im Bilde. In diesem Abschnitt erkunden wir weiter einige fortgeschrittenere Verwendungsweisen der Android-Property-Animation! Wie üblich sind hier die drei Artikel von Meister Guo~

Vollständige Analyse der Android-Property-Animation (Teil 1), Erster Blick auf die grundlegende Verwendung der Property-Animation

Vollständige Analyse der Android-Property-Animation (Teil 2), Fortgeschrittene Verwendung von ValueAnimator und ObjectAnimator

Vollständige Analyse der Android-Property-Animation (Teil 3), Verwendung von Interpolator und ViewPropertyAnimator

Der Inhalt basiert weiterhin auf den oben genannten drei Artikeln. Okay, beginnen wir mit diesem Abschnitt~


1. Benutzerdefinierter Evaluator

1) Einführung in den Evaluator

Im vorherigen Abschnitt,8.4.3 Android-Animationssammlung: Property-Animation – erste Begegnung, ist der erste Schritt bei der Verwendung von Animationen:

Rufe die statische Methode von ValueAnimator auf:ofInt(),ofFloatofInt() oderofObjectofFloat(), um eine ValueAnimator-Instanz zu erstellen!

In den Beispielen haben wir sowohl ofInt als auch ofFloat verwendet, die jeweils für die Animation von Ganzzahl- und Gleitkommadaten verwendet werden!

DannofObjectofObject()? Das Anfangsobjekt und das Endobjekt? Wie funktioniert der Übergang? Oder wie wird dieses Ding verwendet?

Okay, mit diesen Fragen wollen wir zuerst etwas verstehen: den Evaluator. Wir haben tatsächlich über dieses Ding gesprochen, als wir über die Konzepte der Property-Animation plauderten:

wird verwendet, um dem Animationssystem mitzuteilen, wie vom Anfangswert zum Endwert übergegangen wird!Gut, unser Ausgangspunkt ist richtig! Sehen wir uns den Quellcode von IntEvaluator an und schauen, was darin steckt?

Nun, es implementiert dasTypeEvaluatorTypeEvaluator-Interface und überschreibt dann dieevaluate()evaluate-Methode. Es gibt drei Parameter, und zwar in dieser Reihenfolge:

  • fraction: der Abschlussgrad der Animation. Wir berechnen daraus, welchen Animationswert sie haben sollte.
  • startValue: der Startwert der Animation.
  • endValue: der Endwert der Animation.

Animationswert = Anfangswert + Abschlussgrad * (Endwert - Anfangswert)

Ähnlich gibt es FloatEvaluator. Wenn wir dem System sagen wollen, wie es vom initialen Objekt zum Endobjekt übergehen soll, dann müssen wir es selbst implementieren.TypeEvaluator-Interface, also einen benutzerdefinierten Evaluator. Worte sind nutzlos, schreiben wir ein Beispiel, um es zu sehen:

2) Anwendungsbeispiel

Screenshot des Laufeffekts:

Code-Implementierung:

Definiere ein ObjektPoint.java, das Objekt hat nur zwei Eigenschaften, x und y, plus get- und set-Methoden~

/**
 * Created by Jay on 2015/11/18 0018.
 */
public class Point {

    private float x;
    private float y;

    public Point() {
    }

    public Point(float x, float y) {
        this.x = x;
        this.y = y;
    }

    public float getX() {
        return x;
    }

    public float getY() {
        return y;
    }

    public void setX(float x) {
        this.x = x;
    }

    public void setY(float y) {
        this.y = y;
    }
}

Definiere dann eine benutzerdefinierte Evaluator-Klasse:PointEvaluator.java, implementiere das Interface und überschreibe die evaluate-Methode~

/**
 * Created by Jay on 2015/11/18 0018.
 */
public class PointEvaluator implements TypeEvaluator<Point>{
    @Override
    public Point evaluate(float fraction, Point startValue, Point endValue) {
        float x = startValue.getX() + fraction * (endValue.getX() - startValue.getX());
        float y = startValue.getY() + fraction * (endValue.getY() - startValue.getY());
        Point point = new Point(x, y);
        return point;
    }
}

Definiere dann eine benutzerdefinierte View-Klasse:AnimView.java, sehr einfach~

/**
 * Created by Jay on 2015/11/18 0018.
 */
public class AnimView extends View {

    public static final float RADIUS = 80.0f;
    private Point currentPoint;
    private Paint mPaint;

    public AnimView(Context context) {
        this(context, null);
    }

    public AnimView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public AnimView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.BLUE);
    }

    private void drawCircle(Canvas canvas){
        float x = currentPoint.getX();
        float y = currentPoint.getY();
        canvas.drawCircle(x, y, RADIUS, mPaint);
    }

    private void startAnimation() {
        Point startPoint = new Point(RADIUS, RADIUS);
        Point endPoint = new Point(getWidth() - RADIUS, getHeight() - RADIUS);
        ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                currentPoint = (Point) animation.getAnimatedValue();
                invalidate();
            }
        });
        anim.setDuration(3000l);
        anim.start();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (currentPoint == null) {
            currentPoint = new Point(RADIUS, RADIUS);
            drawCircle(canvas);
            startAnimation();
        } else {
            drawCircle(canvas);
        }
    }
}

Zum SchlussMainActivity.javaeinfach diese View an der Stelle instanziieren~

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new AnimView(this));
    }
}

3) Erweiterte Version des Beispiels

Basierend auf dem obigen Beispiel fügen wir Farbänderungen hinzu, während sich der Kreis bewegt. Hier verwenden wir zusätzlich einen ObjectAnimator, um die Farbänderungsanimation zu laden. Wir fügen im View ein int color hinzu, um die Farbe zu steuern, und schreiben außerdem die Methoden getColor() und setColor(). Definieren wir zuerst einen benutzerdefinierten Evaluator~

Screenshot des Laufeffekts:

Implementierungscode:

ColorEvaluator.java:

/**
 * Created by Jay on 2015/11/18 0018.
 */
public class ColorEvaluator implements TypeEvaluator<Integer>{
    @Override
    public Integer evaluate(float fraction, Integer startValue, Integer endValue) {
        int alpha = (int) (Color.alpha(startValue) + fraction *
                (Color.alpha(endValue) - Color.alpha(startValue)));
        int red = (int) (Color.red(startValue) + fraction *
                (Color.red(endValue) - Color.red(startValue)));
        int green = (int) (Color.green(startValue) + fraction *
                (Color.green(endValue) - Color.green(startValue)));
        int blue = (int) (Color.blue(startValue) + fraction *
                (Color.blue(endValue) - Color.blue(startValue)));
        return Color.argb(alpha, red, green, blue);
    }
}

Dann fügen wir im benutzerdefinierten View eine Farbe sowie get- und set-Methoden hinzu; erstellen einen ObjectAnimator und ein AnimatorSet und kombinieren dann die Animationen miteinander. Das ist alles. Um Probleme für Leser zu vermeiden, erstellen wir einfach eine weitere View-Klasse~

AnimView2.java:

/**
 * Created by Jay on 2015/11/18 0018.
 */
public class AnimView2 extends View {

    public static final float RADIUS = 80.0f;
    private Point currentPoint;
    private Paint mPaint;
    private int mColor;

    public AnimView2(Context context) {
        this(context, null);
    }

    public AnimView2(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public AnimView2(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.BLUE);
    }



    private void drawCircle(Canvas canvas){
        float x = currentPoint.getX();
        float y = currentPoint.getY();
        canvas.drawCircle(x, y, RADIUS, mPaint);
    }

    private void startAnimation() {
        Point startPoint = new Point(RADIUS, RADIUS);
        Point endPoint = new Point(getWidth() - RADIUS, getHeight() - RADIUS);
        ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                currentPoint = (Point) animation.getAnimatedValue();
                invalidate();
            }
        });

        ObjectAnimator objectAnimator = ObjectAnimator.ofObject(this, "color", new ColorEvaluator(),
                Color.BLUE, Color.RED);
        //动画集合将前面两个动画加到一起,with同时播放
        AnimatorSet animatorSet = new AnimatorSet();
        animatorSet.play(anim).with(objectAnimator);
        animatorSet.setStartDelay(1000l);
        animatorSet.setDuration(3000l);
        animatorSet.start();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (currentPoint == null) {
            currentPoint = new Point(RADIUS, RADIUS);
            drawCircle(canvas);
            startAnimation();
        } else {
            drawCircle(canvas);
        }
    }

    //color的get和set方法~
    public int getColor() {
        return mColor;
    }

    public void setColor(int color) {
        mColor = color;
        mPaint.setColor(color);
        invalidate();
    }
}

Dann ändern wir in MainActivity bei setContentView einfach AnimView zu AnimView2~


2. Interpolator (Tween)

Nun, wir haben über dieses Ding bereits gesprochen, als wir die Tween-Animation besprochen haben~ Hast du es noch in Erinnerung?

Die obigen Interpolatoren sind sowohl für Tween-Animation als auch für Property-Animation verfügbar, und Property-Animation hat außerdem eine neueTimeInterpolatorSchnittstelle hinzugefügt. Diese Schnittstelle dient zur Kompatibilität mit dem vorherigen Interpolator, sodass alle bisherigen Interpolator-Implementierungsklassen direkt übernommen und in der Property-Animation verwendet werden können! Wir können die Methode setInterpolator() des Animationsobjekts aufrufen, um verschiedene Interpolatoren festzulegen! Ändern wir zuerst etwas, damit der Ball von der oberen Mitte des Bildschirms nach unten fällt. Dann rufen wir für unsere kombinierte Animation die folgende Anweisung auf:animatorSet.setInterpolator(new AccelerateInterpolator(2f));Der Wert in den Klammern wird verwendet, um die Beschleunigung zu steuern~

Ausführungseffekt:

Das erscheint etwas unvernünftig. Normalerweise sollte es springen, oder? Wechseln wir zuBounceInterpolatorund probieren es aus~

Hehe, der Effekt ist ziemlich nett. Natürlich gibt es auch viele vom System bereitgestellte Interpolatoren. Du kannst sie nacheinander ausprobieren. Ich werde sie hier nicht langsam durchgehen~

Schauen wir uns als Nächstes Folgendes an:

1) Der interne Implementierungsmechanismus von Interpolator

Gehen wir zum Quellcode der TimeInterpolator-Schnittstelle und stellen fest, dass es nur einegetInterpolationgetInterpolation()-Methode gibt;

Einfache ErklärungDie getInterpolation()-Methode erhält einen input-Parameter. Der Wert dieses Parameters ändert sich kontinuierlich, während die Animation läuft, aber seine Änderung ist sehr regelmäßig: Er steigt gleichmäßig entsprechend der festgelegten Animationsdauer an, mit einem Änderungsbereich von 0 bis 1. Das heißt, wenn die Animation startet, ist der Wert von input 0; wenn die Animation endet, ist der Wert von input 1; und die Zwischenwerte ändern sich zwischen 0 und 1, während die Animation läuft.

Hier bestimmt derinput-Wert unserenTypeEvaluatorTypeEvaluator-Schnittstellefractionfraction-Wert.getInterpolationDer Wert von input wird vom System berechnet und an die getInterpolation()-Methode übergeben, und dann können wir

den Algorithmus in der getInterpolation()-Methode implementieren. Basierend auf dem Wert von input wird ein Rückgabewert berechnet, und dieser Rückgabewert ist fraction.LinearInterpolatorWir können uns

den Code darin ansehen:BounceInterpolatorHier wird direkt der input-Wert ohne jegliche Verarbeitung zurückgegeben, das heißt, der Wert von fraction ist gleich dem Wert von input. So wird ein Interpolator für gleichförmige Bewegung implementiert! Eigentlich ist es nichts weiter als unterschiedliche Algorithmen, was etwas Mathematik beinhaltet. Wieder einmal erkennen wir die Bedeutung der Mathematik. Hier poste ich auch noch den

Quellcode:AccelerateDecelerateInterpolator

Fragt mich hier nicht nach dem Algorithmus, ich kenne ihn auch nicht. Suchen wir einen, der leichter zu verstehen ist:(float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5fDieser Interpolator hat den Effekt, zuerst zu beschleunigen und dann zu verlangsamen:

Den Algorithmus verstehen:

Lösung: Da der Wertebereich der Eingabe [0,1] ist, kann man schlussfolgern, dass der Wert innerhalb von cos einen Bereich von [π,2π] hat, und die entsprechenden Werte sind -1 und 1; nachdem man diesen Wert durch 2 geteilt und 0.5 addiert hat, liegt das von getInterpolation() zurückgegebene Endergebnis immer noch im Bereich [0,1]. Die entsprechende Kurve sieht wie folgt aus:

Es ist also ein Prozess, der zuerst beschleunigt und dann abbremst!Nun ja, als Lernmuffel kann ich nicht mehr weiterspielen...

Das Obige ist alles aus Onkel Guos Artikel kopiert... Ich möchte eine Weile allein sein...

2) Benutzerdefinierter Interpolator

Nun, traurig sein können wir später. Schreiben wir zuerst ein Beispiel für einen benutzerdefinierten Interpolator: Es ist ganz einfach. Implementiere das TimeInterpolator-Interface und überschreibe die Methode getInterpolation.

private class DecelerateAccelerateInterpolator implements TimeInterpolator {
    @Override
    public float getInterpolation(float input) {
        if (input < 0.5) {
            return (float) (Math.sin(input * Math.PI) / 2);
        } else {
            return 1 - (float) (Math.sin(input * Math.PI) / 2);
        }
    }
}

Der Beispielcode sieht wie folgt aus


3.ViewPropertyAnimator

Rufe einfach setInterpolator(new DecelerateAccelerateInterpolator()) auf, um ihn festzulegen. Aus Platzgründen poste ich den Screenshot nicht~

ObjectAnimator animator = ObjectAnimator.ofFloat(textview, "alpha", 0f);  
animator.start();

Ein neues Feature, das dem System nach 3.1 hinzugefügt wurde und eine bequemere Verwendung für View-Animationsoperationen bietet! Wenn man früher ein TextView vom normalen Zustand in den transparenten Zustand versetzen wollte, schrieb man:

textview.animate().alpha(0f); 

Aber mit ViewPropertyAnimator denselben Effekt zu erzielen, ist verständlicher:Er unterstützt außerdemverkettete Verwendung

textview.animate().x(500).y(500).setDuration(5000)  
        .setInterpolator(new BounceInterpolator());

, Kombinieren mehrerer Animationen, Festlegen der Dauer, Festlegen des Interpolators usw.~

  • Die Verwendung ist sehr einfach. Schau bei der Benutzung einfach in die Dokumentation. Außerdem gibt es unten ein paar Details zu beachten!
  • Die gesamte Funktionalität von ViewPropertyAnimator basiert auf der neuen animate()-Methode, die der View-Klasse hinzugefügt wurde. Diese Methode erstellt eine ViewPropertyAnimator-Instanz und gibt sie zurück. Alle nachfolgenden Methodenaufrufe und alle Eigenschaftseinstellungen werden über diese Instanz abgeschlossen.Nachdem die Animationsdefinition abgeschlossen ist, wird die Animationautomatisch starten.; starten Siedie ()-Methode, um die Animation zu starten.
  • Alle Schnittstellen von ViewPropertyAnimator sind mit Verkettungssyntax entworfen, und der Rückgabewert jeder Methode istihre eigene Instanz, sodass Sie nach dem Aufruf einer Methode direkt eine weitere Methode verketten können, wodurch alle Funktionen miteinander verbunden werden; wir können sogar eine Animation beliebiger Komplexität mit nur einer Codezeile bewerkstelligen.

4. Beispielcode für diesen Abschnitt herunterladen

AnimatorDemo3.zip

Auf Github habe ich ein Projekt mit Animationssammlungen gefunden, das viele Animationseffekte enthält. Hier ist die Adresse:

BaseAnimation-Animationssammlung

Wenn Sie untersuchen möchten, wie verschiedene Animationen implementiert werden, können Sie sich den Quellcode selbst ansehen~


Abschnittszusammenfassung

Nun, in diesem Abschnitt haben wir über einige etwas fortgeschrittenere Dinge gesprochen: Evaluator, Interpolator und ViewPropertyAnimator. Hat das nicht den Horizont aller erweitert~ Dieser Abschnitt ist auch der letzte Unterabschnitt der Android-Grundlagen-Einführung in das Zeichnen und benutzerdefinierte Steuerelemente. Wenn Sie den Inhalt dieses Kapitels beherrschen, dann sollten Sie, wenn Sie mit dem Erlernen benutzerdefinierter Steuerelemente fortfahren oder von anderen geschriebene benutzerdefinierte Steuerelemente ansehen, nicht mehr so ratlos sein, wo Sie anfangen sollen, oder auf eine Menge unbekannter Begriffe stoßen!

Nun, nochmals vielen Dank an Guo Shens Artikel; der größte Teil des Inhalts zur Property-Animation wurde direkt von Guo Shen übernommen.Hehe~ das war alles für diesen Abschnitt, danke~

PS: Die späteren Screenshots verwenden einen Emulator, weil mein N5 herumgesponnen hat...