Se usó la API de Cloud Translation para traducir esta página.

Recursos de animación

Un recurso de animación puede definir uno de dos tipos de animaciones:

Crea una animación mediante la modificación de los valores de propiedades de un objeto durante un período establecido con un Animator.

Animación de vistas

Hay dos tipos de animaciones que puedes hacer con el framework de animación de vistas:

Animación de interpolación: Crea una animación mediante una serie de transformaciones en una sola imagen con una Animation.
Animación de marcos: Crea una animación mediante una secuencia de imágenes en orden con un AnimationDrawable.

Animación de propiedades

Se trata de una animación definida en XML que modifica las propiedades del objeto de destino, como el color de fondo o el valor Alfa, durante un período determinado.

ubicación del archivo:

res/animator/filename.xml
Se utiliza el nombre del archivo como ID de recurso.

tipo de datos de recursos compilados:

Puntero del recurso en un ValueAnimator, ObjectAnimator o AnimatorSet

referencia del recurso:

En código basado en Java o Kotlin: R.animator.filename
En XML: @[package:]animator/filename

sintaxis:

<set
  android:ordering=["together" | "sequentially"]>

    <objectAnimator
        android:propertyName="string"
        android:duration="int"
        android:valueFrom="float | int | color"
        android:valueTo="float | int | color"
        android:startOffset="int"
        android:repeatCount="int"
        android:repeatMode=["restart" | "reverse"]
        android:valueType=["intType" | "floatType"]/>

    <animator
        android:duration="int"
        android:valueFrom="float | int | color"
        android:valueTo="float | int | color"
        android:startOffset="int"
        android:repeatCount="int"
        android:repeatMode=["restart" | "reverse"]
        android:valueType=["intType" | "floatType"]/>

    <set>
        ...
    </set>
</set>

El archivo debe tener un único elemento raíz: <set>, <objectAnimator> o <valueAnimator>. Puedes agrupar elementos de animación dentro del elemento <set>, incluidos otros elementos <set>.

elementos:

<set>

Un contenedor que contiene otros elementos de animación (<objectAnimator>, <valueAnimator> o algún otro elemento <set>). Representa un AnimatorSet.

Puedes especificar etiquetas de <set> anidadas para agrupar más animaciones. Cada <set> puede definir su propio atributo de ordering.

Atributos:

android:ordering

Palabra clave. Especifica el orden de reproducción de las animaciones en este conjunto.

Valor	Descripción
`sequentially`	Reproduce animaciones en este conjunto de manera secuencial.
`together` (predeterminado)	Reproduce animaciones en este conjunto al mismo tiempo.

<objectAnimator>

Anima una propiedad específica de un objeto durante un lapso específico. Representa un ObjectAnimator.

Atributos:

android:propertyName

Cadena. Obligatoria. La propiedad del objeto que se animará, a la que se hace referencia por su nombre. Por ejemplo, puedes especificar "alpha" o "backgroundColor" para un objeto View. Sin embargo, el elemento objectAnimator no expone un atributo target, por lo que no puedes establecer la animación del objeto en la declaración de XML. Para aumentar el recurso XML de la animación, tienes que llamar a loadAnimator(); además, llama a setTarget() para establecer el objeto de destino que contiene esta propiedad.

android:valueTo

flotante, int o color. Obligatorio. Es el valor donde termina la propiedad animada. Los colores se representan como números hexadecimales de seis dígitos, como #333333.

android:valueFrom

flotante, int o color. Es el valor donde comienza la propiedad animada. Si no se especifica, la animación comienza en el valor obtenido por el método get de la propiedad. Los colores se representan como números hexadecimales de seis dígitos, como #333333.

android:duration

int. Es el tiempo en milisegundos de la animación. 300 milisegundos es el valor predeterminado.

android:startOffset

int. La cantidad de milisegundos que tarda la animación después de llamar a start().

android:repeatCount

int. Cuántas veces repetir una animación. Se establece en "-1" a fin de repetir infinitamente o para un número entero positivo. Por ejemplo, un valor de "1" significa que la animación se repite una vez después de su ejecución inicial, de modo que se reproduce un total de dos veces. El valor predeterminado es "0", y esto significa que no hay repeticiones.

android:repeatMode

int. Cómo se comporta una animación cuando llega al final de la animación. android:repeatCount se debe establecer en un número entero positivo o "-1" para que este atributo tenga efecto. Configúralo en "reverse" de modo que la animación revierta la dirección con cada iteración o configúralo en "restart" para que se repita indefinidamente desde el principio cada vez.

android:valueType

Palabra clave. No especifiques este atributo si el valor es un color. El framework de animación maneja los valores de color automáticamente.

Valor	Descripción
`intType`	Especifica que los valores animados son números enteros.
`floatType` (predeterminado)	Especifica que los valores animados son números de punto flotante.

<animator>

Ejecuta una animación durante un lapso especificado. Representa un ValueAnimator.

Atributos:

android:valueTo

flotante, int o color. Obligatorio. Es el valor donde finaliza la animación. Los colores se representan como números hexadecimales de seis dígitos, como #333333.

android:valueFrom

flotante, int o color. Obligatorio. Es el valor donde comienza la animación. Los colores se representan como números hexadecimales de seis dígitos, como #333333.

android:duration

int. Es el tiempo en milisegundos de la animación. 300 milisegundos es el valor predeterminado.

android:startOffset

int. La cantidad de milisegundos que tarda la animación después de llamar a start().

android:repeatCount

android:repeatMode

android:valueType

Palabra clave. No especifiques este atributo si el valor es un color. El framework de animación maneja los valores de color automáticamente.

Valor	Descripción
`intType`	Especifica que los valores animados son números enteros.
`floatType` (predeterminado)	Especifica que los valores animados son números de punto flotante.

ejemplo:

Archivo en formato XML guardado en res/animator/property_animator.xml:

<set android:ordering="sequentially">
    <set>
        <objectAnimator
            android:propertyName="x"
            android:duration="500"
            android:valueTo="400"
            android:valueType="intType"/>
        <objectAnimator
            android:propertyName="y"
            android:duration="500"
            android:valueTo="300"
            android:valueType="intType"/>
    </set>
    <objectAnimator
        android:propertyName="alpha"
        android:duration="500"
        android:valueTo="1f"/>
</set>

Para ejecutar esta animación, aumenta los recursos XML en tu código a un objeto AnimatorSet y, luego, establece los objetos de destino para todas las animaciones antes de comenzar el conjunto de animación. Llamar a setTarget() establece un único objeto de destino para todos los elementos secundarios del AnimatorSet como método de conveniencia. El siguiente código muestra cómo hacer esto:

Kotlin

val set: AnimatorSet = AnimatorInflater.loadAnimator(myContext, R.animator.property_animator)
    .apply {
        setTarget(myObject)
        start()
    }

Java

AnimatorSet set = (AnimatorSet) AnimatorInflater.loadAnimator(myContext,
    R.animator.property_animator);
set.setTarget(myObject);
set.start();

consulta también:

Descripción general de la animación de propiedades
Demostraciones de API para ver ejemplos de uso del sistema de animación de propiedades

Animación de vistas

El framework para la animación de vistas admite tanto animaciones de interpolación como por fotograma, y ambas se declaran en XML. En las secciones siguientes, se describe cómo usar ambos métodos.

Animación de interpolación

Se trata de una animación definida en XML que realiza transiciones en un gráfico, como rotación, atenuación, movimiento y estiramiento.

ubicación del archivo:

res/anim/filename.xml
Se utiliza el nombre del archivo como ID de recurso.

tipo de datos de recursos compilados:

Puntero del recurso a un Animation

referencia del recurso:

En Java: R.anim.filename
En XML: @[package:]anim/filename

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:interpolator="@[package:]anim/interpolator_resource"
    android:shareInterpolator=["true" | "false"] >
    <alpha
        android:fromAlpha="float"
        android:toAlpha="float" />
    <scale
        android:fromXScale="float"
        android:toXScale="float"
        android:fromYScale="float"
        android:toYScale="float"
        android:pivotX="float"
        android:pivotY="float" />
    <translate
        android:fromXDelta="float"
        android:toXDelta="float"
        android:fromYDelta="float"
        android:toYDelta="float" />
    <rotate
        android:fromDegrees="float"
        android:toDegrees="float"
        android:pivotX="float"
        android:pivotY="float" />
    <set>
        ...
    </set>
</set>

El archivo debe tener un único elemento raíz: un elemento <alpha>, <scale>, <translate>, <rotate> o <set> que contenga un grupo (o grupos) de otros elementos de animación (incluso elementos <set> anidados).

elementos:

<set>

Un contenedor que contiene otros elementos de animación (<alpha>, <scale>, <translate>, <rotate>) o algún otro elemento <set>. Representa un AnimationSet.

Atributos:

android:interpolator: Recurso de interpolador. Es un Interpolator para aplicar en la animación. El valor debe ser una referencia a un recurso que especifique un interpolador (no un nombre de clase de interpolador). Hay recursos de interpoladores predeterminados disponibles en la plataforma, o puedes crear tu propio recurso de interpolador. Consulta el siguiente debate para obtener más información sobre interpoladores.
android:shareInterpolator: Booleano. Es "true" si deseas compartir el mismo interpolador entre todos los elementos secundarios.

<alpha>

Es una animación de atenuación de entrada o de salida. Representa un AlphaAnimation.

Atributos:

android:fromAlpha: Número de punto flotante. Compensación de opacidad inicial, donde 0.0 es transparente y 1.0 es opaco.
android:toAlpha: Flotante. Es la compensación de opacidad final, donde 0.0 es transparente y 1.0 es opaco.

Para obtener más atributos compatibles con <alpha>, consulta la referencia de clase para Animation (este elemento hereda los atributos XML de dicha referencia).

<scale>

Es una animación de cambio de tamaño. Puedes especificar pivotX y pivotY para indicar el punto central de la imagen desde donde se expande hacia afuera o hacia adentro. Por ejemplo, si estos valores son 0,0 (la esquina superior izquierda), toda la expansión es hacia abajo y hacia la derecha. Representa un ScaleAnimation.

Atributos:

android:fromXScale: Número de punto flotante. Compensación de tamaño X inicial, donde 1.0 implica ausencia de cambio.
android:toXScale: Flotante. Compensación de tamaño X final, donde 1.0 implica ausencia de cambio.
android:fromYScale: Flotante. Compensación de tamaño Y inicial, donde 1.0 implica ausencia de cambio.
android:toYScale: Flotante. Compensación de tamaño Y final, donde 1.0 implica ausencia de cambio.
android:pivotX: Flotante. La coordenada X permanece fija cuando se escala el objeto.
android:pivotY: Flotante. Es la coordenada Y que permanecerá fija cuando el objeto se escale.

Para obtener más atributos compatibles con <scale>, consulta la referencia de clase para Animation (este elemento hereda los atributos XML de dicha referencia).

<translate>

Es un movimiento horizontal o vertical. Representa un TranslateAnimation. Admite los siguientes atributos en cualquiera de estos tres formatos:

Valores de -100 a 100 que terminan en "%", que indican un porcentaje relativo a sí mismo
Valores de -100 a 100 que terminan en "%p", que indican un porcentaje en relación con su elemento superior
Un valor de punto flotante sin sufijo, que indica un valor absoluto

Atributos:

android:fromXDelta: Número de punto flotante o porcentaje. Es la compensación X inicial. Se expresa en píxeles relativos a la posición normal (como "5"), en un porcentaje relativo al ancho del elemento (como "5%") o en un porcentaje relativo al ancho del elemento superior (como "5%p").
android:toXDelta: Número de punto flotante o porcentaje. Es la compensación X final. Se expresa en píxeles relativos a la posición normal (como "5"), en un porcentaje relativo al ancho del elemento (como "5%") o en un porcentaje relativo al ancho del elemento superior (como "5%p").
android:fromYDelta: Número de punto flotante o porcentaje. Es la compensación Y inicial. Se expresa en píxeles relativos a la posición normal (como "5"), en un porcentaje relativo a la altura del elemento (como "5%") o en un porcentaje relativo a la altura del elemento superior (como "5%p").
android:toYDelta: Número de punto flotante o porcentaje. Es la compensación Y final. Se expresa en píxeles relativos a la posición normal (como "5"), en un porcentaje relativo a la altura del elemento (como "5%") o en un porcentaje relativo a la altura del elemento superior (como "5%p").

Para obtener más atributos compatibles con <translate>, consulta la referencia de clase para Animation (este elemento hereda los atributos XML de dicha referencia).

<rotate>

Es una animación de rotación. Representa un RotateAnimation.

Atributos:

android:fromDegrees: Número de punto flotante. Posición angular inicial, en grados.
android:toDegrees: Flotante. Posición angular final, en grados.
android:pivotX: Flotante o porcentual. Es la coordenada X del centro de rotación. Se expresa en píxeles relativos al borde izquierdo del objeto (como "5"), en un porcentaje relativo al borde izquierdo del objeto (como "5%") o en un porcentaje relativo al borde izquierdo del contenedor superior (como "5%p").
android:pivotY: Número de punto flotante o porcentaje. Es la coordenada Y del centro de rotación. Se expresa en píxeles relativos al borde superior del objeto (como "5"), en un porcentaje relativo al borde superior del objeto (como "5%") o en un porcentaje relativo al borde superior del contenedor superior (como "5%p").

Para obtener más atributos compatibles con <rotate>, consulta la referencia de clase para Animation (este elemento hereda los atributos XML de dicha referencia).

ejemplo:

Archivo en formato XML guardado en res/anim/hyperspace_jump.xml:

<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:fillAfter="false"
        android:duration="700" />
    <set
        android:interpolator="@android:anim/accelerate_interpolator"
        android:startOffset="700">
        <scale
            android:fromXScale="1.4"
            android:toXScale="0.0"
            android:fromYScale="0.6"
            android:toYScale="0.0"
            android:pivotX="50%"
            android:pivotY="50%"
            android:duration="400" />
        <rotate
            android:fromDegrees="0"
            android:toDegrees="-45"
            android:toYScale="0.0"
            android:pivotX="50%"
            android:pivotY="50%"
            android:duration="400" />
    </set>
</set>

El siguiente código de la aplicación aplica la animación a una ImageView e inicia la animación:

Kotlin

val image: ImageView = findViewById(R.id.image)
val hyperspaceJump: Animation = AnimationUtils.loadAnimation(this, R.anim.hyperspace_jump)
image.startAnimation(hyperspaceJump)

Java

ImageView image = (ImageView) findViewById(R.id.image);
Animation hyperspaceJump = AnimationUtils.loadAnimation(this, R.anim.hyperspace_jump);
image.startAnimation(hyperspaceJump);

consulta también:

Animación de vistas

Interpoladores

Un interpolador es un modificador de animación definido en XML que afecta la tasa de cambio en una animación. Esto permite que los efectos de animación existentes se aceleren, se desaceleren, se repitan, reboten, etc.

Se aplica un interpolador a un elemento de animación con el atributo android:interpolator, cuyo valor es una referencia a un recurso de interpolador.

Todos los interpoladores disponibles en Android son subclases de la clase Interpolator. Para cada clase de interpolador, Android incluye un recurso público al que puedes hacer referencia para aplicar el interpolador a una animación mediante el atributo android:interpolator. En la siguiente tabla, se especifica el recurso que corresponde usar para cada interpolador:

Clase de interpolador	ID del recurso
`AccelerateDecelerateInterpolator`	`@android:anim/accelerate_decelerate_interpolator`
`AccelerateInterpolator`	`@android:anim/accelerate_interpolator`
`AnticipateInterpolator`	`@android:anim/anticipate_interpolator`
`AnticipateOvershootInterpolator`	`@android:anim/anticipate_overshoot_interpolator`
`BounceInterpolator`	`@android:anim/bounce_interpolator`
`CycleInterpolator`	`@android:anim/cycle_interpolator`
`DecelerateInterpolator`	`@android:anim/decelerate_interpolator`
`LinearInterpolator`	`@android:anim/linear_interpolator`
`OvershootInterpolator`	`@android:anim/overshoot_interpolator`

Aquí te indicamos cómo puedes aplicar uno de estos con el atributo android:interpolator:

<set android:interpolator="@android:anim/accelerate_interpolator">
    ...
</set>

Interpoladores personalizados

Si los interpoladores que proporciona la plataforma no te satisfacen, puedes crear un recurso de interpolador personalizado con atributos modificados. Por ejemplo, puedes ajustar la tasa de aceleración del AnticipateInterpolator o ajustar la cantidad de ciclos del CycleInterpolator. Para hacerlo, crea tu propio recurso de interpolador en un archivo en formato XML.

ubicación del archivo:

res/anim/filename.xml
Se utiliza el nombre del archivo como ID de recurso.

tipo de datos de recursos compilados:

Puntero del recurso en el objeto interpolador correspondiente

referencia del recurso:

En XML: @[package:]anim/filename

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<InterpolatorName xmlns:android="http://schemas.android.com/apk/res/android"
    android:attribute_name="value"
    />

Si no aplicas ningún atributo, tu interpolador funcionará exactamente igual a como lo hacen los que proporciona la plataforma y que se enumeran en la tabla anterior.

elementos:

Observa que cada implementación de Interpolator, cuando se define en XML, tiene un nombre que comienza con una letra minúscula.

ejemplo:

Archivo en formato XML guardado en res/anim/my_overshoot_interpolator.xml:

<?xml version="1.0" encoding="utf-8"?>
<overshootInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
    android:tension="7.0"
    />

Este XML de la animación aplica el interpolador:

<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:interpolator="@anim/my_overshoot_interpolator"
    android:fromXScale="1.0"
    android:toXScale="3.0"
    android:fromYScale="1.0"
    android:toYScale="3.0"
    android:pivotX="50%"
    android:pivotY="50%"
    android:duration="700" />

Animación de fotogramas

Se trata de una animación definida en XML que muestra una secuencia de imágenes en orden, como una película.

ubicación del archivo:

res/drawable/filename.xml
Se utiliza el nombre del archivo como ID de recurso.

tipo de datos de recursos compilados:

Puntero del recurso a un AnimationDrawable

referencia del recurso:

En Java: R.drawable.filename
En XML: @[package:]drawable.filename

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
    android:oneshot=["true" | "false"] >
    <item
        android:drawable="@[package:]drawable/drawable_resource_name"
        android:duration="integer" />
</animation-list>

elementos:

ejemplo:

Archivo en formato XML guardado en res/drawable/rocket_thrust.xml:

<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
    android:oneshot="false">
    <item android:drawable="@drawable/rocket_thrust1" android:duration="200" />
    <item android:drawable="@drawable/rocket_thrust2" android:duration="200" />
    <item android:drawable="@drawable/rocket_thrust3" android:duration="200" />
</animation-list>

El siguiente código de la aplicación establece la animación como fondo para una View y, luego, reproduce la animación:

Kotlin

val rocketImage: ImageView = findViewById(R.id.rocket_image)
rocketImage.setBackgroundResource(R.drawable.rocket_thrust)

val rocketAnimation = rocketImage.background
if (rocketAnimation is Animatable) {
    rocketAnimation.start()
}

Java

ImageView rocketImage = (ImageView) findViewById(R.id.rocket_image);
rocketImage.setBackgroundResource(R.drawable.rocket_thrust);

rocketAnimation = rocketImage.getBackground();
if (rocketAnimation instanceof Animatable) {
    ((Animatable)rocketAnimation).start();
}

consulta también:

Animación de vistas