Aplicación para Android: agenda comercial y detalles de clientes

UNIVERSIDAD POLITÉCNICA DE VALENCIA ESCUELA TÉCNICA SUPERIOR DE INFORMÁTICA APLICADA Aplicación para Android: agenda comercial y detalles de clientes PROYECTO FIN DE CARRERA Autor Ignacio Domingo Garzarán Directores Carlos Tavares Calafate Emma López Franco Valencia, a 9 de septiembre de 2010 2 Resumen Este proyecto final de carrera consiste en la creación de una aplicación para Android alimentada por peticiones REST (Representational State Transfer) sobre Visual Studio 2008 en C#. Se parte de una serie de librerías ya desarrolladas que sirven información sobre una aplicación que tiene usuarios (gestores) que tienen clientes, y dónde éstos a su vez tienen carteras de inversión. El gestor tiene una agenda de tareas y citas, así como alertas creadas sobre clientes y productos. La aplicación debe ser capaz de: 1. Realizar una búsqueda de clientes y mostrar el resultado del mismo 2. Ver los datos personales de sus clientes 3. Ver el calendario de tareas y de citas general del usuario 4. Ver el calendario de tareas y citas asociado a un cliente dado 5. Dar de alta tareas/citas asociadas a un cliente dado 6. Ver las Alertas de Productos 7. Ver las Alertas de Clientes 8. Ver un informe de las carteras de cliente: •Importe de la cartera por producto •Distribución de los productos PALABRAS CLAVE Android, aplicación móvil, Workplace, agenda comercial 3 4 Índice 1 Introducción.......................................................................................................................................7 1.1 Motivación.................................................................................................................................8 1.2 Objetivos....................................................................................................................................9 1.3 Estructura del documento........................................................................................................10 2 Análisis y diseño..............................................................................................................................11 2.1 Especificación de requisitos.....................................................................................................11 2.2 Especificaciones técnicas.........................................................................................................12 2.2.1 Autenticación HTTP Basic...............................................................................................12 2.2.2 Conexión REST...............................................................................................................13 2.2.3 Información intercambiada..............................................................................................14 2.3 Diagramas UML......................................................................................................................15 2.3.1 Diagrama de casos de uso................................................................................................15 2.3.2 Diagrama de actividades..................................................................................................16 2.3.3 Diagrama de clases...........................................................................................................18 3. Implementación..............................................................................................................................19 4 Validación y pruebas........................................................................................................................21 5 Programación con el SDK de Android............................................................................................25 5.1 Introducción.............................................................................................................................25 5.2 Especificaciones técnicas.........................................................................................................28 5.3 Aplicación Android..................................................................................................................30 5.3.1 Estructura de carpetas......................................................................................................30 5.3.2 API de Android.................................................................................................................32 5.3.2.1 Activity.....................................................................................................................32 5.3.2.2 Intent.........................................................................................................................34 5.3.2.3 View..........................................................................................................................36 5.3.2.4 Leer información de Internet....................................................................................38 5.3.2.5 Activar servicio de búsqueda en un Activity............................................................39 5.3.2.6 Realizar una llamada................................................................................................41 5.3.2.7 Enviar un SMS.........................................................................................................41 5.3.2.8 Enviar un correo electrónico....................................................................................42 5.3.2.9 Crear una pantalla de configuración.........................................................................43 5.3.2.10 Almacenamiento persistente de datos.....................................................................46 5.3.2.11 Comprobar estado de la conexión..........................................................................47 5.3.2.12 Comprobar orientación de la pantalla....................................................................48 5.3.3 Creación de interfaces......................................................................................................49 5.4 Android en Eclipse IDE...........................................................................................................52 5.4.1 Creación de un proyecto Android....................................................................................52 5.4.2 Ejecución de un proyecto.................................................................................................54 5.4.3 Modificación de las características del proyecto.............................................................54 5.4.4 Creación de interfaces gráficas........................................................................................55 5.4.5 Generar instalador............................................................................................................56 5.4.6 Descargar proyectos de ejemplo......................................................................................58 5.5 Otras tecnologías utilizadas.....................................................................................................59 5.5.1 Autenticación Basic..........................................................................................................59 5.5.2 Lectura de ficheros XML.................................................................................................59 5.5.3 Acceso a Google Maps.....................................................................................................61 5.5.4 Dibujar gráficas de evolución..........................................................................................64 5.5.5 Generar un webservice.....................................................................................................64 5 6 Aplicación........................................................................................................................................67 6.1 Inicio de la aplicación..............................................................................................................67 6.2 Menú de usuario.......................................................................................................................69 6.3 Menú de cliente........................................................................................................................76 6.4 Menú de carteras del cliente....................................................................................................81 6.5 Menú de configuración............................................................................................................85 6.6 Mensajes de la aplicación........................................................................................................87 7 Ampliaciones...................................................................................................................................91 8 Conclusión.......................................................................................................................................93 9 Bibliografía......................................................................................................................................95 Anexos................................................................................................................................................99 6 1 Introducción Este documento tiene como propósito detallar la labor realizada durante el periodo de ejecución del proyecto final de carrera, el cual consiste de una aplicación para dispositivos móviles Android y ha sido desarrollado en la empresa Openfinance S.L. La aplicación es una agenda comercial que contacta con el Workplace de la empresa (consultar anexo para más información) a través de servicios web REST (Representational State Transfer). Esto supondrá diversas ventajas tanto para la empresa como para los usuarios ya existentes del Workplace. Por un lado, la empresa ampliará su gama de productos, ofreciendo a sus usuarios del Workplace una nueva forma de acceder a sus datos. Además, al aparecer la aplicación en el Android Market, siempre existe la posibilidad de captar nuevos clientes. Poro otro lado, los usuarios podrán consultar sus datos en cualquier momento y lugar, ya que todos los dispositivos Android disponen de acceso a Internet. Además esta aplicación añade nuevas funcionalidades para interactuar con sus datos Puesto que el objetivo de realizar un proyecto fin de carrera no es sólo la aplicación en sí, sino el paso de estudiante a ingeniero, la estructura del documento sigue una línea temporal, dónde se explica al inicio del mismo los pasos previos que cualquier Ingeniero Informático debe realizar antes de comenzar la implementación, y concluyendo con las ideas y reflexiones obtenidas tras su finalización, tanto sobre la aplicación como a nivel personal en la etapa final como estudiante. Como último aspecto importante, este trabajo ha servido como primera toma de contacto con el mundo laboral, además de como finalización del ciclo de formación universitaria. 7 1.1 Motivación La finalidad de este proyecto es ofrecer a los clientes ya existentes de Openfinance nuevas formas de acceder a sus aplicaciones. Por una parte, esto aporta beneficios a la empresa puesto que sus productos no se quedan obsoletos y se adaptan a las nuevas tecnologías. Por otra parte, los clientes ven como la empresa evoluciona y les proporciona nuevas formas de acceso a sus datos; esto proporcionará confianza y satisfacción de los usuarios actuales, al permitir comprobar que el Workplace es capaz de adaptarse en cada momento a las exigencias del mercado. Al mismo tiempo, esta aplicación puede ayudar a la captación de nuevos clientes, bien sea por descubrimiento de la existencia de la empresa al acceder a esta aplicación desde su dispositivo Android, o clientes que utilizaban productos similares al Workplace y que pueden sentirse atraídos por las nuevas posibilidades que este proyecto les ofrece, ya que es posible que las herramientas que estén utilizando no se hayan adaptado a las nuevas tecnologías. Existe ya una amplia gama de aplicaciones sobre economía para dispositivo móviles Android, pero ninguna similar a una intranet a la que puedes acceder desde tu teléfono. Ésta en concreto está orientada a usuarios gestores, y las ventajas que aporta respecto a otras aplicaciones de gestión de inversiones, es que con esta aplicación no solo podrán mantener un seguimiento de las carteras de inversión de sus clientes desde cualquier lugar, sino que además le ofrece una agenda comercial completa que le permitirá ponerse en contacto con sus clientes de múltiples formas. De esta manera, las ventajas que aporta esta aplicación respecto a las ya existentes sobre finanzas son todas las características definidas en el Anexo sobre el Workplace. Todo ello hace que, a nivel nacional, sea la empresa líder en el desarrollo de aplicaciones de gestión. 8 1.2 Objetivos Hoy en día es cada vez más habitual el uso de Internet en un dispositivo móvil. En el caso de Android, y más teniendo en cuenta que el principal promotor de este sistema operativo es Google, los dispositivos móviles están orientados a un uso optimizado de Internet. Teniendo en cuenta las nuevas tendencias del mercado, el principal objetivo de este proyecto es proporcionar una nueva forma de acceso a los usuarios de Workplace, que es una herramienta de gestión que básicamente permite al usuario realizar un seguimiento de las inversiones de sus clientes. Concretamente, la versión inicial se ha implementado para hacerla funcionar sobre el Workplace de EAFIS (definición en el apartado de Anexos). Esta aplicación logra que un usuario pueda acceder e interactuar con sus datos de una manera rápida y sencilla desde cualquier lugar en el que su dispositivo móvil tenga cobertura. De esta manera, este objetivo principal puede ser dividido en dos bloques: −Acceso eficiente a sus datos: presentárselos de una manera ordenada buscando siempre la optimización de los recursos disponibles. Para ello la aplicación estará dividida en tres menús: de usuario, de cliente y de carteras de un cliente. −Interacción de sus datos con la plataforma en la que accede a ellos: gracias a esta aplicación no sólo podrá acceder a sus datos para verlos, sino que además podrá realizar llamadas, enviar mensajes de texto o correos electrónicos. Respecto a los objetivos personales, teniendo en cuenta que el mundo de la informática está en continua evolución, se busca aprender a utilizar las nuevas tecnologías puesto que aunque se termine la etapa de estudiante, un informático va a estar aprendiendo a usar nuevos lenguajes de programación o tecnologías durante toda su vida laboral. En este caso, el objetivo personal es aprender a programar para una plataforma en la que no se ha trabajado durante la carrera, dado que Android es un sistema operativo muy reciente en el que aún no se ha profundizado a nivel académico. 9 2.3.2 Diagrama de actividades En este diagrama se muestra en el orden en el que el usuario debe realizar las acciones, así como las condiciones que deben cumplirse para poder llevarlas a cabo. El estado final puede alcanzarse desde cualquier actividad. La autenticación se refiere tanto al login como al PIN, puesto que, según la voluntad del usuario al iniciarse la aplicación se pueden requerir ambas, una de ellas o ninguna. Para una mayor claridad el diagrama se encuentra dividido en esta página (en la que se muestran sólo las actividades referidas al menú del cliente) y la siguiente. Figura 4: Diagrama de actividades (parte 1) 16 Figura 5: Diagrama de actividades (parte 2) 17 2.3.3 Diagrama de clases En este apartado se muestra el diagrama de clases, el cual representa las clases que será necesario implementar para adecuarse a los requisitos especificados por la empresa. Debe comentarse que, en este caso, el diagrama no sólo se realiza en base a las especificaciones dadas por Openfinance, sino que se ha orientado también en torno a los servicios web con los que conectará la aplicación, puesto que deberá manejar la información que estos devuelven. Figura 6: Diagrama de clases 18 3. Implementación La implementación se ha llevado a cabo siguiendo un proceso iterativo horizontal de prototipos. A cada prototipo se añaden menús de la aplicación con sus correspondientes funcionalidades. El proceso seguido puede dividirse en cuatro prototipos, los cuales a su vez pueden desglosarse en una serie de pasos y funcionalidades. −Primer prototipo: permite ver toda la información del usuario (gestor). Esto es el menú principal de la aplicación el cual se compone de cuatro pantallas distintas: listado de clientes del usuario, agenda del usuario, alertas del usuario y acceso al Watchlist (definición en apartado Anexos)del usuario. −Segundo prototipo: en el listado de clientes el usuario puede seleccionar el que desee para acceder de esta forma al menú del cliente, el cual se compone de nuevo de cuatro pantallas: listado de las carteras de inversión del cliente, agenda del cliente, alertas del cliente e información completa del cliente. En esta última pantalla se ofrece una serie de posibilidades en función de la información de la que se disponga: si se dispone de los números de contacto se puede realizar una llamada telefónica desde esta ventana, o mandar un SMS si el número fuese de un teléfono móvil, así como mandar un email si se dispone de la dirección de correo electrónico del cliente. −Tercer prototipo: en la pantalla del listado de carteras del cliente, el usuario puede seleccionar una o varias carteras sobre las que desee obtener más datos (posiciones y distribución). En caso de que no seleccione ninguna y acceda al siguiente menú la información a mostrar será de todas las carteras del listado. En este nuevo menú el usuario dispone de dos nuevas pantallas: la primera muestra un informe sobre las posiciones de la cartera o carteras seleccionadas para una determinada fecha; en la segunda ventana se muestra la distribución de las carteras, la cual puede verse en forma de gráfico o de tabla. −Cuarto prototipo: una vez se han realizado todos los menús de la aplicación (menú del usuario, del cliente y de carteras), se incorporan las pantallas de presentación, configuración, autenticación y acceso a la aplicación mediante PIN. Esta última está deshabilitada por defecto, y su visibilidad se controla desde la ventana de configuración. Además de estas ventanas también se implementa el almacenamiento persistente de datos (datos de configuración, URLs, PIN...), así como mejoras en la interfaz y nuevas funcionalidades: posibilidad de que el usuario ordene los listados en base al atributo que elija, acceso a GoogleMaps desde la ventana de información del cliente si se dispone de su dirección o posibilidad de elegir el intervalo de fechas para el cual se quiere listar los datos correspondientes a la agenda. Para llevar a cabo todo esto, el entorno de desarrollo escogido es Eclipse, debido a que en todos los libros de programación consultados y en la página oficial de Android es el recomendado y el único para el cual explican la instalación del plugin para usar el SDK. Los detalles de implementación respecto al SDK se verán más adelante. 19 20 4 Validación y pruebas El SDK de Android permite integrar dispositivos virtuales para probar la aplicación en el entorno de desarrollo Eclipse. Queda a disposición del usuario crearse cuantos emuladores quiera y con las características que se desee. Esta flexibilidad permite entre otras cosas, establecer la versión de sistema operativo en la que se ejecutará, el tipo de pantalla, su resolución, cantidad de memoria... Para realizar las pruebas se han creado dos emuladores: uno que implementa la versión 1.5 de Android, puesto que esta es la más común entre los terminales Android que se comercializan en España, y el segundo con la versión 2.1, puesto que es la última versión comercializada en España (ya existe la 2.2 pero no llegará a España hasta dentro de unos meses). Las principales diferencias entre ambos emuladores son la resolución de pantalla y la incorporación del botón de búsqueda (consultar anexos para una explicación de los botones Android) que en la versión 1.5 aún no existía. En todo momento se realizaban pruebas en uno y otro emulador para poder observar las diferencias de ejecución entre una versión y otra. Las diferencias entre velocidades de ejecución y acceso a Internet eran casi siempre mínimas, siendo lo más destacable los cambios a nivel de interfaz debido a la leve diferencia de resolución de pantallas, permitiendo de esta manera ajustar mejor el tamaño y apariencia de la información a mostrar para una correcta presentación. Como se comentaba en el apartado 3 Implementación, la aplicación se ha ido desarrollando a través de un proceso iterativo de prototipos. Al término de cada uno de ellos se realizaba una pequeña fase de validación, dando la empresa en cada momento su visto bueno y opinión antes de continuar. Esta validación era principalmente en cuanto a interfaz y cumplimiento de funcionalidades, puesto que las pruebas se realizaban sobre un emulador. De esta manera la optimización de código se deja para la fase final de la aplicación cuando ya pueda ser probada en un dispositivo real. Una vez la aplicación se encontraba ya en fase de finalización se probó en un teléfono real, prestando principal atención a los tiempos de ejecución y la presentación de la información. La conclusión principal es que es necesario poner más ventanas de espera, puesto que en un dispositivo real, el usuario puede elegir entre emplear conexión a través de la red 3G, con lo cual los tiempos son similares a los vistos en el emulador, o desconectarse de esta red para ahorro de batería, de esta manera la velocidad de conexión se reduce bastante y los retrasos en las transiciones de pantalla mientras se acceden a los datos son más notables. Se toma también en consideración la forma con la que el sistema operativo Android gestiona el cambio de orientación de la pantalla, puesto que, al girar el dispositivo, lo que hace realmente es destruir la ventana en ejecución y volverla a crear. Esto hace necesario un tratamiento especial para evitar que vuelva a descargar de Internet los datos que ya tenemos, puesto que es lo que más ralentiza la aplicación. 21 Uno de los aspectos críticos a tener en cuenta para la optimización de la aplicación, es el tiempo de procesamiento de los datos obtenidos por los servicios web. Que como ya se ha comentado, devuelven información en ficheros XML. En un principio, el tratamiento de éstos datos se realiza con las clases que proporciona la API de Android. No obstante, algunos de los manuales y foros consultados recomiendan usar la librería externa proporcionada por DOM4J para la lectura de este tipo de datos. Esto se debe a que esta librería hace uso de XPATH, lo cual permite la elaboración de un código más claro y fácil de mantener. Los detalles de implementación de cada una de las dos formas de procesamiento serán detallados en el apartado 5.5.2 Lectura de ficheros XML. No obstante, tras probar la aplicación y comprobar que con una carga considerable de datos el usuario ya tiene que esperar unos segundos hasta que éstos son procesados, se decide hacer una comparación del tiempo medio empleado por cada método de procesamiento. Para realizar estas pruebas, se mide el tiempo que la aplicación tardar en descargar el fichero XML por Internet y procesarlo para representar los datos en la pantalla de la agenda del usuario. Se realiza en esta ventana, por que en ella se puede seleccionar para cuantos meses se desea mostrar la información de la agenda (por defecto muestra dos meses a partir del día actual). Cuando se selecciona mostrar para más de medio año, normalmente sobrepasa ya el segundo de retardo. El proceso de comparación es el siguiente: se mide el tiempo que tarda en ejecutarse el método que se encarga de descargar y procesar el fichero XML. Esto se realiza con cada clase (API de Android o DOM4J) para un intervalo de dos meses, cuatro meses, ocho meses y catorce meses. La medición de cada intervalo se realiza cinco veces y se obtiene el tiempo medio, debido a que en el tiempo también influye el retardo de la conexión (aunque como es en un dispositivo móvil no hay más aplicaciones usando Internet al mismo tiempo). El resultado de la comparación se muestra en la Figura 7. En ella se representa el tiempo tardado (en milisegundos) respecto al número de meses para los que se accede a la información. El lector, utilizando las clases proporcionadas por DOM4J, tarda casi siempre el doble que ejecutando el mismo proceso con las clases de la API de Android, llegando a ser la diferencia de dos segundos de espera para el usuario, cuando se muestran las entradas de la agenda para un año y dos meses. Figura 7: gráfica de tiempo procesamiento de un fichero XML 22 0 2 4 6 8 10 12 14 16 0 1000 2000 3000 4000 5000 Tiempo de procesamiento de fichero XML Lector API de Android Lector DOM4J Meses de la agenda mostrados Tiempo(milisegundos) Lógicamente la diferencia de casi el doble de tiempo en todos los casos es un dato a tener muy en cuenta. Así que se toma la decisión de, una vez esté terminada la aplicación, retomar estas clases para la optimización máxima del código en cada uno de los casos. Una vez se han modificado ambos métodos de lectura se vuelve a realizar las mediciones, obteniéndose el mismo resultado: dos segundos de diferencia con una gran cantidad de datos a procesar. Esta nueva comparativa se puede observar en la Figura 8. El propósito de esta gráfica no es compararla con la Figura 7, principalmente porque hay semanas de diferencia entre la recogida de datos para una y otra, y puesto que el usuario gestor con el que se prueba la aplicación es una cuenta de prueba para el Workplace común para toda la empresa, en estas semanas de diferencia se han introducido más clientes y entradas de la agenda del gestor de prueba. El propósito de esta gráfica es ver que tras optimizar todo lo posible cada una de las formas de procesamiento de datos, la API de Android sigue siendo en todos los casos la más eficiente. Como se ha explicado, para un intervalo de dos meses, cuatro meses, ocho meses y catorce meses se realizan cinco mediciones con cada librería. En todos los casos la cota máxima de cada intervalo del API de Android es siempre inferior a la cota mínima de DOM4J para ese intervalo. Es decir, como conclusión no sólo sacamos que de media sea siempre más rápida la API de Android, sino que además, el caso peor de la API de Android para un mismo intervalo es siempre más rápido que el caso mejor de DOM4J. Figura 8: gráfica de tiempo procesamiento de un fichero XML con código optimizado La principal recomendación para usar DOM4J es que permite realizar un código mucho más legible y fácil de mantener, pero lógicamente a la vista de los resultados la decisión final es la utilización de las clases proporcionadas por la API de Android, con lo cual se ha intentado dejar el código lo más reducido y fácil de mantener que se ha podido. La implementación de cada uno de ellos se detalla más adelante. La conclusión final de estas pruebas realizadas es que, como ya se ha comentado, Android está orientado a hacer un uso lo más optimizado y eficiente de todos los recursos, con lo cual utilizar una librería externa a la API debería realizarse sólo en caso de que la tarea no se pueda realizar con las clases proporcionadas por ésta. 23 0 2 4 6 8 10 12 14 16 0 1000 2000 3000 4000 5000 6000 Tiempo de procesamiento de fichero XML Lector API de Android Lector DOM4J Meses de la agenda mostrados Tiempo(milisegundos) 24 5 Programación con el SDK de Android En este apartado se van a explicar las APIs y tecnologías utilizadas para la elaboración de este proyecto. Android es un sistema operativo para dispositivos móviles muy reciente, puesto que aún no se han cumplido dos años desde su primera aparición en el mercado; no obstante pese a su escaso tiempo de vida un programador con cierta experiencia se adapta enseguida a su programación. Dado que es un tema bastante reciente, y para poner en situación al lector y permitirle conocer las características de este sistema operativo, a continuación se va a hacer una breve introducción sobre que es Android antes de explicar detalles de implementación. 5.1 Introducción Los inicios de este sistema provienen del año 2005 cuando Google compra una pequeña compañía de nombre Android Inc, cuya finalidad es el desarrollo de aplicaciones para dispositivos móviles, centradas principalmente en plataformas Web. La existencia del nuevo sistema operativo no se hace pública hasta el año 2007, momento en el que se anuncia la creación de la Open Handset Aliance. Esta organización es un consorcio de compañías relacionadas con las telecomunicaciones y la informática, cuyo principal objetivo es la promoción del sistema operativo Android y su política las licencias de código abierto. La compañía HTC lanza a finales de septiembre de 2008 el primer teléfono móvil con este sistema operativo. Desde entonces, son ya varias las compañías que están apostando por Android. A modo de resumen estos son los tres nombres más importantes que se pueden relacionar con esta plataforma. Google: esta compañía es en la actualidad una de las más poderosas del mundo, su rápido crecimiento en tan sólo unos pocos años de vida hizo que en 2007 se convirtiera en la marca más valorada del mundo por delante de Microsoft o Coca-Cola, empresas que acostumbraban a dominar esta posición. Google lidera la mencionada Open Handset Aliance. El hecho de que esta compañía de tanta importancia sea la principal promotora de Android aporta dos grandes ventajas tanto a los usuarios de sus teléfonos móviles como a los desarrolladores de aplicaciones para esta plataforma. La primera ventaja es que esta empresa apoya actualmente diversos proyectos de software libre y licencias de código abierto. Ocurre lo mismo con el caso de Android, lo que provoca que cualquier programador comience a trabajar cuando desee sin tener que pagar ninguna licencia para desarrollar aplicaciones o darlas a conocer en el Android Market. Este último es un repositorio de aplicaciones al que se puede acceder desde cualquier Android, quedando a elección del desarrollador que su aplicación sea gratuita o de pago. 25 5.3.2 API de Android En este apartado se comentan las clases que se han utilizado pertenecientes al API de Android. Se utilizan como si fueran cualquier otra clase de Java. 5.3.2.1 Activity Es la principal clase de Android, y cada pantalla que se muestra en la aplicación es una clase que hereda de Activity. Así siendo, podríamos decir que una actividad equivale a una pantalla. En la Figura 12 se muestra el ciclo de vida de una actividad. En el diagrama se observan los métodos que podemos sobrescribir si queremos realizar una acción en concreto, y cuando se ejecutan. No es necesario ni obligatorio implementar ninguno de ellos; el único que debemos implementar siempre (al menos si queremos que la actividad muestre algo) es onCreate() donde definimos todo lo queramos hacer antes de que la pantalla se muestre. Por ejemplo en el caso de que a una actividad se pueda regresar desde diversas actividades, y queremos hacer cosas distintas dependiendo de cuál vengamos, la forma idónea no sería con onResume() puesto que, si queremos, en el momento de llamar desde una actividad a otra podemos dejarla esperando el resultado de la ejecución con un método más eficiente, que será detallado cuando se explique la clase Intent. 32 Figura 12: Ciclo de vida de Activity Como curiosidad, y cosa muy importante a tener en cuenta en el caso de esta aplicación ya que casi todas sus actividades leen datos de Internet, hay que comentar que no hay método definido en el ciclo de vida para detectar cuando se cambia la orientación de la pantalla. Si vamos a leer datos de Internet, lo normal es hacerlo dentro del onCreate() puesto que sólo se ejecuta una vez y si pasamos a otra actividad al volver el onCreate() no se ejecutaría, con lo cual no se vuelven a leer los datos. Sin embargo, cuando se cambia la orientación, la actividad es destruida y se vuelve a ejecutar el onCreate(). Es decir, si fueran datos muy costosos de leer por Internet, y si por descuido o por voluntad propia el usuario mueve el dispositivo y la pantalla gira, deberían volverse a cargar todos los datos. 33 Afortunadamente para este caso, el SDK de Android permite almacenar un objeto cuando la pantalla gira y recuperarlo cuando deseemos. Esto se hace de la siguiente manera: //SE EJECUTA CUANDO SE CAMBIA LA ORIENTACIÓN DE LA PANTALLA public Object onRetainNonConfigurationInstance() { return listaClientes; } En este caso, cuando el usuario cambie la orientación de la pantalla, almacenará automáticamente un ArrayList que contiene todos los clientes del gestor. Este objeto se puede recuperar en cualquier momento con el método getLastNonConfigurationInstance(), el cual devolverá el Object que hubiéramos guardado, o null si ese método no se ejecutó. De esta manera, con el siguiente código en el onCreate(), evitamos que se lean de Internet todos los clientes cada vez que se gire el dispositivo. final Object datos = getLastNonConfigurationInstance(); //SI DATOS != NULL ES POR QUE SE CAMBIÓ ORIENTACIÓN Y YA TENEMOS LOS //DATOS LEIDOS if( datos == null ) { listaClientes = getClientes(); } else { listaClientes = (ArrayList<Cliente>) datos; } Como se ha dicho al principio de este apartado, una actividad es una pantalla, con lo cual podemos hacer que aparezcan elementos visuales en ella. Además, cada uno de ellos debe ser un objeto que herede de la clase View, tal y como se explicará más adelante. También se ha comentado que estos elementos visuales pueden ser definidos mediante código o a través de ficheros XML. Para realizarlo de la segunda forma se hace mediante esta línea de código: public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.listado_carteras_cliente); //… } En este caso, este es el comienzo del onCreate() en el que se mostrará la tabla con las carteras de inversión de un determinado cliente. Antes de hacer nada con ningún elemento visual, debe llamarse al método de la clase superior. Como en este caso queremos que la apariencia visual sea la que tenemos definida en un fichero XML, llamamos al método que toma un contenido visual y a través de clase R.java explicada anteriormente accedemos al XML que queremos mostrar. La clase que queramos mostrar también puede heredar de otra clase que herede de Activity, como por ejemplo TabActivity que construirá la pantalla con un panel con tantas pestañas como definamos, un ListActivity que es para mostrar elementos en forma de lista y sus correspondientes métodos para tratarla, o por ejemplo MapActivity proporcionada por un API de Google. También podemos reutilizar las que ya hemos creado nosotros. 5.3.2.2 Intent La mejor forma de definir la clase Intent es como un nexo de unión. Su uso más frecuente es para pasar de un Activity a otro, o para realizar una acción en una actividad. 34 Esta clase permite que el programador se despreocupe del flujo de datos de su aplicación, ya que la clase Intent se encarga de ello y puesto que todos los Android disponen de un botón “volver” no es necesario ningún control de flujo. Si por ejemplo tenemos una actividad a la que se puede llegar desde cuatro actividades distintas, la clase Intent se encarga de controlar a cual debe regresar cuándo se pulse el botón del dispositivo para volver. Obviamente si es necesario o se desea, a través de todos los métodos que definen el ciclo de vida se podría realizar un control de flujo de datos. En esta línea de código se muestra como pasar de la actividad que lista los clientes a la actividad que muestra el menú del cliente que se ha seleccionado. Simplemente debe construirse un objeto de clase Intent cuyos parámetros sean donde estamos y donde queremos ir: Intent intent = new Intent(ListaClientes.this, MenuCliente.class); startActivity(intent); Como se comentaba al explicar la clase Activity, en este ejemplo pudiera ser que al regresar de MenuCliente queramos hacer algo en ListaClientes y se podría realizar esta acción si implementamos onResume() ya que al volver de otra actividad es el método que se ejecuta. Puede darse el caso que desde una actividad podamos ir a muchas otras, pero que no deseemos que se realice la misma acción siempre que regresemos a ListaClientes. En este caso hay una alternativa a poner el código en onResume(), ya que existe otro método para lanzar el Intent que dejará la actividad que ejecuta el Intent en espera de el resultado de la actividad lanzada. Este código es un ejemplo de ello: Intent intentFecha = new Intent(ListaAgenda.this, IntervaloFechas.class); startActivityForResult(intentFecha, FIN_CAMBIO_FECHA); En este ejemplo, se abre la ventana para seleccionar el intervalo de fechas para el cual el usuario quiere que se muestre su agenda. De esta manera, al regresar de ListaAgenda puede que haya ocurrido una de estas tres cosas: el usuario ha cambiado el intervalo de fechas, no lo ha cambiado o ha cerrado la ventana pulsando el botón “volver” del dispositivo. Lógicamente, sólo queremos realizar un cambio en el primero de los tres casos. Para ello, con startActivityForResult() quedamos a la espera de que la nueva actividad finalice y le damos un identificador. En este caso será el valor que tenga el atributo FIN_CAMBIO_FECHA. En la clase IntervaloFechas podemos asociar un resultado de ejecución correcto con las siguientes líneas de código: setResult(RESULT_OK); finish(); Cuando queramos cerrar una clase Activity lo podemos hacer con la llamada al método finish(). Antes de hacerlo, si queremos, le ponemos el resultado de la acción de la actividad. En el caso que estamos tratando, si el usuario pulsa el botón para guardar el intervalo de fechas, pero no las ha cambiado no haremos el setResult(RESULT_OK); si las ha modificado sí lo haremos. RESULT_OK en este caso no es una constante creada por nosotros como FIN_CAMBIO_FECHA, sino que pertenece a la clase Activity. 35 Una vez que la actividad IntervaloFechas termine se ejecutará el siguiente método en la clase ListaAgenda: protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if( requestCode == FIN_CAMBIO_FECHA && resultCode == RESULT_OK ) { //... } } Este método nos devuelve de qué actividad volvemos y cual ha sido su resultado; si la actividad termina pulsando el botón “volver” el resultado sería RESULT_CANCELED. De esta forma se controla de manera más sencilla e intuitiva las acciones que queremos hacer al regresar a una pantalla que con la clase onResume(). Como se mencionaba al principio, Intent podría considerarse un nexo de unión o para realizar acciones, con lo cual no sirve exclusivamente para pasar de una actividad a otra, sino que, como se muestra en este ejemplo, también sirve para lanzar acciones que el dispositivo móvil lleva integradas, como por ejemplo realizar una llamada. En este caso, al crear el Intent debemos pasarle el número al que se desea llamar: Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + numeroTel)); startActivity(intent); 5.3.2.3 View Todo objeto que queremos que se muestre por pantalla debe heredar de la clase View. Podemos definir nuestras propias clases que hereden de View, o usar las que nos proporciona el API de Android. Los objetos View los podemos organizar y ordenar dentro de objetos de clase Layout. Con un Layout, por ejemplo, podríamos definir que los componentes se agregaran de manera horizontal o vertical en una línea. También definirlos en un formato de tabla controlando las posiciones en columnas y filas. Entre los layouts proporcionados por Android los siguientes son los más básicos: −LinearLayout: este Layout ordena a sus elementos en una línea en sentido horizontal o vertical, agregándolos uno por uno en el orden en que se van definiendo. −FrameLayout: es el tipo más simple de Layout que permite agregar un solo elemento en un espacio en blanco definido. −TableLayout: este Layout agrega sus elementos en columnas y filas. Las filas deben ser insertadas una por una con un RowLayout. −RelativeLayout: permite agregar elementos respecto a uno previo. Esto significa que el posicionamiento se administra según la posición del elemento anterior. Las interfaces se definen de forma jerárquica, con lo cual podemos usar tantos elementos de los descritos anteriormente como queramos, combinándolos o introduciendo unos dentro de otros. Otra forma de organizar los objetos de clase View es utilizar los ViewGroups, los cuales también pueden contener Layouts si se desea. Estos son los más comunes: 36 −Gallery: utilizado para desplegar listados de imágenes en un componente con Scroll. −GridView: despliega una tabla con Scroll de m columnas y n filas. −ListView: despliega una lista con Scroll de una columna. −ScrollView: una columna vertical de elementos con Scroll. Dentro de la jerarquía, el ScrollView sólo puede contener un elemento, si queremos que el scroll se realice sobre varios Views estos deberán estar dentro de un ViewGroup o Layout el cual será el que este dentro del ScrollView. Una vez sabemos organizar los objetos de clase View ya podemos añadir los que deseemos. La elaboración de la interfaz será explicada más adelante; ahora simplemente se hará una descripción de los objetos de clase View más utilizados: −Button: elemento que pinta un botón en la pantalla con el objetivo de que el usuario realice alguna interacción con él. Se le puede colocar una imagen de fondo, pero para construir un botón que sea una imagen existe también una clase similar llamada ImageButton. −CheckBox: caja de texto seleccionable que permite evaluar dos estados del elemento: seleccionado y no seleccionado. −EditText: elemento que permite editar texto dentro. −TextView: etiqueta de texto no editable por el usuario. −RadioButton: elemento seleccionable parecido al CheckBox, pero con la diferencia de que una vez que se ha seleccionado no regresa a su estado anterior si este está definido dentro de un RadioGroup. −Spinner: listado de elementos oculto que solo aparece cuando se pulsa sobre él. Cuando está oculto sólo se puede ver el elemento seleccionado de todo el listado. Con estas tres clases, y sus correspondientes clases descendientes, se podrían construir aplicaciones bastante complejas. Podemos resumirlas de la siguiente manera: una Activity es una pantalla a mostrar, todo lo queramos que aparezca en la pantalla tiene que ser descendiente de View o agrupaciones de estos objetos como Layouts y ViewGroups. Por último, los Intent nos permiten pasar de un Activity a otro, o realizar acciones definidas por el teléfono sobre él. También existe la clase Service, de funciones similares a un Activity pero ejecutándose en segundo plano. Es decir, es como una actividad en background que podemos estar ejecutando y que no mostrará nada por pantalla durante su ejecución. A continuación, en vez de explicar clases concretas se explicarán acciones que se han implementado para esta aplicación, describiendo en cada una de ellas las clases del API necesarias para llevarlo a cabo. 37 5.3.2.4 Leer información de Internet Como se comentó con anterioridad, la forma de conectar con el servidor es mediante un servicio web REST y autenticación Basic. A continuación se va a explicar únicamente como hacer una petición REST desde Android para la obtención de los datos. La conversión del usuario y contraseña a Base64 y el procesamiento de un fichero XML se han realizado con librerías que no pertenecen a la API, con lo cual se explicará en el siguiente apartado. Antes de detallar los aspectos de programación, se explica en que consiste la petición REST mediante autenticación Basic. Este proceso puede verse en la Figura 13, y es comentado a continuación. Figura 13: Autenticación Basic 1. Petición de un recurso protegido: el cliente solicita una URL que requiere autenticación y el cliente no ha proporcionado todavía ninguna información, únicamente ha dicho que quiere acceder a ese recurso. 2. Respuesta del servidor con petición de usuario y contraseña: el servidor responde con un error 401 y comienza el proceso de autenticación. El cliente recibe la cabecera de error 401 y muestra un diálogo al usuario pidiéndole su nombre de usuario y contraseña. 3. Envío de usuario y contraseña: una vez introducidos los datos de usuario y contraseña, el cliente envía la información al servidor. Para ello vuelve a repetir la petición inicial, pero enviando esta vez una cabecera extra con la información de autenticación. Esta información se generará codificando en Base64 una cadena que incluye el nombre del usuario, dos puntos y la contraseña. Por ejemplo la cadena user:password convertida quedará de esta manera: dXNlcjpwYXNzd29yZA== 4. Respuesta del recurso: el servidor recibe la nueva petición de página con la información de autenticación. Si la información suministrada es válida, se permite el acceso al recurso, y, en caso contrario, se vuelve a responder con un código de error 401, para que el usuario vuelva a introducir su información. En el caso de que la autenticación haya sido positiva, en las siguientes peticiones de página se enviará automáticamente la cabecera con la autenticación, para evitar que el diálogo que pide el nombre de usuario y la contraseña aparezca continuamente. En nuestro caso, puesto que la conexión no se realiza desde un navegador sino que se hace mediante código, el usuario y contraseña debe enviarse como una cabecera de la petición, con lo cual, una vez tenemos dos objetos de clase String que contienen la URL de conexión y la 38 autenticación respectivamente, el código para acceder a los datos sería el siguiente: try { HttpClient httpclient = new DefaultHttpClient(); HttpGet httpget = new HttpGet(url); String usuarioBase64 = getUsuario(); httpget.setHeader("Authorization", "Basic " + usuarioBase64); HttpResponse response; try { response = httpclient.execute(httpget); HttpEntity entity = response.getEntity(); if (entity != null) { InputStream instream = entity.getContent(); //... } } catch (ClientProtocolException e) { } catch (IOException e) { } } catch (Exception e) { } Como se ha comentado antes, en el apartado 5.5 Otras tecnologías utilizadas se explicará cómo obtener el usuarioBase64 y qué hacer con el instream. Para poder realizar accesos a Internet ha de añadirse el correspondiente permiso al archivo de manifiesto de la aplicación: <uses-permission android:name="android.permission.INTERNET"> </uses-permission> 5.3.2.5 Activar servicio de búsqueda en un Activity En el apartado Anexos puede consultarse los botones de los que dispone un dispositivo Android. En él se explica el funcionamiento del botón de búsqueda, el cual si queremos que funcione en nuestra aplicación debe ser activado. En este apartado se explica cómo hacerlo. Lo primero de todo es crear un archivo de configuración para permitir realizar la búsqueda, el cual tendrá que ser asociado posteriormente a todas las actividades que vayan a implementar una búsqueda. Esto hará que, cuando en una pantalla el usuario pulse el botón de búsqueda, la barra de búsqueda aparezca con el icono de la aplicación para que el usuario sepa que, en este caso, el texto a buscar se realizará sobre la pantalla que está viendo; en caso contrario se realizará la búsqueda por defecto que tenga asociado el dispositivo (contactos, Internet...). Un ejemplo de las diferencias entre una actividad con la búsqueda activada y otra desactivada lo observamos en las Figuras 14 y 15. Vemos que, como la ventana del listado de clientes sí tiene activada la búsqueda, nos deja en esa pantalla y muestra el icono, mientras que, en el segundo caso que es en la pantalla de la Agenda, al no estar activada simplemente nos lleva a la ventana de búsqueda del dispositivo. 39 Figura 14: Actividad con búsqueda activada Figura 15: Actividad con búsqueda desactivada El archivo de configuración de búsqueda debe ser un archivo XML que guardemos en alguno de los directorios de la carpeta Res. Android aconseja que se llame searchable.xml y se almacene en la carpeta xml. Su contenido debe ser el siguiente: <?xml version="1.0" encoding="utf-8"?> <searchable xmlns:android="http://schemas.android.com/apk/res/android" android:label="@string/app_label" > </searchable> El siguiente paso es declarar las clases que queramos como searchables y asociarles el archivo que acabamos de configurar. Esto se hace en el archivo AndroidManifest. Tal y como se ha explicado anteriormente, donde debemos asociar las siguientes líneas marcadas en rojo: <activity android:name=".ListaClientes" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.SEARCH" /> </intent-filter> <meta-data android:name="android.app.searchable" android:resource="@xml/searchable"/> </activity> En el caso del atributo android: resource=”@xml/searchable” debemos poner la ruta dentro de la carpeta Res donde hemos guardado el fichero mencionado anteriormente. En este caso se llama searchable.xml y está en la carpeta xml dentro del directorio Res. 40 El último paso es saber cuándo se ha activado la búsqueda en la actividad y tratarla. Al igual que cuando es cambiada la orientación de la pantalla, cuando se finaliza la búsqueda la actividad es destruida y se vuelve a ejecutar el onCreate(). Por esta razón tenemos que introducir el siguiente código en ese método para recuperar el texto introducido para la búsqueda: //Devuelve el Intent que lanzó la actividad Intent intent = getIntent(); //ENTRA AQUÍ CUANDO SE HA SOLICITADO UNA BÚSQUEDA if (Intent.ACTION_SEARCH.equals(intent.getAction())) { //Texto introducio por el usuario String busqueda = intent.getStringExtra(SearchManager.QUERY); //Tratamiento de los datos de búsqueda //... } 5.3.2.6 Realizar una llamada Este caso se ha explicado anteriormente y es muy sencillo, simplemente hay que construir un Intent para realizar esa acción y pasarle en una variable de tipo String el número al que se desea llamar. Esto se hace de la siguiente manera: Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + numeroTel)); startActivity(intent); En el archivo de manifiesto deberemos añadir el correspondiente permiso para realizar esta acción: <uses-permission android:name="android.permission.CALL_PHONE"></usespermission> 5.3.2.7 Enviar un SMS Para realizar esta acción es necesaria la clase SmsManager del API y añadir el siguiente permiso en el archivo de manifiesto: <uses-permission android:name="android.permission.SEND_SMS"></usespermission> Según la API y la mayoría de los libros y tutoriales consultados, una vez tenemos el número destinatario y el texto a enviar, es suficiente con estas dos líneas de código: SmsManager smsManager = SmsManager.getDefault(); smsManager.sendTextMessage(numeroDestinatario, null, texto, null, null); Donde los campos puestos a null son respectivamente los siguientes: centro de servicio de mensajería (el cual siempre he encontrado null en todos los ejemplos), Intent que se encargará de enviarlo y por último el Intent que se encargará de recibir respuesta. En caso de que estos campos estén a null se usan los valores por defecto. 41 public static boolean comprobarConexion(Context context){ ConnectivityManager connec = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo redWifi = connec.getNetworkInfo(ConnectivityManager.TYPE_WIFI); NetworkInfo redMobile = connec.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); if( redWifi.isAvailable() || redMobile.isAvailable() ) { return true; } return false; } En este caso se le pasa como parámetro un objeto de la clase Context porque el método no está definido en una clase Activity, con lo cual no puede ejecutar por si sola getSystemService(). Cada actividad que necesite comprobar la conexión llama a este método pasando como argumento NombreClase.this como se ha visto en otros casos. 5.3.2.12 Comprobar orientación de la pantalla Anteriormente se ha explicado qué hacer para guardar los datos cuando el usuario cambia la orientación de la pantalla. Con este método podemos saber cuándo se ha producido esta acción, pero no en qué posición (vertical u horizontal) nos encontramos. Conocer este hecho puede resultar muy útil para reutilizar el espacio en la posición horizontal. Por ejemplo, en esta aplicación, en las tablas que contienen muchos datos a mostrar y es importante su comparación, se muestra una columna más cuando la pantalla está en posición horizontal. Dado que cada vez que este gire se vuelve a ejecutar el método onCreate(), es suficiente con comprobar la orientación en este momento o guardarla en una variable si se quiere utilizar posteriormente en más métodos. Esto lo podemos hacer con el siguiente método: orientacion = getResources().getConfiguration().orientation; En este caso el valor devuelto lo almacenamos en una variable de tipo int, para después utilizarla en otros métodos y mostrar más información o menos, según sea el valor de esta variable. La comprobación puede hacerse comparando con cualquiera de las dos siguientes variables que hacen referencia a posición vertical y horizontal, respectivamente: //ESTA ES EL VALOR PARA POSICIÓN VERTICAL android.content.res.Configuration.ORIENTATION_PORTRAIT //ESTA ES EL VALOR PARA POSICIÓN HORIZONTAL android.content.res.Configuration.ORIENTATION_LANDSCAPE 48 5.3.3 Creación de interfaces Hay dos opciones para construir una interfaz en Android, definiéndola mediante código en la propia actividad o generándola en un fichero XML y accediendo a ella en el método onCreate(), como ya se ha explicado. También se puede realizar una combinación de las dos, creando ciertos elementos que serán fijos en el fichero XML y añadiendo otros mediante código cuando sea necesario. Como ejemplo tenemos la construcción de tablas: definimos la tabla y sus atributos en el XML, y se van añadiendo filas conforme se lean los datos. Se muestra un ejemplo de este caso para la ventana con la tabla de alertas. De esta forma se ven los dos casos: la creación de un elemento visual mediante XML y su acceso en el código, y también la creación de elementos visuales desde código y su forma de añadirlos para mostrarlos por pantalla. En el fichero alertas.xml se definen en su interior, entre otras cosas, dos TableLayout (una para carteras y otra para productos) con las siguientes características: <TableLayout android:layout_width="fill_parent" android:id="@+id/TableLayoutCarteras" android:stretchColumns="1" android:layout_height="wrap_content"> </TableLayout> Se muestra el código que define la tabla para mostrar las alertas de tipo carteras; respecto a la que contiene las de tipo productos su definición es igual salvo que con otro id y ubicada en un lugar distinto dentro de la jerarquía de posiciones de alertas.xml. Para modificarlas en el código lo que debe hacerse es acceder a ellas mediante su identificador de la siguiente manera en onCreate(): tablaCarteras = (TableLayout) findViewById(R.id.TableLayoutCarteras); tablaProductos = (TableLayout) findViewById(R.id.TableLayoutProductos); Una vez tenemos el respectivo objeto de tipo TableLayout instanciado, para añadirles filas basta con un bucle en el que en cada iteración se lea una alerta y añadamos una fila con su información al final de la iteración. Se muestra un resumen del código que añade filas a la tabla: TextView titulo; TextView valor; TableRow tr; Bitmap imagenAlerta = BitmapFactory.decodeResource(this.getResources(), R.drawable.alert_icon); ImageView iconoAlerta; //... for(int i = 0; i < alertas.size(); i++) { alerta = alertas.get(i); tr = new TableRow(this); tr.setId(i); titulo = new TextView(this); titulo.setPadding(3, 5, 3, 5); titulo.setText(alerta.toString()); titulo.setTextColor(Color.WHITE); titulo.setWidth(170); 49 //tratamiento similar para valor pero con sus correspondientes datos iconoAlerta = new ImageView(this); if( ( ! alerta.getFechaActivacion().startsWith(Fecha.FECHA_NULA)) && alerta.getFechaActivacion().compareTo(fecha.getFechaInicio()) <= 0 ) { iconoAlerta.setImageBitmap(imagenAlerta); iconoAlerta.setPadding(2, 10, 2, 0); } else { iconoAlerta.setImageBitmap(null); } tr.addView(iconoAlerta, new TableRow.LayoutParams(0)); tr.addView(titulo, new TableRow.LayoutParams(1)); tr.addView(valor, new TableRow.LayoutParams()); if( alerta.getClase().equals(TIPO_CARTERA) ) { tablaCarteras.addView(tr, new TableLayout.LayoutParams()); } else if( alerta.getClase().equals(TIPO_PRODUCTO) ) { tablaProductos.addView(tr, new TableLayout.LayoutParams()); } } Para una mayor claridad del código se han omitido otras sentencias que aparecen en el flujo de datos implementado, pero en esencia este es el modelo a seguir para interactuar entre datos estáticos y dinámicos de interfaz. En cada iteración se instancia de nuevo cada elemento que queramos añadir y se le da valor a los atributos que deseemos. En el caso de iconoAlerta es un objeto de tipo ImageView en el que en cada iteración se la instancia con la imagen guardada en la carpeta Res/drawable para avisar de que una alerta está activa o se le pone como imagen null para que no aparezca nada. El inconveniente tanto de crear interfaces por código como de hacerlo en el fichero XML es que no podemos ver su apariencia hasta que no ejecutamos la aplicación. Para subsanar este problema Eclipse cuenta con un editor visual de interfaces con el que, a través de una interfaz, podemos ir añadiendo elementos y darle valor a sus atributos. Esta interfaz, a parte de mostrarnos como se verá la ventana en tiempo de ejecución va generando el fichero XML. Esto se explica a continuación en el apartado 5.4 Android en Eclipse IDE. Otras de las opciones que tenemos es la creación de nuestras propias vistas. Esto es, definirnos una clase que herede de la clase View e implementarla a nuestro gusto, para posteriormente añadirla por código como si fuese un Button, TextView o cualquier otro elemento. Por ejemplo, en esta aplicación se ha creado una clase View para representar gráficamente los datos de la distribución de una cartera: private class GraficoQuesito extends View { //... public GraficoQuesito(Context context) { //... protected void onDraw(Canvas canvas) { //... } 50 Y en el onCreate() que deseemos basta con esta línea para representarlo: layoutGrafico = (LinearLayout) findViewById(R.id.LinearLayoutGrafico); layoutGrafico.addView(new GraficoQuesito(this)); A partir de la versión 1.6, la API incluye una forma de definir los métodos asociados a una vista desde el fichero XML. Esto aporta diversas ventajas como mayor claridad de código y no tener que declarar e instanciar algunas de las vistas en código si su único uso es responder a eventos. Por ejemplo, si un Button sólo lo vamos a utilizar para ejecutar cierto código cuando este sea pulsado, y no se desea cambiarle ningún aspecto de apariencia en tiempo de ejecución, podemos asociarle un método a ejecutar con la siguiente línea en el fichero XML: <Button android:onClick="nombreMetodo" ...> </Button> Ahora simplemente debe definirse en la clase Activity que se asocie con el archivo XML en el que aparece este Button un método con ese nombre, el cual debe tener la siguiente visibilidad y parámetros: public void nombreMetodo(View v) { } Por defecto esto solo funcionará si el elemento para el que definimos las propiedades es un Button. Si queremos que funcione con cualquier otro elemento visual debe ponerse con valor True la propiedad en la ventana de propiedades que se observa en la parte inferior de la Figura 19, o también puede hacerse añadiendo la siguiente línea en la vista de texto. Por ejemplo, aquí se muestra el código necesario para que un TextView responda a esta propiedad: <TextView android:onClick="onClickTextViewColumnaTabla" android:clickable="true"> </TextView> 51 5.4 Android en Eclipse IDE Las ventajas que ofrece programar en Eclipse son varias, y se van a ir explicando a lo largo de este apartado. Este entorno de desarrollo nos permite la creación, edición y ejecución de proyectos Android de una manera bastante sencilla. Además el plugin de Android para Eclipse permite otras opciones ya explicadas como el acceso al AVD Manager que, entre otras cosas, sirve para crear dispositivos virtuales como se mencionó anteriormente, así como otras opciones que se explican al final de este apartado. 5.4.1 Creación de un proyecto Android La creación de este tipo de proyecto es muy similar a lo de un proyecto Java habitual. La única diferencia son algunos de los valores que deben introducirse en el último paso de la creación, y que son los que se explican. Para crearlo, una vez está abierto Eclipse debe pulsarse File → New → Project. Si ya está instalado todo correctamente deberá aparecer un directorio llamado Android dentro de la jerarquía de opciones. Desplegamos esta carpeta y seleccionamos Android Project. Esto nos llevará a la siguiente pantalla, que se muestra en la Figura 17, con los datos necesarios ya completados. Los datos que se deben introducir son los que en la imagen aparecen señalados con un ovalo rojo a su alrededor, y estas con las características de cada uno de ellos: −Project name: aquí debemos introducir el nombre que le queramos dar a la carpeta que creará Eclipse en el workspace para identificar el proyecto. Este nombre puede contener espacios si se desea. −Build Target: en este recuadro aparece un listado con todas las versiones del SDK que tenemos instaladas. Debemos seleccionar aquella para la que deseamos implementar la aplicación teniendo en cuenta que, a mayor número de versión, dispondremos de más posibilidades e incluso nuevas clases a nuestra disposición, pero en todas las versiones anteriores a la seleccionada no se podrá ejecutar. Si este listado apareciese vacío, es porque alguno de los pasos explicados en el apartado 5.2 Especificaciones técnicas no se ha ejecutado correctamente, con lo cual debe revisarse en profundidad todo este apartado para solucionarlo. −Properties: aquí deben introducirse datos relacionados con la aplicación y su identificación posterior dentro del dispositivo. 1. Application name es el nombre que le aparecerá al usuario en su menú de aplicaciones una vez esta haya sido instalada; puede contener espacios en blanco y otros caracteres. 2. Package name es la jerarquía de directorios que se explicó anteriormente. Debe estar formado por al menos dos directorios, y ninguno de ellos puede contener espacios en blanco. En este ejemplo se tendrán tres carpetas. 52 3. Create Activity: si seleccionamos esta opción deberemos establecer qué nombre queremos para la actividad. Dentro del Package name establecido creará una clase Java que hereda de Activity, asociada a main.xml (la cual contiene un “Hello World”) de la carpeta Res/layout, que también genera automáticamente si activamos esta opción. También declarará esta clase en el archivo de manifiesto y le pondrá los atributos necesarios para que sea la que se muestra al iniciar la aplicación. Figura 17: creación de un proyecto Android 53 5.4.2 Ejecución de un proyecto La forma de ejecutar un proyecto Android es similar a la de cualquier proyecto Java en Eclipse. Para ello, sobre el nombre del proyecto se hace clic derecho con el ratón y dentro de las opciones seleccionamos Run as → Android Application. Si hemos creado varios dispositivos virtuales y ninguno de ellos está abierto, seleccionará el primero de ellos que sea compatible para poder ejecutarse. Si tenemos ya abierto uno que sea compatible se ejecutará en éste; en caso contrario se abrirá uno en el que se pueda ejecutar. En caso de tener varios abiertos y que más de uno sea compatible con los requerimientos de esta aplicación, mostrará una ventana para que seleccionemos en cual ejecutar. Si, por el contrario, no existe ninguno en la aplicación que se pueda ejecutar, nos preguntará si deseamos crear uno. 5.4.3 Modificación de las características del proyecto Es posible que consultando algún manual encontremos determinado método o clase del SDK de Android que nos convenga utilizar y, al usarlo en nuestro proyecto, no se permita. Tras comprobar que hemos escrito el código correctamente y hecho todo lo que diga el manual, si el error persiste es probable que se deba a que dicha clase o método pertenezca a una versión superior a la cual estamos trabajando. Así siendo, si por este motivo o cualquier otro deseamos cambiar la versión de SDK que seleccionamos durante la creación del proyecto, esta puede ser cambiada en cualquier momento. Para ello se hace clic derecho sobre el proyecto y seleccionamos Properties. Esta acción nos mostrará la ventana que vemos en la Figura 18. Figura 18: propiedades del proyecto 54 Si lo que se desea es cambiar el nombre de la aplicación, la versión mínima del SDK donde podrá ejecutarse, o el nombre del sistema de directorios, cualquiera de estas características se modifican directamente en el archivo AndroidManifest.xml 5.4.4 Creación de interfaces gráficas Cada vez que abrimos un fichero de la carpeta Res/layout nos aparece una ventana como la de la Figura 19. En ella se puede alternar entre dos vistas como muestran las pestañas que observamos en el interior del óvalo rojo de menor tamaño, a la izquierda de la imagen. Si se pulsa en alertas.xml aparece la interfaz en formato texto, y si pulsamos en Layout aparece la ventana que se ve en la imagen. La explicación se realiza sobre esta, puesto que ya se ha hablado sobre la edición del XML. Figura 19: vista de edición de interfaz 55 En la imagen se han marcado los elementos más importantes de la vista Layout. En la parte izquierda aparecen todos los componentes que podemos añadir a la interfaz, divididos en Layouts y Views. Para añadir cualquiera de ellos debe arrastrarse en la imagen sobre el Layout al que queramos asignarlo. En la parte derecha aparece nuestra jerarquía actual de componentes visuales para este archivo, la cual puede ocultar y desplegar el contenido de cada Layout. Si tenemos varios, en vez de arrastrar el objeto sobre el cual queremos añadirlo, es mucho más cómodo seleccionar en esta jerarquía aquel contenedor en el cual queremos añadirlo y, haciendo clic derecho sobre él, seleccionar Add. Esto nos mostrará un listado de todo lo que podamos añadir a ese contenedor, para que seleccionemos el componente deseado. En ambos casos el nuevo componente se posicionará en base a las características definidas del Layout en el que se introduce. Cada vez que seleccionamos un componente del listado de la ventana derecha, en la parte inferior de la pantalla aparece su ventana de propiedades. En esta ventana podemos modificar sus atributos, lo cuales hacen referencia a opciones de visualización del propio elemento y a opciones de visualización de lo que contiene. En caso de que cometamos algún error con este editor visual y queramos deshacerlo, sólo se puede hacer si pasamos a la vista de texto sin cerrar la ventana y así, se puede deshacer y rehacer en esta vista desde como estaba el fichero cuando se abrió. Si marcase un error y en la vista de Layout no se viese nada, accediendo a la vista de texto marcará el error con una breve descripción en la línea que lo produce. Una vez no haya ningún error, todo volverá a mostrarse correctamente al acceder a la vista Layout. Otra limitación de la vista de Layout es la reorganización de componentes. Aunque nos muestre un listado de la jerarquía actual, ésta no puede ser reordenada desde aquí. Las únicas modificaciones posibles son de las propiedades de cada elemento por separado. Puesto que el orden de aparición en pantalla es conforme a su aparición en esta jerarquía, si deseamos modificar el orden de visualización debe hacerse copiando y pegando en la vista de texto hasta que quede organizado como se desea. 5.4.5 Generar instalador Este paso es muy similar a generar un archivo .jar con Eclipse cuando éste es un proyecto de Java. Pero, como se comentó anteriormente, Android usa Java pero no es una aplicación Java. En este caso el instalador es un archivo con extensión .apk (Android package), el cual debe estar firmado digitalmente para poder ser instalado en un dispositivo. El certificado de firmas puede ser self-signed; esto quiere decir que no es necesario obtener un certificado digital de una entidad certificadora como pudiera ser por ejemplo VeriSing, sino que podemos hacerlo nosotros mismos mediante el siguiente comando de Java: keytool –genkey -v -keystore “C:\android\certificado\keystore” -alias androidfirma -storepass password -keypass password -keyalg RSA -validity 14000 56 Donde éstos son los siguientes campos que el desarrollador debe modificar para poner sus propios datos puesto que éstos son de ejemplo: −keystore: ruta donde se desea que se almacene el keystore. −alias: nombre identificador con el cual luego nos referiremos a las claves que estamos creando. −storepass: la clave para acceder al contenido del keystore. −keypass: la clave para acceder posteriormente al alias que estamos creando. −keyalg: tipo de algoritmo empleado, en este caso RSA. −validity: periodo de tiempo de validez en días, se aconseja que sea de al menos 25 años. Para publicar la aplicación en el Android Market el certificado debe ser válido al menos hasta el 22 de octubre de 2033. Este acción nos solicitará una serie de datos personales que asociará al alias que acaba de crear el keystore. Esto sirve para que, una vez firmemos el instalador, posteriormente pueda asociarse de forma univoca a la información dada aquí y no se pueda suplantar nuestra identidad. Para un keystore se pueden añadir tantos alias como se deseen volviendo a realizar este comando. Una vez tenemos el fichero de firmas, el instalador puede ser firmado. Entre las diversas opciones está generar el .apk con Eclipse y firmarlo posteriormente usando, por ejemplo, jarsigner o generar un .apk firmado desde Eclipse. Ésta opción es la que se explica a continuación. Figura 20: Generación de instalador firmado 57 //1: Zoom Más lejano, 21: Más cercano mapController.setZoom(16); overlayitem = new OverlayItem(point, "", ""); itemizedOverlay.addOverlay(overlayitem); } 5.5.4 Dibujar gráficas de evolución Anteriormente se comentó que el desarrollador puede crear sus propias vistas. Como ejemplo de esto, se ha explicado que se ha creado la clase GraficoQuesito, que hereda de View y permite dibujar un gráfico de sectores. En este caso, para representar los datos de la evolución de una cartera, se ha optado por utilizar una clase desarrollada por terceros. Ésta clase se llama GraphView, pertenece a un proyecto de código abierto que puede encontrarse en la siguiente URL, la cual ofrece una serie de tutoriales y proyectos de código abierto sobre Android: http://android.arnodenhond.com/ Ésta vista nos permitirá representar gráficamente un vector de números, tanto de manera lineal como en forma de diagrama de barras. Para ello, al igual que en el ejemplo mostrado con la vista GraficoQuesito, llamamos al constructor de la clase y lo añadimos a la vista del Layout o actividad en la que se desea mostrar. Al cual hay que pasar los siguientes argumentos: GraphView(Context context, float[] values, String title, String[] horlabels, String[] verlabels, boolean type) Los cuales son: la actividad en la que se mostrará la vista, los valores a representar, el título de la gráfica, las etiquetas del eje X, las etiquetas del eje Y y el tipo de representación (GraphView.LINE o GraphView.BAR). En este caso, se ha realizado alguna modificación sobre el código de esta clase. Por ejemplo, para adaptarse a los requerimientos de la gráfica, cuando el valor a representar es mayor o igual a cien, la linea se pintará de color verde y de color rojo en caso contrario, así como una línea horizontal amarilla que marca el valor cien. Los resultados de ésta acción se podrán ver más adelante en el siguiente capítulo, concretamente en la Figura 50. 5.5.5 Generar un webservice Los datos para representar la gráfica que se acaba de explicar son proporcionados por un servicio web REST que he desarrollado como ampliación de la aplicación, una vez esta estaba finalizada y validada. El proceso y tecnologías empleadas para su elaboración ha sido el mismo que la empresa había utilizado para la implementación del resto de servicios web con los que conecta la aplicación. El lenguaje de programación que se ha utilizado es C# y la herramienta de desarrollo utilizada ha sido el Visual Studio 2008. 64 La idea de REST (Representational State Transfer) es aprovechar las capacidades del protocolo HTTP para utilizarlo como arquitectura de servicios. REST describe una interfaz web simple utilizando peticiones HTTP y datos XML pero sin capas adicionales como SOAP. Actualmente es la alternativa más simple a SOAP y a los servicios web basados en WSDL (Web Services Descripcion Language). Al nuevo servicio web hay que asociarle una nueva URI para acceder a los recursos. Desde el punto de vista del cliente de la aplicación que accede a un recurso, la URI determina lo intuitivo que va a ser el servicio web REST, y si el servicio va a ser utilizado tal y como fue pensado en el momento que se diseñó. Las URI’s de los servicios web REST deben ser intuitivas, hasta el punto que sea fácil saber el recurso que nos van a proporcionar. Se piensa en las URI como una interfaz autodocumentada que necesita de muy poca o ninguna explicación o referencia para que un desarrollador pueda comprender a lo que hace referencia. En este caso, como la información a obtener es sobre una cartera, la URI se ha implantado dentro de la jerarquía de los servicios web de las carteras y la URI resultante queda de esta manera: http://OpenfinanceUrlBase/Carteras.svc/{idCliente}/carteras/ {idsCarteras}/evolucion?fechaIni={fechaIni}&fechaFin={fechaFin} En este caso, idsCarteras puede ser el identificador de una cartera o el de varias carteras separadas por comas. En caso de varios identificadores, el servicio web crea una cartera virtual (llamada cartera agregada) formada por todas las carteras cuyo identificador se ha pasado como parámetro. Otra acción a realizar es comprobar que el identificador del cliente es válido y que tiene permiso para acceder a cada uno de los identificadores de carteras. Finalmente, se devuelve la información con los datos de evolución de la cartera para el intervalo dado por fechaIni y fechaFin. Si todos los datos son correctos el servicio web devolverá un XML con un valor para cada día, el primer valor siempre será cien, y los sucesivos valores siempre se calcularán a partir del valor del primer día. El fichero sigue la siguiente estructura: <ListaEvolucion> <DatosEvolucion> <EvolucionData> <Dia>27/09/2009</Dia> <Valor>100</Valor> </EvolucionData> <EvolucionData> <Dia>28/09/2009</Dia> <Valor>100</Valor> </EvolucionData> <EvolucionData> <Dia>29/09/2009</Dia> <Valor>100.07798765033647</Valor> </EvolucionData> … </DatosEvolucion> </ListaEvolucion> 65 66 6 Aplicación 6.1 Inicio de la aplicación Una vez la aplicación ha sido instalada el usuario podrá acceder a ella desde el menú de aplicaciones de su dispositivo. La primera ventana que verá siempre es la ventana de inicio de la aplicación, la cual muestra el nombre y página web de la empresa. Esta ventana, además de ser informativa, sirve como compaso de espera puesto que, durante su visualización, se leen los datos de configuración y se comprueba la disponibilidad de conexión a Internet. Dicha pantalla se muestra en la Figura 21. Figura 21: Pantalla de inicio La siguiente ventana a mostrar puede ser una de las cuatro siguientes opciones, dependiendo de los datos leídos durante el periodo de carga: −No se dispone de conexión a Internet: en ese caso se mostrará un mensaje informativo y se cerrará la aplicación, puesto que todas las pantallas necesitan acceso a Internet. La aplicación no se podrá iniciar hasta que la conexión esté activada. Esta ventana se mostrará más adelante en el apartado de mensajes de aviso. 67 −Es necesario PIN para entrar a la aplicación: si al leer los datos de configuración, la solicitud de PIN está activada se mostrará una ventana para que el usuario pueda introducirlo. En caso de que se solicite pero no haya ninguno almacenado, la ventana a mostrar será la de establecimiento de PIN como muestra la Figura 22. En caso contrario, se mostrará la ventana de la Figura 23, en la que debe introducirse el PIN existente; el usuario dispone de tres intentos, tras los cuales todos los datos de configuración serán borrados, y la próxima vez que inicie la aplicación el usuario deberá establecer un nuevo PIN, así como su nombre de usuario y contraseña en el Workplace. −En esta pantalla los únicos datos que se pueden introducir son de tipo numérico. Teniendo en cuenta que se puede introducir un PIN incorrecto, y que se dispone de un máximo de tres intentos para hacerlo correctamente, se muestra un aviso en letras rojas, además de realizar una animación que “agita” la pantalla para que el usuario se dé cuenta inmediatamente de que los datos son erróneos. Figura 22: Establecimiento de nuevo PIN Figura 23: Ventana de introducción de PIN −No hay nombre de usuario y contraseña almacenados: esto ocurrirá si es la primera vez que se ejecuta la aplicación, se introdujo el PIN incorrectamente tres veces, o se finalizó al hacer logout. Esta ventana muestra un formulario para introducir nombre y contraseña, y se accede a ella tras la ventana de presentación (o tras la de introducción de PIN si este estuviera activo) o cuando se hace logout en la aplicación. Al igual que en el caso descrito anteriormente, se produce una animación cuando la información introducida es errónea. Esta pantalla puede observarse en la Figura 24. 68 Figura 24: Ventana de autenticación −No es necesario PIN de inicio, y hay nombre y contraseña almacenados. Este estado sólo puede ocurrir si en configuración se ha deshabilitado la solicitud de PIN para iniciar la aplicación y la última vez se cerró sin hacer logout. En este caso, tras la ventana de inicio, pasará directamente al menú de usuario, el cual se explica a continuación con más detalle. 6.2 Menú de usuario Este menú está dividido en cuatro pantallas que muestran información referente al gestor, y a las cuales se puede acceder con las pestañas que aparecen en la parte superior de la ventana. A este nivel de navegación existen dos entradas de menú comunes a las cuatro pantallas – logout y configuración – y al resto de menús de la aplicación, los cuales serán detallados más adelante, pasando a continuación a explicar cada una de las ventanas con información del usuario. La primera pantalla de este menú es el listado de clientes del gestor. En dicho listado se muestra por orden alfabético el nombre y apellidos de cada cliente, así como un icono con un teléfono en caso de que se tenga almacenado uno o más números de contacto del cliente. Todo esto se puede observar en la Figura 25. 69 Figura 25: Ventana del listado de clientes Esta ventana permite realizar llamadas telefónicas a cada cliente. Para ello el usuario debe pulsar el icono del teléfono, el cual indica que existe algún teléfono de contacto almacenado en el Workplace para ese cliente. En caso de que sólo se disponga de un único número de contacto, se realizará automáticamente una llamada a dicho número; si, por el contrario, para ese contacto hay almacenado más de un número, al pulsar sobre el icono aparecerá un listado con todos los teléfonos disponibles para que el usuario seleccione a cual desea realizar la llamada, como muestra la Figura 26. Figura 26: Ventana de números del cliente 70 Además, para facilitar la búsqueda de clientes, se ha implementado para esta ventana dos posibilidades. La primera consiste en una etiqueta informativa de cuál es la primera letra del elemento del listado que se acaba de situar en la parte superior de la pantalla, como se observa en la Figura 27. Esta implementación se debe a que todos los dispositivos móviles Android tienen pantalla táctil y se puede realizar un scroll muy rápido en los listados; de esta manera, mientras hace scroll, podrá observar en qué parte del listado se encuentra, y no tendrá más que pulsar la pantalla para detenerse en la letra que desee. Figura 27: Scroll sobre la ventana de listado de clientes La otra opción, es pulsar en el botón de búsqueda común a todos los dispositivos Android (ver Anexo para más información). En la ventana de búsqueda el usuario debe introducir el patrón que desea buscar y automáticamente le aparecerá un nuevo listado con todos los nombres que contienen dicho patrón de búsqueda. Desde esta nueva ventana se pueden realizar todas las opciones explicadas para esta pantalla, así como pulsar sobre un cliente para acceder al menú con información del cliente. Para volver al listado original simplemente debe pulsarse en el botón volver del dispositivo. En la Figura 28 se muestra el resultado de la búsqueda de clientes que contentan la secuencia “an”. 71 Figura 28: Resultado de la búsqueda Dentro del menú de usuario, otra de las ventanas que se puede ver es la agenda. Esta pantalla muestra una tabla con las tareas y citas del usuario ordenadas por fecha. En la parte superior se encuentra la cabecera indicando qué información es la que se muestra en cada columna; esta cabecera es fija y, al hacer scroll, solo se deslizarán las filas de la tabla. Esta ventana se observa en la Figura 29. Figura 29: Pantalla de agenda del usuario 72 Si un elemento contiene algún icono, quiere decir que ocurre alguna acción al pulsar sobre él. Por ejemplo, en la Figura 29 se observa que al final de cada fila hay un icono. En este caso, si el usuario quiere ver más información sobre una cita o tarea no tiene más que pulsar sobre ella. Aparecerá una nueva ventana con toda la información disponible, la cual ha sido implementada siguiendo el estilo de ventana de información extra que sigue Android, como podrá observarse si, por ejemplo, en una foto de la galería de imágenes de su dispositivo se pulsa en solicitar información extra. Esta ventana se puede observar en la Figura 30. Debe comentarse que tanto el tamaño como la información a mostrar es adaptativo, ya que la información almacenada en citas y tareas es distinta. Además, la cantidad de información a mostrar depende del propio elemento en si, puesto que sólo aparecerá los atributos de los cuales tenemos valor almacenado. Figura 30: Pantalla información extra de agenda Como se comentaba anteriormente, todas las ventanas del menú de usuario disponen de un menú contextual desde el cual se puede acceder a la ventana de configuración y hacer logout. En esta pantalla, a dicho menú se añade la opción de seleccionar sobre qué rango de fechas se desea mostrar la información de la agenda. Por defecto el contenido de esta tabla es las citas y tareas del día actual hasta dos meses en adelante. No obstante, como muestra la Figura 31, este rango puede ser modificado por el usuario mostrando, cada vez que se abre la ventana, las fechas en las que actualmente se está obteniendo la información. 73 Figura 40: Ventana información del cliente Figura 41: Formulario para enviar SMS Figura 42: Formulario para enviar email Figura 43: Ventana GoogleMaps 80 6.4 Menú de carteras del cliente Como se comentaba anteriormente, en la pantalla de carteras de inversión del cliente el usuario puede seleccionar una o varias carteras para obtener más información. Tras pulsar en la zona de resumen en la pantalla de las carteras del cliente, llega al menú que se explica a continuación. En este caso se divide en tres pantallas, a las que se accede con sus correspondientes pestañas. Estas son: posiciones, distribución y evolución. El título de la ventana varía en función de si se ha seleccionado previamente una sola cartera o varias. En el primer caso el título será el nombre del cliente y el nombre de la cartera; en caso contrario aparecerá el nombre del cliente y “cartera agregada”. La primera pantalla de este menú muestra una tabla con las posiciones de las carteras. Esta tabla se divide en acciones y fondos. Como observamos en la Figura 45, es muy similar a la pantalla de carteras del cliente puesto que cuenta con tres columnas, de las cuales en dos puede elegirse el campo a mostrar y una zona de resumen en la parte inferior. De nuevo puede establecerse el criterio de ordenación (por defecto se ordenan alfabéticamente) al pulsar sobre el botón menú, y aparecerá una columna más cuando el dispositivo se encuentra en posición horizontal, como muestra la Figura 46. Figura 45: Pantalla de posiciones de la cartera 81 Figura 46: Pantalla de posiciones de la cartera en horizontal En la Figura 47 se observa la pantalla de distribución de las carteras. En ella aparece un gráfico que representa la distribución en porciones por activos. En la parte inferior aparece una leyenda que muestra ordenados por porcentaje los nombres de los activos junto al tanto por ciento que representan. Si el usuario prefiere ver la distribución de la cartera en forma de tabla lo puede hacer pulsando el botón “Tabla”. El resultado de esta acción es la ventana que muestra la Figura 48, en la cual se encuentra una tabla con el nombre del activo, su importe y valor. En este caso también puede seleccionar si desea ordenar la tabla por nombre o por valor pulsando el botón de menú. Figura 47: Ventana distribuciones: modo gráfico Figura 48: Ventana distribuciones: modo tabla 82 La tercera y última pantalla de este menú es la gráfica que muestra la evolución de la cartera. Como se observa en la Figura 50, los datos a representar por defecto son para el intervalo de un año. No obstante, si el usuario desea ver más detalladamente una zona en concreto, no tiene más que pulsar el botón “cambiar fechas” de la entrada de menú. Esta acción mostrará la misma ventana de selección de fechas que se explicó anteriormente, y que se muestra en la Figura 31. Antes de explicar los detalles y funcionalidades de esta ventana, en la Figura 49 podemos ver la gráfica de evolución de una cartera que ofrece el Workplace, sobre la que se explica en que consiste ésta. Los datos que muestra son los movimientos de la cartera para cada día del intervalo temporal que representa el eje horizontal, con lo cual el primer valor siempre valdrá 100%, y los sucesivos tomarán su valor en función del valor de sus movimientos respecto a este primer valor. Figura 49: Gráfica de evolución ofrecida por el Workplace Figura 50: Gráfica de evolución de la aplicación Android 83 En la Figura 49 se observa la gráfica de evolución obtenida por la aplicación Android a partir de los datos devueltos por el servicio web. En este caso la representación es sobre los mismos valores empleados parar dibujar la Figura 50, aunque se ven ligeras diferencias debido a la clase utilizada en este proyecto para representar los datos. La primera diferencia, la cual en este caso es una ventaja para el usuario, es que en la gráfica de Android el eje vertical va desde el valor máximo al valor mínimo de los datos en todos los casos. Esto permite, a primera vista, que el usuario sepa cuál ha sido el valor mínimo y máximo (exactos) en ese intervalo. Otra diferencia significativa es la línea horizontal que marca la frontera de valores por encima de cien y por debajo, la cual en la aplicación Android aporta más información. En este caso los valores iguales o superiores a cien se pintan en color verde, y los inferiores en rojo; esto permite al usuario localizar rápidamente en qué meses se ha producido un descenso o ascenso, y su magnitud. En la imagen se observa que antes de cruzar la frontera del valor cien la línea ya está pintada de rojo; esto se debe a que la línea une valores. Es decir, en este caso de un valor ligeramente superior a cien se pasa a uno ligeramente inferior, lo cual en otras ocasiones permitirá ver al usuario si ha sido un cambio brusco o paulatino, como se ve más detalladamente en la Figura 51. En este caso, si la gráfica no estuviera a dos colores, podría pensarse que la caída a mediados de mayo y la caída a mediados de junio son similares. Pero, con este sistema, en un sólo vistazo se aprecia que una fue repentina y la otra se produjo paulatinamente. Lo mismo podría decirse de las subidas que se produjeron en el primer cuadrante vertical de la gráfica. La última diferencia es los valores de las etiquetas del eje horizontal. En el caso del dispositivo móvil el mes y año se identifican mediante sus valores numéricos debido al reducido tamaño de su pantalla respecta a la un ordenador personal. No obstante, cuando el intervalo mostrado es igual o menor a siete meses estos se identifican de la misma manera que en el Workplace, como se observa en la Figura 51. Figura 51: Gráfica de evolución para un intervalo de cinco meses 84 6.5 Menú de configuración Desde cualquiera pantalla de la aplicación puede accederse a la ventana de configuración, pulsando sobre el botón de menú del dispositivo y seleccionando la entrada configuración. El resultado de esta acción se muestra en la Figura 52. Figura 52: Pantalla de configuración de la aplicación Como se aprecia en la imagen, la apariencia de esta ventana es similar a cualquiera de las pantallas de configuración de un dispositivo Android. En este caso las opciones se encuentran divididas en configuración sobre el PIN de inicio de la aplicación y la URL de conexión al Workplace. En caso de pulsar en la opción de activar PIN y que no haya ninguno almacenado mostrará un mensaje preguntando si se desea establecer uno en ese momento. En cambio, si se pulsa modificar PIN y no hay ninguno almacenado, mostrará automáticamente la ventana para establecer uno como ya se explicó, y se pude ver en la Figura 22. Si ya hubiese PIN, la ventana a mostrar sería la que muestra la Figura 53. En esta pantalla, una vez se pulse el botón “Guardar” se comprobará que se haya introducido correctamente el PIN actual o no podrá realizarse el cambio; si este fuera correcto se comprueba que el nuevo PIN sea numérico, de cuatro dígitos, y que coincida con el escrito en el campo de confirmación del nuevo PIN. 85 Respecto a las opciones sobre la URL del servidor, cuando se pulsa sobre conexión segura se muestra un mensaje avisando que esta opción no está implementada actualmente, ya que su finalidad es conectar mediante el protocolo HTTPS, pero actualmente el servidor en el que se realiza la conexión no soporta este tipo de peticiones para el envío de datos cifrados, con lo cual esto es una actualización para el futuro. Al pulsar en “Servidor de conexión” se muestra una ventana de diálogo con la actual URL, de la que se obtienen los datos como muestra la Figura 54. Debido a que, si la nueva URL es incorrecta, no podrá accederse a ninguno de los datos, cuando el usuario pulsa en “OK” se muestra un mensaje de aviso y confirmación, el cual se detallará más adelante en el apartado de mensajes. Por si, a pesar de la advertencia, o si el servidor actual estuviera mal escrito o dejase de funcionar, la última opción de la ventana permite volver al servidor al que se conectaba cuando la aplicación fue instalada, mostrando antes de realizar la acción un mensaje de confirmación que se explicará en el siguiente apartado. Figura 53: Ventana para modificar PIN Figura 54: Ventana para modificar URL del servidor 86 6.6 Mensajes de la aplicación A continuación se muestran una serie de mensajes que pueden aparecer en cualquiera momento durante la ejecución de la aplicación. El primero y más importante es el mensaje de error de conexión, el cual se observa en la Figura 55. Este aparecerá siempre que se haya perdido la conexión a Internet y se intente realizar una acción que la necesite. Tras pulsar el botón “Aceptar” se cerrará la ventana a la que se intentaba acceder volviendo a la predecesora. En caso de que estemos en el menú de usuario o en la presentación la aplicación, se cerrara ya que no hay ventana con datos correctos a la que volver. Figura 55: Mensaje de error de conexión Otro mensaje que puede aparecer en cualquier momento es la pantalla de espera. Ésta aparecerá en las transiciones entre pantallas cuando sea necesario leer datos de Internet y la operación pueda tardar unos segundos (ver Figura 56). Aparecerá una ventana similar pero con mensaje de texto cuando, dentro de una ventana, se vaya a realizar una operación que pueda tardar un tiempo considerable, como por ejemplo cambiar el intervalo de fechas en la ventana de agendas, tal y como se observa en la Figura 57. Ambas bloquean cualquier otra acción que se pudiera realizar para no ralentizar más el proceso. 87 Figura 56: Ventana de espera entre pantallas Figura 57: Ventana de espera dentro de una pantalla A continuación se muestran el resto de ventanas de diálogo que pueden aparecer en la aplicación. Todas ellas muestran un mensaje de aviso en espera de una confirmación o una cancelación, antes las cuales se realizará la acción asociada o no se hará nada. En la ventana de configuración podemos observar dos mensajes de este tipo. El primero se muestra en la Figura 58 y aparece cuando se solicita modificar la URL del servidor. En este caso si se responde afirmativamente la URL de conexión sera remplazada por la escrita por el usuario, mientras que en caso de respuesta negativa no se hará el cambio. El segundo caso se plantea cuando se solicita restablecer el servidor como se puede ver en la Figura 59, se muestra un mensaje avisando de las consecuencias de realizar la acción. En caso de respuesta afirmativa esta se llevará a cabo y en caso contrario no se hará nada, respectivamente. Otra opción que se puede dar es que, en vez de respuesta afirmativa o negativa, se plantee realizar una acción u otra. Un ejemplo de este caso se muestra en la Figura 60. Esto ocurre cuando en la ventana de información de un cliente pulsamos sobre su teléfono móvil, y dependiendo de la respuesta del usuario, pasaremos a la pantalla que muestra la Figura 42 (mandar un SMS a un número) o a realizar una llamada telefónica. No obstante, si el usuario no quiere realizar ninguna de las dos acciones, puede cerrar el diálogo pulsando sobre el botón “Volver” de su dispositivo Android. 88 Figura 58: Mensaje confirmación cambio URL Figura 59: Mensaje advertencia restablecer servidor Figura 60: Mensaje para escoger acción 89 96 Índice de figuras Figura 1: esquema de la aplicación....................................................................................................12 Figura 2: comunicación REST...........................................................................................................13 Figura 3: Diagrama de casos de uso...................................................................................................15 Figura 4: Diagrama de actividades (parte 1)......................................................................................16 Figura 5: Diagrama de actividades (parte 2)......................................................................................17 Figura 6: Diagrama de clases.............................................................................................................18 Figura 7: gráfica de tiempo de procesamiento de un fichero XML....................................................22 Figura 8: gráfica de tiempo de procesamiento de un fichero XML con código optimizado..............23 Figura 9: Arquitectura Android..........................................................................................................26 Figura 10: Ventana settings del AVD Manager...................................................................................28 Figura 11: estructura de carpetas de un proyecto Android.................................................................31 Figura 12: Ciclo de vida de Activity...................................................................................................33 Figura 13: Autenticación Basic..........................................................................................................38 Figura 14: Actividad con búsqueda activada......................................................................................40 Figura 15: Actividad con búsqueda desactivada................................................................................40 Figura 16: elementos de la ventana de configuración........................................................................45 Figura 17: creación de un proyecto Android......................................................................................53 Figura 18: propiedades del proyecto..................................................................................................54 Figura 19: vista de edición de interfaz...............................................................................................55 Figura 20: Generación de instalador firmado.....................................................................................57 Figura 21: Pantalla de inicio...............................................................................................................67 Figura 22: Establecimiento de nuevo PIN..........................................................................................68 Figura 23: Ventana de introducción de PIN........................................................................................68 Figura 24: Ventana de auntenticación.................................................................................................69 Figura 25: Ventana del listado de clientes..........................................................................................70 Figura 26: Ventana de números del cliente.........................................................................................70 Figura 27: Scroll sobre la ventana de listado de clientes....................................................................71 Figura 28: Resultado de la búsqueda..................................................................................................72 Figura 29: Pantalla de agenda del usuario..........................................................................................72 Figura 30: Pantalla información extra de agenda...............................................................................73 Figura 31: Pantalla modificación intervalo de fecha..........................................................................74 Figura 32: Pantalla alertas del usuario................................................................................................75 Figura 33: Cambiar fecha para mostrar..............................................................................................75 Figura 34: Pantalla watchlist del usuario............................................................................................75 Figura 35: Pantalla del watchlist en posición horizontal....................................................................76 Figura 36: Listado de carteras del cliente en posición horizontal......................................................77 Figura 37: Pantalla con las carteras del cliente...................................................................................77 Figura 38: Carteras seleccionadas......................................................................................................78 Figura 39: Agenda del cliente.............................................................................................................79 Figura 40: Alertas del cliente..............................................................................................................79 Figura 41: Ventana de información del cliente...................................................................................80 Figura 42: Formulario para enviar SMS.............................................................................................80 Figura 43: Formulario para enviar email............................................................................................80 Figura 44: Ventana GoogleMaps........................................................................................................80 Figura 45: Pantalla de posiciones de la cartera...................................................................................81 Figura 46: Pantalla de posiciones de la cartera en horizontal.............................................................82 Figura 47: Ventana de distribuciones: modo gráfico..........................................................................82 97 Figura 48: Ventana de distribuciones: modo tabla..............................................................................82 Figura 49: Gráfica de evolución ofrecida por el Workplace...............................................................83 Figura 50: Gráfica de evolución de la aplicación Android.................................................................83 Figura 51: Gráfica de evolución para un intervalo de cinco meses....................................................84 Figura 52: Pantalla de configuración de la aplicación........................................................................85 Figura 53: Ventana para modificar PIN..............................................................................................88 Figura 54: Ventana para modificar URL del servidor........................................................................88 Figura 55: Mensaje de error de conexión...........................................................................................87 Figura 56: Ventana de espera entre pantallas......................................................................................88 Figura 57: Ventana de espera dentro de una pantalla.........................................................................88 Figura 58: Mensaje confirmación cambio URL.................................................................................89 Figura 59: Mensaje advertencia restablecer servidor.........................................................................89 Figura 60: Mensaje para escoger acción.............................................................................................89 98 Anexos Openfinance: es una empresa líder en soluciones tecnológicas de asesoramiento financiero y gestión de carteras. Workplace: en este documento se hace referencia al producto Workplace ofrecido por la empresa Openfinance. Este producto ofrece la posibilidad de clasificar y segmentar clientes de forma eficaz, realizar propuestas personalizadas, alimentar y mantener una agenda de contactos dinámica, así como llevar a cabo un control exhaustivo y actualizado de la comercialización de productos y servicios. Se ofrece como una aplicación web dónde cada cliente tiene una versión adaptada a sus necesidades específicas. EAFIS: es una asociación de gestores independientes. Esta asociación tiene una versión del Workplace adaptada a sus necesidades concretas. Watchlist: es una lista en la que el usuario puede añadir las acciones o valores que quiere seguir. De esta forma no tiene que ir buscándolos para ir siguiéndolos, y los puede localizar de una forma rápida. Botones Android: a lo largo del presente documento se han mencionado una serie de botones comunes a todos los dispositivos Android. En la imagen pueden verse y a continuación se explica, de izquierda a derecha, cada uno de ellos. El primer botón, podría denominarse volver o botón de retroceso. Sirve para regresar a la pantalla anterior, o para salir de la aplicación en el caso de que se encuentre en el menú principal. El siguiente, es el que durante este documento se nombraba como botón de menú ya que su única función es mostrar en la parte inferior de la pantalla el menú contextual asociado a la ventana que está visible en ese momento. El tercer botón sirve para volver a la pantalla principal del teléfono sin cerrar la aplicación, la siguiente vez que se entre a la aplicación regresará automáticamente a la pantalla en la que se estaba cuando se pulso este botón. El último botón es el de búsqueda. Una vez es pulsado aparece en la parte superior de la pantalla un cuadro para introducir el texto referente a lo que se desea buscar. Cuando la ventana en curso no tiene activada la opción de búsqueda ésta se realiza sobre Internet. En el caso de esta aplicación, la búsqueda sólo está activada para la pantalla del listado de clientes. 99