Primeros Pasos como Android Developer (BootCamp Rosario - Parte 4))

Continuamos con la serie de entradas para realizar el Kick-Off de un Developer, es decir, estamos explicando en distintas entradas del Blog la forma en que tenemos que configurar nuestro entorno de desarrollo, para poder crear aplicaciones Android.
Ahora en esta entrada vamos a montar, paso a pas,o un entorno de programación android utilizando la IDE Eclipse, como lo realizamos anteriormente, pero esta vez con el sistema operativo Mac OS X Leopard de Apple.

Introducción

Ya sabemos que Android SDK incluye una completa variedad de herramientas a medida que le ayudarán en el desarrollo de aplicaciones móviles para la plataforma Android.
Entre las más importantes encontramos el Emulador de Android y el plugin que se integra con Eclipse, Android Development Tools, pero el SDK también incluye una variedad de herramientas para debugging, packaging, y instalar sus aplicaciones en el emulador.
A pesar de existir un plugin para Eclipse se puede continuar desarrollando con su editor favorito, ya que a través de línea de comando también se podrá crear, construir y hacer debug de cualquier proyecto Android.

Necesitaremos un framework en nuestro caso vamos a utiizar el eclipse  Galileo con windows de 32 bits.

Descarga e instalación de Eclipse

1. Entrar en la web de descargas de Eclipse, y descárgate la última versión.


Descarga de Eclipse
2. Descomprime el archivo en el lugar donde quieras instalarlo yo siempre recomiendo directamente en el raiz . Te creará un directorio eclipse.
3. Entra en el directorio eclipse y ejecuta eclipse.exe para lanzar la aplicación. La primera vez que arranques, te pedirá que le indiques un directorio donde colocar tu espacio de trabajo (workspace). Selecciona la ruta que quieras, que es donde se guardarán tus proyectos. Marca la opción “Use this as the default…” para que no te vuelva a preguntar más.

Instalación SDK ( Pre-Requisitos)

Ya sabemos que los Sistemas Operativos soportados son:
* Windows XP (32-bit) o Vista (32- or 64-bit)
* Mac OS X 10.4.8 o posterior (x86 only)
* Linux (probado en Linux Ubuntu y Fedora 14) o 64-bit distros capaces de ejecutar aplicaciones de 32 bit.
Y podemos seleccionar los sig. entornos de desarrollo
Eclipse IDE:
* Eclipse 3.4 (Ganymede) or 3.5 (Galileo)
* JDK 5 o JDK 6 (JRE no es suficiente)
*Android Development Tools plugin (opcional)
* Otros entornos de desarrollo o IDEs como IntellijIdea
* JDK 5 o JDK 6 (JRE no es suficiente)
* Apache Ant 1.6.5 o posterior para Linux y Mac, 1.7 o superior para Windows
* Not compatible with Gnu Compiler for Java (gcj)
Requisitos de Hardware
*Para el paquete base de SDK, mínimo 600MB de espacio, para cada plataforma instalada en el SDK son unos 100 MB necesarios.

Descarga e instalación de las Android Development Tools (ADT)

Descargar el paquete con el SDK apropiado a su sistema.

Descargar SDK Android

Descarga SDK Android

Descomprimimos el archivo en una localización adecuada, más adelante se va a necesitar el nombre y la ruta hasta el directorio si queremos configurar el plugin ADT de Eclipse.

1. Dentro de Eclipse, selecciona Install New Software, en el menú Help. Aparecerá una nueva ventana.
2. Dale click en  ADD en la pantalla Available Software en la parte superior derecha.
3. En la ventana que aparece, poner alguna de esta dirección: https://dl-ssl.google.com/android/eclipse/

Instalación

1. Nos pedirá reiniciar el eclipse

1. Una vez reiniciado, debemos configurar Eclipse para que acceda al SDK de Android ya instalado. Abre el menú Eclipse y selecciona Preferences. En el apartado Android, en SDK Location debemos introducir la ruta donde hemos descomprimido el SDK de Android

En windows >> Android SDK and AVD Manager podemos descargar actualizaciones, documentación y ejemplos

Ejecutar una aplicación Android de prueba

Ahora que ya tenemos el entorno de desarrollo listo, vamos a crear un proyecto Androidpara ver que todo funciona correctamente. Lo primero que tendremos que hacer es crear un dispositivo virtual Android o AVD (Android Virtual Device) en el que probar las aplicaciones que desarrollemos.

1. Abrimos el menú Windows y seleccionamos Android AVD Manager.
2. Introducimos el nombre que le queremos dar al dispositivo virtual, seleccionamos la versión de Android que usará (en este caso la 2.2) e introducimos el tamaño de la tarjeta de memoria SD que tendrá (128M nos servirá).En la pestaña Hardware podremos añadir opciones para el funcionamineto del mismo Clicamos en Create AVDy después en Finish.

Ya tenemos el entorno instalado y 100% operativo.

Herramientas del SDK

El SDK de Android incluye una serie de herramientas especificas para el desarrollo de aplicaciones móviles en la plataforma Android, siendo las más importantes el Android Emulator y el ADT de Eclipse.
Android Development Tools Plugin : añade extensiones potentes que permiten crear y hacer debug en nuestras aplicaciones rápidamente y con facilidad.
Android Emulator: emulador basado en QEMU que permite diseñar, crear y probar nuestras aplicaciones sin usar un dispositivo físico.
Android Virtual Devices (AVDs): son configuraciones especificas del emulador que te permiten modelar mejor el dispositivo actual. Se pueden configurar perfiles de hardware, la plataforma elegida, el tamaño de la memoria SD y otras opciones.
Hierarchy Viewer: permite probar y optimizar la interface de usuario. Proporciona una representación visual de las clases del layout y un editor ampliado de la visualización.
Layoutopt: herramienta de línea de comando que carga los ficheros XML especificados y analiza las estructuras y herencias del layout según una serie de reglas predefinidas.
Dalvik Debug Monitor – DDM: permite administrar los procesos que corren en una instancia de emulador/dispositivo demás de asistir en la depuración de ellos.
Android Debug Bridge – ADB: nos permite instalar aplicaciones (.pak) en una instancia del emulador y acceder a una instancia de emulador usando la línea de comandos.
Android Asset Packaging – AAPT: La herramienta “aapt” permite crear archivos “.apk”, los cuales contienen las imágenes binarias de tu código y recursos de tus aplicaciones.
Android Interface Description Language – AIDL: lenguaje IDL usado para generar código que permite a dos procesos en un dispositivo funcionando con Android hablar utilizando comunicación interproceso.
SQLite3: Esta herramienta ha sido incluida para comodidad de los desarrolladores.
Provee acceso a los archivos de datos “SQLite” creados y usados por las aplicaciones Android.
Traceview: Esta herramienta produce una vista gráfica del análisis de información contenida en bitácoras que puede ser generada desde una aplicación Android.
mksdcard: ayuda a crear una imagen de disco que se puede usar con el emulador, para simular la presencia de una tarjeta de almacenamiento externa (tal como una tarjeta “SD”).
dx : convierte los archivos de “bytecode” estándar (“.class”) en archivos “Android bytecode” (“.dex”).
Activitycreator : es un “script” que genera archivos “ant build” que se puede utilizar para compilar aplicaciones Android.

Arquitectura de una Aplicación

Existen 4 tipos de bloques de construcción de cualquier aplicación Android:

Componente de interface de usuario que corresponde normalmente a una pantalla.
BroadcastReceiver Usados para ejecutar código en reacción a unevento externo.
S ervices Es código que se ejecuta en segundo plano (in background).
Content Provider Este componente es usado para compartir datos entre diferentes aplicaciones (Persistencia).

No necesariamente necesitaremos cada uno de ellos en nuestra aplicación, pero si una combinación de algunos.

Activity
Es el componente mas genérico y más común de la plataforma.
Para hacer uso de ella, necesitamos que nuestra clase herede de la superclase Activity.
La principal función es la de mostrar elementos de UI que se implementan en una View, descritos en archivos XML, y que pueden reaccionar a los eventos del usuario.
Para pasar de un elemento Activity a otro se utiliza generalmente mediante el método startActivity() o el método startActivityForResult() cuando se necesita una llamada síncrona.
La navegación entre pantallas se lleva a cabo mediante una clase especial llamada Intent.
La estructura típica de un Intent es: la acción que desea realizar (la intención) y los datos sobre los que actúa.

Intent
A un Intent podemos asociarle una acción, unos datos y una categoría.
Las actividades pueden declarar el tipo de acciones que pueden llevar a cabo y los tipos de datos que pueden gestionar.
Las acciones son cadenas de texto estándar que describen lo que que la actividad puede hacer.
Esta acción viene predefinida en la clase Intent, pero es posible definir nuevas acciones para nuestras actividades.
La misma actividad puede declarar que el tipo de datos del que se ocupa es, por ejemplo, “vnd.android.cursor.dir/person”.
También puede declarar una categoría, que básicamente indica si la actividad va a ser lanzada desde el lanzador de aplicaciones, desde el menú de otra aplicación o directamente desde otra actividad.

1 2 3 4 5

<intent-filter> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <data android:mimeType="vnd.android.cursor.dir/person" /> </intent-filter>

Service
Comunmente conocido, como tal, un servicio es código que se ejecuta en segundo plano (in background) y no necesita de una interface de usuario en su ciclo de vida.
Si el ciclo de vida de una aplicación es prolongado, debe de incluirse en un Service. Conviene informarse de las prioridades que gestiona el sistema en cuanto al tiempo de vida de los componentes y la influencia del servicio en esta jerarquía de prioridades.
Los servicios se inician con el método startService(Intent) de la clase abstracta Context.
De nuevo se utiliza Intent para inciar un resultado desado en la plataforma.

BroadcastReceiver
Si una apliación desea recibir y repsonder a un evento global como por ejemplo una llamada de teléfono o un mensaje de texto entrante, debe registrarse como BroadcastReceiver. Existen dos técnicas:
1. La aplicación puede implementar un elemento <receiver> en el archivo AndroidManifest.xml. Si el receptor se registra en dicho archivo, no es necesario ejecutarlo para desencadenarlo. El propio SO de Android se encarga de estas tareas de mantenimiento.
2. Una aplicación se puede registrar en tiempo de ejecución a través del método registerReceiver de la clase Context.
Al igual que Service, no dispone de UI. El código que se ejecuta en el método inRecevie no debe asumir operaciones de persistencia o prolongadas.

ContentProvider
Si una aplicación gestiona datos y debe mostrarlos a otras aplicaciones ejecutadas en el entorno de Android, es necesario implementar ContentProvider.
Implementa un conjunto estándar de métodos para que la aplicación pueda acceder a un almacén de datos, ya sea en operaciones de lectura o escritura.
ContentProvider puede proporcionar datos a una actividad o a unservicio incluidos en la misma aplicación o en otra diferente.
Se puede considerar como una capa de datos que proporciona abstracción para sus clientes y centraliza las rutinas de almacenamiento y recuperación.
Suele ser componente de aplicaciones Android de mayor tamaño que alojan al menos un elemento Activity, Service y/o BroadcastReceiver.

Hello Android

Haremos el tipico programa de Hello para comprbar que todo el proceso de instalación ha sido correcto

Creamos un nuevo proyecto Android: File > New > Android Project. Introducimos los siguientes datos para el proyecto:

• Project Name: HelloAndroid
• Application name: Hello, Android
• Package name: com.example.helloAndroid
• Create activity: helloAndroid
• min SDK version: 8

Una vez creado del proyecto vamos a ver la  estructura de un proyecto Android

1. Assets: En este directorio se pone cualquier tipo de fichero externo que sea necesario por la aplicación que se esté ejecutando. Por ejemplo: HTML para el navegador sin necesidad de conexión, tipografías, jars de terceros. Es un repositorio de archivos.
2. Bin: Los binarios compilados de la aplicación.
3. Res: Los recursos, formada por 3 direcotorios:
- Drawable: ficheros de imágenes.
- Layout: Ficheros de diseño de las interfaz de
usuario. Ficheros xml que describen las interfaces.
- Values: definición de variables. Ficheros xml en cada uno de ellos constantes, se agrupa por temática, es decir: definición de colores,definición de texto…

4. Gen: Se almacenan los archivos auto-generados por el compilador de Android. Contiene el archivo “R.java”, que es un índice a todos los recursos definidos en el proyecto.
5. Src: Aquí va todo el código Java de la aplicación.
6. .project, .classpath: ficheros necesarios para abrir el proyecto con Eclipse.
7. AndroidManifest.xml: es un archivo requerido para cada aplicación.
Describe los valores globales de su paquete, incluida la aplicación, componentes (actividades, servicios, etc), las clases para cada uno de los componentes, qué tipo de datos puede manejar cada uno, y donde puede ser lanzado.

Application
android:icon=”drawable resource” ? Se define el icono de la aplicación. Se mostrará cuando la instalación esté instalada en el dispositivo.
android:name=”string” ? A través de este atributo se declara el nombre de la aplicación, aparecerá debajo del icono al instalar.
android:theme=”resource or theme” ? Podemos crear un tema general y usar en toda la aplicación.
activity, service, provider… Cada Activity, Service o Content Provider que creamos en nuestra aplicación debe de estar aquí. En caso contrario, la aplicación no los va a reconocer.

Permissions
Dentro de la etiqueta <manifest> podemos añadir el nodo <users-permission>. Se utiliza para definir las partes a las que la aplicación necesita acceder y los permisos de los usuarios.
-Recibir SMS
-Capturar imágenes desde la cámara
-hacer llamadas
-Acceder a internet…
Cuando se instalan aplicaciones desde el Android Market, algunas tienen un listado de permisos, donde el usuario debe permitirlos o aceptarlos si se quiere instalar la aplicación en el dispositivo.

Version
La etiqueta <uses-sdk>, se define con que versión del SDK la aplicación fue creada, con lo que se puede definir una compatibilidad hacia versiones anteriores.

En nuestro ejemplo de Hello Android deberemos modificar nuestra clase helloAndroid

Y aca tenemos nuestro resultado

A continuar ahora desarrollando, ya que tenemos instalado nuestro entorno de developer en MAC OS y en Windows XP/Vista/7.

saludos,

MAriano!

Primeros Pasos como Android Developer (BootCamp Rosario - Parte 3)

Estructura de un proyecto Android

Para empezar a modificar este ejemplo recién creado, estudiemos la estructura de directorios creada de una aplicación Android, así lo tenemos de ejemplo como una aplicación típica.

Cuando creamos un nuevo proyecto Android en Eclipse se genera automáticamente la estructura de carpetas necesaria para poder generar posteriormente la aplicación. Esta estructura será común a cualquier aplicación, independientemente de su tamaño y complejidad.

En la siguiente imagen vemos los elementos creados inicialmente para un nuevo proyecto Android:

Estudiemos estos elementos principales.

Carpeta /src/            

Contiene todo el código fuente de la aplicación (Ejemplo.java), código de la interfaz gráfica, clases auxiliares, etc. Inicialmente, Eclipse creará por nosotros el código básico de la pantalla principal (una Activity) de la aplicación, siempre bajo la estructura del paquete java definido.

Acaba de aparecer un término nuevo, para aquellos que estén acostumbrados a trabajar en Java: Activity. Más adelante haré un detallado glosario de los términos que usa Android. Por ahora, con que tengamos en cuenta que una Activity es un elemento sobre el que se construye la aplicación y que tiene un ciclo de vida bastante complejo estamos por un muy buen camino. Estas Activities son pantallas de la aplicación, en las que podemos cargar elementos de la interfaz de usuario y capturar eventos. También son los puntos entrantes de la aplicación y puede haber más de una Activity por proyecto.

Si seguimos mirando la estructura, nos encontraremos con las librerías de Android (android.jar, representado por Android 2.2 en la imagen), que nos dan toda la funcionalidad del sistema. Estas librerías dependen de la versión del SDK con el que estemos trabajando. ¿Una buena práctica de programación? siempre estar actualizados en este tema, para esto regularmente visitar la página de desarrolladores Android: http://developer.android.com/index.html A lo largo de este blog utilizaremos la versión 2.2 del SDK y a veces la 4.0 Ice Cream S. para ir estudiando los detalles, y buscaremos tener compatibilidad con versiones anteriores.

Carpeta /res/                  

Son los archivos de recursos necesarios para el proyecto: imágenes, vídeos, cadenas de texto, etc. Los diferentes tipos de recursos se deberán ordenar entre las siguientes carpetas:

·         /res/drawable/. Directorio que contienen las imágenes de la aplicación. Se puede dividir en subcarpetas según la resolución de pantalla de los dispositivos, por ejemplo: /drawable-ldpi, /drawable-mdpi y /drawable-hdpi para utilizar diferentes recursos dependiendo de la resolución del dispositivo.

·         /res/layout/. El Layout, este directorio contienen los archivos de definición de las diferentes pantallas de la interfaz gráfica. Se puede dividir en /layout y /layout-land para definir distintos layouts dependiendo de la orientación del dispositivo.

·         /res/anim/. Contiene la definición de las animaciones utilizadas por la aplicación.

·         /res/menu/. Contiene la definición de los menús de la aplicación.

·         /res/values/. Contiene otros recursos de la aplicación en archivos XML como por ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), etc.

·         /res/xml/. Contiene los archivos XML utilizados por la aplicación.

·         /res/raw/. Contiene recursos adicionales, normalmente en formato distinto a XML, que no se incluyan en el resto de carpetas de recursos.

Como ejemplo, para un proyecto nuevo Android, se crean los recursos para la aplicación que se observan en la imagen, es decir, el Wizard de Eclipse nos ayuda mucho, incluso nos brinda un icono para la aplicación, que luego podemos cambiar.

Carpeta /gen/

De ahora en adelante, asociemos el directorio “gen” con GENERADO, esta carpeta contiene una serie de elementos generados automáticamente al compilar el proyecto. Cada vez que generamos nuestro proyecto, compilándolo desde Eclipse y empaquetándolo, la maquinaria de compilación de Android genera por nosotros una serie de archivos fuente, en java, dirigidos al control de los recursos de la aplicación.

De todo lo que nos genera, el archivo más importante es el que se puede observar en la imagen, el archivo R.java, que contiene la clase R.

Esta clase R contendrá en todo momento una serie de constantes con los ID de todos los recursos de la aplicación incluidos en la carpeta /res/, de forma que podamos acceder fácilmente a estos recursos desde nuestro código a través de este dato. Así, por ejemplo, la constante R.drawable.icon contendrá el ID de la imagen “icon.png” contenida en la carpeta /res/drawable/. Veamos como ejemplo la clase R creada por omisión para un proyecto nuevo:

package com.tutoriales.ejemplo; public final class R {     public static final class attr {     }     public static final class drawable {         public static final int icon=0x7f020000;     }     public static final class layout {         public static final int main=0x7f030000;     }     public static final class string {         public static final int app_name=0x7f040001;         public static final int hello=0x7f040000;     } }

La clase R.java es muy especial, ya que nosotros no podemos modificarla manualmente, de hecho, se genera automáticamente cada vez que modificamos los archivos de recursos, ya sea un xml con la definición de un estilo, o un xml con cadenas de texto. Esta clase se podría considerar el nexo de unión entre los recursos, el XML y las clases puramente Java. Ya veremos más adelante este tema, lo que es sumamente importante es que NO LA EDITEMOS NI MODIFIQUEMOS A LA CLASE R, contenida en el archivo R.java.

Carpeta /assets/

Contiene todos los demás archivos auxiliares necesarios para la aplicación (y que se incluirán en su propio paquete), como por ejemplo archivos de configuración, de datos, etc.

La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidos en la carpeta /assets/ es que para los primeros (/res/raw/) se generará un ID en la clase R y se deberá acceder a ellos con los diferentes métodos de acceso a recursos. Para los segundos sin embargo no se generarán ID y se podrá acceder a ellos por su ruta como a cualquier otro archivo del sistema. Usaremos uno u otro según las necesidades de nuestra aplicación.

Archivo AndroidManifest.xml

Es un archivo muy importante, ya que tiene la definición en XML de los aspectos principales de la aplicación, como por ejemplo su nombre, versión, icono a mostrar, sus componentes, y también debemos registrar los permisos necesarios para su ejecución. Veremos más adelante muchos más detalles de este archivo.

<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android"       package="com.tutoriales.ejemplo"       android:versionCode="1"       android:versionName="1.0">   <application android:icon="@drawable/icon" android:label="@string/app_name">         <activity android:name=".Ejemplo"                   android:label="@string/app_name">             <intent-filter>                 <action android:name="android.intent.action.MAIN" />                 <category android:name="android.intent.category.LAUNCHER" />             </intent-filter>         </activity>     </application> </manifest>

Bueno, en estas 3 primeras partes del BootCamp hemos cubierto lo mínimo y basico para comenzar a desarrollar para Dispositivos Android. Yo aca recomende utilizar Windows, pero tambien funciona muy bien en Mac OS y los Linux.

Hasta la proxima entrega, saludos,
MAriano!

Primeros Pasos como Android Developer (BootCamp Rosario - Parte 2

Creación y análisis del primer programa

Nuestro objetivo ahora es ir probando la instalación a través de un ejemplo. Comenzamos con el “clásico” de la programación, el programa “HolaMundo” que es como se comienza todo curso introductorio de programación, pero dejaríamos de lado algunos conceptos interesantes y muy útiles desde el comienzo con solo ese primer ejemplo. 

Así que, luego de ejecutarlo exitosamente, vamos a adaptar el “HolaMundo” para obtener otra aplicación, vamos a crear una aplicación que le pida al usuario que ingrese su nombre y edad y que nos muestre en otra pantalla dicha información. Analizaremos estos dos ejemplos para comenzar a introducir los nuevos conceptos de la programación Android.

Entonces, para dicha tarea vamos a crear un proyecto muy básico para comprobar que hemos hecho todo correctamente, que ya tenemos en nuestra PC todo el entorno de desarrollo configurado.

Antes de comenzar, tengo que aclarar que las imágenes pueden variar entre versiones de Eclipse, nosotros a lo largo de este libro utilizaremos Eclipse 3.6 (HELIOS).

Comenzando con  “HolaMundo”, dentro de Eclipse, vamos al menú File > New > Project... 

Seleccionamos un  Android Project y pulsamos sobre Next.

Crearemos el proyecto “HolaMundo”, indicaremos como target por ejemplo “Android 2.2″, daremos un nombre a la aplicación e indicaremos que se cree una actividad llamada “HolaMundo”.

En el cuadro de diálogo del wizard, introducimos los valores que aparecen en la imagen siguiente.

Pulsamos sobre Finish.

1.3 Crear Dispositivo Virtual Android

Antes ya nos aseguramos de que instalamos todas las herramientas de trabajo y las configuramos dentro de Eclipse. Lo que necesitamos ahora es ejecutar Android en nuestra PC.

Ya tenemos el proyecto básico HolaMundo creado, ahora necesitamos poder ejecutarlo en nuestra PC, ¿con qué? Con un Emulador, creando uno o más AVD (Android Virtual Devices).

Un Android Virtual Device (AVD) es una herramienta fundamental para los programadores, ya que nos permite emular en nuestra computadora los dispositivos móviles a los que apunta nuestra aplicación. Por omisión, cuando se instala el AVD Manager, no viene creado ningún dispositivo. Entonces, vamos a estudiar cómo crear estos dispositivos virtuales y así no sólo testear nuestra aplicación, sino también conocer Android desde nuestra computadora.

El AVD Manager es el software que nos permitirá gestionar estos dispositivos, podemos ejecutarlo desde dentro o fuera de Eclipse. Por el momento, y como proceso de aprendizaje, para a administrar los dispositivos virtuales de Android, utilizaremos Eclipse. Entonces, dentro de Eclipse vamos a ir al AVD Manager, cuyo icono está encerrado con un círculo en la siguiente imagen:

Luego, se nos despliega una ventana con el listado de los dispositivos existentes, y vamos a presionar el botón New que se encuentra en el lado de la derecha. En un principio no deberíamos tener ningún dispositivo virtual en la lista.

Se despliega una nueva pantalla para configurar y crear nuestro nuevo dispositivo virtual.

◦ Nombre: Es nombre que recibirá nuestro dispositivo virtual. Se recomienda que el nombre contenga la versión de Android, por ejemplo: Droid_2_2 o AVD_2_1, por nombrar dos.
◦ Target: Es la versión de Android que correrá sobre nuestro dispositivo.

Atención, con sólo ingresar esos dos valores ya tendremos un dispositivo listo para usar, ya que el resto de los valores necesarios se completarán de forma automática con valores por omisión para que todo funcione.
Repasemos qué atributos de los dispositivos AVD nos van a interesar más adelante en el libro, cuando necesitemos distintos dispositivos para testear nuestras aplicaciones:

◦ SD Card: Aquí configuramos lo referido con la SD Card. Se puede seleccionar el tamaño o cargar el archivo de una SD Card existente.
◦ Skin: Es la sección donde configuramos lo referido con la pantalla. Se puede seleccionar el tipo de pantalla automáticamente o ingresar la resolución. Esto será útil más adelante, tener distintos dispositivos donde solo cambie el tipo de pantalla o resolución.
◦ Hardware: En este listado podemos agregar todo lo referido al soporte hardware que tendrá nuestro dispositivo virtual. Por ejemplo, que posea acelerómetro, cámara, teclado físico, etcétera.

Una vez que completamos los campos opcionales, que por el momento no son necesarios, vamos a pulsar el botón Create AVD en la misma pantalla de configuración del AVD y luego tenemos que presionar el botón OK del cartel de confirmación que aparecerá.

Ya con el AVD creado, lo vamos a seleccionar y presionar el botón Start para probar nuestra creación, que se encuentra como ultima opción en el menú de la derecha:

Inmediatamente nos aparecerá una ventana con las opciones sobre cómo se va a simular la pantalla del AVD en el monitor, pero se va a dejar todo por omisión y damos clic en Launch.

¡Listo! Ya tenemos un AVD ejecutándose, luego de esperar unos minutos para el arranque del dispositivo (tengamos paciencia, según el hardware que utilizamos),  vamos a poder utilizar Android y probar las aplicaciones.

Crear más de un AVD será útil para nosotros como programadores, en el momento en que queramos testear nuestra aplicación en otras versiones de Android (2.1, 1.6 por ejemplo) y con distintas configuraciones de hardware. Aunque tengo que aclarar, que no hay nada mejor que testear nuestras aplicaciones en un dispositivo físico real, es decir, en un SmartPhone con Android, porque podremos observar otros detalles, como lo es “el impacto de nuestra aplicación en el consumo de batería del dispositivo”, es decir, no queremos que al usuario se le descargue su batería por un mal funcionamiento de nuestro software.

Recordemos que no es necesario volver a ejecutar el AVD cada vez que quieras probar tu proyecto, tan sólo vamos a ejecutar la aplicación y automáticamente se instalará y ejecutará en el dispositivo que estés corriendo (siempre y cuando sea compatible con la versión que hayas elegido para tu programa). Es decir, no vamos a consumir recursos de la PC inútilmente, no apaguemos el emulador de Android, aprovechémoslo al máximo, ya que tardó bastante en arrancar.

1.4 Ejecutar en el Emulador
Entonces a continuación tenemos que ejecutar aquel proyecto simple, el llamado “HolaMundo” que creamos anteriormente. Para esto seleccionamos en Eclipse el menú Run > Open Run Dialog...

Con un doble clic seleccionamos Android Application. 

En el cuadro Name ponemos Ejecución normal, o algo que nos recuerde que ejecutamos.

En el cuadro Project, pulsa sobre Browse... Selecciona HolaMundo y pulsa sobre OK.

En la caja combo de Activity y selecciona el único elemento que hay.

Clic sobre Apply. Y deberías tener algo parecido a esto:

Clic sobre el botón Run para comenzar la ejecución, y en la consola de Eclipse vamos a ir leyendo “cosas” similares a las que aparecen en esta imagen:

El emulador ya fue iniciado anteriormente, y como podemos ir leyendo en la Consola de Eclipse, se instaló con éxito el archivo “HolaMundo.apk”, así con esto debería arrancar la ejecución del proyecto "vacío" que acabamos de crear mostrando “Hello World, Ejemplo” en pantalla. En caso de que no nos arranque nuestra aplicación de forma automática, tendremos que seleccionarla con un clic, luego de navegar por el menú de aplicaciones que nos muestra nuestro AVD.

Si has llegado hasta acá, juntos hemos dado un gran paso, ya que hemos configurado de forma correcta todas las herramientas necesarias para comenzar a desarrollar aplicaciones para Android, tal vez solo desde tu casa, o en compañia nuestra desde el BootCamp Android Rosario 2011.

Hasta la proxima entrada,

saludos, MAriano!