UNIVERSIDAD DE ALMERÍA ESCUELA POLITÉCNICA SUPERIOR (EPS) Ingeniero en Informática (Plan 1999)
Facebook‐Tourism.Desarrollode unaaplicaciónparaAndroid.
Autor:FernandoJesúsFernándezCarrillo Director:AntonioLeopoldoCorralLiria
Agradecimientos En primer lugar me gustaría agradecer a mis padres el apoyo prestado durante estos años, y sobre todo por no dejarme tirar la toalla cuando las cosas eran difíciles. A mis hermanos, Virtudes y Juan Carlos, por ayudarme siempre que los he necesitado. A todos mis amigos y compañeros de clase por la ayuda y el apoyo mostrado, en especial a Juan José Lozano y Luis Sánchez, que han estado ahí siempre. Para finalizar y no porque sea menos importante, a Antonio Corral, que aunque estaba muy ocupado, siempre encontró tiempo para ayudarme con el proyecto.
A todos vosotros, gracias.
1
Resumen El proyecto consiste en desarrollar una aplicación para Android llamada Facebook-Tourism. Esta aplicación permitirá al usuario encontrar los lugares que les
gustan a aquellas personas que tiene agregadas como amigos en Facebook y mostrarlo en el mapa con la ruta más corta hasta llegar a él. Además, mostrará también qué usuarios de dicha aplicación y que son amigos de él se encuentran cerca mostrando su posición y una ruta. El objetivo de la aplicación es permitir al usuario encontrar que lugares gustaron a algún amigo, evitando así sorpresas desagradables al ir a algún lugar en el que trataron mal al cliente o no es como se había anunciado. Durante esta memoria se explicará la situación actual de las distintas plataformas móviles que hay en el mercado y una vez que se haya expuesto la situación de las plataformas de la competencia nos centraremos en Android. De Android se hablará extensamente, explicando su historia, arquitectura, componentes y características. Con esto se pretende sentar las bases de conocimiento sobre Android antes de comenzar con el desarrollo de la aplicación Facebook-Tourism. Una vez sentadas las bases necesarias, se expone todo el proceso de diseño, desarrollo e implementación de la aplicación Facebook-Tourism, incluyendo pruebas realizadas y posibilidades de trabajo futuro. La aplicación Facebook-Tourism utiliza las API’s de Google y de Facebook como pilares para su funcio namiento, por lo que también se explicarán en la medida de lo posible. Para localizar los lugares que les gustan a los amigos de Facebook que se encuentran cerca del usuario se utiliza, por un lado, el sistema de posicionamiento global (GPS) para obtener la posición del usuario actual, con esa posición se busca que lugares se encuentran cerca del usuario y se cruzan esos resultados con los lugares que le gustan al usuario y que se han obtenido realizando consultas con la API de Facebook. En caso de obtener resultados validos, se le muestra un aviso al usuario indicándole que se encuentra cerca de un lugar que le gusta a alguno de sus amigos de Facebook, cuando el usuario quita ese aviso de la pantalla, en el mapa se carga la ruta para llegar andando desde la posición del usuario hasta el lugar indicado. Por otro lado, la aplicación muestra que usuarios de Facebook-Tourism se encuentran cerca, y al igual que con los lugares, muestra un aviso para llegar desde la posición del usuario hasta un amigo. Para calcular que amigos se encuentran cerca del usuario de la aplicación, se calcula en dos fases. La primera fase se realiza en el servidor y se encarga de transmitir a la aplicación, que usuarios se encuentran a menos de 500 metros a la redonda (sin importar si son amigos o no). La segunda fase se realiza en la aplicación, cuando ésta recibe los datos del servidor, comprueba que éste sea un amigo, y en caso de serlo calcula la ruta para llegar a él, si esta ruta es menor de 500 metros, entonces se genera un aviso que muestra un mensaje por pantalla indicando al usuario que un amigo se encuentra cerca. Cuando el usuario cierra ese mensaje, entonces se muestra la ruta en el mapa para llegar desde la posición del usuario hasta la posición del amigo en cuestión.
2
Índice Introducción............................................................................................................... 9 1.1. Objetivos................................................................................................... 10 1.2. Ámbito del trabajo .................................................................................... 11 1.3. Plan de Trabajo ......................................................................................... 11 1.4. Metodología.............................................................................................. 12 1.5. Herramientas............................................................................................. 12 1.6. Motivación................................................................................................ 13 1.7. Temporización.......................................................................................... 13 1.8. Conocimientos Adquiridos ....................................................................... 13 1.9. Estructura de la memoria .......................................................................... 13 Tecnologías móviles ................................................................................................ 15 2.1. Introducción.............................................................................................. 15 2.2. iOS ............................................................................................................ 16 2.2.1. Estado actual de la plataforma .......................................................... 19 2.2.2. Plataforma de distribución ................................................................ 20 2.3. Symbian .................................................................................................... 21 2.3.1. Estado actual de la plataforma .......................................................... 21 2.3.2. Plataforma de distribución ................................................................ 22 2.4. Web-OS .................................................................................................... 23 2.4.1. Estado actual de la plataforma .......................................................... 24 2.4.2. Plataforma de distribución ................................................................ 24 2.5. Windows-Phone ....................................................................................... 25 2.5.1. Estado actual de la plataforma .......................................................... 26 2.5.2. Plataforma de distribución ................................................................ 27 2.6. Blackberry OS .......................................................................................... 28 2.6.1. Estado actual de la plataforma .......................................................... 29 2.6.2. Plataforma de distribución. ............................................................... 30 2.7. Conclusiones y valoración personal de las tecnologías ............................ 31 Plataforma Android ................................................................................................. 33 3.1. Introducción.............................................................................................. 33 3.2. Historia de Android .................................................................................. 33 3.2.1. Historial de actualizaciones ............................................................... 34 3.3. Características de Android........................................................................ 35 3.4. Arquitectura de Android ........................................................................... 36 3.4.1. Linux Kernel ..................................................................................... 37 3
3.4.2. Libraries ............................................................................................ 38 3.4.3. Android Runtime ............................................................................... 38 3.4.4. Application Framework..................................................................... 38 3.4.5. Aplications ........................................................................................ 39 3.5. Android SDK ............................................................................................ 39 3.6. Estructura de una aplicación de Android.................................................. 40 3.6.1. Activity.............................................................................................. 40 3.6.1.1.Listeners Intent ............................................................................................ 3.6.2. ............................................................................................ 41 42 3.6.3. Servicios ............................................................................................ 42 3.6.4. Content Provider ............................................................................... 42 3.6.4.1. Android Manifest ......................................................................... 42 3.7. Aplicaciones en Android .......................................................................... 43 3.7.1. Tareas ................................................................................................ 43 3.7.2. Procesos............................................................................................. 44 3.7.3. Hilos .................................................................................................. 45 3.8. Recursos ................................................................................................... 45 3.9. Herramientas de desarrollo ....................................................................... 46 3.10. Conclusiones......................................................................................... 46 Aplicación Facebook-Tourism ................................................................................ 49 4.1. Introducción.............................................................................................. 49 4.2. Aplicación Location GPS ......................................................................... 49 4.3. Google ...................................................................................................... 53 4.3.1. API Google Maps .............................................................................. 54 4.4. Facebook................................................................................................... 56 4.4.1. API Facebook .................................................................................... 58 4.5. Facebook-Tourism .................................................................................... 58 4.5.1. Arquitectura de la aplicación............................................................. 59 4.5.2. Android Manifest .............................................................................. 60 4.5.3. Permisos ............................................................................................ 62 4.5.4. 4.5.5. 4.5.6. 4.5.7. 4.5.8. 4.5.9. 4.5.10.
Interfaz de la aplicación .................................................................... 67 Archivos XML .................................................................................. 69 Geo localización ................................................................................ 71 Mapas ................................................................................................ 72 Servidor ............................................................................................. 72 Base de datos ..................................................................................... 73 Diagrama de clases informal............................................................. 73 4
4.5.11. Diagrama de clases formal................................................................ 74 4.5.12. Diagramas de secuencia.................................................................... 76 4.5.12.1. Actividad conectar ..................................................................... 76 4.5.12.2. Actividad registrarse .................................................................. 76 4.5.12.3. Buscar un amigo ........................................................................ 77 4.5.12.4. Buscar un lugar .......................................................................... 77 4.5.13. Activity Principal .............................................................................. 78 4.5.14. de Mapas ............................................................................. 81 4.5.15. Activity Clase TratamientoJSON ................................................................... 83 4.5.16. Clase Intereses .................................................................................. 83 4.5.17. Clase Lugares.................................................................................... 83 4.5.18. Clase R .............................................................................................. 83 4.5.19. Problemas encontrados y soluciones propuestas .............................. 83 4.6. Pruebas ..................................................................................................... 85 4.6.1. Localización de lugares ..................................................................... 85 4.6.2. Localización de amigos ..................................................................... 86 4.6.2.1. Amigos fuera del radio ................................................................ 86 4.6.2.2. Amigos dentro del radio, pero demasiado lejos ........................... 86 4.6.2.3. Amigos cerca ............................................................................... 86 4.7. Conclusiones............................................................................................. 87 Conclusiones y trabajo futuro .................................................................................. 89 5.1. Conclusiones............................................................................................. 89 5.2. Líneas futuras ........................................................................................... 90 Bibliografía .............................................................................................................. 92 ANEXOS ................................................................................................................. 95 ANEXO I: Instalación del SDK de Android ....................................................... 95 ANEXO II: Creación de un nuevo proyecto Android ....................................... 100 ANEXO III: Creación de un dispositivo virtual ................................................ 103 ANEXO IV: Obtener una API Key para Google Maps .................................... 106 ANEXO V: Obtener una API Key para Facebook ............................................ 107 ANEXO VI: Manual de usuario de la aplicación .............................................. 109 ANEXO VII: Tutorial Location-GPS................................................................ 113
5
Índice de figuras Figura 1: Cuota de Mercado .................................................................................... 16 Figura 2: Capas iOS 4.0........................................................................................... 16 Figura 3: iCloud....................................................................................................... 20 Figura 4: iTunes....................................................................................................... 20 Figura 5: Logo AppStore ......................................................................................... 21 Figura 6: Logo Symbian .......................................................................................... 21 Figura 7: Symbian^3 ............................................................................................... 22 8: HP Menú Web-OS Figura 9: App Catalog......................................................................................... ....................................................................................... 23 25 Figura 10: Windows Phone 7 .................................................................................. 26 Figura 11: MarketPlace ........................................................................................... 28 Figura 12: Inicio Blackberry ................................................................................... 29 Figura 13: Application Center ................................................................................. 30 Figura 14: Distribución del SO................................................................................ 35 Figura 15: Arquitectura Android ............................................................................. 37 Figura 16: Ciclo de vida de un Activity .................................................................. 41 Figura 17: Android Manifest en XML .................................................................... 43 Figura 18: Pila de procesos...................................................................................... 45 Figura 19: Location GPS ......................................................................................... 50 Figura 20: Posición localizada................................................................................. 51 Figura 21: Señal no encontrada ............................................................................... 51 Figura 22: Documento XML de fuentes.................................................................. 51 Figura 23: Permisos ................................................................................................. 52 Figura 24: Actualización GPS ................................................................................. 52 Figura 25: Logo de Google...................................................................................... 53 Figura 26: Javascript API ........................................................................................ 54 Figura 27: Flash API ............................................................................................... 55 Figura 28: Google Earth API................................................................................... 55 Figura 29: Static Maps API ..................................................................................... 55 Figura 30: Servicios web API.................................................................................. 56 Figura 31: Maps Data API ....................................................................................... 56 Figura 32: Logo Facebook....................................................................................... 57 Figura 33: Arquitectura de la aplicación ................................................................. 59 Figura 34: Manifest ................................................................................................. 60 Figura 35: Application............................................................................................. 61 Figura 36: Permissions ............................................................................................ 61 Figura 37: Código XML .......................................................................................... 62 Figura 38: Ventana Principal ................................................................................... 68 Figura 39: Identificación ......................................................................................... 68 Figura 40: Ventana del Mapa .................................................................................. 69 Figura 41: Mapa.xml ............................................................................................... 70 Figura 42: Main.xml ................................................................................................ 70 Figura 43: Strings.xml ............................................................................................. 71 Figura 44: LocationManager ................................................................................... 71 Figura 45: getLastKnowLocation ............................................................................ 71 Figura 46: requestLocationUpdates......................................................................... 71 Figura 47: Mapa ...................................................................................................... 72 Figura 48: Usando librería ....................................................................................... 72 6
Figura 49: Capas de un mapa .................................................................................. 72 Figura 50: Contenido Tabla amigos ........................................................................ 73 Figura 51: Definición de la tabla amigos ................................................................ 73 Figura 52: Diagrama de clases informal .................................................................. 74 Figura 53: Diagrama de clases formal ..................................................................... 75 Figura 54: Diagrama secuencia conectar ................................................................. 76 Figura 55: Diagrama de secuencia registrarse ......................................................... 76 Figura 56: Diagrama Secuencia buscar amigo ........................................................ 77 Figura 57: Diagrama de secuencia buscar lugares .................................................. 78 Figura 58: Código Principal (I) ............................................................................... 79 Figura 59: Código Principal (II) .............................................................................. 79 Figura 60: Código Principal (III) ............................................................................. 80 Figura 61: Código Principal (IV) ............................................................................ 81 Figura 62: Código Mapas (I) ................................................................................... 81 Figura 63: Código Mapas (II) .................................................................................. 81 Figura 64: Código Mapas (III) ................................................................................ 82 Figura 65: Código Mapas (VI) ................................................................................ 82 Figura 66: Lugar encontrado ................................................................................... 86 Figura 67: Amigo encontrado.................................................................................. 87 Figura 68: Descarga SDK ........................................................................................ 95 Figura 69: Ruta instalación...................................................................................... 95 Figura 70: Elección de paquetes .............................................................................. 96 Figura 71: Términos de licencia .............................................................................. 96 Figura 72: Adición de repositorio ADT .................................................................. 97 Figura 73: Selección de ítems.................................................................................. 97 Figura 74: Aceptación de licencia ........................................................................... 98 Figura 75: Elección de ruta de instalación .............................................................. 98 Figura 76: Términos de licencia .............................................................................. 99 Figura 77: Selección de proyecto .......................................................................... 100 Figura 78: Especificaciones del proyecto .............................................................. 101 Figura 79: Creación de un documento XML ......................................................... 102 Figura 80: Administración dispositivos virtuales .................................................. 103 Figura 81: Configuración nuevo dispositivo ......................................................... 104 Figura 82: Confirmación ....................................................................................... 104 Figura 83: Lista de dispositivos virtuales .............................................................. 105 Figura 84: Generación de certificado .................................................................... 106 Figura 85: Clave generada ..................................................................................... 106 Figura 86: Registro de aplicación .......................................................................... 107 Figura 87: Datos de la aplicación .......................................................................... 107 Figura 88: Generando certificado .......................................................................... 108 Figura 89: Generación de Key............................................................................... 108 Figura de API .................................................................................. Figura 90: 91: Descarga Instanciación Facebook ........................................................................ 108 108 Figura 92: Menú Android ...................................................................................... 109 Figura 93: Inicio de la aplicación .......................................................................... 109 Figura 94: Identificación Facebook....................................................................... 110 Figura 95: Ventana Principal ................................................................................. 110 Figura 96: Menú Amigos....................................................................................... 111 Figura 97: Menú Lugares ...................................................................................... 111 Figura 98: Registro en Facebook........................................................................... 112 7
Figura 99: Permisos GPS....................................................................................... 115 Figura 100: Creación de interfaz ........................................................................... 115 Figura 101: Creación de la clase ........................................................................... 115 Figura 102: Código de la clase .............................................................................. 116 Figura 103: Tratamiento GPS................................................................................ 116 Figura 104: Código thread ..................................................................................... 117 Figura 105: Location Listener ............................................................................... 117 Figura 106: Handler............................................................................................... 118 Figura 107: Pantalla del Activity ........................................................................... 118 Figura 108: Modificación de la clase .................................................................... 118 Figura 109: Widget mapa ...................................................................................... 119 Figura 110: keytool................................................................................................ 119 Figura 111: Uso de la API ..................................................................................... 119 Figura 112: Mostrar posición en el mapa .............................................................. 120 Figura 113: Clase Overlay ..................................................................................... 121 Figura 114: Posición mostrada en el mapa ............................................................ 122 Figura 115: Diseño del layout ............................................................................... 123 Figura 116: Clase friendlist ................................................................................... 123 Figura 117: Clase friendsAdpater.......................................................................... 124 Figura 118: Pantalla del ActivityList .................................................................... 125 Figura 119: Creación del menú ............................................................................. 125 Figura 120: Selección de menú ............................................................................. 126 Figura 121: Pantallas del menú y sub-menú.......................................................... 126 Figura 122: Especificación para el menú contextual ............................................. 126 Figura 123: Rescritura del menú ........................................................................... 127 Figura 124: Especificación de acciones ................................................................ 127 Figura 125: Ejemplo de menú contextual.............................................................. 128
8
Introducción Las redes sociales ha supuesto una revolución en los últimos años en lo que la utilización y concepción de Internet se refiere. Hace unos años, la manera más habitual de comunicarse sobre Internet eran las aplicaciones de mensajería instantánea y los emails, lo cual solía limitar los contactos a personas cercanas o conocidas. Con la entrada de las redes sociales, el número de contactos por usuario ha crecido exponencialmente, se ha motivado el uso de grupos y las comunicaciones han evolucionado. Por otro lado, las aplicaciones móviles también hanmensajes sufrido de algunos cambios.a Anteriormente, los móviles se usaban para llamar o mandar texto. Gracias la evolución del hardware, el rango de uso se ha ampliado a varios campos, como el audiovisual y la navegación por Internet. Por lo tanto, no es de extrañar que las redes sociales aparezcan en los móviles, dado que dotan a éstas de una visión más realista de su uso que es el mantener en contacto a grupos de personas estén donde estén.
9
En este proyecto se va a crear una aplicación para el sistema operativo Android (Facebook-Tourism), que nos permita localizar los lugares favoritos de nuestros amigos en Facebook[39], además, también nos informará cuando estemos cerca de un amigo y nos mostrará la ruta para llegar al lugar indicado por la aplicación. Con esta aplicación se pretende que, de una forma sencilla, el usuario pueda localizar a sus amigos y ser localizado por estos, además, al mostrar los lugares favoritos de éstos, podemos evitar sorpresas desagradables cuando visitamos un lugar. Para conocer la posición del usuario de la aplicación, utilizaremos el sistema GPS y se descartará la localización basándose en la cobertura 3G por imprecisa. La plataforma Android está basada en Linux, y aunque srcinalmente se diseñó para dispositivos móviles (Smartphone), actualmente se puede encontrar este sistema operativo en PC’s,
notebooks, tabletas, etc. Al estar basado en software libre, es de código abierto, por lo que el código fuente está disponible para todos los usuarios. Por último, al utilizar la API de Facebook [42] con los permisos correspondientes podemos conectarnos y obtener los datos que tendríamos si accediéramos por un navegador web, lo que facilita el acceso al listado de amigos y a los lugares que les gustan.
1.1. Objetivos Los objetivos a lograr en este proyecto son los siguientes:
Conocer las tecnologías móviles actuales. En primer lugar vamos a profundizar en los sistemas operativos actuales destinados a dispositivos móviles. En esta fase, se estudiarán las principales características de iOS (MAC), Symbian (Nokia), Windows-Phone 7 (Microsoft), Blackberry (RIM), Web-OS (HP) y [47]
Android (Google, etc.). Nosdevamos a centrar solo en estos seis puesto que son los queMotorola, tienen la LG, mayor cuota mercado. [46] Profundizar en Android . Una vez hecha una primera aproximación a los sistemas operativos de los dispositivos móviles nos vamos a centrar en las características de Android, y en los requisitos necesarios para desarrollar sobre él. En resumen, al final esta fase tendremos que ser capaces de poder desarrollar aplicaciones para Android. Crear una aplicación móvil sencilla [45]. Ésta es la primera toma de contacto con el SDK de Android, con esta aplicación se pretende familiarizarse con la estructura de un programa de Android, usar los periféricos hardware del móvil, etc. Familiarizarse con la API de Facebook [44]. Puesto que la aplicación FacebookTourism utiliza el listado de amigos del usuario de Facebook, es necesario familiarizarse con la API de Facebook y con el perfil de desarrollador de la red social. Creación de Facebook-Tourism. En este último objetivo es donde se desarrollará la aplicación que queremos crear en este proyecto. Como ya se comentó, la aplicación nos mostrará qué amigos de Facebook tenemos cerca y además, que lugares de los que les gustan a esos amigos se encuentran lo suficientemente cerca como para poder ir caminando. Además, también mostrará la ruta para ir desde donde se encuentra el usuario al lugar seleccionado.
10
1.2. Ámbito del trabajo El ámbito de trabajo para este proyecto se centra en la plataforma Android, usando el sistema GPS integrado en el teléfono, la API de Facebook que está a disposición de los desarrolladores [43] y la API de Google necesaria para mostrar los mapas. La plataforma Android, al ejecutarse sobre la máquina virtual de Java, nos proporciona una base para crear aplicaciones para teléfonos móviles sin tener que preocuparnos por la marca o modelo de estos. El sistema GPS nos da la información relativa a la localización de un usuario, esta información será la que utilizaremos para calcular qué lugares y amigos están cerca del usuario y mostrarle esa información en un mapa. La API de Facebook, nos va a proporcionar acceso a la cuenta en la red social del usuario que esté usando la aplicación. Al proporcionarle los mismos permisos que tiene un usuario cuando accede mediante un navegador, podremos obtener el listado de amigos y los intereses de cada uno de ellos. La API de Google, nos va a permitir mostrar un mapa en la aplicación, además, utilizando los servicios Web de dicha API podremos calcular la distancia entre dos puntos y la ruta más óptima entre ellos.
1.3. Plan de Trabajo En primer lugar vamos a tener una fase de documentación, previa al desarrollo del proyecto. En esta fase, vamos a realizar una búsqueda bibliográfica para obtener información sobre cómo realizar aplicaciones en Android y seguiremos algún manual [45]
que nos sirva de toma de es contacto También tendremos que documentarnos sobre la API de Facebook, ya que una parte .importante en el proyecto. Una vez que hemos estudiado suficiente, y tenemos claro cómo alcanzar los objetivos marcados, procederemos a implementar el proyecto. A la hora de la implementación seguiremos las siguientes fases:
Creación de una aplicación sencilla [45]. Esta fase se realizará siguiendo un manual, y servirá para conocer los detalles de la implementación de una aplicación para Android y de la utilización de los componentes hardware del teléfono. Para esta fase, crearemos una aplicación que al pulsar un botón busque nuestra localización usando el GPS y muestre las coordenadas por pantalla. En la segunda fase comenzaremos a implementar la aplicación FacebookTourism, para ello empezaremos a utilizar la API de Facebook. El objetivo de esta fase es, usar dicha API para identificarnos en Facebook, descargar el listado de amigos, y de cada amigo bajar un listado de sus intereses [46]. Una vez tengamos toda la información relativa a la red social, descargada en el teléfono, se procederá a identificar cuáles de los intereses obtenidos son lugares que pueden ser representados en el mapa. Esta fase es muy importante, ya que si identificamos correctamente los lugares podremos marcarlos en el mapa. La cuarta fase es la gestión de la base de datos de usuarios de la aplicación para poder indicar cuando un amigo está cerca. Para ello, la aplicación le mandará al servidor la posición en la que se encuentra el usuario y éste le responderá con los ids de los usuarios que están cerca. Una vez recibidos, será la aplicación la que se encargue de filtrar los que pertenecen a los amigos y mostrarlos. 11
La quinta fase se corresponde con la utilización de la API de GoogleMaps [39]. En esta fase, mostraremos la posición del usuario en el mapa permitiéndole elegir el tipo de vista que desea utilizar (StreetView, Satélite o Trafico) La sexta fase es la última de implementación. En esta fase, se ensamblará todo y el objetivo es que cuando se inicie la aplicación, el usuario se identifique en Facebook y muestre en el mapa información relativa a su posición, la de sus amigos y la de los lugares que le gustan a sus amigos. La última fase se corresponde con las pruebas. Hay que detectar los fallos, los errores y el funcionamiento imprevisto para solucionarlo y que el funcionamiento de la aplicación sea el mejor posible. Elaboración de la memoria del proyecto. En ésta se hablará sobre los distintos sistemas operativos surgidos como consecuencia de la comercialización de Smartphones prestando especial atención en Android. También hablaremos sobre la aplicación (Facebook-Tourism) desarrollada, explicando su implementación y funcionamiento.
1.4. Metodología La metodología a seguir para el desarrollo del proyecto será la siguiente:
Estudio de la plataforma Android y de los requisitos previos para el desarrollo de una aplicación. Estudio de la API de Facebook [1.5], necesaria para las fases relacionadas con dicha red social, tales como la identificación, la descarga de un listado de amigos y la descarga de los intereses de cada uno de esos amigos. Estudio de la API de Google, necesaria para poder utilizar los mapas y calcular las rutas que tienen que seguir los usuarios. Análisis, diseño e implementación de una aplicación sencilla de localización GPS. Esta aplicación se realizará siguiendo paso a paso un manual. Esta aplicación la utilizaremos para familiarizarnos con el entorno y la tecnología, no será utilizada en la aplicación final. Análisis, diseño e implementación de la aplicación servidor. Esta aplicación se encargará de gestionar la base de datos de los usuarios para informar a la aplicación principal de que un amigo del usuario está cerca. Análisis, diseño e implementación de la aplicación Facebook-Tourism. Ésta es la aplicación principal del proyecto. Una vez que el usuario esté identificado en Facebook, se le enviará al servidor información relativa a su posición y el servidor le responderá con la posición de los amigos que están cerca de él.
1.5. Herramientas Para la realización de este proyecto es necesario un PC con conexión a internet y una base de datos en MySQL. Los requisitos hardware de este PC no tienen que ser muy avanzados ya que su único propósito es el de alojar el servidor que le mandará información a la aplicación. Por otro lado es necesario un teléfono móvil con sistema operativo Android, conexión a Internet y sistema de localización GPS incorporado. Durante la implementación del proyecto se realizaran pruebas sobre un terminal “HTC Hero” que
cuenta con un procesador de 528 MHz y 288 MB de memoria RAM.
12
Por último, necesitaremos las siguientes herramientas software para el desarrollo de la aplicación: Eclipse helios, SDK de Android [41], Xampp (Proporciona base de datos MySQL), API de Facebook y API de Google.
1.6. Motivación La motivación de este Proyecto Fin de Carrera es por un lado, obtener los conocimientos necesarios sobre Android para poder desarrollar más aplicaciones en el futuro, y por otro lado crear una aplicación que permita mejorar las comunicaciones entre los usuarios de las redes sociales. Con este proyecto fin de carrera pretendo adquirir los conocimientos necesarios para poder crear aplicaciones mas importantes sobre aplicaciones móviles, ya que aparte de adquirir nuevos conocimientos sobre las distintas plataformas, es una buena oportunidad para concienciarse en no utilizar nada más de los recursos necesarios debido a que los Smartphones, actualmente, tienen recursos hardware muy escasos.
1.7. Temporización El tiempo desglosado para la realización de este proyecto ha sido aproximadamente el siguiente:
Recopilación bibliográfica, para su estudio y una mejor comprensión de los conceptos relacionados con Android. (2 semanas). Estudio e implementación de un ejemplo, que ayude a familiarizarse con el sistema operativo y los componentes hardware (1 Semana). Estudio e implementación de la aplicación Facebook-Tourism, basándome en un modelo de diseño incremental (7 semanas). Diseño y funciona realización de una serieCon de los pruebas paradecomprobar que se la aplicación correctamente. resultados dichas pruebas mostrarán y se formularán las conclusiones (2 semanas). Preparación de la documentación del proyecto (12 semanas).
1.8. Conocimientos Adquiridos La realización de este proyecto me ha aportado conocimientos relacionados con el diseño de aplicaciones para dispositivos móviles, en concreto, para aquellos basados en la plataforma Android. Además de los conocimientos adquiridos relacionados con el desarrollo para Android he podido conocer otras plataformas que están actualmente en el mercado y he ganado experiencia utilizando la tecnología presente en la plataforma. También he aprendido a utilizar los distintos componentes hardware del dispositivo, permitiendo así poder integrarlos en la aplicación para lograr un entorno de usuario más adecuado para el usuario final, ya que gracias al uso de la vibración del dispositivo, no es necesario que esté comprobando continuamente la aplicación.
1.9. Estructura de la memoria Este documento está dividido en 6 capítulos que forman la memoria del proyecto, además, cuenta con varios Anexos en los que por ejemplo se explica la configuración del entorno para poder programar en Android, etc.
13
El capítulo 1 se centra en introducir el proyecto, destacando los objetivos, el ámbito de trabajo, el plan de trabajo, la metodología, las herramientas necesarias para la realización del proyecto, una aproximación temporal de la elaboración del mismo, y por ultimo los conocimientos adquiridos más destacados. En el capítulo 2 se hablará de las distintas tecnologías móviles que hay actualmente en el mercado, centrándome en el estado actual del sistema operativo, de la plataforma de distribución de la aplicaciones (“AppStore”), también hablaré de o tras plataformas como iOS, Symbian, etc. El capítulo 3 se centra exclusivamente en la plataforma Android, en esta capitulo hablaré sobre orígenesal de Android, suenimpresionante expansión en el para mercado, su futuro, etc. Esteloscapítulo, estar centrado Android, se utilizara también explicar la “base teórica” necesaria para el desarrollo de aplicaciones en Android.
En el capítulo 4 me centraré en la aplicación que he desarrollado para este proyecto fin de carrera (Facebook-Tourism), comenzaré hablando de los dos principales pilares de la aplicación (Google y Facebook) y a continuación hablaré de la aplicación en sí, mostrando su diagrama de clases, de secuencia, etc. También mostraré imágenes de la aplicación funcionando y explicaré como funciona, su utilidad, etc. En el capítulo 5 hablaré sobre las conclusiones a las que he llegado mientras realizaba este proyecto así como de cómo seguir desarrollándolo en el futuro para que no se quede estancado. Por último, el capítulo 6 contendrá toda la bibliografía que ha sido necesaria para el desarrollo del proyecto. Principalmente he utilizado como recurso bibliográfico Internet, por lo que en cada dirección Web que indique en la bibliografía, indicaré también, la fecha de la última vez que accedí a dicho enlace.
14
Tecnologías móviles 2.1.
Introducción
Las tecnologías móviles se han ido introduciendo en nuestras vidas de forma progresiva desde los últimos 20 años, haciéndose cada vez un hueco mayor en nuestro día a día. Lo que empezó siendo un dispositivo para realizar llamadas ha ido mejorando su funcionalidad y a día de hoy nos permite estar conectados a Internet en todo momento. Las tecnologías móviles han ido evolucionando y cada vez rivalizan con los ordenadores portátiles, de hecho, los rápidamente últimos Smartphones casi más son considerados tabletas, que son la principal competencia de los ordenadores portátiles. La tendencia que siguen los ordenadores portátiles es de ser cada vez más finos y ligeros, asimilándose al aspecto de las tabletas. Para este proyecto voy a utilizar algunas de las tecnologías que se han añadido a los últimos terminales, en concreto voy a utilizar la conexión GPS, necesaria para poder obtener la posición del usuario y la conexión a Internet, necesaria para poder acceder a los datos de Facebook. 15
En este capítulo voy a hablar de las distintas plataformas móviles que hay en la actualidad. Debido al gran número de plataformas móviles que existen hoy en día, me voy a centrar sólo en las que tienen la mayor cuota de mercado que son iOS, Symbian, Web-OS, Windows-Phone y Blackberry OS. De la plataforma Android hablaré más extensamente en el capítulo siguiente. En el tercer trimestre de 2011 [3], Android posee el 52.5% de la cuota de mercado de los dispositivos móviles, seguido de iOS que tiene el 16.9%, esto queda reflejado en la figura 1.
Figura 1: Cuota de Mercado
2.2.[1] iOS
iOS es un sistema operativo de Apple desarrollado srcinariamente para iPhone, aunque actualmente se puede encontrar en otros dispositivos de la compañía como el iPod y el iPad. Es un derivado de Mac OS X. El iOS tiene cuatro capas de abstracción: la capa del núcleo del sistema operativo, la capa de los Servicios principales, la capa Multimedia y la capa Cocoa Touch. Todo el sistema se encuentra en la partición /root del dispositivo y ocupa unos 500MB. En la figura 2, se muestra como están organizadas dichas capas.
Figura 2: Capas iOS 4.0
La capa del núcleo del sistema operativo (Core OS) contiene las características de bajo nivel sobre las que serán construidas las demás aplicaciones. Es la capa más importante, ya que, aunque una aplicación desarrollada por un tercero, no use directamente ninguna característica del núcleo es muy probable que la use algún 16
framework. Entre otras características, la capa del núcleo es la encargada de núcleo del bluetooth, de interactuar con accesorios externos, de la seguridad del dispositivo, también gestiona el framework responsable de aumentar la velocidad del dispositivo en temas relacionados con el cálculo matricial (resolución de ecuaciones, procesamiento de imágenes, etc.). Este nivel del sistema abarca el entorno del núcleo, drivers, y todas las interfaces de bajo nivel del sistema operativo. El núcleo por sí mismo es el encargado de todos los aspectos del sistema operativo. Administra la memoria virtual, hilos, archivos del sistema, redes, etc. Los drivers son los encargados de proporcionar la interfaz entre los frameworks y el hardware. Por motivos de seguridad, el acceso al núcleo está restringido a un limitado conjunto de frameworks y aplicaciones. La capa de los Servicios principales (Core Services) contiene los servicios fundamentales del sistema que todas las aplicaciones usan. Al igual que con los servicios del núcleo, es posible que una aplicación desarrollada por un usuario no haga uso de ninguno de estos servicios directamente, pero indirectamente se estarán utilizando. Dentro de esta capa se encuentra el soporte para distintos servicios como el soporte para XML, el servicio para la compra de aplicaciones (compra-app) o el GCD. El servicio de compra-App le da al usuario la capacidad para vender contenidos y servicios desde el interior de su aplicación. Esta función se implementa utilizando el marco Kit Store, que ofrece la infraestructura necesaria para procesar las transacciones financieras utilizando la cuenta del usuario en iTunes. El soporte para XML proporciona los elementos necesarios para la recuperación de elementos desde un documento XML. Además, proporciona soporte para la manipulación de documentos XML. Grand Central Dispatch es una tecnología que se usa para administrar la ejecución en una aplicación. GCD combina un modelo de programación asíncrona con un altamente optimizado núcleo para proporcionar una alternativa al Threading. GCD también proporciona muchas alternativas para muchos tipos de tareas de bajo nivel, como leer y escribir en archivos, o monitorizar señales y procesos. Además de los servicios indicados, hay otros que se consideran servicios del núcleo como el framework de red (gestiona las conexiones), el libro de direcciones (gestiona los contactos, el framework de localización (gestiona el GPS), etc.
La capa Multimedia (Media) contiene las tecnologías de gráficos, audio y video orientadas a ofrecer la mejor experiencia posible. Las tecnologías de esta capa fueron diseñadas para hacer fácil el desarrollo de aplicaciones que se muestren y se oigan con la mejor calidad posible. Los gráficos de alta calidad son una parte importante de todas las aplicaciones para iOS. La manera más simple (y a veces la más eficiente) es con imágenes prerenderizadas junto con las vistas estándar y los controles que proporciona el framework “UIKit”. Entre otras tecnologías, la capa multimedia da soporte a imágenes en 2D y 3D, imágenes vectoriales, etc. Al igual que los gráficos, el audio también es importante, por lo que las tecnologías de audio disponibles están diseñadas para proporcionar una gran experiencia a todos los usuarios. El sistema proporciona múltiples unidades para reproducir y grabar audio. Se puede elegir la codificación del audio como AAC, ALAC (Apples LLossLess), MIDI, etc.
17
Cuando un usuario reproduce una película o la ve desde Internet, iOS proporciona numerosas tecnologías para reproducir el contenido. Además de reproducir, el usuario también puede grabar video, y dependiendo de la tecnología utilizada, también se elige la calidad. El sistema operativo iOS ofrece soporte para H.264 a más de 1.5Mbps y MPEG-4 a 2.5Mbps. La capa Cocoa Touch es desde donde se ejecuta la interfaz gráfica. También es una API para la creación de programas proporcionando una capa de abstracción al sistema operativo. Cocoa Touch se basa en el set de herramientas que proporciona la API de Cocoa para crear programas sobre la plataforma Mac OS X. Toda la API está escrita en el lenguaje Objetive-C. La capa Cocoa Touch contiene los frameworks clave para desarrollar aplicaciones para iOS. Esta capa define la infraestructura básica de la aplicación y ofrece soporte para multitasking, entrada basada en pulsos, etc. En esta capa se encuentran numerosos frameworks, no obstante, como no es el objetivo del proyecto, sólo voy a hablar de las características más importantes. Las aplicaciones construidas con el SDK 4.0 o superior, no terminan cuando se pulsa el botón Home, en lugar de eso, la aplicación se va a segundo plano donde esperará hasta que vuelva a ser necesitada. El multitasking definido en el UIKit ayuda a la aplicación a ir y volver del segundo plano rápidamente. Para preservar la batería, las aplicaciones en segundo plano están suspendidas, por lo que al no ejecutar código alguno, gastan menos batería. La protección de datos permite a aplicaciones que trabajan con datos sensibles cifrarlos cuando los escriba en memoria y hacer que la aplicación que ha creado el archivo sea la única que puede acceder, además, si una aplicación que trabaja con datos sensibles se pasa a segundo plano, los datos también se cifran hasta que se vuelva a traer al frente, evitando así que otras aplicaciones puedan acceder. El reconocedor de gestos sabe que objetos se están tocando y utiliza esa información para detectar los tipos más comunes de gestos (golpe y pellizco). Es necesario indicar a la aplicación como tiene que responder ante cada gesto. Una vez reconocido el gesto, el objeto al que se le ha aplicado, basándose en la información que recibe de la heurística del reconocedor de gestos, actuará como se le indica. Hay muchas más características en esta capa como servicios p2p para juegos con bluetooth, servicios de impresión, compartir archivos, mensajería instantánea, twitter, etc. pero he desarrollado las tres anteriores por considerarlas las más importantes. En la figura 3 se muestra un esquema, que a modo de resumen, muestra la comunicación de las aplicaciones con el teléfono.
18
Figura 3: Esquema de Aplicaciones
2.2.1. Estado actual de la plataforma En el momento de la redacción de este documento acaba de liberarse la versión 5 del sistema operativo, esta versión incorpora numerosas mejoras que comentaré a continuación. Según Apple, esta nueva versión del sistema operativo presenta más de 200 mejoras, como optimización de la cámara, mejora en el navegador Safari, incorporación del Quiosco, servicio de mensajería (iMessage), etc. Pero de todas estas mejoras hay dos que destacan: iCloud y la mejora de la integración con iTunes. iCloud [2] permite acceder desde cualquier dispositivo de Apple a los archivos, sin necesidad de que tengas que mantener una copia de dicho archivo de forma local en un dispositivo. Además de ofrecer almacenamiento de fotos, música, videos y aplicaciones (sin límite de capacidad) también remplaza al servicio anteriormente conocido como MobileMe como servidor de correo electrónico, almacenando contactos, el calendario y otros datos (limite 5Gb de forma gratuita). El máximo logro en esta versión, es que el usuario no tiene que hacer nada, una vez configurado el servicio, cuando haga una foto o compre una canción, esta se subirá automáticamente a iCloud y podrá acceder desde cualquier equipo, utilizando iCloud incluso como copia de seguridad. En la figura 3 se muestra el logo que utilizó Apple en la presentación de iCloud en WorldWide Developers Conference de 2011.
19
Figura 3: iCloud
iTunes es reproductor y tienda de contenidos multimedia desarrollado por Apple para gestionar la música del usuario. Está basado en la aplicación SoundJam MP, que fue comprada por Apple en el año 2000, liberando la primera versión en Enero de 2001. Los usuarios tienen la posibilidad de organizar su música en lista de reproducción, editar la información de los archivos, grabarlos en CD, etc. Aunque en su srcen iTunes solo se utilizaba para gestionar archivos de música, desde la versión 4.8 (Mayo 2005) también se puede utilizar para reproducir videos y comprar videos, pudiendo encontrar actualmente películas de Disney y Pixar y episodios de series como “Perdidos” . En esta última versión (10.5) se ha añadido soporte para sincronización Wifi e integración con iCloud. En la figura 4 se muestra la imagen que utilizó Apple cuando explicó el objetivo que perseguía con iTunes.
Figura 4: iTunes
2.2.2. Plataforma de distribución La plataforma de distribución por excelencia de Apple es conocida como AppStore, cuyo logo se ve en la figura 5. Es un servicio que permite a los usuarios buscar y descargar aplicaciones informáticas desde iTunes Store o Mac AppStore publicadas por Apple. Las aplicaciones que se suben no siempre son gratuitas, por lo que de lo que el usuario la aplicación, el vendedor recibe un y Apple queda con el 30% restante.paga No por obstante, ese 30% de beneficios que70% obtiene de secada aplicación le otorgaron más de 1.000 millones de dólares a la compañía. Esta plataforma fue inaugurada en Julio de 2008 por medio de una actualización en iTunes. En el mismo momento de la actualización, las aplicaciones estaban listas para ser descargadas, pero debido a un fallo de compatibilidad las aplicaciones no pudieron instalarse hasta un día después. En menos de un año Apple había superado los 1.000 millones de descargas de aplicaciones desde la plataforma. El sistema operativo iOS lleva un sistema de control parental que puede ser utilizado por los usuarios, por este 20
motivo, la aplicaciones también son controladas por edades, actualmente se clasifican en 4+, 9+, 12+ y 17+. En Enero de 2011 Apple anunció que había sido descargada la aplicación número 10.000 millones, por lo que no se puede negar el éxito arrollador que ha tenido esta plataforma.
Figura 5: Logo AppStore
2.3. Symbian Symbian es un sistema operativo producto de la alianza de varias empresas de telefonía móvil entre las que se encuentra Nokia, Sony Ericsson, LG, Siemens, Motorola, etc. Sus orígenes proceden de su antepasado EPOC32 utilizado en PDA’s de PSION. El objetivo de Symbian fue crear un sistema operativo para terminales móviles que pudiera competir con Windows-Phone. En el 2008, Nokia, que poseía el 48% de Symbian, decidió comprar el 52% restante para restablecer la fundación Symbian y convertirlo en código abierto. A pesar de los esfuerzos de Nokia, en Octubre de 2011 anunció que Symbian tendrá soporte hasta 2016, debido a que no está al mismo nivel que sus competidores directos en lo que se refiere a sistemas operativos de última generación (Android, iOS, Windows-Phone y Blackberry). En la figura 6 se puede ver el logo del sistema operativo Symbian.
Figura 6: Logo Symbian
Symbian comenzó a decaer en 2009, cuando fue superado por Android. En el año 2010 perdió la mitad de su cuota de mercado (paso del 40.9% al 22.1%) [4]. Esto se debe principalmente a que el mercado de los Smartphones está en auge, mientras que el de los teléfonos móviles tradicionales (su principal cuota de mercado) está en declive.
2.3.1. Estado actual de la plataforma Symbian^3 es la última versión delEsta sistema Symbian, fue desarrollado por Nokia y funciona en Smartphones. es la operativo primera versión de código abierto de Symbian, la cual se presentó un mes después de haber liberado el código fuente de todo el sistema. Symbian^3 introdujo soporte para HDMI, aceleración de hardware en gráficos 2D y 3D, y mejoras en la interfaz de usuario, entre ellas la consistencia. Tiene un solo menú de opciones y varios escritorios. El kit de desarrollo de esta versión del sistema operativo está disponible desde Octubre de 2011. Los primeros dispositivos en incorporar este sistema fueron los Smartphones desarrollados por Nokia (N8, E7 y C7). 21
En la figura 7 se pueden ver los distintos escritorios que están disponibles en Symbian^3. Aparte de la versión base de Symbian^3, hay además otras dos actualizaciones que están basados en este sistema:
Symbian Anna: Actualización de Symbian^3 con soporte a NFC, un nuevo navegador con mejoras en el rendimiento general y de la batería. Viene instalada por defecto en los nuevos Nokia X7 y E6, y a partir de septiembre de 2011 se actualizaron todos los teléfonos basados en Symbian^3 vía OTA o Ovi Suite.
Symbian Belle: Nueva actualización que viene por defecto en los Nokia 600, 700 y 701 y que también está disponible para teléfonos que funcionan con Symbian^3 y Symbian Anna. Entre sus mejoras destaca la estabilidad y el menor consumo del sistema operativo, nuevas aplicaciones de Microsoft (añade complementos de Office), una nueva interfaz gráfica con un nuevo menú, nueva barra de navegación, un menú de notificaciones deslizable y nueva barra de notificaciones que deja más espacio para las aplicaciones personales. Symbian Belle fue la última versión desarrollada exclusivamente por Nokia, ya que después de que se terminara el trabajo en esta versión, se anunció la retirada del soporte en 2016.
Figura 7: Symbian^3
2.3.2. Plataforma de distribución Symbian no distribuye aplicaciones de otros usuarios (ni propias) mediante ninguna plataforma, no obstante, sí dispone de software para la actualización del sistema y que permite instalar software que haya desarrollado un usuario.
22
Los sistemas operativos Symbian se pueden actualizar usando dos vías. La primera de ellas es conocida como OTA (On the air), aquí solo se actualiza el sistema operativo, utilizando la red Wifi, o mediante 3G se conecta a los servidores de Nokia (usando OVI [5] ), se baja la nueva versión, se auto-instala y listo. Esta opción, no permite ningún tipo de instalación de otro software por lo que su uso es bastante limitado. Otra forma de actualizar Nokia es mediante el software conocido como Ovi. Este servicio puede ser utilizado por el dispositivo cuando se actualiza mediante OTA o puede usarse desde un ordenador mediante Ovi Suite. Nokia ha concentrado el servicio en cinco áreas: Juegos, multimedia, mapas, mensajería y música. Con estos Ovi significa servicios, Nokia pretendía competir con Microsoft, Google y Apple. puerta en finlandés y pretendía que fuera la entrada de los usuarios a una plataforma llena de aplicaciones y servicios. En teoría, permite que usuarios suban sus aplicaciones, recibiendo Nokia un 30% de los beneficios que generen esas aplicaciones; pero debido a que Nokia tiene que dar el visto bueno a la aplicación antes de publicarla, el sistema no es lo eficiente que debería ni es comparable a otras plataformas como Android Market o AppStore. En mayo de 2011, Nokia anuncio que dejará la marca OVI en favor de la marca Nokia.
2.4. Web-OS
Web-OS [6] es un sistema operativo multitarea para sistemas embebidos basado en Linux, propiedad de Hewlett-Packard. Este sistema operativo fue anunciado en Enero de 2009 junto a Palm Pre, posteriormente fue lanzado Palm Pixi, siendo estos los dispositivos más importantes con este sistema operativo. En Agosto de 2011 HP anuncio que retiraría el soporte a este sistema debido a su poco calado en el mercado. La interfaz gráfica de usuario de web-OS fue diseñada para dispositivos con pantalla táctil y se muestra en la figura 8. Incluye un conjunto de aplicaciones para el manejo de la información personal y usa tecnología web como HTML5, JavaScript y CSS. Palm asegura que el diseño alrededor de estas tecnologías fue intencionado, para evitar así el aprendizaje de un nuevo lenguaje de programación por parte de los desarrolladores.
Figura 8: Menú
23
Web-OS
2.4.1. Estado actual de la plataforma En Octubre de 2010 HP liberó la versión 2.0 de web-OS, que contaba con numerosas versiones desde la última versión estable (1.4.5). Entre sus mejoras, destacan la mejora de la interfaz, la inclusión de la característica Synergy, una mejora del navegador Web, el uso de la sincronización y una implementación real de la multitarea. La versión actual de esta plataforma [8] ofrece uno de los gestores multitarea más eficaces a través de un sistema táctil que permite fácilmente cambiar entre varias aplicaciones y notificaciones abiertas. Como novedad, los “montones de cartas” (stacks of cards) es decir, las pantallas abiertas en cada aplicación, se agrupan de forma lógica al abrirlas formalos de elementos trabajar delrelacionados, usuario. Estopor se organiza través de un sistemapara queadaptarse mantienena la unidos ejemplo,a un correo electrónico con una cita en un restaurante y un mapa con la dirección del lugar. La interfaz de Web-OS está basada en el mismo sistema de cartas que la multitarea. Las aplicaciones pueden ser lanzadas ya sea desde el iniciador, o desde el iniciador rápido. El usuario cambia de aplicaciones realizando un gesto en el teléfono para traer las cartas al frente y moviéndose entre ellas, elegir una tarea. Web-OS también soporta gestos multitoque, posibilitando que la mayoría del ingreso de datos pueda ser realizado a través de la pantalla. Web-OS incluye una característica llamada Synergy que permite integrar información de varias fuentes. Web-OS permite al usuario acceder a sus cuentas de Gmail, Yahoo!, Facebook, LinkedIn, etc. Los contactos de todas las fuentes son integrados en una única lista. Los calendarios de diversas fuentes pueden ser vistos todos juntos como uno solo. Para la mensajería, Synergy combina todas las conversaciones con un contacto en una misma ventana de dialogo, por ejemplo, mensajes instantáneos y SMS juntos. El navegador Web utilizado por web-OS está basado en webKit, y por lo tanto renderiza las páginas de forma similar a Safari, Google Chrome y el navegador de Android. El navegador puede ser visto tanto de forma vertical como de forma horizontal, utilizando el acelerómetro del teléfono para detectar la orientación. Una característica del navegador es la habilidad de poder reproducir archivos .pls sin necesidad de una aplicación externa. Además, también tiene soporte para el reproductor de Adobe Flash Player. Por último, está versión del sistema operativo hace uso de la computación en la nube para la sincronización de datos, pero no tiene un cliente de escritorio.
2.4.2. Plataforma de distribución El catálogo de aplicaciones (AppCatalog) es una tienda online de aplicaciones para dispositivos móviles con el sistema operativo Web-OS. El catalogo es similar al AppStore de Apple o al Android Market de Google. No obstante, no ha tenido tanto éxito como las citadas plataformas, ya que, mientras que el AppStore salió al mercado con miles de aplicaciones, AppCatalog [9] solo disponía de 18. No obstante, un año después de lanzar la plataforma unas 125 aplicaciones habían logrado obtener casi 8 millones de descargas [7]. En la figura 9 se muestra el menú del HP App Catalog.
24
Figura 9: HP App Catalog
2.5. Windows-Phone Windows-Phone es un sistema operativo móvil compacto desarrollado por Microsoft, y diseñado para su uso en teléfonos inteligentes y otros dispositivos móviles. Windows-Phone formadel parte de losoperativo sistemas operativos conyinterfaz usuario.de Se basa en el núcleo sistema Windows CE cuenta natural con undeconjunto aplicaciones básicas utilizando las API de Microsoft Windows. Está diseñado para ser similar estéticamente a las versiones de escritorio. Originalmente apareció bajo el nombre de Pocket PC, como una ramificación de desarrollo de Windows CE para equipos móviles con capacidades limitadas. En la actualidad, la mayoría de los teléfonos con Windows-Phone vienen con un estilete digital, que se utiliza para introducir comandos pulsando en la pantalla. Windows-Phone ha evolucionado y cambiado varias veces de nombre, siendo su última versión la llamada Windows-Phone 7 [10]. A lo largo de su historia, Windows-Phone ha ido mejorando en cada una de sus versiones, pero ha conservado algunas características. A continuación enumeraré las características que se han conservado:
Desde las versiones de Pocket PC se incluyen aplicaciones de Microsoft Office. Estas versiones incluyenpero muchas de otras las características que se utilizan en versiones de escritorio, algunas características como la inserción de las tablas e imágenes no se han incluido versiones anteriores a Windows 5.0. ActiveSync tiene la capacidad de convertir archivos de versiones de escritorio a archivos compatibles con Pocket PC. Outlook Mobile es también un programa que viene con Windows Mobile. Esto incluye tareas, calendario, contactos, y la bandeja de entrada. Windows Media Player para Windows-Phone se añade con el software. Actualmente, todas las versiones de Windows-Phone incluyen la versión 9 25
del reproductor, aunque la versión 10 se ha incluido en los nuevos dispositivos. Windows Media Player reproduce diversos formatos de audio y video. Algunas críticas que ha recibido este reproductor es que no soporta los archivos MPEG, por lo que para reproducirlos necesitan programas de terceros. En la pantalla Hoy nos mostrará la fecha actual, la información del dueño, las citas próximas, los mensajes E-mail y las tareas. En la parte inferior aparecerá, generalmente, una barra con dos botones. También incluye una barra que incluye iconos para notificar el estado del Bluetooth, batería, cobertura, etc. En la figura 10 se puede ver una imagen de la pantalla principal de Windows-Phone 7. En la barra de tareas muestra: la hora actual, el volumen y el estado de la conectividad. Cuando un programa o un mensaje están abiertos el espacio en blanco, en el que estaba el reloj se con convierte en icono de ok o en una barra de cerrar. La característica principal de la barra de tareas es el botón de Inicio, que está diseñado para que sea parecido al botón de Inicio de las versiones de escritorio de Windows. El menú de Inicio ofrece programas abiertos realmente, nuevas entradas del menú personalizadas, y accesos directos a programas, ajustes, búsquedas y ayuda. La barra de tareas aparece en la figura 10, en la parte de arriba de la figura. Cliente para redes PPTP.
Figura 10: Windows Phone 7
2.5.1. Estadoseactual de la plataforma Actualmente encuentra disponible la versión 7, también conocida como Windows-Phone 7 [13]. Es un sistema operativo móvil desarrollado por Microsoft como sucesor de la plataforma Windows Mobile. Está pensado para el mercado de consumo generalista en lugar del mercado empresarial por lo que carece de muchas funcionales que proporciona la versión anterior. Microsoft decidió no hacer compatible esta versión con la versión anterior (Windows Mobile 6) por lo que las aplicaciones existentes no funcionan en Windows-Phone 7 haciendo necesario desarrollar nuevas aplicaciones. 26
Con Windows-Phone 7 Microsoft ofrece una nueva interfaz de usuario, integra varios servicios en el sistema operativo y planea un estricto control del hardware que implementará el sistema operativo, evitando la fragmentación con la evolución del sistema. Windows-Phone 7 cuenta con Internet Explorer 9. Windows-Phone 7.5 es una innovación para Windows-Phone 7. Este cambio se anunció en Mayo de 2011, aunque aún se desconoce su fecha de lanzamiento. Durante el anuncio se anunció que traería Internet Explorer 9 de serie, soporte para CSS3 y soporte para usar GPS cuando se trabaje con las aplicaciones de ubicación geográfica, entre otros. En la actualidad, Windows-Phone competidores como Android o iPhone. 7 continúa perdiendo cuota de mercado, frente a A pesar de tener grandes ventajas respecto a su versión anterior, tiene importantes carencias que han sido muy criticadas por parte de los usuarios. Los principales inconvenientes son [12]:
No soporta Adobe Flash No se pueden administrar los archivos (Aunque Microsoft ha dicho que no lo va a incluir) Conexión a puntos Wi-Fi con IP estática Transferencia de ficheros por BlueTooth (Tampoco está en los planes de Microsoft incluirlo) Soporte para voz sobre IP Copias de seguridad Sincronización de contactos y calendario con PC (se elimina el soporte de
ActiveSync) En Febrero de 2011, cuando Nokia anunció que no iba a seguir dando soporte a Symbian, Microsoft informo que había llegado a un acuerdo con dicha compañía por valor de 1.000 millones de dólares para agilizar la migración de los dispositivos a Windows-Phone 7. El objetivo de esta alianza es la de competir con Android e iOS ya que son los que más cuota de mercado tienen y los que están experimentando mayor crecimiento.
2.5.2. Plataforma de distribución
Windows-Phone-MarketPlace [11] es el nombre elegido por Microsoft para su plataforma de distribución de Windows-Phone. Este servicio permite a los usuarios navegar y descargar aplicaciones que han sido desarrolladas por terceros. Al igual que gran parte de los nuevos dispositivos, se presenta en una panorámica vista donde el usuario puede navegar por categorías y títulos, y obtener detalles de valoraciones, comentarios y precios. Esta plataforma tienecon soporte para compras concuenta tarjeta con de crédito, la facturación del operador, y el contenido publicidad. También una opción de probar antes de comprar donde el usuario tiene la opción de descargar una versión de prueba de una aplicación comercial. Tiene 61 categorías divididas en 16 categorías principales y 25 sub-categorías, una aplicación solo se puede colocar en una categoría. La plataforma contará con descargas de podcasts y música proporcionada por Zune. El desarrollo de aplicaciones de Windows-Phone 7 se basa en Silverlight, XNA, y .NET. Las principales herramientas utilizadas para el desarrollo son Visual Studio 2010 27
y Expression Blend. Windows-Phone 7 solo ejecuta aplicaciones que han sido aprobadas por Microsoft y solo están disponibles a través de Windows-PhoneMarketPlace. Los desarrolladores obtienen el 70% de los ingresos [14] realizados por sus aplicaciones o pueden incluir un modelo de publicidad integrado en sus aplicaciones, los estudiantes pueden presentar sus solicitudes de forma gratuita a través del programa Microsoft DreamSpark. Un proceso de aprobación de la aplicación existe para facilitar una restricción a la violencia y a la desnudez, también están prohibidas representaciones de la prostitución o básicamente cualquier cosa que pueda ser calificada para adultos. En la figura 11 se poder ver el menú principal del MarketPlace, en el que el usuario puede buscar las aplicaciones más populares, novedades, categorías, etc.
Figura 11: MarketPlace
2.6. Blackberry OS Blackberry OS es un sistema operativo desarrollado por Research In Motion (RIM) para los dispositivos Blackberry. El sistema permite multitarea y tiene soporte para diferentes métodos de entrada para su uso en ordenadores de mano. La primera versión (1999) permitía el acceso a correo electrónico, navegación web y sincronización con programas como Microsoft Exchange o Lotus Notes aparte de poder hacer las funciones usuales de un teléfono móvil. Blackberry OS está claramente orientado a su uso profesional como gestor de correo electrónico y agenda. Desde la versión 4 se puede sincronizar el dispositivo con el correo electrónico, el calendario, tareas, notas y contactos de Microsoft Exchange Server el cual es compatible con Lotus Notes. Blackberry Enterprise Server proporciona el acceso y organización del email a grandes compañías identificando a cada usuario con un único BlackBerry PIN. Los usuarios más pequeños cuentan con el software Blackberry Internet Service, programas más sencillos que proporciona acceso a Internet y a correo POP3/IMAP sin tener que usar Enterprise Server.
28
Al igual que en el sistema operativo Symbian, desarrolladores independientes también pueden crear programas para Blackberry pero en el caso de querer tener acceso a ciertas funcionalidades restringidas necesitan ser firmados digitalmente para poder ser asociados a una cuenta de desarrollador de RIM. La figura 12 muestra el escritorio de Blackberry OS, esta es la ventana que ven los usuarios cuando arrancan el sistema operativo.
Figura 12: Inicio Blackberry
2.6.1. Estado actual de la plataforma
Actualmente el sistema operativo va por la versión 7 [15], siendo conocido como BlackBerry 7. Los primeros dispositivos que incorporan este sistema son Blackberry Bold 9900 y BlackBerry Bold 9930. Según el fabricante, esta versión está destinada a ofrecer una búsquedas experienciaactivadas de rapidez y facilidad de usodecon notables mejoras en la navegación, por voz, la posibilidad manejar de forma separada el contenido personal del contenido empresarial y la adición de aplicaciones orientadas a la productividad y vida personal. Para empezar, el navegador disfruta de la mejora ofrecida por la interfaz de usuario Liquid Graphics que aporta su contribución a temas de renderizado y zoom, Blackberry 7 usa para su navegador un nuevo compilador de JavaScript llamado JIT (Just in time) que mejora la velocidad de carga de sitios web y soporta HTML 5 [16]. Desde la versión BlackBerry 6 se ofrecía una característica de búsqueda universal, pero ahora, en BlackBerry 7 da un paso adelante al incluir búsquedas activadas por voz. Otra característica que ha sido muy bien acogida es BlackBerry Balance que se encargará de separar la vida personal del usuario de la vida corporativa. Esto lo logra ofreciendo el uso de email, redes sociales como Facebook o Twitter, juegos y contenido multimedia de forma separada a las necesidades corporativas, como por ejemplo, Black Berry Enterprise Server. En lo referido a las aplicaciones, BlackBerry 7 ofrece a los usuarios la versión completa de Docs To Go que les permitirá ver y editar documentos en formatos Word, Excel y PowerPoint directamente en sus dispositivos, y visualizar documentos en formato PDF. El fabricante ha confirmado que no existe soporte para modelos antiguos en BlackBerry 7, por lo que aquellos dispositivos anteriores a esta generación (incluidos modelos con BlackBerry 6) no recibirán de manera oficial la actualización de software 29
por parte del fabricante, así que los usuarios de BlackBerry deberán actualizar sus terminales si quieren disfrutar de esta versión del sistema operativo.
2.6.2. Plataforma de distribución. Blackberry comenzó lanzando dos plataformas de distribución conocidas como Application Center, donde el usuario podía descargar aplicaciones de terceros por un precio, y Application Storefront, que actuaba como un escaparate para que los desarrolladores pudieran comercializar sus aplicaciones [19]. Application Center [18] está disponible desde la versión 4.7 del sistema operativo, y ofrecía a los usuarios un listado con todas las aplicaciones que hay disponibles (ver figura 13). Se puede acceder desde la pantalla de opciones lo que permite también borrar aplicaciones que ya han sido descargadas. Posee actualizaciones automáticas, por lo que las aplicaciones que descarguen los usuarios estarán siempre actualizadas a la última versión.
Figura 13: Application Center
En 2009, Research In Motion (RIM) unió ambas plataforma en una sola conocida como BlackBerry App World [17]. Este servicio proporciona a los usuarios un entorno en el que navegar, descargar y actualizar aplicaciones de terceros. Aunque inicialmente la plataforma sólo estaba disponible en Estados Unidos, Reino Unido y Canadá, actualmente y gracias a varias actualizaciones la plataforma se encuentra disponible en 113 países de todo el mundo, aceptando como sistema de pago Paypal en todos ellos. A diferencia de las plataformas de iOS, Android o Symbian, RIM se queda con el 20% y no el 30% del coste que paga un usuario por una aplicación, yendo el 80% restante al desarrollador.
30
2.7. Conclusiones y valoración personal de las tecnologías P. Distribu- Estado ción Actual
Cod. Abierto
Ventajas
Desventajas
iOS
iTunes/iClo ud
Expandién No dose
Simbyan
OVI
Decayend Parcialmen- Gran A partir de o (Soporte te variedad de 2016 no retirado) terminales tendrá soporte
Web-OS
AppCatalog Soporte retirado
WindowsPhone
MarketPlace
Expandién No dose
ConectiviPlataforma dad con cerrada Windows en PCs
Blackberry
AppCenter
Se mantiene
Fiabilidad en el ámbito La lo mayoría utilizan empresarial para uso profesional.
No
No
Gran Plataforma expansión. cerrada. Facilidad de uso.
Diseñado para tabletas
Soporte retirado
Tabla 1: Plataformas Móviles
Durante este capitulo he estado hablando de las distintas tecnologías móviles que hay en el mercado. Me he centrado en aquellas que son más importantes o en las que hasta hace poco tiempo, eran mayoritarias entre los usuarios. Me he decantado por Android (descrita ampliamente en el capitulo siguiente), porque en la actualidad es una plataforma que está en auge, que ofrece muchísimas posibilidades de desarrollo, y a que al estar disponible en código abierto, puede ser personalizada desde cero. En caso de tener que elegir otra plataforma, me decantaría por utilizar iOS, ya que es la que mantiene el 2º mayor cuota de mercado y además, a diferencia de Blackberry, está orientada a los usuarios para su uso personal y no para las empresas. Por lo que al ser el objetivo de este proyecto, una aplicación para que un usuario encuentre a sus amigos y los lugares que le gustan a estos, obviamente, no está desarrollada para un uso profesional. Por último, a la hora de desarrollar el proyecto descartaría Symbian y Web-OS, ya que los desarrolladores de ambas plataformas ya han anunciado el cese del soporte a dichas tecnologías. El software de HP ya no tiene soporte, y está siendo retirado del mercado, mientras que Symbian tendrá soporte hasta 2016, y será a partir de ese 31
momento cuando Nokia deje definitivamente la plataforma para apostar por WindowsPhone.
32
Plataforma Android 3.1. Introducción Android es una plataforma de software y sistema operativo para dispositivos móviles basada en un kernel de Linux, desarrollada por Google y más tarde por la Open Handset Alliance. Esta plataforma permite a los desarrolladores escribir código en Java que se ejecuten en móviles mediante las librerías Java desarrolladas por Google. También se pueden escribir aplicaciones en otros lenguajes, como por ejemplo C, para posteriormente compilarlas en código nativo ARM y ejecutarlas, aunque este proceso de desarrollo no está soportado oficialmente por Google. La mayor parte de la plataforma de Android está disponible bajo licencia de software libre de Apache y otras licencias de código abierto.
3.2. Historia de Android Android Inc. fue fundada en Palo Alto, California, en Estados Unidos por Andy Rubin, Rich Minner, Nick Sears y Chris White en Octubre del año 2003 [20]. La compañía fue adquirida por Google solo dos años más tarde y desde entonces todo ha sido una carrera de desarrollo de implementación de tecnologías. En esa época, poco se sabía que las funciones de Android Inc. fueran el desarrollo de software para telefonías 33
móviles. Esto dio pie a rumores de que Google estaba planeando entrar en el mercado de los teléfonos móviles. Ya en Google, un equipo liderado por Rubin, desarrolló una plataforma para dispositivos móviles basada en el kernel de Linux que fue promocionando a fabricantes de dispositivos y operadores con la promesa de proveer un sistema flexible y actualizable. Se informó que Google había alineado ya una serie de fabricantes de hardware y software y señaló a los operadores que estaba abierto a diversos grados de cooperación por su parte. La especulación sobre que el sistema Android de Google entraría en el mercado de la telefonía móvil se incrementó en diciembre 2006. Informes de BBC y The Wall Street Journal señalaron que Google quería sus de servicios de búsqueda y aplicaciones en teléfonos móviles y estaba muy empeñado en ello. Medios impresos y en línea informaron que Google estaba desarrollando un teléfono con su propia marca. En septiembre de 2007, se informó que Google había solicitado diversas patentes en el área de telefonía móvil. El 5 de noviembre de 2007 la Open Handset Alliance, un consorcio de varias compañías entre las que están Nvidia, Intel, LG, Motorola; se estrenó con el fin de desarrollar estándares abiertos para dispositivos móviles construidas en la versión 2.6 del kernel de Linux. El 9 de Diciembre de 2008, se anunció que 14 nuevos miembros se unirían al proyecto Android, incluyendo Sony Ericsson, Toshiba, Vodafone, etc.
3.2.1. Historial de actualizaciones
Android ha visto numerosas actualizaciones desde su liberación inicial [21]. Estas actualizaciones al sistema operativo base típicamente arreglan bugs y agregan nuevas funciones. Generalmente cada actualización del sistema operativo Android es desarrollada bajo un nombre en código con un elemento relacionado con postres. Android ha sido criticado muchas veces por la fragmentación que sufren sus terminales al no ser soportado con actualizaciones constantes por los distintos fabricantes. Sin embargo, esta situación cambiará con un anuncio que hizo oficial Google en el que comunico que los fabricantes se comprometerán a aplicar actualizaciones al menos 18 meses desde su salida al mercado. El primer teléfono en el mercado que posee Android es el T-Mobile G1 (también conocido como Dream), lanzado el día 22 de octubre de 2008 que venía con la versión 1.0 de Android preinstalada. Este móvil es el resultado conjunto de T-Mobile, HTC y Google. Desde el 21 de Octubre de 2008, Android está disponible como código abierto. Gracias a esto, cualquiera puede añadir nuevas aplicaciones o remplazar las existentes por otras dentro del dispositivo móvil. La última versión de Android fue presentada en Octubre 2011, esta versión es la 4.0, también conocida como IceCream Sandwich y presento numerosas mejoras respecto a las versiones 2.3.4 (móviles) y 3.2 (tabletas). En la figura 14 se muestra la cuota de mercado de cada distribución de Android siendo la versión 2.2 o Froyo la más extendida.
34
Figura 14: Distribución del SO
3.3. Características de Android Android posee numerosas características, que son básicas en las distintas versiones del sistema operativo:
Amplia variedad de diseños Almacenamiento de datos en BBDD SQLite Conectividad con redes GSM, UMTS, Wi-Fi, Bluethoot, etc. Mensajería mediante SMS y MMS
Navegador web de Java Máquina virtual Las aplicaciones escritas en Java pueden ser compiladas y ejecutadas en la máquina virtual de Dalvik, la cual es una máquina virtual especializada en el uso de dispositivos móviles. Soporte para distintos formatos como MP3, JPEG, PNG, etc. Soporte para hardware adicional (GPS, acelerómetros, etc.) Entorno de desarrollo (emulador, herramientas de depuración, perfiles de memoria y funcionamiento, plugin para Eclipse IDE (ver Anexo I)) Catálogo de aplicaciones gratuitas o de pago conocida como Android Market Además de las ya citadas, la versión 4.0 de Android incluye las siguientes características:
Unifica el uso en cualquier dispositivo, tanto en teléfonos, tabletas, televisores, notebooks, etc. Interfaz limpia y moderna con una nueva fuente llamada Roboto. Similar a la utilizada por la versión 3.0/3.1/3.2 en las tabletas Opción de utilizar los botones virtuales de la interfaz de usuario, en lugar de los botones táctiles capacitivos. Llega la aceleración por hardware, lo que significa que la interfaz podrá ser manejada y dibujada por la GPU y aumentando notablemente su rapidez y su respuesta. 35
Multitarea mejorada. Añadiendo la posibilidad de finalizar una rarea simplemente desplazándola fuera de la lista. Añadido un gestor del tráfico de datos de Internet. El entorno permite establecer alertas cuando llegue a una cierta cantidad de uso y desactivación de los datos cuando se pasa de su límite. Los widgets están en una nueva pestaña, que figuran en una lista similar a las aplicaciones en el menú principal. El corrector de texto ha sido rediseñado y mejorado, ofreciendo la opción de tocar en una palabra para que nos aparezca una lista con las diferentes opciones de edición y sugerencias de palabras similares. Las notificaciones tienen la posibilidad de descartar las que no son importantes y también desplegar la barra de notificaciones con el dispositivo bloqueado. La captura de pantalla, con solo pulsando el botón de bajar volumen y el botón de encendido. La aplicación de cámara ofrece nuevas utilidades como la posibilidad de hacer fotografías panorámicas de forma automática. Android Beam es la nueva característica que nos permitirá compartir contenido entre teléfonos usando NFC (Near Field Comunication) Reconocimiento de voz del usuario. Aplicación de teléfono nuevo con funcionalidad de buzón de voz visual que le permite adelantarlo o retroceder los mensajes de voz. Reconocimiento facial. Las carpetas son mucho más fáciles de crear, con un estilo de arrastrar y soltar. Un único y nuevo framework para las aplicaciones. Soporte nativo para MKV. Soporte nativo para el uso de Stylus (lápiz táctil).
3.4. Arquitectura de Android Para empezar con el desarrollo de aplicaciones en Android es importante conocer como está estructurado este sistema operativo [22]. A esto le llamamos arquitectura y en el caso de Android está formado por varias capas que facilitan al desarrollador la creación de aplicaciones. Además, esta distribución permite acceder a las capas más bajas mediante el uso de librerías para que así el desarrollador no tenga que programar a bajo nivel las funcionalidades necesarias para que una aplicación haga uso de los componentes hardware de los teléfonos. Cada una de las capas utiliza elementos de la capa inferior para realizar sus funciones, es por ello que a este tipo de arquitectura se le conoce también como pila. Para entender mejor, en la figura 15 cito el diagrama de la arquitectura de Android tomada del sitio web de Android developers:
36
Figura 15: Arquitectura Android
Como se verá a continuación, Android nos proporciona un entorno sumamente poderoso que podamos programar aplicaciones que hagan cosa. Nada dentro de para Android es inaccesible y podemos jugar siempre concualquier las aplicaciones del teléfono para optimizar cualquier tarea. El potencial de Android se sitúa en el control total que se le da al usuario para que haga de su teléfono un dispositivo a su medida. A continuación explicare cada una de las capas iniciando de abajo hacia arriba.
3.4.1. Linux Kernel El núcleo del sistema operativo Android está basado en el kernel de Linux versión 2.6, similar al que puede incluir cualquier distribución de Linux, como Ubuntu, solo que adaptado a las características del hardware en el que se ejecutará Android, es decir, para dispositivos móviles. El núcleo actúa como una capa de abstracción entre el hardware y el resto de las capas de la arquitectura. El desarrollador no accede directamente a esta capa, sino que debe utilizar las librerías disponibles en capas superiores. De esta forma también se evita el hecho de conocer las características precisas de cada teléfono. Si se necesita hacer el uso de la cámara, el sistema operativo se encarga de utilizar la que incluya el teléfono, sea cual sea. Para cada elemento de hardware del teléfono existe un controlador dentro del kernel que permite utilizarlo desde el software. El kernel también se encarga de gestionar los diferentes recursos del teléfono (energía, memoria, etc.) y del sistema operativo en sí: procesos, elementos de comunicación, etc.
37
3.4.2. Libraries La siguiente capa se sitúa justo encima del kernel. La componen las bibliotecas nativas de Android, también llamadas librerías (libreries). Están escritas en C o C++ y compiladas para la arquitectura hardware especifica del teléfono. Estas normalmente están hechas por el fabricante, quien también se encarga de instalarlas en el dispositivo antes de ponerlo a la venta. El objetivo de las librerías es proporcionar funcionalidad a las aplicaciones para tareas que se repiten con frecuencia, evitando tener que codificarlas cada vez y garantizando que se llevan a cabo de forma “ más eficiente”. Entre las librerías incluidas encontramos OpenGL (motor gráfico), Biblioteca multimedia (formatos de audio, imagen y video), Webkit (navegador), SSL otras. (cifrado de comunicaciones), FreeType (fuentes de texto), SQLite (base de datos), entre
3.4.3. Android Runtime Como podemos apreciar en el diagrama, el entorno de ejecución de Android no se considera una capa en sí mismo, dado que también está formado por librerías. Aquí encontramos las librerías con las funcionalidades habituales de Java así como otras específicas de Android. El componente principal del entorno de ejecución de Android (Android es la máquina virtual Dalvik. Las aplicaciones se codifican en Java y son compiladas en un formato específico para que esta máquina virtual las ejecute. La ventaja de esto es que las aplicaciones se compilan una única vez y de esta forma estarán listas para distribuirse con la total garantía de que podrán ejecutarse en cualquier dispositivo Android que disponga de la versión mínima del sistema operativo que requiera la aplicación. Runtime)
Cabe destacar que Dalvik es una variación de la máquina virtual de Java, por lo que no es compatible con el bytecode Java. Java se usa únicamente como lenguaje de programación, y los ejecutables que se generan con el SDK de Android tienen la extensión .dex que es específico para Dalvik, y por ello no podemos ejecutar aplicaciones Java en Android ni viceversa.
3.4.4. Application Framework La siguiente capa está formada por todas las clases y servicios que utilizan directamente las aplicaciones para realizar sus funciones. La mayoría de los componentes de esta capa son librerías Java que acceden a los recursos de las capas anteriores a través de la máquina virtual Dalvik. Siguiendo el diagrama encontramos: 1. Activity Manager. Se encarga de administrar la pila de actividades de nuestra aplicación así como su ciclo de vida. 2. Windows Manager. Se encargara de organizar lo que se mostrará en pantalla. Básicamente crea las superficies en la pantalla que posteriormente ser ocupadas las actividades. 3. pasarán Contenta Provider . Estaporlibrería es muy interesante porque crea una capa que encapsula los datos que se compartirán entre aplicaciones para tener control de cómo se accede a la información. 4. Views. En Android, las vistas los elementos que nos ayudarán a construir las interfaces de usuario: botones, cuadro de texto, lista y hasta elementos más avanzados como un navegador Web o un visor de Google Maps. 5. Notification Manager. Engloba los servicios para notificar al usuario cuando algo requiera su atención mostrando alertas en la barra de estado. 38
Un dato importante es que esta biblioteca también permite jugar con sonidos, activar el vibrador o utilizar los LEDs del teléfono en caso de tenerlos. 6. Package Manager. Esta biblioteca permite obtener información sobre los paquetes instalados en el dispositivo Android, además de gestionar la instalación de nuevos paquetes. Con paquete nos referimos a la forma en que se distribuyen las aplicaciones Android, estos contienen el archivo .apk, que a su vez incluyen los archivos .dex con todos los recursos y archivos adicionales que necesite la aplicación, para facilitar su descarga e instalación. 7. Telephony Manager. Con esta librería podremos realizar llamadas o enviar y recibir SMS/MMS, aunque no permite remplazar o eliminar la actividad que se muestra cuando una llamada está en curso. 8. Resource Manager. Con esta librería podremos gestionar todos los elementos que forman parte de la aplicación y que están fuera del código, es decir, cadenas de texto traducidas a diferentes idiomas, imágenes, sonidos o layouts. 9. Location Manager. Permite determinar la posición geográfica del dispositivo Android mediante GPS o redes disponibles y trabajar con mapas. 10. Sensor Manager. Nos permiten manipular los elementos de hardware del teléfono como el acelerómetro, giroscopio, sensor de luminosidad, sensor de campo magnético, brújula, sensor de presión, sensor de proximidad, sensor de temperatura, etc. 11. Cámara. Con esta librería podemos hacer uso de la(s) cámara(s) del dispositivo para tomar fotografías o para grabar video. 12. Multimedia. Permiten reproducir y visualizar audio, video e imágenes en el dispositivo.
3.4.5. Aplications En la última capa se incluyen todas las aplicaciones del dispositivo, tanto las que tienen interfaz de usuario como las que no, las nativas (programadas en C o C++) y las administradas (programadas en Java), las que vienen preinstaladas en el dispositivo y aquellas que el usuario ha instalado. En esta capa encontramos también la aplicación principal del sistema: Inicio (Home) o lanzador (Launcher), porque es la que permite ejecutar otras aplicaciones mediante una lista y mostrando diferentes escritorios donde se pueden colocar accesos directos a aplicaciones o incluso widgets, que son también aplicaciones de esta capa. La arquitectura Android esta dividida en cuatro capas, en la que cada capa se comunica con la capa directamente inferior. Las aplicaciones de los usuarios están en la capa y estascon sololasselibrerías pueden ycomunicar con losvirtual, frameworks aplicaciones, estos superior se comunican con la maquina y pordeultimo, estas librerías y la maquina virtual se comunican con el núcleo del sistema.
3.5. Android SDK
Android SDK [23], es el kit de desarrollo necesario para crear aplicaciones para Android, el sistema operativo móvil de Google y de Open Handset Alliance. En el kit de desarrollo Android podemos encontrar todas las herramientas que los programadores necesitan para crear aplicaciones: entornos de desarrollo y depuración, 39
librerías, un emulador de móviles, documentación, tutoriales, código de ejemplo, etc. El entorno de desarrollo oficialmente soportado es Eclipse conjuntamente con el plugin ADT proporcionado por Google. Desde noviembre del 2007 han ido surgiendo nuevas actualizaciones del SDK, siendo la ultima la 4.0, la cual soluciona algunos errores de las anteriores, añade nuevas funcionalidades y cambios en las API’s y ofrece compatibilidad con la última versión de Android (IceCream Sandwich). Por defecto, hay dos repositorios de componentes para el SDK: Repositorio de Android (Android Repository) y añadidos de terceras partes ( Third party Add-ons).
El repositorio de Android ofrece los siguientes componentes:
Pre-instalado en el paquete inicial de Android SDK. Contienen herramientas para depurar y probar una aplicación y otras herramientas. Herramientas de la plataforma SDK: Contiene herramientas que son necesarias para desarrollar y depurar la aplicación, pero que se desarrollan junto a la plataforma Android con el fin de apoyar las características mas recientes. Esas herramientas se actualizan normalmente solo cuando se libera una nueva plataforma. Plataforma Android: Una plataforma SDK esta disponible para todas las plataformas de despliegue para Android. Cada componente de la plataforma Android incluye una biblioteca totalmente compatible y cualquier herramienta de la versión especifica. Driver USB para Windows: Contiene los archivos necesarios para poder instalar el SDK en un ordenador con un sistema operativo de Windows y así poder probar y depurar aplicaciones con ese sistema operativo. El driver USB no es necesario a no ser que se vayan a probar aplicaciones en un sistema real. Ejemplos: Contiene códigos de ejemplo y aplicaciones para cada plataforma de desarrollo de Android. Documentación: Contiene una copia local de la ultima versión de la documentación para la API de Android. SDK Tools:
3.6. Estructura de una aplicación de Android Dentro de una aplicación de Android hay cuatro componentes principales: Activity, Listeners, Servicios y Content Provider. Todas las aplicaciones de Android están formadas por algunos de estos elementos o combinaciones de ellos [29].
3.6.1. Activity
Un Activity [24] es una clase concentrada en lo que el usuario puede hacer. Casi todos los Activities actúan con el usuario, así que el Activity crea una ventana donde el desarrollador localiza los elementos de la interfaz de usuario. Se puede afirmar que cada vista es un Activity, por lo que cuando se cambie de vista, también se cambiará de Activity. Cuando cambiamos de vista, la anterior se queda pausada y puesta en una pila esperando una llamada al método OnResume() para volver al primer plano. También se pueden eliminar vistas de la pila en caso de que no vayan a ser necesitadas en el futuro. 40
Al crear una clase que extienda de Activity hay que implementar al menos la función OnCreate(), que es la que se ejecuta cuando se crea el Activity. Por defecto, esta función recibe un objeto que contiene el estado anterior de la actividad en caso de que haya sido suspendida. Para comunicarse entre Activities, también se utiliza este objeto que recibe la función OnCreate() pero esta vez utilizando la clase Intent (4.5.1.1). A continuación voy a mostrar una imagen que resume muy bien el ciclo de vida de un Activity, en la figura 16 se pueden ver los principales métodos y el orden de ejecución [25].
Figura 16: Ciclo de vida de un Activity
3.6.1.1. Intent Un Intent [26] es una descripción abstracta de una operación que va a ser llevada a cabo. Se puede usar al lanzar un Activity, para enviar componentes a otro Activity que esté esperando a recibirlos.
Un Intent proporciona gran facilidad para realizar enlaces en tiempo de ejecución entre distintas aplicaciones. Su uso más importante está en el inicio de los Activities, ya que se puede considerar como la unión entre varios. Se trata básicamente de una estructura de datos pasiva con una descripción abstracta de la acción a realizar. Las dos partes más importantes de un Intent son la acción que se quiere realizar y la información necesaria que se proporciona para poder realizarla, la cual se expresa en formato URI. Relacionado con los Intent hay una clase llamada IntentFilter que es una descripción de que Intents puede gestionar un Activity. Mediante los IntentFilters, el sistema puede resolver Intents, buscando cuales posee cada 41
y escogiendo aquél que mejor se ajuste a sus necesidades. El proceso se realiza en tiempo real, lo cual ofrece dos beneficios: Activity
Los Activities pueden utilizar funcionalidades de otros componentes. Los Activities pueden ser remplazados por nuevos Activities con IntentFilters equivalentes.
3.6.2. Listeners Un Listener es una interfaz en la clase View que contiene un solo método de devolución de llamada. Este método será llamado por el framework de Android cuando la vista con en aunque ha sido usuario elemento de registrado la interfaz. el detector sea provocado por la interacción del Se utilizan para reaccionar a eventos externos, pero, aunque no tienen interfaz de usuario, pueden utilizar el servicio NotificationManager para avisar al usuario. Para lanzar un aviso no hace falta que la aplicación se esté ejecutando, en caso necesario, Android la iniciará si se activa el Listener por algún evento.
3.6.3. Servicios
Un servicio [27] es una aplicación que corre de forma automática, sin interacción con el usuario. Desarrollan tareas importantes para el resto de las aplicaciones o para el sistema. En Android los servicios no son independientes, corren en el mismo proceso que la aplicación que los consume. En caso de que haya múltiples servicios a la vez, se les puede indicar diferentes prioridades según las necesidades
3.6.4. Content Provider En Android, las aplicaciones pueden guardar su información en ficheros, base de datos SQLite, etc. Pero en caso de que lo que se quiera sea compartir dicha información con otras aplicaciones, lo necesario es un Content Provider. Un Content Provider es una clase que implementa un conjunto estándar de métodos que permite a otras aplicaciones guardar y obtener la información que maneja dicho Content Provider. 3.6.4.1. Android Manifest Toda aplicación Android tendrá un archivo llamado AndroidManifest.xml [28] en el directorio raíz del proyecto. El Android Manifest contiene información esencial necesaria sobre el sistema Android, información que además es necesaria antes de poder ejecutar cualquier línea de código. El contenido más importante del documento es el siguiente:
Nombre del paquete Java. Este nombre sirve como un identificador único de la aplicación. Describe todos los componentes de la aplicación (Activity, Servicios, Broadcast receivers y Content providers). Nombra cada clase y el componente que implementa. De esta forma el sistema Android sabe que componentes hay y bajo qué condiciones se ejecutaran. El Android Manifest también determina qué procesos contendrán los componentes de la aplicación. 42
Determina qué permiso tiene la aplicación para acceder a partes protegidas de la API e interactuar con otras aplicaciones. También determina qué permisos tienen otros para acceder a los componentes de la aplicación. Lista las clases de instrumentación que proporcionan perfiles y otra información de ejecución. Esta declaración solo estará presente en el desarrollo y pruebas, cuando la aplicación es publicada se elimina. Declara el nivel mínimo del API de Android. Por último, el Android Manifest lista las librerías que deben enlazarse a la aplicación.
A continuación se muestra la figura 17 que pertenece al Android Manifest de este proyecto. En el apartado correspondiente lo explicare en profundidad.
Figura 17: Android Manifest en XML
3.7. Aplicaciones en Android Las aplicaciones para Android se instalan con un archivo con extensión .apk. Este formato es una variante del formato JAR de java y se usa para distribuir e instalar componentes empaquetados para la plataforma Android para móviles. Un archivo .apk normalmente contiene lo siguiente:
AndroidManifest.xml Clases.dex Resources.arsc Res(carpeta) META-INF (carpeta)
Estos ficheros pueden ser abiertos e inspeccionados usando un software archivador de ficheros como 7-zip, WinZip, WinRAR o ARK.
3.7.1. Tareas Al lanzar una aplicación se crea una tarea que contendrá una pila con las actividades que se vayan creando. Una tarea en Android es lo que el usuario ve como una aplicación y el desarrollador ve como una o más Activities donde el usuario interacciona y va pasando de Vista en Vista. 43
Dentro de las tareas, una actividad toma el papel de punto de entrada (será la primera en mostrarse cuando se ejecute la aplicación) y las demás, si hay, formarán parte de la misma tarea, a la espera de ser instanciadas.
3.7.2. Procesos
Una aplicación Android corre dentro de su propio proceso Linux [30], por tanto, una característica fundamental de Android es que el tiempo y ciclo de vida de una aplicación no está controlado por la misma aplicación sino que lo determina el sistema a partir de una combinación de estados como pueden ser qué aplicaciones están funcionando, qué prioridad tienen para el usuario y cuánta memoria queda disponible en el sistema. Como ya se ha mencionado, cada aplicación de Android corre en su propio proceso, el cual es creado por la aplicación cuando se ejecuta y permanece hasta que la aplicación deja de trabajar o el sistema necesita memoria para otras aplicaciones. Android sitúa cada proceso en una jerarquía de importancia basada en estados, como se puede ver a continuación:
Proceso en primer plano ( Active process). Es un proceso que aloja una Activity en la pantalla y con la que el usuario esta interactuando (su método onResume() ha sido llamado) o que in IntentReceiver está ejecutándose. Este tipo de procesos serán eliminados como último recurso si el sistema necesitase memoria. Proceso visible (Visible process). Es un proceso que aloja un Activity pero no está en primer plano (su método onPause() ha sido llamado). Esto ocurre en situaciones donde la aplicación muestra un cuadro de dialogo para interactuar con el usuario. Este tipo de procesos no será eliminado en caso
que seacorriendo. necesaria la memoria para mantener a todos los procesos del primer plano Proceso de servicio (Started Service process). Es un proceso que aloja un Service que ha sido iniciado con el método startService(). Este tipo de procesos no son visibles y suelen ser importantes para el usuario (conexión con servidores, reproducción de música). Proceso en segundo plano (Background process). Es un proceso que aloja un Activity que no es actualmente visible para el usuario (su método onStop() ha sido llamado). Normalmente la eliminación de estos procesos no suponen un gran impacto para la actividad del usuario. Es muy usual que existan numerosos procesos de este tipo en el sistema, por lo que el sistema mantiene una lista para asegurar que el último proceso visto por el usuario sea el último en eliminarse en caso de necesitar memoria. Proceso vacío (Empty process): Es un proceso que no aloja ningún componente. La razón de existir de este proceso es tener una caché disponible de la aplicación para su próxima activación. Es común, que el sistema elimine este tipo de procesos con frecuencia para obtener memoria disponible. Según esta jerarquía, Android prioriza los procesos existentes en el sistema y decide cuales han de ser eliminados, con el fin de liberar recursos y poder lanzar la aplicación requerida. Para los procesos en segundo plano, existe una lista llamada LRU (Least Recently Used). En función de esta lista se van eliminando los procesos; los primeros que se
44
eliminan son aquellos que llevan más tiempo sin usarse. Así el sistema se asegura de mantener vivos los procesos que se han usado recientemente. A continuación muestra la figura 18 con la pila de procesos y la posición de cada uno de los indicados anteriormente:
Figura 18: Pila de procesos
El objetivo de la pila de procesos es:
Mejora la estabilidad o seguridad de las aplicaciones. Reducir la sobrecarga de proceso ejecutando el código de múltiples aplicaciones en el mismo proceso. Ayudar al sistema a gestionar los recursos separando partes del código pesado en un proceso separado que puede ser eliminado independientemente de otras partes de la aplicación.
3.7.3. Hilos Aunque cada aplicación se ejecuta en proceso distinto, todos los componentes y procesos de dicha aplicación (en principio) corren en el mismo hilo [31]. Esto se puede modificar con el atributo process de cada componente (Activity, provider, receiver, y Service). En la etiqueta application del Manifest podemos poner este atributo para que sea aplicado a todos sus elementos. Para gestionar tareas pesadas podemos usar hilos para ejecutar dichas tareas en un hilo aparte (ejecutarlas en segundo plano). Para llevar a cabo esta operación usaremos el objeto Thread de java, aunque Android proporciona otros objetos para facilitar el trabajo, como Handler, AsyncTask o Looper (entre otros).
3.8. Recursos Android soporta principalmente dos tipos de recursos: archivos XML y archivos raw (como imágenes, audio, video, etc.). Incluso dentro de los archivos XML, se verá, que en algunos casos los recursos están definidos como valores dentro del archivo XML (las cadenas de texto, por ejemplo). En otras ocasiones, un archivo XML es un recurso por sí mismo, como los Layout [32].
45
Podemos encontrar dos tipos de archivos XML: uno se compilará a formato binario y el otro se copiará tal como es al dispositivo. Como ejemplo podemos poner los ficheros XML de recursos String y los ficheros de layout, ambos se compilaran a un formato binario antes de formar parte del paquete de instalación. Estos ficheros XML tienen formatos predefinidos en los que los nodos XML se traducen a IDs. También se pueden guardar los archivos XML con su formato propio, estos archivos no serán interpretados y se les asignará un ID de recurso para poder identificarlos. Sin embargo, podemos querer que estos ficheros también se compilen a un formato binario. Para lograrlo, hay que colocarlos en el directorio ./res/xml. En tal caso, deberemos usar los lectores XML que proporciona Android para acceder a los nodos del fichero. Si se coloca cualquier tipo de archivo, incluyendo ficheros XML, bajo ./res/raw, no se compilarán a un formato binario. Para leer estos archivos habría que usar Strem. Los archivos de audio y video entran también en esta categoría. Los recursos se almacenan en varios subdirectorios según su tipo, a continuación se indicarán los subdirectorios más importantes de la carpeta:
Anim: Archivos compilados de animaciones Drawable: Bitmaps Layout: Definición de vistas e interfaces de usuario Values: Arrays, colores, dimensiones, string y estilos Xml: ficheros XML arbitrarios Raw: ficheros raw no compilados
El compilador de recursos AAPT (Android Asset Packagin Tool), compila todos los recursos los raw el y lo coloca fichero .apkAndroid (Android package) Estea fichero esexcepto el que contiene código de en laselaplicaciones y los recursos,final. similar los .jar de Java. Estos ficheros son los que se usan para instalar aplicaciones en Android.
3.9. Herramientas de desarrollo Para poder desarrollar para Android hay que tener un software específico y cumplir unos requisitos hardware mínimos. En el Anexo I indicaré a modo de manual cuales son esos requisitos y los pasos que hay que seguir para poder desarrollar aplicaciones para Android. Para poder instalar el SDK de Android es necesario tener instalado previamente la maquina virtual de Java y el IDE Eclipse. El SDK nos proporciona las herramientas básicas de desarrollo en Android, por lo que una vez descargado de la pagina oficial, es necesario incluirlo en Eclipse para poder compilar los proyectos y poder probarlos. Además de la máquina virtual de Dalvik, se instala también un emulador de Android configurable, lo que permite poder probar las aplicaciones sin necesidad de tener un teléfono real con el sistema operativo. Para poder todas las características de los emuladores de Android es necesario tener activa una conexión telnet con el emulador que se esté ejecutando.
3.10.Conclusiones En este capítulo se han explicado en profundidad las distintas características de Android, se ha profundizado en el diseño del sistema operativo, explicando desde el núcleo (basado en Linux) hasta los distintos frameworks que hay en capas superiores y que permiten la comunicación de la aplicación con las capas intermedias e incluso con 46
el núcleo. Además de la estructura del núcleo, también se ha explicado el ciclo de vida de una aplicación, así como el funcionamiento de los distintos métodos que se heredan de la clase Activity. También se han explicado los diferentes aspectos que hay que tener en cuenta a la hora de desarrollar una aplicación. Como pueden ser el uso de servicios, Intent, la estructura del manifiesto, etc. Por último se ha explicado el uso que hacen las aplicaciones de hilos, procesos, etc. Utilizar Android presenta una serie de ventajas y desventajas, que enumeraré a continuación: Ventajas:
Código abierto: El hecho de que Android esté liberado con licencia Apache y código abierto lo convierte en un sistema operativo totalmente libre para que un desarrollador no solo pueda desarrollar su código sino también mejorarlo. A través de esas mejoras puede publicar el nuevo código y con el ayudar a mejorar el sistema operativo para futuras versiones sin depender de fabricantes u operadoras para ver si se libera o no dicha mejora. Del mismo modo, al ser código abierto garantiza que, en caso de haber un bug o error, sea detectado y reparado con mayor rapidez al no existir ninguna traba legal para indagar en su interior ni depender de nadie para pedir autorización en su cambio. Libertad: Android da completa libertad al propietario de un terminal a instalar lo que quiera, sea desde Android Market o desde un ejecutable aparte, no limitando la libertad del usuario ni imponiendo software propietario para poder instalar desde el cable USB. Comunidad: Android no solo cuenta con la comunidad más grande mundial de desarrolladores sino también el mayor de estos de eventos, competiciones y reuniones así cómo múltiples víascon de multitud comunicación como foros y chats oficiales para fomentar la participación y la colaboración para encontrar mejoras e ideas para futuras versiones. Personalizable: Al ser abierto y libre, Android es completamente personalizable tanto por usuarios (instalando fondos de pantalla, aplicaciones, widgets, etc…) como para fabricantes con la posibilidad de
crear sus propias capas como HTC Sense permitiendo a unos y a otros poder personalizar sus teléfonos de la mejor manera posible y dando a elegir al usuario la interfaz más adecuada para su gusto, evitando imponer un determinado estilo o interfaz Multitarea: Android con un sistema multitarea inteligente es capaz de gestionar varias aplicaciones abiertas a la vez dejando en suspensión aquellas que no se utilicen y cerrarlos en caso de resultar ya inútiles para evitar un consumo de memoria innecesario. No solo móviles: La libertad del código de Android ha hecho que en poco tiempo se implante en multitud de dispositivos electrónicos, desde móviles hasta ordenadores portátiles e incluso navegadores de abordo en coches. Esto convierte a Android en un sistema operativo multifunción y completamente escalable que garantizará su crecimiento y expansión en el futuro. Desventajas:
Duración de la batería: El consumo de batería en sistemas Android no está optimizado, un usuario que utiliza mucho sus aplicaciones la batería tiende 47
a no durar. De todas formas, hay aplicaciones externas que permiten optimizar el uso de la batería. Fragmentación: Android está totalmente fragmentado provocando problemas de incompatibilidad con algunas aplicaciones del Market que funcionan en determinadas versiones de Android. Oficialmente Android tiene la versión 2.1, 2.2, 2.3 y próximamente la versión 4 (además de la 3.0, 3.1 y 3.2 para tabletas). Multitarea: A pesar de ser una ventaja el ser un sistema multitarea, el hecho de tener varias aplicaciones abiertas hacen que el consumo de la batería aumente y como Android no cierra todas las aplicaciones hay que instalar una aplicación para que las cierre.
48
Aplicación Facebook-Tourism 4.1. Introducción En este capítulo me voy a centrar en la aplicación que he desarrollado para este proyecto. Comenzaré explicando cómo crear una aplicación sencilla, la he realizado basándome en un manual. Esta aplicación sirve como toma de contacto con el entorno, y en los siguientes apartados me centraré en el desarrollo del Facebook-Tourism. En la sección de Facebook-Tourism comenzaré hablando de Google, ya que es la empresa que ha desarrollado Android, seguidamente hablaré de Facebook ya que también es una parte muy importante de la aplicación, por ultimo entraré a explicar detalladamente todos los aspectos de la aplicación, mostrando el diagrama de clases y de secuencia, etc.
4.2. Aplicación Location GPS La aplicación Location-GPS es una aplicación muy sencilla, cuyo manual se puede encontrar en Internet (http://es.scribd.com/doc/47667225/desarrollo-en-android-pdf), y siguiéndolo paso a paso se obtiene la aplicación. 49
El objetivo que se persigue al crear esta aplicación no es otro que el de familiarizarse con el entorno y comprender el funcionamiento de los componentes del dispositivo. Esta aplicación utiliza el sistema GPS, se conecta a Internet y dispone de una interfaz gráfica con algunos de los componentes más utilizados por las aplicaciones. Esta aplicación, está formada por sólo una clase java (además de todos los archivos de configuración que genera el proyecto) encargada de crear todos los componentes gráficos, activar el GPS, obtener su ubicación y mostrársela al usuario. Como se puede ver en la figura 19, el planteamiento de la interfaz es muy sencillo. Se dispone de una etiqueta, que se utiliza para mostrar un texto por pantalla y es el elemento más sencillo de crear, y un botón. Para que funcione la aplicación sólo hay que pulsar el botón.
Figura 19: Location GPS
Una vez que se ha pulsado el botón, la aplicación, utilizando el sistema GPS localizará la posición del dispositivo y la mostrará por pantalla. Además, de forma predeterminada, al actualizar la localización GPS, ésta se guardará en memoria de forma que esté disponible para otras aplicaciones. Esta aplicación fue probada dos veces, la primera en un emulador, y mostraba coordenadas que no son correctas, posiblemente, al introducirlas a mano para simularlas, cometí algún error. Cuando la probé en un teléfono, con toda su funcionalidad ejecutándose sobre un dispositivo real, la precisión de la señal era extremadamente alta. En la figura 20 se muestra la posición que indicaba el emulador.
50
Figura 20: Posición localizada
Por último, también puede ocurrir, que nos encontremos en una zona de sombra para el GPS, en el interior de un edificio o que el dispositivo GPS del terminal no esté activado. En este caso, la aplicación mostrará un mensaje por pantalla tal y como se muestra en la Figura 21.
Figura 21: Señal no encontrada
Observando el código de la aplicación, he descubierto que utiliza mucho los documentos XML que van adjuntos al proyecto, no solo los de la interfaz gráfica, sino también para almacenar valores de cadenas de caracteres. De hecho, hasta el texto que aparece en el botón es importado desde un documento XML, esto se puede apreciar en la figura 22.
Figura 22: Documento XML de fuentes
51
Por supuesto, antes de instalar la aplicación en ningún dispositivo, hay que comprobar los permisos que le vamos a asignar, para que no disponga de ninguno que no necesite. Puesto que la aplicación, solo va a localizar nuestra posición basándose en el GPS, solo tendrá el permiso para utilizar esa característica. Lógicamente, ese permiso será asignado en el manifiesto. En la figura 23 se muestran los permisos de la aplicación.
Figura 23: Permisos
Por último, esta aplicación puede actualizar en cada momento su posición GPS y no es necesario que haya habido un movimiento mínimo ni que haya pasado cierto tiempo. Esta característica la aprovecharé para el desarrollo de la Facebook-Tourism. Para poder utilizar esa funcionalidad, es necesario, que cuando se crea el hilo para la gestión del GPS, en la variable que almacenará la posición se le indique que no espere ningún tiempo para actualizarse ni a que se haya recorrido ninguna distancia. En la Figura 24 mostraré el código para mostrarlo claramente. El principal inconveniente de utilizar esta configuración es que el GPS está siempre activado, por lo que la batería del terminal se gasta rápidamente.
Figura 24: Actualización GPS
En el código de la figura 24, también se muestra que se utilice el sistema GPS y no el 3G, que ese había sido descartado por impreciso. esta pequeña aplicación, se pueden obtener los conocimientos Facebook-Tourism sobreRealizando Android para poder comenzar a desarrollar y porbásicos ende, cualquier aplicación que nos propongamos. Obviamente, con esta aplicación no se ha tratado ni un 1% del potencial que ofrece Android, pero nos ha servido para entender cómo funciona el manifiesto, los permisos, el desarrollo de una interfaz gráfica, el acceso a dispositivos hardware del teléfono, etc. En el manual que utilicé para realizar esta aplicación, sugería como posible mejora, la introducción de un menú que nos permitiera elegir como queríamos localizarnos (GPS o 3G) y que además lo mostrara en un mapa. En el momento que lo desarrolle 52
todavía no había aprendido a utilizar la API de Google, por lo que decidí posponerlo hasta que hubiese adquirido los conocimientos necesarios.
4.3. Google Google Inc. es la empresa propietaria de la marca Google (cuyo logo aparece en la figura 25), cuyo principal producto es el motor de búsqueda de contenido en Internet del mismo nombre [32]. Dicho motor es resultado de la tesis doctoral de Larry Page y Sergey Brin para mejorar las búsquedas en Internet. La coordinación y asesoramiento se debieron al mexicano Hector García Molina, director por entonces del Laboratorio de Sistemas Computacionales de la misma Universidad de Stanford y para la aplicación de los algoritmos de búsqueda contaron con el apoyo de Rajeev Motwani. El dominio Google fue registrado el 15 de septiembre de 1997. Partiendo del proyecto concluido, Page y Brin fundan, el 4 de septiembre de 1998, la compañía Google Inc. que estrena en Internet su motor de búsqueda el 27 de septiembre siguiente. Contaban con un servidor con 80 CPU, y dos routers HP. Este motor de búsqueda supero al otro más popular de la época, AltaVista, que había sido creado en 1995. Aunque su principal producto es el buscador, la empresa ofrece también entre otros servicios: un comparador de precios llamado Google Product Search, un motor de búsqueda para material almacenando en discos locales, Google Desktop Search, un servicio de correo electrónico llamado Gmail, su mapamundi en 3D Google Earth, un servicio de mensajería instantánea basado en XMPP llamado Google Talk y, su más reciente creación, el servicio de red social Google+. Su infraestructura principal está compuesta por varios data centers que funcionan con la distribución del sistema operativo GNU/Linux, cuya elección fue llevada a cabo debido a laRedHat flexibilidad del mismo, por lo que la mayoría de sus trabajadores usan también esta misma distribución en sus estaciones de trabajo por comodidad.
Figura 25: Logo de Google
Actualmente Google está trabajando en nuevos proyectos como el PC de 100$, un nuevo sistema operativo (Chromium), Google Docs & Spreadsheets, colaboración y promoción de aplicaciones de software libre como Firefox, instalación de varias redes inalámbricas gratuitas, desarrollo de un sistema de protocolo abierto de comunicación por voz entre otros. Además se especula que estaría trabajando en el desarrollo de un Google Office y una red global de fibra óptica.
53
Vint Cerf, considerado uno de los padres de Internet, fue contratado por Google en 2005. La compañía cotiza en NASDAQ bajo la clave GOOG. En Octubre de 2006, Google adquirió por 1650 millones de dólares la famosa página de videos Youtube. En Abril de 2007, Google compro DoubleClick, una empresa especializada en publicidad en Internet, por 3100 millones de dólares. Ese mismo mes, Google se convirtió en la marca más valiosa del mundo, alcanzando la suma de 66.000 millones de dólares, superando a empresas emblemáticas como Microsoft y Coca-Cola. En Julio de 2007, Google compro Panoramio, un sitio web dedicado a exhibir las fotografías que los propios usuarios crean y geo posicionan, siendo algunas de ellas subidas al sitio para que puedan ser vistas a través del software Google Earth, cuyo objetivo es permitir a los usuarios del mencionado software a aprender más sobre una zona específica del mapa, observando las fotografías que otros usuarios han tomado ahí. En Septiembre de 2010, Google implementó Google Instant Search, una función que permite hacer búsquedas a medida que el usuario va tecleando su término de búsqueda. En principio solo fue accesible para usuarios de la versión inglesa, y para usuarios en la versión española. En Agosto de 2011, Google adquiere Motorola Mobility por 8.800 millones de euros. Con esta adquisición, Google controlará la mayor parte del mercado de teléfonos Android y tendrá sus propias fábricas de teléfonos móviles al igual que Apple.
4.3.1. API Google Maps Google Maps dispone de una amplia matriz de API que permite al usuario insertar [35]
las funciones completas y laasí utilidad de Google Maps en su propio sitio Web y en sus más propias aplicaciones, como diaria superponer sus propios datos sobre ellas. Hay numerosas versiones de la API disponibles para distintas tecnologías:
JavaScript permite a los usuarios insertar un mapa de Google en sus páginas Web, así como manipular el mapa y añadir contenido a través de diferentes servicios. Con esta API se pueden crear mapas como los que aparecen en la figura 26. JavaScript API:
Figura 26: Javascript API
API permite a los usuarios insertar un mapa de Google en sus aplicaciones o en sus páginas Web basadas en Flash. Asimismo, les permite manipular el mapa en tres dimensiones y añadir contenido a través de diferentes servicios. Con esta API se pueden crear mapas como los que aparecen en la figura 27.
Maps API para Flash: ActionScript
54
Figura 27: Flash
API
Permite a los usuarios insertar un globo digital en 3D en sus páginas Web. De este modo, los usuarios que visiten la página del usuario podrán viajar por cualquier lugar del mundo (incluso por debajo del océano) sin salir de la página. Con esta API se pueden crear mapas como los que aparecen en la figura 28. Google Earth API:
Figura 28: Google Earth API
Permite a los usuarios insertar una imagen rápida y sencilla de Google Maps en sus páginas Web o en sus sitios para móviles sin necesidad de utilizar JavaScript ni ningún sistema de carga de páginas dinámicas. Con esta API se pueden crear mapas como los que aparecen en la figura 29. Static Maps API:
Figura 29: Static Maps API
Puedes utilizar las solicitudes URL para acceder a información de lugares, de direcciones o de codificación geográfica de las aplicaciones cliente, y manipular los resultados en JSON o XML. Con esta API se pueden crear mapas como los que aparecen en la figura 30. Servicios Web:
55
Figura 30: Servicios web API
Maps Data API: Puedes a través de los feeds
visualizar, almacenar y actualizar datos de mapas de Google Data API, mediante un modelo de funciones (marcadores, líneas y formas) y conjuntos de las mismas. Con esta API se pueden crear mapas como los que aparecen en la figura 31.
Figura 31: Maps Data API
Para el desarrollo de la aplicación, he utilizado una clase que hereda de la cual me permite insertar un mapa manipulable en el que podré incluir puntos, dibujar rutas, cambiar el tipo de vista, etc. Para poder utilizar esas funciones hay que tener una API Key, la cual explicaré como obtenerla en el Anexo IV. MapActivity,
4.4. Facebook Facebook es una red social creada por Mark Zuckerberg y fundado por Eduardo Saverin, Chris Hughes, Dustin Moskovits y Mark Zuckerberg [34]. Originalmente era un sitio para estudiantes de la universidad de Harvard, pero actualmente está abierto a cualquier persona que tenga una cuenta de correo electrónico. Los usuarios pueden participar en una o más redes sociales, en relación con su situación académica, su lugar de trabajo o región geográfica. Ha recibido mucha atención en la blogosfera (comunidad de blogs) y en los medios de comunicación al convertirse en una plataforma sobre la que terceros pueden desarrollar aplicaciones y hacer negocio a partir de la red social. A mediados de 2007 lanzo las versiones en francés, alemán y español para impulsar su expansión fuera de Estados Unidos, ya que sus usuarios se concentran en Estados Unidos, Canadá y Gran Bretaña. En Julio de 2010, Facebook cuenta con 500 millones de miembros, y traducciones a 70 idiomas. En mayo de 2011, alcanza los 600 millones de usuarios. Su infraestructura principal está formada por una red de más de 50.000 servidores que usan distribuciones del sistema operativo GNU/Linux usando LAMP. 56
Facebook comenzó a permitir que los estudiantes de universidades agregasen a estudiantes, cuyas escuelas no estaban incluidas en el sitio, debido a las peticiones de los usuarios. En marzo de 2006, BusinessWeek divulgo que una adquisición potencial del sitio estaba bajo negociación. Facebook declinó una oferta de 750 millones de dólares. En Mayo de 2006, la red de Facebook se extendió con éxito en la India, con apoyo de institutos de tecnología de aquel país. En Junio de 2006, hubo un acuerdo con iTunes Store para que iTunes conociera los gustos musicales de los usuarios y ofrecer así un enlace de descarga en su propio sitio. En Agosto de 2006, Facebook agregó universidades en Alemania e Israel a su red. También introdujo la importación de blogs de Xanga, LiveJournal o Blogger. Desde Septiembre de 2006 Facebook se abre a todos los usuarios de Internet, a pesar de protestas de gran parte de sus usuarios, ya que perdería la base estudiantil sobre la cual se había mantenido. En Julio de 2007, Facebook anunció su primera adquisición, Parakey Inc. de Blake Ross y Joe Hewitt. En agosto del mismo año se le dedicó la portada de la prestigiosa revista Newsweek; además de una integración con Youtube. A finales de Octubre de 2007 Facebook vendió una parte, el 1.6% a Microsoft por 240 millones de dólares, con la condición de que Facebook se convirtiera en un modelo de negocio para marcas de fábrica en donde se ofrezcan sus productos y servicios, según los datos del usuario y del perfil de éste. Esta adquisición valoró Facebook en quince mil millones de dólares, aunque el consenso de los analistas fuera que esta cifra supera el valor real de la empresa (para Microsoft no se trataba sólo de una inversión financiera, sino también de un avance estratégico en Internet). Actualmente, cuenta con más de 800 millones de usuarios, según se confirmó en la Developer Conference celebrada el 22 de Septiembre de 2011.
En la figura 32 se muestra el logo de Facebook.
Figura 32: Logo Facebook
Facebook ofrece una gran cantidad de servicios, entre los que destacan:
Lista de Amigos:
En ella el usuario puede agregar a cualquier persone que conozca y esté registrada, siempre que acepte su invitación. En Facebook se pueden localizar amigos con quien se perdió el contacto o agregar otros nuevos con quienes intercambiar fotos o mensajes. Para ello, el servidor de Facebook posee herramientas de búsqueda y de sugerencia de amigos. Grupos y Páginas: Es una de las utilidades de mayor desarrollo reciente. Se trata de reunir personan con intereses comunes. En los grupos se pueden añadir fotos, videos, mensajes, etc. Las páginas, se crean con fines específicos y a diferencia de los grupos no contienen foros de discusión, ya 57
que están encaminadas hacia marcas o personajes específicos y no hacia ningún tipo de convocatoria. Además, los grupos también tienen su normativa, entre la cual se incluye la prohibición de grupos con temáticas discriminatorias o que inciten al odio y falten al respeto y la honra de las personas. Si bien esto no se cumple en muchas ocasiones, existe la opción de denunciar e informar los grupos que vayan contra esta regla, por lo cual Facebook incluye un enlace en cada grupo el cual se dirige hacia un muro de reclamaciones y quejas. Las aplicaciones más utilizadas en Facebook son el muro, las fotos y los regalos:
El muro es un espacio en cada perfil de usuario que permite que los amigos escriban mensajes para que el usuario los vea. Solo es visible para usuarios registrados. Permite incluir imágenes y poner cualquier tipo de logotipos en tu publicación. Fotos: Según Facebook, hay: o 5 mil millones de fotos de usuario. o 160 terabytes de almacenaje Regalos: Los regalos o gifts son pequeños iconos con un mensaje. Los regalos dados a un usuario aparecen en el muro con el mensaje del donante, a menos que el donante decida dar el regalo en privado, en cuyo caso el nombre y el mensaje del donante no se exhibe a otros usuarios. Una opción anónima está también disponible, por la cual cualquier persona con el acceso del perfil puede ver el regalo, pero solamente el destinatario verá el mensaje. Muro:
Algunos gratuitos y el resto cuestan un dólar, (es necesario un número deregalos tarjetason de crédito o cuenta Paypal). o
o
Son pequeñas aplicaciones con las que puedes averiguar tu galleta de la suerte, quien es tu mejor amigo, descubrir cosas de tu personalidad, etc. Juegos: La mayoría de aplicaciones encontradas en Facebook se relacionan con juegos de rol. Entre los célebres se encuentran juegos como FarmVille, CityVille, etc. Aplicaciones:
4.4.1. API Facebook La API de Facebook ofrece los métodos necesarios para obtener toda la información de la red social del usuario que está ejecutando la aplicación. En el caso de este proyecto, va a ser necesario acceder a la información personal del usuario, los amigos de éste y los intereses de dichos amigos [36]. En la zona de recursos de Facebook se ofrecen dos API’s oficiales para el desarrollo, unalaen PHP y otra Puesto aplicación está para desarrollada Android, para realización de en esteJava. proyecto ha que sidolarequerido la API Java. para Para el desarrollo de la aplicación ha sido necesario obtener una API Key (ver Anexo IV).
4.5. Facebook-Tourism Una vez comentados los dos pilares principales de la aplicación, explicaré el desarrollo de la misma, centrándome en los componentes, explicaré los archivos XML, las distintas clases, el uso del GPS, etc. 58
4.5.1. Arquitectura de la aplicación
Figura 33: Arquitectura de la aplicación
En la figura 33, se muestra la arquitectura de la aplicación, en primer lugar, ésta se conecta a Facebook, para obtener los amigos y los lugares de estos. Cuando tiene esos datos, se los envía a la clase Mapa, y una vez recibidos, se conecta con el servidor de amigos para ver cuales están cerca y utiliza el servidor de Google Maps para localizar los lugares que les gustan a esos amigos. Cuando el usuario pulsa el botón Acceder la aplicación se conecta a los servidores de Facebook y obtiene los datos relacionados con el usuario, a continuación se produce la comunicación entre las clases Principal y Mapa, y se obtienen los amigos que están cerca. Cuando un usuario selecciona a un amigo en concreto se cargan los lugares que le gustan y cuando un usuario selecciona un lugar se utilizan los servicios web de Google para obtener la ruta desde la posición del usuario hasta el lugar indicado. 59
4.5.2. Android Manifest El documento Manifest de la aplicación está formado por cuatro secciones que se pueden configurar de forma gráfica, o se puede utilizar una quinta sección, en la que se escribiría el código en XML. La primera sección que encontramos es el Manifest propiamente dicho, esta sección es como un índice en el que hay que indicar el paquete, la versión de la aplicación, los extras, etc. Además contiene enlaces a las demás secciones del documento. La figura 34 muestra en detalle esta sección del Manifest.
Figura 34: Manifest
La segunda sección que encontramos está centrada en la aplicación. Esta sección es sumamente importante, ya que, aparte de poder personalizar el icono o indicar la etiqueta de la aplicación; es en esta sección donde se indicaran que clases son las que se van a mostrar en la aplicación, y cuál de ellas es la primera. Todos los detalles de esta sección se muestran en la figura 35.
60
Figura 35: Application
La tercera sección se corresponde con los permisos que tiene la aplicación. Ésta es otra de las secciones fundamentales del manifiesto, ya que si no incluimos permisos a las características hardware o software que necesita la aplicación, Ésta no funcionará correctamente. Para el caso de la aplicación Facebook-Tourism es necesario que pueda conectarse a Internet, que pueda escribir en disco, que pueda administrar cuentas de usuario, que pueda acceder al GPS y utilizar el vibrador del móvil. Los permisos de la aplicación Facebook-Tourism se muestran en la figura 36.
Figura 36: Permissions
La última sección gráfica es la sección Instrumentation que en este proyecto no ha sido utilizada. Para finalizar esta sección mostraré, en la figura 37, el código en XML del documento. Todo este código ha sido generado por las distintas interfaces gráficas, aunque se puede editar directamente desde el código fuente. 61
Figura 37: Código XML
Como se puede ver en la figura 37, al comienzo del documento se declara el paquete, la versión del código, la localización de los documentos XML, etc. A continuación se muestran los permisos, también se incluye la librería de mapas necesaria para poder mostrar el mapa en la aplicación. En la sección del código donde se indican las clases hay una especificación que no se puede utilizar desde la ventana gráfica, esta especificación es necesaria para que la aplicación no gire la pantalla cuando se gire el teléfono. También se indica qué ventana de la aplicación será la primera en lanzarse.
4.5.3. Permisos Los permisos son muy importantes en una aplicación Android. Cuando se instala una aplicación en Android, el usuario tiene que aceptar los permisos y en caso de creer que no son necesarios (por ejemplo permisos de acceso a datos personales para una aplicación de linterna) rechazarlos y buscar otra aplicación que ofrezca los mismos servicios pero con menos permisos [37]. Cada uno de los permisos tiene distinto grado de peligrosidad dependiendo del perfil de usuario que use el teléfono. A partir de aquí voy a exponer todos los permisos que hay en Android en su nombre en clave para desarrolladores, con una breve explicación e indicaré además, cuáles de ellos estoy usando en la aplicación:
Android.permission.ACCESS_CHECKIN_PROPERTIES: Permite la lectura/escritura de la tabla de propiedades de la base de datos del registro pudiendo cambiar los valores que son actualizables. Android.permission.ACCESS_COARSE_LOCATION: Permite la localización usando las redes inalámbricas en las que te encuentres. Básicamente es una localización por IP. Android.permission.ACCESS_FINE_LOCATION: Permite localizar al usuario utilizando la antena GPS del dispositivo. Este permiso es requerido en la aplicación.
Android.permission.ACCESS_LOCATION_EXTRE_COMMANDS: Permite el acceso a la localización otorgada por los operadores de telefonía. Para poder utilizar este permiso en España (de forma legal) necesitas una orden judicial. Android.permission.ACCESS_MOCK_LOCATION: Es un permiso de depuración, emula a un operador de telefonía y sirve para la localización.
62
Android.permission.ACCESS_NETWORK_STATE: Permite conocer el estado de la red. Android.permission.ACCESS_SURFACE_FLINGER: Permite el acceso a las características de bajo nivel del deflector. Permite el acceso a los identificadores de cuenta. Android.permission.WIFI_STATE: Permite leer información sobre las redes Wifi. Android.permission.ACCOUNT_MANAGER: Sólo el sistema y las aplicaciones del sistema pueden obtener este permiso. Permite el acceso a los identificadores de cuenta. Android.permission.AUTHENTICA_ACCOUNTS: Permite a una aplicación emular un identificador de cuenta para acceder al administrador de cuentas. Android.permission.BATTERY_STATS: Permite el acceso a las estadísticas de la batería. Android.permission.BIND_APPWIDGET: Permite la comunicación entre una aplicación y los datos que gestiona el servicio AppWidget. El AppWidget es el encargado de manejar los widgets de la pantalla y el permiso se usa para acceder a los datos que hayan sido generados por los distintos widgets Android.permission.BIND_DEVICE_ADMIN: Este permiso es requerido por el receptor de la administración del dispositivo para asegurar que sólo el sistema puede interactuar con él. Android.permission.BIND_INPUT_METHOD: Este permiso es requerido por un InputMethodService para asegurarse que sólo el sistema puede unirse a él. Android.permission.BIND_REMOTEVIEWS: Este permiso es requerido por un RemoteViewsService para asegurarse que solo el sistema puede unirse a él. Android.permission.BIND_WALLPAPER: Este permiso es requerido por WallpaperService para asegurarse que sólo el sistema puede unirse a él. Android.permission.BLUETOOTH: Permite la conexión entre aplicaciones y dispositivos conectados por bluetooth. Android.permission.BLUETOOTH_ADMIN: Permite a una aplicación buscar y conectar dispositivos bluetooth. Android.permission.BRICK: Es necesario para conectar o desconectar el teléfono (es muy peligroso). Android.permission.BROADCAST_PACKAGE_REMOVED: Permite a una aplicación difundir una notificación cuando una aplicación ha sido desinstalada. Android.permission.BROADCAST_SMS: una notificación de mensaje sms recibido. Permite a una aplicación difundir Android.permission.BROADCAST_STICKY: Permite la difusión de mensajes pegajosos (broadcast). Android.permission.BROADCAST.WAP.PUSH: Permite a una aplicación difundir notificaciones de mensajes wap entrantes. Android.permission.CALL_PHONE: Permite a una aplicación realizar llamadas de teléfono sin necesidad de usar el dialer de Android. 63
Android.permission.CALL_PRIVILEGED: Igual que la anterior pero además permite usar las llamadas de emergencia. Android.permission.CAMERA: Permite usar la cámara de fotos/video. Android.permission.CHANGE_COMPONENT_ENABLED_STATE: Permite a una aplicación cambiar de estado si un componente (que no sea de la aplicación) esta iniciado o no. Android.permission.CHANGE_CONFIGURATION: Permite cambiar la configuración del sistema (como por ejemplo los Locale). Android.permission.CHANGE_NETWORK_STATE: Permite el cambio de conectividad de la red. Android.permission.CHANGE_WIFI_MULTICAST_STATE: Permite a las aplicaciones acceder al modo Wifi multicast. Android.permission.CHANGE_WIFI_STATE: Permite el cambio de estado de la conexión Wifi. Android.permission.CLEAR_APP_CACHE: Permite a una aplicación borrar la caché creada por otras aplicaciones. Android.permission.CLEAR_APP_USER_DATA: Permite a una aplicación el borrado de los datos de usuario. Android.permission.CONTROL_LOCATION_UPDATES: Permite activar/desactivar la ubicación sobre las actualizaciones del proveedor de telefonía. No se suele usar por aplicaciones normales. Android.permission.DELETE_CACHE_FILES: Permite el borrado de los ficheros en caché. Android.permission.DELETE_PACKAGES: Permite el borrado de aplicaciones. Android.permission.DEVICE_POWER: Permite el acceso de bajo nivel al administrador de energía del dispositivo. Android.permission.DIAGNOSTIC: Permite el acceso de lectura/escritura a las herramientas de diagnóstico. Android.permission.DISABLE_KEYGUARD: Permite a una aplicación el desbloqueo del bloqueo del teclado Android.permission.DUMP: Permite a una aplicación recuperar la información volcada por los servicios del sistema. Android.permission.EXPAND_STATUS_BAR: Permite expandir o contraer la barra de estado. Android.permission.FACTORY_TEST: Sirve para iniciar una aplicación en modo text. Solo el usuario root puede usar este permiso en una ROM compilada en modo de pruebas. Android.permission.FLASHLIGHT: Permite el acceso al flash. Android.permission.FORCE_BACK: Permite a una aplicación volver atrás sea cual sea la aplicación que hay en primer plano. Android.permission.GET_ACCOUNTS: Permite acceder al listado de cuentas registradas en el sistema. Android.permission.GET_PACKAGE_SIZE: Permite a una aplicación saber el tamaño de cualquier paquete. Android.permission.GET_TASKS: Permite saber las aplicaciones que hay en ejecución.
64
Android.permission.GLOBAL_SEARCH: Este permiso es utilizado por proveedores de contenido (Content Proveider) para permitir la búsqueda global del sistema y acceder a sus datos. Android.permission.HARDWARE_TEST: Permite el acceso a los periféricos de hardware. Está diseñado para chequear hardware. Android.permission.INJECTS_EVENTS: Permite a una aplicación insertar eventos tales como una pulsación en pantalla, uso de trackball, etc. Android.permission.INSTALL_LOCATION_PROVIDER: Permite a una aplicación instalar un proveedor de localización en el location manager. Android.permission.INSTALL_PACKAGES: Permite a una aplicación la instalación de otras aplicaciones. Android.permission.INTERNAL_SSTEM_WINDOW: Permite a una aplicación abrir ventadas utilizadas por la interfaz de usuario del sistema. Android.permission.INTERNET: Permite a una aplicación abrir sockets. Este permiso se utiliza en la aplicación . Android.permission.KILL_BACKGROUND_PROCESSES: Permite a una aplicación llamar al killBackgroundProcesses. Android.permission.MANAGE_ACCOUNTS: Permite a una aplicación administrar las cuentas almacenadas en el AccountMAnager. Este permiso se utiliza en la aplicación.
Android.permission.MANAGE_APP_TOKENS: Sólo es usado por el sistema, permite crear o destruir tokens. Android.permission.MASTER_CLEAR: No pone nada sobre este permiso en la documentación de Android. Android.permission.MODIFY_AUDIO_SETTINGS: Permite la modificación de las características del sonido. Android.permission.MODIFY_PHONE_STATE: Permite la modificación del estado del teléfono (encendido, apagado ,…). No permite realizar llamadas. Android.permission.MOUNT_UNMOUNT_FILESYSTEMS: Permite montar sistemas de almacenamiento externo. Android.permission.MOUNT_FORMAT_FILESYSTEMS: Permite formatear sistemas de almacenamiento externo. Android.permission.NFC: Permite las operaciones de entrada/salida de los dispositivos NFC. Android.permission.PROCESS_OUTGOING_CALLS: Permiso obsoleto Android.permission.READ_CALENDAR: Permite leer los datos almacenados en el calendario por el usuario Android.permission.READ_CONTACTS: Permite a una aplicación acceder a la lectura de los datos de tus contactos. Android.permission.READ_FRAME_BUFFER: Permite a una aplicación tomar una captura de pantalla y generalmente el acceso a los datos del frame buffer.
Com.Android.browser.permission.READ_HISTORY_BOOKMARKS: Permite el acceso en modo lectura al historial y los favoritos del buscador. Android.permission.READ_INPUT_STATE: Permite a una aplicación recuperar el estado de teclas o interruptores. Sólo es usado por el sistema
65
Android.permission.READ_LOGS: Calificado como permiso peligroso. Permite el acceso a los logs creados por el sistema. En los logs puedes encontrar claves de usuario. Android.permission.READ_PHONE_STATE: Acceso de solo lectura al estado del teléfono. Android.permission.READ_SMS: Permite a una aplicación leer los sms. Android.permission.READ_SYNC_SETTINGS: Permite a una aplicación leer la configuración de la sincronización. Android.permission.READ_SYNC_STATS: Permite a una aplicación leer estadísticas de la sincronización Android.permission.RECEIVE_BOOT_COMPLETED: Permite a una aplicación recibir el ACTION BOOT COMPLETED. Android.permission.RECEIVE_MMS: Permite monitorizar los mms recibidos Android.permission.RECEIVE_SMS: Permite monitorizar los sms recibidos. Android.permission.RECEIVE_WAP_PUSH: Permite a una aplicación monitorizar las notificaciones wap entrantes. Android.permission.RECORD_AUDIO: Permite grabar audio. Android.permission.REORDER_TASKS: Permite a una aplicación reorganizar las tareas. Android.permission.RESTART_PACKAGES: Permiso obsoleto. Android.permission.SEND_SMS: Permite a una aplicación enviar sms. Android.permission.SET_ACTIVITY_WATCHER: Sólo se usa en modo de depuración Com.android.permission.SET_ALARM: Permite a una aplicación crear una alarma en el sistema. Android.permission.SET_ALWAYS_FINISH: Permite a una aplicación controlar si las actividades en segundo plano son finalizadas. Android.permission.SET_DEBUG_APP: Configura una aplicación para ser depurada. Android.permission.SET_ORIENTATION: Permite a una aplicación acceder a los parámetros de la rotación de pantalla. Android.permission.SET_POINTER_SPEED: Acceso de bajo nivel al puntero Android.permission.SET_PREFERRED_APPLICATIONS: Permiso obsoleto. Android.permission.SET_PROCESS_LIMIT: Permite a una aplicación limitar el número de aplicaciones que se pueden ejecutar en un sistema Android Android.permission.SET_TIME: Permite cambiar la hora del sistema. Android.permission.SET_TIME_ZONE: Permite cambiar la zona horaria. Android.permission.SET_WALLPAPER: Permite a una aplicación poner un salvapantallas. Android.permission.SIGNAL_PERSISTENT_PROCESSES: Permite a una aplicación enviar una señal a los procesos persistentes. Android.permission.STATUS_BAR: Permite a una aplicación abrir, cerrar o deshabilitar la barra de estado y sus iconos. 66
Android.permission.SUBSCRIBED_FEEDS_READ: Permite a una aplicación acceder al feed del proveedor de contenido Android.permission.SUBSCRIBED_FEEDS_WRITE: No hay información disponible sobre este permiso. Android.permission.SYSTEM_ALERT_WINDOW: Permite a una aplicación abrir ventanas usando TYPE SYSTEM ALERT. Android.permission.UPDATE_DEVICE_STATS: Permite actualizar las estadísticas del dispositivo. No es usado por aplicaciones normales. Android.permission.USE_CREDENTIALS: Permite a una aplicación solicitar tokens de autenticación del account manager. Android.permission.USE_SIP: Permite a una aplicación usar el servicio SIP Android.permission.VIBRATE: Permite el acceso al vibrador del dispositivo. Este permiso se utiliza en la aplicación. Android.permission.WRITE_APN_SETTINGS: Permite a una aplicación modificar los ajustes APN. Android.permission.WAKE_LOCK: Permite el acceso a los bloques de energía para mantener el procesador durmiendo o mantener la pantalla apagada. Android.permission.WRITE_CALENDAR: Permite escribir datos en el calendario. No permite leer los datos. Android.permission.WRITE_CONTACTS: Permite escribir contactos en la agenda. No permite leer los datos. Android.permission.WRITE_EXTERNAL_STORAGE: Permite a una aplicación escribir en el almacenamiento externo. Este permiso se utiliza en la aplicación.
Android.permission.WRITE_GSERVICES: Permite a una aplicación modificar el servicio de mapa de Google. Com.Android.browser.permission.WRITE_HISTORY_BOOKMARKS: Permite a una aplicación añadir favoritos y modificar el historial del navegador. Android.permission.WRITE_SETTINGS: Permite a una aplicación leer y escribir los ajustes del sistema. Android.permission.WRITE_SMS: Permite a una aplicación escribir sms. Android.permission.WRITE_SNC_SETTINGS: Permite a una aplicación escribir los ajustes de sincronización.
4.5.4. Interfaz de la aplicación La aplicación de este proyecto está compuesta por dos ventanas diseñadas para el programa, más otra que aparece al identificarse en la red social Facebook. Esta última aparece debido a la API de Facebook La primera de las ventanas es introductoria, está compuesta por un mensaje de bienvenida, dos botones (uno se usa para conectarse, y el otro para salir de la aplicación) y un enlace a la página de Facebook, para que aquellos usuarios que no tienen una cuenta en dicha red social puedan registrarse y así usar la aplicación. Dicha ventana se muestra en la figura 38.
67
Figura 38: Ventana Principal
Cuando se pulsa el botón “Ac ceder”, se lanza un evento que trata de conectarse a la red social Facebook. Lo primero que se necesita es identificar al usuario, para así poder bajarse la lista de amigos y los intereses de estos. La interfaz que se muestra la figura 39 es la que proporciona la API de Facebook, donde, al que igual que en Internet, hay que poner el nombre de usuario y la contraseña. Cuando se pulsa el botón Entrar salta el aviso de si se quiere guardar la contraseña o no. Al ser un dispositivo que se puede perder, no es aconsejable guardar la contraseña en el móvil.
Figura 39: Identificación
68
La última interfaz que tiene la aplicación es en la que el usuario pasará la mayor parte del tiempo. En la parte de arriba de la pantalla se muestra el nombre del usuario. Justo debajo, hay dos etiquetas, una para amigos y otra para lugares, cuando el usuario pulsa sobre la de amigos, aparecerá un menú con un listado de todos los amigos que tiene el usuario. Cuando el usuario elige a un amigo, puede pulsar en la etiqueta lugares y ver todos los lugares que le gustan a ese amigo en concreto. Al elegir un lugar, se mostrará en el mapa la ruta para llegar desde la posición del usuario hasta ese lugar. El usuario también podrá cambiar la vista del mapa a vista de tráfico, a vista de satélite o vista de StreetView. El mapa también puede ser manipulado por el usuario, aumentando el zoom, eligiendo alguna dirección, etc. Todos estos detalles se pueden ver en la figura 40.
Figura 40: Ventana del Mapa
4.5.5. Archivos XML Para la realización del proyecto, ha sido necesaria la utilización de cuatro documentos XML. De uno de ellos (AndroidManifest.xml) ya he hablado anteriormente, por lo que no es necesario que vuelva a repetir lo mismo. Uno de los documentos XML del proyecto es el que se ha utilizado para crear la ventana del mapa. En el apartado anterior ya he mostrado la vista del siguiente documento XML y la he explicado. En esta sección voy a añadir los datos que no he explicado en la sección anterior. En el documento XML es donde se declaran todos los elementos de la interfaz gráfica, la omayoría de, pero los elementos directamente con clase etiquetas de para insertarseel añaden mapa hay que insertar una TextView Checkbox MapView con una clave que explicare como obtenerla en el ANEXO IV. Al declarar un nuevo elemento se declaran todas las características que se quieran utilizar, como por ejemplo la posición en el eje X, en el eje Y, el texto que queremos mostrar, etc. La figura 41 muestra el documento mapa.xml donde se puede ver como se declara la clase necesaria para mostrar el mapa.
69
Figura 41: Mapa.xml
De la misma forma que es necesario un documento XML para la ventana del mapa, es necesario otro documento para la ventana principal (main.xml). Esta ventana no tiene ningún mapa, y ninguno de los elementos que aparecen en ella es importado desde ninguna clase. Este documento se ve en la figura 42, en él se puede apreciar como se crean cinco textView que se muestran en la ventana y los dos botones (necesarios para entrar y salir de la aplicación). En la declaración de cada elemento hay que indicar el texto que van a mostrar, la posición de los elementos (eje X e Y), su layout, etc. Estos indicadores son necesarios para que los elementos se muestren correctamente, además, en este documento se indica que la orientación de la pantalla sea siempre vertical, y que no se gire cuando se gire el teléfono.
Figura 42: Main.xml
70
Además de los documentos ya mencionados, también ha sido necesaria la creación de otro documento donde se declaran las variables ( Strings.xml). Estas variables se declaran como String y son llamadas desde los otros documentos XML. Por ejemplo, se han declarado el color azul y negro, que será utilizado para interfaz gráfica. En la figura 43 se ve este documento.
Figura 43: Strings.xml
4.5.6. Geo localización El SDK de Android incluye un paquete que proporciona soporte primario para montar servicios de localización: Android.location. Este paquete contiene varias clases relacionadas con los servicios de localización y, además, incluye el servicio LocationManager el cual proporciona una API para determinar la localización del dispositivo. LocationManager no puede ser instanciado directamente sino que se debe obtener un controlador, tal y como se muestra en la figura 44.
Figura 44: LocationManager
Cuando se obtiene el control de un siguientes acciones:
LocationManager,
se pueden realizar las 3
Solicitar una lista de todos o algunos de los LocationProviders disponibles. Registrarse o des-registrarse para actualizaciones periódicas de la posición. Registrarse o des-registrarse de eventos cuando el dispositivo se encuentra en determinada ubicación.
Para obtener la localización, hay que llamar al método tal y como se muestra en la figura 45.
getLastKnownLocation
Figura 45: getLastKnowLocation
Para
obtener
actualizaciones periódicas se utiliza el método La figura 46 muestra la llamada al método y los parámetros necesarios para su funcionamiento. requestLocationUpdate.
Figura 46: requestLocationUpdates
71
4.5.7. Mapas El SDK de Android, también incluye un paquete que proporciona soporte primario para los mapas. Este paquete es com.google.android.maps. En este paquete se incluyen varias clases relacionadas con el rendering, control y dibujo sobre mapas. La más importante es la clase MapView que automáticamente dibuja un mapa básico de GoogleMaps cuando se añade al layout de la aplicación. Para obtener el mapa del documento XML hay que ejecutar la sentencia mostrada en la figura 47.
Figura 47: Mapa
Para poder obtener un MapView, se necesita previamente un API Key de GoogleMaps (ver ANEXO IV). Además, para poder hacer uso de esta clase, se ha de añadir el permiso en el manifiesto dado que no es un paquete estándar de Android. La figura 48 muestra el código que hay que añadir al documento AndroidManifext.xml para poder utilizar los mapas de Google en la aplicación. Figura 48: Usando librería
Después de todo el procedimiento, se puede trabajar sobre la vista del mapa con la clase Overlay. En la figura 49 se muestra un ejemplo de uso.
Figura 49: Capas de un mapa
4.5.8. Servidor Una de las características de esta aplicación es que el usuario puede localizar a los amigos que usan esta aplicación. Para hacerlo, al comienzo de la ejecución la aplicación se conecta a un servidor que he preparado con una base de datos (ver apartado 4.5.8.) e indica el Id de usuario de Facebook, y sus coordenadas. Como respuesta del servidor el cliente recibe una lista con todos los usuarios de la aplicación que están a una distancia inferior a 500 metros. Posteriormente, la aplicación filtra esos usuarios y muestra sólo de los que están en la lista de amigos. El cálculo de la distancia se hace en dos partes. Una parte la realiza el cliente y otra el servidor. El servidor calcula la distancia euclidea entre dos usuarios y envía los que están a una distancia menor de la indicada. Porcalcula otra parte, el cliente recibe ellasusuario coordenadas de los amigos que aestán cerca, la rutacuando que tendría que seguir caminando para encontrar esa persona, si la distancia de esta ruta (no olvidemos que no es en línea recta, sino callejeando) es menor de 500 metros, entonces se mostrará la ruta en el mapa, en caso contrario se descartará. Debido a que el servidor tiene que aceptar conexiones de múltiples usuarios de forma simultánea, he decido utilizar un servidor concurrente que escucha en el puerto 15858. Cada vez que llega una nueva conexión, el servidor crea un objeto que hereda de la clase Thread y recibe el socket de la conexión como parámetro, por lo que cada vez 72
que se instancia un objeto se crea un nuevo hilo y se pueden atender varias conexiones simultáneamente.
4.5.9. Base de datos La base de datos que utiliza el servidor es una base de datos muy sencilla compuesta sólo por una tabla con tres campos. Estos campos son el id del usuario, la latitud y la longitud. No son necesarias más tablas debido a que el servidor se encarga de localizar los usuarios y ya es la propia aplicación la que se encarga de filtrar qué usuarios son amigos y cuáles no. A continuación mostraré las figuras 50 y 51 que se corresponden con la tabla de amigos con varios amigos registrados con sus coordenadas GPS y otra de la definición de la tabla de amigos.
Figura 50: Contenido Tabla amigos
Figura 51: Definición de la tabla amigos
4.5.10. Diagrama clases informal Los diagramas de clasesde permiten describir las clases que implementarán el sistema, las interfaces, las relaciones, etc. Es este caso, se trata del diagrama de clases informal, por lo que solo describiré la estructura de clases. Será posteriormente, en el diagrama de clases formal, cuando se especifiquen los atributos, métodos y demás características de las clases. Estos diagramas informales, se usan para la fase de análisis. Para cada clase e interfaz se describen las asociaciones, relaciones de dependencia y de realización. Las clases se unen mediante asociaciones, que tienen asociada una multiplicidad, teniendo cada componente que interviene en la asociación un rol. Además, y como se puede apreciar en la figura 52, expresamos para las asociaciones la navegabilidad que indica quién almacena a quién. Una parte muy importante de los diagramas de clases son las especificaciones de las asociaciones. Las composiciones son asociaciones fuertes entre un objeto y sus componentes, se representan mediante un rombo negro en el extremo opuesto. En este caso el objeto componente pertenece solamente al objeto compuesto, siendo el objeto compuesto el responsable de sus objetos componentes. Por otro lado, las agregaciones débiles se dan entre un objeto y sus componentes, las cuales crea, y se representa con un rombo blanco en cada objeto compuesto. En este caso, el objeto componente puede estar incluido en varias agregaciones, ser el componente de varios objetos compuestos. El objeto puede ser creado por otras clases y cuando el objeto se destruye no implica que los componentes se destruyan. Esta es la diferencia con las agregaciones fuertes, en el que el objeto compuesto crea y destruye sus componentes. 73
Además, en el diagrama de clases informal se representan las herencias y las dependencias entre clases. Las relaciones de dependencia se dan cuando por ejemplo una clase contiene en alguno de sus métodos como parámetro formal a otra, o una clase contiene en alguno de sus métodos una variable local de esa clase.
Figura 52: Diagrama de clases informal
4.5.11. Diagrama de clases formal Un diagrama de clases formal es un tipo de diagrama estático que describe la estructura de un sistema mostrando sus clases, atributos y las relaciones entre ellos. Los diagramas de clases son utilizados durante el proceso de análisis y diseño de los sistemas, donde se crea el diseño conceptual de la información que se manejará en el sistema, y los componentes que se encargaran del funcionamiento y la relación entre uno y otro no. La aplicación está formada por cinco clases, dos de esas clases son heredadas de la clase Activity, tienen componentes gráficos y son las que se le mostrarán al usuario. En la figura 53 se muestra el diagrama de clases formal de la aplicación.
74
Figura 53: Diagrama de clases formal
75
4.5.12. Diagramas de secuencia Los diagramas de secuencia, como vamos a ver en cada uno de los presentados, permiten ver con claridad y rápidamente la interacción de las distintas clases descritas en el diagrama de clases a través de las funcionalidades de que dispone el proyecto. Los diagramas de secuencia formales describen la interacción mediante el uso de métodos y parámetros, de forma que especifican todas las clases que intervienen realmente en la implementación. 4.5.12.1. Actividad conectar
la figurase54 muestro el diagrama de quiere secuencia para alalaactividad de yconectar Esta En actividad realiza cuando el usuario acceder aplicación tiene que. conectarse primero a la red social para bajar la lista de amigos y los intereses de estos.
Figura 54: Diagrama secuencia conectar
4.5.12.2. Actividad registrarse La figura 55 muestra la llamada de los métodos necesarios para que un usuario que no está registrado en Facebook puedaregistrarse y utilizar la aplicación.
Figura 55: Diagrama de secuencia registrarse
76
4.5.12.3. Buscar un amigo La figura 56 se corresponde con el diagrama de actividad de obtener la lista de amigos de Facebook, éste se realiza mediante una petición al servidor, en el que devuelve un objeto con todos los amigos, y este objeto (convertido en cadena) se envía a la clase Mapa.
Figura 56: Diagrama Secuencia buscar amigo
4.5.12.4. Buscar un lugar
La figura 57 muestra diagrama secuencia que sigue la aplicación a la hora de obtener los lugares que leselgustan a losde amigos. Cuando el usuario se conecta a la aplicación, ésta manda un mensaje http al servidor de Facebook para obtener el listado de amigos. Con el listado de amigos descargado, se procederá a buscar los lugares que le gustan a cada amigo, de ahí, que la segunda petición que se le hace al servidor esté en un bucle. Una vez descargados todos los lugares de todos los amigos, se enviarán los datos desde la clase Principal a la clase Mapa, donde serán tratados para que el usuario pueda elegir el lugar que más le interese.
77
Figura 57: Diagrama de secuencia buscar lugares
4.5.13. Activity Principal En este punto, ya he explicado cómo está estructurado el documento XML del Activity principal
así como funcionamiento desde el punto dedicho vistaActivity de la interfaz de usuario. A continuación voy su a explicar cómo esta implementado . Al ser una clase que tiene que mostrarse al usuario, es fundamental que herede de la clase Activity. Los atributos gráficos han sido declarados como globales para poder acceder a ellos desde cualquier método de la clase. Al heredar de la clase Activity es necesario la implementación de varios métodos, uno de ellos es onCreate(), algo así como un método Main en una aplicación Java. Este método es el primero en ejecutarse cuando se inicializa la 78
aplicación y en él se instancian todas las interfaces gráficas y se crea el objeto Facebook, necesario para acceder a la red social. Para poder instanciar el objeto Facebook, es necesario obtener el API Key de aplicación (ver Anexo V). En la figura 58 mostraré el código necesario para la inicialización de la clase:
Figura 58: Código Principal (I)
Para poder utilizar la API, es necesario indicar qué permisos va a tener la aplicación, estos se declaran como cadenas y se insertan en un vector, y será ese vector el que se le pasará como parámetro al método encargado de realizar la conexión. Además del vector de permisos y el Activity ahí que pasarle también un dialogListener, que es el que aparece pidiendo la dirección de correo electrónico y la contraseña al usuario. Como ya dije anteriormente, esta interfaz es creada por Facebook, por lo que yo no tengo ningún control en su diseño ni en su comportamiento. La figura 59 muestra la fracción de código necesaria para poder acceder mediante la API de Facebook.
Figura 59: Código Principal (II)
Una vez que el usuario ha sido identificado correctamente, procederemos a obtener el listado tiene ylapara cada amigo realizará petición de suselintereses. Como ya de se amigos comentóque durante explicación de laseinterfaz dellamapa, aparece nombre del usuario registrado, por lo que habrá que realizar una consulta para obtener el nombre del usuario. La API de Facebook, nos proporciona un método capaz de realizar las consultas al servidor indicándole por parámetros que queremos buscar. La primera consulta que se realiza es para obtener los datos del usuario, de esta forma podemos obtener el nombre y el Id de dicho usuario. Para realizar esta búsqueda, se utiliza el parámetro me. 79
La siguiente consulta que se realiza es para obtener el listado de amigos del usuario, esta consulta devuelve un objeto JSON con el nombre, el Id, y todos los demás datos que hayan proporcionado esos usuarios. Esta consulta se realiza utilizando como parámetro me/friends. Una vez que tenemos el objeto JSON, hay que extraer los Id’s de dichos usuarios para poder realizar la consulta de los lugares que le gustan a dichos usuarios. Esos Id’s se guardarán en un vector, que será usando más adelante. El último conjunto de consultas que se realiza es para obtener los intereses de cada usuario que es amigo del usuario de la aplicación. Para realizar esta consulta utilizaremos como parámetro la cadena formada por el Id del usuario en cuestión seguido de /likes. Esa búsqueda, devuelve un objeto JSON, que al tratarlo devuelve un vector con los lugares que le gustan a ese amigo. Ese vector es insertado en una matriz, en la que cada fila representa los lugares que le gustan a un usuario en concreto. Si a un usuario no le gusta ningún lugar, en su posición estará el valor null. La figura 60 muestra el código necesario para hacer todas las consultas indicadas.
Figura 60: Código Principal (III)
La última parte importante de esta clase es la encargada de enviar la información desde el Activity principal al Activity del mapa. Para hacerlo tenemos que utilizar un Intent e ir añadiendo los datos que queremos mandar mediante el método putExtra. A este método se le pasan dos atributos, el primero es la clave que utilizaremos para recuperarlo y el segundo es el dato que queremos mandar. Durante la implementación del código, este método presentó un problema, y es que no puedes mandar datos que no se pueden serializar, por lo que todas las consultas a Facebook, hay que realizarlas antes de mostrar la vista del mapa. Otro inconveniente que hubo que afrontar fue el envío de la matriz de lugares a la clase Mapa. Esta matriz no es cuadrada, por lo que antes de enviar el vector convertido en array, hay que enviar la longitud de dicho array, y a continuación se envían los datos. Cuando se reciben los arrays hay que volver a construir la matriz. 80
A continuación muestro la figura 61 con el código responsable del envío de los datos entre Activities:
Figura 61: Código Principal (IV)
4.5.14. Activity de Mapas Es este apartado voy a explicar la clase encargada de gestionar toda la funcionalidad de la clase que implementa la mayoría de las funcionalidades del programa. Como todas las clases que heredan de Activity, o de alguna de sus subclases, es necesario que haya un método onCreate(). En esta clase es, además, el método encargado de recibir los datos de la clase principal. Los datos se almacenan en un objeto de tipo Bundle, y serán recuperados cuando la aplicación los requiera. En la figura 62 mostraré el código encargado de recibir toda la información de a clase principal:
Figura 62: Código Mapas (I)
Uno de los principales problemas que hubo a la hora de la comunicación entre las aplicaciones es la limitación del envío de datos. Ya expuse como había solucionado el envío en la clase principal, y en la figura 63 muestro el código necesario para la recepción de datos:
Figura 63: Código Mapas (II)
81
Uno de los principales requisitos de la aplicación es el uso del GPS y la posibilidad de que se vaya actualizando la posición cada vez que el usuario la cambie. Para mantener actualizada la posición, es necesario que la gestión del GPS este ejecutándose en otro hilo. Para ello utilizaré las clases Thread y Loop tal y como se muestra en la figura 64.
Figura 64: Código Mapas (III)
Además de las funciones ya indicadas, esta clase (Activity) también se encarga de dibujar en el mapa la posición en el mapa del usuario, para hacerlo, utiliza las coordenadas obtenidas del GPS. Otra de las funcionalidades que realiza la clase Activity es la de mostrar amigos. Para hacerlo, se conecta al servidor y obtiene una lista de los usuarios de la aplicación que están a menos de 500 metros a la redonda. Cuando se han descargado todos los usuarios, el sistema comprueba si están o no en la lista de amigos, y si es así, calcula la ruta para llegar hasta dónde está ese amigo. Una vez obtenida esa ruta, se calcula la distancia que recorrerá el usuario, y si son menos de 500 metros se acepta y se muestra por pantalla. Después de todo el proceso anterior, si algún amigo ha pasado el filtro, la aplicación generará un aviso que se mostrará por pantalla y avisará al usuario mediante una vibración de 0.5 segundos. A continuación, en la figura 65, mostraré el código necesario para generar el aviso al usuario:
Figura 65: Código Mapas (VI)
Tal y como expuse cuando expliqué el funcionamiento de la interfaz gráfica, son necesarios dos menús para cargar la información de esos menús, además es necesario obtener la información que envía la clase principal. En el primer menú se carga un listado los menú. amigos del usuario, estos datos vienen como un vector y se insertancon en latodos vista del Una vez elegido un amigo, se cargan los lugares que le gustan a ese usuario. Para saber qué lugares hay que cargar de la matriz de lugares, y se utiliza el Id de usuario que identifica la posición en la matriz en la que se encuentran los lugares. La última funcionalidad que implementa esta clase es mostrar los lugares que le gustan a los amigos y el lugar donde se encuentran estos, indicando la ruta para llegar hasta ellos. 82
4.5.15. Clase TratamientoJSON Hasta este punto de la memoria ya he explicado cómo funcionan todos los Activities del proyecto, pero no he comentado nada de ninguna clase auxiliar.
La clase que se trata en este apartado es utilizada para poder extraer los datos de las cadenas JSON que se obtienen del servidor de Facebook. Estos datos se obtienen cuando al API del cliente de Facebook se conecta al servidor y por ejemplo se descarga un listado de objetos JSON con todos los datos del usuario de Facebook, y de estos objetos se extraen el nombre de usuario y el Id. El Id es necesario almacenarlo para poder realizar las búsquedas de los intereses y el nombre de usuario lo utilizaremos para mostrarlo en el menú de los amigos. Otra función que implementa esta clase es para obtener los lugares que les gustan a los amigos. Al igual que en el caso del usuario, cuando la API hace búsquedas de los lugares al servidor de Facebook, hay que tratar los objetos JSON obtenidos. Cuando se descargan los lugares, y se empiezan a tratar se insertan en objetos de tipoIntereses (ver 4.5.15.). Después de tener todos los intereses almacenados, se le pasará un filtro y en función de la categoría, se descartará o no. Por último, esta clase tiene una función que se utiliza para filtrar qué lugares se encuentran cerca del usuario. Esta función es necesaria debido a que no se pueden realizar búsquedas de lugares usando Google Maps, por lo que hay que hacer una búsqueda de los lugares que hay cerca y filtrar los que les gustan a los amigos. La búsqueda se realiza utilizando el motor de búsqueda de Google Places, pero, en España el proveedor de búsquedas son las paginasAmarillas.
4.5.16. Clase Intereses Esta clase se utiliza para almacenar los datos relacionados con los intereses, tales como la fecha de creación del muro, el id, la categoría y el nombre. Es utilizada por la clase TratamientoJSON para guardar los lugares que les gustan a los usuarios, para posteriormente mostrarlos en el menú de la pantalla cuando el usuario quiera ver los lugares que le gustan a un usuario concreto.
4.5.17. Clase Lugares Esta clase se utiliza para almacenar los lugares que están cerca del usuario. Como parámetros fundamentales se almacena la latitud, la longitud, el id y el nombre. Se utiliza para poder filtrar los lugares que están cerca del usuario, de forma que cuando se crucen los datos con los de la claseIntereses, la aplicación pueda mostrar (gracias a las coordenadas) los lugares que les gustan a los amigos del usuario.
4.5.18. Clase R Esta clase es autogenerada cuando se crea el proyecto y se utiliza para enlazar los elementos de la interfaz gráfica con las clases Java para poder modificarlo.
4.5.19. Problemas encontrados y soluciones propuestas Durante la realización del proyecto me he enfrentado a numerosos problemas y contratiempos, algunos de ellos derivados de mi propia inexperiencia en el desarrollo de aplicaciones en esta plataforma, y otros causados por problemas de incompatibilidades y fallos que todavía no se han solucionado en las distintas API’s que he utilizado.
83
En este apartado, expondré los problemas más importantes y explicaré como los he solucionado. El primer problema que tuve durante el desarrollo de la aplicación fue la imposibilidad de identificarme en Facebook usando la aplicación. Este problema se debió a un fallo en la documentación de la API. En dicha documentación, indicaba que los datos de registro del usuario había que pasarlos convertidos en array como parámetro en el método authorize(). Efectivamente, el segundo parámetro del método es un array, pero ese array es para almacenar los permisos de los que dispone la aplicación, no para guardar los datos del usuario. Buscando información en Internet, descubrí que los datos los cogía del dialog que crea la propia API y que no era necesario pasarlos implícitamente en el método. En revisiones posteriores de la documentación esa errata fue eliminada y actualmente se explica correctamente como utilizar la API. Una vez superado el primer problema, continué con el desarrollo de la aplicación y comprobé que no podía enviar el objeto de tipo Facebook que había creado en la clase Principal a la clase Mapa. Esto supone un contratiempo importante, debido a que es necesario realizar numerosas consultas usando la API de Facebook y que no se dispone de dicha API en la clase Mapa. Este problema se presenta porque no se pueden enviar objetos no serializables entre activities, y la API de Facebook no se puede serializar. La solución de este problema conllevó que la aplicación sea bastante más lenta en el cambio de activities de lo que inicialmente se tenía previsto. El motivo es porque en vez de realizar sólo las consultas que el usuario indicara, por ejemplo buscando los lugares de sólo un amigo. Ahora hay que realizar todas las consultas antes de mostrar el Activity del mapa y enviarlos desde el Activity principal, por lo que cuando hay un gran número de amigos, se realizan un gran número de solicitudes que son lentas. Una vez que tenía claro cómo solucionar el problema, utilice varios arrays y una matriz para enviar datos entre los activities. Para hacerlo utilicé la clase Intent, que ofrece el soporte necesario para ese tipo de comunicación. Este ha sido sin duda el problema más grave que me he encontrado mientras desarrollaba la aplicación. Otro problema que tuve que solventar fue como identificar los amigos que estaban cerca del usuario de la aplicación. Este problema presentaba dos fases, por un lado tenía que almacenar en algún sitio ajeno a la aplicación o conocer de alguna forma la posición de los usuarios de la aplicación, y por otro lado, tenía que diferenciar los amigos que están cerca o no. La primera parte del problema lo solucione con una base de datos centralizada (ver 4.5.6), de esa forma tendría localizados en todo momento a los usuarios de la aplicación y podría enviarle a otros usuarios dicha información. La segunda parte era derivada de que un usuario que está a 500 metros a la redonda, cuando tiene que ir andando por las calles de una ciudad, puede ocurrir que se encuentre a 1000 metros o incluso más. Estos datos el servidor no los puede calcular por lo que hay que hacer el cálculo en dos veces, para estar seguro de que un usuario efectivamente está a menos de 500 metros. Para solucionarlo, hago un primer filtro en el servidor, este filtro calcula los usuarios (no necesariamente son amigos) que están a menos de 500 metros del usuario, cuando el cliente recibe los datos, comprueba cuales de esos datos están referidos a sus amigos y elimina los que no sean amigos. Utilizando un servicio Web de Google, puedo obtener un archivo XML con la información de la ruta a seguir, esto es, los puntos que marcará en el mapa, y entre los cuales hay una línea recta. En este momento, vuelvo a utilizar la distancia euclidea para calcular la distancia que hay 84
entre cada par de puntos, si la suma de todas esas distancias es menor de 500 metros, entonces se avisa al usuario, en caso contrario se descarta. El último problema importante que tuve que solucionar fue debido a un cambio en la política de uso de la API de Google Maps. En la versión anterior a la que yo he utilizado en este proyecto, se incluía un servicio que permitía al usuario dibujar una ruta en el mapa indicando sólo el punto de srcen y el punto de fin. En la versión que había disponible cuando fue necesario para el proyecto ese servicio había sido eliminado, por lo que fue necesario el desarrollo de una clase o un método que prestara el mismo servicio. Parauna solucionar ese problema tuveluego que recurrir a laese documentación aprender dibujar línea entre dos puntos, extrapolar sistema paray un númeroa indeterminado de puntos, y por último, preparar esa solución para que se actualice cuando se haga zoom en el mapa. Finalmente conseguí solucionar todos los problemas que se presentaron, unos de forma más eficiente, otros menos eficientemente, pero al final, los objetivos del proyecto se han cumplido, y los pequeños inconvenientes que se han tenido que permitir no son tan importantes como para rechazar el uso de la aplicación. No obstante, todo es mejorable.
4.6. Pruebas En esta sección voy a explicar detalladamente en que consistieron las pruebas que realicé al finalizar la aplicación, y las conclusiones que extraje de ellas. Para aclarar dichas pruebas he dividido la sección en dos, primero explicaré las pruebas para la localización de lugares y a continuación, explicaré las pruebas para la localización de los amigos.
4.6.1. Localización de lugares Como ya he comentado en secciones anteriores, para mostrar una posición en un mapa, primero hago una búsqueda de los lugares que le interesan a un amigo en concreto, y después, busco los lugares que están a mí alrededor y cruzo los datos. Si se produce algún resultado positivo se genera un aviso y se muestra la ruta al usuario. La figura 66 muestra la ventana de la aplicación cuando ha encontrado un resultado.
85
Figura 66: Lugar encontrado
Para buscar los lugares que están a mí alrededor, utilizo un motor de búsqueda proporcionado por las páginasAmarillas y si algún lugar no se anuncia, entonces no aparecerá en los resultados, aunque tenga un perfil en Facebook.
4.6.2. Localización de amigos Para localizar los amigos, se realizarán tres tipos de pruebas que se exponen a continuación: 4.6.2.1. Amigos fuera del radio Esta prueba consistió en poner la posición de un amigo fuera del radio de 500 metros y comprobar que efectivamente esos datos no se enviaban al cliente. Para comprobarlo, utilicé un código auxiliar que mostraba el id de los amigos descartados. Una vez comprobado que el funcionamiento era el esperado, se eliminó el código auxiliar para hacer más eficiente el servidor. 4.6.2.2. Amigos dentro del radio, pero demasiado lejos El objetivo de esta prueba era comprobar que la aplicación es capaz de calcular la distancia que tendría que recorrer un usuario desde su posición hasta la de un amigo. Si la distancia es mayor de 500 metros, se considera que ese amigo está demasiado lejos y ni siquiera se le avisa al usuario. Efectivamente, al realizar la prueba se obtuvo el resultado esperado, que era el descarte de esa información. 4.6.2.3. Amigos cerca Por último, esta prueba estaba pensada para comprobar que efectivamente el sistema calculaba la ruta para aquellos amigos que estaban lo suficientemente cerca. Para ello, introduje en la base de datos el id de una amigo, y su posición eran unos 100 metros en línea recta, cuando el servidor envió esos datos a la aplicación, ésta calculó la ruta y comprobó que eran menos de 500 metros. Por este motivo, muestro un aviso al usuario de la aplicación y además indico la ruta más corta que tendría que seguir caminando desde su posición hasta la de su amigo.
86
Para calcular la distancia que se recorre en la ruta utilizo un servicio Web de Google, en el que dado el srcen y el destino en coordenadas, devuelve un documento XML con el itinerario a seguir. Con estos datos, ya es muy fácil calcular la distancia a recorrer, basta con ir calculando la distancia entre dos puntos y luego ir sumando esas distancias para comparar con la distancia límite. La figura 67 muestra un ejemplo de lo descrito en esta sección.
Figura 67: Amigo encontrado
4.7. Conclusiones Durante la realización del proyecto he tenido que afrontar y superar diversos problemas, así como implementar varias soluciones para un mismo problema y comprobar cuál era la más eficiente. El problema más importante que encontré a la hora del desarrollo de la aplicación fue el envío del objeto Facebook entre Activities, ya que al no ser un objeto serializable no se podía enviar. La solución que encontré fue realizar las consultas antes del cambio de Activities y así al obtener los datos, los cuales se podían enviar al Activity del mapa. Otro problema que tuve que solventar durante la implementación del código fue idear una manera de localizar a los amigos que se encontraban cerca del usuario para poder avisarle. Lo solucioné creando un servidor con una base de datos que almacenara las posiciones de todos los usuarios de la aplicación y cada vez que un nuevo usuario se conecta le envía que seusuarios están a menos de Google 500 metros de él. Cuando aplicacióneste recibe los datos, utiliza un servicio Web de para calcular la ruta y la mostrarla en el mapa en caso de que sea menor de 500 metros. El último gran problema que tuve que solventar fue poder dibujar las rutas para ir desde la posición del usuario hasta el amigo o lugar encontrado. Este problema era causado por dos razones, por un lado Google ha suprimido un servicio que se encargaba de dibujar rutas, y por otro lado, para dibujar en el mapa no se utilizan GeoPoints, sino puntos creados a partir de esos GeoPoints. Lo solucione leyendo la documentación y utilizando ejemplos que encontré en la bibliografía [48]. 87
Como conclusión final, puedo afirmar que el desarrollo de este proyecto me ha aportado conocimientos y experiencias que sin duda me serán de gran utilidad para proyectos Android futuros, ya sea mejorando la aplicación expuesta en este documento o en la creación de aplicaciones nuevas.
88
Conclusiones y trabajo futuro En este capítulo se va a realizar un pequeño resumen de cada uno de los capítulos anteriores, destacando las conclusiones que se pueden obtener de cada uno de ellos, así como una conclusión general de la realización del proyecto. Para finalizar se han presentado unas líneas de trabajo futuro a partir de este proyecto, las cuales se detallarán a lo largo del capítulo.
5.1. Conclusiones A lo largo del desarrollo del proyecto se han ido cumpliendo los objetivos que se marcaron al comienzo del mismo. Gracias a este proyecto, los usuarios dispondrán de una aplicación que les permitirá localizar a sus amigos y los lugares que les gustan a ellos. El primer capítulo sirve para introducirnos en el entorno del proyecto, se hizo un breve resumen de los objetivos que se perseguían con el proyecto, se explicó el ámbito de trabajo, se diseñó un plan de trabajo, y se expusieron la metodología a seguir y las herramientas a utilizar. En este capítulo se definieron algunas de las características del proyecto, como la localización de los amigos basándose en GPS y no en 3G, o la
89
utilización de la API de Google Maps para mostrar la posición de los lugares y la ruta hasta ellos. El segundo y tercer capítulo sirven para ponernos en situación de cómo está actualmente el mercado de telefonía móvil. El segundo capítulo sirve para ver una comparativa de las plataformas móviles con más cuota de mercado (iOS, Web-OS, BlackBerry OS, Symbian y Windows-Phone). A lo largo del capítulo se realiza una comparativa de las distintas plataformas de distribución que tienen dichos sistemas operativos. También se hace una valoración del estado actual de la plataforma, sus posibilidades de evolución, etc. Al ser la temática del proyecto el desarrollo de una aplicación para Android he creído conveniente utilizar un capítulo de este documento a explicar detalladamente las características de Android. A lo largo del tercer capítulo se expliqua cómo funciona el sistema operativo, como están interconectadas las distintas capas del sistema y cuál es el ciclo de vida de una aplicación. Este capítulo sirve para poder entender cómo funciona el sistema, y como se desarrollan aplicaciones para él, además se entrará en detalle en explicar los diferentes permisos que se le pueden asignar a una aplicación ya que es una parte muy importante de las aplicaciones en Android. En el cuarto capítulo es donde se expone el desarrollo de la aplicación. Es en este capítulo cuando explico el funcionamiento de las API’s de Google y de Facebook que son fundamentales para el desarrollo de la aplicación. Por otro lado, también utilizo este capítulo para mostrar todos los aspectos relacionados con la ingeniería del software de esta aplicación. Además de lo ya comentado, en este capítulo se explica cómo funciona la aplicación, como se han solucionado algunos problemas, etc. En líneasy que generales, concluirenque se han alcanzado loselobjetivos propusieron fueron puedo desarrollados el capítulo 1. Además, desarrolloque de se la aplicación me ha servido para profundizar mis conocimientos en la creación de aplicaciones Android, ya que es un mercado emergente, que de momento, crece todos los años y ofrece grandes posibilidades. Lamentablemente, al ser una plataforma tan amplia, es imposible recoger todas las características que ofrece Android y reunirlas en un solo proyecto.
5.2. Líneas futuras Una vez finalizado el proyecto, y revisado concienzudamente en distintos países y comprobado que funciona en todos ellos, se abren varias vías de mejora, a tener en cuenta para desarrollos futuros:
Integración con Tuenti: En España, además de Facebook, la red social Tuenti es muy utilizada, por lo que se podría desarrollar otra versión de la aplicación para dicha red social. Integración con Twitter: Actualmente, la red social twitter se está expandiendo y aumentando su número de usuarios activos, debido al tipo de red social que es twitter, se podrían incorporar los comentarios que ha hecho un usuario sobre un lugar. Disponibilidad con más dispositivos: Como hemos visto en el capítulo dos, existen numerosos sistemas operativos para Smartphones, estos sistemas operativos tienen muchísimos usuarios, por lo que con vistas a una posible comercialización, sería razonable, lanzar versiones de la aplicación 90
compatible con dichas plataformas (iOS y Windows-Phone serian los candidatos más probables). Disponibilidad para todos los usuarios: Siguiendo la línea de trabajo anterior, es muy importante, desarrollar la aplicación para personas que tengan algún tipo de discapacidad física, por ejemplo, con letras más grandes y sonido para personas con problemas de visión, etc.
91
Bibliografía [1] http://www.developer.apple.com [Noviembre-2011] [2] http://www.apple.com/es/icloud/what-is.html [Noviembre-2011] [3] http://www.todoiphone.net/index.php/2011/09/26/android-gana-cuota-de-mercadopero-sin-afectar-a-ios-que-mantiene-su-posicion/ [Noviembre-2011] [4] http://www.cincodias.com/articulo/empresas/nokia-sufre-dura-perdida-cuotamercado-movil/20110812cdscdiemp_3/[Noviembre-2011] [5] http://en.wikipedia.org/wiki/Ovi_(Nokia) [Noviembre-2011] [6] http://www.movilzona.es/2010/10/20/palm-webos-2-0-todos-los-detalles-ycaracteristicas/ [Noviembre-2011] [7] http://www.webosmania.com/webos/10-millones-descargas-software-webos/ [Noviembre-2011] [8] http://www.blogdemoviles.com.ar/caracteristicas-palm-webos-2-0/ [Noviembre2011]
92
[9] http://www.precentral.net/app-catalog-update-pushed-app-update-adds-new-iconmaybe-other-stuff-1 [Noviembre-2011] [10] http://www.xataka.com/moviles/windows-phone-7[Noviembre-2011] [11] http://www.windowsphone.com/es-ES/marketplace?wa=wsignin1.04 [Noviembre2011] [12] http://es.wikipedia.org/wiki/Windows_Phone_7 [Noviembre-2011] [13] http://es.wikipedia.org/wiki/Windows_Phone [Noviembre-2011] [14] http://en.wikipedia.org/wiki/Windows_Phone_Marketplace [Noviembre-2011] http://www.infonucleo.com/2011/05/02/blackberry-os-7-caracteristicas-del-nuevo-s [15] [Noviembre-2011] [16] http://www.amenazabarrial.com/2011/05/caracteristicas-y-detalles-blackberry.html [Noviembre-2011] [17] http://en.wikipedia.org/wiki/BlackBerry_App_World [Noviembre-2011] [18] http://www.celularis.com/blackberry/finalmente-lo-construyeron-blackberryapplication-center.php [Noviembre-2011] [19] http://www.idg.es/pcworldtech/mostrarnoticia.asp?id=72800&seccion=actualidad [Noviembre-2011] [20] http://conecti.ca/2011/07/26/infografia-la-historia-de-android/[Noviembre-2011] [21] http://es.wikipedia.org/wiki/Android [Noviembre-2011] [22] http://androideity.com/2011/07/04/arquitectura-de-android/ [Noviembre-2011] [23] http://www.visualbeta.es/647/movil/android-sdk-ya-disponible/ [Noviembre-2011] [24] http://developer.android.com/reference/android/app/Activity.html [Noviembre2011] [25] http://www.tecnocaos.com/desarrollo-en-android-iii-la-clase-activity-y-cambioentre-actividades/ [Noviembre-2011] [26] http://developer.android.com/reference/android/content/Intent.html [Noviembre2011] [27] http://androide.hijodeblog.com/2010/06/17/creacion-de-aplicaciones-android-parte4-servicios/ [Noviembre-2011] [28] http://www.nosolounix.com/2011/01/android-manifest-archivo-con.html [Noviembre-2011] [29] https://sites.google.com/site/swcuc3m/home/android/generalidades/aplicacionesandroid [Noviembre-2011] [30] https://sites.google.com/site/swcuc3m/home/android/generalidades/aplicacionespag2 [Noviembre-2011] [31] http://www.elbauldelprogramador.com/2011/06/fundamentos-programacionandroid_17.html [Noviembre-2011] [32] http://www.elbauldelprogramador.com/2011/09/programacion-androidrecursos.html [Noviembre-2011] [33] http://es.wikipedia.org/wiki/Google [Noviembre-2011] 93
[34] http://es.wikipedia.org/wiki/Facebook [Noviembre-2011] [35] http://code.google.com/intl/es/apis/maps/index.html[Noviembre-2011] [36] http://www.maestrosdelweb.com/editorial/trabajando-con-la-api-de-facebook-yjavascript/ [Noviembre-2011] [37] http://www.androidzona.net/analisis-de-los-permisos-en-android/ [Noviembre2011] [38] http://apiconz.blogspot.com/2011/11/android-como-generar-api-key-degoogle.html [Noviembre-2011] [39] http://www.facebook.com [40] http://code.google.com/intl/es-ES/apis/maps/index.html[Agosto-2011] [41] http://developer.android.com/sdk/index.html[Agosto-2011] [42] http://developers.facebook.com/docs/guides/mobile/#android [Agosto-2011] [43] https://www.facebook.com/developers/apps.php [Agosto-2011] [44] https://developers.facebook.com/docs/reference/api/permissions/ [Agosto-2011] [45] http://www.android-spa.com/viewtopic.php?p=58781#58781 [Agosto-2011] [46] http://developer.android.com/reference/packages.html [Agosto-2011] [47] http://www.androidsis.com/foro/ [Agosto-2011] [48] Android Essentials (Chis Haseman) [49] The busy coder’s guide to Android development (Mark L. Murphy)
[50] Beginning Android (Mark L. Murphy) [51] Hello, Android (Ed Murnette) [52] Pro Android (Sayed Y. Hashimi & Satya Komatineni)
94
ANEXOS ANEXO I: Instalación del SDK de Android El objetivo de este anexo es explicar cómo se tienen que instalar los plugins necesarios en eclipse para que un usuario pueda desarrollar sus aplicaciones en dicho IDE. El primer paso es descargarse el SDK, para ello, vamos a la página oficial de desarrolladores de Android (http://developer.android.com/sdk/index.html), y nos descargamos instalador adecuado para la versión sistema operativo este Web caso se dispone delel sistema operativo Windows). En la del figura 68 muestro la (en página desde donde se puede descargar el SDK para los sistemas operativos más populares.
Figura 68: Descarga SDK
Una vez descargado el software, procederemos a realizar la instalación como cualquier otro programa de Windows. Al comienzo de la instalación, indicaremos la ruta donde se va a instalar el SDK, tal y como se muestra en la figura 69.
Figura 69: Ruta instalación
95
Una vez instalado el SDK, tendremos que elegir que API’s vamos a instalar, aunque, en teoría, instalando la última versión de la API (actualmente la versión 14) los programas deberían funcionar en versiones anteriores. Esto no siempre es así, por lo que instalaremos todas las versiones, aunque el tiempo de instalación aumente considerablemente. Esto se muestra en la figura 70. Además de por motivos de compatibilidad, hay otro motivo que explicaré más adelante.
Figura 70: Elección de paquetes
Con todos los paquetes seleccionados, se nos informará del acuerdo de licencia, que debemos aceptar para que comience la descarga de los archivos y la posterior instalación. Al haber tantas versiones de la API, este proceso puede tardar bastante tiempo. En la figura 71 se muestra el acuerdo de instalación.
Figura 71: Términos de licencia
96
En este punto ya tenemos instalado el SDK de Android, ahora tenemos que añadir el plugin para poder utilizar Eclipse como entorno de desarrollo, para ello tendremos que añadir el repositorio del ADT (Android Developers Tool), tal y como se muestra en la figura 72. El motivo de haber instalado el SDK es porque proporciona un emulador de dispositivos en el que podemos elegir la versión del sistema operativo a instalar para no tener que hacer pruebas sobre un teléfono de verdad.
Figura 72: Adición de repositorio ADT
Durante la instalación tendremos que elegir las herramientas que vamos a instalar. Por defecto, las elegiremos todas, para así evitar problemas de incompatibilidades con dispositivos. La figura 73 muestra lo descrito en este párrafo.
Figura 73: Selección de ítems
97
Debido a que estamos instalando nuevo software algunas licencias deben ser aceptadas de nuevo. Si no las aceptamos no podremos continuar con la instalación. Las licencias se muestran en la figura 74.
Figura 74: Aceptación de licencia
Antes de comenzar la instalación, tendremos que volver a instalar la última versión del SDK, de esta forma se integrará correctamente con Eclipse. También se puede utilizar la opción de utilizar SDK’s existentes, pero basándome en mi experiencia
personal, el plugin no se integrará correctamente y algunas veces fallará sin razón aparente. La figura 75 muestra lo descrito en este párrafo.
Figura 75: Elección de ruta de instalación
La figura 76, es similar a la que nos apareció cuando estábamos instalando el SDK, solo que en este caso, tendremos que instalar solo la última versión.
98
Figura 76: Términos de licencia
Una vez finalizada la instalación, reiniciaremos Eclipse y ya podremos crear proyectos para el sistema operativo Android (ver anexo II).
99
ANEXO II: Creación de un nuevo proyecto Android En el anexo anterior, he explicado como instalar el SDK de Android en el IDE Eclipse, y en este anexo, voy a explicar como hacer un nuevo proyecto de Android para el desarrollo de una aplicación. En primer lugar, al igual que para cualquier otro proyecto en Eclipse tenemos que ir a File New Project Other y se nos abrirá la ventana que muestro a continuación. En esa ventana elegimos la carpeta Android, y dentro de ella, elegimos Android Project, con esta opción, al finalizar, se crearan todos los archivos necesarios. La figura 77 muestra el proyecto que hay que elegir.
Figura 77: Selección de proyecto
En la siguiente ventana hay que elegir el nombre del proyecto (que no puede estar repetido), el nombre de la aplicación, el nombre del paquete, y de forma opcional el nombre del primer Activity del proyecto. Además, hay que indicar la API que utilizara la aplicación, ya que cuando se suba a la plataforma de distribución (Android Market) solo estará disponible para aquellos dispositivos con una versión igual o superior a la indicada. También es recomendable, si se va a utilizar un mapa o cualquier servicio de Google elegir una API de Google, en lugar de una API genérica. En la figura 78 muestro una imagen donde se ven todos los detalles comentados en el párrafo anterior:
100
Figura 78: Especificaciones del proyecto
101
Para insertar una clase nueva en el proyecto se hace como con cualquier aplicación Java normal: New Class. Si lo que se desea es insertar una ventana para la aplicación, se utiliza New Android XML File, y aparecerá la siguiente ventana en la que podremos elegir qué tipo de archivo XML se va a crear (recordar que no sólo los interfaces están en XML). Esto se muestra en la figura 79.
Figura 79: Creación de un documento XML
102
ANEXO III: Creación de un dispositivo virtual Un consejo que deben seguir los desarrolladores, es no probar una aplicación directamente en un teléfono, ya que pueden provocar problemas en el hardware del teléfono. Por este motivo, el SDK de Android proporciona dispositivos virtuales, en los que probar la aplicación sin ningún riesgo. Para crear un dispositivo, tenemos que acceder a la aplicación previamente instalada (ver anexo I) SDK Manager en el menú de la izquierda selecciona Virtual Devices y pulsar en el botón New. La figura 80 muestra la ventana para crear un nuevo dispositivo virtual.
Figura 80: Administración dispositivos virtuales
Al pulsar el botón New, nos aparecerá una ventana en la que tendremos que elegir, las distintas características del dispositivo que queremos crear. Para este caso, hemos creado un dispositivo con 2Gb de memoria (no son necesarios, pero es recomendable), indicaremos una resolución de pantalla de 800x600 y habilitaremos las siguientes unidades hardware: Soporte a tarjetas SD Soporte GPS (al ser virtual, hay que emular las posiciones) Acelerómetro Todas las características que se han seleccionado se muestran en la figura 81.
103
Figura 81: Configuración nuevo dispositivo
Al pulsar en el botón Aceptar, se nos mostrara una ventana resumiendo las características (ver figura 82). Al pulsar el botón OK, comenzara la creación del dispositivo.
Figura 82: Confirmación
104
Una vez finalizado el proceso de creación, en la ventana inicial de dispositivos, aparecerá el que utilizaremos en este proyecto ( Facebook-Tourism). En la figura 83 se muestra un listado de los dispositivos virtuales que se han creado.
Figura 83: Lista de dispositivos virtuales
105
ANEXO IV: Obtener una API Key para Google Maps Para obtener la clave necesitamos generar una huella digital de certificado MD5, empleando la herramienta keytool que viene con Java SDK y que no forma parte del Android SDK. Para ello se ejecuta el comando que aparece en la figura 84 [38]. El comando que hay que ejecutar es: keytool –list –keystore debug.keystorepass Android -key
Figura 84: Generación de certificado
Con laAceptamos huella digital a la página de registro e insertaremos el dato generado. los obtenida, términos yiremos condiciones y pulsamos en Generate API Key. La pantalla que aparecerá nos muestra el API Key generado, la huella del certificado y un ejemplo de uso. Dicha pantalla se muestra en la figura 85:
Figura 85: Clave generada
Esta clave tiene una validez de 6 meses, por lo que pasado ese tiempo, para que la aplicación siga funcionando tendré que regenerar la API Key.
106
ANEXO V: Obtener una API Key para Facebook Para obtener al API Key necesaria de Facebook, necesaria para nuestra aplicación, tendremos que acceder a la página de desarrolladores de Facebook y otorgarle permisos básicos. Seleccionamos Crea una y acto seguido saltará una ventana para validar nuestra cuenta usando el móvil o la tarjeta de crédito (para probarlo, te cobran y te devuelven 0,72€).
Con la cuenta validada, volvemos a pulsar Crea una y saldrá la ventana que aparece en la figura 86. En dicha ventana, introduciremos el nombre de la aplicación. En este ejemplo la aplicación se llama Facebook-Tourism pero por motivos de acuerdos de licencia, el nombre de la aplicación no puede contener el nombre de la red social.
Figura 86: Registro de aplicación
Una vez creada la aplicación, podremos editar todos los permisos. La página principal de una aplicación, la muestro en la figura 87:
Figura 87: Datos de la aplicación
Al igual que para Google Maps, para poder utilizar la API de Facebook, tenemos que generar un certificado digital para que nos genere la clave a partir de ese certificado. Para hacerlo, iremos a la ventana de comandos e introduciremos la orden que se muestra en la figura 88. Durante el proceso, nos pedirá una contraseña que si no la introducimos correctamente, no podremos terminar el proceso. El comando que hay que ejecutar es: –exportvert –alias –keystore Ketool androiddebugkey ./android/debug.keystore | openssl sha1 –binary | openssl base64
107
Figura 88: Generando certificado
La clave generada anteriormente se indicará en lalafigura página89.de la aplicación y esta generará la Key necesaria. Dicha Key puede verse en
Figura 89: Generación de Key
Aunque ya tenemos la clave generada, todavía no podemos utilizar la API de Facebook. Esto se debe a que no hemos instalado el programaGit. Este es un programa similar al SVN, y es necesario para poder descargar la API. Para instalarlo tendremos que utilizar el comando que aparece en la figura 90:
Figura 90: Descarga de API
Ahora ya si podremos utilizar la API, simplemente se incorpora al proyecto como una librería externa y se instancia un objeto de la clase Facebook, tal y como se muestra en la figura 91.
Figura 91: Instanciación Facebook
108
ANEXO VI: Manual de usuario de la aplicación En este anexo voy a explicar cómo funciona la aplicación del proyecto. El primer requisito es tenerla instalada en el teléfono, la explicación comenzará a partir de ese punto. Accederemos a través del menú y la ejecutaremos. En la figura 92 se muestra el menú de emulador con la aplicación ya instalada.
Figura 92: Menú Android
Esta es la primera proyecto (ver figura 93),social desde aquí tenemos diferentes caminos, por unventana lado, si del estamos registrados en la red podemos acceder a la aplicación, y si pulsamos sobre la etiqueta Regístrate! se lanzará un navegador para que el usuario se registre.
Figura 93: Inicio de la aplicación
109
Cuando el usuario pulsa el botón Acceder, se lanzará un dialog proporcionado por Facebook, en el que el usuario introduce su nombre dirección de correo electrónico y su contraseña. Una vez introducidos los datos se comprobarán en el servidor de Facebook, y si son correctos, se realizaran las consultas de amigos y de lugares para mostrarlos en la siguiente ventana. El dialog de Facebook aparece en la figura 94.
Figura 94: Identificación Facebook
Esta es la ventana donde el usuario de la aplicación pasará más tiempo, desde aquí puede a su listado amigos en la etiqueta de amigos) y verUna los lugaresacceder que le gustan a cadadeuno de los(pulsando amigos (pulsando en la etiqueta lugares). vez elegido un lugar, si este se encuentra cerca, se le mostrará la ruta para llegar hasta él. Sin necesidad de que el usuario haga nada, cuando se conecte a la aplicación o cambie su posición, se le mostrará un aviso indicando los amigos que se encuentran cerca y la ruta para llegar hasta ellos. Esto se muestra en la figura 95.
Figura 95: Ventana Principal
110
Una funcionalidad añadida de esta ventana, es la de poder cambiar la vista del mapa eligiendo el tipo de mapa que se quiere mostrar (StreetView, Satélite o Trafico). Estas vistas son auto-excluyentes, por lo que el usuario no podrá tener seleccionadas dos vistas al mismo tiempo. Cuando el usuario mantiene pulsado sobre la etiqueta Amigos se cargará un menú con un listado de todos sus amigos. Al seleccionar sobre un amigo, el sistema cargará automáticamente los lugares que le gustan a éste y si está cerca, también mostrará la ruta para llegar hasta él. En la figura 96 se muestra el menú con el listado de amigos.
Figura 96: Menú Amigos
Cuando el usuario ha seleccionado un amigo, podrá visualizar un menú con los lugares que le gustan a éste. Para hacerlo basta con mantener pulsado la etiqueta Lugares. Si el usuario selecciona un lugar y este lugar está cerca, la aplicación mostrará la ruta para llegar desde la posición del usuario hasta el lugar seleccionado. El menú con los lugares que le gustan a un amigo en concreto aparece en la figura 97.
Figura 97: Menú Lugares
111
Por último, mostraré en la figura 98 una imagen del navegador Web de Android, con la página de Facebook cargada. Esta pantalla se mostrará cuando un usuario no registrado en Facebook intente usar la aplicación y pulse en la etiqueta Regístrate!.
Figura 98: Registro en Facebook
112
ANEXO VII: Tutorial Location-GPS 1. Introducción
Android es el sistema operativo que Google especialmente diseño para ejecutar en dispositivos móviles. Todo nació allá por el 2007 cuando se estableció la OHA (Open Handset Alliance) que se conforma por más de 40 empresas relacionadas con la fabricación (hardware y software) y distribución de dispositivos móviles. Desde su lanzamiento, numerosos programadores han encontrado en este sistema operativo la primera plataforma de programación sencilla, potente y fiable para programar en sistemas móviles. En este documento vamos a realizar una introducción a la programación en la plataforma Android cuyo fin será que podamos construir una aplicación sencilla basada en Activity, ActivityMap y Services. 2. Que es y que no es este anexo
Este anexo SI: Es una introducción a la programación en Android Te describirá los distintos procesos existentes en Android Te ayudará a realizar tu primera aplicación Android Te enseñará a utilizar mapas, gps y servicios de tu aplicación Android Este anexo NO:
Te enseñará a instalar el entorno (SDK, Eclipse, …) Es un documento explicativo sobre la filosofía de Android Es un documento avanzado sobre programación en Java/Android.
3. Fundamentos de una aplicación Android
La plataforma de Android proporciona diferentes componentes a la hora de programar en función del objetivo de tu aplicación. Android provee cuatro tipos diferentes de componentes:
Un Activity es el componente más usado en las aplicaciones Android. Normalmente un Activity representa una pantalla individual en el terminal y presenta una interfaz gráfica al usuario. Por ejemplo, en una aplicación de listado de teléfonos móviles utilizaríamos dos Activities. Una para mostrar el listado de nombres y teléfonos y la segunda, para mostrar la información detallada del contacto seleccionado. La navegación entre las pantallas se realiza iniciando nuevas Activities. Cuando una Activity es abierta, la Activity previa es puesta en pausa y agregada al history stack y no volverá hasta el estado de ejecución hasta que vuelva a ser invocada. Services: Un service no tiene interfaz gráfica, pero puede ejecutarse en background por un tiempo indefinido (se asemeja mucho al demonio de los sistemas Linux). Por ejemplo, podemos utilizar un service para que vaya capturando cada cierto tiempo la posición GPS y nos avise cuando estemos cerca de algún amigo. Mientras tanto el usuario puede seguir realizando otras tareas. Broadcast receivers: Este tipo de componentes se utilizan para recibir y reaccionar ante ciertas notificaciones broadcast. Este tipo de componentes no tiene interfaz gráfica y pueden reaccionar ante eventos Activity:
113
como cambio de zonas horarias, llamadas, nivel de batería, etc. Todos los receivers heredan de la clase BroadcastReceiver. Intent: Este tipo de componentes es una clase especial que usa Android para moverse de una pantalla a otra. Un Intent describe lo que una aplicación desea hacer. Cualquiera Activity puede reutilizar funcionalidades de otros componentes con solo hacer una solicitud en la forma de Intent.
4. Ciclo de vida de una aplicación Android
En laLinux. mayoría de los casos, una para aplicación Android ejecuta de su ypropio proceso El proceso es creado ejecutar el código de ladentro aplicación es el sistema quien pedirá y reclamará su memoria para reasignarla a otra aplicación. Una característica peculiar de Android es que el tiempo de vida de un proceso es controlado directamente por la aplicación. Es el sistema quien decide y determina el tiempo de vida basándose en el uso y capacidades del sistema. Para determinar los procesos que deberían ser eliminados ante una condición baja de memoria, Android prioriza los procesos bajo una jerarquía para asignar a cada proceso una importancia en el sistema. Existen diferentes procesos de acuerdo a esta jerarquía:
Foreground Process: Es un proceso en primer plano que aloja una Activity
en la pantalla y con la que el usuario está interactuando (su método onResume() ha sido llamado) o que un IntentReceiver está ejecutándose. Este tipo de procesos serán eliminados como último recurso si
el sistemaProcess necesitase Visible : Es memoria. un proceso que aloja una Activity pero no está en primer plano (su método onPause() ha sido llamado). Esto ocurre en situaciones donde la aplicación muestra un cuadro de dialogo para interactuar con el usuario. Este tipo de procesos no será eliminado a causa de que sea necesaria la memoria para mantener a todos los procesos del primer plano corriendo. Service Process: Es un proceso que aloja un Service que ha sido iniciado con el método startService(). Este tipo de procesos no son visibles y suelen ser importantes para el usuario (conexión con servidores, reproducción de música). Background Process: Es un proceso que aloja un Activity que es actualmente visible para el usuario (su método onStop() ha sido llamado). Normalmente la eliminación de estos procesos no suponen un gran impacto para la actividad del usuario. Es muy usual que existan numerosos procesos de este tipo en el sistema, por lo que el sistema mantiene una lista para asegurar que el último proceso visto por el usuario sea el último en eliminarse en caso de necesitar memoria. Empty Process: Es un proceso que no aloja ningún componente. La razón de existir de este proceso es tener una caché disponible de la aplicación para su próxima activación. Es común, que el sistema elimine este tipo de procesos con frecuencia para obtener memoria disponible.
114
5. Desarrollo en Android
Una vez que hemos explicado los diferentes procesos y sus ciclos de vida dentro del sistema operativo Android, vamos a pasar a detallar la implementación de alguno de estos procesos. 5.1. Desarrollo de un Activity
El primer ejemplo práctico que vamos a ver es la creación de una Activity sencilla, simple, que únicamente tenga un par de componentes y una finalidad clara. Vamos a crear una Activity que contenga un botón y una etiqueta (textView) para mostrar la posición GPS actual. La figura 99 muestra un fragmento de los permisos para poder utilizar GPS.
Figura 99: Permisos GPS
Ahora lo que crearemos es el layout (escrito en XML) que representará la interfaz gráfica que tendrá nuestra actividad. Será una interfaz sencilla donde tendremos un botón y un textView para mostrar nuestra localización. El documento XML necesario para la creación de la interfaz se muestra en la figura 100.
Figura 100: Creación de interfaz
Ahora que ya tenemos el layout (que llamaremos main.xml) de la interfaz y los permisos correspondientes, vamos a pasar a la descripción del código de la clase. La cabecera de la clase se muestra en la figura 101. Figura 101: Creación de la clase
115
Nuestra clase LocationActivity hereda de la clase Activity, y además implementa las interfaces OnClickListener (para poder capturar los eventos onClick del botón) y Runnable (ya que vamos a ejecutar en un thread aparte la obtención de la posición GPS). La figura 102 muestra el código de los métodos onCreate() y onClick().
Figura 102: Código de la clase onCreate() se encarga de iniciar la Activity por primera vez, por ello El método realizamos la conexión de los widgets gráficos con la definición del archivo XML. Únicamente tenemos dos, un Button y un TextView. Es importante comentar que al botón le establecemos un listener para el evento onClick, que ejecutará el método updateSignalGPS que se detallará en las siguientes líneas. La figura 103 muestra el código del método writeSignalGPS().
Figura 103: Tratamiento GPS
116
Como vemos, el método writeSignalGPS instancia un processDialog para que se muestre por pantalla mientras se encuentra la posición GPS, y además ejecuta un Thread cuyo código mostramos en la figura 104:
Figura 104: Código thread
En el código de la figura 104 podemos ver como se configura elprovider de GPS como fuente de localización.
Figura 105: Location Listener
Es necesario implementar un LocationListener (tal y como se muestra en la figura 105) para ejecutar nuestro código cuando el sistema encuentra la posición GPS. Cuando el método onLocationChanges se llame, nos indicará que la posición GPS ha cambiado y por tanto podemos escribir dicha información en nuestra actividad. Como nos encontramos ejecutando un thread, no podemos acceder a la interfaz gráfica para poder modificar el textView (es una características típica de los sistemas gráficos). 117
Por ello vamos a utilizar el mecanismo de paso de mensajes que Android implementa como Handlers. El código es mostrado en la figura 106.
Figura 106: Handler
Por último, podemos ver como el manejador que hemos implementado se llama cuando encuentra la posición GPS y por tanto desde aquí si podemos actualizar la interfaz gráfica, por lo que mostramos la información en el textView txtLocation. En la figura 107 se muestra la ventana de la aplicación cuando ha encontrado un resultado.
Figura 107: Pantalla del Activity
5.2. Desarrollo de un Activity Map
Una vez que sabemos desarrollar sin problemas una Activity, vamos a ver como incluir un mapa (google maps) en dicha actividad. Lo primero que tenemos que hacer es heredar de la Actividad MapActivity tal y como se muestra en la figura 108. Figura 108: Modificación de la clase
118
Añadiremos en el layout el widget del mapa, el código necesario aparece en la figura 109.
Figura 109: Widget mapa
Como vemos en la figura 110, necesitamos un apiKey para poder utilizar los mapas de Google desde Android. Para generar la clave debes seguir los siguientes pasos:
Figura 110: keytool
Después se deberá ir a la siguiente url: http://code.google.com/intl/es-ES/android/maps-api-signup.html y obtener tu clave a partir del MD5 que se ha generado anteriormente. Cuando obtengas tu clave guárdala en un sitio seguro y añádela al layout, concretamente en la etiqueta Android:apiKey. Por ultimo solo nos queda añadir en el archivo Manifest.xml la declaración de la figura 111:
Figura 111: Uso de la API
Una vez que hemos configurado el layout para que aparezca el mapa y hemos creado la clave que nos permitirá descargar mapas de Google, en la figura 112 se muestra el código necesario para mostrar nuestra localización en dicho mapa.
119
Figura 112: Mostrar posición en el mapa
Como vemos en el anterior código, conectaremos el widget mapView a la definición del mapView del archivo Manifest.xml. Después calcularemos las coordenadas en el mapa gracias a la localización actual que se ha obtenido a través del GPS. Y por último añadiremos un Overlay o capa al mapa para mostrar nuestro nombre al lado de la posición. En la figura 113 se muestra el código de la clase PositionOverlay.
120
Figura 113: Clase Overlay
121
Por último, sólo nos quedará añadir el código correspondiente para que cuando se encuentra la señal GPS, se llame al método showMap que es el encargado de mostrar nuestra posición en el mapa. En la figura 114 se muestra el código necesario y el resultado obtenido.
Figura 114: Posición mostrada en el mapa
5.3. Desarrollo de un Activity List
Después de ver como creamos un Activity o un ActivityMap vamos a ver cómo crear un ActivityList que nos ayudará a diseñar listas fácilmente. La idea principal de un ActivityList es la creación de un layout que nos permite representar una lista con información. En nuestro ejemplo, vamos a mostrar una lista con información de nuestros amigos. Por lo tanto lo primero, vamos a diseñar el layout, el código necesario aparece en la figura 115.
122
Figura 115: Diseño del layout
Como vemos en la figura 115, sólo generamos el layout para el tipo de fila que tendrá la lista. Dicha fila tiene dos columnas (dos LinearLayout): la primera es una imagen, y la segunda se compone de dosTextViews donde mostraremos el nombre e información de nuestros amigos. En la figura 116 se muestra el código Java de la lista.
Figura 116: Clase friendlist
123
Figura 117: Clase friendsAdpater
Como hemos podido observar en la figura 117, la clase FriendList es una clase en la cual hemos creado un adaptador personalizado para mostrar la información en la lista. Observar que el método getFriendList debe devolver una lista con la información de los amigos. ActivityList
124
Es necesario generar un adaptador para mostrar la lista, ya que Android sólo permite generar listar automáticamente basadas en listas o arrays de enteros o strings. Si queremos generar una lista más compleja debemos crear nuestro propio adaptador, como hemos detallado en el código anterior. No hay que olvidar dar permisos en el Manifest.xml. En la figura 118 se muestra la lista con varios usuarios, y las imágenes añadidas.
Figura 118: Pantalla del ActivityList
6. Menús y menús contextuales
Los menús son una parte importante de toda aplicación, y más en Android, ya que nos permite mostrar numerosa información cuando el usuario lo solicite. En este apartado vamos a ver cómo implementar menús de pantallas y menús contextuales sobre listas. 6.1. Menús
Vamos a incorporar un menú en nuestra aplicación para poder seleccionar si queremos utilizar el proveedor GPS o Wi-Fi para obtener la localización.
Figura 119: Creación del menú
En el código de la figura 119 implementamos el método onCreateOptionsMenu para detallar las partes que tendrá nuestro menú. En este caso, hemos creado un menú principal llamado Location que tiene dos sub-menús GPS y WIFI.
125
Figura 120: Selección de menú
En el de la figura 120, implementamos el método onOptionItemSelected para definir qué acciones se llevan a cabo cuando se seleccionan estas opciones en el submenú. En la figura 121 se muestran los menús creados.
Figura 121: Pantallas del menú y sub-menú
5.3.
Menús contextuales
Los menús contextuales son aquellos que aparecen dependiendo del contexto que tengas en la aplicación. Por ejemplo, vamos a ver un caso donde podemos mostrar un menú contextual cuando se realiza una pulsación prolongada sobre un ítem de la lista. Lo primero que haremos será añadir el código de la figura 122 en el método onCreate del Activity FriendList:
Figura 122: Especificación para el menú contextual
126
A continuación sobrescribiremos el método de la figura 123 para detallar que menús aparecerán:
Figura 123: Rescritura del menú
Y para finalizar, deberemos detallar las acciones que queremos ejecutar cuando se pulsen estos menús, tal y como se muestra en la figura 124:
Figura 124: Especificación de acciones
La ejecución del código anterior nos mostrará la figura 125:
127
Figura 125: Ejemplo de menú contextual
6. Resumen
Recuerde:
Una pantalla = Una actividad = Una clase El archivo Manifest.xml define los permisos y características de la aplicación cuando se ejecuta en el móvil Estás programando en un sistema empotrado, piensa en eficiencia, eficiencia y eficiencia. Android te ofrece diferentes tipos de procesos con ciclos de vida diferentes, estudia bien tu caso y haz uso de ellos Comparte tu código: es bueno para ti, es bueno para todos.
128
