You are on page 1of 90

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA INFORMÁTICA

INGENIERÍA TÉCNICA EN INFORMÁTICA DE SISTEMAS

DIARIO DE VIAJE

Realizado por
ANTONIO GUILLÉN ÁVILA
RAFAEL GARCÍA NARANJO

Dirigido por
Dr. JOSÉ RAMÓN PORTILLO FERNÁNDEZ

Departamento
MATEMÁTICA APLICADA I

Sevilla, Septiembre de 2012

2

INDICE
1.

Introducción .............................................................................................................. 5

2.

Definición de Objetivos ............................................................................................ 7

3.

Análisis de antecedentes y aportación realizada ..................................................... 10

4.

Análisis temporal y de costes de desarrollo ............................................................ 12

5.

4.1.

Planificación .................................................................................................... 13

4.2.

Herramientas para el desarrollo ....................................................................... 14

4.2.1.

Equipos de desarrollo ............................................................................... 15

4.2.2.

Eclipse + Android SDK ............................................................................ 15

4.2.3.

Dropbox .................................................................................................... 16

4.2.4.

Dispositivos físicos ................................................................................... 16

Manual de Android e instalación del entorno de trabajo ........................................ 19
5.1.

Introducción a Android .................................................................................... 20

5.2.

Breve historia ................................................................................................... 21

5.3.

Estructura de Android ...................................................................................... 22

5.4.

Estructura de una aplicación Android .............................................................. 25

5.5.

Ciclo de vida de una aplicación en Android .................................................... 29

5.5.1.
5.6.

6.

Prioridad de procesos................................................................................ 32

Herramientas para el desarrollo ....................................................................... 33

5.6.1.

Instalación de Eclipse ............................................................................... 33

5.6.2.

Instalar SDK Android ............................................................................... 34

5.6.3.

Instalar plugin de Android para Eclipse ................................................... 34

5.6.4.

Completar la instalación ........................................................................... 36

5.6.5.

Otras herramientas útiles .......................................................................... 39

5.6.5.1.

Otras funcionalidades del emulador .................................................. 39

5.6.5.2.

Dalvik Debug Monitor Service ......................................................... 39

5.6.5.3.

Android Debug Bridge ...................................................................... 40

Manual de usuario ................................................................................................... 42
6.1.

Presentación del Proyecto ................................................................................ 43

6.2.

Ventana de la Lista de Viajes (Ventana Principal) .......................................... 43

6.3.

Ventana de “Nuevo Viaje” ............................................................................... 45

3

.................... Bibliografía .............. Diseño e implementación .......... Diseño ..................................................... Ampliaciones..................................................... 89 4 ................................................ 79 9............. Pruebas .....................................................................4.... Conclusiones....... 51 7................................. 54 7................................................................................................2...............................6..............6........................................ 47 6................ Ventana de la Lista de Lugares .................................................. Ventana de “Nuevo Lugar” . Ventana “Lugar” ....... 60 8............................................................5...........................................................1........................................................................................................................................... 50 6........................................ 84 10. Implementación.................................................................................. 55 7. 86 11..........................

Introducción 5 .1.

que permite documentar los viajes visitados. Además. pudiendo localizar estos lugares visitados mediante su posición GPS y mostrarlos a través de Google Maps. dónde se explica al inicio del mismo los pasos previos que cualquier Ingeniero Informático debe realizar antes de comenzar la implementación. Como último aspecto importante. los usuarios podrán consultar datos de los lugares visitados en cualquier momento.Este documento tiene como propósito detallar la labor realizada durante el periodo de ejecución del proyecto final de carrera. tanto sobre la aplicación como a nivel personal en la etapa final como estudiante. El objetivo de esta aplicación es tener un recuerdo con imágenes. 6 . añadiendo información relevante para el usuario. Todo esto mediante Android. que es una plataforma de programación de software para dispositivos móviles creada por Google. además de como finalización del ciclo de formación universitaria. esta aplicación añade nuevas funcionalidades para interactuar con sus datos. También. sino el paso de estudiante a ingeniero. archivados por viaje y lugar. información y comentarios que hayamos introducido en los viajes realizados. la estructura del documento sigue una línea temporal. ya que todos los dispositivos Android disponen de acceso a Internet. fotos y enlaces a wikipedia. y concluyendo con las ideas y reflexiones obtenidas tras su finalización. Esta aplicación presenta un diario de viaje. este trabajo ha servido como primera toma de contacto con el mundo laboral. el cual consiste en una aplicación para dispositivos móviles Android. Ya que el objetivo de realizar un proyecto fin de carrera no es sólo la aplicación en sí.

Definición de Objetivos 7 .2.

partimos de la idea de otorgar una gran importancia al GPS que incluyen la mayoría de smartphones actualmente a la venta. aunque alguna de estas opciones puede que ya se encontraran hace unos años en los móviles. En los primeros compases del diseño. Partimos de la idea de ofrecer un producto simple e interesante desde el punto de vista del público. Dispondremos de una completa guía de instalación de Eclipse y su SDK (kit de desarrollo de software) y. para así. a la vez que podemos añadir comentarios. incluso todas ellas. gracias sobre todo a las prestaciones de los dispositivos móviles con la introducción de procesadores de última generación. El objetivo principal de este proyecto es desarrollar una aplicación que permita al usuario realizar un diario de viaje que organice la información recopilada por el usuario para así tener un recuerdo en su dispositivo móvil. dar la máxima facilidad posible al usuario que desee ver los viajes que ha realizado. 8 . En primer lugar. Para ello. se verán algunas características de los dispositivos móviles que hemos utilizado durante el proyecto y que usan la plataforma Android. En primer lugar. introduciendo fotos y enlaces a wikipedia del lugar visitado. como son el Samsung I5800 Galaxy 3 y el HTC Wirefire S. leyendo toda la documentación enlazada con la Wikipedia. lo que permite que el hardware instalado en los móviles haya obtenido una mejora considerable. y ver las imágenes capturadas con sus respectivos comentarios. tras comentar la aportación que se ha realizado y analizar temporalmente el Proyecto. GPS y acceso a internet con los que cuentan estos dispositivos. queríamos hacer uso de algunas de las funciones propias de este tipo de teléfonos.Hoy en día es cada vez más habitual el uso de Internet. La aplicación nos ayudará a localizar en el mapa algún lugar visitado previamente. entre otros. asimismo. Debido a esta mejora vimos interesante usar estas opciones para crear una aplicación que permitiera unir todas ellas. ha sido con la llegada de los smartphone cuando la usabilidad ha sufrido una mejora considerable. explicaremos como instalar el plugin ADT en Eclipse o en el entorno de desarrollo que estemos utilizando. necesario para empezar a crear aplicaciones propias en Android. Para ello utilizamos la cámara de fotos. se explicarán cada uno de los artilugios que usaremos en nuestro proyecto y de los cuales está dotado el dispositivo. como puede ser el caso del GPS y la cámara. con la finalidad de mejorar la organización y el acceso a la información que un usuario haya obtenido de un viaje. incluso saliendo los últimos con varios núcleos. Después. del GPS y la cámara en un dispositivo móvil. y de qué forma se hace uso de ellos. hemos partido de varias ideas desde las cuales desarrollar el resto. así como hacer uso de Internet y la cámara.

lo que demuestra su buena adaptación dentro de este mundo móvil y pensamos que podría ser una buena salida laboral en este mercado tan competitivo que hay en estos momentos. el objetivo personal es aprender a programar para una plataforma en la que no se ha trabajado durante la carrera. dado que Android es un sistema operativo muy reciente en el que aún no se ha profundizado a nivel académico. En este caso. Respecto a los objetivos personales. por lo que también fue un aliciente por el cual nos decidimos a programar con esta plataforma. se busca aprender a utilizar las nuevas tecnologías puesto que aunque se termine la etapa de estudiante. 9 . se mostrará el resultado de probarlo en nuestro dispositivo móvil.Para finalizar. se explicará la complejidad de desarrollar el diario de viaje y cómo a través de la cámara del teléfono móvil y el GPS. podremos localizar los distintos puntos visitados. teniendo en cuenta que el mundo de la informática está en continua evolución. Una vez explicado. aun siendo uno de los últimos en ser lanzados. Además Android es uno de los sistemas operativos móviles con mayor cuota de mercado dentro de los dispositivos móviles. un informático va a estar aprendiendo a usar nuevos lenguajes de programación o tecnologías durante toda su vida laboral.

Análisis de antecedentes y aportación realizada 10 .3.

este manual tocaba temas importantes para nuestra aplicación como “Localización geográfica” y “Mapas”. puesto que abarca todos los temas necesarios para empezar a desarrollar un aplicación en esta plataforma. tanto para los que estén empezando como para los que tengan algún conocimiento previo. por su amplio contenido e información que permite conocer bien como funciona Android y su API. parte del código que se utiliza para desarrollar la aplicación ha sido ingeniada por nosotros para que se ajuste a la idea que diseñamos. veremos que el SDK de Android sirve de gran ayuda. y que haciendo uso de GoogleMaps (que será muy útil y necesario en nuestro proyecto) hace que programar esta aplicación. 11 . se han utilizado trozos de código obtenido de las distintas fuentes de información que hemos consultado.Para la realización del Proyecto. así como su información complementaria. se empieza recolectando cierta información de un manual de Introducción a Android con el título “Curso programación Android” (Salvador Gómez Oliver) al que se hace referencia en la bibliografía. si no que en nuestro caso las hemos implementado nosotros desde nuestras propias ideas para que se ajusten a nuestra aplicación). Por supuesto no hemos creado la aplicación desde cero. ya que ninguno de nosotros había programado previamente con Android y no conocíamos los conceptos básicos ni la forma de comenzar la aplicación. sea un poco más ameno. pero sí que hemos ideado gran parte de la aplicación cuyo código esta implementado por nosotros (con esto no queremos decir que estas acciones no estén implementadas ya. hay que destacar http://developer. Toda la información recolectada en internet y de los distintos libros consultados nos ha ayudado para aprender este lenguaje de programación nuevo para nosotros y saber cómo funciona. Pero nuestra gran fuente de información aportada ha sido Internet. Además de ello. como la utilización de la cámara. ha sido imprescindible para nosotros en el desarrollo del proyecto gracias a la base que hemos obtenido sobre el desarrollo de aplicaciones Android. y aunque estos estaban desarrollados de una forma muy básica y el manual no toca otros temas que son base de nuestra aplicación. la aplicación ha sido desarrollada usando código de terceros y código implementado por nosotros para así poder llevar a cabo este proyecto de final de carrera. Consideramos este manual lo suficientemente completo como para iniciarnos en Android. Para poder devolver la localización de un punto de interés donde estemos. aunque en la bibliografía están señaladas dichas páginas. Por tanto. Una buena parte de la documentación del proyecto ha sido recolectada de diversas webs y. pero una vez que se obtienen estos conceptos bases. como creemos que sucede con cualquier proyecto informático. a pesar de su dificultad.Android.com.

4. Análisis temporal y de costes de desarrollo 12 .

Sin lugar a dudas. y del conocimiento de la herramienta.4. nuestra experiencia nos dice que a pesar de la numerosa documentación que habíamos consultado. la aplicación empezó a tomar una base sólida. A comienzos de Marzo. y de cómo realizar aplicaciones para este sistema operativo de Google. En total. aparte de ir anotando las horas dedicadas grupal e individualmente. y una vez aclarados algunos conceptos sobre los cuales teníamos dudas a la hora de implementar. También instalamos las versiones del SDK de Android y empezamos a ver cómo funcionaban las aplicaciones de los primeros ejemplos más sencillos. A continuación mostramos gráficamente los tiempos dedicados a cada apartado de este proyecto. se escribieron los manuales de usuario que contiene la memoria. A principio de Febrero y tras una documentación exhaustiva y que se detallará en la Bibliografía.1. Planificación En este apartado se ha analizado el tiempo dedicado a la realización del proyecto. comenzamos a desarrollar las primeras aplicaciones mas decentes en Android. nos costó bastante tiempo la tarea de depurar el código y retocarlo de forma que consiguiera mostrar resultados óptimos. Igualmente. el tiempo dedicado a escribir la memoria junto con los distintos manuales de uso que ésta incluye. Este proyecto fue iniciado a partir de Octubre de 2011. se tuvo que aplazar un poco la realización del proyecto. Así mismo. así como las pruebas realizadas para comprobar que la aplicación funcionaba correctamente. anotando enlaces para la bibliografía y comentando el código de las aplicaciones básicas que realizamos. Android”. aproximadamente 345 horas de trabajo cada uno repartidas de la siguiente forma: 13 . se iban dando pinceladas a la realización de la memoria. Debido a las prácticas de empresa que en ese momento hacíamos los dos y la cercanía de los exámenes de la convocatoria de Diciembre. Una vez que la aplicación estaba casi lista. cuánto nos ha costado realizar la aplicación que hemos llevado a cabo en este Proyecto. y se amplió de manera considerable todo el trabajo de investigación. Estuvimos 2 meses realizando tareas de investigación. Mayo y Junio se realizó la parte importante de la aplicación. Es necesario destacar que en ningún momento hemos dejado de documentarnos. Durante los meses de Abril. como el típico “Hello. hasta la realización de la documentación del mismo. tiene un lugar importante la corrección de fallos en cuanto a tiempo se refiere. tanto del uso de Android en general como de nuestra aplicación en particular. desde todo el trabajo de investigación. Se especificará cuánto tiempo hemos estado investigando acerca del funcionamiento de Android.

un equipo para desarrollar la aplicación y todas las herramientas que hemos empleado para el desarrollo del software son de libre adquisición. debido a que ya teníamos cada uno un móvil con sistema operativo Android. Herramientas para el desarrollo El coste de nuestro proyecto ha sido nulo. 14 .2.Tarea Horas estimadas Horas reales Investigación Desarrollo de la aplicación Memoria Pruebas Total 220 280 90 30 620 270 300 110 15 695 Horas estimadas Investigación Desarrollo de la aplicación Memoria Pruebas Horas reales Investigación Desarrollo de la aplicación Memoria Pruebas 4.

0 GHz. como las de documentación.2. Equipos de desarrollo Hemos usado distintos equipos para las distintas fases del proyecto. el propio Eclipse puede instalar y ejecutar la aplicación mediante una simple conexión USB. Si se emplean dispositivos físicos. Además.696 MB Windows7 64bit Home Premium 4. Tanto las labores de implementación.Android. 2MB L2 cache) 2GB DDR2 Intel Graphics Media Acelerator 900 Windows XP Profesional Equipo2: CPU RAM Targeta gráfica Sistema Operativo Core i5-2410M (2.1. localizar errores.com/sdk/index. hasta 1.html 15 .2.90 GHz Turbo . 3 MB L2) 4GB DDR3 (1333MHz) Intel HD 3000 (HM65). etc. 533MHz FSB.eclipse. debido a su fuerte orientación JAVA. Incluye todas las librerías necesarias para el desarrollo de aplicaciones. están sincronizadas a través de internet. Más información en: http://www. Eclipse + Android SDK El conocido entorno de desarrollo supone la mejor herramienta para programar en Android.2.30 / 2. FSB 1333 MHz.4.org/ http://developer. por lo que no hemos tenido ningún tipo de problema para mantener la coherencia de las distintas fases. es completamente gratuito y de código abierto. Los equipos usados son:  Equipo1: CPU RAM Targeta gráfica Sistema Operativo  Intel Pentium M 760 processor (2. ofreciendo además todo tipo de herramientas para facilitar la programación. así como una máquina virtual configurable para probar el funcionamiento.

El servicio permite a los usuarios almacenar y sincronizar archivos en línea entre computadoras. 236.DNSe (Digital Natural Sound Engine) microSD. MP3. Dropbox Dropbox es un servicio de alojamiento de archivos multiplataforma en la nube.com 4.Touch Wiz 3.5mm jack Card slot Internal GPRS EDGE Speed GSM 850 / 900 / 1800 / 1900 HSDPA 900 / 2100 2010.com/ y son las siguientes:  Samsung I5800 Galaxy 3 2G Network 3G Network General Announced Status Dimensions Body Weight Type Size Display Multitouch Sound Memory Data Alert types Loudspeaker 3. June Available. 256MB RAM Class 10 (4+1/3+2 slots). 16M colors 240 x 400 pixels. Más información en: http://www. July 113. 1GB card included 512MB ROM. 32 .5 x 55 x 12.2. y compartir archivos y carpetas con otros usuarios.2 inches (~146 ppi pixel density) Yes . Dispositivos físicos El uso de la máquina virtual incluida en Eclipse no permite la manipulación de los sensores. las hemos obtenido en la web http://www. Released 2010. up to 32GB. Ambos están actualizados al sistema operativo Android 2. 3. operado por la compañía Dropbox. para el desarrollo de este proyecto hemos adquirido dos Smartphones de gama alta y diferente hardware para poder hacer las pruebas pertinentes.2. WAV ringtones Yes Yes .8 kbps HSDPA. además el rendimiento de las aplicaciones queda muy por debajo del que se obtiene al ejecutarlo en un dispositivo real. 3. Debido a esto.9 mm 109 g TFT capacitive touchscreen.4.0 Vibration.2.4.3.48 kbps Class 10.6 Mbps 16 .gsmarena. Las especificaciones de ambos dispositivos.dropbox.

Excel. QVGA@15fps No Android OS. 256K colors 320 x 480 pixels. microUSB v2. May 101.Predictive text input Standard battery.263 player . up to 32GB. face and smile detection Yes. MMS. 384 Kbps 17 . via Java MIDP emulator Black. upgradable to v2.2) Yes.MP3/WAV/eAAC+ player . Calendar.2 inches (~180 ppi pixel density) .4 mm 105 g . 3.11 b/g/n.2 Samsung S5P6422 667 MHz Accelerometer. Gmail. Li-Ion 1500 mAh Up to 620 h (2G) / Up to 510 h (3G) Up to 15 h 30 min (2G) / Up to 7 h 15 min (3G) GSM 850 / 900 / 1800 / 1900 HSDPA 900 / 2100 HSDPA 850 / 1900 or HSDPA 2100 (Australia) 2011.5mm jack Card slot Memory Internal GPRS EDGE Data Speed Sound Wi-Fi 802.15 MP.Touch-sensitive controls TFT capacitive touchscreen. Google Talk integration . compass SMS(threaded view).MP4/DivX/XviD/WMV/H.4 x 12.0 with A2DP Yes.Document editor (Word. MP3. Push Mail. PDF) .1 (Eclair). autofocus Geo-tagging.Google Search.Organizer . WAV ringtones Yes Yes microSD. v3.264/H.3 x 59. with A-GPS support Yes. IM HTML Stereo FM radio with RDS Yes.Voice memo .0 3. Released 2011. Wi-Fi hotspot (Android 2. White .WLAN Bluetooth USB Primary Features Camera Video Secondary OS CPU Sensors Messaging Browser Radio GPS Java Features Colors Battery  Stand-by Talk time HTC Wildfire S 2G Network 3G Network General Body Announced Status Dimensions Weight Display Type Size Alert types Loudspeaker 3. HSUPA. 2GB included 512 MB ROM. 2048x1536 pixels. PowerPoint. February Available. 7.2 Mbps.1 UI Vibration. 512 MB RAM (418 MB user-available) Up to 114 kbps Up to 560 kbps HSDPA.HTC Sense 2. proximity. YouTube. Email. v2. Maps.

Lilac . Wi-Fi hotspot Yes. Picasa integration .Organizer .Google Search.0 5 MP. with A-GPS support Yes. Silver. Email. upgradable to v2. Google Talk.WLAN Bluetooth USB Primary Features Camera Video Secondary OS Chipset CPU GPU Sensors Messaging Browser Radio GPS Features Java Colors Battery Stand-by Talk time Wi-Fi 802. Gmail .Xvid/MP4/H. autofocus. microUSB v2.3 (Gingerbread).SNS integration . Maps. LED flash Geo-tagging.YouTube. Brown. v3.MP3/AAC+/WAV player . VGA@24fps No Android OS. proximity. v2.Predictive text input Standard battery.264 player .5 Qulacomm MSM7227 600 MHz ARM 11 Adreno 200 Accelerometer. face detection Yes. IM HTML Stereo FM radio with RDS Yes. MMS. EDR Yes.11 b/g/n. Li-Ion 1230 mAh Up to 360 h (2G) / Up to 570 h (3G) Up to 7 h 10 min (2G) / Up to 5 h 50 min (3G) 18 . Push Email.0 with A2DP. 2592 x 1944 pixels.3. via Java MIDP emulator Black. compass SMS(threaded view).Voice memo .

5. Manual de Android e instalación del entorno de trabajo 19 .

a los cuales era imposible acceder. han hecho que se pueda programar con un nivel de abstracción para que el programador se aísle de la capa hardware y no estar pendiente de ella.5. En la actualidad. para lo que era necesario entender el hardware específico sobre el que iban a trabajar.  Todo su software se ha realizado bajo una licencia Apache. haciéndolas prevalecer frente a aplicaciones que se hayan desarrollado por terceras partes. Esto suponía una barrera infranqueable para los desarrolladores de este tipo de aplicaciones. Así mismo. y aplicaciones clave con una serie de librerías API para poder desarrollar aplicaciones a las cuales se les pueden dar la forma y el funcionamiento específico para que pueda funcionar en teléfonos móviles. los propios terminales priorizaban las aplicaciones nativas. Introducción a Android Android es una pila de software de código abierto que incluye un sistema operativo. Históricamente. es porque este tipo de licencia permite que se realicen modificaciones sobre el software inicial y una vez que se 20 . los desarrolladores codificaban sus aplicaciones en lenguajes de bajo nivel. Es por ello que en Android todas las aplicaciones son iguales sin hacer ninguna distinción ni discriminación. los avances realizados en el desarrollo de aplicaciones para terminales móviles. Hasta hace poco.1. poder desarrollar aplicaciones para teléfonos móviles era dificilísimo porque se programaban bajo sistemas operativos propios y entornos de desarrollo cerrados. En Android las aplicaciones tanto nativas como las desarrolladas por terceras partes son escritas usando la misma API y ejecutadas en las mismas condiciones. y generalmente solían ser un dispositivo sencillo o un rango de dispositivos provenientes del mismo fabricante. También una de las causas primordiales por las cuales se ha escogido una licencia Apache. de modo que el código es de libre distribución. Entre las características del sistema operativo Android destacamos:  Todas sus aplicaciones se programan en lenguaje Java y son ejecutadas en una máquina virtual específica diseñada para esta plataforma. middleware.

La Open Handset Alliance está formada por un consorcio de 34 compañías de hardware. se anunció la fundación de la Open Handset Alliance al mismo tiempo que la creación de la plataforma Android. se puede entender como algunos operadores y fabricantes hayan visto con buenos ojos esta iniciativa y es por ello que se hayan sumado a Android. La principal causa de esta adhesión es que dichas compañías podrán modificar el código y desarrollar todo tipo de aplicaciones o trabajos sin la necesidad de verse obligados a compartir todo la elaboración producida. Google adquirió Android. no exige que el software alterado se distribuya como software libre. Una vez en Google. se le proporciona de forma totalmente gratuita un entorno de desarrollo. Google tenía varias patentes de aplicaciones sobre el área de la telefonía móvil. permite que cualquier persona se pueda descargar. En esos momentos. Google adaptó su buscador y sus aplicaciones para su uso en móviles. Intel [39] y Motorola [40] entre otras. El 5 de noviembre del mismo año. La principal finalidad que busca Android desde el punto de vista del desarrollador. acceder al código fuente. En septiembre del 2007. una pequeña startup de California.realicen los oportunos cambios.O. HTC 21 . añadir nuevas funcionalidades y no tener que compartir el código ni permitir su uso a terceros. El primer teléfono en el mercado que posee Android es el T-Mobile G1 [41] (también conocido como Dream). y que toda aplicación que se pueda crear sea portable. basado en Linux para dispositivos móviles. Por último. Este móvil es el resultado conjunto de T-Mobile.2. 5. fácil de desarrollar y reutilizable. De todas formas.0 preinstalada. lanzado el día 22 de octubre de 2008 que viene con la versión Android 1.  A cualquier desarrollador que se plantee programar sobre esta plataforma. Así. Inc [37]. modificarlo y redistribuirlo pero con el ligero inconveniente que a cualquier persona se le exime de este último punto. cabe destacar la gran facilidad que desde Android se ofrece para poder integrar todo tipo de aplicación con las aplicaciones Web de Google. Más adelante. Breve historia En Julio de 2005. HTC [38]. dedicadas a investigar estándares abiertos para dispositivos móviles. entre las cuales se incluyen Google. software y telecomunicaciones. la licencia Apache propuesta por Android. la compañía se dedicaba a la creación de software para teléfonos móviles. es que éste pueda sacar de sí lo mayor posible de la plataforma. Con todo ello. de este modo. Además se integra un emulador en el cual se pueden realizar todo tipo de pruebas sobre el programa elaborado y sí éstas han salido satisfactorias se puede importar el proyecto elaborado al propio dispositivo móvil. Permite a las operadoras modificar a su gusto la plataforma. es decir una SDK que se puede instalar junto con un plug-in en uno de los IDE´s más famosos y conocidos como es Eclipse. el equipo desarrolló un S. se intenta buscar un estándar para el desarrollo de este tipo de aplicaciones. poder controlar y aprovechar cualquier funcionalidad que se proporcione desde el sistema operativo.

incluye diversos drivers lo cual le hace semejante a cualquier otro kernel que corre en un ordenador personal. Android está disponible como código abierto [42].3. en esta capa se establecen los drivers del hardware.6.y Google. es decir. un framework de aplicaciones y las propias aplicaciones. nuevas aplicaciones o reemplazar las existentes por otras dentro del dispositivo móvil 5. cualquiera puede añadir extensiones. desde el 21 de octubre de 2008. A continuación se puede ver el esqueleto de este sistema operativo. una serie de librerías escritas en código C/C++. la gestión de procesos y memoria. Todo ello está manejado por un kernel de Linux con versión 2. Por 22 . un entorno de ejecución propio (Android Run Time). la seguridad. y las gestiones de redes y de energía. Gracias a esto. Estructura de Android El stack de software a grandes rasgos. Aparte de las propiedades que puede dar dicho kernel de Linux. y debajo de la misma se explicarán cada una de las partes que lo conforman. La estructura del sistema operativo es la siguiente:  El núcleo de Linux: es la capa más baja situada y es donde se sitúan los servicios básicos. también hay que decir que precisamente dicho núcleo. está formado por: un núcleo de Linux. y cuya función principal es abstraer a las diferentes capas sucesivas que soporta la estructura de Android del hardware de la máquina. Por último.

la SGL.  La siguiente capa. o OpenGL / ES y SGL: la última libre. es el entorno de ejecución de Android. Dentro de las librerías. al ser Linux cumple con las expectativas con las que Android se lanzará bajo licencia Apache. o la Android Run Time. Además es la encargada de gestionar todas aquellas pantallas de las diferentes aplicaciones activas que se encuentren en ese preciso instante. SQLite es software libre. estas librerías son iguales de básicas. así como los archivos fotográficos. para mapas de bits y vectores. este kernel. o Surface Manager (Administrador de Superficies): es la que realiza toda la gestión del acceso a los subsistemas de pantallas. Cabe destacar que en esta librería se proporcionan los códecs necesarios para poder reproducir los formatos más populares.  Por encima del núcleo de Android se establecen una serie de librerías escritas en lenguaje C/C++. la OpenGL / ES maneja los gráficos 3D en el caso de que el hardware del teléfono móvil lo disponga. o SSL & WebKit: ambas librerías son las encargadas de integrar un navegador para Internet y de proporcionar seguridad cuando se acceda a ésta. Sin embargo. y que se sitúa en el mismo nivel que la anterior. o FreeType: es la encargada de la renderización de fuentes. las más importantes son las siguientes: o Libc: esta librería incluye todas las cabeceras y funciones según el estándar de C. es la encargada de proporcionar el motor gráfico de 2D. Android incluye un set de librerías base que proveen la mayor parte de las funcionalidades disponibles en 23 .otro lado. o SQLite: es la librería que implementa un motor de base de datos. o Media: el principal uso de esta librería es para poder reproducir tanto archivos de audio o video. y al igual que el núcleo. por lo tanto el código fuente es de dominio público.

y ejecuta las clases compiladas por el compilador Java y que se han transformado en el formato .dex podría asemejarse a un archivo jar. ha sido escrita de forma que un dispositivo puede correr múltiples máquinas virtuales de forma eficiente. Los desarrolladores tienen acceso a las mismas API´s que las aplicaciones base. se va a explicar un poco como se realiza todo el proceso. Esta máquina virtual. En esta capa se proporcionan todas las clases necesarias para poder crear aplicaciones en Android. las últimas capas de la plataforma. o Administrador de Ventanas: con ella se pasan a gestionar las ventanas de las aplicaciones. es que ha sido especialmente optimizada y adaptada para las características de cualquier teléfono móvil.… o Proveedor de Contenidos: con esta API. por hacer un símil sencillo.las librerías base del lenguaje de programación Java. con el único objetivo de poder reutilizar los componentes utilizados para la aplicación realizada. una vez que obtenemos los . con su propia instancia en la máquina virtual Dalvik. Del mismo modo. Una vez que se genera el bytecode de la aplicación escrita en Java. es decir. Lo particular de esta máquina virtual. o Vista del Sistema: es con la cual se realiza toda la interfaz de usuario.dex están optimizados para un uso mínimo de la memoria y pensados para procesadores pequeños. o Administrador de Actividad: es la API encargada de gestionar el ciclo de vida de las aplicaciones. Dicha máquina virtual está basada en registros.dex por la herramienta “dx”. 24 . como son los mensajes SMS. llamadas. Todas las aplicaciones se programan en Java y para poder ejecutarlas se ha creado específicamente para Android una máquina virtual.dex con toda la agregación de estos códigos objeto. se sustentan sobre Java. este framework proporciona un nivel de abstracción del acceso al hardware y la gestión de la interfaz del usuario y de los recursos de la aplicación. y de la eficiencia de esta máquina virtual. Dalvik ejecuta archivos en el formato Dalvik Executable (.  La penúltima capa dentro de la estructura del sistema operativo Android es la del Framework de Aplicaciones.class la máquina virtual genera un . un . Para hacernos una idea real de lo que sucede. se pueden compartir los datos de cualquier aplicación. o Administrador de Ubicaciones: permite que las aplicaciones obtengan información sobre la localización y posicionamiento de ésta. En cuanto a las API´s más conocidas son las siguientes: o Administrador de Teléfono: destinada para que el desarrollador pueda interactuar con las funcionalidades del teléfono. Cada aplicación Android corre su propio proceso.dex). la Dalvik Virtual Machine. de forma que los . y no con el bytecode generado por Java. A partir de aquí.

en la que se encuentran tanto las aplicaciones nativas provistas por Android como las desarrolladas por terceras partes. Inicialmente. clases auxiliares.o La capa de Aplicaciones es la última capa del software. 5. Cuando creamos un nuevo proyecto Android en Eclipse se genera automáticamente la estructura de carpetas necesaria para poder generar posteriormente la aplicación. siempre bajo la estructura del paquete java definido. Esta estructura será común a cualquier aplicación. han sido construidas en esta capa y utilizando las mismas API´s y bajo el mismo lenguaje de programación. En la siguiente imagen vemos los elementos creados inicialmente para un nuevo proyecto Android: En los siguientes apartados describiremos los elementos principales de esta estructura. Java. Estructura de una aplicación Android Para empezar a comprender cómo se construye una aplicación Android vamos a echar un vistazo a la estructura general de un proyecto tipo. independientemente de su tamaño y complejidad. Carpeta /src/ Contiene todo el código fuente de la aplicación. etc. Eclipse creará por nosotros el código básico de la pantalla (Activity) principal de la aplicación. 25 . código de la interfaz gráfica. Todas ellas.4.

para un proyecto nuevo Android. Como ejemplo. colores (colors. Contiene la definición de los menús de la aplicación. Contiene recursos adicionales. Los diferentes tipos de recursos de deberán distribuir entre las siguientes carpetas: Carpeta Descripción /res/drawable/ Contienen las imágenes de la aplicación. Contiene otros recursos de la aplicación como por ejemplo cadenas de texto (strings. Contiene los ficheros XML utilizados por la aplicación. vídeos. que no se incluyan en el resto de carpetas de recursos. etc. Para utilizar diferentes recursos dependiendo de la resolución del dispositivo se suele dividir en varias subcarpetas:  /drawable-ldpi   /res/layout/ Contienen los ficheros de definición de las diferentes pantallas de la interfaz gráfica.xml).xml). cadenas de texto. normalmente en formato distinto a XML.Carpeta /res/ Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes. se crean los siguientes recursos para la aplicación: 26 . estilos (styles. Para definir distintos layouts dependiendo de la orientación del dispositivo se puede dividir en dos subcarpetas:   /res/anim/ /res/menu/ /res/values/ /res/xml/ /res/raw/ /drawable-mdpi /drawable-hdpi /layout /layout-land Contiene la definición de las animaciones utilizadas por la aplicación. etc.xml).

icon contendrá el ID de la imagen “icon.java. class string { final int app_name=0x7f040001. el fichero R. Esta clase R contendrá en todo momento una serie de constantes con los ID de todos los recursos de la aplicación incluidos en la carpeta /res/. Así. la constante R. final int hello=0x7f040000. y la clase R.drawable. Veamos como ejemplo la clase R creada por defecto para un proyecto nuevo: public final class R { public static final } public static final public static } public static final public static } public static final public static public static } } class attr { class drawable { final int icon=0x7f020000. de forma que podamos acceder fácilmente a estos recursos desde nuestro código a través de este dato.Carpeta /gen/ Contiene una serie de elementos de código generados automáticamente al compilar el proyecto.png” contenida en la carpeta /res/drawable/. El más importante es el que se puede observar en la imagen. Cada vez que generamos nuestro proyecto. la maquinaria de compilación de Android genera por nosotros una serie de ficheros fuente en “java” dirigidos al control de los recursos de la aplicación. por ejemplo. 27 . class layout { final int main=0x7f030000.

Está clase puede ser equivalente a lo que es un formulario en la arquitectura web. según el tipo de componente que se decida a usar. Usaremos uno u otro según las necesidades de nuestra aplicación. será una extensión de la clase Activity.xml Contiene la definición en XML de los aspectos principales de la aplicación. ya que en función de éstos la clase que se desarrolle heredará las características del componente. Para los segundos sin embargo no se generarán ID y se podrá acceder a ellos por su ruta como a cualquier otro fichero del sistema. …). Veremos más adelante más detalles de este fichero.Carpeta /assets/ Contiene todos los demás ficheros auxiliares necesarios para la aplicación (y que se incluirán en su propio paquete). en cuanto a la aplicación se refiere. Y para dicha presentación se sirve de Views. de datos. como por ejemplo ficheros de configuración. Estos componentes son los que van a identificar y caracterizar a la aplicación que se llegue a crear. icono. para poder realizar la interfaz con la cual el usuario podrá interactuar. versión. y por lo tanto pueden existir diferentes formas de comportamiento. Cualquier pantalla que se muestre al usuario. A la hora de construir una aplicación en Android. hay que tener en cuenta que dicha aplicación puede estar compuesta de un tipo específico de componente o de la combinación de ambos. La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidos en la carpeta /assets/ es que para los primeros se generará un ID en la clase R y se deberá acceder a ellos con los diferentes métodos de acceso a recursos. como por ejemplo su identificación (nombre. o los permisos necesarios para su ejecución. En el siguiente apartado veremos los componentes software principales con los que podemos construir una aplicación Android. sus componentes (pantallas. etc. …). debido principalmente a que es la capa de presentación para todo tipo de aplicación. Fichero AndroidManifest. mensajes. 28 . Los diferentes tipos de componentes con los cuales podemos crear aplicaciones en Android son los siguientes:  Activity Es el componente más importante en cualquier aplicación Android.

La clase Services al contrario que la Activity. es que permite a cualquier aplicación acceder a los datos que están siendo utilizados por otras aplicaciones a la vez. la aplicación que se crea. es decir. realizando cualquier tipo de procedimiento que está obligado a realizarse sin la necesidad de que sea visible al usuario. no interactúa para nada con el usuario. 29 . Services Este componente.5. que se utiliza para determinar el objetivo de la aplicación. son las clases que se ejecutan en background. puesto que las Activities. La gran ventaja que presenta este tipo de componente. 5. En última instancia. Un claro ejemplo puede ser la gestión de las llamadas entrantes que recibe el dispositivo móvil. y es completamente invisible a los ojos del usuario.  Content Provider Los Content Provider. También permiten que cualquier aplicación almacenen los datos en un fichero o cualquier otro formato.  Intent Un Intent. que este componente “corre” por debajo. su propósito. está a la escucha de cualquier Intent proveniente de distintas aplicaciones. en un segundo plano. Ciclo de vida de una aplicación en Android Los componentes que forman las aplicaciones en Android. se utilizan para lanzar eventos provenientes de cualquier tipo de Intent. La principal peculiaridad es la forma en la cual los Intent describen la tarea que se va a llevar a cabo y los datos necesarios para realizarla. la aplicación puede empezar automáticamente y responder al Intent que está a la escucha. Se puede decir que la aplicación está a la escucha de un evento para llevar a cabo la acción a la cual está predestinada. es un simple mensaje. Al utilizar este componente. son principalmente utilizados para gestionar y almacenar las bases de datos de la aplicación. es totalmente opuesto al anteriormente explicado. es el sistema el que finalmente decide cual será el más indicado para realizar sus acciones. realizan los cambios de vista o de interfaz por medio de los Intent. está muy ligado al Activity. tienen bien definido un ciclo de vida de manera que se puede saber en cualquier momento en que estado está la aplicación para poder gestionar los flujos de ésta en función de su estado. Generalmente las aplicaciones que utilizan esta clase. Este componente.  Broadcast Receivers Con esta clase. Se puede decir prácticamente. La clase Service por así decirlo.

es el del componente Activity. arrancarlas o pararlas en función de los recursos que la aplicación necesite. cuyo diagrama es el siguiente: 30 . Android aísla totalmente al usuario del dispositivo de la labor que el sistema operativo está realizando para poder ejecutar la aplicación que el poseedor del teléfono desee. A diferencia de otros entornos. ésta se lleva a cabo en su propio proceso. los componentes de los que está formada dicha aplicación están al tanto de los cambios de estado que ésta pueda generar. de tal modo que Android es el encargado de gestionar todas las aplicaciones.A la hora de ejecutar una aplicación en Android. En cambio. las aplicaciones en Android. de tal manera que el proceso es consciente del estado en cual se ha quedado para que en un futuro vuelva a dicho estado cuando el sistema le conceda el mando. De modo que durante la ejecución puede suceder que una actividad pare mientras otra sea lanzada. no tienen el control sobre su propio ciclo de vida. El caso más conocido de ciclo de vida. Android ejecutará tantos procesos en función de los recursos que tenga disponibles. los cuales pueden estar a la vez formados por más de una actividad (Activity).

Como se puede observar en la figura anterior. los diferentes estados que conforman el ciclo de vida de una actividad son los siguientes:  onCreate: Es el estado en el cual da comienzo el ciclo de vida de la aplicación. Es similar al estado onPause.  onDestroy: Estado en el que se da por finalizado el ciclo de vida. 31 .  onStart: Junto con el estado onStop forman el conjunto de estados en los cuales se maneja la actividad desde su comienzo.  onStop: Es el estado en el cual permanece la actividad cuando ésta no tiene el mando para realizar sus procesos.

ambos estados acotan el ciclo de vida de la actividad en función del foco de atención dispensado a la aplicación. su flujo concluye cuando ésta finalice o cuando otra actividad necesite los recursos que la aplicación está consumiendo. onPause: Similar al estado anteriormente descrito. son componentes de tipo Activity que son visibles pero no están al mando.  Componentes Services que se ejecutan tras un evento proveniente de una aplicación que se crea. A la hora de programar una aplicación hay que tener en cuenta la prioridad que se le va a asignar puesto que en función de la prioridad la aplicación puede morir durante un proceso de ejecución importante. Este tipo de prioridad corresponde a:  Activities que se encuentran en un estado activo y que están respondiendo continuamente a eventos del usuario. 32 . La preferencia por parte de Android a la hora de priorizar determinadas aplicaciones en función de otras se debe en gran parte al tipo de componente que lo forma. Son los procesos cuya importancia es crítica. Procesos visibles. Este tipo de procesos no son matados a menos que sean necesarios los recursos de los que dispone. Services o Broadcast Recivers. 2. Prioridad de procesos Una vez visto el ciclo de vida de una aplicación en Android. Son aquellos que están albergados en aplicaciones que están continuamente estableciendo contacto con el usuario. Son aquellas aplicaciones cuyo principal componente de aplicación es un Service.  Activities. en gran parte a que este tipo de procesos no están continuamente interactuando con el usuario y a que son consideradas actividades que transcurren en un segundo plano. y que generalmente son liquidados en última estancia.5. Procesos de servicio. 5. que se están ejecutando cuando reciben un evento. En extraños casos son matadas. La actividad permanece en este estado cuando ésta no recibe el foco de atención por parte del sistema. ya que una aplicación puede ser más prioritaria respecto de otra. de mayor a menor prioridad: 1. La importancia en cuanto a procesos se refiere es la siguiente.  onResume: Al igual que el estado onPause.1. comienza o se destruye. y concretamente cuando una aplicación se crea. y tienen menor prioridad que un Activity. 3. Como su propio nombre indica. Procesos activos.

4. Procesos de segundo plano. A diferencia de los anteriores, son procesos que
corren en un segundo plano y que no disponen de ningún servicio.
5. Procesos vacíos. Son aquellos procesos que se mantienen en cache para un
posterior relanzamiento.

5.6.

Herramientas para el desarrollo

En este apartado se va a comentar las herramientas y los pasos necesarios para
poder desarrollar aplicaciones en Android.
Es necesario conocer el sistema operativo así como el procesador sobre el cual
se va a instalar el conjunto de herramientas necesarias. Este procedimiento es
importante porque a la hora de instalar la SDK de Android, existen una serie de
necesidades que no hay que pasar por alto. La SDK de Android es totalmente
compatible con los principales sistemas operativos que existen en el mercado, es decir,
Windows, Mac y Linux. A continuación es necesario disponer de una JDK, disponer a
su vez del IDE de desarrollo Java Eclipse.
Procedimientos para instalar las herramientas.

5.6.1. Instalación de Eclipse
Si nuestro PC no dispone de un entorno de desarrollo compatible con Android
SDK, recomendamos descargar Eclipse 3.4 (Ganymede), en la web oficial de Eclipse:
http://www.eclipse.org/downloads.
No nos vamos a parar mucho en cómo instalar Eclipse ya que no es la finalidad
de nuestro proyecto, simplemente vamos a explicar los pasos básicos para tenerlo
funcionando en nuestro equipo.

33

Seleccionamos Eclipse Classic 3.7.2 para Windows, Linux o Mac, dependienfo
del Sistema Operativo que tengamos y nos los descargamos en nuestro equipo.
Descomprimimos el archivo .zip en el directorio que hemos seleccionado y ejecutamos
el archivo eclipse.exe que se encuentra en la carpeta eclipse descomprimida.
Finalmente, elegimos un espacio de trabajo donde elaborar nuestros proyectos.

5.6.2. Instalar SDK Android
Bien, una vez que hemos cumplido los requisitos del apartado anterior, nos
dirigimos al website dedicado para Android:
http://developer.Android.com/sdk/index.html

Y una vez allí, nos descargamos la SDK en función de nuestro sistema
operativo, bien puede ser Windows, Mac o Linux. A continuación, descomprimimos el
archivo en cuestión, teniendo en cuenta la ruta en la cual se ha descomprimido dicho
archivo.
Concluido el proceso de instalación de la SDK, se procede a la instalación del
plugin necesario para Eclipse.

5.6.3. Instalar plugin de Android para Eclipse
Ahora, el siguiente paso es iniciar Eclipse, para que de este modo podamos
incluir el plugin necesario de Android, y así incluir la herramienta ADT (Android
Development Tools) la cual permitirá crear proyectos de Android, debuggarlos y
ejecutarlos.
Abierto el IDE Eclipse, en la pestaña Help->Install New Software… y en la
ventana nueva que aparece, pulsar el botón Add.

34

De nuevo aparecerá una nueva ventana en la cual en los campos Name se pude
introducir por ejemplo ADT y en el campo Location la siguiente URL:
https://dl-ssl.google.com/Android/eclipse/

Y una vez realizado, pulsar el checkbox o el botón Select All y pulsar Next.

35

Y a partir de ahí comenzará a descargarse el software necesario para comenzar a
desarrollar aplicaciones.
Por último Eclipse pedirá que se reinicie, para poder configurar los cambios
realizados.

5.6.4. Completar la instalación
Tras reiniciar Eclipse, los siguientes pasos a realizar son:

Referenciar SDK

Para poder crear proyecto, debemos referenciar la SDK en la pestaña Windows>Preferentes->Android->Browse y buscar el path sobre el que se encuentra la SDK.

Y en último lugar pulsar Apply y Ok.

Descargar los targets necesarios

Además del SDK de Android, también debemos descargar los llamados SDK
Targets de Android, que no son más que las librerías necesarias para desarrollar en cada
una de las versiones concretas de Android. Así, si queremos desarrollar por ejemplo
para Android 1.6 tendremos que descargar su target correspondiente. Para ello, desde
Eclipse debemos acceder al menú Window ->Android SDK Manager, y en la sección
Packages seleccionar e instalar todos los paquetes deseados.

36

Configurar emulador AVD y actualizar plugin

A la hora de probar y depurar aplicaciones Android no tendremos que hacerlo
necesariamente sobre un dispositivo físico, sino que podremos configurar un emulador
o dispositivo virtual (Android Virtual Device, o AVD) donde poder realizar fácilmente
estas tareas. Para ello, nos vamos a Windows->ADV Manager y en la sección Virtual
Devices podremos añadir tantos AVD como se necesiten (por ejemplo, configurados
para distintas versiones de Android).

A continuación, pulsamos sobre el botón New, y aparecerá la siguiente ventana.

37

Para configurar el AVD tan sólo tendremos que indicar un nombre descriptivo. o la disponibilidad de GPS. el tamaño de la tarjeta SD. 38 . como por ejemplo su resolución de pantalla. el target de Android que utilizará. Y por ultimo comenzará un proceso de actualización de la SDK. y las características de hardware del dispositivo virtual.

dispone de distintos tamaños de pantalla. en cuanto a rapidez y latencia respecto a las aplicaciones. obviamente simulados. A través del puerto 5554 se puede entablar todo tipo de órdenes con el emulador.6.5. de modo que sólo son de lectura y obtienen información sobre la manera de ejecutarse éste.5. resoluciones. Éste a su vez.2. Además de proveer de una buena conexión a Internet. 5. 5. Al igual que las imágenes que simulan almacenamientos extraíbles.6. De estas herramientas cabe destacar la Dalvik Debug Monitor Service o DDMS. éstas permiten escribir además de la posibilidad de leer de la imagen correspondiente. al apagar o cerrar el emulador. 39 . es para hacer las labores de caché y para realizar una copia del sistema. dispone de una variedad de posibles maneras de mostrarse como interfaz gráfica.5.6. Otras funcionalidades del emulador Dentro del emulador. Las diferentes tipos de imagen son los siguientes:  Imagen de sistema: son el tipo de imagen necesaria para que el emulador pueda arrancar. flash o de otro tipo. se eliminan por completo.  Imagen de runtime: a diferencia de las anteriores. Y la utilidad que tienen. y de permitir recibir llamadas y SMS. El cual es una propia máquina virtual destinada a ejecutar las aplicaciones de Android. existen otras herramientas que facilitan la programación de cualquier aplicación en Android.1. existe una funcionalidad que permite al emulador de Android contactar y realizar operaciones mediante una conexión Telnet.  Imagen temporal: la característica principal de estas imágenes es que al acabar la ejecución. También existen otro tipo de funcionalidades no menos importantes pero que merecen la pena describirlas. testear y analizar las propias aplicaciones. es decir. incluye diversas herramientas y utilidades que permiten al usuario poder crear. es decir. es por ello la manera más cercana de poder conocer cómo sería un dispositivo móvil con dicho sistema operativo. Otra herramienta que aporta la SDK es el emulador.5. Como añadido a las características anteriormente habladas. como pueden ser aplicaciones instaladas. Otras herramientas útiles Como bien se ha podido apreciar en el apartado anterior la SDK de Android. existe la posibilidad de poder utilizar imágenes que puedan simular memorias internas. Dalvik Debug Monitor Service Aparte del emulador. Y principalmente se utilizan para guardar datos de la sesión.

es una herramienta que mediante una arquitectura cliente servidor permite conectarte desde tu máquina al dispositivo Android. ejecutar los posibles comandos. la Android Debug Bridge o ADB.5. Para poder utilizar las utilidades que nos facilita esta herramienta. el emulador. basta con acceder mediante la línea de comandos hasta el path en el que se encuentra la SDK. pero realmente no sabes lo que realmente está pasando dentro. De este modo. se tiene una versión fidedigna de la ejecución de la aplicación. 40 . y acceder a la carpeta tools y una vez allí. la DDMS es una herramienta que permite “debutar” la aplicación y conocer en todo momento que está sucediendo dentro de los entresijos de la aplicación que se está ejecutando. Para poder acceder a esta herramienta basta con pulsar la pestaña Window-> Open Perspectiva-> DDMS. y la simulación de envío de SMS así como de llamadas entrantes y geolocalización. Android Debug Bridge Para finalizar. conocer de manera primordial la gestión de recursos.En primera instancia. te permite ver qué aspecto presenta la aplicación. instalar aplicaciones o ejecutar comandos para acceder a la shell.6. porque se pueden acceder a los log.3. con esta herramienta. Y aparecerá una perspectiva similar a la siguiente imagen: 5. De esta manera. cómo se comporta y poder interactuar con la misma. Esta herramienta te permite copiar archivos.

 adb reboot: comando con el que se reinicia el emulador. con él.De entre esos comandos. Como por ejemplo.apk). nos descargamos archivos desde el dispositivo a la máquina.apk]: con este comando. los más comunes son los siguientes:  adb shell: con este comando se puede acceder al directorio root del terminal y desde ese punto se podrán lanzar diversos comandos contra el dispositivo. indicándole sólo la ruta desde donde se encuentra el paquete compilado de la aplicación(.  adb install [path/aplicacion. se permite instalar aplicaciones en el dispositivo.  adb pull [remoto][local]: el comando contrario al anterior. 41 .  adb push [local][remoto]: con este comando se pueden enviar archivos al dispositivo desde nuestra propia máquina. acceder al sistema para poder borrar las aplicaciones instaladas.

Manual de usuario 42 .6.

 LUGAR: Hace referencia a un sitio en concreto donde el usuario ha estado durante el viaje. parques. es decir todos aquellos lugares de interés que el usuario crea conveniente recordar durante el viaje o eventos que se han producido durante el viaje como el encuentro con unos amigos. a las que se acceden desde las pestañas que se encuentra en la parte superior de la pantalla. restaurantes.6.1. tal como puede observarse en la figura 6.2. esta lista está vacía.. 6. estancia en un concierto. Este concepto puede hacer referencia a monumentos. La pestaña “Viajes” muestra una lista de los viajes que el usuario ha realizado. tanto de forma escrita con comentarios. edificios. como de forma visual con fotografías y posiciones geográficas representadas en un mapa de los lugares en los que ha estado.. La primera vez que se usa la aplicación.. En definitiva la idea es tener una aplicación que permita acceder fácilmente y tenga ordenada toda la información que el usuario ha guardado de un viaje. museos. Conceptos básicos de la aplicación:  VIAJE: Periodo de tiempo continuo durante el cual el usuario se encuentra en un lugar o en varios lugares. El objetivo principal de la aplicación es que el usuario pueda documentar los viajes que realiza. 43 . Ventana de la Lista de Viajes (Ventana Principal) Una vez se tiene instalada la aplicación en el móvil el usuario puede acceder a ella.1. Presentación del Proyecto “DIARIO DE VIAJE” es una aplicación que está desarrollada para que el usuario pueda almacenar información sobre un viaje que ha realizado y todos los lugares que ha visitado durante el viaje.. etc. La pantalla principal está dividida en dos partes.

Se tiene la opción de desplegar un menú contextual al dejar pulsado durante un instante uno de los viajes. si éste ha finalizado no se pueden modificar sus datos. apareciendo las siguientes opciones:  Editar: Si se marca esta opción se pueden modificar los datos del viaje seleccionado. el viaje que se encuentra activo debe tener la “Fecha Fin” inferior o igual a la fecha actual. si no la aplicación mostrará una ventana emergente que comunicará que no se puede iniciar un nuevo viaje y que debes cerrar antes el viaje que está activo. 44 . una vez que se supera esa fecha el viaje automáticamente cambiara su estado a “Finalizado”. la aplicación solo permite que haya un viaje “En curso” y este debe ser en tiempo real. es decir. Desde esta misma ventana se tiene la opción de poder crear un nuevo viaje pulsando el botón “+ Nuevo Viaje” siempre y cuando no haya ningún viaje “En curso”.Cada elemento de la lista corresponderá con un viaje realizado.2. el cual contendrá la siguiente información:    Nombre del viaje Fecha de inicio y fin del viaje Estado del viaje El estado del viaje indica si un viaje se ha realizado o se está realizando.  Eliminar: Se eliminará el viaje seleccionado. ver figura 6. con la limitación de que el viaje tiene que estar activo.

Se puede estar visitando una ciudad o un sitio cuyo nombre sea menos especifico. donde en este caso las ciudades que se visitan 45 . es la de salir de la aplicación. Además podemos cambiar a la pestaña “Fotos” la cual nos muestra un determinado número de carpetas. como puede ser un viaje por la costa del sol. Cada carpeta nos muestra todas las fotos que se han realizado en un viaje. y muestra un formulario que debe rellenar el usuario. Esta acción es irreversible. El usuario es quien según su criterio pondrá nombre al viaje. Finalizar Viaje: Se tiene la opción de finalizar un viaje en cualquier momento. una por cada viaje realizado. Si se selecciona esta opción el viaje pasará al estado “Finalizado”. Los campos del formulario son los siguientes:  Nombre: Dará nombre al viaje y será el nombre que aparece en la lista de viajes de la pantalla principal. y se cambiar la fecha de final del viaje que aparece en la lista por la fecha actual. Ventana de “Nuevo Viaje” A esta ventana se accede al pulsar el botón “+ Nuevo Viaje” de la pantalla principal. si se finaliza un viaje no podrá volver a estar activo. La única opción que aparece en esta ventana al pulsar el botón “ménu” que contienen todos los dispositivos con el sistema operativo Android. dependiendo de qué tipo de viaje se está realizando. 6.3. Véase la figura 6.4. aunque en un principio se hubiera puesto una fecha de final del viaje superior.

si es para la creación de un nuevo viaje que se quiere realizar o es para actualizar los datos de un viaje en curso.4.3 y 6.corresponderán con los lugares visitados del viaje. y el usuario modificaría los que creyera convenientes.  Fecha Fin: Corresponderá con la fecha en la que finalizará el viaje. Por último se tiene el botón “Crear” o “Actualizar” dependiendo como se haya accedido a está ventana. En caso de que se produjera alguno de estos dos casos explicados no se permitiría crear el viaje.  Fecha Inicio: Corresponderá con la fecha en la que se inicia el viaje. Véase las figuras 6. en este último caso el formulario aparecería con los datos actuales del viaje. 46 . o por el contrario el viaje corresponde con una ciudad y seria el nombre del viaje. la nueva fecha de fin del viaje corresponderá con la actual. Los dos campos relacionados con las fechas (Fecha Inicio y Fecha Fin) cumplen los siguientes dos requisitos:  Ni la Fecha Inicio ni la Fecha Fin pueden ser menor que la fecha actual. en caso de que el usuario decida finalizar el viaje antes de llegar a esta fecha. y se le comunicaría al usuario para que introdujese las fechas correctas.  La Fecha Fin no puede ser menor que la Fecha Inicio.

y que contiene las siguientes opciones:  Editar: Si se marca esta opción se pueden modificar los datos del lugar seleccionado.6. Véase figura 6.6. antes se pedirá una confirmación mediante una ventana emergente. Véase figura 6. para tener más información si el usuario lo desea. La selección de la foto se realiza mediante un menú contextual.  Añadir Foto: Esta opción permite al usuario seleccionar una foto y asignarla al lugar seleccionado de la lista. dejando pulsado un lugar de la lista que despliega un menú similar al de la pantalla principal. Ventana de la Lista de Lugares Esta ventana muestra una lista de los lugares que se han visitado en un viaje. La lista de lugares que se muestra en esta ventana consta del nombre del lugar.4. Para acceder a ella hay que seleccionar un viaje de la lista en la pantalla principal. si es un viaje ha finalizado no se pueden modificar sus datos. con la limitación de que el viaje tiene que estar activo. la fecha en la que se estuvo y una fotografía del lugar que el usuario tiene la opción de poner en la lista.5.  Eliminar: Se eliminará el lugar seleccionado. 47 . Al seleccionar esta opción se abre la galería de fotos que se tenga instalada en el móvil donde aparecen todas las fotos realizadas por el usuario no solo con esta aplicación y este buscaría alguna foto realizada en ese lugar para añadirla a la lista.

8. esta vista se explicara a continuación. Existe un botón en la ventana llamado “+ Nuevo Lugar” que al pulsarlo lleva al usuario a una ventana con un formulario que al rellenarlo permite añadir un nuevo lugar que se visitará durante el viaje. en esta vista también se puede desplegar un menú. él cual permite cambiar la capa del mapa a la de “satélite”. Véase figura 6. Quitar Foto: Es la opción que permite al usuario quitar alguna foto que se hubiera seleccionado.7 y 6. 48 . Durante esta pantalla si el usuario pulsa el botón “menú” del móvil se despliega un menú inferior que permite por un lado volver a la pantalla principal (Lista de Viajes) y por otro lado cambiar la vista de la ventana a la de “mapa”. esta última opción abre un mapa sobre el cual aparecen marcadas las posiciones de todos los lugares que el usuario a visitado durante el viaje.

49 .Las posiciones de los lugares visitados aparecen marcadas sobre el mapa con un icono y corresponde con las coordenadas de cada lugar visitado que se han obtenido mediante el GPS del móvil. fecha. Al pulsar sobre uno de los marcadores se despliega una ventana que indicará al usuario el lugar que es mediante su nombre y la opción de ir a la ventana de ese lugar visitado con información más detallada..9. Véase figura 6... fotos. nombre.. esto se explicará posteriormente en este apartado.

Ventana de “Nuevo Lugar” Es la ventana que permite crear un nuevo lugar que se va a visitar durante el viaje. se accede a ella desde la ventana que contiene la lista de los lugares visitados en un viaje.  Descripción: Se da la opción al usuario si lo desea de poder dar una breve descripción para tener información del lugar que se va a visitar. Los campos del formulario son los siguientes:  Nombre: Nombre del lugar. Una vez que el usuario puede ver la posición representada en el mapa se le da opción de aceptar si está de acuerdo con la posición. Al pulsarlo se accede a un mapa que contiene un botón en la parte superior derecha que hay que pulsar para obtener la posición actual del usuario y que esta sea representada en el mapa.11.6. Véase figura 6.  Ubicación: Este botón permite obtener las coordenadas del lugar mediante el GPS del móvil.10. Véase figura 6. es el que aparecerá en la lista de lugares y en la información detallada del lugar. La ventana contiene un formulario que se rellena con información del lugar.5. Si el usuario acepta se utilizaran las coordenadas para marcar el lugar en el mapa explicado en el apartado anterior. 50 .

En la primera pestaña que nos encontramos. 6. se mostrará una pantalla que consta de las pestañas descripción. Es la misma foto que asociamos a la lista de lugares. como son:  Nombre: Nombre del lugar. Ventana “Lugar” Al crear o seleccionar un lugar.6. 51 . el contenido que la wikipedia contiene del lugar y las fotografías realizadas por el usuario del lugar. También incluyen dos opciones en el menú:  Home: Para ir a la pantalla principal  Cámara: Para acceder a la cámara y poder añadir fotos que se asignaran al lugar que hemos abierto.Al pulsar el botón “Crear” se añadirá un nuevo lugar visitado al viaje y se pasara a la ventana de ese nuevo lugar donde se podrá obtener información más detallada. se mostrarán algunos de los datos que hemos rellenado al crear el lugar.12.  Imagen: Imagen del lugar. Esta fecha está comprendida entre la fecha de inicio y fecha final del viaje. como comentarios sobre el lugar. denominada “descripción”. Véase figura 6. wikipedia y fotos. Esta fecha es tomada automáticamente por la aplicación cuando es creado el lugar.  Fecha: Fecha en la que hemos visitado el lugar.

En el caso de no ser correcta la información. opiniones o datos de interés del lugar mediante el botón “+ Comentario”. Ver la figura 6. Descripción: Breve descripción del lugar que el usuario puede introducir si lo desea. La segunda pestaña. si el usuario está de acuerdo con la información que se muestra podrá aceptar. 52 . que se irán añadiendo a una lista de comentarios. con las siguientes opciones:  Editar: Esta opción permite modificar el comentario seleccionado. entonces el enlace se guardará de forma automática y a partir de ahora será el que se muestre siempre que decidamos volver a consultar esta pestaña. el usuario tendrá la opción de buscar el enlace adecuado y confirmarlo. Ver la figura 6. “wikipedia” nos muestra el artículo que la enciclopedia libre tiene del lugar que hemos seleccionado anteriormente. Al mantener pulsado un comentario se desplegará un menú contextual. la aplicación nos preguntará si la información mostrada es correcta.  Eliminar: Se borrará el comentario seleccionado.13. Cada vez que accedemos a esta pestaña y hasta que no obtengamos confirmación por el usuario.14. En esta pantalla podemos ir añadiendo comentarios.

“Fotos” muestra una galería de fotos. la tercera pestaña.Y por último. Ver figura 6. 53 . si se selecciona una foto de la galería esta se muestra en la pantalla. pasado un breve periodo de tiempo los botones desaparecen pudiendo volver a pulsar en la fotografía para que aparezcan. que son todas las fotos que el usuario realizo de ese lugar accediendo a la cámara desde esta misma ventana. Cuando una imagen se está visualizando en la pantalla se puede pulsar en ella y aparecen dos botones que le dan la opción al usuario de rotar la fotografía a la derecha o a la izquierda.15.

Diseño e implementación 54 .7.

los componentes que hemos usado para desarrollarla. restaurantes. El controlador. parques.. mostraremos la estructura interna. Y por último el modelo. estancia en un concierto.. además de que ya viene incorporada con el SDK de Android.. etc.1. La aplicación está diseñada para que se almacene información sobre uno o varios lugares visitados durante un periodo de tiempo determinado por el usuario y posteriormente se pueda acceder a esa información. esta parte es la que responde a eventos e interacciones por parte del usuario de la aplicación.. Este concepto puede hacer referencia a monumentos. 55 .XML” y en determinados momentos cuando es necesario modificar algo de la vista de forma dinámica hacemos uso de código Java. que sería el funcionamiento de la aplicación.7. Diseño En este apartado explicaremos el diseño de nuestra aplicación. que los almacenaremos en una Base de Datos. que sería la interfaz. así como la forma en que estos se unen y comunican entre sí.  LUGAR: Hace referencia a un sitio en concreto donde el usuario ha estado durante el viaje. el funcionamiento y los datos de la aplicación están separados en partes distintas y unidos mediante código. La vista. La aplicación permite mantener ordenados los viajes que se realizan y acceder fácilmente a toda la información que contienen. consultando en cualquier momento todo aquello que el usuario guardó durante el viaje. museos. Se vuelven a recordar en este capítulo los conceptos básicos de la aplicación:  VIAJE: Periodo de tiempo continuo durante el cual el usuario se encuentra en un lugar o en varios lugares. edificios. está compuesta básicamente por archivos “. es decir todos aquellos lugares de interés que el usuario crea conveniente recordar durante el viaje o eventos que se han producido durante el viaje como el encuentro con unos amigos. cuyas ventajas para este tipo de proyectos (proyecto para dispositivo móvil) son varias. por lo que la interfaz. en nuestro caso nos hemos decidido por SQLite3. está desarrollado por completo en Android (entendiendo que aquí se usa el lenguaje Java con todos sus método y clases si es necesario). entre las que destacan el hecho de no tener que hacer uso de un servidor y el poco espacio que necesita. que hace referencia a los datos usados. Hay que destacar que Android se caracteriza por usar el patrón MVC (Modelo Vista Controlador).

con la condición de que no puede haber ninguno activo al iniciar uno nuevo ya que esta aplicación está pensada para viajes en tiempo real. por lo que la fecha de fin pasara a ser la actual y el viaje pasara al estado de “Finalizado”. 56 .Toda la aplicación gira en torno a estos dos conceptos que están relacionados entre sí y a los que se les va añadiendo información. sólo podremos consultarlo. Si el usuario incumple alguna condición será advertido mediante una notificación. este formulario recoge:    Nombre del viaje: el usuario dará el nombre que crea que mejor representa a ese viaje. es decir. con la condición como ya se ha comentado anteriormente. es decir. Por lo tanto. Se pueden crear todos los viajes que el usuario quiera realizar. Fecha de inicio y fin: Periodo de tiempo durante el cual se estará viajando. Además el usuario tiene la opción de finalizar el viaje activo en el momento que desee. aunque el usuario puede modificar estas fechas. o que la fecha final sea menor que la fecha inicial. como la de que no puede crear un viaje nuevo con la fecha de inicio inferior a la actual. Con la creación de un “viaje” nuevo se recopila información general de éste por parte del usuario a través de un formulario. y no podremos añadirle imágenes ni ningún tipo de información. se puede seguir recopilando información sobre éste. Descripción: Se dará una breve descripción del viaje. que solo puede haber un viaje activo. Dentro de un viaje se van añadiendo los distintos lugares que el usuario ha visitado. un viaje tiene dos estados:  Finalizado: cuando un viaje ha terminado. debido a que el viaje se ha acortado por cualquier motivo. respetando ciertas condiciones. el usuario va recopilando información en el mismo momento en que está viajando.  En curso: cuando un viaje está activo.

se trata de un sistema de gestión de bases de datos relacional. Una vez que el GPS ha obtenido la posición se pide confirmación al usuario de la posición para que esta sea almacenada. Para la información almacenada en la aplicación se ha utilizado la base de datos SQLite3.  MAPA: Muestra la posición del lugar sobre un mapa.Una vez que se tiene un viaje activo se pueden añadir los distintos lugares o eventos que se van realizando durante el viaje. Como ya se ha comentado. La primera parte que recoge información es un formulario en el que se deben rellenar los siguientes campos:  Nombre: es el nombre del lugar que estamos visitando. esto es así porque como ya se ha comentado la aplicación está pensada para que sea en tiempo real. El programa utiliza la funcionalidad de SQLite a través de 57 .  Descripción del lugar: algo genérico que describa el lugar. para que el usuario pueda recordar su estancia teniendo toda la información ordenada y fácilmente accesible. En lugar de eso. El grueso de esta información corresponde con los lugares concretos visitados o los eventos que se han llevado a cabo:  FOTOS: Corresponde con las fotos que el usuario ha realizado del lugar. el motor de SQLite no es un proceso independiente con el que el programa principal se comunica.  COMENTARIO: Son los comentarios que ha realizado el usuario sobre el lugar que ha visitado y ha creído conveniente recordar. por lo que el usuario debe estar en el lugar que se añade. la idea de la aplicación es la recopilación de información sobre los lugares visitados.  WIKIPEDIA: Es la información que contiene la enciclopedia libre “wikipedia” sobre el lugar que se ha visitado y que la aplicación muestra en una de sus pestañas. ya que como se explicará más adelante el usuario tiene la opción de añadir todos los comentarios que desee del lugar visitado. la biblioteca SQLite se enlaza con el programa pasando a ser parte integral del mismo.  Posición del lugar mediante GPS: Se muestra de forma grafica a través de un mapa que marcará la posición actual del usuario. A diferencia de los sistemas de gestión de bases de datos cliente-servidor. incorporada en el SDK de Android. en el momento que quiere recopilar información del mismo. aquí es donde se recopila la mayor parte de la información.

En nuestro proyecto ha sido necesario crear 3 tablas para almacenar la información de los viajes realizados. En su versión 3. o fechaInicio: Fecha en la que se inicia el viaje. o descripción: Es una breve descripción del viaje. Esto reduce la latencia en el acceso a la base de datos. índices. son las siguientes:  Tabla NuevoViaje: Almacena la información relevante a un viaje. o activo: Indica si un viaje esta activo o no (sólo puede haber un viaje activo)  Tabla NuevoLugar: Almacena la información relevante a un Lugar. 58 . o id: Es la clave primaria y se autoincrementa al añadir un nuevo lugar. tablas. o nombre: Indica el nombre del lugar y es obligatorio rellenar este campo. Este diseño simple se logra bloqueando todo el fichero de base de datos al principio de cada transacción. debido a que las llamadas a funciones son más eficientes que la comunicación entre procesos. El conjunto de la base de datos (definiciones. Las tablas con sus respectivos campos. Con este campo relacionamos la tabla lugares con los viajes. o foto: contiene la ruta hacia la foto que se muestra. son guardados como un sólo fichero estándar en la máquina host.llamadas simples a subrutinas y funciones. y los propios datos). o wikipedia: Es la dirección web de la wikipedia donde se encuentra información relevante del lugar visitado. y también permite la inclusión de campos tipo BLOB. o descripción: Es una breve descripción del lugar. o ubicación: almacena las coordenadas GPS del lugar. que son elementos utilizados en las bases de datos para almacenar información de gran tamaño que cambian de forma dinámica. o idViaje: Es el identificador del viaje al que pertenece el lugar visitado. SQLite permite bases de datos de hasta 2 Terabytes de tamaño. o nombre: Indica el nombre del viaje y es obligatorio rellenar este campo. o fechaFin: Fecha en la que finaliza el viaje. o id: Es la clave primaria y se autoincrementa al añadir un nuevo viaje.

comentario TEXT NOT NULL. Estas tablas las hemos creado con el siguiente código SQL: CREATE TABLE NuevoViaje (id INTEGER PRIMARY KEY AUTOINCREMENT. fechaInicio DATE. foto TEXT. fechaFin DATE. CREATE TABLE NuevoLugar (id INTEGER PRIMARY KEY AUTOINCREMENT. 1:N 1 Viajes Visita Lugares 1 Escribe 1:N Comentarios 59 . nombre TEXT NOT NULL. o idLugar: Es el identificador del lugar al que pertenece el comentario. lugar TEXT. nombre TEXT NOT NULL. descripcion TEXT. o id: Es la clave primaria y se autoincrementa al añadir un comentario o comentario: es cada uno de los comentarios que podemos añadir en un lugar. wikipedia TEXT. idViaje INTEGER). Tabla Comentarios: Almacena los comentarios de los lugares visitados. idLugar INTEGER). CREATE TABLE Comentarios (id INTEGER PRIMARY KEY AUTOINCREMENT. Con este campo relacionamos la tabla comentarios con los lugares. activo INTEGER). descripcion TEXT.

Gallery. como ya hemos comentado en otro apartado de esta documentación. Deriva del lenguaje SGML y permite definir la gramática de lenguajes específicos (de la misma manera que HTML es a su vez un lenguaje definido por SGML) para estructurar documentos grandes. Estos objetos varían entre construcciones familiares como EditText. TimePicker y VideoView. TextView y Button hasta elementos más especializados como AnalogClock. Por otro lado también hablaremos del lenguaje de marcas extensibles XML (siglas en inglés de eXtensible Markup Language). la “fecha de inicio” y la “fecha fin” del viaje y por último el “estado” en que se encuentra el viaje. obviamente no vamos a mostrar todo el código porque no creemos que eso sea necesario y daremos por entendido la forma de cómo funcionan y son llamados los métodos del SDK de Android. Archivo main.2. En nuestro caso en concreto es muy utilizado en Android para realizar la interfaz. no será común mostrar el código completo de las clases que hemos implementado. ya que se explico en el apartado 5.com/apk/res/Android" 60 . si no lo normal será seleccionar la parte del código más relevante y es la que se explicará. Android proporciona un amplio conjunto de objetos View en el paquete Android. Comentaremos la parte del código que es la base de la aplicación. que es un lenguaje de marcas desarrollado por el World Wide Web Consortium (W3C).Android. Implementación En este apartado explicaremos y mostraremos parte del código de la aplicación.xml <?xml version="1. el software que hemos usado para implementarla. El software serán métodos y clases de Java y del SDK de Android.0" encoding="utf-8"?> <LinearLayout xmlns:Android="http://schemas. Comenzamos explicando la pantalla principal de la aplicación.LEYENDA Entidades fuertes Entidades débiles Entidades débil en existencia 7.view. así como de una forma genérica. Spinner. DatePicker. de la que destacamos la lista de “viajes realizados” que muestra el “nombre del viaje”. en curso o finalizado.

listas.xml se irán creando conforme sean necesarios. los demás archivos .xml. se encuentran dentro de un <LinearLayout> que es un componente que se usa para estructurar los elementos. en este caso Button y ListView se le da un identificador que será con el que se haga referencia cuando se quiere usar o modificar el elemento. clase principal DiarioDeViaje. de los dos componentes. como botones. Los dos primeros son métodos que incorpora el SDK de Android y que se corresponden con el ciclo de vida de una actividad. además se establece la disposición de los mismos mediante layout_width y layout_height que al igual que pasaba con <LinearLayout> determina el ancho y alto respectivamente. Como ya se ha dicho no profundizamos más en este aspecto porque no es un tema que corresponda a este apartado.Android:layout_width="fill_parent" Android:layout_height="fill_parent" Android:orientation="vertical" > <Button Android:id="@+id/nuevoViaje_button" Android:layout_width="fill_parent" Android:layout_height="wrap_content" Android:text="@string/nuevoViaje_label" /> <ListView Android:id="@+id/listaOpc" Android:layout_width="fill_parent" Android:layout_height="fill_parent </ListView> </LinearLayout > En primer lugar se modifica el archivo main. Todos los elementos que se verán en la interfaz. layout_height que establece el alto y orientation que establece la forma como se distribuyen los elementos dentro del boque. ya que es un estudio que no corresponde a este tema). cuadros. onStart() y cargarLista(). A cada elemento. etc. en este caso un botón y una lista de viajes (Button. ListView).java En esta clase destacamos los siguientes tres metodos que son onCreate(). los atributos más importante y los que normalmente se establecen son. Este tipo de archivo como ya se ha comentado es el encargado de generar la interfaz y los elementos que son necesarios para la pantalla. El último es un método privado que permite una mejor estructuración del código. Dentro del bloque necesitamos un botón para poder crear un nuevo viaje y una lista de elementos que será la que muestre los distintos viajes que el usuario vaya creando. en este caso concreto de forma vertical. 61 . decimos modificar puesto que este archivo se genera al crear el proyecto. layout_width que define el ancho que tomara el bloque (no hemos creído conveniente explicar los valores que se pueden establecer. Así como la disposición que tendrán en la pantalla.

nv = new NuevoViajeSQLiteHelper(this).get(Calendar. o simplemente se pulse un elemento de la lista. acción click sobre el elemento.getInstance(). por eso lo que hacemos es llamar al archivo main. La conexión con la base de datos y su uso se explicara más adelante en este apartado. necesarias en un método posterior. int dayActual = 0.get(Calendar. cargarLista().get(Calendar. listaOpciones. Estos son detalles que ya se explicaron en un apartado anterior aunque comentaremos algunas cosas muy brevemente en estos primeros métodos para situar al lector un poco mejor dentro del contexto.open(). Después de establecer la vista de la actividad se inicializan unas variables que se usaran para tener la fecha en la que nos encontramos actualmente.YEAR). monthActual++. } Este método es llamado cuando la actividad es creada por primera vez. int yearActual = 0.lista_viajes). Finalmente creamos el objeto necesario para acceder a la base de datos y lo abrimos para poder leer y escribir en ella. private ListView listaViajes = null. listaViajes = (ListView) findViewById(R. calend = Calendar. Inicializamos el elemento listaOpciones que es del tipo ListView para mostrar los viajes realizados e indicaremos la acción que deben llevar al acabo cuando se deje pulsado un elemento de la lista (dejar pulsado un breve instante de tiempo el elemento para que aparezca un menú contextual con distintas opciones).onCreate(savedInstanceState). public void onStart(){ super. setContentView(R.private private private private Calendar calend = null.layout. yearActual = calend.setOnItemClickListener(this). int monthActual = 0.xml para que se muestren los elementos creados por ese archivo en la actividad.MONTH). registerForContextMenu(listaViajes).id.onStart(). monthActual = calend. } 62 . /** Called when the activity is first created.DAY_OF_MONTH). nv. dayActual = calend.main). */ @Override public void onCreate(Bundle savedInstanceState) { super.

viajes = nv. si desde esta ventana se pulsa el botón “atrás” que poseen todos los dispositivos con Android se mostraría de nuevo la ventana que contiene la lista de los viajes que se ha realizados. y como el método cargarLista() se llama desde el método onStart() la lista aparecerá actualizad con el nuevo viaje creado. un método privado que es el encargado de listar los viajes en la pantalla.setAdapter(adaptador). nuevo.Este otro método onStart(). viajes). porque si hubiera sido llamado desde el método onCreate() los elementos de la lista no se actualizarían si esta pantalla volviera a estar en primer plano. if(!b){ nuevo. Una vez creado el ArrayLista lo inicializamos con todos los viajes que tenemos almacenados en la base de datos y a continuación los recorremos para comprobar cuál es el viaje que se encuentra activo en estos momentos y comprobar si ese viaje debe finalizarse o no debido a que haya superado la fecha en que finalizaba el viaje. es aquí donde llamamos al método cargarLista(). en este caso se rellenaría un formulario con los datos del viaje y se pulsaría el botón “crear” que te llevaría a una nueva ventana para añadir los lugares que se visitaran.update(nuevo). se llama justo a continuación del método onCreate() o cuando la pantalla vuelve a estar en primer plano porque ya había sido llamada anteriormente.selectAll(). private void cargarLista(){ viajes = new ArrayList<NuevoViajeBean>(). nv.selectAll(). Si es así 63 .getFechaFin()). En primer lugar creamos un ArrayList de NuevoViajeBean . esta parte corresponde al ciclo de vida de Android explicado en el apartado 5 de esta documentación. listaViajes. } El ultimo método que explicamos de la clase principal es cargarLista(). viajes = nv. que es un Bean. Boolean b = compararFecha(fechaActual.setActivo(0). Un ejemplo dentro de esta aplicación seria al crear un nuevo viaje.getActivo() == 1){ String fechaActual = dayActual + "/" + monthActual + "/" + yearActual. un objeto que nos ayuda a manejar los datos necesarios para crear un nuevo viaje. for(NuevoViajeBean nuevo: viajes){ if(nuevo. } } } Adaptador adaptador = new Adaptador(this. es decir. Debido a esto.

a la que le pasamos el array viajes y a continuación a la lista de viajes (listaViajes) le cambiamos mediante el método setAdapter() el adaptador que viene por defecto por el recién creado por nosotros.java. si no se mostrará como activo. ya que la información que devuelven es necesaria en caso de tener que manipular los distintos viajes que se realizan. De esta forma los viajes se finalizan de forma automática cuando se traspasa la fecha que puso el usuario como final del viaje. como ya se ha explicado. Aunque como se ve a continuación en el código también se encuentra el constructor que inicializa el contexto que hace referencia a la activity desde la que se llama a esta clase. ya que el objetivo no es hacer un manual de java si no usar java(concretamente el SDK de Android. ni siquiera a este proyecto. Son métodos de relativa importancia. El método getItem(int arg0) devuelve un objeto. si así lo deseara. ya que esto no corresponde a este apartado. 64 . getCount(). devolvería el Bean correspondiente con ese viaje. aunque se da la opción. para personalizar así la forma como se mostrarán los distintos elementos de la lista. Esto último ha sido una simple apreciación para el lector. que en nuestro caso correspondería con un viaje realizado. El tercer método getItemId(int arg0) devulve el id del viaje que se ha seleccionado. que hemos decidido que fuera el nombre. que junto con getView() son necesarios implementar debido a que extendemos de la clase BaseAdapter. A continuación encontramos los métodos getCount(). que como ya se ha dicho es el más destacado de esta clase. De la clase Adaptador destacamos el método getView() que es donde se establecen los datos que se quieren mostrar en cada elemento de la lista. y también se inicializa la variable datos con el parámetro que se le pasa datos. Finalmente creamos un nuevo objeto de la clase Adaptador. Al haber llamado igual tanto a las variables como a los parámetros que se pasan hemos tenido que utilizar la palabra reservada en Java this. que es la lista de todos los viajes realizados hasta el momento. fecha de inicio. A continuación se muestra el código completo de la clase Adaptador y a continuación se explicará el método getView(). que el usuario finalice el viaje antes de la fecha que marcó como fin. devuelve un valor de tipo int con el tamaño del array que inicializamos en el constructor. El primero de ellos. en caso de tener que usarlo esto se traduce para nuestra aplicación en el número de viajes que llevamos realizados. y por tanto tendríamos un objeto con toda la información del viaje seleccionado.el estado del viaje cambia a Finalizado como el del resto de viajes si los hubiera. que es una clase que hemos creado y explicaremos a continuación. getItem() y getItemId(). concretamente el viaje que se ha seleccionado en la lista. es decir mostrar la información de los distintos viajes. fecha fin y estado del viaje. que está escrito en Java) para realizar un proyecto. en este caso concreto desde la actividad principal DiarioDeViaje.

argb(127.lista_personalizada.getNombre()).id. this.setText(datos.public class Adaptador extends BaseAdapter { private Context context = null. } @Override public int getCount() { // TODO Auto-generated method stub return datos.context = context. TextView nombre = (TextView) item.get(arg0).getActivo() == 1){ item. } public View getView(int arg0.get(arg0). TextView activo = (TextView) item. public AdaptadorP(Context context. } TextView fechaInicio = (TextView) item.id. }else{ item.220. nombre. ArrayList<NuevoViajeBean> datos){ super(). private ArrayList<NuevoViajeBean> datos = null.get(arg0).findViewById(R.setBackgroundColor(Color. activo. View arg1.nombreLista_id).findViewById(R.argb(127.findViewById(R. if(datos.layout.datos = datos.inflate(R.setText("Finalizado"). View item = inflater. this. fechaInicio.60)).setText("Del " + 65 . ViewGroup arg2) { // TODO Auto-generated method stub LayoutInflater inflater = LayoutInflater.124. null).20.0)).from(context).252.setText("En curso"). } @Override public long getItemId(int arg0) { // TODO Auto-generated method stub return arg0.setBackgroundColor(Color.fechaInicio_id).activo_id). } @Override public Object getItem(int arg0) { // TODO Auto-generated method stub return datos.id.size(). activo.

} } Lo primero que hacemos en el método getView() es añadir a la interfaz un nuevo archivo .get(arg0). Después lo que se añade es el nombre del viaje.Android.id. el cual se utliza desde el método getView() de la clase adaptador. en este caso lista_personalizada.com/apk/res/Android" Android:layout_width="match_parent" Android:layout_height="match_parent" Android:orientation="vertical" > <RelativeLayout Android:layout_width="match_parent" Android:layout_height="match_parent" Android:orientation="horizontal" > <TextView Android:id="@+id/nombreLista_id" Android:layout_width="wrap_content" Android:layout_height="wrap_content" Android:textStyle="bold" Android:textSize="25dp" /> <TextView Android:id="@+id/activo_id" Android:layout_width="wrap_content" Android:layout_height="wrap_content" Android:textStyle="normal" Android:layout_alignParentRight="true" Android:textSize="15dip" /> </RelativeLayout> <LinearLayout Android:layout_width="match_parent" 66 .fechaFin_id). este archivo será explicado a continuación.getFechaFin()). la fecha de finalización y la descripción del viaje.xml mediante la clase LayoutInflater.xml.get(arg0).0" encoding="utf-8"?> <LinearLayout xmlns:Android="http://schemas.xml. fechaFin. que personalizará cada elemento de la lista.datos. Y por último se añade la fecha de inicio. para distinguir visualmente entre uno u otro (rojo significa finalizado y verde en curso).findViewById(R. Para personalizar la lista de viajes se usa el archivo lista_personalizad. return item.setText(" al " + datos. <?xml version="1. TextView fechaFin = (TextView) item.getFechaInicio()). se comprueba si éste está en curso o finalizado para indicarlo mediante texto y también para cambiar el color de fondo de ese elemento de la lista.

id. el bloque que muestra las fechas del viajes que se ponen con un simple <LinearLayout>. 67 . esto es por defecto. que en este caso es el nombre. y por otro lado el estado en el que se encuentra el viaje. startActivityForResult(inte. que al pulsar sobre ella abre la galería de fotos donde se puede seleccionar una. en primer lugar se quiere mostrar en la parte superior de cada elemento de la lista el nombre del viaje y el estado en que se encuentra por ello se crea un primer bloque a partir de un <RelativeLayout>. code = SELECT_PICTURE.ACTION_PICK. En segundo lugar. case R.Android:layout_height="match_parent" Android:orientation="horizontal" > <TextView Android:id="@+id/fechaInicioLista_id" Android:layout_width="wrap_content" Android:layout_height="wrap_content" Android:textStyle="normal" Android:textSize="15dp" /> <TextView Android:id="@+id/fechaFinLista_id" Android:layout_width="wrap_content" Android:layout_height="wrap_content" Android:textStyle="normal" Android:textSize="15dp" /> </LinearLayout> </LinearLayout> Con este archivo XML queremos personalizar la forma como se muestran el nombre.Images.MediaStore. Esta información se va a dividir en dos bloques. Para ello en el menú contextual de la lista hay la opción de “Añadir Foto”. en este caso hay que destacar que no se usa un <LinearLayout> debido a que se quiere modificar la posición de los elementos dentro de este bloque.Media. por un lado el nombre del viaje en la parte izquierda del bloque. estado. code).INTERNAL_CONTENT_U RI). en la parte derecha como puede verse en el código con la línea Android:layout_alignParentRight="true". descripción y una sola fecha (fecha en la que se visito el lugar) y con la mayor diferencia que es la posibilidad de mostrar una imagen del lugar en la lista. que son los lugares que se han visitado en cada viaje realizado. fecha de inicio y la fecha fin de cada viaje que ha realizado el usuario. Android.provider. A continuación se muestra el trozo de código que lo implementa. break. ya sea en curso o finalizado.Foto: Intent inte = new Intent(Intent. La lista de lugares visitados. dentro del objeto TextView que corresponde con el estado del viaje. tiene una implementación muy similar a la lista de viajes explicada anteriormente pero variando los elementos que se muestran.

onCreate(savedInstanceState). protected void onActivityResult(int requestCode.Este trozo de código se encuentra dentro del método que genera el menú contextual onContextItemSelected() de la clase Viaje.id. esta clase recibe una serie de datos por parte del usuario.nuevo_viaje).java Esta es la clase que se encarga de rellenar el formulario necesario para la creación de un nuevo viaje. De esta clase hemos destacado el efecto que se produce al pulsar sobre los campos que solicitan las fechas y que es la aparición de una ventana emergente. además de la ventaja de ser más cómodo e intuitivo para el usuario. que no hemos visto necesario explicar su implementación.layout. int day = 0.fechaFin_edit). para que el usuario pueda introducir las fechas de una forma grafica y no mediante texto utilizando el teclado. int year = 0. public void onCreate(Bundle savedInstanceState) { super. int month = 0.id. fechaFinEdit = (EditText)findViewById(R. denominado selector de fechas. } } NuevoViaje. como es el nombre que quiere dar al viaje y las dos fechas que delimitaran el periodo de tiempo que durará el viaje. setContentView(R. private EditText fechaInicioEdit = null. Intent data){ if(requestCode == SELECT_PICTURE){ cargarLista(). tiene la ventaja de que nos aseguraremos que el usuario introduzca los valores de fechas con el formato adecuado. 68 .fechaInicio_edit). Lo único que se hace en este método es volver a llamar al método cargarLista() para que actualice de nuevo la lista de lugares visitados mostrando también la foto que se ha seleccionado. private private private private Calendar calendar = null. Cuando se selecciona una foto de la galería se llama al método onActivityResult() que es el encargado de procesar la respuesta. int resultCode. fechaInicioEdit = (EditText) findViewById(R. Lo que se hace es comprobar dentro del menú si la opción seleccionada era la de añadir una foto y si es así lanzar un intent mediante el método startActivityForResult() que abrirá la galería de fotos. private EditText fechaFinEdit = null.java.

que son setOnclickListener() y setOnFocusChangeListener(). } Este método se encarga de comprobar cuando se selecciona alguno de los campos de fechas que tiene el formulario para crear un nuevo viaje y poder hacer visible el selector de fechas. Para ello se utilizan dos eventos sobre el objeto View pasado por parámetro. Una vez que se tienen todas la variables que son necesarias inicializadas. year = calendar. } }). lanzarEvento(fechaFinEdit).calendar = Calendar.getInstance(). además de inicializar la variables necesarias para obtener la fecha actual. se llama al método privado lanzarEvento(View v) encargado de lanzar el selector de fechas cuando corresponda. month = calendar. Después inicializamos las variables fechaInicioEdit y fechaFinEdit con los objetos view correspondientes que están en el archivo XML recién cargado. Se necesita llamar a los dos por las siguientes razones. si solo se pusiera el método que se ejecuta cuando se cambia el focus (FocusChangeListener) si se quiere modificar una fecha que en ese momento tiene el focus no se lanza el selector de fechas.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub showDialog(DATE_DIALOG_ID).xml.get(Calendar.MONTH). v. } Lo primero que vamos a ver es el método onCreate().get(Calendar. porque en una primera pulsación el campo correspondiente obtiene el focus y en una segunda pulsación es cuando se entiende 69 .YEAR). boolean hasFocus) { // TODO Auto-generated method stub if(hasFocus){ showDialog(DATE_DIALOG_ID).setOnFocusChangeListener(new OnFocusChangeListener() { @Override public void onFocusChange(View v. private void lanzarEvento(View v){ v. lanzarEvento(fechaInicioEdit).DAY_OF_MONTH). y por el contrario si solo se tuviera el evento que se lanza cuando se hace click (clickListener) habría que pulsar dos veces sobre el campo fecha.get(Calendar. day = calendar. Lo primero como siempre es definir el archivo XML que contiene la interfaz que para esta actividad es nuevo_viaje. } } }).

ubicacion. } Este método es el encargado de gestionar todos las ventanas emergentes (se denominan en Android Dialog.java Al igual que sucedía en la clase NuevoViaje. llama al método showDialog(int id) que es el que hace visible el selector de fechas y para ello se ejecuta de forma implícita el código que contiene el método protegido onCreateDialog que es el que realmente abre la ventana emergente (selector de fechas). como puede ser el selector de fechas) que se abren en la actividad correspondiente. Por todo lo explicado anteriormente son necesario los dos eventos. switch (id) { case DATE_DIALOG_ID: d = new DatePickerDialog(this. break.id. así si el usuario cambia el focus entre los dos campos de fechas (fecha de inicio y fecha fin) se lanza el segundo evento (setOnFocusChangeListener()) y se muestra el selector. Finalmente cuando uno de los dos eventos. day). public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState). year.ubicacion_id). default: break. además se comprueba que los dos objetos View sean los que contienen el focus mediante la condición hasFocus. mDateSetListener.setOnClickListener(new OnClickListener() { 70 .layout. vamos a explicar parte del código y lo más destacado es la obtención de la posición del lugar que se visita mediante coordenadas GPS y representarla de forma gráfica en un mapa utilizando la API de google y el GoogleMaps.como el efecto de hacer click. ubicacion = (Button) findViewById(R. De esta clase. public class NuevoLugar extends Activity { private Button ubicacion = null. setContentView(R. dependiendo de la acción del usuario.nuevo_lugar). } return d. NuevoLugar. como pasaba con la clase anterior. protected Dialog onCreateDialog(int id){ Dialog d = null. Por tanto comprueba cual es el Dialog al cual se está llamando y crea un nuevo Dialog que es el que se devuelve y será mostrado.java esta clase se encarga de gestionar los datos introducidos por el usuario en un formulario. para evitar que si se cambia el focus a otro campo que no sea uno de fechas no se lance el selector. month.

from(this).mapa_superpuesto.class).setOnClickListener(this). ImageView ubicacion = null. private private private private LayoutInflater myInflater = null. Esta acción es la de ejecutar una nueva activity con el nombre MapaUbicación.id. aceptar. View overView = null. LayoutParams.boton_aceptar). setContentView(R. new LayoutParams(LayoutParams. aceptar = (Button) findViewById(R. el cual inicializamos con el botón creado en archivo XML al que hemos hecho referencia anteriormente mediante el método findViewById(). this. Para ello en el método onCreate() en primer lugar y como siempre se hace referencia al archivo XML que contendrá la interfaz que se mostrará en la aplicación. View overView = myInflater.ubicacion).addContentView(overView. private LocationManager locManager = null.onCreate(savedInstanceState). ubicacion. private MapController controlMap = null. MapaUbicacion.LOCATION_SERVICE). null).layout.setOnClickListener(this).mapa). la acción que se lleva a cabo al pulsar sobre el botón. 71 . public void onCreate(Bundle savedInstanceState){ super.layout. El código anterior solo es una parte de la clase NuevoLugar. private LocationListener locListener = null. } }).java. myInflater = LayoutInflater.FILL_PARENT)). locManager = (LocationManager) getSystemService(Context. Una vez que tenemos la variable ubicación creada cambiamos. ubicacion = (ImageView) findViewById(R.FILL_PARENT. utilizando el método setOnClickListener().@Override public void onClick(View arg0) { // TODO Auto-generated method stub Intent intent = new Intent(contexto. startActivity(intent).inflate(R. Button aceptar = null. A continuación creamos un objeto de tipo Button. private MapView mapa = null. del que vamos a explicar el campo ubicación que aparece en la aplicación al crear un nuevo lugar visitado en un viaje.id.

dentro del método onCreate(). 0. Por último. se hace uso de la clase LayoutInflater. A continuación se asigna a los dos botones ya mencionados. En primer lugar tenemos. se ha implementado en un método a parte que se explicara más adelante. la acción que se realiza al pulsar.locListener = new MiLocationListener(). para ser visualizada. el método onCreate() que además del ya comentado método setContentView(). 0. locManager. } @Override public void onProviderEnabled(String provider) { // TODO Auto-generated method stub comprobarDispositivo = true. ubicación y aceptar. se tiene lo más importante dentro de este método y que es la inicialización de las variables locManager y locListener. que ayudándonos de una clase interna llamada MiLocationListener() podemos hacer uso del GPS del dispositivo. } @Override public void onProviderDisabled(String provider) { // TODO Auto-generated method stub comprobarDispositivo = false. nod sirve para añadir dos botones sobre la interfaz original ya mencionada que contiene el mapa de Google. las acciones que se llevaran acaba al pulsar sobre ellos mediante el método setOnClickListener(). Para mostrar cómo se hace se van a explicar los métodos más importantes de la activity. private class MiLocationListener implements LocationListener{ @Override public void onLocationChanged(Location location) { // TODO Auto-generated method stub comprobarRecibeCoordenadas = true. } @Override 72 . locListener).requestLocationUpdates(LocationManager. como se muestra más arriba. } Esta nueva activity es la que se encarga de obtener mediante coordenadas GPS la posición actual del usuario y mostrar sobre un mapa.GPS_PROV IDER. que en esta activity añade un mapa que usaremos para representar las coordenadas y que se explicara más adelante el archivo XML que se emplea. en este caso se. uno de ellos para obtener las coordenadas y el otro para aceptar si el usuario está de acuerdo con la posición que se ha recibido en el mapa. que junto con los métodos inflate() y addContentView().

getId()) { case R.marc ador).getOverlays().getResources(). longitud.getLongitude()*1E6. MyOverlay itemizedOverlay = new MyOverlay(drawable). itemizedOverlay.getLastKnownLocation(LocationManager .makeText(contexto. latitud = loc. "Coordenadas no disponibles". mapOverlays = mapa. aceptar. OverlayItem overlayItem = new OverlayItem(geoPoint. int status.getLatitude()*1E6. el segundo cuando el GPS esta desactivado y el tercero cuando el GPS esta activo. controlMap.addOverlay(overlayItem). controlMap.getDrawable(R.LENGTH_LONG).public void onStatusChanged(String provider.id.intValue()). public void onClick(View v) { // TODO Auto-generated method stub switch (v. }else{ loc = locManager. "logitud: " + longitud + " latitud: " + latitud. Toast. Toast.GPS_PROVIDER).makeText(contexto.setVisibility(1). "Hola").add(itemizedOverlay). mapOverlays.show(). Bundle extras) { // TODO Auto-generated method stub } } Esta clase interna . "Hola". Toast.drawable.LENGTH_LONG). que se encuentra dentro de la clase MapaUbicación.setCenter(geoPoint). El primero es llamado cuando se produce un cambio de coordenadas. Para saber si se ha producido alguno de estos casos que acabamos de describir. usamos las variables comprobarRecibeCoordendas y comprobarDispositivo. geoPoint = new GeoPoint(latitud.intValue().setZoom(16). drawable = this. longitud = loc. contiene cuatro métodos de los que hemos usado tres y que son llamado de forma implícita cuando se produce algún evento relacionado con ellos. 73 .show().ubicacion: if(comprobarDispositivo){ if(!comprobarRecibeCoordenadas){ Toast.

} break. y con la ayudad de las clases Drawable y GeoPoint del SDK de Android y una nueva clase interna llamada MyOverlay se dibuja sobre el mapa con un marcador(un icono gráfico) la posición que se ha obtenido.class). en caso negativo se informa al usuario. para saber si el GPS esta activado o no. la pestaña donde se pueden ver las fotos realizadas y la información que contiene la enciclopedia libre Wikipedia sobre el lugar visitado. como es el uso de la cámara. puesto que al salir de esta pantalla que contiene el mapa ya no es necesaria la función del GPS. La otra opción del método onClick(). lo que se hace es comprobar la variable comprobarDispositivo. si no es así.removeUpdates(locListener). Posteriormente se hace visible sobre la pantalla el botón aceptar.} }else{ Toast. break. NuevoLugar. es la de pulsar el bóton aceptar para confirmar que es la posición deseada y dejar esta pantalla. Antes de abandonarla se utiliza el método removeUpdates() para parar que el GPS siga buscando coordenadas. } } En el método onClick() se implementa.makeText(contexto. inicializada en la clase privada MiLocationListener. comprobarRecibeCoordenadas. Intent intent = new Intent(contexto. A partir de ahora explicaremos parte del código que usamos para almacenar la información de los lugares visitados. case R.boton_aceptar: locManager. startActivity(intent). como ya se ha comentado.id. Toast. default: break.show().LENGTH_LONG). para que el usuario de su conformidad sobre la posición y por ultimo se centra el mapa sobre el punto recientemente localizado. "El GPS esta desactivado". se almacenan en las variables latitud y longitud. también inicializada en la mencionada clase interna que nos dirá si se están recibiendo coordenadas GPS. si no se comprueba la otra variable. la acción que se lleva a cabo al pulsar sobre los botones ubicación y aceptar. Una vez que se obtienen. y evitar así un gasto de batería adicional. se comunicara al usuario que aún no hay coordenadas disponibles debido a que el GPS está intentando obtenerlas. 74 . En cuanto al primero.

a partir de la variable rutaLugar que ya tenemos inicializada dentro de la clase donde se encuentra el código y que corresponde con una carpeta creada para esta aplicación cuando se instala por primera vez. la aplicación preguntará con cual queremos abrir. Android siempre trae una aplicación para la cámara. para abrir la cámara usamos un intent y le indicamos la ruta donde guardar el archivo. A continuación obtenemos la ruta donde almacenar la foto. y con la variable anterior file terminado en .jpg para que corresponda con un formato de imagen.jpg". Uri output = Uri. WIKIPEDIA Para obtener la información de wikipedia nos apoyamos en el nombre que el usuario le da al lugar en el momento de crearlo y junto con la dirección "http://es. Una vez se tiene la ruta lanzamos la cámara a través de una de las aplicaciones que tenga nuestro móvil.getYear() + "_" + fecha.camara_id: Date fecha = new Date(). Intent i = new Intent(MediaStore. esta variable es la que utilizaremos para nombrar la fotografía que se realice.getSeconds() + ".EXTRA_OUTPUT. startActivity(i).putExtra(MediaStore.php?title=Special%3ASearch&search=" que vimos que era la que utilizaba wikipedia para redireccionar al artículo que se está buscando y si no coincide la palabra buscada con un artículo te redirecciona a los artículos relacionados o que más se ajustan a la palabra buscada donde puedes elegir el correcto. break.getMonth() + "-" + fecha. rutaFoto = new File(rutaLugar. En primer lugar se obtienen la fecha y la hora actual. String file = fecha. Al optar por la opción de la cámara se ejecuta el código anterior. output). que corresponderá a la fecha y hora en que se realiza la foto y se almacena en una variable llamada file. file).id. en el caso de que hayamos instalado nosotros una de terceros.fromFile(rutaFoto). Este código se encuentra dentro del método onOptionsItemSelected() que es el que se encarga de llevar a cabo una acción cuando se pulsa una opción en el menú de la pantalla.getMinutes() + "-" + fecha. por defecto. para ello también añadimos una notificación y un botón que aparece la primera vez que quieres ver la información en la wikipedia.getHours() + "-" + fecha. en caso contrario 75 .getDay() + "-" + fecha. finalmente lanzamos la actividad.wikipedia. la notificación te pregunta si estás de acuerdo con el artículo mostrado para que aceptes con el botón.ACTION_IMAGE_CAPTURE).org/w/index.CAMARA case R. i.m.

y se denomina Gallery.loadUrl(cadena).lugar). estas dos cadenas se unen usando un método privado dentro de la misma clase donde va el método onCreate().puedes buscar el artículo que describe el lugar visitado y aceptas. Para cargar el artículo de wikipedia correspondiente en nuestra aplicación usamos el método loadUrl que recibe la variable cadena.webview).xml y lo llamamos desde la clase Lugar. esta variable está inicializada con la dirección mencionada anteriormente más el nombre que se le dio al lugar por parte del usuario. myWebView = (WebView) findViewById(R. myWebView. gracias a este método siempre estaremos navegando por internet dentro de nuestra aplicación. En primer lugar inicializamos la variable myWebView con el elemento que se encuentra en el archivo Lugar.onCreate(savedInstanceState).java similar a lo que sucedía con el elemento WebView para crear el navegador interno de nuestra aplicación.layout.xml que es donde se define toda la vista para la pantalla donde se muestra la información de un lugar.setWebViewClient(new verMiWeb()). En el momento que se acepta el artículo que se encuentra a la vista es el que se mostrará en sucesivas visitas a la pestaña de wikipedia. Lo hicimos finalmente de esta manera porque aunque estuvimos buscando alguna api de wikipedia que pudiéramos usar aplicándola a nuestra aplicación y dentro de nuestro código no la encontramos finalmente y nos decidimos por esto. Finalmente tenemos la llamada al método setWebViewClient() que recibe una clase privada que hemos implementado. setContentView(R. este elemento lo definimos en el archivo lugar. y que sirve para evitar que se abra un navegador externo a nuestra aplicación.xml. } En el método onCreate() a parte de las líneas de código que se pueden ver hay varias líneas de código más que no hemos puesto porque no son relevantes para explicar el funcionamiento de la información que se muestra de la wikipedia y que si la hubiéramos puesto ocuparía demasiado espacio. Para poder usar nuestra aplicación como un navegador web mostrando así información de internet y no tener que usar un navegador externo a nuestra aplicación para ver contenido de la web hay que definir un elemento WebView en un archivo . public void onCreate(Bundle savedInstanceState) { super. por lo tanto hemos puesto lo necesario para explicar lo deseado.xml. este componente lo creamos en el archivo Lugar.id. myWebView. En el sdk de Android se encuentra un componente que nos sirve para implementar la galería de fotos. 76 . FOTOS Para visualizar las fotos hemos creado una galería.

= Bitmap scaled = Bitmap. A continuación inicializamos la variable gallery con el elemento que hemos creado en el archivo .lugar). ViewGroup parent) { ImageView imageView = new ImageView(this. imageView. FileInputStream fd. setContentView(R. Bitmap bitmapFoto BitmapFactory.public void onCreate(Bundle savedInstanceState) { super. 120)).onCreate(savedInstanceState). gallery. 200. imageView.id.gallery).contexto).LayoutParams(150. una vez inicializado utilizamos el método setAdapter() para cambiar el adaptador de la galería por uno personalizado por nosotros.setAdapter(new ImageAdapter(this)). } Lo primero es asociar el archivo Lugar.createScaledBitmap(bitmapFoto. View convertView.setLayoutParams(new Gallery. Finalmente mediante el método setOnItemClickListener() implementaremos la acción a llevar a cabo cuando se seleccione una foto de la galería. gallery. 200.xml. } catch (Exception e) { // TODO Auto-generated catch block e. public View getView(int position. try { fd = new FileInputStream(fotos[position]). lo hacemos con la ayuda de la lista fotos que contiene las rutas de todas las fotos que se hicieron con la cámara desde la pantalla de un lugar concreto.layout.setOnItemClickListener(this). Gallery gallery = (Gallery)findViewById(R. } return imageView. A 77 .setImageBitmap(scaled).printStackTrace(). Después creamos un objeto de tipo File con el que obtenemos la ruta de la imagen a colocar en la galería.decodeFileDescriptor(fd. esta acción será la de colocar la foto en la pantalla para verla.xml a nuestra actividad. En primer lugar inicializamos la variable imageView que es donde se almacenarán cada una de las fotos que se visualizarán.getFD()). true). } } De la clase interna ImageAdapter que sirve para personalizar la galería a nuestro gusto destacamos el método getView() que es el que configura cada fotografía para que se previsualice en el elemento Gallery.

78 . posteriormente se utiliza este bitmap para crear uno nuevo pero con la escala deseada. para que aparezcan en la galería mediante la utilización del método setImageBitmap() y por ultimo cambiamos el ancho y alto de la galería con el método setLayoutParams().continuación se crea un objeto Bitmap para poder trabajar con una imagen. Finalmente se asocia el último Bitmap creado al elemento ImageView que hemos formado al principio. para poder reducir el tamaño original de una foto y pueda previsualizarse en la galería. este objeto se crea a partir del archivo anterior.

Pruebas 79 .8.

sin embargo si es posible emular coordenadas GPS para simular un punto del mapa. Los lugares visitados fueron: 80 . Y se iban realizando las fotos de cada lugar. puesto que estas son las más comunes entre los terminales Android. ambas fechas coincidieron en nuestro caso ya que realizamos la prueba real de la aplicación en un solo día. Las diferencias entre velocidades de ejecución y acceso a Internet eran casi siempre mínimas. En todo momento se realizaban pruebas en uno y otro emulador para poder observar las diferencias de ejecución entre una versión y otra. Cada vez que acabábamos una parte de la aplicación. puesto que las pruebas se realizaban sobre un emulador.El SDK de Android permite integrar dispositivos virtuales para probar la aplicación en el entorno de desarrollo Eclipse. se introdujeron las fechas en las que se visitó. descripción y obteniendo la posición GPS del mismo. visitamos los distintos lugares turísticos. Queda a disposición del usuario crearse cuantos emuladores quiera y con las características que se desee. La única forma de llevar a cabo una prueba de nuestra aplicación es realizar un diario de viaje en vivo. la probábamos en cada uno de los emuladores para su correcto funcionamiento. en primer lugar creamos un nuevo viaje al que se le dio el nombre de Sevilla. siendo lo más destacable los cambios a nivel de interfaz debido a la leve diferencia de resolución de pantallas.3 de Android. su resolución. fecha de incio y fecha de fin del viaje. por tanto tomamos el móvil y salimos por alguna de las zonas turísticas de Sevilla probando así la aplicación. el tipo de pantalla. De esta manera la optimización de código se deja para la fase final de la aplicación cuando ya pueda ser probada en un dispositivo real. Una vez terminada la aplicación y habiendo sido probada en el emulador nos decimos por hacer una prueba real de la misma.2 otro con la versión 2. en relación a la ciudad que estábamos visitando. establecer la versión de sistema operativo en la que se ejecutara. Esta comprobación era principalmente en cuanto a interfaz y cumplimiento de funcionalidades. En nuestro caso no tuvimos problemas para probar la aplicación en el emulador de Android a excepción de la cámara. cantidad de memoria. De esta manera probamos la localización GPS de una forma real y también la cámara que fue algo que no puedo realizar en el emulador. puesto que no se puede ejecutar ninguna cámara desde el emulador. Esta flexibilidad permite entre otras cosas... permitiendo de esta manera ajustar mejor el tamaño y apariencia de la información a mostrar para una correcta presentación. Para realizar las pruebas hemos creado un emulador que implementa la versión 2. Una vez creado el viaje. Este viaje lo realizamos en la ciudad de Sevilla. para cada uno de ellos se crea un nuevo lugar en la aplicación rellenando el nombre.

- Ayuntamiento de Sevilla Catedral de Sevilla Reales Alcázares de Sevilla Archivo de Indias Plaza de toros de Sevilla Torre del Oro Parlamento de Andalucía La siguiente imagen es una captura de la aplicación con las posiciones GPS representadas en el GoogleMaps con los lugares visitados. 81 .

Estas son algunas de las fotos realizadas durante la prueba real de la aplicación. 82 .

83 .

9. Ampliaciones 84 .

y es donde se pone mayor interés.Esta aplicación está preparada para futuras ampliaciones. ya que el objetivo de un proyecto fin de carrera es el demostrar que se tiene los conocimientos necesarios para llevar a cabo un proyecto y no el proyecto en sí. comentarios que ha hecho el usuario. En cuanto a la interfaz de la aplicación somos conscientes de las mejoras que se pueden realizar. Una vez creado el servicio web con zonas turísticas se podría crear una opción de “indicación” dentro del mapa que te indica la posición del lugar. los usuarios deberían registrarse y al documentar un lugar turístico. Al estar realizando un proyecto de fin de carrera hemos puesto mayor interés en la parte funcional de la aplicación y por supuesto en la documentación de la misma. Una de las mejoras más interesante que vemos para este proyecto es la creación de un servicio web. en nuestro caso informático. 85 . este servicio mostraría de forma online lugares turísticos para que el usuario de la aplicación pudiera saber que puede visitar en su alrededor y la información del mismo. se daría la oportunidad al usuario de subir ese lugar si lo desea. pero sabemos que en un mundo laboral real este aspecto sería fundamental y que la mejora de la parte visual de la aplicación sería lo primero en mejorar para una posible comercialización. Por tanto el no llevar a cabo estas mejoras comentadas anteriormente no es por falta de ambición si no por falta de tiempo real. Se ha pensado que este servicio web se construiría con la ayuda de aquellos usuarios que quisieran colaborar. guardándose así la posición GPS del lugar. las cuales pueden ser tanto de mejora de la interfaz como de incorporación de nuevas funcionalidades. a semejanza con el “Google Maps”. aunque esta última parte siempre es importante. enlace de wikipedia y alguna fotografía que quisiera subir. Como se acaba de comentar el objetivo de un proyecto fin de carrera es la demostración de que se tiene los conocimientos para diseñar y llevar a cabo un proyecto. para mostrar la ruta desde la posición que se encuentra el usuario hasta el lugar turístico al que se quiere ir.

10. Conclusiones 86 .

Además. sacrificio y duro trabajo. en definitiva. hemos encontrado un sector en el que no nos importaría que se desarrollase nuestro futuro laboral. No obstante. Desarrollo de aplicaciones de nueva generación con un gran futuro por delante. permitiéndonos obtener el título de Ingeniero Técnico en Informática de Sistemas. Xml). El desarrollo de Android. Tener todas las herramientas disponibles en internet. investigado y aprendido mucho sobre un tema que nos apasiona y que hasta ahora era desconocido a nivel técnico para nosotros. Y. Para un estudiante esto supone unas posibilidades impensables hace escasos años. tan importante en el mundo laboral. consideramos que este Proyecto ha puesto a prueba nuestros conocimientos y nuestra capacidad de aprendizaje con un resultado positivo.La finalización del proyecto final de carrera representa uno de esos momentos de la vida en los que merece la pena echar la vista atrás y hacer balance de todo lo pasado. también hemos aprendido otros conocimientos:       Soltura con lenguajes de programación vistos durante el estudio de la carrera universitaria (Java. que seguro serán mucho más rápidos y ágiles. y sin coste. sino que su entrega simboliza también la conclusión de toda una carrera a través de muchos años de entrega. No sólo significa el fruto de varios meses de desarrollo. y esperamos que el Tribunal lo considere de la misma forma. Avanzar en la investigación. Además. la proliferación de dispositivos móviles con grandes capacidades hardware y las facilidades para el desarrollo de los mismos. la simplificación de conceptos en el sector. casi sin costes de distribución. permiten que las aplicaciones lleguen a cualquier parte del mundo en el momento en el que terminen su desarrollo. la distribución digital. nos ha servido para tener una base de cara a futuros desarrollos. Nuestro objetivo principal. Manejo de la API de Android. permite que cualquier desarrollador interesado pueda programar aplicaciones sin tener que pertenecer a una empresa o universidad. Desarrollando este proyecto hemos disfrutado. Las sensaciones que tenemos tras acabar este Proyecto Fin de Carrera son muy positivas. 87 . a pesar del objetivo fundamental que supone la realización del proyecto. También hemos podido comprobar que es posible desarrollar una aplicación desde cero utilizando exclusivamente herramientas libres. aprender todo lo posible sobre el desarrollo de aplicaciones para móviles bajo la plataforma Android ha sido cumplido. Redacción y publicación de documentos técnicos. Programar aplicaciones para teléfonos móviles.

queremos agradecer en primer lugar a nuestro tutor Dr. José Ramón Portillo Fernández todo el tiempo que nos ha dedicado guiándonos en la elaboración de esta documentación. Gracias a todos. y en segundo lugar pero no menos importante a nuestros familiares y amigos por todo el tiempo que le hemos quitado durante el periodo en el que hemos realizado este proyecto. 88 .Por último.

11. Bibliografía 89 .

wikipedia.Android.html PÁGINA OFICIAL DE ANDROID [Abril – Mayo 2012] http://developer. [2011] Android: curso de desarrollo de aplicaciones / Scott McCracken Barcelona: Inforbook's. [2011] El gran libro de Android / Jesús Tomás Gironés Barcelona: Marcombo.com BLOG NOSINMIUBUNTU [Abril – Mayo 2012] http://www. Frank Ableson.Android : Guia para desarrolladores / W.com/editorial/curso-Android Curso programación Android / Salvador Gómez Oliver SGOLIVER www.com/p/programacion-Android.Android-spa.com WIKIPEDIA http://es. Madrid: Anaya Multimedia.net 90 .org/wiki/Android Curso de Android desarrollo de aplicaciones móviles / Adrián Catalán MAESTROS DEL WEB http://www.maestrosdelweb. [2012] Manual imprescindible de desarrollo de aplicaciones para Android / Joan Ribas Lequerica Madrid: Anaya Multimedia. 2012 BLOG ANDROIDEITY / Aurora Rodríguez [Abril – Junio 2012] http://Androideity.com FORO ANDROID-SPA [Abril – Mayo 2012] http://www. Chris King.nosinmiubuntu. Robi Sen.sgoliver.