Introduction de la section :

Dans la section précédente, nous avons fait une étude préliminaire de l'animation de propriétés Android. Je pense que vous n'êtes plus dans un état de demi-compréhension. Dans cette section, nous continuons à explorer quelques usages plus avancés de l'animation de propriétés Android ! Comme d'habitude, voici les trois articles du Maître Guo~

Analyse complète de l'animation de propriétés Android (Partie 1), premier aperçu de l'utilisation de base de l'animation de propriétés

Analyse complète de l'animation de propriété Android (Partie 2), Utilisation avancée de ValueAnimator et ObjectAnimator

Analyse complète de l'animation de propriété Android (Partie 3), Utilisation d'Interpolator et de ViewPropertyAnimator

Le contenu est toujours basé sur les trois articles ci-dessus. Bon, commençons cette section~


1. Evaluator personnalisé

1) Introduction à Evaluator

Dans la section précédente,8.4.3 Collection d'animations Android : Animation de propriétés - Première rencontre, la première étape de l'utilisation d'une animation est :

Appelez la méthode statiqueofInt(),ofFloatofInt() ouofObjectofFloat() de ValueAnimator pour créer une instance de ValueAnimator !

Dans les exemples, nous avons utilisé à la fois ofInt et ofFloat, respectivement utilisés pour animer des données entières et à virgule flottante !

EnsuiteofObjectofObject() ? L'objet initial et l'objet final ? Comment la transition fonctionne-t-elle ? Ou comment cette chose est-elle utilisée ?

Bon, avec ces questions, commençons par comprendre quelque chose : Evaluator. Nous avons en fait parlé de cette chose lorsque nous divaguions sur les concepts d'animation de propriétés :

utilisé pour indiquer au système d'animation comment effectuer la transition de la valeur initiale vers la valeur finale !Bien, notre point de départ est correct ! Entrons dans le code source d'IntEvaluator et voyons ce qu'il contient ?

Eh bien, il implémente l'TypeEvaluatorTypeEvaluator interface, puis redéfinit laevaluate()evaluate méthode. Il y a trois paramètres, dans l'ordre :

  • fraction: le degré d'achèvement de l'animation. Nous calculons la valeur de l'animation en fonction de celui-ci.
  • startValue: la valeur de début de l'animation.
  • endValue: la valeur de fin de l'animation.

Valeur d'animation = valeur initiale + degré d'achèvement * (valeur finale - valeur initiale)

De même, il existe FloatEvaluator. Si nous voulons indiquer au système comment effectuer la transition de l'objet initial vers l'objet final, alors nous devons l'implémenter nous-mêmes.TypeEvaluatorinterface, c'est-à-dire un Evaluator personnalisé. Les mots sont inutiles, écrivons un exemple pour voir :

2) Exemple d'utilisation

Capture d'écran de l'effet d'exécution:

Implémentation du code:

Définissez un objetPoint.java, l'objet possède seulement deux propriétés, x et y, plus les méthodes get et set~

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

Définissez ensuite une classe Evaluator personnalisée :PointEvaluator.java, implémentez l'interface et redéfinissez la méthode evaluate~

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

Définissez ensuite une classe View personnalisée :AnimView.java, très simple~

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

EnfinMainActivity.javail suffit d'instancier cette View à l'emplacement~

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

3) Version améliorée de l'exemple

En vous basant sur l'exemple ci-dessus, ajoutez des changements de couleur pendant que le cercle se déplace. Ici, nous utilisons en plus un ObjectAnimator pour charger l'animation de changement de couleur. Nous ajoutons un int color dans la View pour contrôler la couleur, et écrivons aussi les méthodes getColor() et setColor(). Commençons par définir un Evaluator personnalisé~

Capture d'écran de l'effet d'exécution:

Code d'implémentation:

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

Ensuite, ajoutez une couleur, les méthodes get et set dans la View personnalisée ; créez un ObjectAnimator et un AnimatorSet, puis combinez les animations ensemble. C'est tout. Pour éviter des problèmes aux lecteurs, créons simplement une autre classe View~

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

Ensuite, dans MainActivity, au niveau de setContentView, remplacez simplement AnimView par AnimView2~


2. Interpolator (Tween)

Bon, nous avons déjà parlé de ce truc quand nous discutions de l'animation tween~ Vous vous en souvenez encore ?

Les interpolateurs ci-dessus sont disponibles à la fois pour l'animation tween et l'animation de propriétés, et l'animation de propriétés a aussi ajouté une nouvelle interfaceTimeInterpolator. Cette interface sert à assurer la compatibilité avec l'Interpolator précédent, donc toutes les anciennes classes d'implémentation d'Interpolator peuvent être directement reprises et utilisées dans l'animation de propriétés ! Nous pouvons appeler la méthode setInterpolator() de l'objet d'animation pour définir différents Interpolators ! D'abord, modifions quelque chose pour que la balle tombe du centre supérieur de l'écran vers le bas. Ensuite, nous appellerons l'instruction suivante pour notre animation combinée :animatorSet.setInterpolator(new AccelerateInterpolator(2f));La valeur entre parenthèses sert à contrôler l'accélération~

Effet d'exécution:

Cela semble un peu déraisonnable. Normalement, ça devrait rebondir, non ? Passons àBounceInterpolatorpour essayer~

Héhé, l'effet est plutôt sympa. Bien sûr, il existe aussi beaucoup d'Interpolators fournis par le système. Vous pouvez les essayer un par un. Je ne vais pas m'embêter à les passer en revue lentement ici~

Ensuite, jetons un coup d'œil :

1) Le mécanisme d'implémentation interne de l'Interpolator

Allons dans le code source de l'interface TimeInterpolator et constatons qu'il n'y a qu'une seule méthodegetInterpolationgetInterpolation() ;

Explication simpleLa méthode getInterpolation() reçoit un paramètre d'entrée. La valeur de ce paramètre change continuellement pendant l'exécution de l'animation, mais son changement est très régulier : elle augmente uniformément selon la durée d'animation définie, avec une plage de variation de 0 à 1. C'est-à-dire que, lorsque l'animation commence, la valeur de input est 0 ; lorsqu'elle se termine, la valeur de input est 1 ; et les valeurs intermédiaires varient entre 0 et 1 au fur et à mesure de l'exécution de l'animation.

Ici,inputla valeur détermine notreTypeEvaluatorl'interface TypeEvaluator dont lafractionvaleur de fraction.getInterpolationLa valeur de input est calculée par le système et transmise à la méthode getInterpolation(), puis nous pouvons implémenter

l'algorithme dans la méthode getInterpolation(). En fonction de la valeur de input, calculez une valeur de retour, et cette valeur de retour est fraction.LinearInterpolatorNous pouvons regarder

le code à l'intérieur :BounceInterpolatorIci, il renvoie directement la valeur input sans aucun traitement, c'est-à-dire que la valeur de fraction est égale à la valeur de input. C'est ainsi qu'est implémenté un Interpolator à mouvement uniforme ! En fait, ce n'est rien de plus que différents algorithmes, ce qui implique un peu de mathématiques. Une fois de plus, nous réalisons l'importance des mathématiques. Ici, je vais aussi publier le

code source :AccelerateDecelerateInterpolator

Ne me demandez pas l'algorithme ici, je ne le connais pas non plus. Trouvons-en un plus facile à comprendre :(float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5fCet Interpolator a pour effet d'accélérer d'abord, puis de décélérer :

Comprendre l'algorithme :

Solution : Puisque la plage de valeurs de l'entrée est [0,1], on peut en conclure que la valeur à l'intérieur de cos a une plage de [π,2π], et les valeurs correspondantes sont -1 et 1 ; après avoir divisé cette valeur par 2 et ajouté 0.5, le résultat final renvoyé par getInterpolation() est toujours dans la plage [0,1]. La courbe correspondante est la suivante :

C'est donc un processus d'accélération puis de décélération !Bon, en tant que cancre, je ne peux plus jouer...

Tout ce qui précède est copié de l'article d'Oncle Guo... Je veux être seul un moment...

2) Interpolateur personnalisé

Bon, soyons tristes plus tard. D'abord, écrivons un exemple d'Interpolateur personnalisé : C'est très simple. Implémentez l'interface TimeInterpolator et redéfinissez la méthode 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);
        }
    }
}

L'exemple de code est le suivant


3.ViewPropertyAnimator

Appelez simplement setInterpolator(new DecelerateAccelerateInterpolator()) pour le définir. En raison de limitations d'espace, je ne publierai pas la capture d'écran~

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

Une nouvelle fonctionnalité ajoutée au système après la 3.1, offrant une utilisation plus pratique pour les opérations d'animation de View ! Si auparavant, pour faire passer un TextView d'un état normal à un état transparent, vous écriviez :

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

Mais utiliser ViewPropertyAnimator pour obtenir le même effet est plus compréhensible :Il prend également en chargel'utilisation chaînée

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

, en combinant plusieurs animations, en définissant la durée, en définissant l'Interpolator, etc~

  • L'utilisation est très simple. Consultez simplement la documentation lors de son utilisation. De plus, il y a quelques détails à noter ci-dessous !
  • Toute la fonctionnalité de ViewPropertyAnimator repose sur la nouvelle méthode animate() ajoutée à la classe View. Cette méthode crée et renvoie une instance de ViewPropertyAnimator. Tous les appels de méthode suivants et tous les réglages de propriétés sont effectués via cette instance.Une fois la définition de l'animation terminée, l'animation vadémarrer automatiquement.démarrerla méthode () pour lancer l'animation.
  • Toutes les interfaces de ViewPropertyAnimator sont conçues avec une syntaxe de chaînage, et la valeur de retour de chaque méthode estsa propre instance, donc après avoir appelé une méthode, vous pouvez directement enchaîner une autre méthode, reliant toutes les fonctionnalités ensemble ; nous pouvons même réaliser une animation de complexité arbitraire avec une seule ligne de code.

4. Téléchargez le code d'exemple de cette section

AnimatorDemo3.zip

Sur Github, j'ai trouvé un projet de collections d'animations, qui contient de nombreux effets d'animation. Voici l'adresse :

Collection d'animations BaseAnimation

Si vous voulez étudier comment diverses animations sont implémentées, vous pouvez consulter le code source vous-même~


Résumé de la section

Eh bien, dans cette section, nous avons parlé de quelques choses un peu plus avancées : Evaluator, Interpolator et ViewPropertyAnimator. Cela n'a-t-il pas élargi les horizons de tout le monde~ Cette section est aussi la dernière sous-section de l'introduction aux bases Android pour le dessin et les contrôles personnalisés. Si vous avez maîtrisé le contenu de ce chapitre, alors lorsque vous passerez à l'apprentissage des contrôles personnalisés, ou que vous regarderez des contrôles personnalisés écrits par d'autres, vous ne devriez plus être aussi perdu sur par où commencer, ni tomber sur une multitude de termes inconnus !

Eh bien, merci encore à l'article de Guo Shen ; la plupart du contenu sur l'animation de propriétés a été repris directement de Guo Shen.Héhé~ c'est tout pour cette section, merci~

PS : Les captures d'écran suivantes utilisent un émulateur parce que mon N5 faisait des siennes...