Trabajo Teórico POO marzo, 2010

DESARROLLO DE APLICACIONES EN ANDROID

Carlos García García David Hernández Pulido Javier Montejo Berlingen

Departamento de Informática y Automática Universidad de Salamanca (http://diaweb.usal.es)

Información de los autores: Carlos García García

Alumno de la asignatura de Programación Orientada a Objetos Departamento de Informática y Automática carlosggg@usal.es
David Hernández Pulido

Alumno de la asignatura de Programación Orientada a Objetos Departamento de Informática y Automática davidherpul@usal.es
Javier Montejo Berlingen

Alumno de la asignatura de Programación Orientada a Objetos Departamento de Informática y Automática javiermontejo@usal.es

Este documento puede ser libremente distribuido. © 2010 Departamento de Informática y Automática - Universidad de Salamanca.

Resumen
Hoy en día, una nueva generación de teléfonos móviles, conocidos como smartphones o teléfonos inteligentes, ocupan las primeros puestos en el mercado. Estos teléfonos son completamente capaces de ejecutar aplicaciones programadas por el usuario. El problema radica en grandes diferencias entre las plataformas de hardware que hacen que la portabilidad sea casi imposible. Android es un sistema operativo diseñado para smartphones, que proporciona una capa de abstracción completa, y haciendo por tanto todas las aplicaciones portables, independientemente del hardware subyacente. También se ocupa de la gestión de los limitados recursos del teléfono en comparación con otros tipos de dispositivos. Este documento ofrece una visión en los aspectos básicos de Android. Aunque algunos aspectos generales de su integración en los teléfonos móviles son necesariamente mencionados, el objetivo principal es discutir acerca de cómo trata el paradigma de la orientación a objetos. A través del uso eficiente de las herramientas de programación orientada a objetos que nos proporciona, Android es capaz de ofrecer al programador un marco de trabajo que facilita enormemente su labor. Los aspectos básicos de cómo Android consigue este propósito a través de programación orientada a objetos se examinan a fondo, incluyendo algunos ejemplos de implementación que pensamos pueden ser esclarecedores.

Trabajo Teórico POO

i

Abstract
Nowadays, a new generation of mobile phones, known as “smart-phones” are topping the markets. These phones are fully capable of running user-programmed applications. The problem comes from the large hardware differences between platforms which makes portability almost impossible. Android is a operating system designed for smart-phones, it provides a complete abstraction layer, and therefore making every application portable regardless of the underlying hardware. It also deals with the management of the limited resources of the phone. This document offers an insight in the basic aspects of Android. Although some general aspects of its integration in mobile phones is necessarily mentioned, the main goal is to discuss its object oriented paradigm. Through the efficient use of the tools that object oriented programming provides us, Android is able to offer the programmer a framework which eases enormously his work. The basics aspects of how Android reaches this goal through object oriented programming are discussed at length, including some implementation examples where we thought that they might be enlightening.

ii

Trabajo Teórico POO

2............. 7 MÁQUINA VIRTUAL DALVIK .......... 2. 5 IDEs ......................................... 15 Content Provider ...............................................1 1................... 5 Kernel de Linux .......................... 8 Native Development Kit .. 5 Paquetes .........................2........................3.....3 1.........1........................... 1................................ 9 Activity.......................................... INTRODUCCIÓN ...5 1..............................1 4.... 14 Objeto Intent .....1........................................................ 4.............. 4.........4 1......................................................................................... 7 Emulador........................ 15 Service.................................................4.........................................................................................................................................................................................Tabla de Contenidos 1.3.1. 5 Runtime de android...... 3..................................2............................................2 4................................................. 1 Mercado ....................................................................................2.................... 7 Android SDK Y ADT ..........................................................3...............1..........................3....3................................. 11 Ciclo de vida ............................... 4.............................................................................................................................................. 2....................................2....................................... 4 Application Framework .............2................................. 4 Librerías. 9 Diferencias respecto a la MV de Java ....................................................................................................... 3.................................................................................. 1.............................. 15 HERRAMIENTAS DE DESARROLLO ........................... Historia...... 14 Resolución de Intents..............................................3....... 11 Trabajo Teórico POO iii .......................2.......... 4..............................3.3..............................................................................................................................................................................................1 1.........1.. 2 Ventajas de Android frente a otros sistemas............................ 3............................................................ 4.............3...............2.... 1 1.................1 4...... 8 Funcionamiento................................................................. 9 ANATOMÍA DE UNA APLICACIÓN ANDROID ......................................... 2................ 12 Tareas......................................................................................... 13 Intent e Intent Filters .......... 3......................2 1......................2 4.................... 4 Aplicaciones ...................................................................................1 2............2...............................................................1............................................................ 3 Arquitectura .. 9 Optimización................................ 1.........................................4...............

.............................................. Broadcast Receivers ...........1..............2................................................................................................................ 6........................................................ 6.............................................. 21 Contenedores ............................ 5....... 31 iv Trabajo Teórico POO ........................1 5........ 23 Reutilización ................................................................ 26 Location . 25 FACILIDADES DE ANDROID .....2..................1........................ 25 MapActivity.................................... 29 Reconocimiento de gestos............................................................. 16 Manifiesto ..................................................................................................... 5........................... 19 GOOGLE MAPS ..................................... 29 Telephony............................1.....................................................................................................1 6.........................................2.......................................... 25 MapView ..6......................................................................................2 6.....................1......................................................................................4..............2........................1................................ 8...........2....... 5.... 29 CONCLUSIONES ..................................... 25 Ejemplo ...................................... 4..................................... 25 MapController....................................... 7............................3 6................5................................................... 22 Widgets .............................................3............... 19 Layout .... 16 Otros.......... 7......................................3 6........................................... 30 ESTRUCTURA DE UN PROYECTO .... 7..........................1...................................................... 7.............................................................2.............................. 5.................. 24 Clases básicas...........2 5...........................................................................

.................... 1 Ilustración 3 – Porcentaje de dispositivos móviles Android por cada versión a 12/4/2010 ............................... para smartphones según el uso de la red de datos..................................Tabla de Ilustraciones Ilustración 1 – Logo de la plataforma Android ..................................O................................... 21 Ilustración 11 – Ejemplo de aplicación creada mediante el uso de Google Maps................... Android.......... 13 Ilustración 10 – Herramienta de creación de GUIs ....... Linux................. 3 Ilustración 6 – Componentes del S...... 27 Trabajo Teórico POO v .....................................O............................................................. 4 Ilustración 7 – Logo de Eclipse .................... 2 Ilustración 4 – Gráfico de los S...................... 7 Ilustración 8 – IDE Eclipse y emulador de Android ejecutándose sobre un S.................... 2 Ilustración 5 – Gráfica del número de nuevas aplicaciones para Android ..................... 1 Ilustración 2 – Logo de la Open Handset Alliance. 8 Ilustración 9 – Diagrama de estados del ciclo de vida de una actividad ..O.........................................................

teclado. Representa los elementos visuales y reacciona a las acciones del usuario Android Developer Challengue: concurso creado por Google para fomentar el desarrollo de aplicaciones en Android. Widget: combinación de la palabra window gadget. Es una agrupación de varios ficheros Java y se usa generalmente para la distribución conjunta de clases y metadatos. Dalvik: nombre de la máquina virtual utilizada por el sistema operativo Android. ADT: Android Development Tools Activity es la clase responsable de una ventana dentro de una aplicación. aplicaciones de usuario como navegador web o cliente de correo. más abstracto que el código máquina. Smartphone: dispositivo móvil que supone una evolución de los teléfonos móviles. Frecuentemente se utiliza para conocer la velocidad y desplazamiento de un cuerpo en uno o varios ejes dimensionales. con la inclusión de pantalla táctil. y que necesita de un mediador o máquina virtual para poder ser transformado y ejecutado en el hardware. JAR: acrónimo de Java Archive. con el cual el usuario puede interactuar. Es un componente gráfico utilizado en interfaces de usuario. Bytecode: código intermedio. Manifiesto: es un archivo XML que describe a la aplicación y sus componentes NDK: Native development kit. vi Trabajo Teórico POO . entre otros. conexión wifi.GLOSARIO Acelerómetro: instrumento destinado a medir aceleraciones. Android Market: aplicación de red que permite publicar aplicaciones a los desarrolladores para ponerlas a disposición de los usuarios.

Andy Rubin. Para su creación se han teniendo en cuenta los avances tecnológicos en los diferentes terminales móviles. sino que gracias a su kernel de Linux. Uno de los cofundadores de aquella compañía.de muchos. Aquella empresa era desconocida para el mundo de las tecnologías en aquellos años. Se ha diseñado en un principio para el control de dispositivos móviles mediante librerías Java. Ilustración 2 – Logo de la Open Handset Alliance -1- . cinco días después del anuncio Google lanza un SDK.y alegría .O abierto para móviles. aunque su versatilidad le hace propicio para otros dispositivos empotrados. comienza en Junio del 2005. por ello el sistema soporta bluetooth. Historia La historia de este S. Ilustración 1 – Logo de la plataforma Android El 5 de Noviembre del 2007 se anuncia la creación de la Open Handset Alliance. INTRODUCCIÓN Android en un Sistema Operativo además de una plataforma de software basada en el núcleo de Linux (monolítico). wifi y pantallas táctiles. Está formada por fabricantes de equipos y prestadores de servicios de tecnología que unieron fuerzas para lanzar el primer S. que incluía un emulador de Android para ir probando las primeras líneas de código. que no estaría atado a su funcionamiento en una marca o dispositivo concreto.O. una organización cuyo objetivo es la difusión de la plataforma móvil Android. telecomunicaciones y aplicaciones móviles. podría ser adaptado a casi cualquier dispositivo.1. momento en el cual Google compró una pequeña compañía cuya finalidad era el desarrollo de aplicaciones para dispositivos móviles: Android Inc.1. Para sorpresa . 1. a pesar de lo cual el grupo de fundadores tenía gran experiencia en plataformas web. pasaría posteriormente a ser el director de la división de plataformas móviles de Google.

según el uso que hacen del tráfico de red: Ilustración 4 – Gráfico de los S. Mercado Con el avance de las nuevas tecnologías se han incrementado las posibles funcionalidades del móvil en relación a las nuevas formas de comunicación lo que ha conllevado al desarrollo de nuevos sistemas operativos para smartphones. el hecho de que Android se haya creado con el objetivo de poder correr sobre terminales de distintos fabricantes abre un nuevo panorama en el mercado de las aplicaciones para móviles.2. no lo es en cambio en el uso de Internet. que en principio se plantea como el principal obstáculo de Android.O. campo en el que domina iPhone OS. permitirá la Trabajo Teórico POO 2 . Tras varias correcciones y nuevas implementaciones el sistema se encuentra en su versión 2. estando dividida en Abril del 2010 en siete niveles.Desarrollo de aplicaciones en Android Su lanzamiento inicial fue el 21 de Octubre de 2008 con la versión 1. Además. para smartphones según el uso de la red de datos A pesar de que Symbian –propiedad de Nokia . Sin embargo.O. A continuación se observa un gráfico que muestra el panorama actual de los diferentes S. el hecho de la existencia del Android Market. un espacio para la distribución y venta de aplicaciones. 1. La siguiente gráfica obtenida de la web “Android Developers” muestra el porcentaje de dispositivos Android que utilizan una determinada versión: Ilustración 3 – Porcentaje de dispositivos móviles Android por cada versión a 12/4/2010 Por cada nueva versión de la plataforma se ha ido añadiendo un nivel más a la API.es el líder respecto a las ventas de móviles.1 a fecha del 17 de Marzo de 2010.0. abierto a todos los desarrolladores y sin intermediarios.

Esto significa que un programador puede realizar modificaciones en el código de los programas. Ilustración 5 – Gráfica del número de nuevas aplicaciones para Android 1. lo que potencia el software libre. así como el pago por estas. Permite personalizar el teléfono móvil y su entorno de funcionamiento. que aun estando la API también disponible para otros sistemas. La prueba la tenemos en la buena acogida que ha tenido el Android Developer Challengue.2. para móviles de Apple ). Es un sistema que puede instalarse en una gran cantidad de dispositivos diferentes ( al contrario que el S. además de la existencia de concursos financiados por diferentes empresas y organizaciones. a pesar de que a fecha de escritura de este texto el número de terminales con S. posibilidad de hacer un buen negocio apostando por esta plataforma. solo en Android con el total de sus características. que actualmente es uno de los gigantes de la informática. • • • • • • 3 Trabajo Teórico POO .1 Ventajas de Android frente a otros sistemas • Está apadrinado por Google. Más recientemente la red social Buzz de Google acaba de ser adaptada para este S. Android Market facilita la difusión de las aplicaciones creadas.O. Las APIs permiten crear casi cualquier cosa. Es por ello que como se observa en la siguiente gráfica el número de aplicaciones para Android sigue creciendo. La liberación gratuita del SDK permite también a empresas con pocos recursos y jóvenes emprendedores desarrollar aplicaciones para los dispositivos que utilicen este S. con gran participación y excelentes proyectos.Android no es todavía suficientemente elevado y las empresas no están aun obteniendo los beneficios esperados.García et al. lo que facilita que el número de comunidades de usuarios y el soporte vaya aumentando. por lo que esta intentará que todos los servicios que ofrece estén también disponibles para la plataforma Android. y este número va aumentando a medida que se sacan nuevos drivers.O. facilitando el trabajo y motivando a los desarrolladores.O. Un claro ejemplo es Google Maps.O. al contrario que si este no estuviera disponible. Es licenciable bajo GPL.

OO. 1. mapas. Android 1. Este mismo mecanismo permite que los componentes que puedan ser reemplazados por el usuario. sujeto a las limitaciones de seguridad impuestas. que todavía no poseen esta característica.1 Aplicaciones Android suministra un amplio espectro de aplicaciones para que el usuario pueda satisfacer sus necesidades.3.3.2 Application Framework Los desarrolladores tienen pleno acceso a las mismas APIs del framework usadas por las aplicaciones básicas.O. Trabajo Teórico POO 4 . navegador. programa de SMS. además de la posibilidad de añadir nuevas mediante el ya mencionado Android Market. contactos.Desarrollo de aplicaciones en Android • Es multitarea permitiendo ejecutar aplicaciones en segundo plano. La arquitectura se ha diseñado para simplificar la reutilización de componentes: cualquier aplicación puede publicar sus capacidades para que otro programa pueda hacer uso de estas. calendario. pero aun así supone una ventaja con respecto a otros SS. etc… 1.3. Esto ya lo consiguió hacer Nokia en un dispositivo móvil. Por defecto se incluye un cliente de correo electrónico. Arquitectura El sistema operativo Android está formado principalmente por los siguientes componentes: Ilustración 6 – Componentes del S.

graphics: proporciona herramientas gráficas de bajo nivel tales como filtros de color. Paquetes Android reutiliza a una gran cantidad de paquetes ya existentes como son los del lenguaje Java ( java. además de prestar los servicios de seguridad.sqlite: posee las clases necesarias para el manejo de bases de datos SQLite.3.dex por la herramienta “dx”.3. y corre clases compiladas por Javac que han sido transformadas al formato. etc… 1.media: clases para controlar las diferentes interfaces de audio y video. Estos son algunos que se han considerado relevantes: • • android: contiene las clases correspondientes a los recursos ( imágenes. application o service – se encuentran en este paquete. • • • • • • • 5 Trabajo Teórico POO . 1.García et al.5 Kernel de Linux El sistema operativo está basado en la versión 2. sino que la biblioteca SQLite se enlaza con la aplicación pasando a ser parte integral de la misma. Este es el sistema comúnmente usado a la hora de instalar bases de datos locales en un dispositivo Android. android. o rectángulo. red y drivers.util. Algunas de las clases más importantes – activity. La máquina virtual está basada en registros. bibliotecas de gráficos. pero a la vez también añade una gran cantidad de paquetes propios que aportan mayores posibilidades a las aplicaciones que sean desarrolladas mediante su uso.wifi: gestión de la funcionalidad wifi del dispositivo.hardware: provee soporte para dispositivos hardware que pueden no estar presente en todos los teléfonos móviles ( por ejemplo la cámara ). android. android.net. Esta MV ha sido escrita de forma que un dispositivo pueda correr múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.3.4.dex).database: contiene clases para explorar los datos devueltos por un proveedor de contenidos. android. gestión de procesos. bibliotecas de medios. android. Algunas son: System C Library ( implementación de la biblioteca C Standard ). android. modelos de IG. 1.3 Librerías Incluye un conjunto de librerías C / C + + usadas por diversos componentes del sistema. android.database. puntos. android. etc… ). bibliotecas 3D. con su propia instancia de la máquina virtual Dalvik. java.bluetooth: clases para el manejo de la tecnología bluetooth. atributos… ) utilizados por las aplicaciones.4 Runtime de android Android incluye un set de bibliotecas base que proporcionan la mayor parte de la funcionalidad disponible en las bibliotecas base de Java. el cual está optimizado para usar la menor cantidad de memoria que sea posible. 1. Cada aplicación Android corre en su propio proceso.net. que permiten dibujar en la pantalla.app: proporciona clases que encapsulan el modelo general de una aplicación. gestión de memoria.6 del núcleo de Linux que actúa como una capa de abstracción entre el hardware y el del conjunto de software. Este es un sistema de gestión de bases de de datos que no está basado en el modelo cliente-servidor en el que el SGBD es un proceso independiente. SQLite.

text: es un paquete dedicado al tratamiento de textos: copiar y pegar. ampliamente usada en otros campos para el desarrollo de videojuegos. Se antojaba bastante necesario. WebKit supone la base del navegador Safari. que se compone de un motor texto-voz ( imprescindible para un ciego si quiere enterarse de lo que le comunican por un SMS ) y de una funcionalidad que permite que no sea necesario mirar la pantalla táctil para hacer uso de ella ( Más información en http://obm. Actualmente es usado entre otros en los navegadores Mozilla Firefox y Google Chrome y en el framework Qt. android. • • • • • • Trabajo Teórico POO 6 . CAD o realidad virtual. android. calendarios.opengl: utilidades para la generación de gráficos 2D y 3D mediante la API OpenGL.net/20090429/usa-el-movil-sin-mirar-con-eyes-free/ ). android. Es por esto que le fue solicitado a Google un paquete con estas características. etc… android.webkit: herramientas para la navegación web.os: clases para el uso de los servicios básicos del sistema operativo.util: proporciona diversos útiles como la fecha. texto con formato.corcoles. locales ( idiomas ).view:: clases que manejan la disposición de los elementos en la pantalla y la interacción con el usuario. ya no solo para ayudar a los discapacitados sino también para otros usuarios como pueden ser los ancianos.Desarrollo de aplicaciones en Android • android. Un ejemplo es el proyecto Eyes-Free.accessibility: paquete de accesibilidad al sistema para personas con capacidades disminuidas. como son los mecanismos IPC. y a pesar de que todavía no está maduro y le queda mucho por desarrollar. ya se han desarrollado algunas aplicaciones con él. etc… android. android. Proporciona un analizador sintáctico de HTML y un intérprete de JavaScript. tablas hash. y fue liberado por Apple en 2005. pensado para gente con visibilidad nula o reducida.view.

eclipse. El IDE NetBeans es el segundo en importancia – a mucha distancia de Eclipse . • • • • HERRAMIENTAS DE DESARROLLO Obviamente resultaría muy complicado programar una aplicación directamente desde el teléfono móvil por las limitaciones que este tiene: La pantalla es mucho más pequeña. IDEs El IDE que acapara casi la totalidad de los productos desarrollados para Android es Eclipse. El teclado. si existen. Está implementado para todas las plataformas y su versión actual es la 2. Toda la información relativa a estos dos elementos se puede encontrar en la web Android Developers. Android SDK Y ADT Google aparte de liberar el SDK incluye en el mismo un emulador para fomentar la creación de aplicaciones. La memoria y la velocidad de la CPU son mucho más ajustadas en comparación con la de un ordenador de sobremesa. Es por ello que existen herramientas que permiten crear y probar las aplicaciones a lo largo de su desarrollo. 2.1. documentación y códigos de ejemplo.y es posible encontrar información sobre su configuración para Android en la siguiente dirección: http://wiki. -7 - . y por ello la mayor parte de la documentación que se puede encontrar en webs y manuales hace referencia a este entorno de desarrollo. es mucho más pequeño.netbeans. Los dispositivos de señalamiento. son molestos ( un lápiz ) o inexactos (dedos grandes y "multi-táctil LCD" no son una buena mezcla). El paquete Eclipse IDE for Java Developers (descargable a través de http://www.2. en caso de tenerlo. En este SDK podemos encontrar las librerías para programar. La diferencia entre unas versiones y otras son cuestiones de soporte y ampliaciones de la propia API. y en consecuencia menor es la documentación al respecto siendo más complicado resolver los problemas que surjan a la hora de configurar el entorno y desarrollar aplicaciones.1.org/downloads/) incluye las herramientas esenciales para la programación en Java y se puede usar por tanto para desarrollar aplicaciones para Android en conjunción con el SDK de Android y el plugin ADT ( Android Development Tools ) for Eclipse.2. Ilustración 7 – Logo de Eclipse También existe la posibilidad de programar con otros IDEs.org/IntroAndroidDevNetBeans 2. Eclipse es multiplataforma y de código abierto y soporta varios lenguajes de programación. pero estos cuentan con un uso y apoyo mucho menores.

No hay soporte para cámara de captura de video ( entrada ). No hay soporte para los auriculares del dispositivo. aunque pueda tener algunas limitaciones.Desarrollo de aplicaciones en Android Además se ha desarrollado un plugin para el IDE Eclipse llamado ADT. Esto puede proporcionar beneficios a ciertas clases de aplicaciones. 2. donde existen otros métodos de configuración. No hay soporte para las conexiones USB ni Bluetooth. así como varias capacidades de depuración que permiten simular el recibimiento de llamadas telefónicas. Native Development Kit El NDK de Android es un conjunto de herramientas que permite integrar componentes que hagan uso del código nativo en las aplicaciones Android. que puede "presionar" con el ratón simulando el apuntador de un dispositivo móvil o el teclado para generar eventos para su aplicación. el emulador de Android puede iniciarse como una aplicación independiente desde una línea de comandos ( útil cuando quiera establecer los parámetros de la simulación ) o puede usarlo como parte de su entorno de desarrollo Eclipse. 2. junto con las otras aplicaciones Android.3. El NDK permite al desarrollador implementar las partes de su código utilizando lenguajes nativos como C y C + +. Se puede simular llamadas telefónicas ( realizadas y recibidas ) a través del emulador de la consola.1 Emulador Imita todo el hardware y software de un dispositivo móvil típico.O.1 ) son: • • • • • • No hay soporte para hacer o recibir llamadas de teléfono reales. en forma de reutilización de código existente. Ilustración 8 – IDE Eclipse y emulador de Android ejecutándose sobre un S. Linux Las únicas limitaciones que el emulador presenta en su versión actual ( Android SDK 2. Trabajo Teórico POO 8 .2. No hay soporte para determinar el nivel de carga de la batería y el estado de carga de CA. mensajes de texto o conexiones mientras la aplicación se ejecuta. No hay soporte para determinar que se ha insertado/expulsado una tarjeta SD. el cual facilita mucho la depuración de programas para esta plataforma. Durante el desarrollo de una aplicación. A pesar de todo está en constante mejora y muchas de estas limitaciones serán eliminadas. También ofrece una pantalla en la que se muestran las aplicaciones desarrolladas. El emulador de Android proporciona una buena variedad de métodos de navegación: las teclas de control.

Esto es debido a que los procesadores de los teléfonos móviles están optimizados para la ejecución basada en registros. MÁQUINA VIRTUAL DALVIK Android utiliza una máquina virtual propia llamada Dalvik.1. basada en el uso de pilas. 3. El hecho de funcionar sobre un núcleo Linux implica que es posible escribir aplicaciones en C/C++ que funcionen directamente sobre el kernel. a costa de programas que ocupan más espacio tras la compilación. A pesar de las ligeras diferencias en su mayor parte el contenido de las librerias es idéntico. La “recogida de basura” (liberar el espacio de objetos ya no accesibles) ha sido perfeccionada a fin de mantener siempre libre la máxima memoria posible. 3. El hecho de no utilizar la máquina virtual de Java (aparte de posibles aspectos legales y de propiedad) es la necesidad de optimizar al máximo los recursos y enfocar el funcionamiento de los programas hacia un entorno de escasos recursos en cuanto a memoria. El hecho de usar varias máquinas virtuales protege las aplicaciones. Aunque es posible hacer esto. Diferencias respecto a la MV de Java Las máquina virtual de Java. sobre el cual delega las tareas relacionadas con la gestión de hilos y memoria a bajo nivel. Por contra. que ha sido diseñada para optimizar memoria y recursos de hardware en un entorno de teléfonos móviles. A pesar de usar Java para la programación.3. las máquinas virtuales basadas en registros permiten una ejecución más rápida. Optimización Es capaz de reducir bastante el tamaño del programa buscando información duplicada en las diversas clases y reutilizándola. 3.dex). de forma que el fallo o cierre inesperado de una de ellas no afecte para nada a las demás. Funcionamiento Dalvik es una máquina virtual intérprete que ejecuta archivos en el formato Dalvik Executable (*. hogar de los antepasados del ingeniero que diseñó la máquina virtual. la máquina virtual Dalvik está basada en registros. indicar que el nombre Dalvik viene de un pueblo en Islandia. solo en ciertas ocasiones es ventajoso.3. un formato optimizado para el almacenamiento eficiente y ejecución mapeable en memoria. La DalvikVM ha sido también optimizada para que haya múltiples instancias suyas funcionando con un coste muy bajo de memoria. procesador y almacenamiento. La máquina virtual Dalvik ( DalvikVM. A diferencia de la máquina virtual de Java. Dalvik virtual machine ) está basada en registros y puede ejecutar clases compiladas por un compilador Java y que posteriormente han sido convertidas al formato nativo usando la herramienta “dx”. Su objetivo fundamental es el mismo que cualquier máquina virtual. La máquina virtual corre por encima de un kernel Linux 2. y la máquina virtual interpreta este bytecode a la hora de ejecutar el programa. el bytecode de Java no es ejecutable en un sistema Android Por otra parte. disponible en la mayoría de los ordenadores hoy en día. permite que el código sea compilado a un bytecode independiente de la máquina en la que se va a ejecutar. -9 - . está basada en el uso de pilas. la DalvikVM está basada en registros. Como curiosidad.6. las librerías Java que utiliza Android son ligeramente distintas de las incluidas en Java Standard Edition (Java SE) o en Java Mobile Edition (Java ME).2. Además.

Trabajo Teórico POO 10 .Desarrollo de aplicaciones en Android Android hace un uso extenso del XML como forma de definir las interfaces gráficas y otros elementos. Los archivos XML tienen que ser linkeados igualmente a la hora de compilar y son convertidos igualmente a bytecode para mejorar el rendimiento.

Registramos un Broadcast Receiver para escuchar y procesar Intents generales. a los cuatro anteriores. • Activity: Una actividad es cada una de las pantallas dentro de una aplicación. En un sentido estricto. Antes de entrar a hablar en detalle de cada uno de los componentes hacemos una breve presentación de cada uno. Activity Las actividades son probablemente el elemento más común en una aplicación para Android. Las actividades mostrarán una interfaz de usuario basada en vistas ( Views ) y responderá a eventos. Se tratará esto en más detalle de este archivo en secciones posteriores. Content Provider: Un proveedor de contenido es un almacén de información provisto de una API mediante la cual el usuario y aplicaciones pueden acceder al contenido sin necesidad de conocer los detalles del almacenamiento. Los elementos que componen la aplicación han de figurar en un archivo llamado AndroidManifest.1. mientras que podemos personalizar tanto como queramos su comportamiento sobrescribiendo los métodos de la clase padre. • • • • ANATOMÍA DE UNA APLICACIÓN ANDROID Activity Intent Service Content Provider Hay cuatro bloques básicos que componen una aplicación Android: No todas las aplicaciones tienen porque tener los cuatro elementos. y posteriormente lanzar las Actividades o Servicios deseados. pero al menos ha de tener uno. A través de la herencia evitamos volver a implementar aspectos comunes a todos los objetos del mismo tipo.app. 4. que todos los elementos de Android son objetos y por tanto estos cuatro no son ninguna excepción. Toda actividad se inicia como respuesta a un Intent.xml. Hay que enfatizar. Cuando se lanza un Intent el sistema busca que actividades son capaces de dar respuesta a ese Intent y elige la más adecuada. como la hora o la entrada de un mensaje. Es la responsable de presentar los elementos visuales y reaccionar a las acciones del usuario. Una actividad se puede definir como una única pantalla o interfaz dentro de una aplicación. Pasamos ahora a tratar en mayor detalle cada uno de estos elementos constituyentes. es posible construir una actividad sin interfaz de usuario.4. sus capacidades y requisitos. Service: Un servicio es una tarea que se ejecuta durante periodos prolongados y no interacciona con el usuario.Service ) y todo elemento que queramos implementar será una subclase del elemento original. Este archivo XML contiene la declaración de los componentes de la aplicación. Intent: se puede considerar como un deseo de realizar una tarea. • • • Podríamos añadir un quinto elemento. sin embargo no es lo apropiado ya que tenemos los Services y Content Providers destinados 11 . Broadcast Receiver. El comportamiento de cada uno de ellos está definido en su correspondiente clase base ( por ejemplo android.- . la mayoría tendrá una combinación de ellos.

conserva su estado y toda la información. como son onSaveIntanceState() y onRestoreInstanceState(). Puede mantener activa la información sobre su estado.app. De esta forma iremos navegando por las distintas pantallas de la aplicación. Cada una de estas pantallas estará implementada por una actividad diferente. pero puede ser finalizada por el sistema en casos extremos de falta de recursos. Una actividad puede iniciar otra actividad. De nuevo estamos reaprovechando código común a una familia de objetos haciendo uso de la herencia. de esta forma. otra para escribir mensajes.1. Una actividad puede estar en cuatro estados: • • Activa: si la actividad está en primer plano en la pantalla. Cualquier aplicación y actividad que no sea visible será detenida para liberar recursos. por ejemplo al pulsar un botón. Si es llamada de nuevo iniciará el ciclo completamente a diferencia de una actividad detenida. aunque lo más probable es que sea finalizada por el sistema para liberar memoria y recursos. De esta forma. Cuando la nueva actividad termine. una tercera para elegir el contacto al cual se desea enviar el mensaje y otra más para navegar por los mensajes enviados y recibidos. Cada actividad se implementa como una única subclase que hereda de la clase android. sin embargo ésta no forma parte de la actividad.Desarrollo de aplicaciones en Android a esa finalidad. se puede guardar el estado de la Actividad antes de hacerla vulnerable a ser finalizada por el sistema. la siguiente actividad en la pila es reactivada. no necesitamos preocuparnos de muchos de los aspectos relacionados con el funcionamiento de las actividades ya que por herencia nuestra actividad contendrá ya esa funcionalidad. Ésto garantiza la separación del aspecto funcional del aspecto visual.1 Ciclo de vida Las actividades son manejadas mediante una pila de actividades. siendo cada una de ellas una actividad. Una actividad pausada se puede considerar completamente activa. De cualquier forma hay que remarcar que la actividad es responsable de mostrar la interfaz gráfica. la cual aún almacena su estado de ejecución a fin de recuperarlo cuando sea llamada de nuevo. por ejemplo una aplicación que gestiona mensajes puede tener una pantalla de configuración. Finalizada: una vez que la actividad ha completado su ejecución libera todos los recursos que estaba utilizando y finaliza el ciclo. 4. Pausada: si la actividad ha dejado de estar en primer plano pero aún es visible ( una nueva actividad que no ocupa toda la pantalla o es traslucida ha sido llamada ) pasa a estar pausada. Cuando una nueva actividad es iniciada la anterior es pausada y almacenada en una pila de actividades. View. Hay que tener en cuenta que Android está diseñado para el campo de los teléfonos móviles y por tanto tiene en cuenta la más que probable escasez de memoria. y por tanto en la parte superior de la pila de actividades está activa y ejecutándose. Para ello existen métodos de la clase. Normalmente una aplicación constará de varias actividades. • • Trabajo Teórico POO 12 . Detenida: si una actividad no es visible pasa a ser detenida. facilitando en gran medida el desarrollo posterior.Activity. Todos los elementos gráficos y visuales se definirán dentro de una vista. Sin embargo la actividad debe guardar su estado actual de ejecución de forma que cuando la actividad vuelva a ser la primera en la pila pueda recuperar el estado en el que estaba por última vez. Puesto que el sistema puede decidir finalizar una actividad pausada o detenida por motivos de memoria cada actividad es responsable de salvar su estado de forma que sea posible restaurarla tras haber sido pausada o detenida.

solo necesitamos hacer uso de los Intents.2 Tareas Una tarea es lo que el usuario percibe como una aplicación. 13 Trabajo Teórico POO .García et al. podemos recurrir a otra actividad que gestiona mapas y posiciones. algunas de ellas posiblemente fuera de la aplicación original. De la misma forma puede iniciar otra de una aplicación externa. No es posible reordenar o navegar por la pila de actividades. al igual que en cualquier pila solo podemos acceder y cerrar la actividad superior o crear una nueva encima. que veremos posteriormente.1. De esta forma estaremos haciendo uso de actividades externas que para el usuario aparecerán como integradas en nuestra aplicación. Es una pila de actividades que se han ido llamando sucesivamente. Si nuestra actividad necesita hacer uso de una posición en un mapa por ejemplo. Ilustración 9 – Diagrama de estados del ciclo de vida de una actividad Como se vio anteriormente una actividad puede iniciar otra dentro de la misma aplicación. 4.

Intent e Intent Filters Una de las piezas claves de Android es la clase Intent. • • 4. por ejemplo. Los Intents sirven como interfaz de comunicación entre aplicaciones. Cualquier aplicación puede lanzar su Intent sin necesidad de conocer ningún detalle sobre la aplicación que lo va a resolver. Para ello crearía un nuevo Intent con la acción VIEW y añadiría como datos la URI ( Uniform Resource Identifier ) de la página web deseada. podría considerarse como declarar una necesidad.2. Al volver. Adicionalmente puede incluir un conjunto de elementos opcionales. aislar dependencias y asegurar la reutilización de funcionalidades. • • Acción: es una cadena de texto completamente cualificada que indica la acción a realizar. Una actividad puede declarar sus Intent Filters tan genéricos o específicos como desee. en el ejemplo anterior el sistema registraría la creación de un Intent y buscaría qué aplicaciones son capaces de resolverlo.Desarrollo de aplicaciones en Android El sistema Android permite iniciar varias tareas. Un Intent describe lo que una aplicación desea que se haga.intent. Cuando una aplicación registra su Intent Filter y por tanto se declara capaz de manejar una tarea. Cuando el usuario pulsa el botón HOME o BACK. cumpliendo así con una de las premisas básicas de la programación orientada a objetos.LAUNCHER nos indica que el Intent puede iniciar una aplicación si así es requerido Datos: están definidos content://contacts/123 en forma de un objeto URI. por ejemplo. Por otra parte hay una clase relacionada llamada IntentFilter. Categoria: metadatos referidos al Intent. toda la tarea se restaura y de nuevo la última actividad de la pila pasa a estar activa y accesible para el usuario. android.action. De esta forma podemos construir aplicaciones centradas en una única actividad y cuyo trabajo puede ser reaprovechado por otras aplicaciones. categoría y datos. la reutilización. sabiendo que para realizar cualquier tarea que no sea de su ámbito únicamente debe lanzar un Intent.category. De esta forma. esta aportando una funcionalidad que el resto de aplicaciones ya no necesitan implementar. un Intent Filter es una declaración de las capacidades de una aplicación.intent. el equivalente a una API. teniendo en cuenta los datos asociados al Intent. Por ejemplo una actividad se puede declarar capaz de visualizar imágenes JPG pero no serlo para PNG. • Trabajo Teórico POO 14 . No hay interdependencia entre aplicaciones. cualquier actividad puede ser reemplazada por otra que tenga sus mismos Intent Filter y este reemplazo será transparente para todos los procesos que usaban la funcionalidad original. • Cada aplicación es responsable únicamente de su funcionamiento.2. Mientras un Intent es un deseo de hacer algo.VIEW. Por ejemplo. 4. toda la tarea es minimizada mientras el usuario ejecuta otras aplicaciones. Por tanto su código será reutilizado por todas las aplicaciones que lo necesiten para ejecutar el Intent deseado. Los Intent e Intent Filters son una manera de encapsular tareas.1 Objeto Intent El objeto Intent se compone de tres partes: acción. Por ejemplo. android. una aplicación puede requerir visualizar una página web.

únicamente conociendo los métodos de acceso de ésta nueva API. normalmente se trata de una invocación implícita. con los campos indicados anteriormente.3. En el ejemplo anterior. En este ejemplo la actividad desea ver los datos de contacto de la persona con ID 123 para lo cual lanza el Intent correspondiente. proporcionando unos métodos de forma que cualquier aplicación pueda acceder al contenido sin necesidad de conocer la implementación del almacenamiento. en este caso se tratará de una invocación explícita. Un buen ejemplo sería un reproductor de música. sin embargo tiene la capacidad de lanzar notificaciones para informar al usuario. ya que el usuario espera que la música siga sonando aunque lance nuevas actividades. La interfaz y el proceso de elegir y activar una lista de reproducción estaría manejado por una actividad. 4. cada aplicación puede optar por su propio mecanismo. En cualquier momento una actividad puede asociarse a un servicio para modificar su comportamiento o detenerlo. Service Un servicio es un proceso cuyo periodo de ejecución se extiende durante un tiempo largo y que carece de interfaz gráfica. 4. Cuando se instala el paquete. bases de datos.García et al. Un proveedor de contenido define una interfaz que recubre el método de almacenamiento. Si por ejemplo estuviéramos interesados en que sonara una canción en concreto cuando iniciamos el lector de mensajes el servicio de reproducción de música sería remoto.2. sin embargo la reproducción en si estaría manejado por un servicio. Cuando una actividad lanza un Intent. Otra forma de proceder es que la actividad indique explícitamente el destinatario del Intent. archivos de configuración o cualquier otro soporte. Una vez registrados. y Service. De esta forma es mucho más sencillo compartir información con otras aplicaciones ya que proporcionan un nivel de abstracción respecto al 15 Trabajo Teórico POO . 4. como pueden ser archivos. Un servicio local solo puede ser accedido por la aplicación que lo contiene. En el ejemplo anterior el servicio probablemente sería local ya que no tenemos ningún interés en que otras aplicaciones puedan detener la reproducción o pasar canciones. Cada elemento <intent-filter> es parseado en un objeto IntentFilter. un servicio carece de interfaz gráfica. el usuario podría regresar a la actividad que gestiona el reproductor para saltar la canción que está sonando. La actividad indica la tarea que desea realizar y el sistema asigna el Intent a la aplicación más apropiada.2 Resolución de Intents Hay tres tipos de componentes Android que pueden registrarse para resolver Intents: Activity.xml.4. cada vez que se emita el Intent el sistema elegirá el elemento más adecuado para procesarlo según nuestras preferencias. BroadcastReceiver. el sistema toma nota de los componentes que pueden tratar los diversos Intents. Sin embargo esto no es recomendable ya que estamos creando una dependencia innecesaria. Estos componentes se declaran capaces de tratar Intents registrando elementos <intent-filter> en el archivo AndroidManifest. Content Provider A la hora de almacenar datos. Como ya hemos dicho. Los servicios pueden ser clasificados en locales y remotos. Un servicio remoto permite a otras aplicaciones asociarse con él mediante el método bindService() para de esta forma tomar el control. y el hecho de desinstalar el paquete del destinatario provocará errores en la aplicación emisora del Intent.

la actividad. update(. De esta forma podemos programar actividades y servicios como respuesta a eventos.5.6. Algunos de los Intents que pueden recibir por parte del sistema son por ejemplo ACTION_TIME_CHANGED cuando el usuario cambia la hora del dispositivo. Cuando una aplicación lanza un Intent.. se puede acceder a los datos individuales mediante expresiones semejantes a las usadas en SQL. una y solo una actividad será elegida para tratarlo. Otros Hemos mencionado.subruta/datos")..). Los proveedores de contenido son un elemento muy útil de abstracción. ya que ofrecen un método de acceso a los datos contenidos ocultando cualquier detalle interno. sin embargo es perfectamente posible hacer que el Broadcast Receiver ejecute una aplicación. Una actividad puede lanzar Intents para Broadcast Receivers. insert(. No vamos a entrar en detalles sobre la composición e implementación de las diversas opciones gráficas en View pero queremos remarcar esta separación entre el aspecto funcional de la aplicación. haciendo uso de las funciones get(. Cualquier aplicación puede acceder a los datos de la agenda a través de la API del proveedor de contenido. que viene ya implementado en cualquier sistema Android. Un claro ejemplo de proveedores de contenido. Broadcast Receivers La mejor forma de ver un Broadcast Receiver es como un servicio capaz de registrar Intents referidos a eventos generales. pero en ese caso no será posible establecer permisos o niveles de seguridad. por ejemplo: public static final Uri CONTENT_URI = Uri.. Cada proveedor ha de definir su URI. que poseen una interfaz gráfica hacia el usuario y sin embargo la codificación del aspecto gráfico no se realiza dentro del objeto Actividad. cualquier aplicación sabe como acceder a los datos e igualmente puede ofrecer datos a los que todos pueden acceder permitiendo a la vez una completa libertad a la hora de implementar el almacenamiento. Esta separación es un Trabajo Teórico POO 16 .Desarrollo de aplicaciones en Android almacenamiento y todas las aplicaciones acceden a la información a través de unas funciones comunes para todos los proveedores de contenido.. y el aspecto gráfico contenido en View. Una forma de crear servicios que funcionen siempre que el teléfono está encendido es registrar un BroadcastReceiver que espere recibir el Intent BOOT_COMPLETED para lanzar el servicio. Se envía una consulta al proveedor de contenido y este devuelve un objeto cursor mediante el cual se pueden ir recolectando individualmente los datos. El Intent es lanzado al sistema y todo aquel registrado para recibirlo lo recibirá. 4. De esta forma se lanzará el servicio en cuanto se encienda el teléfono. todos aquellos que se hayan registrado para responder a un Intent serán notificados y por tanto serán iniciados con el Intent correspondiente.). De esta forma estamos mejorando la cohesión del sistema sin provocar dependencias. Se puede acceder a los datos contenidos en un proveedor de contenido a partir de su URI. o ACTION_PACKAGE_REMOVE cuando se desinstala un paquete. como la llegada de un mensaje de texto o una llamada. Al igual que los servicios carece de interfaz de usuario.. 4. al hablar de las Actividades..)..).. Esto es así porque poseen la función setContentView(View) mediante la cual muestran la interfaz almacenada en un objeto de tipo View.parse("content://com. delete(. Otra particularidad es que el procesamiento de Intents no es exclusivo. En el caso de Broadcast Receivers.ruta. es la gestión de los contactos. A partir de aquí.

cada objeto es responsable de una única tarea y se comunica con los demás mediante funciones establecidas. siempre que respetemos los canales de comunicación. En cualquier momento podremos modificar cualquier aspecto de la actividad o de la vista sin afectar a la otra parte. elemento básico de la programación orientada a objetos. 17 Trabajo Teórico POO .García et al.

.

El fundamental es android.ap_ que mantendrá los recursos de la aplicación. correspondiéndose cada una con uno de los recursos de la carpeta res/ y de la assets/). • assets/: sirve para guardar ficheros y datos. build. values/: ficheros XML donde se definen cadenas. Este es un fichero comprimido que contiene el . como fondo de un widget o como icono por ejemplo. El archivo classes. src/: guarda el código fuente de la aplicación.java ( el cual contiene constantes numéricas. No existe en Eclipse/ADT. dimensiones. ESTRUCTURA DE UN PROYECTO Es muy importante saber que archivos componen un proyecto Android antes de dedicarse a escribir código como un loco. y los recursos 5.apk. siendo por tanto donde se alojan las subclases de activity creadas. • • • • • • El archivo que se requiere para la ejecución de la aplicación en el dispositivo móvil es el de extensión .- . A su vez contiene otras carpetas para cada tipo. pero estos pierden su formato original y necesitan de la clase AssetManager para su uso. libs/: mantiene los JARs ( Java ARchive es un tipo de archivo que permite ejecutar aplicaciones escritas en Java ) que la aplicación requiera para su ejecución. a destacar: drawable/: permite añadir las imágenes que se desean usar en la aplicación. xml/: archivos XML con otros fines. etc… layout/: contiene los archivos XML que definen el diseño de las diferentes interfaces gráficas de la aplicación. siendo estas sus principales nodos ( etiquetas ) y propósitos: 19 . bin/: guardará la aplicación ya compilada. Es generado y modificado automáticamente por el IDE.jar. gen/: contiene ficheros Java autogenerados. por ejemplo recursos.xml: es un archivo que describe la aplicación. Contendrá además las clases compiladas y al archivo *.dex.jar.dex será el ejecutable. recursos o instrucciones de generación de una aplicación: • • AndroidManifest. Guarda similitudes con un makefile. menu/: especificaciones XML que definen menús. Se encuentra en el directorio fuente del proyecto. el manifiesto. Manifiesto Es un archivo XML que describe e indica los componentes de la aplicación que se esté desarrollando.1.xml: contiene una sentencia de comandos para compilar la aplicación e instalarla en un dispositivo. Por esa razón no se suele utilizar.5. El usado para crear aplicaciones que hagan uso de Google Maps es maps. Por ello se procederá a explicar a continuación cuales son los ficheros que contendrán el código.properties: contiene la configuración del proyecto. default. res/: contiene diversos recursos que se emplean en la aplicación. destacando R.

necesita ( algunos ejemplos son INTERNET. y así poder saber cual es la más reciente ( versionCode ). <manifest xmlns:android="http://schemas.miaplicacion" android:versionCode="1" android:versionName="1.Desarrollo de aplicaciones en Android • <manifest>: Es el nodo padre o raíz.. Por seguridad serán presentados al usuario durante la instalación por si quisiese denegarlos. CAMERA…). Indica el nombre del paquete que el desarrollador crea para su aplicación. Por su parte.0" > • <uses-permission>: Declara los permisos que la aplicación.ACCESS_FINE_LOCATION" > • <permission>: Define nuevos permisos que otras aplicaciones requerirán para poder acceder a partes restringidas de esta. <application>: Indica mediante sus propiedades ciertos metadatos de la aplicación como el título e icono. Es el nodo padre de <activity>. android:targetSdkVersion indica el nivel de la API sobre el cual está diseñado para ejecutarse la aplicación ( nivel óptimo ). A dichos permisos se les podrá asignar un nivel de protección ( normal. Se usa también para guardar el número de versión de la aplicación si existiesen varias. Es por esto que mediante tres propiedades de esta etiqueta se controlan sobre que versiones de la plataforma puede ejecutarse una aplicación. dangerous. <provider> y <receiver> ( y estos a su vez contienen definiciones de <intentfilters> entre otros datos ). En ocasiones también se incluyen nuevos nodos y propiedades para el manifiesto. lo cual es muy importante en el desarrollo de un proyecto software.android. sino el indicado en versionName. Ocurre que a veces la aplicación pueda usar elementos o comportamientos de dicho nivel. da nombre al proceso sobre el que correrá la aplicación o asigna un tema visual común a todas las actividades.permission. Este no es sin embargo el número de versión que se muestra a los usuarios de la aplicación. que contendrá al resto. … ) para saber si durante la ejecución se pueden conceder con directamente o mediante una nueva confirmación del usuario e incluso se podrán agrupar varios dentro de un mismo grupo. <uses-permission android:name="android. READ_CONTACTS. e incluso reemplazando partes que se han mejorado y quedan ahora obsoletas ( aunque la política empleada es la de mantener ambas partes para evitar la incompatibilidad de antiguas aplicaciones en nuevas versiones ). proveyendo estos nuevas clases y/o paquetes. <uses-sdk>: El desarrollo de la plataforma Android hace que vaya aumentando el número de niveles de la API. Este nodo especifica también si se está en modo debug o no. en lugar de limitarse a los existentes en el nivel mínimo que limitan al programa. android:minSdkVersion especifica el nivel mínimo de la API en el que puede funcionar ( si no se cumple la aplicación no comenzará a ejecutarse ) y posee el valor 1 por defecto y android:maxSdkVersion: el máximo ( aunque es habitual no declarar valor máximo ). ya que sino se podría dar el caso de que una aplicación maligna tuviese permiso SEND_SMS y se dedicase a mandar mensajes de texto a otros terminales sin el conocimiento del usuario. • • Trabajo Teórico POO 20 . y después se asignará dicho nombre a la propiedad android:permissionGroup de <permission>.com/apk/res/android" package="android. Para esto se creará un <permission-group> al que se dará un nombre. Las otras aplicaciones harán uso de cada permiso o de un grupo entero mediante <usespermission>. <services>.

• <activity>: indica múltiples propiedades de cada actividad. 21 Trabajo Teórico POO . Puede haber varias dentro de un <application>. Layout Aunque es posible usando el lenguaje Java instanciar y posicionar widgets a nuestra activity. Sin embargo existen ciertas bibliotecas que no lo hacen automáticamente. El principal motivo para hacer esto es que facilita la utilización de herramientas específicas de creación de modelos de GUI. siendo sin embargo las aquí mencionadas las de uso más común. 5. como son el awt y los mapas de Google.google. y solo es necesario importar los que se vayan a usar desde el código fuente.García et al. la forma más común de realizar dicha tarea será usar un fichero XML denominado Layout ( pueden crearse varios. todo ello sin tener que programar puesto que el código sería simultáneamente generado por la herramienta usada.android. <uses-library android:name="com. texto y reloj ) que posee como fondo una imagen añadida por el usuario a los recursos. en las que el usuario va disponiendo los widgets sobre la pantalla según le parezca y con las propiedades que desee. incluso algunas usadas únicamente para el desarrollo y testeo de la aplicación. entre ellas las relacionadas con el multiproceso y la forma en que se mostrará la activity en la pantalla.Actividad1” > <uses-library>: especifica una biblioteca compartida con la que el programa se ha de vincular.2. lo suyo es uno por cada activity ). Esta contiene otras clases estáticas ( una por tipo de recurso ) con identificadores para cada recurso ( layouts y widgets entre ellos ). Además el hecho de crear la interfaz apartada de las funcionalidades permite facilitar la separación de la vista y el modelo de datos.maps" > • Por supuesto existen otras muchas expresiones para describir la aplicación. permitiendo acceder a ellos desde el código Java de la aplicación. Los paquetes android. Ilustración 10 – Herramienta de creación de GUIs En la imagen superior se observa que se ha creado una interfaz con tres widgets ( botón. Son linkados por defecto.java que corresponde a una clase no heredable y autogenerada. Para modificar la interfaz durante la ejecución necesitaremos del archivo R. <activity android:name = ".

layout.las propiedades android:layout_width y android:layout_height que especifican su anchura y altura.1 Contenedores Existen unos elementos llamados contenedores ( también denominados layouts. p. public static final int LinearLayout01=0x7f050000. mientras que el número mínimo de columnas será igual al número de widgets de la fila más larga. Se puede ajustar también la distancia del widget a cada uno de los cuatro bordes del layout ( mediante las propiedades padding ). ej si quisiesemos a un widget A debajo y a la izquierda de otro B. } // […] } Ahora es muy sencillo poder hacer uso de los recursos en una aplicación. public static final int Button01=0x7f050002. Permite además configurar el tamaño de estos: cada widget dentro de un contenedor posee . este contenedor se compone de varios TableRow ( filas ) El número de filas será especificado por el programador. public static final int LinearLayout02=0x7f050003. A su vez. Dichos contenedores pueden contener a su vez a otros. y encima de C. Así pues en cada archivo xml usado para definir un modelo de interfaz gráfica se suelen incluir diferentes contenedores ( normalmente por lo menos uno que ocupe toda la pantalla y que contenga al resto ) que ajusten totalmente lo que aparece en la ventana respecto a lo que quiere el diseñador. ). TableLayout: permite crear una tabla invisible. . pero no deben confundirse con los archivo Layout ) que ayudan a posicionar y agrupar los widgets dentro de ellos. } public static final class id { public static final int AnalogClock01=0x7f050004.Desarrollo de aplicaciones en Android public final class R { public static final class attr { } public static final class drawable { public static final int fondo=0x7f020000. o fill_parent para que el widget se expanda para ocupar todo el espacio que quede disponible en el contenedor. 5. Basta con poner dentro del código de esa clase la siguiente línea: setContentView(R.2.main). Estas propiedades pueden tomar tres valores: un valor numérico que indica los píxeles exactos. } public static final class layout { public static final int main=0x7f030000. Por ejemplo se muestra como asignar el layout main ( el único que se ha creado ) a una clase activity. public static final int icon=0x7f020001. public static final int TextView01=0x7f050001. siendo posible que un widget ocupe varias celdas de una misma fila. • • Trabajo Teórico POO 22 . wrap_content que hace que el widget ocupe justo el tamaño que necesite. Estos son los más comunes: • LinearLayout: Alinea a los widgets uno detrás de otro vertical u horizontalmente ( según se especifique en la propiedad android:orientation. RelativeLayout: dispone a cada widget basándose en su relación con el resto.

permite instanciar cualquier elemento de IG declarado en la carpeta de recursos. iniciando la nueva actividad y finalizando la actual.TextView01). Esta última clase permite conocer cuál de todos los botones que agrupa es el que está marcado ( getCheckedRadioButtonId() ). NuevaActividad.class).García et al. Este sería el código de la acción a realizar: private OnClickListener accionBoton = new OnClickListener() { public void onClick(View v) { Intent intent = new Intent(). Ya en la segunda línea se ejecuta el cambio de texto haciendo uso de la instancia creada.this. texto. siendo necesario hacer un casting a la clase correspondiente. todos ellos con su correspondiente etiqueta XML y su clase. Se suele usar para identificar widgets adyacentes.setOnClickListener(accionBoton). RadioButton: hereda también de CompoundButton y se suelen usar en grupo mediante RadioGroup ( subclase de LinearLayout ). En el siguiente ejemplo se observa como se procedería si se quisiese cambiar el texto “HELLO” de la Ilustración 10 por otro durante la ejecución: TextView texto = (TextView)findViewById(R. finish(). } }. para comprobar su estado. Para que sea esto lo que se ejecute al pulsar el botón es necesario añadir lo siguiente en la actividad: boton. yendo estos desde los más simples hasta algunos más complejos como las galerías de imágenes. Hereda indirectamente de Button a través de CompoundButton. • • 23 Trabajo Teórico POO . Su clase tiene un método. lo que le permite usar los métodos de esta. A continuación se listan algunos de los más comunes con ejemplos ilustrativos de código: • TextView: una etiqueta de texto no editable por el usuario.2 Widgets Como ya se ha visto. android:singleLine para controlar si el texto editable es de una o varias líneas.id. Este código realiza el cambio mediante un intent. • EditText: es una clase derivada de TextView empleada como texto editable. etc… CheckBox: casilla de verificación con dos estados: marcado y sin marcar. así como desmarcar todos ( clearCheck () ).setClass(Actividad.2. Hay que resaltar además que Button hereda de TextView. Su objetivo es realizar una acción al ser pulsado. 5.setText("HOLA"). En la primera línea se observa como el método findViewById(). startActivity(intent). android:autoText para obtener ayuda ortográfica. La clase TextView posee los diferentes métodos para su modificación. de la clase Activity. intent. el SDK de Android proporciona una colección de widgets. En el Layout se puede configurar mediante diversas propiedades para que actúe como el diseñador quiera: android:capitalize para poner o automáticamente la primera letra en mayúscula. • Button: es un botón del cual se pueden modificar todos los aspectos de su apariencia. isChecked(). Para ejemplificar esto se va a mostrar como se haría para que al pulsar un botón se pase de la activity actual a otra distinta.

que requiere que se le indique una referencia al Layout que se quiere incluir dentro de otro. Estas pueden corresponden a los recursos. usando el método SetImage(). pero también se puede establecer basándose en el contenido de una URI. muchas veces esto no es suficiente. Sería más útil poder reutilizar una interfaz compleja con alguna utilidad concreta que se suela repetir comúnmente en las aplicaciones.2.java. un botón y una barra de progreso. por ejemplo un diálogo de identificación o login que cuente con un una etiqueta.3 Reutilización A pesar de que Android ofrece una buena variedad de widgets con la posibilidad de poderlos modificar a gusto del diseñador. La reusabilidad de la funcionalidad de dichas interfaces suele ir de la mano de la Activity creada ( heredada ) para dicho propósito.Desarrollo de aplicaciones en Android • Image View: permite instar imágenes. e incluso hacer alguna modificación sobre él. volviéndolo a usar cuando se use dicha interfaz gráfica en otra aplicación. pudiéndose incluir varios y hacer la elección de uso durante la ejecución. que tendrá su propio fichero . Esto también es útil cuando existen varios Layouts con el mismo propósito pero diferentes estilos. un texto editable. 5. Esta necesidad ha sido satisfecha en los Layouts de Android mediante el uso del nodo <include>. Trabajo Teórico POO 24 .

displayZoomControls()… Guardar su estado: onSaveInstanceState(android. no lo hace con las mismas características. la utilidad que se le puede dar a GMaps se acrecenta al pasar de un ordenador de sobremesa a un dispositivo móvil. La clase MapView anteriormente comentada solo puede ser instanciada en una MapActivity que se haga cargo de la gestión de sus servicios y su eliminación. onTouchEvent(. puesto que a pesar de que existe en algunos otros sistemas.view.6. … 6.google.1. como desplazamientos o zoom. por lo que sus métodos y manejo es idéntico: creando una subclase a la medida de lo que necesite el desarrollador. GOOGLE MAPS Uno de los servicios más populares de Google es el por todos conocidos Google Maps. 6.getController(). Esto se debe a que depende de varios hilos para acceder a la red y el sistema de archivos en segundo plano.1.1.ViewGroup y puede ser añadida al Layout. setStreetView(boolean)… boolean Mostrar diferentes controles para hacer uso del mapa: setBuiltInZoomControls(boolean).. Se obtiene como valor de retorno de MapView. isSatellite().3 MapController Gestiona el manejo de un mapa.com/android/add-ons/google-apis/mapkey.. Posee métodos para realizar los siguientes cometidos: • • • • Controlar el modo de vista: setTraffic(boolean).google. Sin embargo para poderlo utilizar es necesario obtener una clave de la API en la siguiente dirección: http://code.html y añadir el correspondiente permiso en el manifiesto.- .. Además.1.2 MapActivity Es la clase principal que contendrá el código con el que se haga uso de los diferentes servicios ofrecidos por Google Maps. Únicamente se admite un MapActivity por proceso.maps.android. puesto que no se trata de un paquete estándar.os. Clases básicas Existen tres clases que son fundamentales a la hora de construir una aplicación que haga uso del servicio ofrecido por Google Maps. Es una subclase de Activity. en caso contrario se pueden obtener resultados inesperados.Bundle) Control de eventos: onSizeChanged(. Estos son algunos de sus métodos: 25 .1 MapView Representa un mapa gracias a la información que obtiene del servicio del Google Maps.. y dichos hilos deben ser guiados en conjunción con el ciclo de vida del MapActivity. Resulta interesante hacer una mención a esta posibilidad que ofrece Android. 6. No es raro por tanto que Android lo integre a través del paquete com. puesto que en las situaciones en las que uno más necesitará de un mapa que le permita guiarse no tendrá posibilidad de echar mano de su PC.). 6.). Esta clase hereda de android.

toPixels(geo.setColor( Color. 10. estando solo disponible en ciertas ubicaciones ).y. se obtiene el centro del mapa y se traduce a píxeles.draw(canvas. Posteriormente serán añadidas al mapa insertándolas en la lista devuelta por MapView. canvas. • • 6. int setZoom(int): Permite modificar el nivel de zoom.x. GeoPoint geo = mapView.2. shadow). mapView. mapView. punto.getProjection().Desarrollo de aplicaciones en Android • animateTo (GeoPoint): Mueve el mapa hasta el punto dado como parámetro. Para el ejemplo propuesto este sería el código del Overlay: public class Simbolo extends Overlay { public void draw(Canvas canvas. Paint dibujoExter = new Paint(). } } Se explica brevemente: se instancia un objeto Paint para cada círculo.drawCircle(punto. actualizando el centro del mapa a todo lo que la animación parcial haya llegado. para posteriormente proceder a dibujar los dos círculos sobre dicho centro mediante el objeto Canvas pasado por parámetro.setColor( Color. dibujoExter. La clase GeoPoint representa un punto geográfico y su constructor recibe dos enteros: la latitud y la longitud multiplicadas por 1E6. canvas. Para esto es necesario conocer la existencia de la clases Overlay del paquete de GMaps. Paint dibujoInter = new Paint().getMapCenter(). dibujoInter). boolean shadow) { super.YELLOW ). Ahora solo queda proceder a la creación del mapa dentro de un MapActivity: Trabajo Teórico POO 26 . punto). dibujoInter.Canvas que será el que sea pintado en el MapView.x. Devuelve el nivel del zoom al que finalmente se ha situado.graphics. El modo de uso es por herencia: se debe de hacer una subclase y crear las instancias de esta que sean necesarias. stopAnimation(boolean): Para cualquier animación que esté en progreso en ese momento.getOverlays(). MapView mapView. El parámetro tomará un valor entre 1 ( el más lejano ) y 21 ( el más cercano.RED ). 25.drawCircle(punto. Point punto = new Point(). punto. dibujoExter). Para su instanciación requiere de un objeto gráfico de la clase android. pintandose dos círculos concéntricos encima de esta ( se omiten del código los paquetes importados ). Esta permite dibujar elementos sobre el mapa y gestionar los eventos que sobre el dibujo acontezcan. Ejemplo Se presenta ahora un sencillo ejemplo en el cual se va a obtener un mapa sobre la ciudad de Salamanca . Ese código serviría para pintar sobre el mapa.y.

vistamapa.add(simb).mapview). vistamapa = ( MapView )findViewById(R.getController(). vistamapa.setCenter(punto). controller = vistamapa.669643. vistamapa. private MapController controller = null.García et al. true). double lat = 40.id.onCreate(savedInstanceState). double lon = -5. public class mapa extends MapActivity { private MapView vistamapa = null. public void onCreate(Bundle savedInstanceState) { super.draw(canvas.layout. punto = new GeoPoint( (int) (lat*1E6). Simbolo simb = new Simbolo().960659. controller. setContentView(R.main). (int) (lon*1E6) ). controller.getOverlays(). simb. } } Este sería el resultado obtenido: Ilustración 11 – Ejemplo de aplicación creada mediante el uso de Google Maps 27 Trabajo Teórico POO .setZoom(17). private GeoPoint punto = null.setBuiltInZoomControls(true). Canvas canvas = new Canvas().

.

etc… • Pero no todo es malo. Además es posible simular un GPS NMEA-compatible en el emulador.2. LocationListener: interfaz que permite implementar una clase que captura los eventos asociados al dispositivo de localización.O.O. Android en la mayoría de los casos se ejecutará sobre un teléfono móvil. Telephony No conviene que nos olvidemos que el S. Supongamos por ejemplo que un empresario necesita una aplicación de gestión en su móvil. mientras que el segundo permite enviar sentencias NMEA 0183. Sus elementos más relevantes son: • • Location: clase que representa una localización geográfica en un tiempo concreto. 7. Para poder usarlo es necesario otorgar el permiso ACCESS_FIND_LOCATION a la aplicación. android. como pintar la posición del usuario en un mapa o transmitirla a otros dispositivos. con un solo click y sin tener que abandonar la aplicación.telephony. donde el primer parámetro sirve para especificar la longitud y latitud en grados. • • Tiene múltiples utilidades. dado que la consola proporciona un comando que permite establecer la posición geográfica actual.7. que permite controlar la información del servicio telefónico y su manipulación: acceder a los contactos.getLastKnownLocation("gps"). o disparar un evento específico cuando el dispositivo entra en la proximidad de una zona geográfica determinada. Permite actualizaciones periódicas de la situación geográfica del dispositivo. Su sintaxis es la siguiente: geo <fix|nmea>. Dicha aplicación podría incorporar la posibilidad de poder llamar o mandar un mensaje directamente desde esta a los clientes y/o proveedores. FACILIDADES DE ANDROID Este capítulo pretende mostrar al lector algunos de los paquetes que Android provee para controlar el dispositivo para que pueda hacerse una idea de las posibilidades de esta plataforma. y viceversa. Location Es el paquete que provee las clases necesarias para el manejo de GPS en Android. Geocoder: clase que permite traducir entre direcciones físicas y coordenadas en latitud y longitud. Así por ejemplo para conocer la situació actual se utiliza LocationManager. 29 . Es por esto que Android incorpora un paquete. LocationManager: clase para gestionar el dispositivo de localización.- . o que haya fugas de memoria que bloqueen el teléfono completamente. Esto puede suponer ciertos problemas: • • Si la aplicación hace uso de un alto porcentaje de CPU sería un impedimento de cara a que se puedan recibir llamadas.1. e incluso la altitud en metros si fuese necesario. por ejemplo no desvaneciéndose a segundo plano cuando hay una llamada entrante. No optimizar los recursos de forma que se agote la batería en poco tiempo ( el usuario no podría seguir usando el teléfono ). Que las aplicaciones desarrolladas no colaboren convenientemente con el resto de aplicaciones y el S. puesto que ese hecho le añadirá más funcionalidad: los usuarios pueden enviar y recibir llamadas. 7. pero ahora además también podrán ser ayudados a ello.

3.Desarrollo de aplicaciones en Android dividir un texto en varios SMS para que puedan ser enviados. Android. etc… Pero el método más importante es getCallState(). gestionar el envío y recepción de mensajes. La forma de obtener un objeto de esta clase es la siguiente: TelephonyManager telefono=(TelephonyManager) getSystemService(Context. CALL_STATE_OFFHOOK: Llamada en progreso. ha desarrollado la clase android. para no quedarse atrás.hardware. valor que deberá tenido en cuenta antes de realizar otras operaciones. realizar llamadas. CALL_STATE_RINGING: Llamada solicitada. principalmente para los videojuegos. habrá que hacer la correspondiente adición en el manifiesto. Esta tecnología puede tener muchas más utilidades de las que parece. como ya llevan tiempo haciendo otras empresas como Apple en su Ipod y Nintendo con la Wii. Esta forma es similar a la usada para el GPS o el servicio wifi. el emulador no está preparado aun para simular muchas de las opciones del paquete. A pesar de todo. Teniendo en cuenta además que se trata de un servicio. supliendo la falta de teclado de los móviles táctiles con movimientos de este. aunque la que se encarga de regular y controlar el dispositivo es TelephonyManager.SensorManager que provee métodos para el reconocimiento y la creación de gestos que el usuario haga con el móvil ( por ejemplo un sacudido ). 7. cometido que hasta ahora no había sido posible de ninguna forma: http://code. Una vez instanciada. Puede ser: • • • CALL_STATE_IDLE: El teléfono no está en uso. A modo de curiosidad se le ofrece al lector visitar el siguiente enlace en el que se explica un proyecto que se está desarrollando para poder simular dichos gestos mediante el emulador usando el ratón. etc… El paquete en cuestión contiene varias clases para realizar dichas operaciones. Por ejemplo getLine1Number() retorna el número de teléfono propio.TELEPHONY_SERVICE). Reconocimiento de gestos Algunos de los nuevos dispositivos móviles ahora incorporan acelerómetros y brújula.com/p/openintents/wiki/SensorSimulator Trabajo Teórico POO 30 . podremos hacer uso de sus numeros métodos.google. Este devuelve una constante que indica el estado de llamada del dispositivo. aunque provee un comando sms para simular envío de mensajes hacia el emulador. getNetworkOperatorName() devuelve el nombre del operador de telefonía utilizado.

Incentivando (e incluso imponiendo) el uso de la reutilización de código. Por último cabe destacar el magnífico recurso que es la clase Intent.8. buscando la máxima optimización posible de los recursos disponibles. Es de código abierto. robusto y con abundante documentación como es Java. probablemente debidos a una publicación prematura.- . la separación de funcionalidades. Por todas estas razones auguramos un gran futuro para Android. de forma que tareas recurrentes en múltiples aplicaciones sean siempre resueltas de la misma forma. CONCLUSIONES El sistema operativo Android es un buen candidato para establecerse como opción principal dentro del sector de teléfonos móviles. Permite al programador concentrarse en una tarea sabiendo que el resto están cubiertas por otras aplicaciones. siendo las últimas versiones muy estables y extendidas. Reúne múltiples características para convertirlo en la opción preferida. Reutiliza un idioma de programación muy extendido. De esta forma. la gestión de contactos o la navegación web. todas estas funcionalidades adicionales quedan integradas en las aplicaciones propias. Optimiza la gestión de recursos. proporcionando al usuario una interfaz cohesionada. adecuándose a dispositivos de escasa memoria y procesador como son los teléfonos móviles. como pueden ser el manejo de mapas. A pesar de que las primeras versiones contenían abundantes errores. En nuestra opinión lo que hace de Android un producto a tener muy en cuenta es el buen diseño de su arquitectura y funcionamiento. sus múltiples niveles de abstracción que permiten modificar o reemplazar fácilmente sus componentes por separado y naturalmente el enfoque hacia un entorno de teléfonos móviles. con el paso del tiempo el sistema ha madurado. cualquier persona puede crear aplicaciones según su necesidad. estando la mayoría de ellas incluidas en las librerías de Android. 31 .

.

html * Último acceso a todas las direcciones webs: 15 de Abril de 2010.com/index.google. Ed ( 2008 ): Hello Android Gramlich.wikipedia. Nicolas: AndBook Android Developers: http://developer.org/ Kronox: http://kronox.com/intl/es-ES/android/addons/google-apis/reference/com/google/android/maps/package-summary.androlib.maps: http://code. y Komatineni .android.com/mobile/maps/ OpenIntents: http://code.google. Reto ( 2009 ): Professional Android Application Development Burnette. Satya ( 2009 ): Pro Android Meier.google. L ( 2009 ): Beginning Android Hashimi.- .org/ Androlib: http://www. 33 .cfm?post_id=4563 Google Mobile: http://www.google.Bibliografía • • • • • • • • • • • • • Murphy.android.com/p/openintents/w/list Package com.com/ Wikipedia: http://es. Sayed Y. Mark.com/ Eliax: http://eliax.

Sign up to vote on this title
UsefulNot useful