Inicio a la programación en Android

v1.1

Oct 2010

Autores:

Alberto Población Navarro

Alberto Gutiérrez Martínez

Inicio a la programación en Android....................................................................................................................... 1
v1.1 .............................................................................................................................................................................. 1
Autores: .......................................................................................................................................................................... 1
Alberto Población Navarro ..................................................................................................................................... 1
Alberto Gutiérrez Martínez .................................................................................................................................... 1
Tema 1: Introducción a Android. .............................................................................................................................. 4
¿Qué es Android? ........................................................................................................................................................ 4
Historia y desarrollo. ................................................................................................................................................ 5
Empresas participantes ........................................................................................................................................... 7
Arquitectura del Sistema Operativo ................................................................................................................ 10
Linux Kernel ......................................................................................................................................................... 11
Bibliotecas nativas ............................................................................................................................................. 13
Android Runtime ................................................................................................................................................ 15
Application Framework................................................................................................................................... 16
Tema 2: Desarrollo de Aplicaciones en Android (I) ...................................................................................... 18
Lenguaje de programación: Java....................................................................................................................... 18
Software Development Kit: SDK ....................................................................................................................... 18
Configuración del emulador: ......................................................................................................................... 27
Arquitectura aplicación ........................................................................................................................................ 31
Bloques constituyentes de una aplicación............................................................................................... 31
Ciclo de vida de una aplicación..................................................................................................................... 33
Archivos de un proyecto Android ............................................................................................................... 36
Creación de una aplicación: Hello World! ..................................................................................................... 40
Desarrollo en un teléfono ............................................................................................................................... 43

http://tmovil.usal.es
 Tema 1: Introducción a Android.

¿Qué es Android?

Android1 es una plataforma de software y un sistema operativo para dispositivos

móviles basado en el núcleo de Linux. Esta plataforma ofrece: sistema operativo, middleware
(capa de abstracción software situada entre las aplicaciones y el sistema operativo junto con
la red) y herramientas para el desarrollo de aplicaciones móviles.

Android ha sido creada por una serie de empresas

unidas en la denominada Open Handset Alliance2. En ella se
agrupan 47 empresas de diferentes ámbitos como pueden ser
empresas de telefónica, de creación de hardware, de
fabricación de hardware y de teléfonos. La empresa más
importante y más involucrada en el desarrollo de este sistema
operativo es Google3.

La plataforma ha sido creada totalmente abierta. El sistema está diseñado para

permitir a los desarrolladores crear aplicaciones y explotar todas las ventajas que un teléfono
puede ofrecer creando aplicaciones que pueden desde realizar llamadas, mandar mensajes o
usar la cámara. Al ser creado como código abierto puede extenderse para incorporar nuevas
tecnologías emergentes.

En Android todas las aplicaciones son ejecutadas con los mismos privilegios,
no existe diferencia entre las aplicaciones del núcleo y aquellas creadas por terceras
personas. Una aplicación puede utilizar todas las características proporcionadas por el
teléfono ofreciendo a los usuarios gran variedad de servicios. Se puede desde cambiar la
pantalla de inicio, el programa de marcación telefónica o la aplicación por defecto que se
utilizará para la visualización de fotografías.

1
Android: http://www.android.com/
2
Open Handset Alliance: http://www.openhandsetalliance.com/
3
Google: http://www.google.com/

http://tmovil.usal.es
 Con Android se intentan romper las barreras de desarrollo e innovación en
aplicaciones para móviles. Un desarrollador puede combinar información obtenida desde una
página Web con la información en su propio teléfono para mejorar la experiencia de usuario.

Se facilita el uso de un gran número de bibliotecas y herramientas que pueden ser

utilizadas para desarrollar software. Gracias a las capacidades hardware, con una aplicación
se puede obtener la localización del dispositivo y comunicarse con otro mediante aplicaciones
peer-2-peer (red informática entre iguales, sin clientes-servidores). Además, se incluye un
gran número de herramientas que han sido construidas junto con el desarrollo de la
plataforma para permitir a los desarrolladores una alta productividad y una profunda visión
de su aplicaciones.

El sistema operativo está construido sobre un núcleo abierto de Linux. Se ha

desarrollado una maquina virtual diseñada especialmente para la optimización de memoria y
el uso de recursos hardware en entornos móviles. Actualmente Android permite desarrollar
con lenguaje Java e incluye bibliotecas desarrolladas o adaptadas por Google (Google
APIs).

Historia y desarrollo.

Android es un sistema operativo de reciente desarrollo. Se puede definir su inicio el

5 de noviembre de 2007 cuando fue anunciado como su primer producto por la recién
presentada Open Handset Alliance. Ese mismo mes fue lanzada una primera versión del
SDK. En la Ilustración 1 se observa la evolución del sistema hasta que el 21 de octubre de
2009 el código fuente de Android fue liberado.

http://tmovil.usal.es
Ilustración 1. Android Timeline

http://tmovil.usal.es
 Además de las fechas que se muestran en el diagrama, es importante resaltar ciertos
hechos significativos en este periodo de tiempo para explicar la evolución de ésta plataforma
para móviles.

En noviembre de 2007 se publica la primera versión del SDK para que pueda ser
utilizado por desarrolladores.
En enero de 2008 se anuncia el primer concurso de aplicaciones para Android que tuvo
gran acogida con más de 1700 participaciones.
En agosto de 2008 se presenta el Android Market, una plataforma libre para la
distribución de contenido entre usuarios y desarrolladores.
En septiembre de 2008 se anuncia el primer móvil con Android: HTC G1 o Google
phone; coincidiendo con la publicación de la versión 1.0 del SDK.
En abril de 2009 se publica la nueva versión del sistema operativo con el SDK: Android
1.5 Cupcake.

Empresas participantes

El conjunto de empresas participantes que han

desarrollado Android están unidas en la denominada Open
Handset Alliance. Esta alianza esta formada por un grupo de
47 compañías de tecnología y móviles cuyo objetivo es acelerar
la innovación en telefonía y ofrecer a los clientes una
experiencia de uso innovadora y asequible. Todas las partes
del entorno de tecnologías móviles están representadas en la
alianza. Cada tipo de compañía se compromete al desarrollo del
proyecto en el ámbito que le corresponda. Se incluyen operadoras de telefonía, fabricantes
de móviles y de componentes, empresas de software, y compañías de comercio. Todas estas
empresas se comprometieron a realizar una versión de éxito comercial de la plataforma
según las características de la compañía:

Empresas de software (ver Ilustración 5) son las encargadas del desarrollo de software.
Dentro de estas empresas destaca Google4.
Los fabricantes de componentes (ver Ilustración 4) son los encargados de crear
hardware compatible con la plataforma. Dos ejemplos de grandes empresas
5 6
participantes son Nvidia o Intel .

4
Google: http://www.google.com
5
Nvidia: http://www.nvidia.com

http://tmovil.usal.es
 Fabricantes de móviles (ver Ilustración 3) cuya finalidad es la producción de teléfonos
móviles. Destacan empresas como HTC7 o Sony Ericsson8.
Operadoras de telefonía (ver Ilustración 2) y de comercio (ver Ilustración 6)
encargadas de distribuir la plataforma mediante modelos de servicios profesionales. En
España participan dos grandes operadoras como Telefónica9 y Vodafone10.

Ilustración 2. Operadoras móviles.

6
Intel: http://www.intel.com
7
HTC: http://www.htc.com
8
Sony-Ericsson: http://www.sonyericsson.com
9
Telefónica: http://www.telefonica.com
10
Vodafone: http://www.vodafone.com

http://tmovil.usal.es
Ilustración 3. Fabricantes de teléfonos.

Ilustración 4. Fabricantes de hardware.

http://tmovil.usal.es
Ilustración 5. Compañías de Software.

Ilustración 6. Compañías comerciales

Arquitectura del Sistema Operativo

Por tratarse de una nueva plataforma de desarrollo, es importante conocer la

estructura interna del sistema operativo para poder trabajar con él. Por la filosofía de
desarrollo seguido en el proyecto, Android es totalmente abierto al programador. Cualquier
desarrollador puede utilizar todos los servicios provistos por el sistema operativo para sus
propias aplicaciones.

A continuación se realiza un análisis de las diferentes capas que componen Android

(ver Ilustración 7) centrándose en los aspectos relevantes de cada una.

10

http://tmovil.usal.es
Ilustración 7. Arquitectura Android

Linux Kernel

Comenzando por la capa de abstracción más cercana al hardware se encuentra el

núcleo, o kernel, de Linux. Android no es una distribución de Linux pese a estar basado en su
núcleo. Esta parte proporciona unos servicios muy importantes relativos a la seguridad, la
memoria, los procesos, la red y los modelos de los drivers (controladores de dispositivos).

El kernel utilizado no ofrece un sistema nativo de ventanas ni el conjunto entero de

herramientas estándar de Linux.

Ilustración 8. Partes del núcleo de Linux.

Características
Actualmente Android utiliza el estándar de kernel versión 2.6.27
No existe soporte para glibc: Biblioteca estándar de C que entre otras características
proporciona y define llamadas al sistema y es muy utilizada en sistemas GNU basadas
en el kernel de Linux.

11

http://tmovil.usal.es
 Se añade un conjunto de mejoras en el kernel para el soporte de Android. Destacan la
introducción del Binder y el Power Management.
Alarm: herramienta para el control del tiempo. Dentro de la API se encuentran tres
tipos de relojes que permiten este control:
El encargado de medir el tiempo real.
Un reloj que mide el tiempo que lleva el dispositivo encendido sin contar el
tiempo en suspensión.
Un reloj que mide el tiempo total que lleva el dispositivo encendido.
Ashmem (Anonymus Shared Memory): sistema de memoria compartida que ofrece
las interfaces necesarias para que los procesos puedan compartir bloques de
memoria.
Low Memory Killer: herramienta llamada automáticamente que escanea los procesos
ejecutados y libera memoria cuando ésta escasea.
Kernel Debugger: instrumento que facilita la depuración y el desarrollo de
aplicaciones.
Logger: herramienta que permite almacenar mensajes del registro del kernel en un
buffer (zona de memoria reservada para almacenamiento temporal). Los procesos de
usuario pueden escribir y leer de este buffer.
Binder: cuando las aplicaciones corren en procesos separados y desean comunicarse
y compartir información puede producirse agujeros de seguridad. Para solucionar
este problema se crea un controlador para mejorar la comunicación entre procesos o
IPC (Inter-Process Comunication) mediante llamadas a unas API de más alto nivel.
Mejora el rendimiento en el uso de memoria compartida.
Para peticiones de procesamiento existe una pila de hilos por proceso.
Mantiene la referencia del contador y del mapeo de objetos entre procesos.
Proporciona llamadas sincronizadas entre procesos.
Power Management: da solución al problema de limitación de batería de los
dispositivos móviles. Crea un administrador de energía con una política más
agresiva que funciona por encima del gestor del kernel de Linux. Para que las
aplicaciones puedan mantener activa la CPU se utilizan los denominados wake locks,
gracias a este servicio se evita que el teléfono entre en suspensión o sleep mode. En
la Ilustración 9 se puede observar un diagrama de secuencia explicando el
funcionamiento del Power Management.

12

http://tmovil.usal.es
Ilustración 9. Power Management.

Bibliotecas nativas

Por encima de núcleo de

Linux, el siguiente nivel de
software que se encuentra son las
bibliotecas nativas de Android.

Características
Biblioteca Bionic: se trata de la implementación propia de la biblioteca estándar de C
(glibc) para su uso integrado en el sistema. Esta licenciada bajo BSD. Esta biblioteca se
carga con cada proceso, por ello se necesita que sea rápida y de pequeño tamaño
debido a la limitada capacidad de procesamiento de los terminales. Es por estas razones
por la que se creó esta biblioteca completamente nueva. Está preparada para trabajar
con los servicios específicos de Android. Bionic libc no es compatible con GNU libc
(glibc) y no soporta ciertas características de las interfaces de sistemas operativos
portátiles, POSIX (Portable Operating System Interface).
Biblioteca de funciones:
Webkit: está basada en el código abierto del navegador Webkit. Es compatible con
CSS, JavaScript, DOM, y AJAX. Es capaz de mostrar las páginas a tamaño
completo. (Más información en la web de Webkit11).

11
Webkit: http://webkit.org/

13

http://tmovil.usal.es
 Media Framework: biblioteca basada en el OpenCORE de PacketVideo. Este motor
proporciona las características esenciales para el desarrollo de aplicaciones
multimedia. Soporta estándares de video y audio. (Más información en la web 12)
SQlite13: gestor liviano transaccional de almacenamiento de datos. Implementa el
motor de bases de datos SQL.
Servidores nativos:
Surface Flinger: proporciona un compositor de pantallas. Se encarga de manejar
todas las capas enviándolas al dispositivo de frame buffer (encargado de la porción
de memoria que almacena los gráficos antes de ser enviados a la pantalla). Para
transferir las capas al buffer utiliza llamadas al Binder IPC. Es capaz de manejar
superficies en 2D y 3D utilizando OpenGL ES (API gráfica OpenGL 14 para sistemas
integrados) y aceleración hardware.

Ilustración 10. Surface Flinger.

Audio Flinger: es el encargado de manejar todas las salidas de audio. Procesa los
flujos de sonido mediante un modulador de pulsos codificados (PCM) y los envía a
una o varias salidas de audio.

Ilustración 11. Audio Flinger

Biblioteca de abstracción de hardware: encargada de separar la plataforma lógica de

Android, de la interfaz de hardware. Es necesaria porque cada componente tiene un driver (o
controlador) distinto que debe cumplir un requerimientos de Android.

12
PacketVideo: http://www.packetvideo.com/products/android/index.html
13
SQlite: http://www.sqlite.org/
14
OpenGL: http://www.opengl.org/

14

http://tmovil.usal.es
 Android Runtime

En este apartado se definen las partes referentes al tiempo de ejecución de las

aplicaciones como son las bibliotecas del núcleo y la Máquina Virtual Dalvik.

Ilustración 12. Android Runtime

Dalvik Virtual Machine: Android tiene su propia implementación de la máquina virtual de

Java. Proporciona portabilidad a las aplicaciones y consistencia en tiempo de ejecución.
Está preparada para trabaja de forma optimizada con archivos “dex”, es decir clases de
java convertidas en tiempo de compilación. Dalvik Virtual Machine está diseñada para
trabajar en un sistema integrado, soporta múltiples instancias para procesos y tiene
optimizado el intérprete de bytecodes. Un bytecode es código intermedio más abstracto
que código máquina; es tratado como un fichero binario que contiene un programa
ejecutable. El uso de memoria de la máquina virtual en tiempo de ejecución es muy
eficiente.
Core Libraries (Bibliotecas del núcleo): son las interfaces de programación de
aplicaciones que proporcionan una potente y simple plataforma de desarrollo. Por
ejemplo: Network access, File Access o Graphics. Estas bibliotecas proporcionan la
mayoría de las funcionalidades disponible en el núcleo del lenguaje de programación
Java.

15

http://tmovil.usal.es
 Application Framework

En esta capa se encuentran las estructuras que soportan las aplicaciones creadas. A
continuación se pueden observar sus diferentes componentes.

Ilustración 13. Application Framework.

Esta parte del sistema operativo es de especial relevancia en el desarrollo ya que

permite la comunicación entre el hardware y nuestra aplicación. Para acceder a dichas
características, existen una serie de objetos denominados Manager que permiten su
utilización. Estos objetos son los encargados manejar los servicios ofrecidos por hardware y
devolver los recursos necesarios para su utilización. Dentro del entorno de desarrollo se
encuentran diferentes tipos:

Activity Manager: gestiona el ciclo de vida de las aplicaciones. Interactúa con todas las
actividades corriendo en el sistema.
Package Manager: se encarga de manejar información relacionada a los paquetes de
aplicaciones instalados en el sistema.
Windows Manager: gestiona la capa de mayor nivel donde las aplicaciones pueden
colocar sus ventanas
Telephony Manager: proporciona la información sobre los servicios de telefonía del
dispositivo.
Resource Manager: proporciona el acceso a los recursos distintos al código como
cadenas, gráficos y plantillas de diseño o layouts.
Notification Manager: permite a las aplicaciones mostrar notificaciones en la barra de
estado.
Content Provider: permite a las aplicaciones acceder a datos de otras aplicaciones y
compartir sus propios datos.
View System: el sistema de vistas es utilizado para construir la aplicación incluye listas,
botones e incluso un visor web integrado.

Muchas de estas características se verán con más detalle en el tema dedicado al

desarrollo de aplicaciones.

16

http://tmovil.usal.es
 Dentro de los recursos provistos por el hardware se encuentran desde recursos
referentes a la conectividad, a sensores internos y relativos a la localización del terminal.

Telephony Service: recurso relativo a las características telefónicas del teléfono.

Location Service: suministra las herramientas para la localización del teléfono mediante
redes GPS.
Bluetooth Service: proporciona las herramientas para la utilización del bluetooth
(dispositivo de red inalámbrico que funciona mediante radiofrecuencia).
WiFi Service: proporciona el acceso al dispositivo de red de ordenadores inalámbrico.
USB Service: facilita el uso del bus de datos serie.
Sensor Service: proporciona acceso a los dispositivos internos del teléfono como pueden
ser acelerómetro, sensor de campo magnético o termómetro.

17

http://tmovil.usal.es
 Tema 2: Desarrollo de Aplicaciones en Android (I)
En este tema se pretende indicar los pasos necesarios para comenzar a crear una
aplicación. Una vez conocido la estructura de la plataforma es importante conocer los
recursos provistos por Google para desarrollar software para Android. Además del SDK, se
explica el ciclo de vida de las aplicaciones y los bloques más importantes que pueden
constituirlas.

Lenguaje de programación: Java

Actualmente el desarrollo de aplicaciones en Android solo está soportado en lenguaje

Java, concretamente J2SE. Gracias a este lenguaje y mediante las APIs provistas por Google
se pueden acceder a todos los recursos de los dispositivos móviles para crear las
aplicaciones.

Para más información acerca de este lenguaje de programación se recomienda visitar

la web de Sun Microsystems15; en ella se encuentra tutoriales y código de ejemplo para
aprender Java.

Software Development Kit: SDK

Para poder crear aplicaciones para la plataforma Android, se encuentra a disposición

de los programadores un conjunto de herramientas que permiten el desarrollo de software:
Software Development Kit (SDK)16. El SDK se encuentra disponible para Windows, Linux o
Mac OS X. Las principales herramientas son el emulador y el plugin para el entorno de
desarrollo Eclipse. El desarrollo de software mediante el emulador garantiza el
funcionamiento de aplicaciones en los dispositivos debido a que se uso la misma imagen del
sistema.

15
Java SE, Sun Microsystem: http://java.sun.com/javase/reference/index.jsp
16
Android SDK: http://developer.android.com/sdk/1.5_r2/index.html

18

http://tmovil.usal.es
Ilustración 14. Emulador de Android.

Además el SDK también proporciona una serie de útiles para depurar, empaquetar e
instalar aplicaciones en el emulador o en el dispositivo.

Herramientas
Android Emulator: se trata de un teléfono móvil virtual ejecutado en nuestro ordenador.
Puede usarse para diseñar, depurar y testear nuestras aplicaciones en un entorno del
sistema operativo Android.
Android Development Tools Plugin (for Eclipse IDE): una extensión para el entorno de
desarrollo que permite crear y depurar aplicaciones más fácil y rápidamente en Eclipse.
Android Virtual Devices (AVDs): configuraciones creadas del emulador para modelar la
aplicación con distintas características. En cada configuración se pueden especificar la
plataforma de Android, las características hardware y la piel o máscara del emulador.
Las funciones de cada AVD son independientes, al igual que el amancebamiento de la
información de usuario y la tarjeta de memoria.
Hierarchy Viewer: herramienta que permite depurar y optimizar la interfaz de usuario.
Proporciona una representación virtual de la jerarquía de capas.
Draw 9-patch: permite crear fácilmente una imagen NinePatch (imagen que se puede
escalar ciertas partes) usando un editor del tipo WYSIWYG, es decir lo que ves es lo
que obtienes (what you see is what you get).
Dalvik Debug Monitor Service (ddms): herramienta que interactúa con la maquina
virtual de Android, Dalvik. Permite gestionar los procesos en el emulador/dispositivo y
ayuda en la depuración.
Android Debug Bridge (adb): facilita la instalación de aplicaciones (archivos apk) en el
emulador/dispositivo y acceder a éste mediante la línea de comandos.

19

http://tmovil.usal.es
 Android Assent Packaging Tool (aapt): permite crear los archivos apk que contienen los
recursos y los archivos binarios de las aplicaciones para Android.
Android Interface Description Language (aidl): permite generar código para una interfaz
de procesos.
SQlite3: se incluye por conveniencia. Gracias a ella se puede acceder a los archivos de
bases de datos SQlite creadas y usadas en programas de Android.
Traceview: herramienta para producir un análisis gráfico de las vistas y de los registros
de traza de datos que se pueden generar en una aplicación de Android.
Mksdcard: permite crear una imagen virtual de una tarjeta de memoria para emular la
presencia de ésta en el emulador.
Dx: reescribe bytecodes de los archivos class en Android bytecodes (archivos dex).
UI/Application Exerciser Monkey: se trata de un programa que corre en el emulador y
genera un flujo de eventos pseudo-aleteatorios de eventos de usuarios como, clicks,
eventos táctiles o movimientos. Se puede utilizar realizar un test de stress en la
aplicación que estas depurando.
Android: script que permite manejar los AVD’s y generar los archivos ant que pueden
utilizarse para compilar las aplicaciones para Android.

A continuación se detallan los pasos necesarios para la instalación de SDK en un

equipo utilizando el entorno de desarrollo integrado Eclipse con el plugin
proporcionado por Google (ADT Plug-in):

1. Descargar la versión más actual de ECLIPSE IDE: http://www.eclipse.org/downloads/

2. Descargar el SDK más reciente de Android:
http://developer.android.com/sdk/index.html
3. El SDK viene con varias carpetas y un archivo ejecutable llamado SDK Setup. En la
carpeta “tools” se encuentra el emulador y algunas herramientas mencionadas
anteriormente. Sin embargo la carpeta “platforms” está vacía y es necesario instalar al
menos una para poder trabajar. Para ello ejecutar el instalador del SDK de Android.
4. Si existe un error indicando que no ha sido posible acceder a las descargas disponibles
como el mostrado en la siguiente captura de pantalla (Ilustración 15) siga los siguientes
pasos, en caso contrario continúa en el paso 8.

20

http://tmovil.usal.es
Ilustración 15: Fallo de conexión HTTPS muy común

5. Cancela las pantallas que aparezcan y elige Settings.

6. Clic en “Force https://...sources to be fetched using http://...”

Ilustración 16: Forzar HTTP cuando falla HTTPS

21

http://tmovil.usal.es
7. Cierra el instalador y vuelve a abrirlo. Debería de aparecer la siguiente pantalla:

Ilustración 17: Instalación de paquetes disponibles

8. Aunque se pueden instalar desde la pantalla mostrada en la Ilustración 17 es más lioso

saber qué se está instalando así que se recomienda Cancelar.

9. Clic en Available packages y marcar al menos una plataforma, una Google API y si se
desea tener la documentación cuando no se tiene acceso a Internet marcar también
para descarga. Si se desea conectar un terminal Android en Windows, descargar
también el driver USB. En la siguiente pantalla ( Ilustración 17) se puede ver
seleccionada la última plataforma disponible en el momento de elaboración de esta
documentación, junto con la documentación y Google APIs más recientes. También
aparece seleccionado el driver USB para Windows.

22

http://tmovil.usal.es
Ilustración 18: Selección de paquetes a instalar

10. Clic en Accept All y Install Accepted. Esperar a que se descarguen y se instalen los
paquetes elegidos.
11. Comprobar que todo está OK. Para el caso de haber seleccionado los paquetes de la
Ilustración 17 al hacer clic en Installed Packages debería mostrarse lo siguiente:

23

http://tmovil.usal.es
Ilustración 19: Paquetes instalados

12. Ahora es necesario instalar el Plug-in que enlace Eclipse con el SDK de Android. Para
ello hay que descargarse el ADT Plug-in siguiendo las instrucciones en
http://developer.android.com/sdk/eclipse-adt.html
13. Desde ECLIPSE 3.5 (Galileo) Clic en Help -> Install New Software
14. En Available Software clic en Add… y pon un nombre significativo como por ejemplo
“Android Plugin”
15. En el campo Location pon la URL https://dl-ssl.google.com/android/eclipse/ (Si no
funciona prueba a cambiarla por http:// (Sin la S). Clic en OK. Después de la instalación
cerrar ECLIPSE y volver a abrirlo.
16. Elige los siguientes componentes como en la Ilustración 20 y clic en Next.

24

http://tmovil.usal.es
Ilustración 20: Instalación del plug-in ADT para ECLIPSE

17. Ahora hay que configurar el plug-in indicándole dónde tenemos instalado el Android
SDK. Para ello Window -> Preferences. Elegimos Android en el panel izquierdo y se
nos indicará que debemos de configurar el Android SDK como muestra la Ilustración 21

25

http://tmovil.usal.es
Ilustración 21: Configuración del ADT

18. Ahora le indicamos dónde se encuentra la carpeta del SDK haciendo clic en Browse,
que en este caso se llama android-sdk-windows. Hacemos clic en Apply (esperamos
unos segundos y si todo ha ido bien se mostrará una pantalla como la Ilustración 22

26

http://tmovil.usal.es
Ilustración 22: ADT enlazado correctamente con el Android SDK

Configuración del emulador:

A diferencia de otros SDKs de otras plataformas como J2ME o iPhone, en Android

tendremos que crearnos un emulador de acuerdo a las características de nuestra plataforma
objetivo, ya que por defecto no trae ninguno configurado. En Android un emulador es
denominado AVD (Android Virtual Device), y podremos crear tantos como queramos. Será
necesario tener al menos uno configurado y ejecutándose para poder emular nuestras
aplicaciones. A continuación se indican los pasos necesarios.

1. Lanzar el gestor de emuladores desde Eclipse (Ver Ilustración 23)

27

http://tmovil.usal.es
Ilustración 23: Lanzar el Android SDK and AVD Manager

2. Se lanza la ventana mostrada en la Ilustración 24. Hacer clic en New

Ilustración 24: Ventana del gestor de AVDs

3. Rellenamos los campos del emulador por ejemplo como muestra la Ilustración 25 y
hacemos clic en Create AVD. Nota: Si se desea que el emulador de información sobre si
dispone o no de cierto hardware cuando es interrogado por nuestro programa, añadir en
Hardware los valores que necesitemos. El emulador por ejemplo, reproducirá sonido
independientemente de estos valores, la diferencia está en que si le añadimos el valor
de hardware “Audio playback= false” desde nuestro programa podremos detectar con

28

http://tmovil.usal.es
 nuestro código (y probar) si un dispositivo no es capaz de reproducir sonido (para por
ejemplo sacar un mensaje de alerta por pantalla).

Ilustración 25: Configurando un AVD

4. Si todo ha ido correctamente, a partir de ahora veremos la pantalla del gestor de AVDs

como muestra la Ilustración 26.

29

http://tmovil.usal.es
Ilustración 26: Gestor de AVDs con un emulador disponible

5. Ahora ya sólo queda arrancar el emulador haciendo clic en Start. (Esto debe hacerse
siempre al menos una vez para probar las aplicaciones y puede tardar varios minutos en
arrancar la primera vez, y un tiempo nada razonable las siguientes veces, por lo tanto
se recomienda no cerrar el emulador mientras estemos trabajando). Cuando el

emulador haya terminado la carga tendrá un aspecto similar a la Ilustración 27

30

http://tmovil.usal.es
Ilustración 27: Emulador (AVD) arrancado

Arquitectura aplicación

Por la filosofía utilizada por Android, los elementos de una aplicación pueden ser
utilizados por otras, si éstas lo permiten. Para conseguir esto, el sistema debe ser capaz de
ejecutar un proceso de una aplicación cuando una de sus partes lo necesite. Es por ello que
al contrario que la mayoría de las aplicaciones en otros sistemas, las aplicaciones en Android
no tienen un solo punto de entrada para todo, es decir no hay por ejemplo una función
“main()“. En vez de ello los componentes esenciales de la aplicación pueden ser iniciados
cuando se necesiten.

Bloques constituyentes de una aplicación

Activity

Una actividad (activitity) representa una interfaz grafica para una acción que el
usuario puede realizar. Puede tratarse por ejemplo de una lista que presente una serie de
opción que pueden elegirse. Si tomamos como modelo una aplicación para mandar
mensajes, una actividad puede ser la que liste los contactos a los que se van a mandar un

31

http://tmovil.usal.es
mensaje, una segunda actividad para escribir el mensaje y otras para reenviar antiguos
mensajes o cambiar opciones. Aunque trabajen en conjunto para formar una interfaz gráfica
de usuario, cada actividad es independiente de las otras y es implementada como una
subclase de la clase Activity.

Cada actividad tiene una ventana para dibujar en ella. Normalmente esta ventana
rellena la pantalla completa pero puede no ser así. Una actividad puede utilizar ventanas
adicionales como un cuadro de dialogo.

El contenido visual de la ventana esta provista por una jerarquía de vistas. Cada una
de éstas controla un espacio rectangular en la ventana. Las vistas padres organizan la
organización de las vistas hijas. Las últimas clases de la jerarquía dibujan los rectángulos
que controlar y responden ante las acciones de usuario. Dentro de estas vistas se incluyen
los botones, los campos de textos, elementos de menú, etc.

Services

Se puede definir un servicio (service) como un proceso que corre durante un tiempo
indefinido de forma invisible para el usuario. Carecen de interfaz gráfica. Sus utilidades son
muy variadas desde reproducir música de fondo hasta descarga información de la red
mientras el usuario se dedica a otras tareas.

Cada servicio hereda las características de la clase Service. Es posible conectarse a

un servicio o iniciarlo, en caso de no estar funcionando. Una vez conectado se puede
mantener la conexión con él a través de una interfaz definida por el servicio.

ContentProvider

Gracias a un content provider (o proveedor de contenido) se puede conseguir

compartir información entre aplicaciones. La información es almacenada en el sistema de
ficheros (por ejemplo en una base de datos, SQlite). Las nuevas clases que se creen con
este fin, heredan de ContentProvider y deben implementar los métodos necesarios para
permitir a otras aplicaciones leer o escribir información. Sin embargo las aplicaciones no
llaman a estos métodos sino que usan un objeto de tipo ContentResolver que se encarga de
ello. Este objeto puede dialogar con cualquier proveedor y cooperar con él para manejar la
comunicación entre procesos. Más adelante se profundizará en el uso de ContentProviders.

BroadcastReceivers

La tarea principal de los receptores de difusión (BroadcastReceivers) es reaccionar

ante una señal o mensaje. Un broadcast receiver no hace nada hasta que no recibe el aviso.
Estos mensajes pueden ser enviados por el sistema cuando varíe la zona horaria o la batería

32

http://tmovil.usal.es
esté baja pero además las nuevas aplicaciones también pueden iniciar nuevos mensajes de
difusión.

Una aplicación puede tener todos los broadcast receiver que se desee para responder
a ciertos mensajes. Estos objetos heredan de la clase BroadcastReceiver.

Al igual que los servicios, no poseen interfaz grafica, pero si son capaces de lanzar
una nueva actividad en respuesta a la información recibida.

Intents

Mientras que los Content Providers son iniciados por un ContentResolver, existe una
clase especial para iniciar actividades, servicios y receptores de difusión: la clase Intent. Un
intent es un mensaje de llamada asíncrono. Para las actividades y servicios se especifica la
acción que se va a realizar y la dirección de la información con la que se va a trabajar. Para
los receptores de difusión, el Intent nombra la acción que va a ser anunciada.

Ciclo de vida de una aplicación

Como se ha explicado anteriormente una aplicación no solo tiene un punto de

entrada para todos los acontecimientos, por ello no se puede declarar el ciclo de vida de una
aplicación en general, si no que hay que tener en cuenta el comportamiento de cada uno de
sus componentes: activities, services y broadcast recivers.

Ciclo de vida de una actividad

Una actividad puede encontrarse en tres estados diferente:

Activa (o corriendo): cuando está en primer plano de la pantalla. Esta actividad tiene el
foco y recibe las acciones del usuario.
Pausada: ha perdido el foco pero es aún visible para el usuario, es decir, existe una
actividad por encima de ella de modo transparente o no ocupando la pantalla entera. La
actividad pausada mantiene toda la información y se mantiene adjunto al manejador de
ventanas, pero puede ser cerradas por el sistema en caso de baja memoria.
Parada: la actividad ha sido cubierta completamente. Mantiene su estado y la
información pero probablemente será eliminada por el sistema cuando se necesite más
memoria.

33

http://tmovil.usal.es
Ilustración 28. Ciclo de vida de una actividad

Es importante mencionar tres ciclos anidados que pueden sucederse en el

comportamiento de una actividad.

El ciclo de vida completo de una actividad sucede entre la llamada onCreate(), donde
realiza su configuración inicial, hasta la única llamada a onDestroy(), donde libera los
recursos restantes.

34

http://tmovil.usal.es
 El ciclo visible de una actividad ocurre entre onStart() y onStop(). Durante este tiempo
el usuario puede ver la actividad en pantalla, no necesariamente en primer plano. Las
llamadas a estas funciones pueden realizarse muchas veces, cada vez que la actividad
pasa de estar escondida a mostrarse al usuario.
El ciclo de vida en primer plano sucede entre las llamadas a onResume() y onPause().
En este momento la actividad se encuentra por encima de las demás actividad y recibe
las acciones del usuario. Con frecuencia una actividad puede pasar de pausada a
reanudada por lo que el código entre estas dos llamadas debe ser lo más ligero posible.

Ciclo de vida de un servicio

Un servicio puede ser utilizado de dos maneras

Puede ser iniciado y estar funcionando hasta que se a detenido (por si mismo o por otro
elemento).
Puede ser utilizado mediante una interfaz definida por cada servicio. Los clientes
establecen una conexión para utilizarlo. Si el servicio no esta iniciado se crea con la
primera llamada.

Ilustración 29. Ciclo de vida de un servicio

35

http://tmovil.usal.es
 Es importante al igual que en las actividades, mencionar el comportamiento de
ciertos bucles en el ciclo de vida de un servicio.

El ciclo de vida completo de un servicio sucede entre las llamadas a onCreate() y

onDestroy(). Al igual que en la actividad la configuración inicial sucede en la primera
llamada y se liberan recursos en la segunda.
El ciclo de vida activo de un servicio empieza con onStart(). En este método se maneja
el objeto Intent que ha provocado el inicio.

Si el servicio permite enlazarse (bind), la llamada onBind() devuelve el canal de

comunicación usado por el cliente hasta la llamada a onUnbind().

Ciclo de vida de un Broadcast receiver

El ciclo de vida de un receptor de difusión es más simple que el de una actividad o un

servicio. Cuando recibe un mensaje el sistema llama a onReceive() pasándole el Intent con la
información recibida. Una vez finalizado el procesamiento del mensaje el receptor queda
inactivo.

Archivos de un proyecto Android

Cuando se crea un nuevo proyecto Android bien mediante el uso de Eclipse o con la
herramienta Android17, se crea automáticamente una serie de directorio y de ficheros. Cada
uno de estos elementos tiene una función específica dentro de la aplicación.

Nombre Función

<proyecto>/src Directorio donde se encuentran los

distintos paquetes que contienen las clases
Java que forman la aplicación.

<proyecto>/Google APIs/ Carpeta que contiene todos los

archivos del SDK.

17
Crear proyecto sin Eclipse:
http://developer.android.com/guide/tutorials/hello-world.html#noeclipse

36

http://tmovil.usal.es
 <proyecto>/Referenced Libraries Carpeta donde se encuentran las
bibliotecas externas referenciadas o
utilizadas en el código.

<proyecto>/gen Carpeta generada automáticamente

donde se guardan las referencias de los
distintos elementos creados. Estos archivos
se actualizan automáticamente y no deben
ser modificados de forma manual.

<proyecto>/assets/ Archivos de recursos necesarios. Por

ejemplo archivos multimedia.

<proyecto>/res/ Carpeta raíz para los recursos

usados en la interfaz de usuario

<proyecto>/res/drawable Directorio para las imágenes que

serán dibujadas por la interfaz de usuario

<proyecto>/res/layout Las plantillas de las distintas vistas

en formato XML se almacenarán en esta
carpeta.

<proyecto>/res/values Sitio para almacenar las cadenas y

los archivos de configuración

AndroidManifest.xml Archivo que describe la aplicación al

sistema operativo.

Android Manifest.

Cada aplicación debe tener un archivo AndroidManifest.xml en la raíz del proyecto.

Este archivo presenta la información necesaria sobre la aplicación al sistema operativo. Las
principales funciones del Android Manifest son:

Describe los paquetes Java para la aplicación. Cada paquete tiene un identificador único
para la aplicación.
Detalla los componentes de la aplicación: actividades, servicios, receptores de difusión y
proveedores de contenido. Relaciona cada una de las clases correspondientes a cada

37

http://tmovil.usal.es
 componente. Mediante esta declaración el sistema sabe qué componentes pueden ser
lanzados bajo qué condiciones.
Especifica que procesos mantendrá los componentes de la aplicación.
Declara los permisos que necesita la aplicación para acceder a partes protegidas de las
API.
Se especifica también los permisos que se deben tener para interactuar con los
componentes de esta aplicación.
Especifica el “level” mínimo que debe tener la API de Android para hacer funcionar la
aplicación.
Describe las bibliotecas que la aplicación debe enlazar.

38

http://tmovil.usal.es
 <?xml version="1.0" encoding="utf-8"?>

<manifest>

<uses-permission />
<permission />
<permission-tree />
<permission-group />

<instrumentation />

<uses-sdk />

<application>

<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>

<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>

<service>
<intent-filter> . . . </intent-filter>
<meta-data/>
</service>

<receiver>
<intent-filter> . . . </intent-filter>
<meta-data />
</receiver>

<provider>
<grant-uri-permission />
<meta-data />
</provider>

<uses-library />
<uses-configuration />

</application>

</manifest>

Tabla 1. Estructura AndroidManifest.xml

39

http://tmovil.usal.es
 Para más información sobre la declaración de elementos en el AndroidManifest.xml
se recomienda visitar la documentación oficial18.

Creación de una aplicación: Hello World!

Gracias al uso de Eclipse junto con el plugin de Android, la creación de una aplicación
es muy sencillo, basta con dirigirse dentro de Eclipse al menú File > New > Android
Project

Ilustración 30. Crear aplicación 1

A continuación se muestra un cuadro de diálogo con los cuadros de edición que se

muestra en la Ilustración 31 que debemos rellenar:

Ilustración 31. Crear aplicación

- Project name: nombre que desea poner al proyecto

- Package name: paquete donde se almacenaran las distintas clases que se creen
18
Android Manifest: http://developer.android.com/guide/topics/manifest/manifest-intro.html

40

http://tmovil.usal.es
- Activity name: nombre de la actividad principal de la aplicación.
- Application name: nombre que tendrá la aplicación y que mostrará en el teléfono.

Una vez rellenados los campos, es necesario marca la opción “Create new Project in
workspace”. Haga clic en Finish y se creará la aplicación Hello World (Hola mundo) lista para
ser ejecutada.

Se creará una actividad que se lanzará cuando se ejecute la aplicación que tendrá
una apariencia similar a este código:

public class helloworld extends Activity {

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}

En este fragmento vemos, como se declara la función onCreate() que será llamada
automáticamente cuando se inicie la actividad. En esta aplicación en concreto simplemente
se mostrará por pantalla una pantalla con el mensaje “Hello world, <actividad>” tal y como
esta definido en el archivo <proyecto>/res/layout/main.xml. Para ello se realiza la llamada
setContentView(R.layout.main).

41

http://tmovil.usal.es
 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>
</LinearLayout>

El entorno de desarrollo facilita la tarea de instalar la aplicación en el dispositivo.

Recuerda que para ejecutar la aplicación basta con hacer clic en Run > Run o Control +
F11. Si en cambio se desea depurar la aplicación, Run > Debug o F11. Eclipse detectará si
existe algún dispositivo Android conectado al sistema o un emulador iniciado. Se puede
elegir en qué dispositivo real o virtual se desea instalar y ejecutar la aplicación. Si el entorno
de desarrollo no es capaz de encontrar ningún dispositivo permite la opción de lanzar un

42

http://tmovil.usal.es
emulador con una configuración concreta. Además si Eclipse detecta que la aplicación que se
está compilando se encuentra instalada, la elimina e instala la nueva versión.

Ilustración 32. Compilar y ejecutar aplicación

Desarrollo en un teléfono

Para que el ordenador reconozca el teléfono conectado, en Windows y Linux es

necesario preparar el sistema operativo.

Sistemas Windows
Conecte el terminal Android vía USB. Cuando se le notifique que se ha encontrado un
nuevo hardware conectado y le pregunte si desea que Windows busque el software.
Seleccione No y haga clic en Siguiente.
Seleccione instalar desde una lista o localización específica y haga clic en Siguiente.
Si utiliza un sistema Windows de 32 bits: Seleccione Buscar el mejor controlador en esta
localización. Navegue a la carpeta usb_driver\i386 en el paquete del SDK
(<SDK>\usb_driver\x86).
Si utiliza un sistema Windows Vista de 64 bits: Seleccione Buscar el mejor controlador
en esta localización. Navegue a la carpeta usb_driver\amd64 en el paquete del SDK
(<SDK>\usb_driver\amd64).
Haga clic en Finalizar. El sistema debería instalar los archivos del controlador necesario.
Puede necesitar reiniciar el ordenador.

Sistemas Linux
Identifíquese como súper usuario (root) y cree el archivo: “/etc/udev/rules.d/50-
android.rules”.

Para usuarios de Ubuntu Gusty/Hardy, edite el archivo como:

SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"

Tabla 2. 50-android.rules Ubuntu Gusty/Hardy

43

http://tmovil.usal.es
 Para usuarios de Ubuntu Dapper, edite el archive como:

SUBSYSTEM=="usb_device", SYSFS{idVendor}=="0bb4", MODE="0666"

Tabla 3. 50-android.rules Ubuntu Dapper

Finalmente ejecute

chmod a+rx /etc/udev/rules.d/50-android.rules

Tabla 4. 50-android.rules Permisos

44

http://tmovil.usal.es