Introducción de esta sección:
En la sección anterior hicimos un primer estudio de las animaciones de propiedades de Android. Creo que ya no estamos en un estado de conocimiento superficial. En esta sección continuaremos explorando algunos usos más avanzados de las animaciones de propiedades de Android. Como siempre, adjunto los tres artículos del Gran Dios Guo~
El contenido sigue haciendo referencia a los tres artículos mencionados. Bien, comencemos con el contenido de esta sección~
1. Evaluator personalizado
1) Introducción al Evaluator
En la sección anterior,8.4.3 Colección de animaciones de Android: Animación de propiedades - Primer vistazo, el primer paso para usar animaciones es:
Llamar al método estáticoofInt(),ofFloat() oofObject() método estático para crear una instancia de ValueAnimator!
En los ejemplos, hemos usado tanto ofInt como ofFloat, que se utilizan respectivamente para realizar operaciones de animación sobre datos de tipo flotante y entero.
Entonces,ofObject¿()? ¿Objeto inicial y objeto final? ¿Cómo se hace la transición? O mejor dicho, ¿cómo se usa esto?
Bien, con estas dudas, primero vamos a entender una cosa: el Evaluator. En la parte de conceptos de animación de propiedades, en realidad ya mencionamos esto:

Se usa para decirle al sistema de animación cómo hacer la transición del valor inicial al valor final¡Bien, nuestro punto de partida es correcto! Entremos en el código fuente de IntEvaluator y veamos qué hay dentro.

Mmm, implementaTypeEvaluatorla interfaz y luego sobrescribeevaluate()el método. Hay tres parámetros, que son en orden:
- fraction: el grado de finalización de la animación. Según esto calculamos cuál debería ser el valor de la animación.
- startValue: el valor inicial de la animación.
- endValue: el valor final de la animación.
El valor de la animación = valor inicial + grado de finalización * (valor final - valor inicial)
De igual manera, también está FloatEvaluator. Si queremos decirle al sistema cómo pasar del objeto inicial al objeto final, entonces necesitamos implementarlo nosotros mismosTypeEvaluatorla interfaz, es decir, personalizar el Evaluator. Las palabras de más no sirven; escribamos un ejemplo para verlo:
2) Ejemplo de uso
Captura del efecto en ejecución:

Implementación del código:
Definir un objetoPoint.javaque solo tiene dos propiedades, x e y, junto con sus métodos get y 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;
}
}
Luego personalizamos la clase Evaluator:PointEvaluator.javaimplementando la interfaz y sobrescribiendo el método 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;
}
}
Después personalizamos una clase View:AnimView.java, es muy sencillo~
/**
* 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);
}
}
}
Por último,MainActivity.javasolo hay que instanciar esta View~
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(new AnimView(this));
}
}
3) Versión mejorada del ejemplo
Sobre la base del ejemplo anterior, añadimos el cambio de color cuando el círculo se mueve. Aquí usamos además un ObjectAnimator para cargar la animación de cambio de color. Añadimos un campo int color en la View para controlar el color, y también escribimos los métodos getColor() y setColor(). Primero personalicemos un Evaluator~
Captura del efecto en ejecución:

Código de implementación:
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);
}
}
Luego, en la View personalizada añadimos un color y los métodos get y set; creamos un ObjectAnimator y un AnimatorSet, y luego combinamos las animaciones. Eso es todo. Solo añadimos algo aquí; para evitar problemas a los lectores, creemos directamente otra 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();
}
}
Luego en MainActivity, en setContentView, solo hay que cambiar AnimView por AnimView2~
2. Interpolator (interpolador)
Mmm, ya hablamos de esto cuando explicamos las animaciones interpoladas (Tween). ¿Aún lo recuerdas?

Los interpoladores anteriores se pueden usar tanto en animaciones interpoladas como en animaciones de propiedades. Además, las animaciones interpoladas añadieron una nuevaTimeInterpolatorinterfaz. Esta interfaz se usa para ser compatible con el Interpolator anterior, lo que permite que todas las clases de implementación de Interpolator pasadas se puedan usar directamente en las animaciones de propiedades. ¡Podemos llamar al método setInterpolator() del objeto de animación para configurar diferentes interpoladores! Primero cambiemos algo para que la bolita caiga desde la parte superior central de la pantalla hasta la parte inferior. Luego, para nuestra animación de conjunto, llamaremos a la siguiente instrucción:animatorSet.setInterpolator(new AccelerateInterpolator(2f));El valor entre paréntesis se usa para controlar la aceleración~
Efecto en ejecución:

Parece un poco irracional; normalmente debería rebotar, ¿verdad? Cambiemos aBounceInterpolatorpara probar~

Jeje, el efecto es bastante genial. Por supuesto, hay muchísimos Interpolator proporcionados por el sistema; pueden probarlos uno por uno. Aquí no me detendré a discutirlos con ustedes~
A continuación, echemos un vistazo a:
1) Mecanismo de implementación interna de Interpolator
Primero vamos al código fuente de la interfaz TimeInterpolator y descubrimos que solo hay ungetInterpolationmétodo () ;

Una explicación sencilla: El método getInterpolation() recibe un parámetro input. El valor de este parámetro cambia continuamente a medida que la animación se ejecuta. Sin embargo, su cambio es muy regular: aumenta de manera uniforme según la duración de la animación establecida, y el rango de variación es de 0 a 1. Es decir, cuando la animación comienza, el valor de input es 0; cuando la animación termina, el valor de input es 1; y los valores intermedios varían entre 0 y 1 según el tiempo transcurrido de la animación.
Aquí, elinputvalor determina nuestroTypeEvaluatoren la interfazfractiondel valor.getInterpolationEl valor de input es pasado por el sistema, después de ser calculado, al método getInterpolation(). Luego podemos implementar nosotros mismos
el algoritmo en el método (), calcular un valor de retorno según el valor de input, y este valor de retorno es fraction.LinearInterpolatorPodemos echar un vistazo

al código en:BounceInterpolatorAquí no se procesa nada; se devuelve directamente el valor de input, es decir, el valor de fraction es igual al valor de input. Esta es la forma de implementación del Interpolator para movimiento uniforme. En realidad, no es más que una diferencia de algoritmos; esto involucra algunas cosas matemáticas. Una vez más sentimos la importancia de las matemáticas. Aquí pego otro

código fuente:AccelerateDecelerateInterpolator

No me preguntes por el algoritmo de aquí; yo tampoco lo sé. Busquemos uno más fácil de entender:(float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5fEste Interpolator tiene el efecto de primero acelerar y luego desacelerar:
Comprensión del algoritmo de:
Solución: dado que el rango de valores de input es [0,1], se puede deducir que el rango de valores en cos es [π,2π], y los valores correspondientes son -1 y 1. Luego, al dividir este valor por 2 y sumarle 0.5, el rango del valor de retorno final del método getInterpolation() sigue siendo [0,1]. La curva correspondiente es la siguiente:
Por lo tanto, es un proceso de primero acelerar y luego desacelerar.
Mmm, yo, como mal estudiante, ya no puedo seguir...
, todo lo anterior está copiado de los artículos del tío Guo... Quiero estar tranquilo...
2) Interpolator personalizado
Bueno, dejemos la tristeza para después; primero escribamos un ejemplo de Interpolator personalizado. Es muy sencillo: implementar la interfaz TimeInterpolator y sobrescribir el método 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);
}
}
}
El código de ejemplo es el siguiente
3.ViewPropertyAnimator
Solo hay que llamar a setInterpolator(new DecelerateAccelerateInterpolator()) para configurarlo. Debido a limitaciones de espacio, no pego la imagen.
ObjectAnimator animator = ObjectAnimator.ofFloat(textview, "alpha", 0f); animator.start();
Una nueva función añadida al sistema después de 3.1, que proporciona una forma más conveniente para las operaciones de animación de View. Antes, para hacer que un TextView pasara de un estado normal a un estado transparente, se escribía así:
textview.animate().alpha(0f);
Mientras que usar ViewPropertyAnimator para lograr el mismo efecto resulta más fácil de entender:También admiteuso encadenado, combinar múltiples animaciones, establecer la duración, configurar Interpolator, etc.~
textview.animate().x(500).y(500).setDuration(5000)
.setInterpolator(new BounceInterpolator());
El uso es muy sencillo; solo consulta la documentación cuando lo uses. Además, hay varios detalles a tener en cuenta a continuación.
- Toda la funcionalidad de ViewPropertyAnimator se basa en el nuevo método animate() añadido a la clase View. Este método crea y devuelve una instancia de ViewPropertyAnimator. Todos los métodos llamados posteriormente y todas las propiedades configuradas se completan a través de esta instancia.
- Usar ViewPropertyAnimatorDespués de que se complete la definición de la animación, la animación seiniciará automáticamente.start() método para iniciar la animación.
- Todas las interfaces de ViewPropertyAnimator están diseñadas con sintaxis encadenada, el valor de retorno de cada método esuna instancia de sí mismo, por lo tanto, después de llamar a un método, se puede encadenar directamente la llamada a otro método de la misma instancia, conectando así todas las funciones; incluso podemos completar animaciones de cualquier complejidad con una sola línea de código.
4. Descarga del código de ejemplo de esta sección
AnimatorDemo3.zip
En Github encontré un proyecto de colección de animaciones, tiene muchos efectos de animación. Aquí está la dirección:
BaseAnimation colección de animaciones
Si quieres investigar cómo se implementan varias animaciones, puedes ver el código fuente tú mismo~
Resumen de esta sección
Bueno, en esta sección hemos hablado de cosas un poco más avanzadas como Evaluator, Interpolator y ViewPropertyAnimator, ¿no hemos ampliado nuestros conocimientos? Esta es también la última subsección del dibujo y animación de la introducción básica a Android. Si dominan el contenido de este capítulo, luego al aprender controles personalizados, o al ver controles personalizados escritos por otros, ya no deberían sentirse tan perdidos sin saber por dónde empezar, ¡ni encontrarse con un montón de caras nuevas!
Bueno, gracias al artículo de Guo Shen; el contenido de la parte de animación de propiedades fue en su mayoría tomado directamente de Guo Shen.
Jeje~ Esto es todo por esta sección, ¡gracias~
PD: Las figuras posteriores usan un emulador porque el N5 estaba fallando...
Jeje~ Esto es todo por esta sección, ¡gracias~