Introducción de esta sección:
Esta sección trae la segunda de las tres animaciones de Android: la animación Tween (Tween). A diferencia de la animación de fotogramas aprendida anteriormente, la animación de fotogramas simula el efecto de animación reproduciendo imágenes continuamente, mientras que en la animación Tween el desarrollador solo necesita especificarel inicio de la animaciónyel fin de la animación(los "fotogramas clave"), y el sistema calcula y completa los "fotogramas intermedios" del cambio de animación. ¡Bien, comencemos a aprender en esta sección~
1. Clasificación de las animaciones Tween e Interpolator
Los efectos de animación Tween soportados por Android son los siguientes cinco, o más bien cuatro; el quinto es solo una combinación de los anteriores~
- AlphaAnimation:Cambio de transparencia (Alpha): al crearlo, se debe especificar la transparencia inicial y final, además de la duración de la animación; el rango de transparencia es (0,1), 0 es completamente transparente y 1 es completamente opaco; corresponde a la etiqueta <alpha/>!
- ScaleAnimationCambio de escala (Scale): al crearlo, se debe especificar la relación de escala inicial y final, el punto de referencia de escala y la duración de la animación; corresponde a la etiqueta <scale/>!
- TranslateAnimationCambio de posición (Translate): al crearlo, se especifican la posición inicial y final, y la duración de la animación; corresponde a la etiqueta <translate/>!
- RotateAnimationCambio de rotación (Rotate): al crearlo, se especifican el ángulo de rotación inicial y final, la duración de la animación y el eje de rotación; corresponde a la etiqueta <rotate/>!
- AnimationSetCambio combinado (Set): es la combinación de los cambios anteriores; corresponde a la etiqueta <set/>!
Antes de explicar el uso de las distintas animaciones, primero debemos explicar una cosa:Interpolator
Sirve para controlar la velocidad de cambio de la animación; se puede entender como un renderizador de animación. Por supuesto, también podemos implementar la interfaz Interpolator para controlar la velocidad de cambio de la animación. Android ya nos proporciona cinco clases de implementación opcionales:
- LinearInterpolatorLinearInterpolator: la animación cambia a una velocidad uniforme
- AccelerateInterpolatorAccelerateInterpolator: al comienzo de la animación la velocidad de cambio es lenta y luego comienza a acelerar
- AccelerateDecelerateInterpolatorAccelerateDecelerateInterpolator: al inicio y al final de la animación la velocidad de cambio es lenta, y en el medio es acelerada
- CycleInterpolatorCycleInterpolator: la animación se reproduce en bucle un número específico de veces y la velocidad de cambio varía según una curva sinusoidal: Math.sin(2 * mCycles * Math.PI * input)
- DecelerateInterpolatorDecelerateInterpolator: al comienzo de la animación la velocidad de cambio es rápida y luego comienza a desacelerar
- AnticipateInterpolatorAnticipateInterpolator: primero retrocede, se mueve en dirección opuesta un tramo y luego acelera
- AnticipateOvershootInterpolatorAnticipateOvershootInterpolator: al principio retrocede y luego se lanza hacia adelante con un cierto exceso, para finalmente volver al valor final
- BounceInterpolatorBounceInterpolator: rebota; cuando se acerca al valor objetivo, el valor salta, por ejemplo, si el objetivo es 100, los valores posteriores pueden ser 85, 77, 70, 80, 90, 100
- OvershottInterpolatorOvershootInterpolator: rebase; al final sobrepasa el valor objetivo y luego cambia lentamente hasta el valor objetivo
Y esto generalmente se usa al escribir el archivo XML de animación; el atributo es: `android:interpolator`android:interpolatory los valores correspondientes de arriba son:@android:anim/linear_interpolatoren realidad solo es convertir la nomenclatura de camello (camelCase) a subrayado. ¡AccelerateDecelerateInterpolator corresponde a @android:anim/accelerate_decelerate_interpolator!
2. Explicación detallada de las distintas animaciones
Aquí los `duration`android:durationson la duración de la animación, en milisegundos~
1) AlphaAnimation (cambio de transparencia)
anim_alpha.xml:
<alpha xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:fromAlpha="1.0"
android:toAlpha="0.1"
android:duration="2000"/>
Explicación de atributos:
fromAlpha`fromAlpha`: transparencia inicial
toAlpha`toAlpha`: transparencia final
El rango de transparencia es: 0-1, completamente transparente - completamente opaco
2) ScaleAnimation (cambio de escala)
anim_scale.xml:
<scale xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/accelerate_interpolator"
android:fromXScale="0.2"
android:toXScale="1.5"
android:fromYScale="0.2"
android:toYScale="1.5"
android:pivotX="50%"
android:pivotY="50%"
android:duration="2000"/>
Explicación de atributos:
- fromXScale/fromYScale`fromXScale` / `fromYScale`: relación de escala inicial a lo largo del eje X/eje Y
- toXScale/toYScale`toXScale` / `toYScale`: relación de escala final a lo largo del eje X/eje Y
- pivotX/pivotY`pivotX` / `pivotY`: coordenadas X/Y del eje central de escala, es decir, la posición relativa al borde izquierdo de sí mismo; por ejemplo, 50% toma el centro de la imagen como eje central
3) TranslateAnimation (cambio de posición)
anim_translate.xml:
<translate xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:fromXDelta="0"
android:toXDelta="320"
android:fromYDelta="0"
android:toYDelta="0"
android:duration="2000"/>
Explicación de atributos:
- fromXDelta/fromYDelta`fromXDelta` / `fromYDelta`: coordenadas X/Y de la posición inicial de la animación
- toXDelta/toYDelta`toXDelta` / `toYDelta`: coordenadas X/Y de la posición final de la animación
4) RotateAnimation (cambio de rotación)
anim_rotate.xml:
<rotate xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:fromDegrees="0"
android:toDegrees="360"
android:duration="1000"
android:repeatCount="1"
android:repeatMode="reverse"/>
Explicación de atributos:
- fromDegrees/toDegrees`fromDegrees` / `toDegrees`: ángulo inicial/final de rotación
- repeatCount`repeatCount`: número de rotaciones; el valor predeterminado es 0, que representa una vez; si es otro valor, por ejemplo 3, rotará 4 veces. Además, cuando el valor es -1 o `infinite`, significa que la animación nunca se detiene
- repeatMode`repeatMode`: establece el modo de repetición, por defectorestart`restart`, pero solo es efectivo cuando `repeatCount` es mayor que 0, o es `infinite` o -1. También se puede configurar comoreverse`reverse`, lo que significa que en las repeticiones pares la animación se moverá en dirección opuesta.
5) AnimationSet (cambio combinado)
Muy simple, es solo combinar las animaciones anteriores~
anim_set.xml:
<set xmlns:android="http://schemas.android.com/apk/res/android"
android:interpolator="@android:anim/decelerate_interpolator"
android:shareInterpolator="true" >
<scale
android:duration="2000"
android:fromXScale="0.2"
android:fromYScale="0.2"
android:pivotX="50%"
android:pivotY="50%"
android:toXScale="1.5"
android:toYScale="1.5" />
<rotate
android:duration="1000"
android:fromDegrees="0"
android:repeatCount="1"
android:repeatMode="reverse"
android:toDegrees="360" />
<translate
android:duration="2000"
android:fromXDelta="0"
android:fromYDelta="0"
android:toXDelta="320"
android:toYDelta="0" />
<alpha
android:duration="2000"
android:fromAlpha="1.0"
android:toAlpha="0.1" />
</set>
3. Escribamos un ejemplo para experimentarlo
Bien, a continuación usaremos las animaciones escritas anteriormente para crear un ejemplo y experimentar qué es una animación Tween. Primero hagamos un diseño simple:activity_main.xml:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<Button
android:id="@+id/btn_alpha"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="透明度渐变" />
<Button
android:id="@+id/btn_scale"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="缩放渐变" />
<Button
android:id="@+id/btn_tran"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="位移渐变" />
<Button
android:id="@+id/btn_rotate"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="旋转渐变" />
<Button
android:id="@+id/btn_set"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="组合渐变" />
<ImageView
android:id="@+id/img_show"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:layout_marginTop="48dp"
android:src="@mipmap/img_face.html" />
</LinearLayout>
Bien, luego pasamos a nuestroMainActivity.java, que también es muy simple: solo hay que llamar a `AnimationUtils.loadAnimation()` para cargar la animación, y luego nuestro control View llama a `startAnimation` para iniciar la animación~
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private Button btn_alpha;
private Button btn_scale;
private Button btn_tran;
private Button btn_rotate;
private Button btn_set;
private ImageView img_show;
private Animation animation = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bindViews();
}
private void bindViews() {
btn_alpha = (Button) findViewById(R.id.btn_alpha);
btn_scale = (Button) findViewById(R.id.btn_scale);
btn_tran = (Button) findViewById(R.id.btn_tran);
btn_rotate = (Button) findViewById(R.id.btn_rotate);
btn_set = (Button) findViewById(R.id.btn_set);
img_show = (ImageView) findViewById(R.id.img_show);
btn_alpha.setOnClickListener(this);
btn_scale.setOnClickListener(this);
btn_tran.setOnClickListener(this);
btn_rotate.setOnClickListener(this);
btn_set.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btn_alpha:
animation = AnimationUtils.loadAnimation(this,
R.anim.anim_alpha);
img_show.startAnimation(animation);
break;
case R.id.btn_scale:
animation = AnimationUtils.loadAnimation(this,
R.anim.anim_scale);
img_show.startAnimation(animation);
break;
case R.id.btn_tran:
animation = AnimationUtils.loadAnimation(this,
R.anim.anim_translate);
img_show.startAnimation(animation);
break;
case R.id.btn_rotate:
animation = AnimationUtils.loadAnimation(this,
R.anim.anim_rotate);
img_show.startAnimation(animation);
break;
case R.id.btn_set:
animation = AnimationUtils.loadAnimation(this,
R.anim.anim_set);
img_show.startAnimation(animation);
break;
}
}
}
Imagen del efecto de ejecución:

Jeje, es un poco interesante, ¿verdad? ¡Anímate a probarlo, cambia algo o combina libremente las animaciones para lograr efectos geniales~
4. Monitoreo del estado de la animación
Podemos monitorear el estado de ejecución de la animación llamando al método `setAnimationListener` del objeto de animación:
- setAnimationListener(new AnimationListener())sobrescribiendo los siguientes tres métodos:
- onAnimationStart`onAnimationStart()`: inicio de la animación
- onAnimtaionRepeat`onAnimationRepeat()`: repetición de la animación
- onAnimationEnd`onAnimationEnd()`: fin de la animación
Así se completa el monitoreo del estado de ejecución de la animación~
5. Configurar efectos de animación dinámicamente para View
Primero llamar aAnimationUtils.loadAnimation`AnimationUtils.loadAnimation()` (archivo XML de animación), y luego el control View llama a `startAnimation(anim)` para iniciar la animación. Esta es la forma de carga estática; por supuesto, también puedes crear directamente un objeto de animación, configurarlo con código Java y luego llamar a `startAnimation` para iniciar la animación~
6. Configurar animaciones de transición para Fragment
Aquí hay que tener en cuenta un punto: si el Fragment usa elpaquete v4o elpaquete app¡de Fragment! Podemos llamar al métodoFragmentTransactiondel objeto `FragmentTransaction`setTransition(int transit)para especificar la animación de transición estándar para el Fragment; los valores opcionales de `transit` son los siguientes:
- TRANSIT_NONE`TRANSIT_NONE`: sin animación
- TRANSIT_FRAGMENT_OPEN`TRANSIT_FRAGMENT_OPEN`: animación en forma de apertura
- TRANSIT_FRAGMENT_CLOSE`TRANSIT_FRAGMENT_CLOSE`: animación en forma de cierre
Las animaciones de transición estándar anteriores pueden ser llamadas por ambos; la diferencia está en la animación de transición personalizada
setCustomAnimations`setCustomAnimations()`.
Fragment bajo el paquete `app`: setCustomAnimations(int enter, int exit, int popEnter, int popExit)Son las animaciones para agregar, eliminar, entrar en la pila y salir de la pila, respectivamente.objectAnimator>,<valueAnimatorAdemás, hay que tener en cuenta que el tipo de animación correspondiente es: animación de propiedades (Property), es decir, la etiqueta raíz del archivo de animación debe ser: <set`objectAnimator>` o poner los dos anteriores en un <
`set>`;Fragment bajo el paquete `v4`: bajo el paquete v4 se admiten dos tipos de `setCustomAnimations()`

Además, ten en cuenta que el tipo de animación correspondiente es: animación Tween (Tween), igual que el View anterior~
Puede que tengas dudas: ¿cómo sabes el tipo de animación correspondiente? En realidad, solo tienes que ir al código fuente de Fragment y buscar:
el valor de retorno del método `onCreateAnimation()` y lo sabrás:
paquete v4:

paquete app:

7. Configurar animaciones de transición para Activity
Establecer animaciones de transición para Activity es muy simple; el método que se llama es: `overridePendingTransition()`overridePendingTransition(int enterAnim, int exitAnim)
El uso es muy simple:Después de `startActivity(intent)`ofinish()añadir después:
Los parámetros en orden son:cuando la nueva Activity entra, la animación de entrada, ycuando la antigua Activity sale, la animación de salida.
A continuación se proporcionan varias animaciones de transición simples y de uso común para que todos las usen~

Portal de descarga:Animaciones de transición comunes de Activity.zip
8. Escribamos un ejemplo del efecto de animación en el que los botones de inicio de sesión y registro aparecen desde la parte inferior al entrar en la APP:
Captura del efecto al ejecutarse:

Implementación del código:
Primero, nuestro archivo de diseño:activity_main.xml:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#DDE2E3"
tools:context=".MainActivity">
<LinearLayout
android:id="@+id/start_ctrl"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:orientation="vertical"
android:visibility="gone">
<Button
android:id="@+id/start_login"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#F26968"
android:gravity="center"
android:paddingBottom="15dp"
android:paddingTop="15dp"
android:text="登陆"
android:textColor="#FFFFFF"
android:textSize="18sp" />
<Button
android:id="@+id/start_register"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="#323339"
android:gravity="center"
android:paddingBottom="15dp"
android:paddingTop="15dp"
android:text="注册"
android:textColor="#FFFFFF"
android:textSize="18sp" />
</LinearLayout>
</RelativeLayout>
A continuaciónMainActivity.java:
public class MainActivity extends AppCompatActivity {
private LinearLayout start_ctrl;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
start_ctrl = (LinearLayout) findViewById(R.id.start_ctrl);
//设置动画,从自身位置的最下端向上滑动了自身的高度,持续时间为500ms
final TranslateAnimation ctrlAnimation = new TranslateAnimation(
TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 0,
TranslateAnimation.RELATIVE_TO_SELF, 1, TranslateAnimation.RELATIVE_TO_SELF, 0);
ctrlAnimation.setDuration(500l); //设置动画的过渡时间
start_ctrl.postDelayed(new Runnable() {
@Override
public void run() {
start_ctrl.setVisibility(View.VISIBLE);
start_ctrl.startAnimation(ctrlAnimation);
}
}, 2000);
}
}
Los comentarios están muy claros, así que no explicaré más aquí. Si tienes dudas sobre TranslateAnimation.RELATIVE_TO_SELF, búscalo tú mismo en Google o en Baidu. Debido al espacio (soy perezoso), no lo escribiré aquí, es bastante simple~

9. Descarga del código de ejemplo de esta sección
AnimationDemo3.zip
AnimationDemo4.zip
Resumen de esta sección:
En esta sección explicamos detalladamente la segunda animación en Android (la animación interpolada), el análisis detallado de los cuatro tipos de animación, la configuración de listeners de animación, y también cómo configurar animaciones para View, Fragment y Activity. Finalmente, escribimos un ejemplo en el que, después de entrar, los botones de inicio de sesión y registro aparecen desde la parte inferior de la APP. Puede ser un poco largo, pero todo es muy fácil de entender. ¡Creo que todos quedarán satisfechos después de leerlo! Bien, esto es todo por esta sección, ¡gracias~