Memoria Proyecto Fin de Carrera SWADroid

Escuela Técnica Superior de Ingenierías Informática y de Telecomunicación Universidad de GranadaCliente Android para la plataforma de educación SWAD Juan Miguel Boyero Corral

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍAS INFORMÁTICA Y DE TELECOMUNICACIÓN UNIVERSIDAD DE GRANADA Proyecto Fin de Carrera de Ingeniería Informática: “SWADroid: Cliente Android para la plataforma de educación SWAD” Autor: Juan Miguel Boyero Corral Director de proyecto: Antonio Cañas Vargas Departamento de Arquitectura y Tecnología de Computadores 3

PROYECTO FIN DE CARRERA ESCUELA TÉCNICA SUPERIOR DE INGENIERÍAS INFORMÁTICA Y DE TELECOMUNICACIÓN SWADroid: Cliente Android para la plataforma de educación SWAD Juan Miguel Boyero Corral Resumen Desarrollar la base de un cliente para dispositivos basados en el sistema operativo Androidpara la plataforma de teleformación y gestión docente SWAD (http://swad.ugr.es/) de forma que seafácilmente ampliable con nuevas funciones de acceso a SWAD. El desarrollo de este cliente se ha realizado en Java. 4

D. Antonio Cañas Vargas, profesor de la titulación de Ingeniería Informática, pertenecienteal Departamento de Arquitectura y Tecnología de Computadores de la Universidad de Granada, encalidad de director del proyecto fin de carrera de D. Juan Miguel Boyero Corral INFORMA que el proyecto SWADroid: Cliente Android para la plataforma de educación SWAD. Ha sido realizado y redactado por dicho alumno, y corresponde a la investigación realizadabajo su dirección, y con esta fecha autoriza su presentación. Granada, Junio de 2011 Director del proyecto Firmado: Antonio Cañas Vargas. D. Juan Miguel Boyero Corral con DNI 75135292-L, autorizo a que una copia de esteProyecto Fin de Carrera, titulado “SWADroid: Cliente Android para la plataforma de educaciónSWAD”, se deposite en la biblioteca de la facultad de la Escuela Técnica Superior de IngenieríasInformática y de Telecomunicación para que pueda ser libremente consultada. Granada, Junio de 2011. Firmado: Juan Miguel Boyero Corral. 5

Resumen El presente proyecto ilustra el modo en que se ha realizado la implementación de laaplicación móvil SWADroid. La aplicación móvil constituye la base de un cliente para dispositivos basados en el sistemaoperativo Android para la plataforma de teleformación y gestión docente SWAD(http://swad.ugr.es/) de forma que sea fácilmente ampliable con nuevas funciones de acceso aSWAD. Será utilizado por alumnos y profesores para acceder a los servicios de SWAD queimplemente el cliente. Consta de una parte cliente y otra que actúa como servidor. El servidor seejecuta en el ordenador donde está alojado SWAD e implementa los servicios web requeridos paraque el cliente pueda acceder a los servicios de SWAD. El cliente es un programa ejecutado por elprofesor o alumno sobre un dispositivo basado en Android e inicialmente implementará uno ovarios de los servicios de SWAD (según disponibilidad temporal) a modo de ejemplo. SWADroid está disponible para su instalación desde Android Market (tienda de aplicacionesde Android) de forma gratuita a través del enlace directo https://market.android.com/details?id=es.ugr.swad.swadroid y mediante el siguiente código QR: El código fuente de SWADroid está disponible en https://github.com/Amab/SWADroid conlicencia GPLv3. Este documento tiene licencia FDL.Palabras claveAndroid, aplicación móvil, SWAD, aprendizaje electrónico móvil, e-learning, m-learning, mobilelearning 6

Abstract This project illustrates how the implementation has made the mobile application SWADroid. The mobile application is the basis of a client for devices based on Android operating systemfor e-learning platform and educational administration SWAD (http://swad.ugr.es/) so as to be easilyexpandable with new access functions of SWAD. Will be used by students and teachers to access tothe SWAD services that implements the client. It consists of a client and a server. The server runs onthe computer that hosts SWAD and implements web services required for the customer to access tothe SWAD services. The client is a program executed by the teacher or student on an Android-baseddevice and initially deploy one or more of the SWAD services (depending on time availability) asan example. SWADroid is available for installation from the Android Market (Android app store) for freevia the direct link https://market.android.com/details?id=es.ugr.swad.swadroid and by the followingQR code: SWADroid source code is available in the forge https://github.com/amab/SWADroid underGPLv3 license.This document is licensed under FDL.KeywordsAndroid, aplicación móvil, SWAD, aprendizaje electrónico móvil, e-learning, m-learning, mobilelearning 7

Índice de contenido1. Introducción....................................................................................................................................102. Definición de objetivos y especificaciones.....................................................................................11 2.1. Estado del arte.........................................................................................................................11 2.2. Motivación..............................................................................................................................13 2.3. Objetivos.................................................................................................................................15 2.4. Software y documentación libre.............................................................................................163. Análisis y Diseño............................................................................................................................17 3.1. Diagrama de Casos de Uso.....................................................................................................17 3.2. Sistema operativo móvil.........................................................................................................18 3.3. Plataforma de desarrollo.........................................................................................................19 3.4. Diagrama de funcionamiento de los servicios web................................................................20 3.5. Diagrama de la Base de Datos................................................................................................21 3.6. Diagramas de clase.................................................................................................................224. Módulos..........................................................................................................................................23 4.1. Desarrollo de un módulo.........................................................................................................255. Internacionalización.......................................................................................................................296. Validación y pruebas.......................................................................................................................337. Programación con el SDK de Android...........................................................................................38 7.1. Introducción............................................................................................................................38 7.2. Especificaciones técnicas........................................................................................................41 7.3. Aplicación Android.................................................................................................................44 7.4. API de Android.......................................................................................................................47 7.4.1. Activity............................................................................................................................47 7.4.2. Intent...............................................................................................................................50 7.4.3. View................................................................................................................................51 7.5. Crear una pantalla de configuración.......................................................................................53 7.6. Almacenamiento persistente de datos.....................................................................................60 7.7. Comprobar estado de la conexión...........................................................................................62 7.8. Evitar el reinicio de la actividad por cambio de orientación de la pantalla............................63 7.9. Creación de interfaces.............................................................................................................648. Android en Eclipse IDE..................................................................................................................66 8.1. Creación de un proyecto Android...........................................................................................66 8.2. Ejecución de un proyecto........................................................................................................69 8.3. Modificación de las características del proyecto....................................................................70 8.4. Creación de interfaces gráficas...............................................................................................71 8.5. Generar instalador...................................................................................................................73 8.6. Descargar proyectos de ejemplo.............................................................................................759. Creación de un repositorio en la forja GitHub...............................................................................76 9.1. Configurar Git.........................................................................................................................76 9.2. Crear un repositorio en GitHub..............................................................................................8010. Publicación en Android Market....................................................................................................82 10.1. Información general..............................................................................................................82 10.2. Registro.................................................................................................................................82 10.3. Subida de una aplicación......................................................................................................8311. Futuras mejoras.............................................................................................................................8612. Conclusiones.................................................................................................................................8813. Bibliografía...................................................................................................................................9214. Apéndices.....................................................................................................................................93 8

14.1. Manual de Usuario................................................................................................................9314.2 Artículos sobre SWADroid en prensa..................................................................................105 9

1. Introducción Este documento tiene como propósito detallar la labor realizada durante el periodo deejecución del proyecto final de carrera, consistente en desarrollar una aplicación para dispositivosmóviles Android. La aplicación constituye la base de un cliente Android capaz de acceder a la plataforma deteleformación SWAD (http://swad.ugr.es) de la Universidad de Granada mediante servicios webbasados en el protocolo SOAP (Simple Object Access Protocol). Esto conllevará ventajas tanto paralos usuarios de la plataforma como para el propio SWAD. En primer lugar, SWAD ampliará su presencia en el ámbito académico ofreciendo a sususuarios una nueva forma de acceder a sus contenidos de forma rápida y sencilla. En segundo lugar, los usuarios de SWAD podrán acceder al mismo en cualquier momento ylugar e incluso podrán acceder a ciertos servicios de SWAD sin necesidad de una conexión aInternet. 10

2. Definición de objetivos y especificaciones 2.1. Estado del arte Se denomina aprendizaje electrónico móvil, en inglés, m-learning, a una metodología deenseñanza y aprendizaje valiéndose del uso de pequeños y maniobrables dispositivos móviles, talescomo teléfonos móviles, celulares, agendas electrónicas, tablets PC, pocket pc, i-pods y tododispositivo de mano que tenga alguna forma de conectividad inalámbrica. La educación va incorporando intensivamente las nuevas tecnologías de la comunicación,pasando por varias etapas. Diversos conceptos describen ese fenómeno, según avanza la tecnología:EAO (Enseñanza apoyada por el ordenador), multimedia educativo, tele-educación, enseñanzabasada en web (web-based teaching), aprendizaje electrónico (e-learning), etc. Tanto desde el simple uso de la computadora y los soportes multimedia, como eladvenimiento de Internet y las redes en general, todo ha servido para apoyar el proceso deenseñanza-aprendizaje en sus diferentes modalidades y aspectos. De un tiempo a esta parte, se vienen incorporando a nuestras vidas, cada vez con más fuerza,las tecnologías móviles, y por lo tanto, está surgiendo lo que denominamos mobile learning o m-learning y que consiste en usar estos aparatos electrónicos para aprender. Esto está generando gran expectativa en el sistema educativo, sobre el que se estánrealizando interesantes iniciativas empresariales y proyectos de investigación. El "Mobile Learning Engine" (MLE) es una aplicación integral de aprendizaje. Transfiere el aprendizaje asistido por ordenador y multimedia (conocidos como e-learning) para un entorno móvil (con un teléfono móvil). Este tipo especial de aprendizaje asistido por ordenador y multimedia se conoce comúnmente como "mLearning". El MLE permite al estudiante a utilizar su teléfono móvil como un medio para el aprendizaje. Como consecuencia, es posible utilizar cualquier tipo de tiempo de espera para el aprendizaje, no importa dónde se encuentre. Actualmente sólo se puede acceder a SWAD desde un dispositivo móvil mediante unainterfaz web adaptada a este tipo de dispositivos que no es capaz de aprovechar todo el potencial delos dispositivos móviles además de requerir una conexión permanente a Internet para su uso. 11

Esta interfaz hace que el acceso a SWAD desde un dispositivo móvil sea extremadamentelento debido al menor ancho de banda con que suelen contar estos dispositivos y a que el uso de uninterfaz web requiere la transmisión de información referente tanto a los datos que se deseanmostrar al usuario como a la forma de presentarlos por pantalla. Esto hace que se tenga quetransmitir una gran cantidad de datos, cosa que no ocurriría de enviar únicamente la informaciónútil que necesita el usuario y delegar la presentación de los datos en el dispositivo móvil. Por otra parte, existen dispositivos móviles que no pueden acceder a la interfaz móvil deSWAD. Por ejemplo, los móviles con Android 2.1 o inferior tienen problemas para acceder apáginas web mediante el protocolo HTTPS, requerido por SWAD, por lo que no pueden acceder almismo. 12

2.2. Motivación La finalidad de este proyecto es ofrecer a los usuarios ya existentes de SWAD nuevas formasde acceder a la plataforma. Por una parte, esto aporta beneficios a la plataforma puesto que seadapta a las nuevas tecnologías. Por otra parte, los usuarios ven cómo la plataforma evoluciona y lesproporciona nuevas formas de acceso a la misma; esto proporcionará confianza y satisfacción a losusuarios actuales. Al mismo tiempo, SWADroid puede ayudar a la captación de nuevos usuarios, bien sea pordescubrimiento de la existencia de la plataforma al acceder a SWAD desde su dispositivo Android,o usuarios que utilizaban otras plataformas similares a SWAD y que pueden sentirse atraídos por lasnuevas posibilidades que este proyecto les ofrece, ya que es posible que las herramientas que esténutilizando no se hayan adaptado a las nuevas tecnologías. Los últimos estudios que analizan la procedencia de los accesos a la información por partede los usuarios muestran claramente un enorme crecimiento del acceso a la información a través dedispositivos móviles que ya ha superado al acceso vía web. Por otra parte, esta aplicación puede permitir que los usuarios accedan a SWAD a través dedispositivos móviles que antes no podían acceder al mismo, como se ha comentado en la secciónanterior. Actualmente no existe ninguna aplicación móvil que permita acceder a la plataforma SWADdesde un dispositivo móvil. Esta aplicación está orientada tanto a profesores como a alumnos y lespermitirá realizar un seguimiento de sus asignaturas desde cualquier lugar. 13

Las razones que justifican la existencia de una aplicación nativa para acceder a SWAD son: • Menor funcionalidad, pero más inmediata y sencilla • Un solo toque para activarla • Usuario-contraseña almacenado en configuración (no requiere introducirlos cada vez que se accede a SWAD) • Menos información en pantalla (evita saturar al usuario con el exceso de información) • Mayor claridad • Menor consumo de ancho de banda • Funcionalidades off-line Se han implementado en SWADroid dos de las funciones más utilizadas en SWAD, como lodemuestran las estadísticas proporcionadas por la plataforma, por lo que el número de usuariospotenciales de SWADroid al término del proyecto es alto y constituye un aliciente más paradesarrollarlo. • Notificaciones (Estadísticas 21/06/2011) ◦ 9991 usuarios (13,55%) ◦ 539155 eventos ◦ 380172 correos enviados • Tests (Estadísticas 21/06/2011) ◦ 211 asignaturas con tests (<10%) ◦ 15199 preguntas ◦ 72,03 preguntas/asignatura ◦ 8806738 preguntas respondidas ◦ 41738,09 preguntas respondidas por asignatura ◦ 579,43 veces se ha respondido cada pregunta 14

2.3. Objetivos Hoy en día es cada vez más habitual el uso de Internet en un dispositivo móvil. En el caso deAndroid, 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 proyectoes proporcionar una nueva forma de acceso a los usuarios de SWAD, una plataforma de e-learningde la Universidad de Granada que ha sido desarrollada por Antonio Cañas Vargas. El objetivo principal de la aplicación se materializará en el desarrollo de la base de uncliente Android para la plataforma de e-learning SWAD. Este cliente proporcionará dos funcionesde ejemplo a modo de demostración de su capacidad para interactuar con SWAD: • Notificaciones: Esta función permitirá al usuario consultar las últimas notificaciones recibidas en la plataforma SWAD. • Tests: Esta función permitirá descargar las preguntas de test de las asignaturas que dispongan de ellas y generará tests de autoevaluación con la configuración establecida por el profesor de la asignatura correspondiente que el usuario podrá realizar para comprobar sus conocimientos y habilidades en la materia en cuestión. Esta aplicación logra que un usuario pueda acceder e interactuar con sus datos de unamanera rápida y sencilla en cualquier momento y lugar. De esta manera, este objetivo puede serdividido en dos bloques: • Acceso eficiente y sencillo a sus datos: presentarlos de una manera ordenada buscando siempre la optimización de los recursos disponibles y la usabilidad. Para ello, la aplicación respetará la clasificación de funciones que realiza SWAD y las mostrará en una lista expandible en la ventana principal. • 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 consultarlos, sino que además podrá realizar operaciones sobre los mismos. Algunas de estas operaciones podrán realizarse sin necesidad de una conexión a Internet. 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 setermine la etapa de estudiante, un informático va a estar aprendiendo a usar nuevos lenguajes deprogramació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 nose ha trabajado durante la carrera, dado que Android es un sistema operativo muy reciente en el queaún no se ha profundizado a nivel académico. 15

2.4. Software y documentación libre Todo el software desarrollado ha sido liberado bajo la licencia GPLv3. La documentaciónsobre este proyecto ha sido liberada bajo la licencia FDL. Esto significa que cualquiera puede usarlopara cualquier propósito, compartirlo, estudiar su funcionamiento, modificarlo y compartir esasmodificaciones. Pero el software libre no significa únicamente una serie de libertades para elusuario, también es beneficioso para el propio proyecto: recibe visibilidad (publicidad), logramejoras gracias a la retroalimentación de los usuarios y recibe la colaboración de otros usuarios. La liberación del software y la documentación también permite la transferencia deconocimientos y la innovación tecnológica, haciendo que el proyecto no quede estancado una vezque finalice, sino que pueda servir para cubrir futuras necesidades continuando su desarrollo ointegrándose en el de otro proyecto. Este proyecto, además, se basa completamente en estándaresabiertos y herramientas libres, por lo que es también una obligación moral devolver a la comunidadlo recibido, además de que algunas licencias obligan a liberar los desarrollos derivados. El proyecto no ha sido únicamente liberado, sino que ha sido desarrollado en un procesocompletamente abierto, siendo accesibles todos los avances del desarrollo en una forja(https://github.com/Amab/SWADroid) y publicando información sobre él en las redes sociales. Eldesarrollo ha permitido también la colaboración de los usuarios mediante el envío de sugerencias demejoras y errores. Copyright (c) 30 de julio de 2011, Juan Miguel Boyero CorralPermission is granted to copy, distribute and/or modify thisdocument under the terms of the GNU Free Documentation License,Version 1.3 or any later version published by the Free SoftwareFoundation; with no Invariant Sections, no Front-Cover Texts, andno Back-Cover Texts. A copy of the license is available inhttp://www.gnu.org/copyleft/fdl.html 16

3. Análisis y Diseño3.1. Diagrama de Casos de Uso 17

3.2. Sistema operativo móvil Los dos principales sistemas operativos para dispositivos móviles que existen en laactualidad son iOS de Apple para iPhone/iPad, y Android de Google. • iOS El desarrollo para iOS resulta demasiado caro y problemático para este proyecto. Para poderobtener el entorno de desarrollo es necesario darse de alta como desarrollador en la página web deApple con un coste de 99$/mes, una tarifa demasiado alta para las características y los objetivos deeste proyecto. Por otra parte, la licencia GPL de este proyecto es incompatible con la tienda de aplicacionesde Apple (App Store), único modo de distribuir las aplicaciones de iOS, por lo que este proyecto nopodría ser distribuido en la misma y, por tanto, no estaría disponible para ningún dispositivo queutilizara el sistema iOS. Esto provoca que desarrollar el proyecto como una aplicación de iOS seauna tarea absurda y totalmente improductiva, ya que se crearía una aplicación que nadie podríainstalar ni utilizar en su dispositivo móvil. • Android El desarrollo para Android no requiere pago alguno para obtener el entorno de desarrollo,que se puede descargar de forma gratuita desde http://developer.android.com/sdk/index.html. Aunque la aplicación se puede distribuir por muchos medios, es aconsejable publicarla en latienda de aplicaciones de Android (Android Market), lo que requiere un único pago de 25$ en elmomento de registrarse en la misma como desarrollador. A partir de ese momento se puedenpublicar cuantas aplicaciones se deseen sin coste adicional. Estas aplicaciones estarán disponiblespara multitud de dispositivos móviles que utilicen el sistema Android. 18

3.3. Plataforma de desarrollo Como plataforma de desarrollo para el proyecto se ha utilizado el IDE Eclipse junto con elplugin ADT (Android Development Tools) sobre GNU/Linux por ser el modo de desarrollorecomendado por la página web de para desarrolladores de Android y porque la combinaciónEclipse+ADT era la opción que más funcionalidad ofrecía de entre todas las alternativas probadas. 19

3.4. Diagrama de funcionamiento de los servicios web SWADroid se comunica con SWAD mediante un conjunto de servicios web proporcionadospor la plataforma y que han sido implementados por Antonio Cañas utilizando el protocolo SOAP.El código fuente de los servicios web está implementado en C y ha sido generado con la ayuda de laherramienta gSOAP. Durante la etapa de identificación, SWADroid envía a SWAD una petición de identificaciónque contiene el usuario y la contraseña del usuario, y la AppKey de la aplicación. La AppKey, o clave de aplicación, es una cadena alfanumérica proporcionada por AntonioCañas (creador de SWAD) con el fin de que SWADroid demuestre durante la etapa de identificaciónque está autorizada a utilizar los servicios web de SWAD. Si SWADroid intenta acceder a SWADcon datos de usuario correctos y una AppKey errónea, la petición será rechazada por SWAD. Si la petición ha tenido éxito, SWAD devuelve los datos del usuario identificado y un códigode sesión que será utilizado para acceder a los servicios web de SWAD. Si la petición es errónea,SWAD devolverá un mensaje de error y SWADroid informará al usuario de que los datos deidentificación proporcionados en la configuración de la aplicación son incorrectos. 20

3.5. Diagrama de la Base de Datos 21

3.6. Diagramas de clase El núcleo de SWADroid, exceptuando algunas clases de apoyo para construir la ventanaprincipal y realizar operaciones menores, lo constituyen tres clases principales: • Global La clase Global define las constantes que se utilizarán a nivel global en toda la aplicación,como las constantes que definen los nombres de las tablas de la base de datos, y la AppKey.También define algunos métodos auxiliares para realizar tareas menores, como la conversión devalores de tipo booleano a tipo entero o cadena y viceversa. • Preferences La clase Preferences se encarga de construir la pantalla de configuración y gestionar laconfiguración de SWADroid permitiendo que sea accedida y modificada por el resto de laaplicación. • SWADMain La clase SWADMain es la clase principal y el punto de entrada de SWADroid. Se encarga deconstruir la pantalla principal y lanzar todas las funciones que implementa la aplicación a peticióndel usuario. 22

4. Módulos SWADroid sigue una arquitectura modular que permite añadir funcionalidad en forma denuevos módulos realizando modificaciones mínimas en el resto de la aplicación. Estasmodificaciones vienen impuestas principalmente por la arquitectura de Android, que obliga a quelas aplicaciones sigan un esquema determinado y a que ciertas acciones se realicen de una formapreestablecida por la arquitectura del sistema. La arquitectura modular de SWADroid se basa en la clase Module, de la que heredan todoslos módulos de la aplicación y que implementa las estructuras de datos y las operaciones comunes atodos los módulos, tanto presentes como futuros. Esta clase implementa, entre otras funciones, elmecanismo de comunicación mediante el acceso a los servicios web que implementa SWADproporcionando métodos para construir las peticiones que se realizan a dichos servicios web yrecibir y procesar las respuestas recibidas de los mismos. Los métodos de la clase Module generan las peticiones en ficheros XML que envían aSWAD, que a su vez envía las respuestas en otro fichero XML. Estos ficheros se estructuran con elformato especificado por el protocolo SOAP, utilizado en las comunicaciones con SWAD. SWADroid incluye cuatro módulos: • Login Este módulo se encarga de comprobar si SWADroid se ha identificado en SWAD o no y, ensu caso, enviar una petición de identificación para obtener la clave de sesión necesaria para accedera los servicios web de SWAD. El módulo Login es llamado desde la clase Module como paso previo al envío de unapetición desde cualquier módulo. De esta forma se asegura que SWADroid siempre tendrá la clavede sesión antes de acceder a un servicio web. 23

• Courses Este módulo se encarga de obtener los datos de las asignaturas en las que el usuario estádado de alta en SWAD. El módulo Courses es utilizado por el módulo Tests para obtener y mostrarel listado de las asignaturas desde las que el usuario tendrá la opción de descargar preguntas de test. • Notifications Este módulo se encarga de obtener las últimas notificaciones enviadas al usuario desdeSWAD y mostrarlas por pantalla. Además de la información que envía SWAD por correoelectrónico cuando avisa al usuario de que tiene nuevas notificaciones, el módulo Notificationsobtiene y muestra el contenido de las mismas, salvo para las notificaciones referentes a lascalificaciones de una asignatura, que por el formato de su contenido deben ser tratadas de formaespecial. Actualmente el módulo Notifications soporta todas las notificaciones que puede generarSWAD. • Tests Este módulo se encarga de descargar las preguntas de test de las asignaturas en las que elusuario esté dado de alta, que contengan preguntas de test y cuya opción de exportar las preguntasde test a un dispositivo móvil haya sido habilitada por alguno de los profesores de la asignatura encuestión. Por otra parte, el módulo Tests genera tests de preguntas seleccionadas de forma aleatoriateniendo en cuenta la configuración establecida por los profesores de la asignatura y los parámetrosdefinidos por el usuario, como el número de preguntas del test y los descriptores y tipos depreguntas que desea que aparezcan en el test. 24

4.1. Desarrollo de un módulo El desarrollo de un nuevo módulo para SWADroid requiere seguir una serie de pasos: 1. Declarar el módulo en el archivo AndroidManifest.xml. A modo de ejemplo se muestra el código necesario para declarar el módulo Login: <activity android:name=".modules.Login" android:label="@string/loginModuleLabel" android:configChanges="keyboard|keyboardHidden|orientation" android:theme="@android:style/Theme.Translucent.NoTitleBar"> </activity> 2. Añadir, en su caso, los permisos necesarios en el archivo AndroidManifest.xml para el correcto funcionamiento del módulo. A modo de ejemplo se muestra el código necesario para añadir los permisos que requiereactualmente SWADroid:<uses-permission android:name="android.permission.INTERNET"></uses-permission><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission> 3. Añadir una llamada al módulo desde la actividad que debe llamarlo. A modo de ejemplo se muestra el código necesario para llamar al módulo Notificationsdesde la clase principal SWADMain: activity = new Intent(getBaseContext(), Notifications.class); startActivityForResult(activity, Global.NOTIFICATIONS_REQUEST_CODE); El método startActivityForResult permite recoger la respuesta devuelta por el módulo, si esque devuelve alguna, para su posterior procesamiento por parte de la actividad llamante. Si elmódulo no va a devolver nada se puede emplear en su lugar el método startActivity. NOTIFICATIONS_REQUEST_CODE es un código asignado al módulo en la clase Global afin de poder procesar la respuesta devuelta por el mismo en el método onActivityResult. Cualquiermétodo que requiera el procesamiento de su respuesta debe tener asignado un REQUEST_CODE afin de poder realizar dicho procesamiento. 4. Añadir el módulo, en su caso, al menú de funciones de la pantalla principal. Si el módulo implementa una nueva función que debe estar presente en el menú principal deSWADroid, se puede añadir la misma mediante un código similar al siguiente, que muestra cómoañadir la función Notificaciones dentro de la categoría Mensajes:final ArrayList<HashMap<String, Object>> headerData = newArrayList<HashMap<String, Object>>();final HashMap<String, Object> messages = new HashMap<String, Object>();messages.put(NAME, getString(R.string.messages)); 25

messages.put(IMAGE, getResources().getDrawable(R.drawable.msg));headerData.add( messages );final ArrayList<ArrayList<HashMap<String, Object>>> childData = newArrayList<ArrayList<HashMap<String, Object>>>();final ArrayList<HashMap<String, Object>> messagesData = newArrayList<HashMap<String, Object>>();childData.add(messagesData);HashMap<String, Object> map = new HashMap<String,Object>();map.put(NAME, getString(R.string.notificationsModuleLabel) );map.put(IMAGE, getResources().getDrawable(R.drawable.notif));messagesData.add(map); 5. Implementar el módulo. Todos los módulos de SWADroid deben heredar de la clase Module, que implementa unaserie de métodos abstractos que todos los módulos están obligados a implementar para mantener elflujo de ejecución de SWADroid. Estos métodos son: • connect Este método se encarga de mostrar un cuadro de diálogo de progreso, si es necesario, y delanzar la ejecución de la tarea implementada por el módulo en una hebra en segundo plano. A modo de ejemplo se muestra el código del método connect del módulo Notifications: String progressDescription =getString(R.string.notificationsProgressDescription); int progressTitle = R.string.notificationsProgressTitle; new Connect(true, progressDescription, progressTitle).execute(); • postConnect Este método se encarga de realizar las acciones que deban llevarse a cabo después de haberejecutado la tarea principal del módulo, como por ejemplo el refresco de la pantalla para actualizarla información mostrada. A modo de ejemplo se muestra el contenido del método postConnect del móduloNotifications: refreshScreen(); El código del método refreshScreen se detalla a continuación://Refresh data on screendbCursor = dbHelper.getDb().getCursor(Global.DB_TABLE_NOTIFICATIONS, selection,orderby);adapter.changeCursor(dbCursor);ListView list = (ListView)this.findViewById(R.id.listItems);//If there are notifications to show, hide the empty notifications message and 26

show the notifications listif(dbCursor.getCount() > 0) { text.setVisibility(View.GONE); list.setVisibility(View.VISIBLE);} • requestService Este método implementa la tarea principal que llevará a cabo el módulo, que normalmenteconsiste en construir y enviar una petición a un servicio web de SWAD y procesar la respuestadevuelta por el mismo. El flujo de ejecución de un módulo estándar es el siguiente (se ilustrará mediante lassecciones relevantes del código del módulo Notifications): a) El nombre del servicio web al que se enviará la petición se suele configurar durante la ejecución del método onCreate del módulo, que se ejecuta la primera vez que se lanza el módulo durante la ejecución de SWADroid, pero también puede hacerse en este método. setMETHOD_NAME("getNotifications"); b) Se inicializa la petición, se le añaden los parámetros requeridos por el servicio web y se envía al servicio web. //Creates webservice request, adds required params and sends request to webservice createRequest(); addParam("wsKey", User.getWsKey()); addParam("beginTime", timestamp); sendRequest(Notification.class, false); c) Se procesa la respuesta del servicio web y, en su caso, se almacenan en la base de datos los datos recibidos.if (result != null) { //Stores notifications data returned by webservice response Vector res = (Vector) result; SoapObject soap = (SoapObject) res.get(1); int csSize = soap.getPropertyCount(); Integer lastId = new Integer(dbHelper.getFieldOfLastNotification("id")); for (int i = 0; i < csSize; i++) { SoapObject pii = (SoapObject)soap.getProperty(i); String eventType = pii.getProperty("eventType").toString(); Long eventTime = new Long(pii.getProperty("eventTime").toString()); String userSurname1 = pii.getProperty("userSurname1").toString(); String userSurname2 = pii.getProperty("userSurname2").toString(); String userFirstName = pii.getProperty("userFirstname").toString(); String location = pii.getProperty("location").toString(); String summary = pii.getProperty("summary").toString(); Integer status = new Integer(pii.getProperty("status").toString()); String content = pii.getProperty("content").toString(); Notification n = new Notification(lastId+i, eventType, eventTime,userSurname1, userSurname2, userFirstName, location, summary, status, content); dbHelper.insertNotification(n); if(isDebuggable) 27

Log.d(TAG, n.toString()); } //Request finalized without errors Log.i(TAG, "Retrieved " + csSize + " notifications"); //Clear old notifications to control database size dbHelper.clearOldNotifications(SIZE_LIMIT); }} 28

5. Internacionalización SWADroid provee soporte para varios idiomas. Actualmente está disponible en español einglés. El idioma no puede ser seleccionado explícitamente por el usuario, sino que se estableceautomáticamente en función del idioma configurado en el sistema. Las cadenas de texto de cada idioma se encuentran almacenadas en archivos XML dentro dela carpeta res/values seguida del código del idioma al que corresponden. Así, la carpetacorrespondiente al idioma español es res/values-es. Si no se especifica ningún código después devalues, se tomará por defecto como inglés. Actualmente existen dos archivos dentro de la carpeta res/values-es que contienen todas lascadenas de texto requeridas por SWADroid. Estos archivos son strings.xml y lists.xml. Es muy sencillo traducir SWADroid a otros idiomas. Sólo es necesario traducir las cadenasde texto que se encuentran entre las etiquetas <string> y </string> sin modificar en ningún caso elparámetro name de la etiqueta <string>, ya que éste es el identificador que utilizar SWADroid paraacceder a la cadena de texto en el idioma apropiado. Una vez traducidos ambos archivos, deben incluirse en una nueva carpeta cuyo nombre debeser res/values-[CODIGO_IDIOMA]. Hecho esto, el nuevo idioma estará disponible en SWADroid. A modo de ejemplo se muestra el contenido de ambos archivos: strings.xml<?xml version="1.0" encoding="UTF-8"?><resources> <string name="app_name">SWADroid</string> <string name="loginModuleLabel">Conectar</string> <string name="notificationsModuleLabel">Notificaciones</string> <string name="coursesModuleLabel">Asignaturas</string> <string name="testsModuleLabel">Tests</string> <string name="title_error_dialog">ERROR</string> <string name="close_dialog">Cerrar</string> <string name="set_preferences">Configuración</string> <string name="user_preferences">Datos del usuario</string> <string name="userIDName_preferences">Usuario</string> <string name="userIDSummary_preferences">DNI o Apodo</string> <string name="userIDTitle_preferences">Usuario</string> <string name="userPasswordName_preferences">Contraseña</string> <string name="userPasswordSummary_preferences">Contraseña</string> <string name="userPasswordTitle_preferences">Contraseña</string> <string name="saveMsg_preferences">Configuración guardada</string> <string name="saveSummary_preferences">Guarda la configuraciónactual</string> <string name="saveTitle_preferences">Guardar configuración</string> <string name="preferencesTitle_menu">Configuración</string> <string name="about_preferences">Acerca de</string> <string name="versionTitle_preferences">Versión de la aplicación</string> <string name="author_preferences">Programado por Juan Miguel BoyeroCorral</string> <string name="organization_preferences">Universidad de Granada</string> <string name="loginTitle_menu">Conectar</string> 29

<string name="loginProgressTitle">Identificación</string> <string name="loginProgressDescription">Conectando...</string> <string name="coursesProgressTitle">Asignaturas</string> <string name="coursesProgressDescription">Obteniendoasignaturas...</string> <string name="notificationsProgressTitle">Notificaciones</string> <string name="notificationsProgressDescription">Obteniendo nuevasnotificaciones...</string> <string name="notificationsEmptyListMsg">No se ha descargado ningunanotificación.nnPara descargar las notificaciones más recientes pulse el icono de la esquina superiorderecha de la pantalla.</string> <string name="testsDownloadProgressTitle">Tests</string> <string name="testsDownloadProgressDescription">Sincronizando preguntas detest.nnDependiendo del número de preguntas a sincronizar, el procesamiento de los datos puede tardarunos minutos.nnPor favor, espere...</string> <string name="errorMsgWorkaroundEmulator">Mierda. Ese bug del emulador deAndroid ha vuelto a aparecer. Reintentando...</string> <string name="errorMsgLaunchingActivity">Ha ocurrido un error durante laejecución de la operación</string> <string name="errorMsgNoConnection">No hay conexión</string> <string name="errorCopyMsg_DB">Error copiando base de datos</string> <string name="upgradeMsg_DB">Actualizando base de datos...</string> <string name="loginSuccessfulMsg">Conectado</string> <string name="examAnnouncement">Convocatoria de examen</string> <string name="marksFile">Calificaciones</string> <string name="notice">Aviso</string> <string name="message">Mensaje</string> <string name="forumReply">Respuesta en foro</string> <string name="content">Contenido</string> <string name="messages">Mensajes</string> <string name="evaluation">Evaluación</string> <string name="assignment">Actividad</string> <string name="survey">Encuesta</string> <string name="unknownNotification">Notificación desconocida</string> <string name="fromMsg">De</string> <string name="dateMsg">Fecha</string> <string name="noSubjectMsg">Sin asunto</string> <string name="noContentMsg">Sin contenido</string> <string name="yesMsg">Sí</string> <string name="noMsg">No</string> <string name="trueMsg">Verdadero</string> <string name="falseMsg">Falso</string> <string name="acceptMsg">Aceptar</string> <string name="cancelMsg">Cancelar</string> <string name="allMsg">Todos</string> <string name="selectCourseTitle">Seleccione asignatura</string> <string name="noCourseSelectedMsg">Debe seleccionar una asignatura paradescargar las preguntas de test</string> <string name="noQuestionsAvailableTestsDownloadMsg">No hay preguntas detest disponibles para esta asignatura</string> <string name="noQuestionsPluggableTestsDownloadMsg">El profesor de estaasignatura no permite la descarga de las preguntas de test</string> <string name="questionsTestsDownloadSuccesfulMsg">Preguntas de testsincronizadas</string> <string name="testNoQuestionsCourseMsg">No se ha descargado ninguna 30

pregunta de test para esta asignatura</string> <string name="testNoQuestionsMsg">Antes de realizar un test debe descargarlas preguntas de test de al menos una asignatura</string> <string name="testNoQuestionsMeetsSpecifiedCriteriaMsg">No hay ningunapregunta que se ajuste a los criterios especificados</string> <string name="testNumQuestionsMsg">Indique el número de preguntas deltest</string> <string name="testTagsMsg">Seleccione los descriptores que desea incluiren el test</string> <string name="testNoTagsSelectedMsg">Debe seleccionar al menos undescriptor</string> <string name="testAnswerTypesMsg">Seleccione los tipos de respuesta quedesea incluir en el test</string> <string name="testNoAnswerTypesSelectedMsg">Debe seleccionar al menos untipo de respuesta</string> <string name="testEvaluateMsg">Corregir</string> <string name="testResultsTextMsg">Puntuación</string> <string name="testShowResultsMsg">Ver totales</string> <string name="testShowResultsDetailsMsg">Ver detalles</string> <string name="testNoDetailsMsg">El profesor no permite ver losdetalles</string> <string name="testNoResultsMsg">El profesor no permite ver los resultadosdel test</string> <string name="firstRunMsg">Antes de usar la aplicación por primera vezdebe introducir el nombre de usuario y la contraseña de acceso a SWAD enla pantalla de configuración.nnPuede acceder a la pantalla de configuración desde el menú de la aplicación en cualquier momento.nn¿Desea abrir ahora la pantalla de configuración?</string> <string name="initialDialogTitle">IMPORTANTE</string> <string name="upgradeMsg">Debido a cambios en la base de datos todos los datos de las notificaciones han sido borrados.nnDisculpe las molestias.</string> <string name="errorBadLoginMsg">Usuario o contraseña incorrectos</string> <string name="errorServerResponseMsg">Error en respuesta delservidor</string> <string name="errorConnectionMsg">Error durante la conexión con elservidor</string> <string name="errorTimeoutMsg">Tiempo de espera agotado intentandoconectar con el servidor</string></resources> 31

lists.xml<?xml version="1.0" encoding="utf-8"?><resources> <string-array name="functions"> <item>Notificaciones</item> <item>Tests</item> </string-array> <string-array name="testMenuItems"> <item>Sincronizar preguntas</item> <item>Realizar test</item> </string-array> <string-array name="testAnswerTypesNames"> <item>Todos</item><item>Verdadero/Falso</item> <item>Elección única</item> <item>Elección múltiple</item> <item>Texto</item> <item>Nº entero</item> <item>Nº real</item> </string-array></resources> 32

6. Validación y pruebas El SDK de Android permite integrar dispositivos virtuales para probar SWADroid en elentorno de desarrollo Eclipse. Queda a disposición del usuario crearse cuantos emuladores quiera ycon las características que se desee. Esta flexibilidad permite, entre otras cosas, establecer la versióndel sistema operativo en la que se ejecutará, el tipo de pantalla, su resolución, cantidad dememoria... Para realizar las pruebas se han creado dos emuladores: uno que implementa la versión1.6 de Android, puesto que esta es la versión mínima en la que se puede ejecutar SWADroid, y elsegundo con la versión 2.3.3, puesto que es la última versión disponible. Por otra parte, SWADroid también ha sido probado en varios dispositivos reales: • Móvil Sony Ericsson Xperia X8 con Android 2.1. • Móvil HTC Desire con Android 2.3. • Tableta Samsung Galaxy con Android 2.3 En todo momento se han realizado pruebas en ambos emuladores y en todos los dispositivosreales para poder observar las diferencias de ejecución entre una versión y otra. Las diferenciasentre velocidades de ejecución y acceso a Internet eran casi siempre mínimas, siendo lo másdestacable 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 parauna correcta presentación. Las pruebas en los dispositivos reales han dado lugar a que el famoso problema de lafragmentación de Android (diferencias de comportamiento según la versión del sistema operativo yel dispositivo móvil utilizado) se manifieste en toda su envergadura llegando a provocar en algunoscasos situaciones en las que SWADroid funcionaba correctamente en ambos emuladores y en eldispositivo móvil Sony Ericsson pero sufría errores de ejecución en el resto de los dispositivosreales. Estas dificultades hacen que el problema de la fragmentación deba tenerse muy en cuenta ala hora de desarrollar aplicaciones para Android procurando probarlas en el mayor número posiblede dispositivos reales para asegurar su correcto funcionamiento en la mayor parte de los mismos. 33

Se toma también en consideración la forma en la que el sistema operativo Android gestionael cambio de orientación de la pantalla, puesto que, al girar el dispositivo, se destruye la ventana enejecución y se vuelve a crear reiniciando así la actividad asociada a ella. Esta forma de actuarrequiere un tratamiento especial para evitar comportamientos molestos del interfaz gráfico desde elpunto de vista del usuario. Se ha realizado una comparativa para estudiar de forma empírica las diferencias existentesentre acceder a la información de SWAD a través de la interfaz web y acceder a través deSWADroid. En el acceso vía web se comienza con la caché del navegador inicialmente vacía. Losparámetros objeto del estudio son el número necesario de peticiones al servidor para realizar laacción deseada, la cantidad de datos descargados en cada caso y el tiempo de carga de la web (en elacceso a través de la interfaz web) o de la respuesta del servicio web (en el acceso a través deSWADroid). 34

En las gráficas anteriores se muestra el valor de los parámetros medidos agrupados enfunción de la acción realizada. En el acceso a través de la interfaz web las acciones realizadas sonlas siguientes: • Inicio+Login Esta acción engloba los pasos necesarios para identificarse en la plataforma: 1. Carga de la pantalla inicial en la que se pide el usuario y la contraseña. 2. Carga de la pantalla de confirmación de identificación correcta. • Notificaciones Esta acción engloba los pasos necesarios para consultar las notificaciones recibidas: 1. Acceder a la pestaña Mensajes. 2. Pulsar sobre la opción Notificaciones. 35

• Mostrar y evaluar test EC1 Esta acción engloba los pasos necesarios para configurar, realizar y evaluar un test de laasignatura Estructuras de los Computadores 1: 1. Seleccionar la asignatura Estructuras de los Computadores 1. 2. Acceder a la pestaña Evaluación. 3. Pulsar sobre la opción Test de autoevaluación. 4. Configurar el test y aceptar. 5. Responder a las preguntas del test y enviar las respuestas. 6. Carga de la pantalla de resultados del test (realimentación máxima). • Logout Esta acción lleva a cabo el cierre de sesión en la plataforma. En el acceso a través de SWADroid sólo se requiere una petición al servidor por cada acciónrealizada. Las acciones realizadas son las siguientes: • Login Esta acción engloba los pasos necesarios para identificarse en la plataforma. Se realiza deforma automática sin intervención del usuario cuando es necesario. • Notificaciones Esta acción engloba los pasos necesarios para consultar las notificaciones recibidas. El únicopaso que debe realizar el usuario es pulsar el botón de actualización para descargar las últimasnotificaciones desde SWAD. • Asignaturas Esta acción permite al usuario seleccionar la asignatura de la que desea descargar laspreguntas de test cuando pulsa sobre la opción Sincronizar preguntas. • Descarga EC1 (Configuración) Esta acción descarga la configuración establecida por el profesor para la realización de lostests de su asignatura (en este caso, Estructuras de los Computadores 1). Esta acción se lleva a cabode forma automática sin la intervención del usuario después de seleccionar la asignatura de la quedescargar las preguntas de test. • Descarga EC1 (Datos) Esta acción descarga las preguntas y respuestas de test de la asignatura seleccionada por elusuario. Esta acción se lleva a cabo inmediatamente después de descargar la configuración de lostests de la asignatura y se realiza de forma automática sin la intervención del usuario después deseleccionar la asignatura de la que descargar las preguntas de test. 36

En este caso no se requiere realizar ningún cierre de sesión, puesto que éste se lleva a cabode forma implícita al transcurrir el período de caducidad establecido por la plataforma SWAD paralas claves de sesión. La comparativa anterior pone de manifiesto que el acceso a la información de SWAD desdeSWADroid es, por regla general, más cómodo y rápido que el acceso desde la interfaz web. Todas las acciones estudiadas requieren dar más pasos, realizar más peticiones al servidor,transferir más cantidad de datos y consumir más tiempo si se realizan mediante la interfaz web. Enel caso de la realización y evaluación de tests la situación es aún más favorable para SWADroid, yaque desde la interfaz web es necesario descargar los datos cada vez que se realiza un test. Sinembargo, SWADroid sólo transfiere los datos durante la descarga de las preguntas de test, queúnicamente se realiza una vez. La realización de tests desde SWADroid no requiere conexión aInternet y, por tanto, no produce tráfico de datos en la red. 37

7. Programación con el SDK de Android En este apartado se van a explicar las APIs y tecnologías utilizadas para la elaboración deeste proyecto. Android es un sistema operativo para dispositivos móviles muy reciente, puesto queaún no se han cumplido dos años desde su primera aparición en el mercado; no obstante y pese a suescaso tiempo de vida, un programador con cierta experiencia se adapta rápidamente a suprogramación. 7.1. Introducción Los inicios de este sistema provienen del año 2005 cuando Google compra una pequeñacompañía llamada Android Inc, cuya finalidad es el desarrollo de aplicaciones para dispositivosmóviles, centradas principalmente en plataformas Web. La existencia del nuevo sistema operativo no se hace pública hasta el año 2007, momento enel que se anuncia la creación de la Open Handset Aliance. Esta organización es un consorcio decompañías relacionadas con las telecomunicaciones y la informática, cuyo principal objetivo es lapromoció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 estesistema operativo. Desde entonces, son ya varias las compañías que están apostando por Android. Amodo de resumen estos son los tres nombres más importantes que se pueden relacionar con estaplataforma. Google: esta compañía es en la actualidad una de las más poderosas del mundo, su rápidocrecimiento en tan sólo unos pocos años de vida hizo que en 2007 se convirtiera en la marca másvalorada del mundo por delante de Microsoft o Coca-Cola, empresas que acostumbraban a dominaresta posición. Google lidera la mencionada Open Handset Aliance. El hecho de que esta compañía de tantaimportancia sea la principal promotora de Android aporta dos grandes ventajas tanto a los usuariosde 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 softwarelibre y licencias de código abierto. Ocurre lo mismo con el caso de Android, lo que provoca quecualquier programador comience a trabajar cuando desee sin tener que pagar ninguna licencia paradesarrollar aplicaciones o darlas a conocer en el Android Market. Este último es un repositorio deaplicaciones al que se puede acceder desde cualquier Android, quedando a elección deldesarrollador que su aplicación sea gratuita o de pago. La segunda ventaja, es la cantidad de productos pertenecientes a Google tales como Gmail,Youtube, Google Maps, Google Calendar... que cuentan actualmente con un nivel de aceptaciónmuy alto por parte de los usuarios. Todos los Android cuentan con un acceso rápido y eficiente aestos productos y, al mismo tiempo, Google proporciona APIs para que el programador puedaincluir estos servicios en sus aplicaciones de forma muy sencilla. 38

Linux: Android es un sistema operativo abierto para dispositivos móviles, y se basa en laversión 2.6 del Kernel de Linux que actúa como una capa de abstracción entre el hardware y el restodel conjunto de software, además de prestar los servicios de seguridad, gestión de memoria, gestiónde procesos... , que permite que pueda ser adaptado con facilidad a otros dispositivos. Esto presentauna gran ventaja para las compañías fabricantes de teléfonos móviles. A continuación se muestra un diagrama con los principales componentes del sistemaoperativo Android, que serán comentados a continuación. • Aplicaciones: suministra un conjunto de aplicaciones que incluye cliente de correo electrónico, proveedor de SMS, calendario, mapas, navegador web, contactos... más todas aquellas que el usuario desee descargar del Android Market. • Framework de aplicaciones: proporciona acceso a los marcos utilizado por la API de las aplicaciones básicas. La arquitectura de aplicaciones se ha diseñado para simplificar la reutilización de componentes. De esta forma cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación podrá hacer uso de esas capacidades (sujeto a las limitaciones de seguridad impuestas por el marco). Esto hecho permite la reutilización de componentes por parte del usuario. Detrás de todas las aplicaciones existen un conjunto de servicios y sistemas que incluyen un conjunto de vistas para construir las pantallas, así como proveedores de contenido que permiten que las aplicaciones de acceso a los datos de otras aplicaciones (como Contactos), o para compartir sus propios datos. 39

• Librerías: incluye un conjunto de librerías escritas en C y C++ utilizado diversos componentes del sistema. Estas capacidades están expuestas a los desarrolladores a través del Framework. • Android Runtime: incluye un conjunto de librerías que proporciona la mayor parte de la funcionalidad disponible en el núcleo de las bibliotecas y esta basado en el lenguaje de programación Java. Cada aplicación se ejecuta como un proceso independiente, con su propia instancia de la máquina virtual Dalvík que se ha escrito de modo que un dispositivo puede ejecutar múltiples máquinas virtuales de manera eficiente. La máquina virtual de Dalvík ejecuta archivos .dex cuyo formato está optimizado para un consumo de memoria mínima. La máquina virtual se basa en registros, y corre clases compiladas por un compilador de lenguaje Java que se han transformado con la herramienta incluida dx. La máquina virtual de Dalvík se basa en el Kernel de Linux para la funcionalidad subyacente como subprocesos y de gestión de memoria a bajo nivel. • Kernel de Linux: explicado anteriormente antes de mostrar el diagrama. Java: el tercer nombre importante asociado al sistema operativo Android es Java. Como secomentaba anteriormente, a pesar del poco tiempo de vida de esta plataforma cualquierprogramador se adapta a su funcionamiento en muy poco tiempo, dado que el código fuente de unaaplicación se escribe en Java y este es uno de los lenguajes de programación más utilizados en laactualidad. Más adelante se explicarán detalles de programación. Además, como ventaja añadida el “principal inconveniente” que se suele asociar con Java essu velocidad de ejecución. En este caso, como se ha explicado antes, ese problema ni siquiera existedado que, aunque la aplicación se escribe en Java, no es una aplicación Java ya que no se ejecuta enuna máquina virtual de Java. De esta forma el programador cuenta con todas las ventajas de estelenguaje, y desaparece una de sus mayores desventajas. 40

7.2. Especificaciones técnicas Antes de comenzar con los detalles de programación, se explica todo lo necesario paracomenzar a desarrollar aplicaciones así como los pasos necesarios para la instalación de todos suscomponentes. Estos pasos pueden seguirse también de forma resumida en la página oficial deAndroid, en el apartado Developers → Download SDK desde el cual, además, podemos descargartodos los elementos necesarios que a continuación se explican. JDK (Java Development Kit): en primer lugar es necesario tener instalado Java, la versiónmínima del JDK debe ser la 5. Puede comprobarse si se dispone de la versión necesariaintroduciendo en la ventana de comandos el siguiente comando (debería mostrar al menos 1.5 paraque sea la correcta): javac -version Android SDK: mientras que el JDK proporciona lo necesario para utilizar las clases deJava, el SDK da acceso a las clases necesarias para construir una aplicación Android. Para ello sedescarga de la página oficial de Android en el apartado comentado anteriormente, seleccionando laversión correspondiente a la máquina en la que se vaya a trabajar (Mac, Windows o Linux). Estopermite guardar un archivo comprimido, que únicamente hay que descomprimir y guardar la carpetaresultante en el directorio en el que se desee tener el SDK. Tanto la página oficial como los libros consultados afirman que no es necesario nada más yque simplemente debe descomprimirse el archivo y posicionarlo donde se desee. El siguiente paso es crear un dispositivo virtual (puede realizarse en cualquier momentoantes de probar la aplicación), lo que permitirá probar la aplicación en el emulador antes deinstalarla en un dispositivo real. Se pueden crear cuantos emuladores se desee y con diversas características. Por ejemplo sepuede crear uno con la versión 1.5 de Android que fue la primera en comercializarse en España yotro con la última versión para comprobar que funcione todo correctamente en diferentes versiones. 41

Para crearlos se accede a la opción Window → Android SDK and AVD Manager, la ventanamostrada, y se pulsa New. En la nueva ventana se debe establecer un nombre identificador para cadadispositivo virtual, en el apartado Target la versión de sistema operativo que se desee y el tamañoque se quiera que tenga su tarjeta de memoria. Eclipse IDE: es un entorno de desarrollo para compilar y ejecutar aplicaciones. Si seprefiere NetBeans también cuenta con su plugin para programar en Android, pero todos los libros yla página oficial de Android se centran en la herramienta Eclipse. La versión mínima necesaria es la 3.4, ya sea de Classic o para desarrolladores de Java. Eneste caso sí que es suficiente con sólo descargar el archivo y descomprimirlo, ya que no es necesarianinguna instalación. Una vez realizados todos los pasos anteriores sólo queda configurar Eclipse correctamentepara poder implementar aplicaciones con el SDK de Android. Los pasos dados se han realizado paraEclipse Classic 3.7, por lo que dependiendo de la versión es posible que los nombres de las pestañaso su localización varíen ligeramente. Una vez abierto Eclipse hay que realizar las siguientesacciones: 1. Help → Install New Software. 2. En la nueva ventana pulsar Add. 3. En la ventana emergente escribir en el campo Name el nombre que se desee dar al plugin y en Location copiar este enlace y pulsar OK: https://dl-ssl.google.com/android/eclipse/ 42

4. Cuando finalice la descarga seleccionar todos los elementos que aparezcan, pulsar Next, aceptar todos los acuerdos de licencia y finalizar, tras lo cual será necesario reiniciar Eclipse. Una vez se ha instalado el plugin es necesario configurarlo mediante los siguientes pasos: 1. Window → Preferences. 2. En el panel seleccionar Android y en SDK Location escribir la ruta de la carpeta en laque se ha descomprimido el SDK de Android. A continuación, pulsar Apply y OK. 43

7.3. Aplicación Android En este apartado se dará una visión general de las clases básicas que proporciona el SDK, asícomo las principales funcionalidades implementadas para la elaboración de este proyecto. Primerose comentará la estructura de carpetas de un proyecto Android, a continuación se ofreceráncomentarios sobre la API y código, y por último sobre la construcción de interfaces gráficas, quepueden especificarse mediante código o a través de archivos XML. Estructura de carpetas El sistema de directorios de un proyecto Android se organiza en tres directorios principales: • SRC: en esta carpeta se incluyen las clases con el código fuente de la aplicación al igual que en cualquier otro proyecto Java. Dentro de este directorio se puede organizar como se quiera, y con cuantas subcarpetas sean necesarias, con la peculiaridad de que, en un proyecto Android, las carpetas contenidas en SRC deben tener como mínimo dos niveles de profundidad. • Gen: esta carpeta es generada y controlada automáticamente por el entorno de desarrollo, no debe ser modificada, puesto que se actualiza por sí sola cada vez que se realiza algún cambio dentro de la carpeta res. Sirve, por lo tanto, como interfaz entre la carpeta res y el código fuente contenido en src. Cada vez que quiera accederse mediante código a un elemento de la carpeta res debe hacerse a través de la clase R.java. La siguiente línea de código muestra un ejemplo: 44

map.put(IMAGE, getResources().getDrawable(R.drawable.notif)); En ella se asigna como icono la imagen con nombre notif existente en las carpetas drawable (según la resolución de imagen determinada por el sistema en función del tamaño de pantalla) a la función Notificaciones del menú principal de la aplicación. • Res: en esta carpeta se incluye todo lo que no sea código Java, pero que interesa que aparezca en la aplicación. Por defecto están creadas las carpetas drawable (para colocar imágenes), layout (para crear archivos XML que definen interfaces) y values (para colocar Strings y arrays). Pero se pueden añadir más. En este caso contiene la carpeta xml en la que se almacenan los ficheros XML que definen la interfaz gráfica de la pantalla de preferencias y la estructura de la base de datos de SWADroid. También contiene la carpeta values-es, que almacena el mismo contenido que la carpeta values con la diferencia de que en la primera las cadenas de texto están traducidas al castellano y en la segunda están traducidas al inglés. Cada vez que se introduzca un elemento nuevo en una de estas carpetas, o se modifique el contenido de algo que ya hubiera, se le asignará un identificador en la carpeta R.java con el nombre del archivo. En el caso de los archivos de la carpeta layout el nombre debe estar escrito en minúsculas. Por último se observa la existencia del archivo AndroidManifest.xml, que tiene un papel fundamental para el correcto funcionamiento de la aplicación. En él deben definirse todos los permisos de los que haga uso la aplicación, puesto que serán mostrados al usuario en el momento de instalación para que decida si quiere instalarla o no. Si, en algún momento se intenta realizar una acción que requiera un permiso que no esté definido en este archivo, la aplicación lanzará una excepción y finalizará su ejecución. Para evitar esta situación se añaden los permisos necesarios para SWADroid en el archivo de manifiesto:<uses-permission android:name="android.permission.INTERNET"></uses-permission><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission> También debe especificarse el nombre de todas las actividades que aparecen en la aplicación, en otro caso se lanzará una excepción cuando la actividad correspondiente sea ejecutada. También pueden definirse ciertos aspectos de la actividad como su título y su apariencia como muestra la siguiente línea de este fichero:<activity android:name=".modules.tests.Tests" android:theme="@android:style/Theme.NoTitleBar" android:label="@string/testsModuleLabel"></activity> 45

En esta línea se declara la actividad Tests.java dentro de la carpeta SRC, su título es el contenido por el String testsModuleLabel de la carpeta values/string.xml y no mostrará la barra de título habitual en las aplicaciones Android con objeto de sustituirla por una barra de título personalizada. Por último es necesario especificar también qué actividad será la primera en mostrarse en la aplicación mediante el código:<activity android:name=".SWADMain" android:label="@string/app_name" android:icon="@drawable/ic_launcher_swadroid" android:configChanges="keyboard|keyboardHidden|orientation" android:theme="@android:style/Theme.NoTitleBar"> <intent-filter> <action android:name="android.intent.action.MAIN"/> <category android:name="android.intent.category.LAUNCHER"/> </intent-filter></activity> 46

7.4. API de Android En este apartado se comentan las clases que pertenecientes al API de Android. Se utilizancomo cualquier otra clase de Java. 7.4.1. Activity Es la principal clase de Android, y cada pantalla que se muestra en la aplicación es una claseque hereda de Activity. Se podría decir que una actividad equivale a una pantalla. A continuación semuestra el ciclo de vida de una actividad. En el diagrama se observan los métodos que se pueden sobrescribir si se desea realizar unaacción en concreto, y cuándo se ejecutan. No es necesario ni obligatorio implementar ninguno deellos; el único que debemos implementar siempre (al menos si se desea que la actividad muestrealgo) es onCreate() donde se define todo lo que se necesite realizar antes de que la pantalla semuestre. 47

Una actividad es una pantalla en la que pueden aparecer elementos visuales en ella. Además,cada uno de ellos debe ser un objeto que herede de la clase View. Estos elementos visuales puedenser definidos mediante código o a través de ficheros XML (recomendado). La segunda forma se lleva a cabo mediante el siguiente código:@Overridepublic void onCreate(Bundle icicle) { //... //Initialize screen super.onCreate(icicle); setContentView(R.layout.main);} En este caso, este es el comienzo del onCreate() en el que se mostrará la lista expandible conlas funciones del SWADroid agrupadas por categorías siguiendo el mismo esquema definido porSWAD. Antes de llevar a cabo una acción con un elemento visual, debe llamarse al método de laclase superior. Como en este caso se desea que la apariencia visual se lea desde un fichero XML, sellama al método que toma un contenido visual y, a través de clase R.java explicada anteriormente,se accede al XML que se desea mostrar. La clase que se desee 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 sedefinan, un ListActivity, que muestra elementos en forma de lista y sus correspondientes métodospara tratarla, o MapActivity, proporcionada por un API de Google. También se pueden reutilizar lasActivities ya creadas anteriormente en SWADroid. 49

7.4.2. Intent La mejor forma de definir la clase Intent es como un nexo de unión. Su uso más frecuente esllamar a una Activity desde otra, o para realizar una acción en una actividad. Esta clase permite que el programador se despreocupe del flujo de datos de su aplicación, yaque 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. La clase Intent también se encarga de controlar a qué actividad se debe regresar cuando sepulse el botón del dispositivo para volver atrás. Si es necesario, se podría realizar un control de flujode datos a través de todos los métodos que definen el ciclo de vida. En esta línea de código se muestra cómo pasar de la actividad que lista los clientes a laactividad que muestra el menú del cliente que se ha seleccionado. Simplemente debe construirse unobjeto de clase Intent cuyos parámetros sean el contexto de la aplicación y la clase de la actividadque se desea llamar:Intent activity = new Intent(getBaseContext(), Notifications.class);startActivityForResult(activity, Global.NOTIFICATIONS_REQUEST_CODE);En este ejemplo, se abre la ventana correspondiente a la función Notificaciones. ConstartActivityForResult() la actividad llamante a la espera de que la nueva actividad finalice y se leasigna un identificador. En la clase Notifications se puede asociar un resultado de ejecucióncorrecto con las siguientes líneas de código: setResult(RESULT_OK); finish();Cuando se desee cerrar una clase Activity se puede llamar al método finish(). Antes de hacerlo sepuede indicar el resultado de la acción de la actividad. Si la actividad ha realizado su tareacorrectamente se puede llamar dentro de ella al método setResult(RESULT_OK) para informar a laactividad llamante; en otro caso se puede llamar al método setResult(RESULT_CANCELED). RESULT_OK es una constante que pertenece a la clase Activity. Intent podría considerarse un nexo de unión y un modo de realizar acciones en eldispositivo. No sirve exclusivamente para pasar de una actividad a otra, sino que, como se muestraen este ejemplo, también sirve para lanzar acciones que el dispositivo móvil lleva integradas, comopor ejemplo realizar una llamada. En este caso, al crear el Intent es necesario indicarle el número alque se desea llamar: Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + numeroTel)); startActivity(intent); 50

7.4.3. View Todo objeto que se desee mostrar por pantalla debe heredar de la clase View. Se puedendefinir clases propias que hereden de View, o usar las que proporciona el API de Android. Losobjetos View se pueden organizar y ordenar dentro de objetos de clase Layout. Con un Layout, porejemplo, se puede definir que los componentes se agreguen de manera horizontal o vertical en unalínea. También es posible definirlos en un formato de tabla controlando las posiciones en columnasy 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, por lo que es posible usar tantos elementoscomo se desee, combinándolos o introduciendo unos dentro de otros. Otra forma de organizar losobjetos de clase View es utilizar ViewGroups, que también pueden contener Layouts si se desea.Estos son los más comunes: • 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 se desea que el scroll se realice sobre varios Views estos deberán estar dentro de un ViewGroup o Layout, que será incluido dentro del ScrollView. Los objetos más utilizados de clase View son: • Button: elemento que muestra 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 del mismo. 51

• 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 construiraplicaciones bastante complejas. Se pueden resumir de la siguiente manera: una Activity es unaventana que se muestra por pantalla, todo lo que se desee incluir en la pantalla debe que serdescendiente de View o agrupaciones de estos objetos como Layouts y ViewGroups. Por último, losIntent 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 ensegundo plano. Es decir, es una actividad en background que se puede ejecutar de forma indefiniday que no mostrará nada por pantalla durante su ejecución. 52

7.5. Crear una pantalla de configuración El programador tiene dos opciones para crear una pantalla de configuración. En primer lugarpuede crearla a su gusto como una actividad más y almacenar los datos como desee. En segundolugar, la API ofrece una forma de construir esta ventana de forma automática y mostrando unaapariencia similar a la de todas las ventanas de configuración del dispositivo. Otra de las ventajas de esta última opción es que el programador no debe preocuparse por elalmacenamiento y recuperación de datos, ya que esta opción se encarga de ello de forma automáticay transparente al programador cada vez que se abre la ventana de configuración. No obstante, sepuede seguir teniendo acceso a estos datos y manejar esta pantalla como una actividad más. Son necesarios dos archivos, un archivo XML en la carpeta Res en el subdirectorio que sedesee y con cualquier nombre y otro en la carpeta SRC junto con el resto de las clases Activity,aunque que en este caso la clase heredará de PreferenceActivity en lugar de Activity. En SWADroid se ha creado el archivo preferences.xml en el directorio Res/xml/. Sucontenido es el siguiente:<?xml version="1.0" encoding="UTF-8"?><PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"> <PreferenceCategory android:title="@string/user_preferences"> <EditTextPreference android:name="@string/userIDName_preferences" android:hint="@string/userIDSummary_preferences" android:defaultValue="" android:title="@string/userIDTitle_preferences" android:key="userIDPref" /> <EditTextPreference android:name="@string/userPasswordName_preferences" android:hint="@string/userPasswordSummary_preferences" android:defaultValue="" android:title="@string/userPasswordTitle_preferences" android:key="userPasswordPref" android:password="true" /> </PreferenceCategory> <PreferenceCategory android:title="@string/about_preferences"> <Preference android:hint="" android:defaultValue="" android:selectable="false" android:title="@string/versionTitle_preferences" android:key="currentVersionPref" /> <Preference android:summary="@string/author_preferences" android:defaultValue="" android:selectable="false" android:title="@string/organization_preferences"/> </PreferenceCategory></PreferenceScreen> Este código puede ser construido con el editor gráfico que proporciona Eclipse. Acontinuación se listan los elementos que pueden aparecer en este archivo, que son muy parecidos a 53

los View mencionados anteriormente: • PreferenceScreen: similar al Layout pero, para la ventana de configuración, puede agrupar otros objetos. • PreferenceCategory: permite dividir la ventana en submenús, es otro objeto contenedor. • CheckBoxPreference: similar al CheckBox, solo que en este caso cuenta con un texto y un texto explicativo. • EditTextPreference: tiene un título y un texto explicativo, y cuando se pulsa aparece una ventana de diálogo con un campo para editar texto. • ListPreference: similar al Spinner, pero con título y texto descriptivo. • Preference: el Preference más básico, se le puede asociar título y descripción y la acción que se desee. En este caso cuando se le hace clic nos lleva a otra pantalla. A continuación se observa el resultado del fichero XML presentado anteriormente. Una vez terminado el fichero XML es necesario crear una clase que herede dePreferenceActivity para mostrarla por pantalla, esta clase puede implementar el resto de métodos yacciones que se han descrito hasta ahora y deberá declararse en el archivo de manifiesto. 54

Una diferencia con respecto a las actividades descritas anteriormente es la forma de accederal XML. En un ejemplo anterior, se explicó como asociar un fichero que define una interfaz a unaactividad. En este caso la forma de asociar actividad e interfaz es la siguiente:public class Preferences extends PreferenceActivity implementsOnPreferenceChangeListener { /** * Application preferences */ private SharedPreferences prefs; /** * User identifier. */ private String userID; /** * User identifier preference name. */ private static final String USERIDPREF = "userIDPref"; /** * User password. */ private String userPassword; /** * User password preference name. */ private static final String USERPASSWORDPREF = "userPasswordPref"; /** * Last application version */ private int lastVersion; /** * Last course selected */ private int lastCourseSelected; /** * Last application version preference name. */ private static final String LASTVERSIONPREF = "lastVersionPref"; /** * Current application version preference name. */ private static final String CURRENTVERSIONPREF = "currentVersionPref"; /** * Last course selected preference name. */ private static final String LASTCOURSESELECTEDPREF ="lastCourseSelectedPref"; /** * User ID preference */ private Preference userIDPref; /** * User password preference */ private Preference userPasswordPref; /** * Current application version preference */ private Preference currentVersionPref; 55

/** * Preferences editor */Editor editor;/** * Gets user identifier. * @return User identifier. */public String getUserID() { return userID;}/** * Gets User password. * @return User password. */public String getUserPassword() { return userPassword;} /** * Gets last application version * * @return returns last application version */ public int getLastVersion() { return lastVersion; } /** * Sets last application version */ public void setLastVersion(int lv) { lastVersion = lv; editor = prefs.edit(); editor.putInt(LASTVERSIONPREF, lv); editor.commit(); } /** * Gets last course selected * @return Last course selected */ public int getLastCourseSelected() { return lastCourseSelected; } /** * Sets last course selected * @param lastCourseSelected Last course selected */ public void setLastCourseSelected(int lcs) { lastCourseSelected = lcs; editor = prefs.edit(); editor.putInt(LASTCOURSESELECTEDPREF, lcs); editor.commit(); } private String getStarsSequence(int size) 56

{ String stars = ""; for(int i=0; i<size; i++) { stars += "*"; } return stars; } /** * Initializes preferences of activity. * @param ctx Context of activity. */ public void getPreferences(Context ctx) { // Get the preferences prefs = PreferenceManager.getDefaultSharedPreferences(ctx); userID = prefs.getString(USERIDPREF, ""); userPassword = prefs.getString(USERPASSWORDPREF, ""); lastVersion = prefs.getInt(LASTVERSIONPREF, 0); lastCourseSelected = prefs.getInt(LASTCOURSESELECTEDPREF, 0); } /* (non-Javadoc) * @see android.app.Activity#onCreate() */ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); //Restore preferences addPreferencesFromResource(R.xml.preferences); prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext()); userID = prefs.getString(USERIDPREF, ""); userPassword = prefs.getString(USERPASSWORDPREF, ""); lastVersion = prefs.getInt(LASTVERSIONPREF, 0); lastCourseSelected = prefs.getInt(LASTCOURSESELECTEDPREF, 0); editor = prefs.edit(); userIDPref = findPreference(USERIDPREF); userPasswordPref = findPreference(USERPASSWORDPREF); currentVersionPref = findPreference(CURRENTVERSIONPREF); userIDPref.setOnPreferenceChangeListener(this); userPasswordPref.setOnPreferenceChangeListener(this); userIDPref.setOnPreferenceClickListener(new OnPreferenceClickListener(){ /** * Called when a preference is selected. * @param preference Preference selected. */ public boolean onPreferenceClick(Preference preference) { userID = prefs.getString(USERIDPREF, ""); editor.putString(USERIDPREF, userID); return true; } 57

}); userPasswordPref.setOnPreferenceClickListener(newOnPreferenceClickListener() { /** * Called when a preference is selected. * @param preference Preference selected. */ public boolean onPreferenceClick(Preference preference) { userPassword = prefs.getString(USERPASSWORDPREF, ""); editor.putString(USERPASSWORDPREF, userPassword); return true; } }); try {currentVersionPref.setSummary(getPackageManager().getPackageInfo(getPackageName(), 0).versionName); } catch (NameNotFoundException e) { e.printStackTrace(); } } public boolean onPreferenceChange(Preference preference, Object newValue){ String key = preference.getKey(); Notifications n = new Notifications(); //If preferences have changed, logout and save new preferences if (USERIDPREF.equals(key) || USERPASSWORDPREF.equals(key)) { Global.setLogged(false); n.clearNotifications(this); editor.commit(); } if(USERPASSWORDPREF.equals(key)) { String stars = getStarsSequence(((String) newValue).length()); preference.setSummary(stars); } else { preference.setSummary((CharSequence) newValue); } return true; } /* (non-Javadoc) * @see android.app.Activity#onResume() */ @Override protected void onResume() { super.onResume(); String stars = getStarsSequence(prefs.getString(USERPASSWORDPREF,"").length()); userIDPref.setSummary(prefs.getString(USERIDPREF, "")); userPasswordPref.setSummary(stars); } 58

@Override protected void onPause() { super.onPause(); editor.putInt(LASTVERSIONPREF, lastVersion); editor.putInt(LASTCOURSESELECTEDPREF, lastCourseSelected); editor.commit(); }} Con las dos primeras líneas del método onCreate() sería suficiente para que la pantalla deconfiguración se muestre y gestione los datos de forma automática. Pero como se puede observar enel código, es posible acceder también a los objetos definidos en el fichero XML para realizaracciones específicas con ellos a través del método findPreference() al que se le pasa comoargumento el String especificado en el valor key. 59

7.6. Almacenamiento persistente de datos La pantalla de configuración se encarga de almacenar y recuperar automáticamente los datosque en ella se muestran. Si el usuario desea acceder a estos datos o almacenar otros, estas son lasopciones que la API de Android proporciona para el almacenamiento de datos: • Estado de la aplicación: Android proporciona una serie de métodos que permiten guardar estados o el objeto que se desee ante determinados eventos, como el cambio de orientación de la pantalla. • Ficheros: permite la escritura y lectura de ficheros, tanto en el directorio en el que se encuentra instalada la aplicación, como en la tarjeta de memoria. • Bases de datos: cuando los datos a almacenar son abundantes o siguen una estructura más compleja se cuenta con la opción de construir una base de datos SQL a través de la librería SQLite. • SharedPreferences: permite crear archivos en los que almacenan datos en la forma atributo/valor. Los archivos de preferencias son idóneos cuando se tienen que almacenar sólo unos pocosdatos y con estructuras sencillas. Además, permite distintos niveles de seguridad, desde modopúblico en el que otras aplicaciones pueden acceder a estos datos (que no es público en si, ya que elprogramador de la aplicación debe conocer el sistema de directorios creado por la otra aplicaciónasí como el nombre del fichero de preferencias y cada atributo para acceder a los datos) a modoprivado en el que sólo la aplicación que lo ha creado tiene acceso. Los datos se almacenan de la forma atributo/valor. La forma de trabajar es similar a la de unHashMap, pero SharedPreferences genera un archivo XML. Se muestran dos formas de acceder aun archivo de preferencias: la primera es acceder al archivo de preferencias que la aplicación tieneasociado por defecto; es decir, el que ha creado automáticamente la ventana de configuración. Elsegundo es crear archivos propios. Este es el código para cada caso: • Archivo de configuración creado automáticamente PreferenceManager.setDefaultValues(context, R.xml.preferences, false); SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context); context es un objeto de la clase Context, que generalmente es la actividad que ejecuta el método. Cuando la clase hereda de Activity, context es NombreClase.this como se ha visto en la creación de los Intent. • Archivo creado por el programador SharedPreferences preferencias = getSharedPreferences(String nombre, Context.MODE_PRIVATE); En este ejemplo se accede al fichero de preferencias cuyo nombre sea el valor del primer atributo. En caso de no existir, se creará en ese momento con el grado de privacidad especificado en el segundo atributo. 60

Una vez se tiene el objeto de preferencias, accediéndose de una manera o de otra, la formade obtener sus datos es la siguiente: //SI NO EXISTE LA ENTRADA DEVUELVE EL VALOR DEL SEGUNDO CAMPO String s = preferences.getString(String nombreAtributo, null); Este método devolverá el valor asociado al atributo del archivo de preferencias cuyo nombrees pasado como primer argumento. En caso de que este atributo no exista devolverá el valor pasadocomo segundo argumento. Los objetos de preferencias no sólo trabajan con Strings. Se pueden almacenar y recuperar elresto de tipos básicos: boolean( getBoolean() ), int ( getInt() ), float ( getFloat() )... Si se desea añadir o modificar el valor de un atributo, el código es: Editor editor = preferences.edit(); editor.putString(String atributo, String valor); editor.commit(); 61

7.7. Comprobar estado de la conexión Un aspecto importante para una aplicación que va a acceder a Internet es conocer si existeuna conexión disponible antes de intentar conectar con el servidor. La comprobación del estado de la conexión se realiza cada vez que SWADroid necesitaacceder a la red y, si no se dispone de ningún tipo de acceso a Internet (Wi-Fi o red móvil),SWADroid mostrará un mensaje para informar al usuario de que no existe ninguna conexióndisponible. Para poder realizar la comprobación lo es necesario añadir el siguiente permiso en elarchivo de manifiesto:<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission> La API proporciona la clase ConnectivityManager, que permite, entre otras cosas,comprobar el estado de los distintos tipos de conexión. Un teléfono puede disponer de varios tiposde conexión según su modelo; en este caso se comprueba la conexión a cualquiera de los dos tiposde conexión de que dispone cualquier dispositivo Android. En SWADroid el código encargado deesta tarea es:public static boolean connectionAvailable(Context ctx){ boolean connAvailable = false; ConnectivityManager connec =(ConnectivityManager)ctx.getSystemService(Context.CONNECTIVITY_SERVICE); //Survey all networks (wifi, gprs...) NetworkInfo[] networks = connec.getAllNetworkInfo(); for(int i=0; i<2; i++){ //If any of them has a connection available, put boolean to true if (networks[i].isConnected()){ connAvailable = true; } } //If boolean remains false there is no connection available return connAvailable;} En este caso el parámetro pasado al método connectionAvailable(ctx) es un objeto de la claseContext porque el método no está definido en una clase Activity, por lo que no puede ejecutar elmétodo getSystemService(). Cada actividad que necesite comprobar la conexión llama a este método pasando comoargumento NombreClase.this. 62

7.8. Evitar el reinicio de la actividad por cambio de orientación de lapantalla Cuando el movimiento del dispositivo móvil provoca un cambio de orientación de lapantalla, el sistema destruye la actividad actual y la vuelve a crear llamando de nuevo al métodoonCreate(). Este comportamiento provoca que la actividad vuelva a su estado inicial. Si el usuario está leyendo las últimas notificaciones descargadas o realizando un test deautoevaluación y se produce un cambio de orientación en la pantalla, esta forma de actuar forzará ala actividad en cuestión a comenzar desde el principio perjudicando la experiencia del usuario. Para evitar este problema se puede actuar de dos maneras distintas: • Deshabilitar el cambio de orientación forzando a la aplicación a mantener siempre la misma orientación sobrecargando el método onConfigurationChanged(): @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); } • Deshabilitar el reinicio de la actividad añadiendo los atributos apropiados a su declaración en el fichero AndroidManifest.xml (método utilizado por SWADroid):<activity android:name=".modules.Login" android:label="@string/loginModuleLabel" android:configChanges="keyboard|keyboardHidden|orientation" android:theme="@android:style/Theme.Translucent.NoTitleBar"></activity> 63

7.9. Creación de interfaces Hay dos opciones para construir una interfaz en Android, definiéndola mediante código en lapropia actividad o generándola en un fichero XML y accediendo a ella en el método onCreate().También se puede realizar una combinación de las dos opciones, creando ciertos elementos queserán fijos en el fichero XML y añadiendo otros mediante código cuando sea necesario. Se muestra un ejemplo para la ventana de selección de tipos de respuesta del módulo detests. De esta forma se muestran los dos casos: la creación de un elemento visual mediante XML ysu acceso desde código, y también la creación de elementos visuales desde código así como laforma de añadirlos para mostrarlos por pantalla. En el fichero tests_make_questions.xml se define,entre otras cosas, un ListView con las siguientes características:<ListView android:id="@+id/testMakeList" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_below="@+id/testMakeStem" android:layout_above="@+id/testMakeBottomBar" android:background="@android:color/transparent" android:cacheColorHint="@color/background" android:visibility="gone"></ListView> Se muestra el código que define la lista para mostrar todas las posibles respuestas de unapregunta de un test de autoevaluación. Esta lista está inicialmente oculta en el interfaz gráfico, yaque sólo es utilizada por algunos tipos de respuestas. Para modificarla en el código es necesarioacceder a ella mediante su identificador de la siguiente manera: ListView testMakeList = (ListView) findViewById(R.id.testMakeList); Una vez se ha instanciado el objeto de tipo ListView, se utiliza un bucle en el que en cadaiteración se lea una respuesta y se añada una fila con la información leída al final de la iteración. Acontinuación se muestra el código que crea la lista de respuestas para el tipo de respuesta deelección mútiple:checkedAnswersAdapter = new CheckedAnswersArrayAdapter(this,R.layout.list_item_multiple_choice,answers, test.isEvaluated(), test.getFeedback(), answerType);testMakeList.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);testMakeList.setAdapter(checkedAnswersAdapter);for(int i=0; i<numAnswers; i++) { a = answers.get(i); testMakeList.setItemChecked(i, Global.parseStringBool(a.getUserAnswer()));}testMakeList.setVisibility(View.VISIBLE); 64

CheckedAnswersArrayAdapter es una clase del tipo conocido como Adaptador (Adapter).Estos adaptadores se encargan de leer una colección de datos desde una lista o desde el cursor deuna base de datos y mostrarlos por pantalla según el formato especificado por el ficherolist_item_multiple_choice.xml para cada elemento del objeto ListView. El método setChoiceMode()le indica a ListView que establezca el método de selección múltiple para sus elementos. El métodosetItemChecked() establece un elemento de ListView como marcado o desmarcado según el valor delos atributos pasados como parámetros. El inconveniente tanto de crear interfaces por código como de hacerlo en el fichero XML esque no es posible ver su apariencia final hasta que no se ejecuta la aplicación. Para subsanar esteproblema Eclipse cuenta con un editor visual de interfaces con el que, a través de una interfazvisual, se pueden añadir elementos y darle valor a sus atributos. Además de mostrar el aspecto de laventana en tiempo de ejecución, esta interfaz visual también se encarga de generar el fichero XMLcorrespondiente. Otras de las opciones existentes en la creación de interfaces gráficos es la creación de vistaspropias. Esto es, definir clases que hereden de la clase View e implementarlas a medida delprogramador para posteriormente añadirlas por código como cualquier otro elemento predefinidodel interfaz gráfico. 65

8. Android en Eclipse IDE Este entorno de desarrollo permite la creación, edición y ejecución de proyectos Android deforma cómoda y sencilla. El plugin de Android para Eclipse permite otras opciones como el acceso al AVD Managerque se utiliza principalmente para crear dispositivos virtuales. 8.1. Creación de un proyecto Android La creación de este tipo de proyecto es muy similar a la de un proyecto Java habitual. Laúnica diferencia son algunos de los valores que deben introducirse en el último paso de la creación. Para crear un proyecto Android, una vez está abierto Eclipse debe pulsarse File → New →Project. Si ya está instalado todo correctamente deberá aparecer un directorio llamado Androiddentro de la jerarquía de opciones. Se despliega esta carpeta y se selecciona la opción AndroidProject. Esta acción llevará a la siguiente pantalla con los datos necesarios ya completados. Los datos que se deben introducir son los siguientes: • Project name: aquí se introduce el nombre que se le quiera dar a la carpeta que creará Eclipse en el workspace para identificar el proyecto. Este nombre puede contener espacios. • Build Target: en este recuadro aparece un listado con todas las versiones del SDK que se encuentren instaladas. Se debe seleccionar aquella para la que se desee implementar la aplicación teniendo en cuenta que, a mayor número de versión, más posibilidades e incluso nuevas clases a nuestra disposición. Sin embargo, en las versiones anteriores a la seleccionada no se podrá ejecutar la aplicación. Si este listado estuviera vacío, significa que alguno de los pasos explicados en el apartado Especificaciones técnicas no se ha ejecutado correctamente, por lo que debe revisarse en profundidad el mencionado apartado para solucionar el problema. • Properties: aquí deben introducirse datos relacionados con la aplicación y su identificación posterior dentro del dispositivo. 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. 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. • Create Activity: al seleccionar esta opción se debe establecer qué nombre darle a la actividad. Dentro del Package name establecido se creará una clase Java que hereda de Activity, asociada a main.xml (que inicialmente contiene un “Hello World”) de la carpeta Res/layout, que también genera automáticamente si se activa esta opción. También declarará esta clase en el archivo de manifiesto y le asignará los atributos necesarios para mostrarla al iniciar la aplicación. 66

8.2. Ejecución de un proyecto La forma de ejecutar un proyecto Android es similar a la de cualquier proyecto Java enEclipse. Para ello, sobre el nombre del proyecto se hace clic derecho con el ratón y dentro de lasopciones se selecciona Run as → Android Application. Si se han creado varios dispositivos virtuales y ninguno de ellos está abierto, seleccionará elprimero de ellos que sea compatible para poder ejecutarse. Si ya está abierto uno que seacompatible, se ejecutará en éste; en caso contrario se abrirá uno en el que se pueda ejecutar. En casode tener varios abiertos y que más de uno sea compatible con los requerimientos de la aplicación,mostrará una ventana para seleccionar en cuál de ellos ejecutar la aplicación. Si, por el contrario, noexiste ninguno en la aplicación que se pueda ejecutar, preguntará si se desea crear uno. 69

8.3. Modificación de las características del proyecto Es posible que consultando algún manual se encuentre determinado método o clase del SDKde Android que convenga utilizar y, al usarlo en el proyecto, no se permita. Tras comprobar que seha escrito el código correctamente y realizado todos los pasos que indica el manual, si el errorpersiste es probable que se deba a que dicha clase o método pertenezca a una versión superior a lautilizada en el proyecto. Si por este motivo o cualquier otro se desea cambiar la versión de SDK que se seleccionódurante la creación del proyecto, ésta puede ser cambiada en cualquier momento. Para ello se haceclic derecho sobre el proyecto y se selecciona Properties. Esta acción mostrará la siguiente ventana. Si lo que se desea es cambiar el nombre de la aplicación, la versión mínima del SDK dondepodrá ejecutarse, o el nombre del sistema de directorios, cualquiera de estas características semodifican directamente en el archivo AndroidManifest.xml. 70

8.4. Creación de interfaces gráficas Cada vez que se abre un fichero de la carpeta Res/layout aparece la siguiente ventana. Enella se puede alternar entre dos vistas. Si se pulsa en tests_make_main.xml aparece la interfaz enformato texto, y si se pulsa en Layout aparece la ventana que se ve en la imagen. En la parte izquierda aparecen todos los componentes que se pueden añadir a la interfazagrupados según su tipo. Para añadir cualquiera de ellos debe arrastrarse en la imagen sobre el Layout al que se deseeasignarlo. En la parte derecha aparece la jerarquía actual de componentes visuales para este archivo,que puede ocultar y desplegar el contenido de cada Layout. Si existen varios, en vez de arrastrar elobjeto sobre el sobre el que se desea añadirlo, es mucho más cómodo seleccionar en esta jerarquíaaquel contenedor en el que se quiera añadirlo y, haciendo clic derecho sobre él, seleccionar Add.Esta acción mostrará un listado de todo lo que se puede añadir al contenedor y permitirá seleccionarel componente deseado. En ambos casos el nuevo componente se posicionará según lascaracterísticas definidas del Layout en el que se introduce. Cada vez que se selecciona un componente del listado de la ventana derecha, en la parteinferior de la pantalla aparece su ventana de propiedades. En esta ventana se pueden modificar susatributos, que hacen referencia a opciones de visualización del propio elemento y a opciones devisualización de los elementos que contiene. En caso de cometer algún error con este editor visual y se quiera deshacer el mismo, esnecesario pasar a la vista de texto sin cerrar la ventana. Si marcase un error y la vista de Layout nomostrara nada, accediendo a la vista de texto el error aparecerá marcado con una breve descripciónen la línea que lo produce. Una vez corregidos todos los errores, todo volverá a mostrarsecorrectamente al acceder a la vista Layout. 71

Otra limitación de la vista de Layout es la reorganización de componentes. Aunque semuestre un listado de la jerarquía actual, ésta no puede ser reordenada desde aquí. Las únicasmodificaciones posibles son de las propiedades de cada elemento por separado. Puesto que el ordende aparición en pantalla es conforme a su aparición en esta jerarquía, si se desea modificar el ordende visualización debe hacerse copiando y pegando en la vista de texto hasta que quede organizadocomo se desea. 72

8.5. Generar instalador Este paso es muy similar a generar un archivo .jar con Eclipse cuando éste es un proyecto deJava. Aunque Android utiliza el lenguaje Java, sus aplicaciones no son aplicaciones Java. En este caso el instalador es un archivo con extensión .apk (Android package), que debeestar firmado digitalmente para poder ser instalado en un dispositivo. El certificado de firmas puedeser self-signed; es decir, no es necesario obtener un certificado digital de una entidad certificadoracomo Verisign, sino que es posible generar un certificado propio mediante el siguiente comando deJava:keytool –genkey -v -keystore rutaAbsolutaKeystore -alias androidFirma -storepasspassword -keypass password -keyalg RSA -validity 14000 Donde los campos pertinentes son: • keystore: ruta donde se desea almacenar el keystore. • alias: nombre identificador que servirá para referirse a las claves creadas. • storepass: la clave para acceder al contenido del keystore. • keypass: la clave para acceder posteriormente al alias. • 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 menoshasta el 22 de octubre de 2033. Esta acción solicitará una serie de datos personales que asociará alalias que acaba de crear el keystore y que servirá para que, una vez firmado el instalador,posteriormente pueda asociarse de forma unívoca a esta información y no se pueda suplantar laidentidad del desarrollador. 73

Para un keystore se pueden añadir tantos alias como se deseen repitiendo este comando. Unavez generado 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. Haciendo clic derecho sobre el proyecto de entre las opciones disponibles se seleccionaAndroid Tools. Se despliegan varias opciones, entre las cuales se encuentra Export UnsignedApplication Package, con la que sólo es necesario dar un nombre al archivo .apk y una ruta en laque almacenarlo. Sin embargo, es más interesante usar la opción Export Signed ApplicationPackage porque genera el paquete ya firmado. En la primera ventana se selecciona el proyecto Android que se desea firmar. Por defectoaparece el proyecto sobre el que se ha hecho clic, por lo que se puede pulsar directamente en next.En la siguiente ventana se debe establecer la ruta del fichero de claves generado anteriormente y sucontraseña de paso (valores dados en la línea de comando a -keystore y -storepass) y pulsar next. Si la contraseña es correcta se podrá seleccionar en la pestaña alias el identificador con elque se desee firmar. En caso de que sólo exista uno, aparecerá seleccionado por defecto y sólo seránecesario indicar la contraseña asociada a este alias (valor de -keypass) y pulsar de nuevo next. Siesta última contraseña es incorrecta mostrará un error en la siguiente ventana. Si todo va bien sepedirá el nombre y la ruta para guardar el archivo .apk, que desde este momento puede ser instaladoen un dispositivo móvil. 74

8.6. Descargar proyectos de ejemplo La página oficial de Android ofrece una gran cantidad de proyectos Eclipse de aplicacionesAndroid que pueden ser consultados online para ver su código fuente o descargarlos para podermodificarlos y ejecutarlos. La descarga puede realizarse automáticamente desde Eclipse de la siguiente manera: • Abrir el AVD Manager: desde el botón en la barra de tareas de Eclipse o en el directorio en el que está instalado el SDK. • En el panel se selecciona Available packages, en el desplegable se indican los paquetes que se deseen y cuyo nombre empiece por Samples for SDK y se pulsa Install Selected. • En la siguiente ventana se acepta la licencia y comenzará la descarga. Esta acción creará en el directorio en el que se encuentre instalado el SDK un carpeta denombre Samples donde estarán todos los proyectos descargados. Es una colección bastantecompleta en la que se incluyen aplicaciones tales como una agenda, un juego, chat a través deBluetooth.... y una aplicación llamada ApiDemos existente para varias versiones del SDK quemuestra muchas opciones sobre lo que se puede realizar y cómo hacerlo. Es muy recomendableejecutar esta aplicación y dedicarle tiempo si es la primera vez que se va a desarrollar para Android,puesto que puede dar muchas ideas sobre cómo diseñar el interfaz gráfico y qué se puede hacer. Para abrir cualquiera de estos proyectos desde Eclipse debe hacerse lo siguiente: File → New → Project → Android Project En la ventana que aparece después de realizar esta acción se selecciona la opción Createproject from existing source y se establece la ruta de cualquiera de los proyectos de ejemplodescargados. 75

9. Creación de un repositorio en la forja GitHub SWADroid utiliza el sistema de control de versiones Git, desarrollado por los creadores deGNU/Linux, y mantiene su código fuente en un repositorio público alojado en la forja GitHub(https://github.com/). Para crear un repositorio en la forja GitHub se deben seguir estos pasos (también detalladosen la ayuda online de GitHub): 9.1. Configurar Git 1. Descargar e instalar la última versión de Git desde un gestor de paquetes 76

O desde la terminal: $ sudo apt-get install git-core git-gui git-doc 2. Generar las claves SSH GitHub utiliza claves SSH para establecer una conexión segura entre el ordenador deldesarrollador y el servidor. La generación de estas claves es muy sencilla: a) Comprobar si ya existe una clave SSH en el ordenador $ cd ~/.ssh Si el directorio .ssh no existe, ir al paso c), en otro caso, ir al paso b). b) Realizar una copia de seguridad y eliminar las claves SSH existentes $ ls config id_rsa id_rsa.pub known_hosts $ mkdir key_backup $ cp id_rsa* key_backup $ rm id_rsa* c) Generar una nueva clave SSH ssh-keygen -t rsa -C "your_email@youremail.com" Generating public/private rsa key pair. Enter file in which to save the key (/Users/your_user_directory/.ssh/id_rsa):<press enter> Enter passphrase (empty for no passphrase):<enter a passphrase> Enter same passphrase again:<enter passphrase again> d) Añadir la clave SSH a GitHub En la página web de GitHub pulsar en Account Settings > SSH Public Keys > Addanother public key . Abrir el fichero id_rsa.pub con un editor de texto (Notepad, TextEdit, o gedit).Este fichero contiene la clave pública SSH. Es posible que sea necesario activar la opción verficheros ocultos para encontrarlo porque el directorio .ssh está oculto. Es importante copiar la claveSSH de forma exacta, sin añadir espacios ni retornos de carro. Por último, copiar la clave en elcampo Key y pulsar Add key. 78

3. Configurar la información del desarrollador a) Configurar el nombre de usuario y el email Git lleva a cabo un seguimiento sobre quién realiza cada commit comprobando el nombre deusuario y su email. Además, GitHub utiliza esta información para asociar los commits con la cuentade GitHub. Para configurar este aspecto es necesario ejecutar el siguiente código reemplazando elnombre de usuario y email por sus respectivos valores. El nombre debe ser el nombre real deldesarrollador, no el nombre de la cuenta GitHub. $ git config --global user.name "Firstname Lastname" $ git config --global user.email "your_email@youremail.com" b) Configurar el token GitHub Algunas herramientas se conectan a GitHub sin utilizar SSH. Para poder utilizarlascorrectamente es necesario configurar un API Token. En la página web de GitHub pulsar AccountSettings > Account Admin En la línea de comandos ejecutar el siguiente código utilizando el nombre de usuario GitHuby el token apropiados: $ git config --global github.user username $ git config --global github.token 0123456789yourf0123456789token NOTA: Si se cambia la contraseña de GitHub se creará un nuevo token y será necesariorepetir estos pasos. 79

9.2. Crear un repositorio en GitHub1. Crear un repositorioPulsar New Repository, rellenar los campos del formulario y pulsar Create Repository.2. Crear un fichero README a) Crear el fichero README $ mkdir ~/Hello-World $ cd ~/Hello-World $ git init Initialized empty Git repository in /Users/your_user_directory/Hello-World/.git/ $ touch README 80

b) Realizar un commit del fichero README $ git add README $ git commit -m first commit El código anterior ejecuta acciones de forma local, es decir, que aún no se han reflejado enGitHub. Para conectar el repositorio local con la cuenta GitHub es necesario configurar unrepositorio remoto y realizar acciones push sobre él: $ git remote add origin git@github.com:username/Hello-World.git $ git push origin master 81

10. Publicación en Android Market 10.1. Información general Android Market permite a los desarrolladores distribuir aplicaciones entre los usuarios deAndroid de una forma sencilla. A continuación, se indican algunas de las características principalesde Android Market. • Apertura: cualquier desarrollador puede utilizar libremente Android Market. • Sencillez: utilizar de Android Market mediante 3 sencillos pasos (registro, subida y publicación). • Comunidad: los usuarios de Android pueden puntuar y comentar las aplicaciones. • Preferencia: se pueden distribuir aplicaciones tanto gratuitas como de pago. • Administración: los desarrolladores pueden administrar la cartera de aplicaciones y ver las descargas, las puntuaciones y los comentarios. 10.2. Registro Para poder distribuir productos en Android Market es necesario registrarse. Se debe pagaruna cuota de inscripción única de 25 dólares. El objetivo de esta cuota es incentivar la entrada deproductos de alta calidad en el mercado (y reducir, por ejemplo, los productos no deseados). A diferencia de Apple, que cobra 100 dólares por año, Android Market cobra 25 una sola vezdurante el registro de una cuenta de desarrollador, pero es necesario disponer de una cuenta GoogleCheckout. Para completar el registro, es necesario agregar un nombre de desarrollador (puede ser unnombre personal, que se puede cambiar más adelante). 82

10.3. Subida de una aplicación Subir aplicaciones a Android Market es muy fácil una vez que se ha completado el registro.En la pantalla principal de la consola para desarrolladores(http://market.android.com/publish), se selecciona Subir aplicaciones. Será necesario quecompletar la información de la aplicación indicada a continuación: Subir recursos • Tamaño de archivo APK: el tamaño máximo admitido es 50 MB. • Borrador de archivo .apk de aplicación: al subir un archivo .apk, se puede guardar como un borrador mientras editas el resto de aspectos de la lista. NOTA: Los nombres de paquetes de los archivos de aplicaciones son únicos y permanentes, por lo que deben elegirse con cuidado. Los nombres de paquetes no se pueden eliminar ni utilizar en el futuro. • Capturas de pantalla: son necesarias dos capturas de pantalla. Las seis restantes son opcionales. • Icono de aplicación de alta resolución (obligatorio) • Gráfico promocional (opcional) • Gráfico de funciones (opcional) • Vídeo promocional (opcional) 83

Especificación de detalles• Idioma: sirve para indicar el idioma de la aplicación. El idioma predeterminado es el inglés de EE.UU. La lista de idiomas irá aumentando a medida que los dispositivos con la tecnología de Android estén disponibles en más idiomas.• Título: es el nombre de la aplicación tal como aparecerá en Android Market. Se puede añadir un nombre por idioma.• Descripción: es la descripción de la aplicación que se puede consultar en Android Market. La función de traducción puede traducir la descripción de la aplicación a otros idiomas. En este campo, se puede utilizar un máximo de 4.000 caracteres. NOTA: el uso de palabras clave repetitivas e irrelevantes en la descripción promocional, en la descripción o en el título de la aplicación ofrece al usuario una experiencia no deseada y puede derivar en la suspensión de la aplicación.• Cambios recientes: la función de cambios recientes ofrece la oportunidad de añadir notas sobre los cambios específicos de la versión más reciente de la aplicación. El campo de cambios recientes permite informar a los usuarios sobre los cambios que se han realizado en la aplicación.• Texto promocional: es el texto situado junto al gráfico promocional en lugares destacados de Android Market.• Tipo de aplicación: Android Market se divide en dos tipos de aplicaciones principales ("Aplicaciones" y "Juegos").• Categoría: Se debe elegir una categoría para la aplicación. Opciones de publicación• Protección contra copias: la protección contra copias puede contribuir a evitar que se copien las aplicaciones desde un dispositivo. Aumenta la cantidad de memoria necesaria para instalar la aplicación en el teléfono. La protección contra copias quedará obsoleta en breve.• Ubicaciones: son las ubicaciones en las que se pueden distribuir las aplicaciones. • No todas las ubicaciones de la lista actual tienen usuarios con dispositivos con la tecnología de Android. • Se pueden seleccionar las ubicaciones de una en una o elegir la opción Todas las ubicaciones actuales y futuras. Esta opción significa que se habilitarán más ubicaciones de distribución a medida que Android Market las vaya habilitando para la aplicación. 84

Información de contacto• Se debe elegir un canal de asistencia para la aplicación: sitio web, correo electrónico o teléfono.• Los usuarios de Android Market verán esta información.• Se puede elegir más de un canal de asistencia. Una vez realizados los pasos anteriores se publica la aplicación pulsando en Publicar. 85

11. Futuras mejoras Lejos de considerarse un producto acabado, SWADroid es un proyecto en constanteevolución sobre el que se han planificado diversas mejoras y ampliaciones. Entre ellas se puedendestacar la traducción de SWADroid a otros idiomas que aún no estén disponibles, la revisión deldiseño de la interfaz gráfica y la implementación de nuevas funciones de acceso a SWAD. Funcionalidades futuras: • Escribir y responder mensajes • Consultar calificaciones • Escribir avisos • Descargar documentos • Enviar trabajos • Ver listas de alumnos / profesores • Ver ficha de alumno • Apuntarse o borrarse de grupos • Leer / escribir en foros • Realizar encuestas • Cambiar datos personales • Enviar estadísticas de uso sobre los tests. Las funcionalidades resaltadas en negrita corresponden a las características cuyaimplementación en SWADroid es prioritaria por ser algunas de las funciones más utilizadas de laplataforma SWAD. Por otra parte, se pretende ampliar y mejorar la infraestructura desplegada para desarrollar ymantener SWADroid y crear una comunidad de usuarios que proporcionen una buenarealimentación a través de sus intervenciones tanto en los comentarios que permite dejar el AndroidMarket como en las redes sociales, en las que SWADroid ya tiene presencia. 86

También se puede crear un blog para informar sobre los progresos en el desarrollo deSWADroid y otra información relevante. Además, sería interesante crear un wiki a modo de manualde uso online que podría incorporarse como sección al wiki ya existente sobre SWAD o crearse deforma autónoma. Asimismo, se pueden estudiar otros protocolos de comunicaciones como REST paraencontrar métodos que permitan una comunicación más eficiente entre SWADroid y SWAD. 87

12. Conclusiones El proyecto ha superado con creces los objetivos básicos que se habían propuesto respetandolas especificaciones planteadas. Se ha desarrollado el núcleo de una aplicación que permite comunicarse e interactuar conSWAD. Su diseño modular permite que la funcionalidad de la aplicación pueda ampliarse de formacómoda, fácil y rápida. Asimismo, se han implementado módulos que permiten acceder a dos de las funciones másutilizadas de SWAD: la consulta de las notificaciones y la descarga y realización de tests deautoevaluación. Estos módulos también sirven de ejemplo para ilustrar el proceso a seguir en eldesarrollo e integración de nuevos módulos para SWADroid. Por otra parte, se ha logrado desplegar una infraestructura que permitirá el mantenimiento yla continuidad del proyecto. Las fases seguidas para la creación y el despliegue de dichainfraestructura se muestran en el siguiente diagrama de Gantt. Desde su publicación en el Android Market en el mes de marzo, SWADroid ha recibidovarios comentarios y puntuaciones que la sitúan entre las aplicaciones mejor valoradas de sucategoría. SWADroid cuenta ya con 398 usuarios activos (hasta el 21/6/2011) y ha comenzado arecibir realimentación en forma de sugerencias y valoraciones por parte de sus usuarios. Asimismo, SWADroid ya está disponible en, al menos, 498 modelos de dispositivosmóviles y en varias versiones del sistema operativo Android. 88

SWADroid también está presente en las principales redes sociales, a través de las quemantiene una comunicación directa con sus usuarios, lo que le permite adaptarse mejor a lasnecesidades de los mismos. SWADroid, como aplicación precursora de la iniciativa La UGR en tu móvil y avanzadilla dela incursión que la Universidad de Granada pretende realizar en el cada vez más pujante mundo delos dispositivos móviles con objeto de hacer que la información y los servicios universitarios seantambién accesibles a través de un dispositivo móvil, ha obtenido repercusión en varios medios, tantodigitales como escritos, dentro y fuera de la Universidad de Granada. Algunos de ellos son lasprincipales páginas web de información de la Universidad y el periódico Ideal de Granada. 91

13. Bibliografía FS Foundation. The GNU General Public License (GPL), pp. 2007. http://www.gnu.org/licenses/gpl.html FS Foundation. The GNU Free Documentation License (FPL), pp. 2008. http://www.gnu.org/licenses/fdl.html Aprendizaje electrónico móvil. Artículo Wikipedia, 2011 http://es.wikipedia.org/wiki/Aprendizaje_electr%C3%B3nico_m%C3%B3vil Mobile Learning Engine http://mle.sourceforge.net/mle/index.php Estadísticas interesantes de dispositivos móviles, 2010 http://webmacheter.com/2010/03/24/estadisticas-interesantes-de-dispositivos-moviles-enero-de-2010/ Infografía: ¿Cómo se está apoderando Android?, 2010 http://webmacheter.com/2010/10/21/infografia-%C2%BFcomo-se-esta-apoderando-android/ Página principal para desarrolladores de Apple http://developer.apple.com/programs/ios/ Página principal para desarrolladores de Android http://developer.android.com/index.html GPL Enforcement in Apples App Store http://www.fsf.org/news/2010-05-app-store-compliance Ayuda online de Google para publicar aplicaciones en el Android Market https://www.google.com/support/androidmarket/developer/ Página principal de la librería gSOAP http://www.cs.fsu.edu/~engelen/soap.html Flurry: Time Spent On Mobile Apps Has Surpassed Web Browsing, 2011 http://techcrunch.com/2011/06/20/flurry-time-spent-on-mobile-apps-has-surpassed-web-browsing/ Android. Artículo Wikipedia, 2011 http://es.wikipedia.org/wiki/Android Página web de preguntas y respuestas orientada a desarrolladores http://stackoverflow.com/ Ayuda online de la forja GitHub http://help.github.com/ 92

14. Apéndices 14.1. Manual de Usuario Primera ejecución La primera vez que SWADroid se ejecuta después de haber sido instalado desde el AndroidMarket se muestra un cuadro de diálogo informando al usuario de que debe introducir su usuario ycontraseña de acceso a SWAD en la pantalla de configuración para que SWADroid pueda acceder alos datos relacionados con el usuario en SWAD. Este cuadro de diálogo da la posibilidad de mostrar la pantalla de configuración para que elusuario pueda introducir los datos en ese momento o realizar este paso más adelante. 93

Notificaciones Para consultar las últimas notificaciones recibidas en SWAD se accede a dicha funcióndesde la pantalla principal mediante Mensajes → Notificaciones. 94

Para descargar las últimas notificaciones es necesario pulsar sobre el icono de las flechascirculares que se muestra en la esquina superior derecha de la pantalla. En caso de no encontrarninguna conexión disponible en el dispositivo, SWADroid informará al usuario mediante unmensaje en la parte inferior de la pantalla. Tests La descarga y realización de tests de autoevaluación se lleva a cabo mediante la funciónEvaluación → Tests. En la pantalla principal de la función de tests se pueden sincronizar las preguntas de test decualquier asignatura en la que esté dado de alta el usuario mediante la función Sincronizarpreguntas. Esta función mostrará un cuadro de diálogo permitiendo al usuario seleccionar lasignatura sobre la que desea sincronizar las preguntas de test. Se requiere conexión a Internet para que SWADroid pueda obtener la lista de asignaturas enlas que el usuario está dado de alta. Una vez seleccionada la asignatura deseada comenzará la sincronización, que abrirá unaconexión con SWAD y descargará tanto la configuración establecida por el profesor de la asignaturapara la realización de los tests como las preguntas y respuestas de test de la asignatura. 96

Si SWADroid no pudiera descargar las preguntas de test porque la asignatura elegida nodispone de ninguna pregunta o porque el profesor de la misma no ha habilitado la descarga de laspreguntas de test a un dispositivo móvil, SWADroid informará al usuario y lo devolverá a lapantalla principal de la función de tests. Para realizar un test de autoevaluación de una asignatura se accede a la función Realizar test.Esta función mostrará el mismo cuadro de diálogo de selección de asignatura descrito anteriormente(en esta ocasión no requiere conexión a Internet). Si no se ha descargado ninguna pregunta de test para ninguna asignatura, SWADroidinformará al usuario y lo devolverá a la pantalla principal de la función de tests. Una vez seleccionada la asignatura de la que se desea realizar el test se le pedirá al usuario elnúmero de preguntas que desea que tenga el test y los descriptores y tipos de pregunta que deseaque aparezcan en el mismo. 97

Después de proporcionarle esta información a SWADroid, la aplicación generará un test deautoevaluación seleccionando de forma aleatoria el número de preguntas especificado por elusuario. En caso de que la asignatura elegida tuviera menos preguntas de test que las especificadaspor el usuario, SWADroid incluirá todas las preguntas de la asignatura en el test. Para navegar a través de las preguntas del test se utilizan las flechas situadas a ambos ladosde la barra de progreso de la parte inferior de la pantalla, que indica en todo momento en quépregunta se encuentra el usuario y el número total de preguntas del test. Una vez contestadas las preguntas del test (es posible dejar preguntas en blanco), se debepulsar el botón Corregir situado en la esquina superior derecha de la pantalla para que SWADroidevalúe las respuestas dadas por el usuario y, en función del nivel de realimentación permitido por elprofesor de la asignatura, mostrarle los resultados del mismo de forma más o menos detallada oincluso no mostrarle ningún resultado si el profesor así lo especifica (en este caso, SWADroidinformará al usuario sobre el motivo de la ocultación de los resultados). En la pantalla global de resultados SWADroid mostrará la puntuación del test sobre elnúmero de preguntas de que consta el test y la puntuación sobre diez obtenida por el usuario. Enfunción del nivel de realimentación permitido, esta pantalla mostrará un botón Ver detalles para queel usuario pueda navegar a través de las preguntas y consultar la puntuación individual obtenida y,en su caso, las respuestas correctas de las mismas. 99

Para volver a la pantalla de resultados globales se debe pulsar el botón Ver totales situado enla esquina superior derecha de la pantalla. 100

14.2. Artículos sobre SWADroid en prensa Artículo periódico Ideal 105

Artículo BIOTIC 106

Artículo Granada Digital 107

Artículo miugr.ideal.es 108

Artículo Universia 109

Artículo Secretaría General UGR 110

http://elcuernodehipnos.wordpress.com	189
http://www.slideshare.net	1
http://www.docseek.net	1

Memoria Proyecto Fin de Carrera SWADroid

by Juan Miguel Boyero Corral

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 191

Statistics

Memoria Proyecto Fin de Carrera SWADroid Document Transcript