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

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

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

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

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

Índice de contenido1. Introducción....................................................................................................................................102. Definición de objetivos y especificaciones.....................................................................................11

2.1. Estado del arte.........................................................................................................................112.2. Motivación..............................................................................................................................132.3. Objetivos.................................................................................................................................152.4. Software y documentación libre.............................................................................................16

3. Análisis y Diseño............................................................................................................................173.1. Diagrama de Casos de Uso.....................................................................................................173.2. Sistema operativo móvil.........................................................................................................183.3. Plataforma de desarrollo.........................................................................................................193.4. Diagrama de funcionamiento de los servicios web................................................................203.5. Diagrama de la Base de Datos................................................................................................213.6. Diagramas de clase.................................................................................................................22

4. Módulos..........................................................................................................................................234.1. Desarrollo de un módulo.........................................................................................................25

5. Internacionalización.......................................................................................................................296. Validación y pruebas.......................................................................................................................337. Programación con el SDK de Android...........................................................................................38

7.1. Introducción............................................................................................................................387.2. Especificaciones técnicas........................................................................................................417.3. Aplicación Android.................................................................................................................447.4. API de Android.......................................................................................................................47

7.4.1. Activity............................................................................................................................477.4.2. Intent...............................................................................................................................507.4.3. View................................................................................................................................51

7.5. Crear una pantalla de configuración.......................................................................................537.6. Almacenamiento persistente de datos.....................................................................................607.7. Comprobar estado de la conexión...........................................................................................627.8. Evitar el reinicio de la actividad por cambio de orientación de la pantalla............................637.9. Creación de interfaces.............................................................................................................64

8. Android en Eclipse IDE..................................................................................................................668.1. Creación de un proyecto Android...........................................................................................668.2. Ejecución de un proyecto........................................................................................................698.3. Modificación de las características del proyecto....................................................................708.4. Creación de interfaces gráficas...............................................................................................718.5. Generar instalador...................................................................................................................738.6. Descargar proyectos de ejemplo.............................................................................................75

9. Creación de un repositorio en la forja GitHub...............................................................................769.1. Configurar Git.........................................................................................................................769.2. Crear un repositorio en GitHub..............................................................................................80

10. Publicación en Android Market....................................................................................................8210.1. Información general..............................................................................................................8210.2. Registro.................................................................................................................................8210.3. Subida de una aplicación......................................................................................................83

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

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

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

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

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

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

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

3. Análisis y Diseño

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

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

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

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

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

• 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

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:

<activityandroid: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

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

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 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 webservicecreateRequest();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 responseVector 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 errorsLog.i(TAG, "Retrieved " + csSize + " notifications");

//Clear old notifications to control database sizedbHelper.clearOldNotifications(SIZE_LIMIT);

}}

28

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

<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.\n\nPara descargar lasnotificaciones 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.\n\nDependiendo del número depreguntas a sincronizar, el procesamiento de los datos puede tardar

unos minutos.\n\nPor favor, espere...</string><string name="errorMsgWorkaroundEmulator">Mierda. Ese bug del emulador de

Android ha vuelto aaparecer. 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 laspreguntas de test</string>

<string name="questionsTestsDownloadSuccesfulMsg">Preguntas de test sincronizadas</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 descargar

las preguntas de test de al menos unaasignatura</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

debeintroducir el nombre de usuario y la contraseña de acceso a SWAD en

lapantalla de configuración.\n\nPuede acceder a la pantalla deconfiguración desde el menú de la aplicación en cualquiermomento.\n\n¿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.\n\nDisculpe lasmolestias.</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 elservidor</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 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

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

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

• 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

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

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

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

• 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

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

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

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

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

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:

<activityandroid: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 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

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:

@Overridepublic void onCreate(Bundle icicle) {

//...

//Initialize screensuper.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

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, 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 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

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

• 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

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

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

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

/** * 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(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() */@Overrideprotected 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 de configuración se muestre y gestione los datos de forma automática. Pero como se puede observar en el código, es posible acceder también a los objetos definidos en el fichero XML para realizar acciones específicas con ellos a través del método findPreference() al que se le pasa como argumento 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 datos que en ella se muestran. Si el usuario desea acceder a estos datos o almacenar otros, estas son las opciones 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 pocos datos y con estructuras sencillas. Además, permite distintos niveles de seguridad, desde modo público en el que otras aplicaciones pueden acceder a estos datos (que no es público en si, ya que el programador de la aplicación debe conocer el sistema de directorios creado por la otra aplicación así como el nombre del fichero de preferencias y cada atributo para acceder a los datos) a modo privado 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 un HashMap, pero SharedPreferences genera un archivo XML. Se muestran dos formas de acceder a un archivo de preferencias: la primera es acceder al archivo de preferencias que la aplicación tiene asociado por defecto; es decir, el que ha creado automáticamente la ventana de configuración. El segundo 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 forma de 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 nombre es pasado como primer argumento. En caso de que este atributo no exista devolverá el valor pasado como segundo argumento.

Los objetos de preferencias no sólo trabajan con Strings. Se pueden almacenar y recuperar el resto 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 existe una 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 necesita acceder 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ón disponible.

Para poder realizar la comprobación lo es necesario añadir el siguiente permiso en el archivo 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 tipos de conexión según su modelo; en este caso se comprueba la conexión a cualquiera de los dos tipos de conexión de que dispone cualquier dispositivo Android. En SWADroid el código encargado de esta 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 trueif (networks[i].isConnected()){

connAvailable = true;}

}

//If boolean remains false there is no connection availablereturn connAvailable;

}

En este caso el parámetro pasado al método connectionAvailable(ctx) es un objeto de la clase Context porque el método no está definido en una clase Activity, por lo que no puede ejecutar el método getSystemService().

Cada actividad que necesite comprobar la conexión llama a este método pasando como argumento NombreClase.this.

62

7.8. Evitar el reinicio de la actividad por cambio de orientación de la pantalla

Cuando el movimiento del dispositivo móvil provoca un cambio de orientación de la pantalla, el sistema destruye la actividad actual y la vuelve a crear llamando de nuevo al método onCreate(). Este comportamiento provoca que la actividad vuelva a su estado inicial.

Si el usuario está leyendo las últimas notificaciones descargadas o realizando un test de autoevaluación y se produce un cambio de orientación en la pantalla, esta forma de actuar forzará a la 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():

@Overridepublic 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):

<activityandroid: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 la propia 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 que será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 de tests. De esta forma se muestran los dos casos: la creación de un elemento visual mediante XML y su acceso desde código, y también la creación de elementos visuales desde código así como la forma 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:

<ListViewandroid: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 una pregunta de un test de autoevaluación. Esta lista está inicialmente oculta en el interfaz gráfico, ya que sólo es utilizada por algunos tipos de respuestas. Para modificarla en el código es necesario acceder 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 cada iteración se lea una respuesta y se añada una fila con la información leída al final de la iteración. A continuación se muestra el código que crea la lista de respuestas para el tipo de respuesta de elecció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 de una base de datos y mostrarlos por pantalla según el formato especificado por el fichero list_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étodo setItemChecked() establece un elemento de ListView como marcado o desmarcado según el valor de los atributos pasados como parámetros.

El inconveniente tanto de crear interfaces por código como de hacerlo en el fichero XML es que no es posible ver su apariencia final hasta que no se ejecuta la aplicación. Para subsanar este problema Eclipse cuenta con un editor visual de interfaces con el que, a través de una interfaz visual, se pueden añadir elementos y darle valor a sus atributos. Además de mostrar el aspecto de la ventana en tiempo de ejecución, esta interfaz visual también se encarga de generar el fichero XML correspondiente.

Otras de las opciones existentes en la creación de interfaces gráficos es la creación de vistas propias. Esto es, definir clases que hereden de la clase View e implementarlas a medida del programador para posteriormente añadirlas por código como cualquier otro elemento predefinido del 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 de forma cómoda y sencilla.

El plugin de Android para Eclipse permite otras opciones como el acceso al AVD Manager que 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 Android dentro de la jerarquía de opciones. Se despliega esta carpeta y se selecciona la opción Android Project. 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

67

68

8.2. Ejecución de un proyecto

La forma de ejecutar un proyecto Android es similar a la de cualquier proyecto Java en Eclipse. Para ello, sobre el nombre del proyecto se hace clic derecho con el ratón y dentro de las opciones se selecciona Run as → Android Application.

Si se han creado varios dispositivos virtuales y ninguno de ellos está abierto, seleccionará el primero de ellos que sea compatible para poder ejecutarse. Si ya está abierto uno que sea compatible, se ejecutará en éste; en caso contrario se abrirá uno en el que se pueda ejecutar. En caso de tener varios abiertos y que más de uno sea compatible con los requerimientos de la aplicación, mostrará una ventana para seleccionar en cuál de ellos ejecutar la aplicación. Si, por el contrario, no existe 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 SDK de Android que convenga utilizar y, al usarlo en el proyecto, no se permita. Tras comprobar que se ha escrito el código correctamente y realizado todos los pasos que indica el manual, si el error persiste es probable que se deba a que dicha clase o método pertenezca a una versión superior a la utilizada 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 hace clic 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 donde podrá ejecutarse, o el nombre del sistema de directorios, cualquiera de estas características se modifican 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. En ella se puede alternar entre dos vistas. Si se pulsa en tests_make_main.xml aparece la interfaz en formato 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 interfaz agrupados según su tipo.

Para añadir cualquiera de ellos debe arrastrarse en la imagen sobre el Layout al que se desee asignarlo. 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 el objeto sobre el sobre el que se desea añadirlo, es mucho más cómodo seleccionar en esta jerarquía aquel 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á seleccionar el componente deseado. En ambos casos el nuevo componente se posicionará según las características definidas del Layout en el que se introduce.

Cada vez que se selecciona un componente del listado de la ventana derecha, en la parte inferior de la pantalla aparece su ventana de propiedades. En esta ventana se pueden modificar sus atributos, que hacen referencia a opciones de visualización del propio elemento y a opciones de visualización de los elementos que contiene.

En caso de cometer algún error con este editor visual y se quiera deshacer el mismo, es necesario pasar a la vista de texto sin cerrar la ventana. Si marcase un error y la vista de Layout no mostrara nada, accediendo a la vista de texto el error aparecerá marcado con una breve descripción en la línea que lo produce. Una vez corregidos todos los errores, todo volverá a mostrarse correctamente al acceder a la vista Layout.

71

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

72

8.5. Generar instalador

Este paso es muy similar a generar un archivo .jar con Eclipse cuando éste es un proyecto de Java. 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 debe estar firmado digitalmente para poder ser instalado en un dispositivo. El certificado de firmas puede ser self-signed; es decir, no es necesario obtener un certificado digital de una entidad certificadora como Verisign, sino que es posible generar un certificado propio mediante el siguiente comando de Java:

keytool –genkey -v -keystore rutaAbsolutaKeystore -alias androidFirma -storepass password -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 menos hasta el 22 de octubre de 2033. Esta acción solicitará una serie de datos personales que asociará al alias 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 la identidad del desarrollador.

73

Para un keystore se pueden añadir tantos alias como se deseen repitiendo este comando. Una vez 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 selecciona Android Tools. Se despliegan varias opciones, entre las cuales se encuentra Export Unsigned Application Package, con la que sólo es necesario dar un nombre al archivo .apk y una ruta en la que almacenarlo. Sin embargo, es más interesante usar la opción Export Signed Application Package porque genera el paquete ya firmado.

En la primera ventana se selecciona el proyecto Android que se desea firmar. Por defecto aparece 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 su contraseñ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 el que 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. Si esta última contraseña es incorrecta mostrará un error en la siguiente ventana. Si todo va bien se pedirá el nombre y la ruta para guardar el archivo .apk, que desde este momento puede ser instalado en 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 aplicaciones Android que pueden ser consultados online para ver su código fuente o descargarlos para poder modificarlos 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 de nombre Samples donde estarán todos los proyectos descargados. Es una colección bastante completa en la que se incluyen aplicaciones tales como una agenda, un juego, chat a través de Bluetooth.... y una aplicación llamada ApiDemos existente para varias versiones del SDK que muestra muchas opciones sobre lo que se puede realizar y cómo hacerlo. Es muy recomendable ejecutar 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 Create project from existing source y se establece la ruta de cualquiera de los proyectos de ejemplo descargados.

75

9. Creación de un repositorio en la forja GitHub

SWADroid utiliza el sistema de control de versiones Git, desarrollado por los creadores de GNU/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 detallados en 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

77

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 del desarrollador 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

$ lsconfig 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 > Add another 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 ver ficheros ocultos para encontrarlo porque el directorio .ssh está oculto. Es importante copiar la clave SSH de forma exacta, sin añadir espacios ni retornos de carro. Por último, copiar la clave en el campo 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 de usuario y su email. Además, GitHub utiliza esta información para asociar los commits con la cuenta de GitHub. Para configurar este aspecto es necesario ejecutar el siguiente código reemplazando el nombre de usuario y email por sus respectivos valores. El nombre debe ser el nombre real del desarrollador, 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 utilizarlas correctamente es necesario configurar un API Token. En la página web de GitHub pulsar Account Settings > Account Admin

En la línea de comandos ejecutar el siguiente código utilizando el nombre de usuario GitHub y 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á necesario repetir estos pasos.

79

9.2. Crear un repositorio en GitHub

1. Crear un repositorio

Pulsar 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 initInitialized 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 en GitHub. Para conectar el repositorio local con la cuenta GitHub es necesario configurar un repositorio 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 de Android de una forma sencilla. A continuación, se indican algunas de las características principales de 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 pagar una cuota de inscripción única de 25 dólares. El objetivo de esta cuota es incentivar la entrada de productos 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 vez durante el registro de una cuenta de desarrollador, pero es necesario disponer de una cuenta Google Checkout.

Para completar el registro, es necesario agregar un nombre de desarrollador (puede ser un nombre 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 que completar 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 constante evolución sobre el que se han planificado diversas mejoras y ampliaciones. Entre ellas se pueden destacar la traducción de SWADroid a otros idiomas que aún no estén disponibles, la revisión del diseñ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 cuya implementación en SWADroid es prioritaria por ser algunas de las funciones más utilizadas de la plataforma SWAD.

Por otra parte, se pretende ampliar y mejorar la infraestructura desplegada para desarrollar y mantener SWADroid y crear una comunidad de usuarios que proporcionen una buena realimentación a través de sus intervenciones tanto en los comentarios que permite dejar el Android Market 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 de SWADroid y otra información relevante. Además, sería interesante crear un wiki a modo de manual de uso online que podría incorporarse como sección al wiki ya existente sobre SWAD o crearse de forma autónoma.

Asimismo, se pueden estudiar otros protocolos de comunicaciones como REST para encontrar 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 respetando las especificaciones planteadas.

Se ha desarrollado el núcleo de una aplicación que permite comunicarse e interactuar con SWAD. Su diseño modular permite que la funcionalidad de la aplicación pueda ampliarse de forma cómoda, fácil y rápida.

Asimismo, se han implementado módulos que permiten acceder a dos de las funciones más utilizadas de SWAD: la consulta de las notificaciones y la descarga y realización de tests de autoevaluación. Estos módulos también sirven de ejemplo para ilustrar el proceso a seguir en el desarrollo e integración de nuevos módulos para SWADroid.

Por otra parte, se ha logrado desplegar una infraestructura que permitirá el mantenimiento y la continuidad del proyecto. Las fases seguidas para la creación y el despliegue de dicha infraestructura se muestran en el siguiente diagrama de Gantt.

Desde su publicación en el Android Market en el mes de marzo, SWADroid ha recibido varios comentarios y puntuaciones que la sitúan entre las aplicaciones mejor valoradas de su categoría. SWADroid cuenta ya con 398 usuarios activos (hasta el 21/6/2011) y ha comenzado a recibir realimentación en forma de sugerencias y valoraciones por parte de sus usuarios.

Asimismo, SWADroid ya está disponible en, al menos, 498 modelos de dispositivos móviles y en varias versiones del sistema operativo Android.

88

89

90

SWADroid también está presente en las principales redes sociales, a través de las que mantiene una comunicación directa con sus usuarios, lo que le permite adaptarse mejor a las necesidades de los mismos.

SWADroid, como aplicación precursora de la iniciativa La UGR en tu móvil y avanzadilla de la incursión que la Universidad de Granada pretende realizar en el cada vez más pujante mundo de los dispositivos móviles con objeto de hacer que la información y los servicios universitarios sean también accesibles a través de un dispositivo móvil, ha obtenido repercusión en varios medios, tanto digitales como escritos, dentro y fuera de la Universidad de Granada. Algunos de ellos son las principales 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, 2011http://es.wikipedia.org/wiki/Aprendizaje_electr%C3%B3nico_m%C3%B3vil

Mobile Learning Enginehttp://mle.sourceforge.net/mle/index.php

Estadísticas interesantes de dispositivos móviles, 2010http://webmacheter.com/2010/03/24/estadisticas-interesantes-de-dispositivos-moviles-enero-

de-2010/

Infografía: ¿Cómo se está apoderando Android?, 2010http://webmacheter.com/2010/10/21/infografia-%C2%BFcomo-se-esta-apoderando-android/

Página principal para desarrolladores de Applehttp://developer.apple.com/programs/ios/

Página principal para desarrolladores de Androidhttp://developer.android.com/index.html

GPL Enforcement in Apple's App Storehttp://www.fsf.org/news/2010-05-app-store-compliance

Ayuda online de Google para publicar aplicaciones en el Android Markethttps://www.google.com/support/androidmarket/developer/

Página principal de la librería gSOAPhttp://www.cs.fsu.edu/~engelen/soap.html

Flurry: Time Spent On Mobile Apps Has Surpassed Web Browsing, 2011http://techcrunch.com/2011/06/20/flurry-time-spent-on-mobile-apps-has-

surpassed-web-browsing/

Android. Artículo Wikipedia, 2011http://es.wikipedia.org/wiki/Android

Página web de preguntas y respuestas orientada a desarrolladoreshttp://stackoverflow.com/

Ayuda online de la forja GitHubhttp://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 Android Market se muestra un cuadro de diálogo informando al usuario de que debe introducir su usuario y contraseña de acceso a SWAD en la pantalla de configuración para que SWADroid pueda acceder a los datos relacionados con el usuario en SWAD.

Este cuadro de diálogo da la posibilidad de mostrar la pantalla de configuración para que el usuario 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ón desde la pantalla principal mediante Mensajes → Notificaciones.

94

95

Para descargar las últimas notificaciones es necesario pulsar sobre el icono de las flechas circulares que se muestra en la esquina superior derecha de la pantalla. En caso de no encontrar ninguna conexión disponible en el dispositivo, SWADroid informará al usuario mediante un mensaje 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ón Evaluación → Tests.

En la pantalla principal de la función de tests se pueden sincronizar las preguntas de test de cualquier asignatura en la que esté dado de alta el usuario mediante la función Sincronizar preguntas. Esta función mostrará un cuadro de diálogo permitiendo al usuario seleccionar la signatura sobre la que desea sincronizar las preguntas de test.

Se requiere conexión a Internet para que SWADroid pueda obtener la lista de asignaturas en las que el usuario está dado de alta.

Una vez seleccionada la asignatura deseada comenzará la sincronización, que abrirá una conexión con SWAD y descargará tanto la configuración establecida por el profesor de la asignatura para 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 no dispone de ninguna pregunta o porque el profesor de la misma no ha habilitado la descarga de las preguntas de test a un dispositivo móvil, SWADroid informará al usuario y lo devolverá a la pantalla 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, SWADroid informará 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 el número de preguntas que desea que tenga el test y los descriptores y tipos de pregunta que desea que aparezcan en el mismo.

97

98

Después de proporcionarle esta información a SWADroid, la aplicación generará un test de autoevaluación seleccionando de forma aleatoria el número de preguntas especificado por el usuario. En caso de que la asignatura elegida tuviera menos preguntas de test que las especificadas por 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 lados de 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 debe pulsar el botón Corregir situado en la esquina superior derecha de la pantalla para que SWADroid evalúe las respuestas dadas por el usuario y, en función del nivel de realimentación permitido por el profesor de la asignatura, mostrarle los resultados del mismo de forma más o menos detallada o incluso no mostrarle ningún resultado si el profesor así lo especifica (en este caso, SWADroid informará 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 el número de preguntas de que consta el test y la puntuación sobre diez obtenida por el usuario. En función del nivel de realimentación permitido, esta pantalla mostrará un botón Ver detalles para que el 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 en la esquina superior derecha de la pantalla.

100

101

102

103

104

14.2. Artículos sobre SWADroid en prensa

105

Artículo periódico Ideal

106

Artículo BIOTIC

107

Artículo Granada Digital

108

Artículo miugr.ideal.es

109

Artículo Universia

110

Artículo Secretaría General UGR