Gráficos y animación de Android

Android proporciona un marco muy rico y diverso para admitir gráficos y animaciones 2D. En este tema se presentan estos marcos y se describe cómo crear gráficos y animaciones personalizados para su uso en una aplicación de Xamarin.Android.

Información general

A pesar de ejecutarse en dispositivos que tradicionalmente tienen una potencia limitada, las aplicaciones móviles más altamente calificadas suelen tener una experiencia de usuario sofisticada (UX), completa con gráficos y animaciones de alta calidad que proporcionan una sensación intuitiva, dinámica y dinámica. A medida que las aplicaciones móviles son cada vez más sofisticadas, los usuarios han empezado a esperar más y más aplicaciones.

Afortunadamente para nosotros, las plataformas móviles modernas tienen marcos muy eficaces para crear animaciones sofisticadas y gráficos personalizados, a la vez que conservan la facilidad de uso. Esto permite a los desarrolladores agregar interactividad enriquecida con muy poco esfuerzo.

Los marcos de API de interfaz de usuario en Android se pueden dividir aproximadamente en dos categorías: Gráficos y animación.

Los gráficos se dividen en diferentes enfoques para realizar gráficos 2D y 3D. Los gráficos 3D están disponibles a través de varios marcos integrados, como OpenGL ES (una versión específica móvil de OpenGL) y marcos de terceros, como MonoGame (un kit de herramientas multiplataforma compatible con el kit de herramientas XNA). Aunque los gráficos 3D no están dentro del ámbito de este artículo, examinaremos las técnicas de dibujo 2D integradas.

Android proporciona dos API diferentes para crear gráficos 2D. Uno es un enfoque declarativo de alto nivel y el otro una API de bajo nivel mediante programación:

• Recursos dibujables : se usan para crear gráficos personalizados mediante programación o (más normalmente) mediante instrucciones de dibujo en archivos XML. Normalmente, los recursos dibujables se definen como archivos XML que contienen instrucciones o acciones para que Android represente un gráfico 2D.

• Canvas : se trata de una API de bajo nivel que implica dibujar directamente en un mapa de bits subyacente. Proporciona un control muy específico sobre lo que se muestra.

Además de estas técnicas de gráficos 2D, Android también proporciona varias maneras diferentes de crear animaciones:

• Animaciones dibujables : Android también admite animaciones frame-by-frame conocidas como Animación dibujable. Esta es la API de animación más sencilla. Android carga secuencialmente y muestra recursos dibujables en secuencia (como un dibujo animado).

• Animaciones de vista: las animacionesde vista son las API de animación original de Android y están disponibles en todas las versiones de Android. Esta API está limitada en que solo funcionará con objetos View y solo puede realizar transformaciones sencillas en esas vistas. Normalmente, las animaciones de vista se definen en archivos XML que se encuentran en la /Resources/anim carpeta .

• Animaciones de propiedad : Android 3.0 introdujo un nuevo conjunto de animaciones de la API conocida como animaciones de propiedades. Esta nueva API introdujo un sistema extensible y flexible que se puede usar para animar las propiedades de cualquier objeto, no solo ver objetos. Esta flexibilidad permite encapsular animaciones en clases distintas que facilitarán el uso compartido de código.

Las animaciones de vista son más adecuadas para las aplicaciones que deben admitir las API anteriores a Android 3.0 (nivel de API 11). De lo contrario, las aplicaciones deben usar las API de animación de propiedades más recientes por los motivos mencionados anteriormente.

Todos estos marcos son opciones viables, sin embargo, siempre que sea posible, se debe dar preferencia a las animaciones de propiedades, ya que es una API más flexible con la que trabajar. Las animaciones de propiedad permiten encapsular la lógica de animación en clases distintas que facilitan el uso compartido de código y simplifican el mantenimiento del código.

Accesibilidad

Los gráficos y animaciones ayudan a hacer que las aplicaciones Android sean atractivas y divertidas de usar; sin embargo, es importante recordar que algunas interacciones se producen a través de lectores de pantalla, dispositivos de entrada alternativos o con zoom asistido. Además, algunas interacciones pueden producirse sin funcionalidades de audio.

Las aplicaciones son más utilizables en estas situaciones si se han diseñado teniendo en cuenta la accesibilidad: proporcionar sugerencias y ayuda de navegación en la interfaz de usuario y garantizar que hay contenido de texto o descripciones para elementos pictoriales de la interfaz de usuario.

Consulte la Guía de accesibilidad de Google para obtener más información sobre cómo usar las API de accesibilidad de Android.

Gráficos 2D

Los recursos dibujables son una técnica popular en aplicaciones Android. Al igual que con otros recursos, los recursos dibujables son declarativos: se definen en archivos XML. Este enfoque permite una separación limpia del código de los recursos. Esto puede simplificar el desarrollo y el mantenimiento porque no es necesario cambiar el código para actualizar o cambiar los gráficos en una aplicación Android. Sin embargo, aunque los recursos dibujables son útiles para muchos requisitos gráficos simples y comunes, carecen de la potencia y el control de canvas API.

La otra técnica, mediante el objeto Canvas , es muy similar a otros marcos de API tradicionales, como System.Drawing o el dibujo principal de iOS. El uso del objeto Canvas proporciona el mayor control de cómo se crean los gráficos 2D. Es adecuado para situaciones con las que un recurso dibujable no funcionará o será difícil trabajar con él. Por ejemplo, puede ser necesario dibujar un control deslizante personalizado cuya apariencia cambiará en función de los cálculos relacionados con el valor del control deslizante.

Examinemos primero los recursos dibujables. Son más sencillos y cubren los casos de dibujo personalizados más comunes.

Recursos dibujables

Los recursos dibujables se definen en un archivo XML en el directorio /Resources/drawable. A diferencia de la inserción de PNG o JPEG, no es necesario proporcionar versiones específicas de densidad de recursos dibujables. En tiempo de ejecución, una aplicación Android cargará estos recursos y usará las instrucciones contenidas en estos archivos XML para crear gráficos 2D. Android define varios tipos diferentes de recursos dibujables:

• ShapeDrawable : se trata de un objeto Dibujable que dibuja una forma geométrica primitiva y aplica un conjunto limitado de efectos gráficos en esa forma. Son muy útiles para cosas como personalizar botones o establecer el fondo de TextViews. Veremos un ejemplo de cómo usar un elemento ShapeDrawable más adelante en este artículo.

• StateListDrawable : se trata de un recurso dibujable que cambiará la apariencia en función del estado de un widget o control. Por ejemplo, un botón puede cambiar su apariencia en función de si se presiona o no.

• LayerDrawable : este recurso dibujable que apilará varios otros dibujables uno encima de otro. En la captura de pantalla siguiente se muestra un ejemplo de LayerDrawable :

  

• TransitionDrawable : se trata de una capaDrawable pero con una diferencia. TransitionDrawable es capaz de animar una capa en la parte superior.

• LevelListDrawable : es muy similar a stateListDrawable en que mostrará una imagen basada en determinadas condiciones. Sin embargo, a diferencia de StateListDrawable, LevelListDrawable muestra una imagen basada en un valor entero. Un ejemplo de levelListDrawable sería mostrar la intensidad de una señal Wi-Fi. A medida que cambia la intensidad de la señal WiFi, el dibujable que se muestra cambiará en consecuencia.

• ScaleDrawable/ClipDrawable : como su nombre implica, estos drawables proporcionan funcionalidades de escalado y recorte. ScaleDrawable escalará otro Drawable, mientras que ClipDrawable recortará otro Drawable.

• InsetDrawable: este drawable aplicará conjuntos en los lados de otro recurso dibujable. Se usa cuando una vista necesita un fondo más pequeño que los límites reales de la vista.

• Mapa de bits XMLDrawable: este archivo es un conjunto de instrucciones, en XML, que se van a realizar en un mapa de bits real. Algunas acciones que Android puede realizar son mosaicos, dithering y anti-aliasing. Uno de los usos muy comunes de esto es crear un mapa de bits en el fondo de un diseño.

Ejemplo dibujable

Echemos un vistazo a un ejemplo rápido de cómo crear un gráfico 2D mediante .ShapeDrawable Puede ShapeDrawable definir una de las cuatro formas básicas: rectángulo, óvalo, línea y anillo. También es posible aplicar efectos básicos, como degradado, color y tamaño. El siguiente XML es un ShapeDrawable objeto que se puede encontrar en el proyecto complementario AnimationsDemo (en el archivo Resources/drawable/shape_rounded_blue_rect.xml). Define un rectángulo con un fondo degradado púrpura y esquinas redondeadas:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
<!-- Specify a gradient for the background -->
<gradient android:angle="45"
          android:startColor="#55000066"
          android:centerColor="#00000000"
          android:endColor="#00000000"
          android:centerX="0.75" />

<padding android:left="5dp"
          android:right="5dp"
          android:top="5dp"
          android:bottom="5dp" />

<corners android:topLeftRadius="10dp"
          android:topRightRadius="10dp"
          android:bottomLeftRadius="10dp"
          android:bottomRightRadius="10dp" />
</shape>

Podemos hacer referencia a este recurso dibujable mediante declaración en un diseño u otro drawable, como se muestra en el siguiente XML:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="#33000000">
    <TextView android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:layout_centerInParent="true"
              android:background="@drawable/shape_rounded_blue_rect"
              android:text="@string/message_shapedrawable" />
</RelativeLayout>

Los recursos dibujables también se pueden aplicar mediante programación. El siguiente fragmento de código muestra cómo establecer mediante programación el fondo de un TextView:

TextView tv = FindViewById<TextView>(Resource.Id.shapeDrawableTextView);
tv.SetBackgroundResource(Resource.Drawable.shape_rounded_blue_rect);

Para ver el aspecto que tendría esto, ejecute el proyecto AnimationsDemo y seleccione el elemento Dibujable de formas en el menú principal. Deberíamos ver algo similar a la captura de pantalla siguiente:

Para obtener más información sobre los elementos XML y la sintaxis de Drawable Resources, consulte la documentación de Google.

Uso de Canvas Drawing API

Los dibujables son eficaces, pero tienen sus limitaciones. Algunas cosas no son posibles o muy complejas (por ejemplo, aplicar un filtro a una imagen tomada por una cámara en el dispositivo). Sería muy difícil aplicar la reducción de ojos rojos mediante un recurso dibujable. En su lugar, Canvas API permite que una aplicación tenga un control muy específico para cambiar de forma selectiva los colores de una parte específica de la imagen.

Una clase que se usa normalmente con Canvas es la clase Paint . Esta clase contiene información de color y estilo sobre cómo dibujar. Se usa para proporcionar cosas como un color y una transparencia.

Canvas API usa el modelo del pintor para dibujar gráficos 2D. Las operaciones se aplican en capas sucesivas entre sí. Cada operación abarcará algún área del mapa de bits subyacente. Cuando el área se superpone a un área previamente pintada, la nueva pintura ocultará parcialmente o completamente el antiguo. Este es el mismo modo en que muchas otras API de dibujo, como System.Drawing y los gráficos principales de iOS funcionan.

Hay dos maneras de obtener un Canvas objeto . La primera manera implica definir un objeto Bitmap y, a continuación, crear una instancia de un Canvas objeto con él. Por ejemplo, el siguiente fragmento de código crea un nuevo lienzo con un mapa de bits subyacente:

Bitmap bitmap = Bitmap.CreateBitmap(100, 100, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(b);

La otra manera de obtener un Canvas objeto es mediante el método de devolución de llamada OnDraw que se proporciona a la clase base View . Android llama a este método cuando decide que una vista debe dibujarse y pasar un Canvas objeto con el que la vista funcione.

La clase Canvas expone métodos para proporcionar mediante programación las instrucciones de dibujo. Por ejemplo:

• Canvas.DrawPaint : rellena el mapa de bits del lienzo completo con la pintura especificada.

• Canvas.DrawPath : dibuja la forma geométrica especificada utilizando la pintura especificada.

• Canvas.DrawText : dibuja el texto en el lienzo con el color especificado. El texto se dibuja en la ubicación x,y .

Dibujo con canvas API

Este es un ejemplo de canvas API en acción. El siguiente fragmento de código muestra cómo dibujar una vista:

public class MyView : View
{
    protected override void OnDraw(Canvas canvas)
    {
        base.OnDraw(canvas);
        Paint green = new Paint {
            AntiAlias = true,
            Color = Color.Rgb(0x99, 0xcc, 0),
        };
        green.SetStyle(Paint.Style.FillAndStroke);

        Paint red = new Paint {
            AntiAlias = true,
            Color = Color.Rgb(0xff, 0x44, 0x44)
        };
        red.SetStyle(Paint.Style.FillAndStroke);

        float middle = canvas.Width * 0.25f;
        canvas.DrawPaint(red);
        canvas.DrawRect(0, 0, middle, canvas.Height, green);
    }
}

Este código anterior crea primero una pintura roja y un objeto de pintura verde. Rellena el contenido del lienzo con rojo y, a continuación, indica al lienzo que dibuje un rectángulo verde que sea el 25 % del ancho del lienzo. Un ejemplo de esto se puede ver en AnimationsDemo el proyecto que se incluye con el código fuente de este artículo. Al iniciar la aplicación y seleccionar el elemento Dibujo en el menú principal, deberíamos una pantalla similar a la siguiente:

Animación

A los usuarios les gustan las cosas que se mueven en sus aplicaciones. Las animaciones son una excelente manera de mejorar la experiencia del usuario de una aplicación y ayudarle a destacar. Las mejores animaciones son las que los usuarios no notan porque se sienten naturales. Android proporciona las tres API siguientes para animaciones:

• Animación de vista : esta es la API original. Estas animaciones están vinculadas a una vista específica y pueden realizar transformaciones simples en el contenido de la vista. Debido a su simplicidad, esta API sigue siendo útil para cosas como animaciones alfa, rotaciones, etc.

• Animación de propiedades : las animaciones de propiedad se introdujeron en Android 3.0. Permiten a una aplicación animar casi cualquier cosa. Las animaciones de propiedad se pueden usar para cambiar cualquier propiedad de cualquier objeto, incluso si ese objeto no está visible en la pantalla.

• Animación dibujable : este recurso especial dibujable que se usa para aplicar un efecto de animación muy simple a los diseños.

En general, la animación de propiedades es el sistema preferido para usar, ya que es más flexible y ofrece más características.

Ver animaciones

Las animaciones de vista se limitan a Vistas y solo pueden realizar animaciones en valores como puntos iniciales y finales, tamaño, rotación y transparencia. Estos tipos de animaciones se conocen normalmente como animaciones de interpolación. Las animaciones de vista se pueden definir de dos maneras: mediante programación en el código o mediante archivos XML. Los archivos XML son la manera preferida de declarar animaciones de vista, ya que son más legibles y fáciles de mantener.

Los archivos XML de animación se almacenarán en el /Resources/anim directorio de un proyecto de Xamarin.Android. Este archivo debe tener uno de los siguientes elementos como elemento raíz :

• alpha – Animación de atenuación o atenuación.

• rotate – Animación de rotación.

• scale – Animación de cambio de tamaño.

• translate – Movimiento horizontal o vertical.

• set : contenedor que puede contener uno o varios de los otros elementos de animación.

De forma predeterminada, todas las animaciones de un archivo XML se aplicarán simultáneamente. Para que las animaciones se produzcan secuencialmente, establezca el android:startOffset atributo en uno de los elementos definidos anteriormente.

Es posible afectar a la tasa de cambio en una animación mediante un interpolador. Un interpolador permite acelerar, repetir o ralentizar los efectos de animación. El marco de Android proporciona varios interpoladores de fábrica, como (pero no limitado a):

• AccelerateInterpolator / DecelerateInterpolator : estos interpoladores aumentan o reducen la tasa de cambio en una animación.

• BounceInterpolator : el cambio rebota al final.

• LinearInterpolator : la tasa de cambios es constante.

El siguiente XML muestra un ejemplo de un archivo de animación que combina algunos de estos elementos:

<?xml version="1.0" encoding="utf-8"?>
<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:fillEnabled="true"
           android:fillAfter="false"
           android:duration="700" />

    <set android:interpolator="@android:anim/accelerate_interpolator">
        <scale android:fromXScale="1.4"
               android:toXScale="0.0"
               android:fromYScale="0.6"
               android:toYScale="0.0"
               android:pivotX="50%"
               android:pivotY="50%"
               android:fillEnabled="true"
               android:fillBefore="false"
               android:fillAfter="true"
               android:startOffset="700"
               android:duration="400" />

        <rotate android:fromDegrees="0"
                android:toDegrees="-45"
                android:toYScale="0.0"
                android:pivotX="50%"
                android:pivotY="50%"
                android:fillEnabled="true"
                android:fillBefore="false"
                android:fillAfter="true"
                android:startOffset="700"
                android:duration="400" />
    </set>
</set>

Esta animación realizará todas las animaciones simultáneamente. La primera animación de escala estirará la imagen horizontalmente y la reducirá verticalmente y, a continuación, la imagen se rotará simultáneamente 45 grados en sentido contrario a las agujas del reloj y se reducirá, desapareciendo de la pantalla.

La animación se puede aplicar mediante programación a una vista inflando la animación y aplicándola a una vista. Android proporciona la clase Android.Views.Animations.AnimationUtils auxiliar que inflará un recurso de animación y devolverá una instancia de Android.Views.Animations.Animation. Este objeto se aplica a una vista llamando StartAnimation a y pasando el Animation objeto . En el fragmento de código siguiente se muestra un ejemplo de esto:

Animation myAnimation = AnimationUtils.LoadAnimation(Resource.Animation.MyAnimation);
ImageView myImage = FindViewById<ImageView>(Resource.Id.imageView1);
myImage.StartAnimation(myAnimation);

Ahora que tenemos un conocimiento fundamental de cómo funcionan las animaciones de vista, vamos a pasar a Animaciones de propiedad.

Animaciones de propiedades

Los animadores de propiedades son una nueva API que se introdujo en Android 3.0. Proporcionan una API más extensible que se puede usar para animar cualquier propiedad en cualquier objeto.

Todas las animaciones de propiedad se crean mediante instancias de la subclase Animator . Las aplicaciones no usan directamente esta clase, sino que usan una de sus subclases:

• ValueAnimator : esta clase es la clase más importante de toda la API de animación de propiedades. Calcula los valores de las propiedades que deben cambiarse. no ViewAnimator actualiza directamente esos valores; en su lugar, genera eventos que se pueden usar para actualizar objetos animados.

• ObjectAnimator : esta clase es una subclase de ValueAnimator . Está pensado para simplificar el proceso de animar objetos aceptando un objeto de destino y una propiedad que se van a actualizar.

• AnimationSet : esta clase es responsable de orquestar cómo se ejecutan las animaciones entre sí. Las animaciones se pueden ejecutar simultáneamente, secuencialmente o con un retraso especificado entre ellas.

Los evaluadores son clases especiales que usan los animadores para calcular los nuevos valores durante una animación. De fábrica, Android proporciona los siguientes evaluadores:

• IntEvaluator : calcula los valores de las propiedades de entero.

• FloatEvaluator : calcula los valores de las propiedades float.

• ArgbEvaluator : calcula los valores de las propiedades de color.

Si la propiedad que se está animando no es un floatcolor o , int las aplicaciones pueden crear su propio evaluador mediante la implementación de la ITypeEvaluator interfaz . (La implementación de evaluadores personalizados está fuera del ámbito de este tema).

Uso de ValueAnimator

Hay dos partes en cualquier animación: calcular valores animados y, a continuación, establecer esos valores en propiedades en algún objeto. ValueAnimator solo calculará los valores, pero no funcionará directamente en objetos. En su lugar, los objetos se actualizarán dentro de los controladores de eventos que se invocarán durante la duración de la animación. Este diseño permite actualizar varias propiedades a partir de un valor animado.

Para obtener una instancia de ValueAnimator , llame a uno de los métodos de fábrica siguientes:

• ValueAnimator.OfInt
• ValueAnimator.OfFloat
• ValueAnimator.OfObject

Una vez hecho esto, la ValueAnimator instancia debe tener su duración establecida y, a continuación, se puede iniciar. En el ejemplo siguiente se muestra cómo animar un valor de 0 a 1 en el intervalo de 1000 milisegundos:

ValueAnimator animator = ValueAnimator.OfInt(0, 100);
animator.SetDuration(1000);
animator.Start();

Pero en sí mismo, el fragmento de código anterior no es muy útil: el animador se ejecutará, pero no hay ningún destino para el valor actualizado. La Animator clase generará el evento Update cuando decida que es necesario informar a los agentes de escucha de un nuevo valor. Las aplicaciones pueden proporcionar un controlador de eventos para responder a este evento, como se muestra en el siguiente fragmento de código:

MyCustomObject myObj = new MyCustomObject();
myObj.SomeIntegerValue = -1;

animator.Update += (object sender, ValueAnimator.AnimatorUpdateEventArgs e) =>
{
    int newValue = (int) e.Animation.AnimatedValue;
    // Apply this new value to the object being animated.
    myObj.SomeIntegerValue = newValue;
};

Ahora que tenemos un conocimiento de ValueAnimator, vamos a obtener más información sobre .ObjectAnimator

Uso de ObjectAnimator

ObjectAnimator es una subclase de ViewAnimator que combina el motor de control de tiempo y el cálculo de valores de ValueAnimator con la lógica necesaria para conectar controladores de eventos. Requiere que las ValueAnimator aplicaciones conecten explícitamente un controlador de eventos: ObjectAnimator se encargará de este paso para nosotros.

La API para ObjectAnimator es muy similar a la API para ViewAnimator, pero requiere que proporcione el objeto y el nombre de la propiedad que se va a actualizar. En el ejemplo siguiente se muestra un ejemplo de uso ObjectAnimatorde :

MyCustomObject myObj = new MyCustomObject();
myObj.SomeIntegerValue = -1;

ObjectAnimator animator = ObjectAnimator.OfFloat(myObj, "SomeIntegerValue", 0, 100);
animator.SetDuration(1000);
animator.Start();

Como puede ver en el fragmento de código anterior, ObjectAnimator puede reducir y simplificar el código necesario para animar un objeto.

Animaciones dibujables

La API de animación final es la API de animación dibujable. Las animaciones dibujables cargan una serie de recursos dibujables una después de la otra y las muestran secuencialmente, de forma similar a una animación de volteo.

Los recursos dibujables se definen en un archivo XML que tiene un <animation-list> elemento como elemento raíz y una serie de <item> elementos que definen cada fotograma de la animación. Este archivo XML se almacena en la /Resource/drawable carpeta de la aplicación. El siguiente XML es un ejemplo de una animación dibujable:

<animation-list xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:drawable="@drawable/asteroid01" android:duration="100" />
  <item android:drawable="@drawable/asteroid02" android:duration="100" />
  <item android:drawable="@drawable/asteroid03" android:duration="100" />
  <item android:drawable="@drawable/asteroid04" android:duration="100" />
  <item android:drawable="@drawable/asteroid05" android:duration="100" />
  <item android:drawable="@drawable/asteroid06" android:duration="100" />
</animation-list>

Esta animación se ejecutará a través de seis fotogramas. El android:duration atributo declara cuánto tiempo se mostrará cada fotograma. El siguiente fragmento de código muestra un ejemplo de creación de una animación dibujable e inicio cuando el usuario hace clic en un botón en la pantalla:

AnimationDrawable _asteroidDrawable;

protected override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);
    SetContentView(Resource.Layout.Main);

    _asteroidDrawable = (Android.Graphics.Drawables.AnimationDrawable)
    Resources.GetDrawable(Resource.Drawable.spinning_asteroid);

    ImageView asteroidImage = FindViewById<ImageView>(Resource.Id.imageView2);
    asteroidImage.SetImageDrawable((Android.Graphics.Drawables.Drawable) _asteroidDrawable);

    Button asteroidButton = FindViewById<Button>(Resource.Id.spinAsteroid);
    asteroidButton.Click += (sender, e) =>
    {
        _asteroidDrawable.Start();
    };
}

En este punto hemos tratado los fundamentos de las API de animación disponibles en una aplicación Android.

Resumen

En este artículo se introdujeron muchos conceptos y API nuevos para ayudar a agregar algunos gráficos a una aplicación Android. En primer lugar, se describen las diversas API de gráficos 2D y se muestra cómo Android permite que las aplicaciones se dibujen directamente en la pantalla mediante un objeto Canvas. También vimos algunas técnicas alternativas que permiten crear gráficos mediante declaración mediante archivos XML. A continuación, hemos pasado a analizar las API antiguas y nuevas para crear animaciones en Android.

Vínculos relacionados

• Demostración de animación (ejemplo)
• Animación y gráficos
• Uso de animaciones para llevar tus aplicaciones móviles a la vida
• AnimationDrawable
• Lienzo
• Animador de objetos
• Animador de valor