Guía básica para la creación de Apps sencillas nativas sobre Android
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

Guía básica para la creación de Apps sencillas nativas sobre Android

  • 3,487 views
Uploaded on

Proyecto final de ciclo, en Sistema de Telecomunicaciones e Informáticos, del alumno Xavier Valls. Ver más en......

Proyecto final de ciclo, en Sistema de Telecomunicaciones e Informáticos, del alumno Xavier Valls. Ver más en http://www.francescperez.net/html/proyectos/articulos/art_5_Guia_basica_apps_Android.html

Ver más en http://francescperez.net/html/proyectos/articulos/art_5_Guia_basica_apps_Android.html

More in: Education
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
3,487
On Slideshare
3,397
From Embeds
90
Number of Embeds
2

Actions

Shares
Downloads
226
Comments
1
Likes
8

Embeds 90

http://francescperez.net 48
http://www.francescperez.net 42

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Programación en Android Proyecto final CFGS Sistemas de Telecomunicaciones e Infomáticos.Autor: Xavier Valls FabregatTutor: Francesc PérezFecha: 22 de junio de 2012
  • 2. 2
  • 3. INTRODUCCIÓNMi nombre es Xavier Valls Fabregat, estudio 2n curso de CFGS de sistemas detelecomunicaciones e informática y mi proyecto se basa en programación sobreAndroid.Antes que nada quiero destacar que este proyecto para mi supuso un reto, ya quetenia ganas de aprender a programar en Android por la innovación y popularidadque ese plataforma presenta, pero teniendo en cuenta que mi nivel en programaciónsobre Android y sobretodo en Java era básicamente nula, solo tenía nociones deprogramación en C adquiridas en el primer curso del grado superior.El proyecto presente tiene como finalidad estudiar el funcionamiento y lasposibilidades que ofrece el sistema operativo móvil Android comenzando por unenfoque analítico de sus características hasta llegar a la realización de unaaplicación que ejemplifique sus funcionalidades básicas.El primer capítulo se centra en el eje de este proyecto, el sistema operativo Android,donde se presentará brevemente su origen para dar paso al estudio de los recursosque ofrece así como el tipo de aplicaciones que se desarrollan en él y lasherramientas que ayudan a su implementación.En el segundo capítulo se explicara la estructura de un proyecto Android así comolas diferentes carpetas y tipos de archivos que lo componen.En el tercer capítulo se pasará a un enfoque práctico, mostrando ejemplos deimplementación de las diferentes partes así como configuraciones necesarias parael correcto funcionamiento de las aplicaciones.Por último, se hablara de la aplicación desarrollada en la cual se unen gran parte losconceptos explicados a lo largo del proyecto, de los objetivos iniciales y de losresultados finales, así como de las conclusiones y mi valoración personal.En los Anexos se explica detalladamente la aplicación creada y su código, comotambién las herramientas utilizadas para su desarrollo. 3
  • 4. ÍNDICEINTRODUCCIÓN .............................................................................. 31. CONCEPTOS SOBRE ANDROID................................................... 7 1.1 ¿Qué es una plataforma de software? .................................................................. 7 1.2 ¿Qué es Android? ................................................................................................. 7 1.3 Android SDK ....................................................................................................... 10 1.4 Anatomía de una aplicación de Android .............................................................. 10 1.5 Tipos de aplicación de Android ........................................................................... 12 1.6 Ciclo de vida de una aplicación de Android ......................................................... 13 1.7 Almacenamiento ................................................................................................. 16 1.8 Gráficos .............................................................................................................. 17 1.9 Direccionamiento en Android .............................................................................. 18 1.10 Recursos ........................................................................................................... 182. ESTRUCTURA DE UN PROYECTO ANDROID ............................. 19 2.1 Carpeta /src/ ...................................................................................................... 19 2.2 Carpeta /res/ ...................................................................................................... 19 2.3 Carpeta /gen/ ..................................................................................................... 20 2.4 Carpeta /assets/ ................................................................................................. 21 2.5 Fichero AndroidManifest.xml .............................................................................. 213. ANDROID EN PRÁCTICA ........................................................... 22 3.1 Android Manifest ................................................................................................. 22 3.2 Interfaz de Usuario .............................................................................................. 23 3.3 Geolocalización y Mapas .................................................................................... 36 3.4 Bases de datos ................................................................................................... 38 3.5 Configuración SD Card ....................................................................................... 40 3.6 Media APIs ......................................................................................................... 40 3.7 Otros ejemplos .................................................................................................... 414. CREANDO UNA APLICACIÓN EN ANDROID ................................ 425. CONCLUSIONES ....................................................................... 44 5.1 Valoración personal ........................................................................................... 44 5.2 Líneas futuras .................................................................................................... 446. BIBLIOGRAFÍA .......................................................................... 45 4
  • 5. ANEXO I HERRAMIENTAS DE DESARROLLO ................................. 47 AI.1 Instalación de las herramientas básicas: JDK, SDK y Eclipse ........................... 47 AI.2 Herramientas adicionales: Droid Draw ............................................................... 52ANEXO II EXPLICACIÓN DETALLADA DE LA APLICACIÓN ............. 53 AII.1 Carpeta /res/layout ........................................................................................... 54 AII.2 Carpeta /src ...................................................................................................... 59 AII.3 Android Manifest.xml ........................................................................................ 67 5
  • 6. 6
  • 7. 1. CONCEPTOS SOBRE ANDROID1.1 ¿Qué es una plataforma de software?Una plataforma de software es un elemento crucial en el desarrollo del mismo.Mediante el marco de trabajo que proporcionan las plataformas se puede crearnuevo software y que este se pueda ejecutar sobre ellas (ver Fig. 2.1). Lasplataformas de desarrollo típicas incluyen una arquitectura de computadores,un sistema operativo (S.O.), lenguajes de programación y sus correspondienteslibrerías o interfaces gráficas. Usuario Aplicación Plataforma de software Hardware Fig. 2.1 Estructura de capasLas plataformas son comúnmente mencionadas con las APIs (funciones ymétodos que ofrece una biblioteca para ser utilizada por otro software comouna capa de abstracción). Un conjunto completo de APIs constituye unaplataforma software. Estas plataformas son normalmente dependientes de lossistemas operativos aunque existen otras en las que no es así.Java es un ejemplo de plataforma no dependiente del S.O. debido a que Javaes tanto el lenguaje como la plataforma de desarrollo, la cual incluye la JavaVirtual Machine (JVM) cuya función es interpretar el bytecode resultante de lacompilación del código fuente del programa en Java.1.2 ¿Qué es Android?Android es una plataforma de software y un sistema operativo para dispositivosmóviles basada en un kernel Linux, desarrollada por Google y más tarde por laOpen Handset Alliance. Esta plataforma permite a los desarrolladores escribircódigo en Java que se ejecuten en móviles mediante las librerías Javadesarrolladas por Google. También se pueden escribir aplicaciones en otroslenguajes, como por ejemplo C, para posteriormente ser compiladas en códigonativo ARM y ejecutarlas, aunque este proceso de desarrollo no está soportadooficialmente por Google. La mayor parte de la plataforma de Android estádisponible bajo licencia de software libre de Apache y otras licencias de códigoabierto. 7
  • 8. 1.2.1 Breve HistoriaEn Julio de 2005, Google adquirió Android, Inc, una pequeña startup deCalifornia. En esos momentos, la compañía se dedicaba a la creación desoftware para teléfonos móviles. Una vez en Google, el equipo desarrolló unS.O. basado en Linux para dispositivos móviles. Más adelante, Google adaptósu buscador y sus aplicaciones para su uso en móviles.En septiembre del 2007, Google tenía varias patentes de aplicaciones sobre elárea de la telefonía móvil. El 5 de noviembre del mismo año, se anunció lafundación de la Open Handset Alliance al mismo tiempo que la creación de laplataforma Android. La Open Handset Alliance está formada por un consorciode 34 compañías de hardware, software y telecomunicaciones, entre las cualesse incluyen Google, HTC, Intel y Motorola entre otras, dedicadas a investigarestándares abiertos para dispositivos móviles.El primer teléfono en el mercado que posee Android es el T-Mobile G1 (tambiénconocido como Dream), lanzado el día 22 de octubre de 2008 que viene con laversión Android 1.0 preinstalada. Este móvil es el resultado conjunto de T-Mobile, HTC y Google. Por último, desde el 21 de octubre de 2008, Androidestá disponible como código abierto . Gracias a esto, cualquiera puede añadirextensiones, nuevas aplicaciones o reemplazar las existentes por otras dentrodel dispositivo móvil1.2.2 Características de Android  Amplia variedad de diseños (VGA, librerías de gráficos 2D y 3D…)   Almacenamiento de datos en BBDD SQLite   Conectividad (GSM/EDGE, CDMA, EV-DO, UMTS, Bluetooth y Wi-Fi)   Mensajería (SMS y MMS)   Navegador Web   Máquina virtual de Java   Las aplicaciones escritas en Java pueden ser compiladas y ejecutadas en la maquina virtual de Dalvik, la cual es una especializada máquina virtual diseñada para uso en dispositivos móviles.   Soporte de formatos (MPEG-4, H.264, MP3, AAC, OGG, AMR, JPEG, PNG, GIF)   Soporte para hardware adicional (cámaras de video, pantallas táctiles,  GPS, acelerómetros…)   Entorno de desarrollo (emulador, herramientas de depuración, perfiles de memoria y funcionamiento, plugin para Eclipse IDE).  8
  • 9. 1.2.3 Arquitectura de AndroidEn la Fig. 2.2 se muestra la composición de la arquitectura de Android. Fig. 2.2 Arquitectura de AndroidA continuación, se detallarán los diferentes componentes principales de laarquitectura de Android:  Aplicaciones: Las aplicaciones base incluirán un cliente de email, programa de SMS, calendario, mapas, navegador, contactos, y otros. Todas las aplicaciones están escritas en el lenguaje de programación Java.  Framework de aplicaciones: Los desarrolladores tienen acceso completo a las APIs del framework usado por las aplicaciones base. La arquitectura está diseñada para simplificar el reuso de componentes; cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación puede luego hacer uso de esas capacidades (sujeto a reglas de seguridad del framework). Éste mismo mecanismo permite que los componentes sean reemplazados por el usuario. Este framework está formado por:  o Un extenso conjunto de Vistas tales como listas, cajas de texto, botones… o Content Providers que permiten a las aplicaciones acceder a información de otras aplicaciones o compartir su propia información. 9
  • 10. o Resource Manager, que proporciona acceso a recursos que no son código como pueden ser gráficos, cadenas de texto... o Notification Manager, que permite a las aplicaciones mostrar alarmas personalizadas en la barra de estado. o Activity Manager, que gestiona el ciclo de la vida de las aplicaciones.  Librerías: Android incluye un set de librerías C/C++ usadas por varios componentes del sistema. Estas capacidades se exponen a los desarrolladores a través del framework de aplicaciones de Android, el cual interactúa con las librerías mediante JNI (Java Native Interface). Algunas son: System C library (implementación librería C estándar), librerías de medios, librerías de gráficos, 3d, SQLite, entre otras.  Runtime de Android: Android incluye un set de librerías base que proveen la mayor parte de las funcionalidades disponibles en las librerías base del lenguaje de programación Java. Cada aplicación Android corre su propio proceso, con su propia instancia de la máquina virtual Dalvik. Dalvik ha sido escrito de forma que un dispositivo puede correr múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.dex), el cual está optimizado para memoria mínima.  Núcleo - Linux: Android depende de un Linux versión 2.6 para los servicios base del sistema como seguridad, gestión de memoria, gestión de procesos, pila de red, y modelo de drivers. El núcleo también actúa.1.3 Android SDKEl kit de desarrollo de software (software development kit o SDK) incluye unconjunto de herramientas de desarrollo, tales como un debugger, librerías, unemulador (basado en QEMU ), documentación, código de ejemplo y tutoriales.Está soportado en S.O. Windows, Linux y Mac. El entorno de desarrollo(integrated development environment o IDE) oficialmente soportado es Eclipseconjuntamente con el plugin ADT proporcionado por Google.1.4 Anatomía de una aplicación de AndroidDentro de una aplicación de Android hay cuatro componentesprincipales:Activitity, Listeners, Servicios y Content Provider. Todas las aplicacionesde Android están formadas por algunos de estos elementos o combinacionesde ellos. 10
  • 11. 1.4.1 ActivityLas Activities (o Actividades) son el elemento constituyente de Android máscomún. Para implementarlas se utiliza una clase por cada Actividad queextiende de la clase base Activity. Cada clase mostrará una interfaz de usuario,compuesta por Views (o Vistas). Cada vez que se cambie de Vista, secambiará de Actividad, como por ejemplo en una aplicación de mensajería quese tiene una Vista que muestra la lista de contactos y otra Vista para escribir losmensajes. Cuando cambiamos de Vista, la anterior queda pausada y puestadentro de una pila de historial para poder retornar en caso necesario. Tambiénse pueden eliminar las Vistas del historial en caso de que no se necesiten más.Para pasar de vista en vista, Android utiliza una clase especial llamada Intent .  IntentsUn Intent es un objeto mensaje y que, en general, describe que quiere haceruna aplicación. Las dos partes más importantes de un Intent son la acción quese quiere realizar y la información necesaria que se proporciona para poderrealizarla, la cual se expresa en formato URI (Uniform Resource Identifier). Unejemplo seria ver la información de contacto de una persona, la cual medianteun Intent con la acción ver y la URI que representa a esa persona se podríaobtener.Relacionado con los Intents hay una clase llamada IntentFilter que es unadescripción de que Intents puede una Actividad gestionar. Mediante losIntentFilters, el sistema puede resolver Intents, buscando cuales posee cadaactividad y escogiendo aquel que mejor se ajuste a sus necesidades. Elproceso de resolver Intents se realiza en tiempo real, lo cual ofrece dosbeneficios:  Las actividades pueden reutilizar funcionalidades de otros componentes simplemente haciendo peticiones mediante un Intent.   Las actividades pueden ser remplazadas por nuevas actividades con  IntentFilters equivalentes. 1.4.2 ListenersLos Listeneres se utilizan para reaccionar a eventos externos (por ejemplo, unallamada). Los Listeners no tienen UI (User Interface) pero pueden utilizar elservicio NotificationManager para avisar al usuario.Para lanzar un aviso no hace falta que la aplicación se esté ejecutando, encaso necesario, Android la iniciará si se activa el Listeners por algún evento. 11
  • 12. 1.4.3 ServiciosUn Servicio es básicamente un código que se ejecuta durante largo tiempo ysin necesidad de UI, como puede ser un gestor de descarga en el cual seindican los contenidos a descargar y posteriormente el usuario puede accedera una nueva Vista sin que el gestor se interrumpa.En caso de que haya múltiples servicios a la vez, se les puede indicardiferentes prioridades según las necesidades.1.4.4 Content ProviderEn Android, las aplicaciones pueden guardar su información en ficheros, BBDDSQLite... Pero en caso de que lo que se quiera sea compartir dicha informacióncon otras aplicaciones, lo necesario es un Content Provider. Un ContentProvider es una clase que implementa un conjunto estándar de métodos quepermite a otras aplicaciones guardar y obtener la información que maneja dichoContent Provider.1.4.5 Android ManifiestEn Android existe un archivo XML llamado AndroidManifest que, aunque noforme parte del código principal de la aplicación, es necesario para su correctofuncionamiento. Este archivo es el fichero de control que le dice al sistema quetiene que hacer con todos los componentes anteriormente mencionados eneste apartado que pertenecen a una aplicación en concreto.1.5 Tipos de aplicación de AndroidUn Android Package (.apk) es el fichero que contiene el código de la aplicacióny sus recursos, y que posteriormente se instala en el dispositivo para poderejecutar la aplicación.1.5.1 TareasUna tarea en Android es lo que el usuario ve como una aplicación y eldesarrollador ve como una o más Actividades donde el usuario interacciona yva pasando de Vista en Vista.Dentro de las tareas, una actividad toma el papel de punto de entrada (será laprimera en mostrarse cuando se ejecute la aplicación) y las demás, si hay,formarán parte de la misma tarea, a la espera de ser instanciadas. 12
  • 13. 1.5.2 ProcesosEn Android, los procesos se ejecutan a nivel de kernel y el usuarionormalmente no tiene constancia de ellos. Todo el código de la aplicación sesuele ejecutar en un proceso dedicado pero también se puede especificar sisólo se quiere que se ejecute en el proceso una determinada clase ocomponente de la aplicación.Los principales usos de los procesos son:  Mejorar la estabilidad o seguridad de las aplicaciones.   Reducir la sobrecarga de proceso ejecutando el código de múltiples aplicaciones en el mismo proceso.   Ayudar al sistema a gestionar los recursos separando partes de código pesado en un proceso separado que puede ser eliminado independientemente de otras partes de la aplicación. 1.5.3 ThreadsEn lo referente a threads, Android evita la creación de threads adicionales porparte de un proceso, manteniendo la aplicación en un sólo thread al menos queno los cree la propia aplicación. Esto repercute de manera importante en lasllamadas a instancias a Actividades, Listeners y Servicios, ya que sólo puedenser hechas por el thread principal del proceso en el que están corriendo.Por otro lado, al no crearse un thread por cada instancia, dichas instancias nodeben realizar operaciones largas o bloqueantes cuando son llamadas, de locontrario, bloquearían todos los demás componentes del proceso.1.6 Ciclo de vida de una aplicación de AndroidCada aplicación de Android corre en su propio proceso, el cual es creado por laaplicación cuando se ejecuta y permanece hasta que la aplicación deja detrabajar o el sistema necesita memoria para otras aplicaciones.Una característica fundamental de Android es que el ciclo de vida de unaaplicación no está controlado por la misma aplicación sino que lo determina elsistema a partir de una combinación de estados como pueden ser queaplicaciones están funcionando, que prioridad tienen para el usuario y cuantamemoria queda disponible en el sistema. De esta manera, Android sitúa cadaproceso en una jerarquía de importancia basada en los estados comentados,como se puede ver a continuación. 13
  • 14. 1. Un proceso en primer plano es uno que se requiere para lo que el usuario está actualmente haciendo. Se considera en primer plano si:  Esta ejecutándose una Actividad perteneciente a la pantalla con la que el usuario está interactuando.   Está ejecutando un BroadcastReceiver   Esta ejecutándose un servicio.  2. Un proceso visible es aquel que contiene una Actividad que es visible al usuario mediante la pantalla pero no en primer plano (esta pausada). Este proceso solo se eliminará en caso de que sea necesario para mantener ejecutándose los procesos en primer plano. 3. Un proceso de servicio es aquel que contiene un servicio que ha sido inicializado. No son directamente visibles al usuario y el sistema los mantendrá a no ser que no pueda servir los dos anteriores. 4. Un proceso en background es aquel que acoge una actividad que no está actualmente visible al usuario. Mientras que dichos procesos implementen bien su propio ciclo de vida, el sistema puede eliminarlos para dar memoria a cualquiera de los 3 servicios anteriores. 5. Un proceso vacío es aquel que no contiene ningún componente activo de ninguna aplicación. La única razón para mantener dicho proceso es para mejorar sus inicializaciones posteriores a modo de caché.Para comprender mejor el ciclo de vida de una aplicación de Android, en la Fig.2.3 se muestra el diagrama de flujo de dicho ciclo, mencionando también losmétodos que se llaman durante el transcurso del mismo. 14
  • 15. Fig 2.3 Ciclo de la vida de una aplicación Android 15
  • 16. 1.7 Almacenamiento Android presenta varias formas de almacenamiento de la información, las cuales, se describen en la Tabla 2.1. Es importante notar que en Android todos los datos de la aplicación son privados a esta. Tabla 2.1 Mecanismos de almacenamiento de la información en Android Mecanismo Descripición Preferencias Mecanismo ligero para almacenar y recuperar parejas de claves-valor, útil para guardar preferencias Ficheros Se pueden guardar tanto en el dispositivo como en dispositivos extraíbles BBDD Soporte para crear BBDD SQLite privadas pertenecientes al package que las creó Content Provider Explicado en 1.4.4 Red Uso de la red para almacenar y recuperar información1.7.1 Imágenes de discoDentro de la categoría de ficheros, encontramos las imágenes de disco, queAndroid usa para poder almacenar los datos y las diferentes configuraciones, lascuales simulan particiones flash de disco, por ejemplo, una imagen quecontenga el kernel del emulador, una imagen para la memoria ram, datos deusuario y una imagen para simular una tarjeta SD.Por defecto, Android guarda localizaciones predeterminadas para estasimágenes. Durante el arranque, el emulador busca y lee estos ficheros deimágenes. Esta ubicación se puede especificar mediante las opciones dearranque del emulador; si no encuentra ninguna imagen, utiliza las direccionespor defecto.El emulador usa tres tipos de imagen: de sistema, de runtime, y temporales.  Las imágenes de sistema contienen datos del sistema y configuraciones por defecto necesarias para que el emulador arranque. Estas imágenes son de sólo lectura, ya que no se deben modificar.  Las imágenes de runtime leen y escriben datos. Son dos: la de datos y la de tarjetas SD emuladas. Cada emulador usa una imagen de datos de usuario para guardar los datos específicos de sesión y usuario, como por ejemplo, las aplicaciones instaladas. Si se usan varias instancias de emularos a la vez, solo la primera puede usar datos persistentes si no se especifican ficheros de imagen diferentes en el arranque. Opcionalmente, se pueden crear imágenes de disco que emulen tarjetas SD. Solamente se puede cargar una imagen de disco en la carga del emulador. Además una vez cargada una tarjeta SD, no se puede extraer de un emulador en funcionamiento, pero si navegar por ella y añadir o remover archivos. El emulador soporta tarjetas SDHC emuladas por lo que soporta tamaños de hasta 128 gigabytes.  16
  • 17.   Por último están las imágenes temporales, las cuales se eliminan al apagarse el dispositivo. Estas imágenes son una copia de la imagen de sistema de Android y la imagen de la memoria caché. 1.8 GráficosPara implementar gráficos 2D y 3D (ver Fig. 2.4), Android utiliza OpenGL ES(OpenGL for Embedded Systems) , una variante simplificada de la API gráficaOpenGL diseñada para dispositivos integrados tales como teléfonos móviles,PDAs y consolas de videojuegos. La define y promueve el Grupo Khronos , unconsorcio de empresas dedicadas a hardware y software gráfico interesadas enAPIs gráficas y multimedia. Existen varias versiones, de entre las cuales laversión 1.0 ha sido seleccionada como la API oficial para gráficos 3D de Android. Fig. 2.4 Ejemplo de gráfico 3D generado con OpenGL ESLa API original, OpenGL, es una especificación estándar que define una APImultilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos2D y 3D. La interfaz consiste en más de 250 funciones diferentes que puedenusarse para dibujar escenas tridimensionales complejas a partir de primitivasgeométricas simples, tales como puntos, líneas y triángulos. Fue desarrolladaoriginalmente por Silicon Graphics Inc. (SGI) en 1992 y se usa ampliamente enCAD, realidad virtual, representación científica, visualización de información ysimulación de vuelo. También se usa en desarrollo de videojuegos, dondecompite con Direct3D en plataformas Microsoft Windows.OpenGL tiene dos propósitos esenciales:  Ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas, presentando al programador una API única y uniforme.  Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten la funcionalidad completa de OpenGL (utilizando emulación software si fuese necesario).Dado que la explicación del uso de OpenGL ES no entra dentro del ámbito deeste proyecto, no se entrará en detalle de su implementación. 17
  • 18. 1.9 Direccionamiento en AndroidCada instancia del emulador corre detrás de un router virtual que aísla elemulador de las interfaces de red del PC. Un dispositivo emulado no puede verel PC u otro emulador de la red. En su lugar, solo ve que está conectado através de una Ethernet a un router.Cabe destacar que las mismas direcciones son usadas en todos los emuladoresque se están ejecutando, reforzando el aislamiento. Para consultar el espacio dedirecciones de Android, consultar el . También destacar que estedireccionamiento es específico al emulador y que probablemente sea muydiferente en dispositivos reales. Actualmente, el emulador no soporta IGMP omulticast.1.10 Recursos Los recursos en Android son ficheros externos que no son código y que son usados y compilados dentro de la aplicación. Android soporta diferentes tipos de recursos, incluido XML, PNG y JPEG. Los ficheros XML tienen diferente formato dependiendo de que describan. Los recursos se exteriorizan respecto al código. Los ficheros XML se compilan dentro un archivo binario por razones de eficiencia y los strings se comprimen en una forma más eficiente de almacenamiento. Es por esta razón que hay diferentes tipos de recursos en Android. En general, hay recursos de tres tipos: ficheros XML, bitmaps y ficheros raw (por ejemplo, ficheros de sonido). En la Tabla 2.2 se muestran los tipos de recursos posibles que hay en Android. Tabla 2.2 Tipo de recursos en Android Tipo Descripción Anim Ficheros XML que son compilados en objetos de animacionesDrawable Ficheros con formato .png, .9.png, .jpg que se compilan en un fichero bitmap Layout Ficheros XML que se compilan en vistas de pantalla Ficheros XML que se compilan en varios tipos de recursos, para Values definir, por ejemplo, arrays, colores, strings... Ficheros XML arbitrarios que son compilados y pueden ser XML llamados en tiempo de ejecución Raw Ficheros arbitrarios que son copiados directamente al dispositivo 2.11 Herramientas de desarrollo Para poder desarrollar sobre Android hay una serie de herramientas necesarias y unos requisitos que hay que tener en cuenta. Ver Anexo I. 18
  • 19. 2. ESTRUCTURA DE UN PROYECTO ANDROIDPara empezar a comprender cómo se construye una aplicación Android vamos aechar un vistazo a la estructura general de un proyecto.Cuando creamos un nuevo proyecto Android en Eclipse se generaautomáticamente la estructura de carpetas necesaria para poder generarposteriormente la aplicación. Esta estructura será común a cualquier aplicación,independientemente de su tamaño y complejidad.En la siguiente imagen vemos los elementos creados inicialmente para un nuevoproyecto Android:Describamos los elementos principales.2.1 Carpeta /src/Contiene todo el código fuente de la aplicación, código de la interfaz gráfica,clases auxiliares, etc. Inicialmente, Eclipse creará por nosotros el código básicode la pantalla (Activity) principal de la aplicación, siempre bajo la estructura delpaquete java definido.2.2 Carpeta /res/Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes,vídeos, cadenas de texto, etc. Los diferentes tipos de recursos de deberándistribuir entre las siguientes carpetas:  /res/drawable/. Contienen las imágenes de la aplicación. Se puede dividir en /drawable-ldpi, /drawable-mdpi y /drawable-hdpi para utilizar diferentes recursos dependiendo de la resolución del dispositivo.  /res/layout/. Contienen los ficheros de definición de las diferentes pantallas de la interfaz gráfica. Se puede dividir en /layout y /layout-land para definir distintos layouts dependiendo de la orientación del dispositivo.  /res/anim/. Contiene la definición de las animaciones utilizadas por la aplicación.  /res/menu/. Contiene la definición de los menús de la aplicación. 19
  • 20.  /res/values/. Contiene otros recursos de la aplicación como por ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), etc.  /res/xml/. Contiene los ficheros XML utilizados por la aplicación.  /res/raw/. Contiene recursos adicionales, normalmente en formato distinto a XML, que no se incluyan en el resto de carpetas de recursos.Como ejemplo, para un proyecto nuevo Android, se crean los siguientes recursospara la aplicación:2.3 Carpeta /gen/Contiene una serie de elementos de código generados automáticamente alcompilar el proyecto. Cada vez que generamos nuestro proyecto, la maquinariade compilación de Android genera por nosotros una serie de ficheros fuente enjava dirigidos al control de los recursos de la aplicación.El más importante es el que se puede observar en la imagen, el fichero R.java, yla clase R.Esta clase R contendrá en todo momento una serie de constantes con los ID detodos los recursos de la aplicación incluidos en la carpeta /res/, de forma quepodamos acceder fácilmente a estos recursos desde nuestro código a través deeste dato. Así, por ejemplo, la constante R.drawable.icon contendrá el ID de laimagen “icon.png” contenida en la carpeta /res/drawable/. Veamos como ejemplola clase R creada por defecto para un proyecto nuevo: 20
  • 21. 1 package net.sgoliver;23 public final class R {4 public static final class attr {5 }6 public static final class drawable {7 public static final int icon=0x7f020000;8 }9 public static final class layout {10 public static final int main=0x7f030000;11 }12 public static final class string {13 public static final int app_name=0x7f040001;14 public static final int hello=0x7f040000;15 }16 }2.4 Carpeta /assets/Contiene todos los demás ficheros auxiliares necesarios para la aplicación (y quese incluirán en su propio paquete), como por ejemplo ficheros de configuración,de datos, etc.La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidosen la carpeta /assets/ es que para los primeros se generará un ID en la clase R yse deberá acceder a ellos con los diferentes métodos de acceso a recursos.Para los segundos sin embargo no se generarán ID y se podrá acceder a ellospor su ruta como a cualquier otro fichero del sistema. Usaremos uno u otrosegún las necesidades de nuestra aplicación.2.5 Fichero AndroidManifest.xmlContiene la definición en XML de los aspectos principales de la aplicación, comopor ejemplo su identificación (nombre, versión, icono, etc…), sus componentes(pantallas, mensajes, …), o los permisos necesarios para su ejecución. Veremosmás adelante más detalles de este fichero. 21
  • 22. 3. ANDROID EN PRÁCTICA3.1 Android ManifestEs el fichero de control que indica al sistema que hacer con todos loscomponentes que conforman la aplicación (por ejemplo, que tipo deinformación puede manejar, que permisos de ejecución tiene, etc). Esobligatoria su inclusión el proyecto y se ubica en el directorio raíz de laaplicación. Un ejemplo de un AndroidManifest simple es el que se muestra enla Fig. 3.1.<?XML version="1.0" encoding="utf-8"?><manifestXMLns:android="http://schemas.android.com/apk/res/android"package="com.my_domain.app.helloactivity"> <application android:label="@string/app_name"> <activity android:name=".HelloActivity"> <intent-filter> <action android:name="android.intent.action.MAIN"/> <category android:name="android.intent.category.LAUNCHER"/ > </intent- filter> </activity> </application></manifest> Fig. 3.1 Ejemplo básico de AndroidManifestComo los otros ficheros XML de Android, el fichero AndroidManifest incluye unadeclaración de espacio de nombres. Esta declaración permite usar unavariedad de atributos estándares de Android.Los manifiestos incluyen un elemento <application>, que define todas lasactivities que hay disponibles en el package definido.Cualquier package que sea presentado al usuario como aplicación de alto nivelnecesitará incluir como mínimo un componente Activity que soporte la acciónMAIN y la categoría LAUNCHER, tal y como se muestra en el ejemplo de laFig. 3.1 22
  • 23. 3.1.1 PermisosLas aplicaciones de Android no tienen permisos asociados a no ser que seconfiguren previamente en el AndroidManifest. De esta manera, se evitanmodificaciones no deseadas en la información del dispositivo. Por lo tanto, parapoder utilizar las funcionalidades protegidas, se deben incluir los tags <uses-permission> en el AndroidManifest declarando los permisos necesarios.Por ejemplo, una aplicación que necesite controlar los SMS entrantes tiene queindicarlo de la manera que muestra la Fig. 3.2<manifestXMLns:android="http://schemas.android.com/apk/res/android"package="com.android.app.myapp" > <uses-permission android:name="android.permission.RECEIVE_SMS" /></manifest> Fig. 3.2 Ejemplo de declaración de permisosLa lista entera detallada de permisos disponibles se puede encontrar en.3.2 Interfaz de UsuarioEn este apartado se tratará sobre como implementar la UI de una pantalla deuna aplicación de Android, por ejemplo, que elementos la conforman, como sedefinen los archivos XML, etc.3.2.1 XMLA la hora de diseñar la UI, Android permite hacerlo tanto por código Java comopor ficheros en lenguaje XML. La primera manera puede llegar a ser muycompleja y confusa, mientras que la segunda añade los beneficios y la potenciadel uso del lenguaje XML.Android define un gran número de elementos personalizados, cada unorepresentando una subclase de View. Para diseñar una interfaz, se anidan losdiferentes elementos y se guardan en un fichero XML dentro del directoriores/layout de la aplicaciónCada fichero describe una sola pantalla, pero esta puede estar compuestatanto por un elemento simple como un conjunto de ellos. 23
  • 24. Android dibuja los elementos en el orden que aparecen en el XML, por lo que sialgún elemento se solapa, se dibujará el último que se lea. Cada fichero XMLse compila a partir del árbol de elementos por lo que el fichero sólo debecontener un tag root, tal y como se muestra en la Fig. 3.3:<?XML version="1.0" encoding="utf-8"?><!-- Demonstrates using a relative layout to create a form--> <RelativeLayoutXMLns:android="http://schemas.android.com/apk/res/android android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@drawable/blue" android:padding="10px"> <TextView id="@+id/label" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Type here:"/> <EditText id="@+id/entry" android:layout_width="fill_parent" android:layout_height="wrap_content" android:background="@android:drawable/editbox_back ground" android:layout_below="@id/label"/> <Button id="@+id/ok" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@id/entry" android:layout_alignParentRight="true" android:layout_marginLeft="10px" android:text="OK" /> <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_toLeftOf="@id/ok" android:layout_alignTop="@id/ok" android:text="Cancel" /></RelativeLayout> Fig. 3.3 Ejemplo de layout declarado en XMLLa pantalla resultante del anterior fichero XML sería la mostrada en la Fig. 3.4 24
  • 25. Fig. 3.4 Ejemplo de pantalla en Android3.2.2 ViewsSi la unidad básica funcional de una aplicación de Android son las actividades,la unidad básica de la UI son las vistas (views) y los grupos de vistas(viewgroups)Las views son objetos de la clase base android.view.View. Es básicamente unaestructura de datos que almacena la presentación de una área de la pantalladel dispositivo, controlando así diferentes parámetros como pueden ser lasproporciones, scrolling, etc.Mediante la clase View podemos implementar subclases llamadas widgets quese encargan de dibujar elementos interactivos en la pantalla. A continuación sedetallarán los usados en este proyecto:  Text - Permite mostrar texto por la pantalla (ver Fig. 3.5).<TextView android:id="@+id/label" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Color"/> Fig. 3.5 Ejemplo de widget Text 25
  • 26.  EditText - Permite que un widget del tipo Text sea editado (ver Fig. 3.6).<EditText android:id="@+id/edit" android:layout_width="fill_parent" android:layout_height="wrap_content"/> Fig. 3.6 Ejemplo de widget EditText  Button – Representa un botón, el cual realiza una acción cuando es pulsado (ver Fig. 3.7).<Button android:id="@+id/button" android:text="Save" android:layout_width="wrap_content" android:layout_height="wrap_content"/> Fig. 3.7 Ejemplo de widget Button  ScrollView – Representa a un contenedor para demás Views que puede ser desplazado por el usuario, permitiendo que la View sea más grande de lo que es físicamente la pantalla (ver Fig. 3.8).<ScrollViewXMLns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"></ScrollView> 26
  • 27. Fig. 3.8 Ejemplo de widget ScrollViewAparte de widgets simples que se pueden definir con un simple archivo XML,existen otros más complejos que necesitan de algunas líneas de código paraimplementarlos:  Menu – Interfaz para gestionar los elementos de un menu. Por defecto, cada Activity soporta un menú de opciones que se activa al pulsar la tecla menú. Se pueden añadir elementos a este menú y gestionar los clicks en ellos (ver Fig. 3.9). //En la creación del Menu se añaden las opciones que contendrá@Overridepublic boolean onCreateOptionsMenu(Menu menu) { super.onCreateOptionsMenu(menu);//Se indica si pertenece a algún grupo, el identificador, el//peso dentro del menú y la frase a mostrar. Además se leañade //un icono menu.add(0, ALGO, 0, R.string.Algo) .setIcon(R.drawable.icono); return true;}//Si se pulsa algún element del menú, se accede a este método@Overridepublic boolean onMenuItemSelected(int featureId, MenuItem item){ // Se identifica la accion para el item seleccionado switch(item.getItemId()){ case ALGO: //Hacer algo return true; } return super.onMenuItemSelected(featureId, item);} 27
  • 28. Fig. 3.9 Ejemplo de widget Menu  Menu Contextual – Igual que el menú, pero este se despliega al clicar sobre algún elemento de la pantalla (ver Fig. 3.10).//Al elemento escogido para que despliegue el menú, se leañade //el siguiente métodoElemento.setOnCreateContextMenuListener(new OnCreateContextMenuListener() { @Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {//Se crea el menu de contexto para elegir la acciondeseada //sobre el elemento elegido menu.setHeaderTitle("Se indica un título"); //Los métodos son los mismos que en la clase menú menu.add(0, ALGO, 0, R.string.Algo) }});//Al igual que en menú, si se clica algún elemento del menúse //accede a un método, en este caso a este:@Overridepublic boolean onContextItemSelected(MenuItem item) Fig. 3.10 Ejemplo de widget Menu Contextual 28
  • 29.  List – Es una colección la cual mantiene un orden en sus elementos (ver Fig. 3.11).//Primero se indica en el fichero XML<LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="fill_parent"> <ListView android:id="@+id/list_results" android:layout_width="wrap_content" android:layout_height="wrap_content" /></LinearLayout>//Una vez declarada, se selecciona en el código dela //siguiente maneraLista = (ListView) findViewById(R.id.list_results);//El contenido de la lista se añade mediante el adapter,el //cual se explicará más adelanteArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1, ContenidoLista);mList.setAdapter(adapter); Fig. 3.11 Ejemplo de widget List  Toast – Es una vista que contiene un pequeño mensaje que se muestra brevemente al usuario. Cuando la vista aparece, se muestra en una vista flotante sobre la aplicación, nunca recibe el foco de acción, intentando no estorbar en exceso al usuario, simplemente adevertiendolo de algún evento (ver Fig. 3.12).Toast.makeText(this,Mensaje a mostrar, Tiempo que se muestra el mensaje).show(); 29
  • 30. Fig. 3.12 Ejemplo de widget Toast  Alert Dialog – Al contrario que el toast, este widget si que recibe el foco de acción y se puede interactuar con él (ver Fig. 3.13).new AlertDialog.Builder(this) //Indica un título .setTitle(R.string.title) //Indica un mensaje .setMessage(R.string.bmessage) //Añade un botón para realizar alguna opción .setPositiveButton(R.string.button, okButtonListener) //Lo muestra .show(); Fig. 3.13 Ejemplo de widget Alert Dialog  Notification – Clase para notificar al usuario los eventos que ocurren. En este proyecto, las notificaciones se muestran en un icono persistente en la barra de estado el cual, cuando es seleccionado, lanza un Intent previamente definido. Cada notificación tiene un indentificador único. Si se llama a dos notificaciones con el mismo identificador, la última se solapará a la primera (ver Fig. 3.14). //Se llama al servicio de notificaciónNotificationManager nm =(NotificationManager)getSystemService(NOTIFICATION_SERVICE);//Detalles del mensajeCharSequence from = Algo;CharSequence msn = Algo2; 30
  • 31. //El PendingIntent lanza la actividad que indica el Intentsi //el usuario selecciona esta notificacionPendingIntent contentIntent = PendingIntent.getActivity(this, 0, Intent, 0);//Texto de aviso de notificacionString tickerText =getString(R.string.Incoming_message_ticker_text, message);//Construye el objeto de notificacionNotification notif = new Notification(R.drawable.stat_sample, tickerText,System.currentTimeMillis());//Inicializa los campos de la notificacionnotif.setLatestEventInfo(this, from, msn, contentIntent);//Se lanza la notificación (el ID debe ser único)nm.notify(R.string.Incoming_message_ticker_text, notif); Fig. 3.14 Ejemplo de widget Notification  Progress Dialog – Una vista que es muestra un indicador de progreso con un mensaje opcional (ver Fig. 3.15).//Si se crea un objeto Dialog, se accede a este métodoprotected Dialog onCreateDialog(final int id) { final ProgressDialog dialog = new ProgressDialog(this); dialog.setMessage("Mensaje”); //Indica si la duración será fija o indeterminada dialog.setIndeterminate(true); dialog.setTitle("Título"); 31
  • 32. Fig. 3.15 Ejemplo de widget Progress DialogUna vez expuestos los widgets más representativos, cabe notar que existe unavariedad mucho mayor de Views. Exponerlas aquí sobrepasaría el ámbito delproyecto. No obstante, esta lista puede ser consultada en o en el directorio/samples/APIDemos/res/layout del SDK de Android.3.2.3 ViewsGroupsUn ViewGroup es un tipo especial de View cuya función es contener y controlarun conjunto de Views y/o ViewGroups. Cada ViewGroup tiene laresponsabilidad de medir el espacio disponible y asignárselo a las Viewscontenidas. La manera más corriente de asignar espacio es adaptarse a lasdimensiones del contenido de la View o ser tan grande como lo permita elViewGroup contenedor. Los ViewGroups más utilizados son los siguientes:  FrameLayoutEs el más simple de todos, compuesto por un espacio en blanco en la pantallasobre el cual se pueden ir añadiendo objetos, los cuales se van solapando amedida que se añaden.  LinearLayoutEste ViewGroup alinea todos los elementos en una única dirección (vertical uhorizontal) y los posiciona uno detrás del otro formando una sola columna o fila.LinearLayout permite asignar padding entre los diferentes elementos, así comoespecificar su peso en la pantalla, entre otras características.El caso del peso es interesante debido a que, según el tipo pantalla queestemos mostrando, habrá elementos que nos interesará que se muestren másque otros. Mediante el peso, podemos expandir los elementos hasta querellenen el espacio sobrante en la pantalla. El peso por defecto es 0. En la Fig.3.16 se muestra un ejemplo de cómo varía la especificación del peso en loselementos. 32
  • 33. Fig. 3.16 Ejemplo de asignación de pesos en LinearLayout  AbsoluteLayoutPermite a los elementos especificar exactamente las coordenadas (x, y) dondese mostrará en pantalla, donde (0,0) es la esquina superior izquierda.  RelativeLayoutPermite a los nodos hijos especificar su posición relativa uno respecto a otro(especificada por el ID) o respecto al nodo padre. Si se usa XML paraespecificar esta disposición, se precisa un elemento de referencia antes dereferirlo. En la Fig. 3.17 se muestra un ejemplo de RelativeLayout, así comolas especificaciones de cada elemento en el fichero XML. Fig. 3.17 Ejemplo de RelativeLayout 33
  • 34. Los ViewGroups y las Views se pueden anidar formando un árbol jerárquico, taly como se muestra en Fig. 3.18 Árbol de nodos View o ViewgroupsFig. 3.18 Fig. 3.18 Árbol de nodos View o ViewgroupsPara indicar a la pantalla que dibuje el árbol de views pasado como parámetro,la Actividad ha de llamar al método setContentView() y pasarle como referenciael nodo raíz (ver Fig. 3.19). Una vez pasado, el nodo raíz pide a los nodoshijos que se dibujen ellos mismos por turnos y así sucesivamente.protected void onCreate(Bundle savedValues){ // Llamamos a la superclase. super.onCreate(savedValues); // Carga los recursos de la vista // El fichero XML se encuentra en // res/layout/hello_activity.XML setContentView(R.layout.hello_activity);} Fig. 3.19 Visualización de un archivo de layout por pantallaUna vez cargada la interfaz gráfica, podemos obtener el control sobre unelemento tal y como se indica en la Fig. 3.20.TextView msgTextView = (TextView)findViewById(R.id.msg);msgTextView.setText(Texto); Fig. 3.20 Obtención de control sobre un elemento de la pantalla 34
  • 35. Por otro lado, Android implementa automáticamente algunas notificaciones deeventos sobre elementos de la pantalla, como por ejemplo onFocusChange,que indica que el foco de la pantalla ha cambiado. Sin embargo, hay otras queno están implementadas nativamente y es trabajo del usuario registrarlas eimplementarlas. En la Fig. 3.21 se muestra a modo de ejemplo laimplementación de una acción por parte del usuario en respuesta a un clicksobre un botón determinado.public class SendResult extends Activity{ protected void onCreate(Bundle savedValues) { ... // Escucha pulsaciones del botón Button button = (Button)findViewById(IDBoton); button.setOnClickListener(mBotonListener); } private OnClickListener mBotonListener = new OnClickListener() { public void onClick(View v) { setResult(RESULT_OK); finish(); } };} Fig. 3.21 Implementación de acciones ante eventos3.2.4 Adapter ViewsPara poder interaccionar entre el código de la aplicación y los elementos de laUI se precisa de una subclase llamada AdapterView. Estos objetos, una vezinstanciados en el código, pueden realizar dos tipos de tareas:  Rellenar la pantalla con datos (ver Fig. 3.22).    Atender a las selecciones de los usuarios (ver Fig. 3.23).  35
  • 36. Obtiene un Spinner y lo enlaza con el ArrayAdapter que referencia al array de StringsSpinner s1 = (Spinner) findViewById(R.id.spinner1);ArrayAdapter adapter = ArrayAdapter.createFromResource( this, R.array.colors, android.R.layout.simple_spinner_item);adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);s1.setAdapter(adapter); Fig. 3.22 Rellenar la pantalla con AdapterViewprivate OnItemClickListener mMessageClickedHandler =new OnItemClickListener() { public void onItemClick(AdapterView parent, View v,int position, long id) { // Se muestra un mensaje Toast.makeText(mContext,"Tienes un evento”, Toast.LENGTH_SHORT).show(); }};// Gracias al AdapterView se puede reaccionar frente a la//pulsación de un elemento de la lista, en este caso//mostrándolo en un historial de elementos seleccionadosmHistoryView = (ListView)findViewById(R.id.history);mHistoryView.setOnItemClickListener(mMessageClickedHandler); Fig. 3.23 Atender a eventos con AdapterView3.3 Geolocalización y MapasEl SDK de Android incluye dos packages que proporcionan soporte primariopara montar servicios de localización: android.location ycom.google.android.maps.El primero contiene varias clases relacionadas con los servicios de localizacióny, además, incluye el servicio LocationManager el cual proporciona una APIpara determinar la localización del dispositivo. LocationManager no puede serinstanciado directamente sino que se debe obtener un controlador, tal y comomuestra la Fig. 3.24.myLocationManager=(LocationManager)getSystemService(Context.LOCATION_SERVICE); Fig. 3.24 Creación de un LocationManager 36
  • 37. Cuando se obtiene el control de un LocationManager, se pueden realizar las 3siguientes acciones (ver Fig. 3.25):  Solicitar una lista de todos o algunos de los LocationProviders disponibles.  Registrarse o des registrarse para actualizaciones periódicas de la posición.  Registrarse o des registrarse de eventos cuando el dispositivo se encuentra en determinada ubicación (por ejemplo, cerca de otros dispositivos).//Solicitación de un LocationProvider concreto (gps)myLocation = myLocationManager.getLastKnownLocation("gps");//Registro para actualizaciones periódicas (2 argumento) ypara eventos (3 argumento)myLocationManager.requestLocationUpdates(strProvider,MINIMUM_TIME_BETWEEN_UPDATE,MINIMUM_DISTANCECHANGE_FOR_UPDATE,listener ); Fig. 3.25 Acciones posibles con un LocationManagerCuando se usa el emulador se deben introducir los datos de la ubicación. Sepuede utilizar tanto el DDMS como el comando geo (ver Fig. 3.26).geo fix -121.45356 46.51119 4392 Fig. 3.26 Ejemplo de uso del comando geoEn el segundo package (com.google.android.maps), se obtienen varias clasesrelacionadas con el rendering, control y dibujo sobre mapas. La más importantees la clase MapView que automáticamente dibuja un mapa básico de GoogleMaps cuando lo añades al layout de la aplicación (ver Fig. 3.27).// Crea un Mapa y lo muestra porpantalla myMapView = new MapView(this,""); setContentView(myMapView); Fig. 3.27 Inclusión de mapas en la pantalla de AndroidPara poder obtener un MapView, se necesita previamente un API Key deGoogle Maps. Además, para poder hacer uso de esta clase, se ha de añadir elpermiso en el manifiesto (Ver Fig. 3.28) dado que no es un package estándarde Android. Como último requisito, es necesario tener la configuración regionaldel ordenador donde corre el emulador seleccionada en Estados Unidos paraque reconozca la puntuación de las coordenadas. 37
  • 38. <uses-library android:name="com.google.android.maps" /> Fig. 3.28 Permiso para poder utilizar la librería de mapas de AndroidDespués de todo el procedimiento, se puede trabajar sobre la vista del mapacon la clase Overlay (ver Fig. 3.29)// Se obtiene el control de capas del objeto MapViewoverlays = myMapView.getOverlays();// Se crea un objeto Overlay y se define una capa para el mapaMyLocationOverlay myLocationOverlay = new MyLocationOverlay();//Una vez definida la capa, se añade a lavista overlays.add(myLocationOverlay); Fig. 3.29 Ejemplo de obtención de capas de un MapView3.4 Bases de datosAndroid soporta BBDD Sqlite y proporciona funciones de control que permitenalmacenar datos complejos en forma de objeto, como por ejemplo los datos detipo Contacto. Para crear una BBDD, se debe extender a la claseSQliteOpenHelper, tal y como indica la Fig. 3.30.private static class DatabaseHelper extends SQLiteOpenHelper { DatabaseHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase db) db.execSQL(DATABASE_CREATE); }} Fig. 3.30 Clase para instanciar una BBDD SQliteUna vez creada, se debe obtener el handler sobre ella para poderla llamar yutilizar sus métodos. A su vez, una vez se deje de utilizar hay que cerrarla (verFig. 3.31). 38
  • 39. // Obtención de HandlermDbHelper = new DatabaseHelper(mCtx);mDb = mDbHelper.getWritableDatabase();// Cierre de la BBDDmDbHelper.close(); Fig. 3.31 Obtención de control de BBDD SQliteCuando tenemos el control de la BBDD se pueden realizar acciones con ellacomo ingresar nuevos valores, borrarlos o hacer peticiones de búsqueda (verFig. 3.32 a Fig. 3.34)// Necesario para ingresar valores en la TablaContentValues initialValues = new ContentValues();initialValues.put(KEY_NAMEUSER, user);initialValues.put(KEY_PASSWORD, password);// Devuelve el rowID para el usuario en casocontrario, devuelve -1return mDb.insert(DATABASE_TABLE, null, initialValues); Fig. 3.32 Ingresar valores en BBDD SQlitemDb.delete(DATABASE_TABLE, KEY_ROWID + "=" + rowId, null) Fig. 3.33 Borrar valor en BBDD SQliteCursor mCursor = mDb.query(true, DATABASE_TABLE, new String[] {KEY_ROWID, KEY_NAMEUSER, KEY_PASSWORD},KEY_NAMEUSER + "=" + user + " and " + KEY_PASSWORD +"=" + password + "",null,null, null, null, null);if (mCursor != null) { mCursor.moveToFirst();} Fig. 3.34 Buscar valores en BBDD SqliteCualquier BBDD creada para una aplicación será accesible por su nombre porcualquier clase en dicha aplicación, pero no fuera de ella . 39
  • 40. 3.5 Configuración SD CardPara crear la tarjeta SD emulada se precisa de la herramienta mksdcard, quese incluye en el SDK. Esta utilidad crea una imagen de disco FAT32 que sepuede cargar en el emulador durante el arranque. El comando utilizado es elmostrado en la Fig. 3.35mksdcard <size> <file>// Por ejemplomksdcard 1024M sdcard1.iso Fig. 3.35 Uso de la aplicación mksdcardPara navegar por la tarjeta se utiliza la vista File Explorer del plugin ADT deEcplise. Para poder insertar o extraer algún elemento del sistema de ficherosdel emulador tan sólo hay que utilizar los botones Push y Pull (ver Fig. 3.36). Fig. 3.36 Explorador de la SDcard3.6 Media APIsLa plataforma Android es capaz de reproducir audio y video, tanto de ficheroslocales como via streaming. Para conseguirlo, se utiliza la claseandroid.media.MediaPlayer.Para lograr reproducir un fichero (normalmente de audio) se hace lo siguiente: 1. Poner el fichero dentro del directorio /res/raw del proyecto, donde el plugin de Eclipse lo pueda encontrar y hacerlo referenciable mediante la clase R. 40
  • 41. 2. Crear una instancia de MediaPlayer, referenciando al recurso usando los métodos adecuados (ver Fig. 3.37).MediaPlayer mp = MediaPlayer.create(context,R.raw.sound_file_1);mp.start(); Fig. 3.37 Reproducción de fichero en AndroidPara parar la reproducción se llama al método stop(). Si se quiere reiniciar lareproducción, se llama a los métodos reset() y prepare() antes de llamar a start()otra vez. Para pausar, llamar al método pause().En la Fig. 3.38 se muestra el código para reproducir archivos desde una URL. MediaPlayer mp = new MediaPlayer(); mp.setDataSource(URL_AL_FICHERO); mp.prepare(); mp.start(); Fig. 3.38 Reproducción de fichero via URL por Android3.7 Otros ejemplosDada la limitación de páginas en la memoria del proyecto, se han intentandomostrar los ejemplos básicos de Android. No obstante, si se tiene interés enprofundizar en el tema, ejemplos de códigos más complejos se pueden observar enla página oficial de Android . 41
  • 42. 4. CREANDO UNA APLICACIÓN EN ANDROIDEn este apartado intentare explicar cómo he creado el programa a grandes rasgos,de la forma más clara que pueda sin tener que entrar directamente en el código. Sise quiere ver el código entero del programa he preferido ponerlo con susrespectivas explicaciones línea a línea en el Anexo II.Para llevar a cabo todo esto he usado las herramientas explicadas en el Anexo I, elJDK (kit de desarrollo Java), el SDK (kit de desarrollo Android, con el emuladorDelvik incluido) y como no podía faltar el programa Ecplise, el cual es un entorno dedesarrollo integrado de código abierto multiplataforma desde donde realmenteprogramaremos y escribiremos el código del programa.Basándonos en la estructura de un proyecto Android tal y como se explica en elpunto 2 de esta memoria, intentaré explicar con gráficos los diferentes funcionesque realiza cada archivo del proyecto. Ver Anexo II para ver las imágenes de cadainterfaz y el código para una mayor comprensión. 42
  • 43. Diagrama de flujos main.xml FinalActivity.java Fig AII.1 Actividad principal, login y usuario. Login incorrecto Botón Salir Login correcto frmsaludo.xml LoginResult.java Fig AII.2 Actividad que contiene el menú principal con las 3 opciones. Opción cámara Opción Camera.java coordenada Actividad donde Opción calculadora hacemos una foto y la mostramos. AplicacionSencillaActivity.java Actividad principal de la opción Calculadora.java coordenada, donde recogemos Actividad que contiene los datos. la calculadora cam.xml Fig AII.7Botón “Otra vez” coordenadas.xml Fig AII.3 y Fig AII.4 calc.xml Fig AII.6 AplicacionSencillaResults.java Actividad donde mostramos los datos recogidos en la actividad results.xml anterior. Fig AII.5 43
  • 44. 5. CONCLUSIONES5.1 Valoración personalLa idea principal de este proyecto era desarrollar una aplicación en Android usandolos conceptos explicados anteriormente. Una vez creada la aplicación y a sabiendasque no se trataba de una aplicación útil de cara al mundo, decidí que el proyecto seprofundizara más hacia la parte teórica que no hacia la práctica, creando undocumento bien estructurado y que podría ser muy útil hacia la gente que como yoque quiera iniciarse en el mundo de la programación para Android.Con todo esto explicado, decir que la realización de este proyecto me ha aportadoconocimientos sobre varias tecnologías pero sobretodo de cómo desarrollar unaaplicación que las unifique a todas y tengan una función práctica. Además, a travésde su estudio he podido constatar un mercado emergente que cada día realiza másavances y terminará dotando a las personas de un nivel de comunicación muyelevado pero sobretodo, de una accesibilidad inmediata.Por otro lado, el desarrollo para Android ha sido, a mi parecer, muy interesante dadoel gran abanico de posibilidades que ofrece, siendo imposible recogerlas todas enun proyecto y menos en una sola aplicación. Aun a pesar de las limitaciones queofrece el emulador enfrente a un dispositivo real, es un buen punto de partida parafamiliarizarse con el entorno y probar prototipos de aplicaciones de una manerarápida y sencilla.Con el resultado obtenido puedo decir que estoy satisfecho por toda la informaciónrecogida y aplicada en este proyecto, aunque mi aplicación no es del todo comoesperaba, ya que al final su utilidad principal será de ayuda o guía para la creaciónde futuras aplicación más sofisticadas o con un fin más concreto.5.2 Líneas futurasCon este proyecto se abren varias líneas de investigación y desarrollo, desde lamejora de la aplicación presentada como la implementación en dispositivos reales.A medida que aparezcan nuevos SDK con funcionalidades mejoradas y otras denuevas, las posibilidades se irán ampliando, pudiendo desarrollar aplicaciones másy más complejas.En cuanto a las mejoras de la aplicación en si, a parte de las obvias de la UI,destacan el manejo de medios multimedia y un uso más elaborado del protocoloXMPP. La geolocalización es otro elemento a tener en cuenta, dado que es uno delos impulsores del uso de las aplicaciones móvilesPor otro lado, la implementación en dispositivos es interesante, a parte del estudiodel rendimiento y del funcionamiento de la aplicación en escenarios reales, por lalibertad de desarrollo que ofrece Android. Esta libertad impulsaría de maneranotable la evolución natural de estas redes si la gente se motivara a experimentarcon Android, que es en parte también lo que busca este proyecto. 44
  • 45. 6. BIBLIOGRAFÍALibrosBeginning Android - 2009 – ApressFor Dummies - Android Application Development For Dummies - Dec.2010Páginas webs y fórumshttp://www.sgoliver.net/blog/?p=1313http://www.htcmania.com/showthread.php?t=218891http://www.edu4java.com/es/android/android1.htmlhttp://www.android.com/http://androideity.com/2011/10/03/testear-aplicaciones-android-en-tu-telefono/http://www.htcmania.com/mediawiki/index.php/C%C3%B3mo_iniciarse_programando_aplicaciones_con_Android_SDK#Depura_tu_proyecto 45
  • 46. ANEXOS 46
  • 47. ANEXO I HERRAMIENTAS DE DESARROLLOAI.1 Instalación de las herramientas básicas: JDK, SDK y Eclipse1. Instalar Jdk java, se trata de un conjunto de herramientas (programas y librerías)que permiten desarrollar programas en lenguaje Java (compilar, ejecutar, generardocumentación, etc.). DESCARGAR JDK2. Descargar el SDK recomendado de Android, el SDK es un kit de desarrollo quecontiene herramientas para desarrollar en Android, contiene herramientas como porejemplo la maquina virtual Dalvik. DESCARGAR SDK3. Configurando SDK, abrimos la aplicación que se ha instalado en mis “Archivos deProgramas->Android->Android-sdk-windows” y ejecutamos SDK Setup.exe, aquíinstalamos los paquetes del SDK los cuales serán descargados de internet. Fig 6.1 Seleccionamos los componentes como en la imagen. Fig 6.2 En “ToolsOptions” podemos configurar un proxy 47
  • 48. 4. Una vez instalado el JDK, procedemos a descargar Eclipse. Este es un entornode desarrollo integrado de código abierto multiplataforma. Para Eclipse 3.5 o másreciente, utilice la versión recomendada “Eclipse Classic “. Es solo descargar,descomprimir y utilizar. DESCARGAR ECLIPSE5. Configurar proxy en Eclipse. En el apartado de“WindowsPreferencesNetwork”. Seleccionas las tres opciones, HTTP, HTTPS ySOCKS, le damos a editar y ponemos el proxy.6. Instalamos componentes de Android para eclipse, en Eclipse “Help->Install NewSoftware”.Añadimos la dirección de donde nos bajaremos los componentes paraAndroid : https://dl-ssl.google.com/android/eclipse/ 48
  • 49. Seleccionamos todos los componentes y le damos a Next.7. Ahora vamos “PreferenceAndroid” y en SDK location tenemos que poner lacarpeta donde instalamos el SDK. 49
  • 50. 8. Configuramos el emulador de Android. Volvemos a Preference y le damos a AVDManager. Click en New y ya podemos configurar un nuevo emulador de Android conlas características que queramos. 50
  • 51. 9. Finalmente vamos a crear un proyecto Android, nos dirigimos a New Project,seleccionamos Android Project, le pondremos un nombre y ya tendremos nuestroprimer proyecto creado, el clásico Hello World.Para ejecutar el programa le damos a Run project as Android y se nos abrirá elemulador con el código de prueba por defecto. Este código lo ejecutamos como unaaplicación más, así que para abrirla tenemos de entrar en el menú del “móvil” yejecutarla. 51
  • 52. AI.2 Herramientas adicionales: Droid DrawLa construcción de interfaces de usuario es un pilar muy importante cuandodesarrollamos cualquier tipo de aplicación. En Android utilizamos el lenguaje XMLpara hacer la maquetación de las interfaces, y dado que esto puede resultar tedioso,existen herramientas como el DroidDraw que nos pueden facilitar mucho las cosas.DroidDraw, es una aplicación web que nos permitirá diseñar nuestras interfacesusando un editor completamente visual y que incorpora funciones drag & drop paraincorporar los elementos que necesitemos. Cabe mencionar que podemos utilizar laversión web de la herramienta o bien, descargarnos la aplicación multiplataforma anuestra máquina.http://www.droiddraw.org/Una vez que descomprimamos el archivo, bastará con ejecutar el .jar que viene enel directorio para empezar a utilizar el programa.La pantalla principal de DroidDraw se encuentra divida en tres partes. Del ladoizquierdo tenemos la pantalla que corresponde a la vista previa de la interfaz; y dellado derecho la pantalla se divide en dos módulos, uno superior que muestra loswidgets que podemos agregar a la interfaz que vamos a crear y el inferior en el quese generará el código XML del diseño cuando lo hayamos terminado. 52
  • 53. ANEXO II EXPLICACIÓN DETALLADA DE LA APLICACIÓNEmpezare por mostrar una vista general al proyecto y luego me centrare encomentar primero los archivos .xml de la carpeta layout, que como explique antesson por así decirlo “lo que vemos” o la interfaz con la que interactuara el usuario.Seguidamente explicare los archivos .java que son las actividades, donde realmenteestá el código pesado del programa y se llevan a cabo las funciones. Por últimoveremos el código del AndroidManifest.xml.A destacar que las demás carpetas, no se explican aquí ya que están explicadasanteriormente en el proyecto, básicamente porque las genera el propio ecplise oporque contienen información o datos que no se usan en este proyecto. 53
  • 54. AII.1 Carpeta /res/layoutAquí veremos las diferentes “vistas” que tiene la aplicación, donde creamos losbotones, textviews, textedit y demás views explicados en el punto 3.2.2 de esteproyecto.AII.1.1 Main.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="wrap_content" android:orientation="vertical" android:padding="10dip"> <TextView android:id="@+id/TextView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Usuario:" android:textStyle="bold" /> <EditText android:id="@+id/TxtUsuario" android:layout_height="wrap_content" android:layout_width="fill_parent" /> <TextView android:id="@+id/TextView02" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Contraseña:" android:textStyle="bold" /> <EditText android:id="@+id/TxtPassword" android:layout_height="wrap_content" android:layout_width="fill_parent" /> <LinearLayout android:orientation="horizontal" android:layout_width="fill_parent" android:layout_height="fill_parent" > Fig AII.1 Pantalla inicial <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/BtnAceptar" android:text="Login" android:paddingLeft="20dip" android:paddingRight="20dip" /> <TextView android:id="@+id/LblMensaje" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingLeft="10dip" android:textStyle="bold" /> <Button android:id="@+id/BtnExit" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Salir" /> </LinearLayout></LinearLayout> 54
  • 55. AII.1.2 Frmsaludo.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <TextView android:id="@+id/TxtSaludo" android:layout_width="wrap_content" android:layout_height="wrap_content" /> <TextView android:id="@+id/LblMensaje" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Selecciona una opción:" /> <Spinner android:id="@+id/CmbOpciones" android:layout_width="fill_parent" android:layout_height="wrap_content" /> <RelativeLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_weight="0.28" > <Button android:id="@+id/BtnIr" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignParentLeft="true" Fig AII.2 Pantalla menú principal android:layout_centerVertical="true" android:layout_marginLeft="20dp" android:paddingLeft="20dip" android:paddingRight="20dip" android:text="Ir" /> <Button android:id="@+id/BtExit" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignBaseline="@+id/BtnIr" android:layout_alignBottom="@+id/BtnIr" android:layout_alignParentRight="true" android:layout_marginRight="65dp" android:text="Salir" /> </RelativeLayout></LinearLayout> Fig AII.3 Vista del Spinner 55
  • 56. AII.1.3 Coordenadas.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <TextView android:id="@+id/textView" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Pulsa" /> Fig AII.4 Pantalla inicial de</LinearLayout> coordenadas.AII.1.4 Results.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <TextView android:id="@+id/textView1" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="resultados1" /> <TextView android:id="@+id/textView2" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="resultados2" /> <RelativeLayout android:id="@+id/relativeLayout1" android:layout_width="match_parent" android:layout_height="146dp" android:layout_weight="0.16" > <Button android:id="@+id/BtnRepetir" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignParentLeft="true" android:layout_alignParentTop="true" android:layout_marginLeft="37dp" android:layout_marginTop="130dp" android:text="Otra vez" /> <Button android:id="@+id/BtnSalir" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignBaseline="@+id/BtnRepetir" android:layout_alignBottom="@+id/BtnRepetir" Fig AII.5 Pantalla de los resultados android:layout_marginLeft="54dp" android:layout_toRightOf="@+id/BtnRepetir" de la opción coordenadas. android:text="Salir" /> </RelativeLayout></LinearLayout> 56
  • 57. AII.1.5 Calc.xml<?xml version="1.0" encoding="utf-8"?> <TextView<RelativeLayout android:id="@+id/texto_resultado"xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_height="fill_parent"> android:layout_below="@id/dividir" <TextView android:text="Resultado:"/> android:id="@+id/label_a" <TextView android:layout_width="fill_parent" android:id="@+id/resultado" android:layout_height="wrap_content" android:layout_width="fill_parent" android:text="Operando A:"/> android:layout_height="wrap_content" <EditText android:layout_below="@id/texto_resultado" android:id="@+id/op_a" android:text="Realice operación para obtener android:layout_width="fill_parent" resultado"/> android:layout_height="wrap_content" android:layout_below="@id/label_a"/> <Button <TextView android:id="@+id/Salir" android:id="@+id/label_b" android:layout_width="wrap_content" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_height="wrap_content" android:layout_alignParentBottom="true" android:layout_below="@id/op_a" android:layout_alignRight="@+id/multiplicar" android:text="Operando B:"/> android:layout_marginBottom="80dp" <EditText android:layout_marginRight="15dp" android:id="@+id/op_b" android:onClick="cSalir" android:layout_width="fill_parent" android:text="Salir" /> android:layout_height="wrap_content" android:layout_below="@id/label_b"/> </RelativeLayout> <Button android:id="@+id/sumar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@id/op_b" android:layout_alignParentLeft="true" android:layout_marginLeft="1dip" android:onClick="cSumar" android:text="+" /> <Button android:id="@+id/restar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_toRightOf="@id/sumar" android:layout_alignTop="@id/sumar" android:onClick="cRestar" android:text="-" /> <Button android:id="@+id/multiplicar" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_toRightOf="@id/restar" android:layout_alignTop="@id/restar" android:onClick="cMultiplicar" android:text="*" /> <Button android:id="@+id/dividir" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_toRightOf="@id/multiplicar" android:layout_alignTop="@id/sumar" android:onClick="cDividir" android:text="/" /> Fig AII.6 Pantalla general de la calculadora. 57
  • 58. AII.1.6 Cam.xml<?xml version="1.0" encoding="utf-8"?><AbsoluteLayout android:id="@+id/widget0" android:layout_width="fill_parent" android:layout_height="fill_parent" xmlns:android="http://schemas.android.com/apk/res/android"><Button android:id="@+id/btnPic" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Foto" android:layout_x="57dp" android:layout_y="323dp" /><Button android:id="@+id/btSal" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Salir" android:onClick="cSal" android:layout_x="193dp" android:layout_y="322dp" /><ImageView android:id="@+id/imgView" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_x="98dp" android:layout_y="108dp" /></AbsoluteLayout> Fig AII.7 Pantalla de la opción cámara. 58
  • 59. AII.2 Carpeta /srcAquí veremos la parte más interna del programa, todas las funciones yprocedimientos y como se interactúa con las vistas mostradas en el apartadoanterior.AII.2.1 FinalActivity.javaEsta es la actividad principal, enlazada con el layout “main.xlm”, ver figura AII.1. Sellama al abrir la aplicación, en ella encontramos el control de login, básicamente elusuario solo podrá acceder a la siguiente actividad si se loguea con el pass y lacontraseña “demo”. En caso de loguin correcto llamamos a la actividad siguienteque contendrá el menú, la “LonginResult.java”.A destacar que le pasaremos el nombre del logueado a la siguiente actividadaprovechando un bundle.package xavi.valls;//Bibliotecas importadasimport android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.TextView;public class FinalActivity extends Activity { /** Called when the activity is first created. */ @Override //Aquí es donde estamos ligando esta activity con la layout main.xml public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //Localizamos los controles de la layout para poder usarlos final EditText TxtUsuario = (EditText)findViewById(R.id.TxtUsuario); final EditText TxtPassword = (EditText)findViewById(R.id.TxtPassword); final Button BtnAceptar = (Button)findViewById(R.id.BtnAceptar); final TextView LblMensaje = (TextView)findViewById(R.id.LblMensaje); final Button BtnExit = (Button)findViewById(R.id.BtnExit); // Al darle aceptar se comprueba que los datos sean correctos BtnAceptar.setOnClickListener(new OnClickListener() { public void onClick(View v) { String usuario = TxtUsuario.getText().toString(); String password = TxtPassword.getText().toString(); //solo entrara con el user y la pass "demo". if (usuario.equals("demo") && password.equals("demo")){ LblMensaje.setText("Login Correcto"); //Creamos el Intent Intent intent = new Intent(FinalActivity.this, LoginResult.class); //Creamos la información a pasar entre actividades Bundle b = new Bundle(); 59
  • 60. b.putString("NOMBRE", TxtUsuario.getText().toString()); //Añadimos la información al intent intent.putExtras(b); //Iniciamos la nueva actividad startActivity(intent); } else{ //En el caso de que el loguin no se correcto nos muestra este mensaje saje.setText("Error, vuelva a intentarlo"); } } }); //El botón salir finaliza la activity BtnExit.setOnClickListener(new OnClickListener() { public void onClick(View v) { finish(); } }); }}AII.2.2 LoginResult.javaActividad que contiene el menú principal con un spinner y tres opciones. Estaactividad va ligada al layout “frmsaludo.xml”, ver figura AII.2 y figura AII.3. Apretandoel botón “Ir” y según la opción que elijamos del spinner iremos a una actividad uotra. Podemos ver como en la apantalla aparece un saludo hacia el usuario sacandola información del bundle que nos llega de la actividad anterior. El botón salir nosdevolverá a la actividad “FinalActivity.java”.package xavi.valls;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.AdapterView;import android.widget.ArrayAdapter;import android.widget.Button;import android.widget.Spinner;import android.widget.TextView;public class LoginResult extends Activity { /** Called when the activity is first created. */@Override//Aquí es donde estamos ligando esta activity con la layout frmsaludo.xml public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.frmsaludo); //Localizar los controles TextView txtSaludo = (TextView)findViewById(R.id.TxtSaludo); //Recuperamos la información pasada en el intent Bundle bundle = this.getIntent().getExtras(); //Construimos el mensaje a mostrar txtSaludo.setText("Hola " + bundle.getString("NOMBRE")); //Creamos el spinner (desplegable) y la array que lo compone 60
  • 61. final TextView lblMensaje = (TextView)findViewById(R.id.LblMensaje); final Spinner cmbOpciones = (Spinner)findViewById(R.id.CmbOpciones); final String[] datos = new String[]{"Coordenadas","Calculadora","Camara"}; ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, datos); adaptador.setDropDownViewResource( android.R.layout.simple_spinner_dropdown_item); cmbOpciones.setAdapter(adaptador); cmbOpciones.setOnItemSelectedListener( new AdapterView.OnItemSelectedListener() { public void onItemSelected(AdapterView<?> parent, android.view.View v, final int position, long id) { //en este procedimiento se crea la variable "postion" que indicara en que casilla de la array estamos lblMensaje.setText("Seleccionado: " + datos[position]); //Usamos el botón "Ir" junto con un switch y la variable "position" para ir a la activity que se seleccione final Button BtnIr = (Button)findViewById(R.id.BtnIr); BtnIr.setOnClickListener(new OnClickListener() { public void onClick(View v) { switch(position){ case 0: Intent intent = new Intent(LoginResult.this, AplicacionSencillaActivity.class); startActivity(intent); break; case 1: Intent calcu = new Intent(LoginResult.this, calculadora.class); startActivity(calcu); break; case 2: Intent foto = new Intent(LoginResult.this, Camera.class); startActivity(foto); break; } } }); } public void onNothingSelected(AdapterView<?> parent) { lblMensaje.setText(""); } }); // el botón Salir nos devolvería a la activity principal de loguin final Button BtExit = (Button)findViewById(R.id.BtExit); BtExit.setOnClickListener(new OnClickListener() { public void onClick(View v) { finish(); } }); }} 61
  • 62. AII.2.3 AplicacionSencillaActivity.javaActividad ligada con el layout “coordenadas.xml” que vemos en la fig AII.4. Actividadque espera que clickemos en algún lugar de la pantalla para recoger lascoordenadas y el tiempo que hemos mantenido pulsada la pantalla para enviarestos datos a través de un bundle a la siguiente activity“AplicacionSencillaResults.java”.package xavi.valls;import java.util.Calendar;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.MotionEvent;public class AplicacionSencillaActivity extends Activity { /** Called when the activity is first created. */ @Override //Aquí es donde estamos ligando esta activity con la layout coordenadas.xml public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.coordenadas); } // variables calendar que servirán para detectar el tiempo pulsando la pantalla Calendar tiempoInicio = null; Calendar tiempoFinal = null; @Override public boolean onTouchEvent(MotionEvent event) { //guarda las coordenadas pulsadas int x = (int)event.getX(); int y = (int)event.getY(); //con este switch sabemos cuándo se ha pulsado y cuando se ha dejado de pulsar la pantalla switch (event.getAction()) { case MotionEvent.ACTION_DOWN: tiempoInicio = Calendar.getInstance(); break; case MotionEvent.ACTION_MOVE: break; case MotionEvent.ACTION_UP: tiempoFinal = Calendar.getInstance(); //Creamos un nuevo intent para ir a la siguiente activity y le pasamos los datos a través de un bundle Intent intent = new Intent (AplicacionSencillaActivity.this,AplicacionSencillaResults.class); Bundle bundle = new Bundle(); bundle.putLong( "TIEMPOPRESIONADO", tiempoFinal.getTimeInMillis() - tiempoInicio.getTimeInMillis()); bundle.putInt("X", x); bundle.putInt("Y", y); intent.putExtras(bundle); finish(); startActivity(intent); break; } return true; }} 62
  • 63. AII.2.4 AplicacionSencillaResults.javaActividad ligada con el layout “results.xml”, interfaz que podemos ver en la figuraAII.5. Aquí recibimos el bundle con los datos enviados de la actividad anterior, loscuales serán presentados al usuario a través de los textviews. Tenemos un botónpara volver a la actividad anterior y repetir todo el proceso de la opción coordenadasy en caso de querer volver al menú principal tenemos el botón de salir.package xavi.valls;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.TextView;public class AplicacionSencillaResults extends Activity { /** Called when the activity is first created. */ @Override //Aquí es donde estamos ligando esta activity con la layout results.xml public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.results); // recogemos la información que trae el bundle de la otra activity Bundle bundle = getIntent().getExtras(); float segundosPresionado = bundle.getLong("TIEMPOPRESIONADO") / 1000f; TextView txtMensaje1 = (TextView) findViewById(R.id.textView1); TextView txtMensaje2 = (TextView) findViewById(R.id.textView2); // Sacamos los datos del bundle a la pantalla txtMensaje1.setText( "Has pulsado la pantalla durante " + segundosPresionado + " segundos"); txtMensaje2.setText( "Has pulsado en las coordenadas (" + bundle.getInt("X") + ", " + bundle.getInt("Y") + ")"); // Aquí vemos las funciones del botón de "Otra vez" final Button btnRepetir = (Button)findViewById(R.id.BtnRepetir); btnRepetir.setOnClickListener(new OnClickListener() { public void onClick(View v) { Intent intent = new Intent (AplicacionSencillaResults.this, AplicacionSencillaActivity.class); finish(); startActivity(intent); } }); // Aquí vemos las funciones del botón de "Salir" final Button btnSalir= (Button)findViewById(R.id.BtnSalir); btnSalir.setOnClickListener(new OnClickListener() { public void onClick(View v) { finish(); } }); }} 63
  • 64. AII.2.5 Calculadora.javaActividad donde tenemos todas las funciones y procedimientos para llevar a cabo lasegunda opción que tenemos en el menú principal, la calculadora. Esta enlazadacon el layout “calc.xml” que podemos ver en la figura AII.6.A destacar en este actividad a diferencia de las demás usadas hasta ahora, que notenemos listeners para los botones en el propio archivo .java, usamos otra manerade diseñar la funcionalidad de los botones aprovechando una opción que traen lospropios botones en su layout, ver código en AII.1.5.Podemos apreciar que en el código xml de los botones que tenemos una opciónllamada android:onClick="nombre del procedimiento" , la cual liga la acción de hacer click enel botón con un procedimiento que podremos tener en nuestro archivo .java.package xavi.valls;import android.app.Activity;import android.os.Bundle;import android.widget.*;import android.view.*;public class calculadora extends Activity { // Instancias de objetos a usar private double valor_a, valor_b; private EditText op_a, op_b; private TextView resultado; // Ligamos la actividad con el layout calc.xml public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.calc); // Asignamos los objetos this.op_a = (EditText) findViewById(R.id.op_a); this.op_b = (EditText) findViewById(R.id.op_b); this.resultado = (TextView) findViewById(R.id.resultado); }// Aquí vemos los procedimientos usados para calcular cada operación y como mostramos los resultados al usuario. public void cSumar(View view) { if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) { this.valor_a = Double.parseDouble(this.op_a.getText().toString()); this.valor_b = Double.parseDouble(this.op_b.getText().toString()); this.resultado.setText(Double.toString((this.valor_a + this.valor_b))); } } public void cRestar(View view) { if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) { this.valor_a = Double.parseDouble(this.op_a.getText().toString()); this.valor_b = Double.parseDouble(this.op_b.getText().toString()); this.resultado.setText(Double.toString((this.valor_a - this.valor_b))); } } public void cMultiplicar(View view) { if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) { this.valor_a = Double.parseDouble(this.op_a.getText().toString()); this.valor_b = Double.parseDouble(this.op_b.getText().toString()); 64
  • 65. this.resultado.setText(Double.toString((this.valor_a * this.valor_b))); } } public void cDividir(View view) { if(this.op_a.getText().toString().length() > 0 && this.op_b.getText().toString().length() > 0) { this.valor_a = Double.parseDouble(this.op_a.getText().toString()); this.valor_b = Double.parseDouble(this.op_b.getText().toString()); if(this.valor_b != 0) { this.resultado.setText(Double.toString((this.valor_a / this.valor_b))); } else { this.resultado.setText("Infinito"); } } }// Boton de salir public void cSalir(View view) { finish(); }}AII.2.6 Camera.javaÚltima actividad para llevar a cabo la última opción que nos da el menú principal.Ligada con el layout “cam.xml” que podemos ver en la fig AII.7. En ella encontramoslas funciones que nos dejaran llevar a cabo la acción de tomar una foto y mostrarlaen pantalla.Para poder llevar a cabo esta acción usamos funciones predefinidas en Androidcomo “startActivityForResult” o la “ActivityResult” las cuales nos ayudan a enviar yrecibir los datos que nos manda la cámara, la imagen en si.Para conseguir la imagen, usamos otra función de la biblioteca MediaStore que nosofrece Android para poder usar la cámara del dispositivo mobil,ver figura AII.8, estafunción es (MediaStore.ACTION_IMAGE_CAPTURE) la cual a través de un intent nos mandarala imagen que tomemos con la cámara.package xavi.valls;import android.app.Activity;import android.content.Intent;import android.graphics.Bitmap;import android.os.Bundle;import android.provider.MediaStore;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.ImageView;public class Camera extends Activity { @Override//ligamos esta actividad con el layout “cam.xml” public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.cam); 65
  • 66. Button btnAction = (Button)findViewById(R.id.btnPic); //Al hacer click en Foto se nos abrirá la cámara del dispotivo y podres tomar una foto, figura AII.8 btnAction.setOnClickListener(new OnClickListener() { public void onClick(View v) { //guardamos la imagen en un intent Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); int code=0; //este int lo creamos aunque no lo usaremos, solo que la función ForResutl por defecto pide un int. startActivityForResult(intent, code); } }); } @Override//Pasamos el intent con la imagen en su interior y la mostramos en pantalla protected void onActivityResult(int requestCode, int resultCode, Intent data) { ImageView iv = (ImageView)findViewById(R.id.imgView); iv.setImageBitmap((Bitmap) data.getParcelableExtra("data")); } //Boton salir public void cSal(View view) { finish(); }} Fig AII.8 Pantalla que se nos abre cuando usamos la función (MediaStore.ACTION_IMAGE_CAPTURE), llamado a la cámara del dispositivo. 66
  • 67. AII.3 Android Manifest.xmlEste archivo se utiliza para unificar todo el proyecto y decirle al compilador queactividades forman parte de la aplicación.A su vez en este archivo es donde se quedarán reflejadas las propiedades queluego el archivo de instalación .apk mostrará, propiedades como el nombre delarchivo, el icono con el que se verá al instalar la aplicación y sobretodo en queversión de android y del SDK se ha programado para así saber en que dispositivosfuncionaria y sería compatible la aplicación.<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="xavi.valls" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="10" /> <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" > //Aquí le indicamos todas las actividad que forman parte de nuestra aplicación <activity android:name=".FinalActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <activity android:name="LoginResult" /> <activity android:name="AplicacionSencillaActivity" /> <activity android:name="AplicacionSencillaResults"></activity> <activity android:name="calculadora" /> <activity android:name="Camera" /> </application></manifest> 67