Animación y gráficos de Android

Android proporciona un marco muy completo y diverso para admitir animaciones y gráficos 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 con mayor puntuación suelen tener una experiencia de usuario (UX) sofisticada, completa con animaciones y gráficos de alta calidad que proporcionan una sensación intuitiva, dinámica y con capacidad de respuesta. A medida que las aplicaciones móviles son cada vez más sofisticadas, los usuarios han empezado a esperar cada vez más de las aplicaciones.

Afortunadamente, 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 una interactividad enriquez 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 una serie de marcos integrados, como OpenGL ES (una versión específica para dispositivos móviles de OpenGL) y marcos de terceros como MonoGame (un kit de herramientas multiplataforma compatible con el kit de herramientas de 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 drawable: se usan para crear gráficos personalizados mediante programación o (más normalmente) mediante la inserción de instrucciones de dibujo en archivos XML. Los recursos drawables normalmente 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 preciso 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 drawable: Android también admite animaciones fotograma a fotograma conocidas como animación dibujable. Se trata de la API de animación más sencilla. Android carga y muestra secuencialmente los recursos drawable en secuencia (de forma muy parecido a una animación).

• Animaciones de vista:las animaciones de vista son las API de animación originales en 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. Las animaciones de vista se definen normalmente en archivos XML que se encuentran en la /Resources/anim carpeta .

• Animaciones de propiedades: Android 3.0 introdujo un nuevo conjunto de API de animación conocidas como animaciones de propiedad. Estas nuevas API han introducido un sistema extensible y flexible que se puede usar para animar las propiedades de cualquier objeto, no solo para 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, pero siempre que sea posible, se debe dar preferencia a las animaciones de propiedad, 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 las animaciones ayudan a hacer que las aplicaciones Android sea 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 útiles en estas situaciones si se han diseñado pensando en 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 gráficos 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

Drawable Resources es una técnica popular en aplicaciones Android. Al igual que con otros recursos, los recursos drawable 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 drawable 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 otras plataformas de API tradicionales, como System.Drawing o Core Drawing de iOS. El uso del objeto Canvas proporciona el máximo control sobre cómo se crean los gráficos 2D. Es adecuado para situaciones en las que un recurso drawable 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 drawables. Son más simples y cubren los casos de dibujo personalizados más comunes.

Recursos drawables

Los recursos drawables se definen en un archivo XML en el directorio /Resources/drawable . A diferencia de la inserción de ARCHIVOS PNG o JPEG, no es necesario proporcionar versiones específicas de la densidad de los recursos drawables. 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 drawables:

• ShapeDrawable: se trata de un objeto drawable que dibuja una forma geométrica primitiva y aplica un conjunto limitado de efectos gráficos a esa forma. Son muy útiles para aspectos 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 drawable 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 está presionado o no.

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

  

• TransitionDrawable: se trata de un layerDrawable, pero con una diferencia. TransitionDrawable puede animar una capa que se muestra encima de otra.

• LevelListDrawable: es muy similar a StateListDrawable, ya que mostrará una imagen en función de 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 Wi-Fi, el drawable que se muestra cambiará en consecuencia.

• ScaleDrawableClipDrawable: como su nombre indica, estos drawables proporcionan la funcionalidad de escalado y recorte. ScaleDrawable escalará otro drawable, mientras que ClipDrawable recortará otro drawable.

• InsetDrawable: este drawable aplicará los conjuntos en los lados de otro recurso drawable. Se usa cuando una vista necesita un fondo que sea menor que los límites reales de la vista.

• XML BitmapDrawable: 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 el tiling, el dithering y el suavizado de alias. Uno de los usos muy comunes de esto es crear mosaicos de un mapa de bits en el fondo de un diseño.

Ejemplo drawable

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 el degradado, el color y el tamaño. El siguiente XML es un que se puede encontrar en el proyecto complementario ShapeDrawableShapeDrawable (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 drawable mediante declaración en un diseño u otro drawable, como se muestra en el xml siguiente:

<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 drawable también se pueden aplicar mediante programación. El fragmento de código siguiente muestra cómo establecer mediante programación el fondo de un objeto TextView:

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

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

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

Uso de Canvas Drawing API

Los drawables son eficaces, pero tienen sus limitaciones. Ciertas 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 con los ojos rojos mediante un recurso drawable. 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 Paint clase. Esta clase contiene información de estilo y color sobre cómo dibujar. Se usa para proporcionar un color y una transparencia.

Canvas API usa el modelo del escritor para dibujar gráficos 2D. Las operaciones se aplican en capas sucesivas unas encima de otras. Cada operación cubrirá algún área del mapa de bits subyacente. Cuando el área se superpone a un área previamente dibujada, la nueva pintura ocultará parcial o completamente la antigua. Esto es lo mismo que funcionan muchas otras API de dibujo, como System.Drawing y Core Graphics de iOS.

Hay dos maneras de obtener un Canvas objeto . La primera consiste en definir un objeto Bitmap y, a continuación, crear instancias de un 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 objeto es mediante el método de devolución de llamada CanvasCanvas que se proporciona a la clase base View. Android llama a este método cuando decide que una vista debe dibujarse a sí misma y pasa un objeto para Canvas 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 de todo el lienzo con la pintura especificada.

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

• Canvas.DrawText: dibuja el texto del 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. Puede ver un ejemplo de esto en el AnimationsDemo 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, debemos tener una pantalla similar a la siguiente:

Animación

A los usuarios les gusta 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 ayudar a destacarla. Las mejores animaciones son las que los usuarios no observan porque se siente naturales. Android proporciona las tres API siguientes para animaciones:

• Ver animación: 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 drawable: es un recurso drawable especial que se usa para aplicar un efecto de animación muy sencillo 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 están limitadas a Vistas y solo pueden realizar animaciones en valores como los puntos inicial y final, el tamaño, la rotación y la 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 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 redimensionamiento.

• translate : movimiento horizontal o vertical.

• set : contenedor que puede contener uno o varios de los demás 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 android:startOffset el atributo en uno de los elementos definidos anteriormente.

Es posible afectar a la velocidad de cambio en una animación mediante un interpolador. Un interpolador permite acelerar, repetir o ralentizar los efectos de animación. Android Framework proporciona varios interpoladores de serie, como (pero sin limitarse a):

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

• BounceInterpolator : el cambio se recupera al final.

• LinearInterpolator : la tasa de cambios es constante.

En el xml siguiente se 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 ajustará la imagen horizontalmente y la reducirá verticalmente y, a continuación, la imagen se girará simultáneamente 45 grados en sentido contrario a las agujas del reloj y se reducirá, y desaparecerá de la pantalla.

La animación se puede aplicar mediante programación a una vista si se infla la animación y, a continuación, se aplica a una vista. Android proporciona la clase auxiliar Android.Views.Animations.AnimationUtils que inflará un recurso de animación y devolverá una instancia de Android.Views.Animations.Animation . Este objeto se aplica a una vista llamando a StartAnimation y pasando el objeto Animation . El siguiente fragmento de código 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 una comprensión fundamental de cómo funcionan las animaciones de vista, vamos a pasar a Animaciones de propiedades.

Animaciones de propiedad

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 propiedad. Calcula los valores de las propiedades que deben cambiarse. no actualiza directamente esos valores; en su lugar, genera ViewAnimator eventos que se pueden usar para actualizar objetos animados.

• ObjectAnimator: esta clase es una subclase de . Está diseñado para simplificar el proceso de animar objetos mediante la aceptación de un objeto de destino y una propiedad para 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 forma nativa, 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 anima no es un , o color, las aplicaciones pueden crear su propio evaluador float mediante la implementación de la interfaz intITypeEvaluator . (La implementación de evaluadores personalizados está fuera del ámbito de este tema).

Uso de ValueAnimator

Hay dos partes para 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 los 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 generador siguientes:

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

Una vez hecho esto, ValueAnimator la 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 durante un 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 clase genera el evento Update cuando decide que es necesario informar a los agentes Animator 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 una comprensión de ValueAnimator , vamos a obtener más información sobre ObjectAnimator .

Uso de ObjectAnimator

ObjectAnimator es una subclase de que combina el motor de control de tiempo y el cálculo de valores de con la lógica necesaria para conectar controladores de ValueAnimator eventos. requiere que las aplicaciones a wire up an event handler (conectar explícitamente un controlador de eventos) se ValueAnimatorObjectAnimator encargan de este paso.

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

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, puede reducir y simplificar el código necesario ObjectAnimator para animar un objeto.

Animaciones drawables

La API de animación final es drawable Animation API. Las animaciones drawables cargan una serie de recursos drawables uno tras otro y los muestran secuencialmente, de forma similar a una animación de volteo.

Los recursos drawables se definen en un archivo XML que tiene un elemento como elemento raíz y una serie de elementos que definen cada <animation-list><item> 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 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. En el fragmento de código siguiente se muestra un ejemplo de cómo crear una animación drawable e iniciarla cuando el usuario hace clic en un botón de 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 abordado los fundamentos de las API de animación disponibles en una aplicación Android.

Resumen

En este artículo se presentaron muchos conceptos nuevos y API para ayudar a agregar algunos gráficos a una aplicación Android. En primer lugar, se han analizado las distintas API de gráficos 2D y se ha mostrado cómo Android permite que las aplicaciones se dibujen directamente en la pantalla mediante un objeto Canvas. También hemos visto algunas técnicas alternativas que permiten crear gráficos mediante declaración mediante archivos XML. Después, analizamos 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 hacer que Mobile Apps vida
• AnimationDrawable
• Lienzo
• Object Animator
• Value Animator