Memoria del Proyecto Fin de Carrera SWADroid, un cliente Android para la plataforma de teleformación SWAD(http://swad.ugr.es).

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

2. 2

3. 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

4. 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 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 a SWAD.
El desarrollo de este cliente se ha realizado en Java.
4

5. D. Antonio Cañas Vargas, profesor de la titulación de Ingeniería Informática, perteneciente
al Departamento de Arquitectura y Tecnología de Computadores de la Universidad de Granada, en
calidad 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 realizada
bajo 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 este
Proyecto Fin de Carrera, titulado “SWADroid: Cliente Android para la plataforma de educación
SWAD”, se deposite en la biblioteca de la facultad de la Escuela Técnica Superior de Ingenierías
Informática y de Telecomunicación para que pueda ser libremente consultada.
Granada, Junio de 2011.
Firmado: Juan Miguel Boyero Corral.
5

6. Resumen
El presente proyecto ilustra el modo en que se ha realizado la implementación de la
aplicación móvil SWADroid.
La aplicación móvil constituye la base de un cliente para dispositivos basados en el sistema
operativo 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 a
SWAD. Será utilizado por alumnos y profesores para acceder a los servicios de SWAD que
implemente el cliente. Consta de una parte cliente y otra que actúa como servidor. El servidor se
ejecuta en el ordenador donde está alojado SWAD e implementa los servicios web requeridos para
que el cliente pueda acceder a los servicios de SWAD. El cliente es un programa ejecutado por el
profesor o alumno sobre un dispositivo basado en Android e inicialmente implementará uno o
varios 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 aplicaciones
de 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 con
licencia GPLv3.
Este documento tiene licencia FDL.
Palabras clave
Android, aplicación móvil, SWAD, aprendizaje electrónico móvil, e-learning, m-learning, mobile
learning
6

7. 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 system
for e-learning platform and educational administration SWAD (http://swad.ugr.es/) so as to be easily
expandable with new access functions of SWAD. Will be used by students and teachers to access to
the SWAD services that implements the client. It consists of a client and a server. The server runs on
the computer that hosts SWAD and implements web services required for the customer to access to
the SWAD services. The client is a program executed by the teacher or student on an Android-based
device and initially deploy one or more of the SWAD services (depending on time availability) as
an example.
SWADroid is available for installation from the Android Market (Android app store) for free
via the direct link https://market.android.com/details?id=es.ugr.swad.swadroid and by the following
QR code:
SWADroid source code is available in the forge https://github.com/amab/SWADroid under
GPLv3 license.
This document is licensed under FDL.
Keywords
Android, aplicación móvil, SWAD, aprendizaje electrónico móvil, e-learning, m-learning, mobile
learning
7

8. Índice de contenido
1. Introducción....................................................................................................................................10
2. 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.............................................................................................16
3. 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.................................................................................................................22
4. Módulos..........................................................................................................................................23
4.1. Desarrollo de un módulo.........................................................................................................25
5. Internacionalización.......................................................................................................................29
6. Validación y pruebas.......................................................................................................................33
7. 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.............................................................................................................64
8. 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.............................................................................................75
9. Creación de un repositorio en la forja GitHub...............................................................................76
9.1. Configurar Git.........................................................................................................................76
9.2. Crear un repositorio en GitHub..............................................................................................80
10. Publicación en Android Market....................................................................................................82
10.1. Información general..............................................................................................................82
10.2. Registro.................................................................................................................................82
10.3. Subida de una aplicación......................................................................................................83
11. Futuras mejoras.............................................................................................................................86
12. Conclusiones.................................................................................................................................88
13. Bibliografía...................................................................................................................................92
14. Apéndices.....................................................................................................................................93
8

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

10. 1. Introducción
Este documento tiene como propósito detallar la labor realizada durante el periodo de
ejecución del proyecto final de carrera, consistente en desarrollar una aplicación para dispositivos
móviles Android.
La aplicación constituye la base de un cliente Android capaz de acceder a la plataforma de
teleformación SWAD (http://swad.ugr.es) de la Universidad de Granada mediante servicios web
basados en el protocolo SOAP (Simple Object Access Protocol). Esto conllevará ventajas tanto para
los usuarios de la plataforma como para el propio SWAD.
En primer lugar, SWAD ampliará su presencia en el ámbito académico ofreciendo a sus
usuarios 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 y
lugar e incluso podrán acceder a ciertos servicios de SWAD sin necesidad de una conexión a
Internet.
10

11. 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 de
enseñanza y aprendizaje valiéndose del uso de pequeños y maniobrables dispositivos móviles, tales
como teléfonos móviles, celulares, agendas electrónicas, tablets PC, pocket pc, i-pods y todo
dispositivo 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ñanza
basada en web (web-based teaching), aprendizaje electrónico (e-learning), etc.
Tanto desde el simple uso de la computadora y los soportes multimedia, como el
advenimiento de Internet y las redes en general, todo ha servido para apoyar el proceso de
enseñ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án
realizando 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 una
interfaz web adaptada a este tipo de dispositivos que no es capaz de aprovechar todo el potencial de
los dispositivos móviles además de requerir una conexión permanente a Internet para su uso.
11

12. Esta interfaz hace que el acceso a SWAD desde un dispositivo móvil sea extremadamente
lento debido al menor ancho de banda con que suelen contar estos dispositivos y a que el uso de un
interfaz web requiere la transmisión de información referente tanto a los datos que se desean
mostrar al usuario como a la forma de presentarlos por pantalla. Esto hace que se tenga que
transmitir 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 de
SWAD. Por ejemplo, los móviles con Android 2.1 o inferior tienen problemas para acceder a
páginas web mediante el protocolo HTTPS, requerido por SWAD, por lo que no pueden acceder al
mismo.
12

13. 2.2. Motivación
La finalidad de este proyecto es ofrecer a los usuarios ya existentes de SWAD nuevas formas
de acceder a la plataforma. Por una parte, esto aporta beneficios a la plataforma puesto que se
adapta a las nuevas tecnologías. Por otra parte, los usuarios ven cómo la plataforma evoluciona y les
proporciona nuevas formas de acceso a la misma; esto proporcionará confianza y satisfacción a los
usuarios actuales.
Al mismo tiempo, SWADroid puede ayudar a la captación de nuevos usuarios, bien sea por
descubrimiento 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 las
nuevas posibilidades que este proyecto les ofrece, ya que es posible que las herramientas que estén
utilizando no se hayan adaptado a las nuevas tecnologías.
Los últimos estudios que analizan la procedencia de los accesos a la información por parte
de los usuarios muestran claramente un enorme crecimiento del acceso a la información a través de
dispositivos 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 de
dispositivos móviles que antes no podían acceder al mismo, como se ha comentado en la sección
anterior.
Actualmente no existe ninguna aplicación móvil que permita acceder a la plataforma SWAD
desde un dispositivo móvil. Esta aplicación está orientada tanto a profesores como a alumnos y les
permitirá realizar un seguimiento de sus asignaturas desde cualquier lugar.
13

14. 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 lo
demuestran las estadísticas proporcionadas por la plataforma, por lo que el número de usuarios
potenciales de SWADroid al término del proyecto es alto y constituye un aliciente más para
desarrollarlo.
• 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

15. 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 de
Android, y más teniendo en cuenta que el principal promotor de este sistema operativo es Google,
los dispositivos móviles están orientados a un uso optimizado de Internet.
Teniendo en cuenta las nuevas tendencias del mercado, el principal objetivo de este proyecto
es proporcionar una nueva forma de acceso a los usuarios de SWAD, una plataforma de e-learning
de 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 un
cliente Android para la plataforma de e-learning SWAD. Este cliente proporcionará dos funciones
de 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 una
manera rápida y sencilla en cualquier momento y lugar. De esta manera, este objetivo puede ser
dividido 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 se
termine la etapa de estudiante, un informático va a estar aprendiendo a usar nuevos lenguajes de
programación o tecnologías durante toda su vida laboral.
En este caso, el objetivo personal es aprender a programar para una plataforma en la que no
se ha trabajado durante la carrera, dado que Android es un sistema operativo muy reciente en el que
aún no se ha profundizado a nivel académico.
15

16. 2.4. Software y documentación libre
Todo el software desarrollado ha sido liberado bajo la licencia GPLv3. La documentación
sobre este proyecto ha sido liberada bajo la licencia FDL. Esto significa que cualquiera puede usarlo
para cualquier propósito, compartirlo, estudiar su funcionamiento, modificarlo y compartir esas
modificaciones. Pero el software libre no significa únicamente una serie de libertades para el
usuario, también es beneficioso para el propio proyecto: recibe visibilidad (publicidad), logra
mejoras 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 de
conocimientos y la innovación tecnológica, haciendo que el proyecto no quede estancado una vez
que finalice, sino que pueda servir para cubrir futuras necesidades continuando su desarrollo o
integrándose en el de otro proyecto. Este proyecto, además, se basa completamente en estándares
abiertos y herramientas libres, por lo que es también una obligación moral devolver a la comunidad
lo 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 proceso
completamente 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. El
desarrollo ha permitido también la colaboración de los usuarios mediante el envío de sugerencias de
mejoras y errores.
Copyright (c) 30 de julio de 2011, Juan Miguel Boyero Corral
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
Version 1.3 or any later version published by the Free Software
Foundation; with no Invariant Sections, no Front-Cover Texts, and
no Back-Cover Texts. A copy of the license is available in
http://www.gnu.org/copyleft/fdl.html
16

17. 3. Análisis y Diseño
3.1. Diagrama de Casos de Uso
17

18. 3.2. Sistema operativo móvil
Los dos principales sistemas operativos para dispositivos móviles que existen en la
actualidad 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 poder
obtener el entorno de desarrollo es necesario darse de alta como desarrollador en la página web de
Apple con un coste de 99$/mes, una tarifa demasiado alta para las características y los objetivos de
este proyecto.
Por otra parte, la licencia GPL de este proyecto es incompatible con la tienda de aplicaciones
de Apple (App Store), único modo de distribuir las aplicaciones de iOS, por lo que este proyecto no
podría ser distribuido en la misma y, por tanto, no estaría disponible para ningún dispositivo que
utilizara el sistema iOS. Esto provoca que desarrollar el proyecto como una aplicación de iOS sea
una tarea absurda y totalmente improductiva, ya que se crearía una aplicación que nadie podría
instalar 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 la
tienda de aplicaciones de Android (Android Market), lo que requiere un único pago de 25$ en el
momento de registrarse en la misma como desarrollador. A partir de ese momento se pueden
publicar cuantas aplicaciones se deseen sin coste adicional. Estas aplicaciones estarán disponibles
para multitud de dispositivos móviles que utilicen el sistema Android.
18

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

20. 3.4. Diagrama de funcionamiento de los servicios web
SWADroid se comunica con SWAD mediante un conjunto de servicios web proporcionados
por 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 la
herramienta gSOAP.
Durante la etapa de identificación, SWADroid envía a SWAD una petición de identificación
que 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 Antonio
Cañas (creador de SWAD) con el fin de que SWADroid demuestre durante la etapa de identificación
que está autorizada a utilizar los servicios web de SWAD. Si SWADroid intenta acceder a SWAD
con 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ódigo
de 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 de
identificación proporcionados en la configuración de la aplicación son incorrectos.
20

21. 3.5. Diagrama de la Base de Datos
21

22. 3.6. Diagramas de clase
El núcleo de SWADroid, exceptuando algunas clases de apoyo para construir la ventana
principal 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 de
valores 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 la
configuración de SWADroid permitiendo que sea accedida y modificada por el resto de la
aplicación.
• SWADMain
La clase SWADMain es la clase principal y el punto de entrada de SWADroid. Se encarga de
construir la pantalla principal y lanzar todas las funciones que implementa la aplicación a petición
del usuario.
22

23. 4. Módulos
SWADroid sigue una arquitectura modular que permite añadir funcionalidad en forma de
nuevos módulos realizando modificaciones mínimas en el resto de la aplicación. Estas
modificaciones vienen impuestas principalmente por la arquitectura de Android, que obliga a que
las aplicaciones sigan un esquema determinado y a que ciertas acciones se realicen de una forma
preestablecida por la arquitectura del sistema.
La arquitectura modular de SWADroid se basa en la clase Module, de la que heredan todos
los módulos de la aplicación y que implementa las estructuras de datos y las operaciones comunes a
todos los módulos, tanto presentes como futuros. Esta clase implementa, entre otras funciones, el
mecanismo de comunicación mediante el acceso a los servicios web que implementa SWAD
proporcionando métodos para construir las peticiones que se realizan a dichos servicios web y
recibir y procesar las respuestas recibidas de los mismos.
Los métodos de la clase Module generan las peticiones en ficheros XML que envían a
SWAD, que a su vez envía las respuestas en otro fichero XML. Estos ficheros se estructuran con el
formato 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, en
su caso, enviar una petición de identificación para obtener la clave de sesión necesaria para acceder
a los servicios web de SWAD.
El módulo Login es llamado desde la clase Module como paso previo al envío de una
petición desde cualquier módulo. De esta forma se asegura que SWADroid siempre tendrá la clave
de sesión antes de acceder a un servicio web.
23

24. • 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 mostrar
el 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 desde
SWAD y mostrarlas por pantalla. Además de la información que envía SWAD por correo
electrónico cuando avisa al usuario de que tiene nuevas notificaciones, el módulo Notifications
obtiene y muestra el contenido de las mismas, salvo para las notificaciones referentes a las
calificaciones de una asignatura, que por el formato de su contenido deben ser tratadas de forma
especial.
Actualmente el módulo Notifications soporta todas las notificaciones que puede generar
SWAD.
• Tests
Este módulo se encarga de descargar las preguntas de test de las asignaturas en las que el
usuario esté dado de alta, que contengan preguntas de test y cuya opción de exportar las preguntas
de test a un dispositivo móvil haya sido habilitada por alguno de los profesores de la asignatura en
cuestión.
Por otra parte, el módulo Tests genera tests de preguntas seleccionadas de forma aleatoria
teniendo en cuenta la configuración establecida por los profesores de la asignatura y los parámetros
definidos por el usuario, como el número de preguntas del test y los descriptores y tipos de
preguntas que desea que aparezcan en el test.
24

25. 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 requiere
actualmente 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 Notifications
desde 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 es
que devuelve alguna, para su posterior procesamiento por parte de la actividad llamante. Si el
mó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 a
fin de poder procesar la respuesta devuelta por el mismo en el método onActivityResult. Cualquier
método que requiera el procesamiento de su respuesta debe tener asignado un REQUEST_CODE a
fin 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 de
SWADroid, se puede añadir la misma mediante un código similar al siguiente, que muestra cómo
añadir la función Notificaciones dentro de la categoría Mensajes:
final ArrayList<HashMap<String, Object>> headerData = new
ArrayList<HashMap<String, Object>>();
final HashMap<String, Object> messages = new HashMap<String, Object>();
messages.put(NAME, getString(R.string.messages));
25

26. messages.put(IMAGE, getResources().getDrawable(R.drawable.msg));
headerData.add( messages );
final ArrayList<ArrayList<HashMap<String, Object>>> childData = new
ArrayList<ArrayList<HashMap<String, Object>>>();
final ArrayList<HashMap<String, Object>> messagesData = new
ArrayList<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 una
serie de métodos abstractos que todos los módulos están obligados a implementar para mantener el
flujo 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 de
lanzar 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 haber
ejecutado la tarea principal del módulo, como por ejemplo el refresco de la pantalla para actualizar
la información mostrada.
A modo de ejemplo se muestra el contenido del método postConnect del módulo
Notifications:
refreshScreen();
El código del método refreshScreen se detalla a continuación:
//Refresh data on screen
dbCursor = 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

27. show the notifications list
if(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 normalmente
consiste en construir y enviar una petición a un servicio web de SWAD y procesar la respuesta
devuelta por el mismo.
El flujo de ejecución de un módulo estándar es el siguiente (se ilustrará mediante las
secciones 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

28. 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

29. 5. Internacionalización
SWADroid provee soporte para varios idiomas. Actualmente está disponible en español e
inglés. El idioma no puede ser seleccionado explícitamente por el usuario, sino que se establece
automáticamente en función del idioma configurado en el sistema.
Las cadenas de texto de cada idioma se encuentran almacenadas en archivos XML dentro de
la carpeta res/values seguida del código del idioma al que corresponden. Así, la carpeta
correspondiente al idioma español es res/values-es. Si no se especifica ningún código después de
values, se tomará por defecto como inglés.
Actualmente existen dos archivos dentro de la carpeta res/values-es que contienen todas las
cadenas 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 cadenas
de texto que se encuentran entre las etiquetas <string> y </string> sin modificar en ningún caso el
parámetro name de la etiqueta <string>, ya que éste es el identificador que utilizar SWADroid para
acceder a la cadena de texto en el idioma apropiado.
Una vez traducidos ambos archivos, deben incluirse en una nueva carpeta cuyo nombre debe
ser 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ón
actual</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 Boyero
Corral</string>
<string name="organization_preferences">Universidad de Granada</string>
<string name="loginTitle_menu">Conectar</string>
29

30. <string name="loginProgressTitle">Identificación</string>
<string name="loginProgressDescription">Conectando...</string>
<string name="coursesProgressTitle">Asignaturas</string>
<string name="coursesProgressDescription">Obteniendo
asignaturas...</string>
<string name="notificationsProgressTitle">Notificaciones</string>
<string name="notificationsProgressDescription">Obteniendo nuevas
notificaciones...</string>
<string name="notificationsEmptyListMsg">No se ha descargado ninguna
notificación.nnPara descargar las
notificaciones más recientes pulse el icono de la esquina superior
derecha de la pantalla.</string>
<string name="testsDownloadProgressTitle">Tests</string>
<string name="testsDownloadProgressDescription">Sincronizando preguntas de
test.nnDependiendo del número de
preguntas a sincronizar, el procesamiento de los datos puede tardar
unos minutos.nnPor favor, espere...</string>
<string name="errorMsgWorkaroundEmulator">Mierda. Ese bug del emulador de
Android ha vuelto a
aparecer. Reintentando...</string>
<string name="errorMsgLaunchingActivity">Ha ocurrido un error durante la
ejecució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 para
descargar las preguntas de test</string>
<string name="noQuestionsAvailableTestsDownloadMsg">No hay preguntas de
test disponibles para esta asignatura</string>
<string name="noQuestionsPluggableTestsDownloadMsg">El profesor de esta
asignatura no permite la descarga de las
preguntas de test</string>
<string name="questionsTestsDownloadSuccesfulMsg">Preguntas de test
sincronizadas</string>
<string name="testNoQuestionsCourseMsg">No se ha descargado ninguna
30

31. pregunta de test para esta asignatura</string>
<string name="testNoQuestionsMsg">Antes de realizar un test debe descargar
las preguntas de test de al menos una
asignatura</string>
<string name="testNoQuestionsMeetsSpecifiedCriteriaMsg">No hay ninguna
pregunta que se ajuste a los criterios
especificados</string>
<string name="testNumQuestionsMsg">Indique el número de preguntas del
test</string>
<string name="testTagsMsg">Seleccione los descriptores que desea incluir
en el test</string>
<string name="testNoTagsSelectedMsg">Debe seleccionar al menos un
descriptor</string>
<string name="testAnswerTypesMsg">Seleccione los tipos de respuesta que
desea incluir en el test</string>
<string name="testNoAnswerTypesSelectedMsg">Debe seleccionar al menos un
tipo 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 los
detalles</string>
<string name="testNoResultsMsg">El profesor no permite ver los resultados
del test</string>
<string name="firstRunMsg">Antes de usar la aplicación por primera vez
debe
introducir el nombre de usuario y la contraseña de acceso a SWAD en
la
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 del
servidor</string>
<string name="errorConnectionMsg">Error durante la conexión con el
servidor</string>
<string name="errorTimeoutMsg">Tiempo de espera agotado intentando
conectar con el
servidor</string>
</resources>
31

32. 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

33. 6. Validación y pruebas
El SDK de Android permite integrar dispositivos virtuales para probar SWADroid en el
entorno de desarrollo Eclipse. Queda a disposición del usuario crearse cuantos emuladores quiera y
con las características que se desee. Esta flexibilidad permite, entre otras cosas, establecer la versión
del sistema operativo en la que se ejecutará, el tipo de pantalla, su resolución, cantidad de
memoria... Para realizar las pruebas se han creado dos emuladores: uno que implementa la versión
1.6 de Android, puesto que esta es la versión mínima en la que se puede ejecutar SWADroid, y el
segundo 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 dispositivos
reales para poder observar las diferencias de ejecución entre una versión y otra. Las diferencias
entre velocidades de ejecución y acceso a Internet eran casi siempre mínimas, siendo lo más
destacable los cambios a nivel de interfaz debido a la leve diferencia de resolución de pantallas,
permitiendo de esta manera ajustar mejor el tamaño y apariencia de la información a mostrar para
una correcta presentación.
Las pruebas en los dispositivos reales han dado lugar a que el famoso problema de la
fragmentación de Android (diferencias de comportamiento según la versión del sistema operativo y
el dispositivo móvil utilizado) se manifieste en toda su envergadura llegando a provocar en algunos
casos situaciones en las que SWADroid funcionaba correctamente en ambos emuladores y en el
dispositivo móvil Sony Ericsson pero sufría errores de ejecución en el resto de los dispositivos
reales. Estas dificultades hacen que el problema de la fragmentación deba tenerse muy en cuenta a
la hora de desarrollar aplicaciones para Android procurando probarlas en el mayor número posible
de dispositivos reales para asegurar su correcto funcionamiento en la mayor parte de los mismos.
33

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

35. En las gráficas anteriores se muestra el valor de los parámetros medidos agrupados en
función de la acción realizada. En el acceso a través de la interfaz web las acciones realizadas son
las 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

36. • Mostrar y evaluar test EC1
Esta acción engloba los pasos necesarios para configurar, realizar y evaluar un test de la
asignatura 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ón
realizada. Las acciones realizadas son las siguientes:
• Login
Esta acción engloba los pasos necesarios para identificarse en la plataforma. Se realiza de
forma automática sin intervención del usuario cuando es necesario.
• Notificaciones
Esta acción engloba los pasos necesarios para consultar las notificaciones recibidas. El único
paso que debe realizar el usuario es pulsar el botón de actualización para descargar las últimas
notificaciones desde SWAD.
• Asignaturas
Esta acción permite al usuario seleccionar la asignatura de la que desea descargar las
preguntas 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 los
tests de su asignatura (en este caso, Estructuras de los Computadores 1). Esta acción se lleva a cabo
de forma automática sin la intervención del usuario después de seleccionar la asignatura de la que
descargar las preguntas de test.
• Descarga EC1 (Datos)
Esta acción descarga las preguntas y respuestas de test de la asignatura seleccionada por el
usuario. Esta acción se lleva a cabo inmediatamente después de descargar la configuración de los
tests de la asignatura y se realiza de forma automática sin la intervención del usuario después de
seleccionar la asignatura de la que descargar las preguntas de test.
36

37. En este caso no se requiere realizar ningún cierre de sesión, puesto que éste se lleva a cabo
de forma implícita al transcurrir el período de caducidad establecido por la plataforma SWAD para
las claves de sesión.
La comparativa anterior pone de manifiesto que el acceso a la información de SWAD desde
SWADroid 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. En
el caso de la realización y evaluación de tests la situación es aún más favorable para SWADroid, ya
que desde la interfaz web es necesario descargar los datos cada vez que se realiza un test. Sin
embargo, 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 a
Internet y, por tanto, no produce tráfico de datos en la red.
37

38. 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 de
este proyecto. Android es un sistema operativo para dispositivos móviles muy reciente, puesto que
aún no se han cumplido dos años desde su primera aparición en el mercado; no obstante y pese a su
escaso tiempo de vida, un programador con cierta experiencia se adapta rápidamente a su
programación.
7.1. Introducción
Los inicios de este sistema provienen del año 2005 cuando Google compra una pequeña
compañía llamada Android Inc, cuya finalidad es el desarrollo de aplicaciones para dispositivos
móviles, centradas principalmente en plataformas Web.
La existencia del nuevo sistema operativo no se hace pública hasta el año 2007, momento en
el que se anuncia la creación de la Open Handset Aliance. Esta organización es un consorcio de
compañías relacionadas con las telecomunicaciones y la informática, cuyo principal objetivo es la
promoción del sistema operativo Android y su política las licencias de código abierto.
La compañía HTC lanza a finales de septiembre de 2008 el primer teléfono móvil con este
sistema operativo. Desde entonces, son ya varias las compañías que están apostando por Android. A
modo de resumen estos son los tres nombres más importantes que se pueden relacionar con esta
plataforma.
Google: esta compañía es en la actualidad una de las más poderosas del mundo, su rápido
crecimiento en tan sólo unos pocos años de vida hizo que en 2007 se convirtiera en la marca más
valorada del mundo por delante de Microsoft o Coca-Cola, empresas que acostumbraban a dominar
esta posición.
Google lidera la mencionada Open Handset Aliance. El hecho de que esta compañía de tanta
importancia sea la principal promotora de Android aporta dos grandes ventajas tanto a los usuarios
de sus teléfonos móviles como a los desarrolladores de aplicaciones para esta plataforma.
La primera ventaja es que esta empresa apoya actualmente diversos proyectos de software
libre y licencias de código abierto. Ocurre lo mismo con el caso de Android, lo que provoca que
cualquier programador comience a trabajar cuando desee sin tener que pagar ninguna licencia para
desarrollar aplicaciones o darlas a conocer en el Android Market. Este último es un repositorio de
aplicaciones al que se puede acceder desde cualquier Android, quedando a elección del
desarrollador que su aplicación sea gratuita o de pago.
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ón
muy alto por parte de los usuarios. Todos los Android cuentan con un acceso rápido y eficiente a
estos productos y, al mismo tiempo, Google proporciona APIs para que el programador pueda
incluir estos servicios en sus aplicaciones de forma muy sencilla.
38

39. Linux: Android es un sistema operativo abierto para dispositivos móviles, y se basa en la
versión 2.6 del Kernel de Linux que actúa como una capa de abstracción entre el hardware y el resto
del conjunto de software, además de prestar los servicios de seguridad, gestión de memoria, gestión
de procesos... , que permite que pueda ser adaptado con facilidad a otros dispositivos. Esto presenta
una gran ventaja para las compañías fabricantes de teléfonos móviles.
A continuación se muestra un diagrama con los principales componentes del sistema
operativo 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

40. • 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 se
comentaba anteriormente, a pesar del poco tiempo de vida de esta plataforma cualquier
programador se adapta a su funcionamiento en muy poco tiempo, dado que el código fuente de una
aplicación se escribe en Java y este es uno de los lenguajes de programación más utilizados en la
actualidad. 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 es
su velocidad de ejecución. En este caso, como se ha explicado antes, ese problema ni siquiera existe
dado que, aunque la aplicación se escribe en Java, no es una aplicación Java ya que no se ejecuta en
una máquina virtual de Java. De esta forma el programador cuenta con todas las ventajas de este
lenguaje, y desaparece una de sus mayores desventajas.
40

41. 7.2. Especificaciones técnicas
Antes de comenzar con los detalles de programación, se explica todo lo necesario para
comenzar a desarrollar aplicaciones así como los pasos necesarios para la instalación de todos sus
componentes. Estos pasos pueden seguirse también de forma resumida en la página oficial de
Android, en el apartado Developers → Download SDK desde el cual, además, podemos descargar
todos los elementos necesarios que a continuación se explican.
JDK (Java Development Kit): en primer lugar es necesario tener instalado Java, la versión
mínima del JDK debe ser la 5. Puede comprobarse si se dispone de la versión necesaria
introduciendo en la ventana de comandos el siguiente comando (debería mostrar al menos 1.5 para
que sea la correcta):
javac -version
Android SDK: mientras que el JDK proporciona lo necesario para utilizar las clases de
Java, el SDK da acceso a las clases necesarias para construir una aplicación Android. Para ello se
descarga de la página oficial de Android en el apartado comentado anteriormente, seleccionando la
versión correspondiente a la máquina en la que se vaya a trabajar (Mac, Windows o Linux). Esto
permite guardar un archivo comprimido, que únicamente hay que descomprimir y guardar la carpeta
resultante 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 y
que simplemente debe descomprimirse el archivo y posicionarlo donde se desee.
El siguiente paso es crear un dispositivo virtual (puede realizarse en cualquier momento
antes de probar la aplicación), lo que permitirá probar la aplicación en el emulador antes de
instalarla en un dispositivo real.
Se pueden crear cuantos emuladores se desee y con diversas características. Por ejemplo se
puede crear uno con la versión 1.5 de Android que fue la primera en comercializarse en España y
otro con la última versión para comprobar que funcione todo correctamente en diferentes versiones.
41

42. Para crearlos se accede a la opción Window → Android SDK and AVD Manager, la ventana
mostrada, y se pulsa New. En la nueva ventana se debe establecer un nombre identificador para cada
dispositivo virtual, en el apartado Target la versión de sistema operativo que se desee y el tamaño
que se quiera que tenga su tarjeta de memoria.
Eclipse IDE: es un entorno de desarrollo para compilar y ejecutar aplicaciones. Si se
prefiere NetBeans también cuenta con su plugin para programar en Android, pero todos los libros y
la 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. En
este caso sí que es suficiente con sólo descargar el archivo y descomprimirlo, ya que no es necesaria
ninguna instalación.
Una vez realizados todos los pasos anteriores sólo queda configurar Eclipse correctamente
para poder implementar aplicaciones con el SDK de Android. Los pasos dados se han realizado para
Eclipse Classic 3.7, por lo que dependiendo de la versión es posible que los nombres de las pestañas
o su localización varíen ligeramente. Una vez abierto Eclipse hay que realizar las siguientes
acciones:
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

43. 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 la
que se ha descomprimido el SDK de Android. A continuación, pulsar Apply y OK.
43

44. 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. Primero
se comentará la estructura de carpetas de un proyecto Android, a continuación se ofrecerán
comentarios sobre la API y código, y por último sobre la construcción de interfaces gráficas, que
pueden 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

45. 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

46. 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

47. 7.4. API de Android
En este apartado se comentan las clases que pertenecientes al API de Android. Se utilizan
como 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 clase
que hereda de Activity. Se podría decir que una actividad equivale a una pantalla. A continuación se
muestra el ciclo de vida de una actividad.
En el diagrama se observan los métodos que se pueden sobrescribir si se desea realizar una
acción en concreto, y cuándo se ejecutan. No es necesario ni obligatorio implementar ninguno de
ellos; el único que debemos implementar siempre (al menos si se desea que la actividad muestre
algo) es onCreate() donde se define todo lo que se necesite realizar antes de que la pantalla se
muestre.
47

48. 48

49. 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 pueden
ser definidos mediante código o a través de ficheros XML (recomendado).
La segunda forma se lleva a cabo mediante el siguiente código:
@Override
public 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 con
las funciones del SWADroid agrupadas por categorías siguiendo el mismo esquema definido por
SWAD. Antes de llevar a cabo una acción con un elemento visual, debe llamarse al método de la
clase superior. Como en este caso se desea que la apariencia visual se lea desde un fichero XML, se
llama 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 se
definan, un ListActivity, que muestra elementos en forma de lista y sus correspondientes métodos
para tratarla, o MapActivity, proporcionada por un API de Google. También se pueden reutilizar las
Activities ya creadas anteriormente en SWADroid.
49

50. 7.4.2. Intent
La mejor forma de definir la clase Intent es como un nexo de unión. Su uso más frecuente es
llamar 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, ya
que la clase Intent se encarga de ello y, puesto que todos los Android disponen de un botón volver,
no es necesario ningún control de flujo.
La clase Intent también se encarga de controlar a qué actividad se debe regresar cuando se
pulse el botón del dispositivo para volver atrás. Si es necesario, se podría realizar un control de flujo
de 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 la
actividad que muestra el menú del cliente que se ha seleccionado. Simplemente debe construirse un
objeto de clase Intent cuyos parámetros sean el contexto de la aplicación y la clase de la actividad
que 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. Con
startActivityForResult() la actividad llamante a la espera de que la nueva actividad finalice y se le
asigna un identificador. En la clase Notifications se puede asociar un resultado de ejecución
correcto 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 se
puede indicar el resultado de la acción de la actividad. Si la actividad ha realizado su tarea
correctamente se puede llamar dentro de ella al método setResult(RESULT_OK) para informar a la
actividad 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 el
dispositivo. No sirve exclusivamente para pasar de una actividad a otra, sino que, como se muestra
en este ejemplo, también sirve para lanzar acciones que el dispositivo móvil lleva integradas, como
por ejemplo realizar una llamada. En este caso, al crear el Intent es necesario indicarle el número al
que se desea llamar:
Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:" + numeroTel));
startActivity(intent);
50

51. 7.4.3. View
Todo objeto que se desee mostrar por pantalla debe heredar de la clase View. Se pueden
definir clases propias que hereden de View, o usar las que proporciona el API de Android. Los
objetos View se pueden organizar y ordenar dentro de objetos de clase Layout. Con un Layout, por
ejemplo, se puede definir que los componentes se agreguen de manera horizontal o vertical en una
línea. También es posible definirlos en un formato de tabla controlando las posiciones en columnas
y filas. Entre los layouts proporcionados por Android los siguientes son los más básicos:
• LinearLayout: este Layout ordena a sus elementos en una línea en sentido horizontal o
vertical, agregándolos uno por uno en el orden en que se van definiendo.
• FrameLayout: es el tipo más simple de Layout que permite agregar un solo elemento en un
espacio en blanco definido.
• TableLayout: este Layout agrega sus elementos en columnas y filas. Las filas deben ser
insertadas una por una con un RowLayout.
• RelativeLayout: permite agregar elementos respecto a uno previo. Esto significa que el
posicionamiento se administra según la posición del elemento anterior.
Las interfaces se definen de forma jerárquica, por lo que es posible usar tantos elementos
como se desee, combinándolos o introduciendo unos dentro de otros. Otra forma de organizar los
objetos 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

52. • TextView: etiqueta de texto no editable por el usuario.
• RadioButton: elemento seleccionable parecido al CheckBox, pero con la diferencia de que
una vez que se ha seleccionado no regresa a su estado anterior si este está definido dentro de
un RadioGroup.
• Spinner: listado de elementos oculto que solo aparece cuando se pulsa sobre él. Cuando está
oculto sólo se puede ver el elemento seleccionado de todo el listado.
Con estas tres clases, y sus correspondientes clases descendientes, se podrían construir
aplicaciones bastante complejas. Se pueden resumir de la siguiente manera: una Activity es una
ventana que se muestra por pantalla, todo lo que se desee incluir en la pantalla debe que ser
descendiente de View o agrupaciones de estos objetos como Layouts y ViewGroups. Por último, los
Intent permiten pasar de un Activity a otro, o realizar acciones definidas por el teléfono sobre él.
También existe la clase Service, de funciones similares a un Activity pero ejecutándose en
segundo plano. Es decir, es una actividad en background que se puede ejecutar de forma indefinida
y que no mostrará nada por pantalla durante su ejecución.
52

53. 7.5. Crear una pantalla de configuración
El programador tiene dos opciones para crear una pantalla de configuración. En primer lugar
puede crearla a su gusto como una actividad más y almacenar los datos como desee. En segundo
lugar, la API ofrece una forma de construir esta ventana de forma automática y mostrando una
apariencia 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 el
almacenamiento y recuperación de datos, ya que esta opción se encarga de ello de forma automática
y transparente al programador cada vez que se abre la ventana de configuración. No obstante, se
puede 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 se
desee 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/. Su
contenido 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. A
continuación se listan los elementos que pueden aparecer en este archivo, que son muy parecidos a
53

54. 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 de
PreferenceActivity para mostrarla por pantalla, esta clase puede implementar el resto de métodos y
acciones que se han descrito hasta ahora y deberá declararse en el archivo de manifiesto.
54

55. Una diferencia con respecto a las actividades descritas anteriormente es la forma de acceder
al XML. En un ejemplo anterior, se explicó como asociar un fichero que define una interfaz a una
actividad. En este caso la forma de asociar actividad e interfaz es la siguiente:
public class Preferences extends PreferenceActivity implements
OnPreferenceChangeListener {
/**
* 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

56. /**
* 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

57. {
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

58. });
userPasswordPref.setOnPreferenceClickListener(new
OnPreferenceClickListener() {
/**
* 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