francisco gavidiari.ufg.edu.sv/jspui/bitstream/11592/4183/2/005.74-c353d.pdf · a mis padres, por...
TRANSCRIPT
UNIVERSIDAD FRANCISCO GAVIDIA
FACULTAD DE INGENIERIA Y ARQUITECTURA
TRABAJO DE GRADUACION
“DESARROLLO DE APLICACIONES MÓVILES PARA
ACCEDER A CONTENIDO MULTIMEDIA DE LA
UNIVERSIDAD FRANCISCO GAVIDIA”
PRESENTADO POR:
RAFAEL DAVID CASTRO LUNA
PARA OPTAR AL GRADO DE:
INGENIERO EN CIENCIAS DE LA COMPUTACIÓN
OCTUBRE 2012
SAN SALVADOR, EL SALVADOR, CENTRO AMÉRICA
UNIVERSIDAD FRANCISCO GAVIDIA
RECTOR
ING. MARIO ANTONIO RUÍZ RAMÍREZ
SECRETARIA GENERAL
LICDA. TERESA DE JESUS GONZALEZ DE MENDOZA
FACULTAD DE INGENIERÍA Y ARQUITECTURA
DECANO
ELBA PATRICIA CASTAÑEDA DE UMAÑA
UNIVERSIDAD FRANCISCO GAVIDIA
ORGANIZACIÓN DEL TRABAJO DE GRADUACIÓN
DECANO
ELBA PATRICIA CASTAÑEDA DE UMAÑA
ASESOR
ING. LUIS ENRIQUE REYES VALENCIA
JURADO
ING. NELSON ANTONIO TESORERO VALENCIA
ING. SONIA HAYDEE AMAYA DE LEON
ING. NELSON EMILIO MORALES
Agradecimientos
A DIOS, Por estar presente en el proceso de trabajo de graduación, por no
dejarme caer en ningún momento y darme las fuerzas para seguir adelante.
A MIS PADRES, Por haberme dado la vida y la oportunidad para prepararme.
A MI ESPOSA, Por brindarme su apoyo incondicional, confianza y paciencia en
todo momento de mi carrera.
A MIS HIJOS, Rafael David y Emilio Javier, este sacrificio mío, ha sido para
ustedes.
A MI ASESOR, Ing. Luis Enrique Reyes, por brindarme su experiencia en el
desarrollo de aplicaciones y su conocimiento en base de datos que ha sido
fundamental para mí.
Rafael David Castro Luna
TABLA DE CONTENIDO
Resumen................................................................................................................................................8
Introducción ...........................................................................................................................................9
CAPÍTULO I ....................................................................................................................................... 10
PLANTEAMIENTO DEL PROBLEMA ........................................................................................... 10
1.1 Descripción del problema ................................................................................................ 10
1.2 Justificación ......................................................................................................................... 11
1.3 Objetivos ............................................................................................................................... 12
1.4 Alcances y Limitaciones................................................................................................... 13
1.4.1 Alcances .............................................................................................................................. 13
1.4.2 Limitaciones ......................................................................................................................... 14
CAPÍTULO II ...................................................................................................................................... 16
MARCO DE REFERENCIA ............................................................................................................. 16
2. MARCO TEÓRICO ................................................................................................................... 16
2.1 Antecedentes de la Universidad Francisco Gavidia ................................................ 16
2.2 Internet ................................................................................................................................... 16
2.3 Paginas Web......................................................................................................................... 17
2.4 Aplicaciones Web ............................................................................................................... 19
2.5 Sistema Operativo Android ............................................................................................. 21
2.5.1 Arquitectura .................................................................................................................... 23
2.5.2 Aplicaciones para Android .......................................................................................... 24
2.6 Servidor Web........................................................................................................................ 25
2.7 Servicios Web ...................................................................................................................... 25
2.8 Moodle .................................................................................................................................... 28
Servidor ....................................................................................................................................... 28
2.9 Sistema Gestor de Base de Datos ................................................................................. 29
2.10 Teléfonos Móviles............................................................................................................... 31
2.11 Generalidades sobre los teléfonos inteligentes o smartphones. ........................ 31
2.12 Desarrollo de aplicaciones para dispositivos móviles ........................................... 33
2.13 ¿Cómo se prueba una aplicación móvil? .................................................................... 33
CAPÍTULO III ..................................................................................................................................... 34
METODOLOGÍA DE LA INVESTIGACION .................................................................................. 34
3.1 Generalidades ............................................................................................................................. 34
3.2 Ámbito de la investigación ........................................................................................................ 34
3.3 Metodología de la investigación .............................................................................................. 35
3.4 Técnicas e instrumentos de Investigación ................................................................. 35
3.4.1 Recolección Bibliográfica ............................................................................................ 36
3.4.2 Entrevista ........................................................................................................................ 36
3.4.3 Encuesta ......................................................................................................................... 37
3.4.4 Ficha Bibliográfica ........................................................................................................ 38
3.4.5 Guía de Entrevista ........................................................................................................ 38
3.4.6 Guía de Encuesta ......................................................................................................... 38
3.5 Determinación del Universo ..................................................................................................... 39
3.6 Tamaño de la muestra............................................................................................................... 39
3.6.1 Selección de la muestra .................................................................................................... 39
CAPITULO IV ..................................................................................................................................... 44
RECOLECCIÓN DE LOS DATOS ................................................................................................. 44
4.1 Elaboración del instrumento de investigación .......................................................... 44
4.2 Forma de determinar la confiabilidad ................................................................................ 44
4.3 Resultados obtenidos ....................................................................................................... 46
4.4 Conclusión de los resultados ......................................................................................... 56
4.5 Estudio de Factibilidad ..................................................................................................... 56
4.5.1 Factibilidad Técnica...................................................................................................... 56
4.5.1.1 Razones para la selección de la plataforma móvil ......................................... 57
4.5.1.2 Requerimientos del equipo de los usuarios..................................................... 59
4.5.1.3 Recurso Humano .................................................................................................. 59
4.5.1.3 Software ........................................................................................................................ 59
4.5.1.4 Definiciones ........................................................................................................... 60
4.5.2 Factibilidad Operativa .................................................................................................. 60
4.5.3 Factibilidad Económica ................................................................................................ 61
CAPÍTULO V ...................................................................................................................................... 62
DISEÑO .............................................................................................................................................. 62
5.1 Generalidades ...................................................................................................................... 62
5.1.1. Pasos para el diseño de una aplicación para Android .......................................... 63
5.1.2 Estructura física de un proyecto Android ................................................................. 65
5.2 Importancia ........................................................................................................................... 70
5.3 Diseño .................................................................................................................................... 70
5.3.1 Diagrama jerárquico de la aplicación ........................................................................ 70
5.3.2 Diagrama de flujo .......................................................................................................... 71
5.3.3 Diseño de los servicios web ....................................................................................... 72
5.3.4 Diseño de la base de datos ........................................................................................ 76
5.3.5 Pasos para la navegación de la aplicación .............................................................. 79
5.3.6 Sincronización de la base de datos........................................................................... 79
5.3.7 Diseño de Pantallas ............................................................................................................ 79
5.3.8 Uso del sistema ............................................................................................................. 80
5.3.8.1 Acceso al sistema ................................................................................................. 80
5.3.8.2 Menú Principal....................................................................................................... 80
5.3.8.3 Mis asignaturas inscritas ..................................................................................... 81
5.3.8.4 Mis recursos .......................................................................................................... 82
5.3.8.5 Calendario ............................................................................................................... 85
5.3.8.6 Mis notas ................................................................................................................. 86
5.3.8.7 Mis mensajes ......................................................................................................... 86
5.3.8.8 Mis Noticias............................................................................................................ 88
5.3.9 Actividades para la implementación .......................................................................... 88
Instalación y prueba del sistema .................................................................................... 89
Actualización ...................................................................................................................... 89
CAPÍTULO VI ..................................................................................................................................... 90
CONCLUSIONES Y RECOMENDACIONES .............................................................................. 90
6.1 Conclusiones ............................................................................................................................... 90
6.2 Recomendaciones...................................................................................................................... 90
BIBLIOGRAFIA .................................................................................................................................. 91
Anexo 1 ..................................................................................................................................................1
Manual Técnico ....................................................................................................................................1
Anexo 2 ............................................................................................................................................... 47
Manual del usuario (Android) .......................................................................................................... 47
Anexo 3 ............................................................................................................................................... 56
Preparar el entorno para desarrollo con Android ........................................................................ 56
Resumen
El presente trabajo está conformado por 6 capítulos, en los que se ha desarrollado
un prototipo con funcionalidad limitada para acceder a contenido multimedia de la
Universidad Francisco Gavidia.
Capítulo I: Consiste en presentar los objetivos, alcances, limitaciones, justificación,
planteamiento del problema.
Capítulo II: Se detalla el marco teórico, donde se presentan las tecnologías de
internet, aplicaciones web, detalles del sistema operativo Android, mostrando su
arquitectura y aplicaciones para el mismo; se describe el sistema gestor de
contenidos a utilizar, Moodle; generalidades de los smartphones así como los
antecedentes de la Universidad Francisco Gavidia.
Capítulo III: Se presenta la investigación de campo donde se desarrolla la
investigación planteada con el fin de establecer los requerimientos de la
aplicación mediante el uso de encuestas.
Capítulo IV: Aquí se detalla como se elabora el instrumento de investigación, como
se determina la muestra y estudio de factibilidad.
Capítulo V: Se muestra el diseño y desarrollo de la aplicación según lo obtenido
del estudio realizado a los usuarios de la aplicación, creación de servicios web
para que la aplicación consuma los datos provenientes del servidor que contiene
la información, diseño de la base de datos interna de la aplicación.
Capítulo VI: Conclusiones y recomendaciones.
Introducción
Debido al auge de las tecnologías móviles en nuestro medio, ya sea mediante
teléfonos inteligentes o tabletas, se considera que el desarrollo de una aplicación
móvil para los estudiantes de la universidad Francisco Gavidia es una alternativa
para que puedan acceder al contenido multimedia que la universidad proporciona
mediante su plataforma virtual. La universidad Francisco Gavidia siempre ha
estado a la vanguardia de la tecnología en El Salvador, ofreciendo novedosos
servicios para sus estudiantes: registro en línea, notas en línea y otros.
Este trabajo de graduación está encaminado a ofrecer a los estudiantes una forma
adicional de acceder al contenido que necesitan, esto es, a través de una
aplicación que se ejecuta en dispositivos móviles ( tabletas y teléfonos
inteligentes). Para el caso práctico se ha hecho uso del sistema operativo Android,
aunque Blackberry se encuentre más distribuido, se muestra en el Capítulo IV el
porqué de la elección de Android. Android es un sistema de crecimiento rápido a
nivel mundial, siendo su más cercano perseguidor el sistema operativo iOS1,
seguido de Blackberry OS. En el presente trabajo se presenta el desarrollo de una
aplicación para Android por medio de la cual accederán a los servicios que la
universidad proporciona.
Sistema Operativo Cantidad de Estudiantes Porcentaje
Blackberry OS 213 55.32%
Android OS 51 13.25%
N/A 57 14.81%
Symbian 40 10.39%
Otros Sistemas 24 6.23%
Total 385
Tabla 1. Distribución de sistemas operativos móviles entre los estudiantes de la
Universidad Francisco Gavidia. Fuente: Encuesta de opinión.
1Android vs. Apple vs. Blackberry ¿Quién está ganando la batalla?http://cultura-
geek.com/noticias/actualidad/dispositivos -moviles/184-android-vs-apple-vs-blackberry-iquien-esta-
ganando-la-batalla.html Fecha: 9/07/2011
CAPÍTULO I
PLANTEAMIENTO DEL PROBLEMA
1.1 Descripción del problema
Con frecuencia la demanda de uso por parte de los estudiantes de las redes
locales de la Universidad Francisco Gavidia es mayor a la o ferta de
computadoras que en ellas se encuentran. Lo cual podría ser solventado
mediante la implementación de aplicaciones móviles para dispositivos
preparados para ello: teléfonos inteligentes, tabletas y otros dispositivos que
hagan uso del sistema operativo adecuado.
Con el desarrollo de una aplicación para teléfonos inteligentes se podría
reducir en una gran medida la necesidad de los estudiantes para acceder al
contenido académico que la Universidad brinda en su plataforma virtual. El
estudiante al hacer uso de esta aplicación, descargable desde la página we b
de la Universidad Francisco Gavidia, podrá acceder fácilmente al contenido
que necesita: documentos, acceder a información importante, ver videos,
presentaciones e incluso videos de clases y acceso al canal de televisión de la
universidad desde su dispositivo móvil.
Entre las limitantes que se podrían encontrar se tienen:
1. Las plataformas móviles son tan diferentes: Android OS, iOS, Windows
Mobile, RIM BlackBerry OS y Symbian que el estudio se limitará a dos de
los más distribuidos en la actualidad los cuales son Blackberry OS y
Android OS, el cual este año ha mostrado un crecimiento del 5.1% respecto
al 1.4% de iOS y -4.2% de BlackBerry, Android OS tiene la mayoría con el
38% del mercado1.
2. El temor al cambio: algunos estudiantes podrían ser reacios a aceptar el
uso de las aplicaciones, lo que podría llevar a falta de distribución de ellas.
Esto se solventaría haciendo una campaña de divulgación ya sea en prensa
o televisión para que se generalice su uso.
Es por ello que con la presente investigación se busca dar solución a este
problema desarrollando un prototipo con funcionalidad limitada que servirá de
base para desarrollar una aplicación para que los estudiantes puedan acceder
al contenido multimedia de la Universidad sin tener que hacer uso de los
centros de cómputo esto también aliviaría la saturación de los mismos en
cuanto a la utilización de los equipos informáticos.
1.2 Justificación
La importancia de este estudio radica en que con el desarrollo de aplicaciones
móviles para acceder a contenido multimedia de la Universidad Francisco Gavidia
se aliviará la carga existente en los centros de cómputo de la universidad ya que
los estudiantes accederán al contenido desde sus dispositivos móviles: teléfonos
inteligentes y tabletas.
Actualmente se observa una tendencia del uso de dispositivos móviles para
desarrollar un sinfín de tareas tales como: acceso a correo electrónico, navegación
por internet, compras en línea, pagos de servicios entre otros. Por lo que el
desarrollo de una aplicación para lo anteriormente expuesto podría ser de
aceptación para la población estudiantil de la Universidad.
1Android vs. Apple vs. Blackberry ¿Quién está ganando la batalla?http://cultura-
geek.com/noticias/actualidad/dispositivos-moviles/184-android-vs-apple-vs-blackberry-iquien-esta-
ganando-la-batalla.html Fecha: 9/07/2011
Este prototipo con funcionalidad limitada servirá de base para desarrollar una
aplicación que sirva para que los estudiantes puedan acceder al contenido de una
manera fácil y adecuada. Se puede citar un ejemplo: en una clase el docente le
informa a sus estudiantes que se ha subido en ese momento a la plataforma
virtual de la universidad un video que es importante para el desarrollo de la
cátedra. El estudiante fácilmente puede acceder a el o los videos que el docente
les ha dicho desde su dispositivo, para verlo o descargarlo en el momento. Se
espera obtener es una reducción de la sobrecarga que se observa en las redes
locales cuando se tienen más estudiantes que computadoras disponibles para el
uso. Estas aplicaciones pondrán a la Universidad a la vanguardia para ofrecer
acceso a su contenido a los estudiantes, ya que mediante el uso de estas se
obtendrá acceso inmediato al contenido que se desee acceder.
1.3 Objetivos
Objetivo General: Desarrollar aplicaciones móviles para acceder a contenido
multimedia de la Universidad Francisco Gavidia.
Objetivos Específicos
Desarrollar un prototipo con funcionalidad limitada que sea fácil de utilizar e
intuitiva para quien la utilice.
Determinar cómo el prototipo accederá a los servicios.
Desarrollar un prototipo que sea fácil de instalar y configurar en los
dispositivos móviles que sean capaces de soportarlo.
Hacer pruebas piloto del prototipo.
1.4 Alcances y Limitaciones
1.4.1 Alcances
El alcance de este proyecto será los estudiantes de la Universidad Francisco
Gavidia, sede central, San Salvador. El desarrollo del estudio será de 4 meses
y la cantidad de usuarios a la que estará orientada será la población estudiantil
de la Universidad.
Se efectuará un análisis preliminar para determinar la forma en que el
prototipo será estructurado, para luego finalizar con el desarrollo del software.
La aplicación, la cual se podría desarrollar a partir de este prototipo, será
utilizada solamente por los estudiantes de la Universidad Francisco Gavidia .
Para plantear claramente las áreas que abarcará el proyecto a desar rollar y
para definir más detalladamente las capacidades de funcionalidad del mismo,
tenemos los siguientes aspectos:
i. Acceso mediante usuario y clave, para mayor comodidad, los mismos de
la plataforma virtual de la Universidad (U Virtual).
ii. El prototipo hará uso de servicios web para poder llenar su base de datos
interna y mostrar la información al usuario a través de la aplicación.
Cuando esté sin señal de Internet, la aplicación no se sincronizará y solo
le mostrará al usuario lo que tenga almacenado en la base de datos.
iii. Crear consultas de los recursos (documentos, videos, imágenes, etc.) de
las asignaturas que el estudiante esté cursando en determinado
momento. Este los podrá descargar mediante la aplicación .
iv. El prototipo se desarrollará para el sistema operativo Android. Según
datos obtenidos en la encuesta, ver Capítulo V.
1.4.2 Limitaciones
Entre las limitaciones tenemos:
i. El estudio se limitará a desarrollar un prototipo con funcionalidad limitada
utilizando para ello la plataforma Android, ya que este sistema operativo
es el de mayor crecimiento a nivel mundial.
ii. La aplicación no será implementada, solamente se hará a nivel de
pruebas en servidor local. Como servidor local se utilizará una
computadora portátil a la cual la aplicación accederá con fines
demostrativos, la aplicación correrá en un emulador en la computadora,
la cual simulará cómo se comportará la aplicación real.
iii. La aplicación solo estará diseñado para acceder a contenido multimedia:
documentos, imágenes, audio y videos de la Universidad.
iv. La aplicación a desarrollar será “UN PROTOTIPO CON
FUNCIONALIDAD LIMITADA”, quedará a opción del lector, el continuar
con el desarrollo.
v. El sistema no será implementado en dispositivos que no soporten
aplicaciones java, entre ellos tenemos iPhone y iPad, que utilizan otra
tecnología, la cual es sistema operativo iOS propiedad de Apple, este
sistema operativo trabaja con el lenguaje Objective C . Con esto se
espera cubrir aproximadamente al 83% de los estudiantes, el 17%
restante quedan fuera al no poseer un Smartphone o tener un sistema
operativo incompatible para los aplicativos.
CAPÍTULO II
MARCO DE REFERENCIA
2. MARCO TEÓRICO
2.1 Antecedentes de la Universidad Francisco Gavidia
La Universidad Francisco Gavidia fue fundada el día 7 de marzo de 1981, creada
por decreto legislativo No. 244 del 24 de mayo de 1965. El Ministerio de
Educación, mediante el acuerdo No. 3007 del 29 de julio de 1981 autorizó el inicio
de sus actividades. El 14 de Septiembre de ese mismo año, obtuvo la personería
jurídica y sus estatutos se publicaron en el Diario Oficial No. 176, tomo 272 el 24
de Septiembre.
Los primeros planes de estudio se autorizaron en 1983 e inició con una población
de 500 estudiantes.
La universidad inició con dos facultades: Facultad de Ciencias Sociales y Facul tad
de Ciencias Económicas1.
2.2 Internet
Sus orígenes se remontan a la década de 1960, dentro de ARPA, como respuesta
a la necesidad de esta organización de buscar mejores maneras de usar los
computadores de ese entonces, pero enfrentados al problema de que los
principales investigadores y laboratorios deseaban tener sus propios
computadores, lo que no sólo era más costoso, sino que provocaba una
duplicación de esfuerzos y recursos. Así nace ARPA Net (Advanced Research
Projects Agency Network o Red de la Agencia para los Proyectos de Investigación
Avanzada de los Estados Unidos), que nos legó el trazado de una red inicial de
comunicaciones de alta velocidad a la cual fueron integrándose otras instituciones
1 Historia de la Universidad Francisco Gavidia. http://www.ufg.edu.sv/historia.html
gubernamentales y redes académicas durante los años 70 . Investigadores,
científicos, profesores y estudiantes se beneficiaron de la comunicación con otras
instituciones y colegas en su rama, así como de la posibilidad de consultar la
información disponible en otros centros académicos y de investigación. De ig ual
manera, disfrutaron de la nueva habilidad para publicar y hacer disponible a otros
la información generada en sus actividades. En el mes de julio de 1961 Leonard
Kleinrock publicó desde el MIT el primer documento sobre la teoría de
conmutación de paquetes. Kleinrock convenció a Lawrence Roberts de la
factibilidad teórica de las comunicaciones vía paquetes en lugar de circuitos, lo
cual resultó ser un gran avance en el camino hacia el trabajo informático en red. El
otro paso fundamental fue hacer dialogar a los ordenadores entre sí. Para explorar
este terreno, en 1965, Roberts conectó una computadora TX2 en Massachusetts
con un Q-32 en California a través de una línea telefónica conmuta da de baja
velocidad, creando así la primera (aunque reducida) red de computadoras de área
amplia jamás construida2.
2.3 Páginas Web
Una página web es el nombre de un documento o información electrónica
adaptada para la World Wide Web y que puede ser accedida mediante un
navegador para mostrarse en un monitor de computadora o dispositivo móvil. Esta
información se encuentra generalmente en formato HTML o XHTML, y puede
proporcionar navegación a otras páginas web mediante enlaces de hipertexto. Las
páginas web frecuentemente incluyen otros recursos como hojas de estilo en
cascada, guiones (scripts) e imágenes digitales, entre otros.Las páginas web
pueden estar almacenadas en un equipo local o un servidor web remoto. El
servidor web puede restringir el acceso únicamente para redes privadas, p. ej., en
una intranet corporativa, o puede publicar las páginas en la World Wide Web. El
acceso a las páginas web es realizado mediante su transferencia desde servidores
utilizando el protocolo de transferencia de hipertexto (HTTP).
2 Historia de Internet. http://www.timetoast.com/timelines/118626
Características: Una página web está compuesta principalmente por información
(sólo texto y/o módulos multimedia) así como por hiperenlaces; además puede
contener o asociar datos de estilo para especificar cómo debe visualizarse, y
también aplicaciones embebidas para así hacerla interactiva.
Las páginas web son escritas en un lenguaje de marcado que provee la capacidad
de manejar e insertar hiperenlaces, generalmente HTML.
El contenido de la página puede ser predeterminado (“página web estática”) o
generado al momento de visualizarla o solicitarla a un servidor web (“página web
dinámica”). Las páginas dinámicas que se generan al momento de la visualización,
se especifican a través de algún lenguaje interpretado, generalmente JavaScript, y
la aplicación encargada de visualizar el contenido es la que realmente debe
generarlo. Las páginas dinámicas que se generan, al ser solicitadas, son creadas
por una aplicación en el servidor web que alberga las mismas.
Respecto a la estructura de las páginas web, algunos organismos, en especial el
W3C, suelen establecer directivas con la intención de normalizar el diseño, y para
así facilitar y simplificar la visualización e interpretación del contenido.
Una página web es en esencia una tarjeta de presentación digital, ya sea para
empresas, organizaciones, o personas, así como una tarjeta de presentación de
ideas y de informaciones. Así mismo, la nueva tendencia orienta a que las páginas
web no sean sólo atractivas para los internautas, sino también optimizadas
(preparadas) para los buscadores a través del código fuente. Forzar esta doble
función puede, sin embargo, crear conflictos respecto de la calidad del contenido.
2.4 Aplicaciones Web
Se denomina aplicación web a aquellas aplicaciones que los usuarios pueden
utilizar accediendo a un servidor web a través de Internet o de una intranet
mediante un navegador. En otras palabras, es una aplicación software que se
codifica en un lenguaje soportado por los navegadores web en la que se confía la
ejecución al navegador. Las aplicaciones web son populares debido a lo práctico
del navegador web como cliente ligero, a la independencia del sistema operativo,
así como a la facilidad para actualizar y mantener aplica ciones web sin distribuir e
instalar software a miles de usuarios potenciales. Existen aplicaciones como los
web mails, wikis, weblogs, tiendas en línea y la propia Wikipedia que son ejemplos
bien conocidos de aplicaciones web. Es importante mencionar que una página
Web puede contener elementos que permiten una comunicación activa entre el
usuario y la información. Esto permite que el usuario acceda a los datos de mod o
interactivo, gracias a que la página responderá a cada una de sus acciones, como
por ejemplo rellenar y enviar formularios, participar en juegos diversos y acceder a
gestores de base de datos de todo tipo. Una ventaja significativa es que las
aplicaciones web deberían funcionar igual independientemente de la versión del
sistema operativo instalado en el cliente. En vez de crear clientes para Windows,
Mac OS X, GNU/Linux y otros sistemas operativos, la aplicación web se escribe
una vez y se ejecuta igual en todas partes. Sin embargo, hay aplicaciones
inconsistentes escritas con HTML, CSS, DOM y otras especificaciones estándar
para navegadores web que pueden causar problemas en el desarrollo y soporte
de estas aplicaciones, principalmente debido a la falta de adicción de los
navegadores a dichos estándares web (especialmente versiones de Internet
Explorer anteriores a la 7.0). Adicionalmente, la posibilidad de los usuarios de
personalizar muchas de las características de la interfaz (tamaño y color de
fuentes, tipos de fuentes, inhabilitar Javascript) puede interferir con la consistencia
de la aplicación web. Otra aproximación es utilizar AdobeFlash Player o Java
applets para desarrollar parte o toda la interfaz de usuario. Como casi todos los
navegadores incluyen soporte para estas tecnologías (usualmente por medio de
plug-ins), las aplicaciones basadas en Flash o Java pueden ser implementadas
con aproximadamente la misma facilidad. Dado que ignoran las configuraciones
de los navegadores, estas tecnologías permiten más control sobre la interfaz,
aunque las incompatibilidades entre implementaciones Flash o Java puedan crear
nuevas complicaciones, debido a que no son estándares. Por las similitudes con
una arquitectura cliente-servidor, con un cliente "no ligero", existen discrepancias
sobre el hecho de llamar a estos sistemas “aplicaciones web”; un término
alternativo es “Aplicación Enriquecida de Internet”. Aunque existen muchas
variaciones posibles, una aplicación web está normalmente estructurada como
una aplicación de tres-capas. En su forma más común, el navegador web ofrece la
primera capa y un motor capaz de usar alguna tecnología web dinámica (ejemplo:
PHP, Java Servlets o ASP, ASP.NET, CGI, ColdFusion, Perl, Python o Ruby
onRails) constituye la capa del medio. Por último, una base de datos constituye la
tercera y última capa. El navegador web manda peticiones a la capa del medio
que ofrece servicios valiéndose de consultas y actualizaciones a la base de datos
y a su vez proporciona una interfaz de usuario.
2.4.1 Ventajas de las aplicaciones Web
i. Ahorra tiempo: Se pueden realizar tareas sencillas sin necesidad de
descargar ni instalar ningún programa.
ii. No hay problemas de compatibilidad: Basta tener un navegador
actualizado para poder utilizarlas.
iii. No ocupan espacio en nuestro disco duro.
iv. Actualizaciones inmediatas: Como el software lo gestiona el propio
desarrollador, cuando nos conectamos estamos usando siempre la última
versión que haya lanzado.
v. Bajo consumo de recursos: Dado que toda (o gran parte) de la aplicación
no se encuentra en nuestra computadora, muchas de las tareas que
realiza el software no consumen recursos nuestros porque se realizan
desde otro equipo.
vi. Multiplataforma: Se pueden usar desde cualquier sistema operativo
porque sólo es necesario tener un navegador.
vii. Portables: Es independiente de la computadora donde se utilice (una
computadora de escritorio o una portátil) porque se accede a través de
una página web (sólo es necesario disponer de acceso a Internet). La
reciente tendencia al acceso a las aplicaciones web a través de teléfonos
móviles requiere sin embargo un diseño específico de los ficheros CSS
para no dificultar el acceso de estos usuarios.
viii. La disponibilidad suele ser alta porque el servicio se ofrece desde
múltiples localizaciones para asegurar la continuidad del mismo.
ix. Los virus no dañan los datos porque éstos están guardados en el
servidor de la aplicación.
x. Colaboración: Gracias a que el acceso al servicio se realiza desde una
única ubicación es sencillo el acceso y compartición de datos por parte
de varios usuarios. Tiene mucho sentido, por ejemplo, en aplicaciones
online de calendarios u oficina.
xi. Los navegadores ofrecen cada vez más y mejores funcionalidades para
crear aplicaciones web ricas (RIAs)
2.5 Sistema Operativo Android
Android es un sistema operativo móvil basado en Linux, que junto con
aplicaciones middleware, está enfocado para ser utilizado en dispositivos móviles
como teléfonos inteligentes y tabletas. Es desarrollado por la Open Handset
Alliance, la cual es liderada por Google.
Fue desarrollado inicialmente por Android Inc., una firma comprada por Google en
2005. Es el principal producto de la Open Handset Alliance, un conglomerado de
fabricantes y desarrolladores de hardware, software y operadores de servicio. Las
unidades vendidas de teléfonos inteligentes con Android se ubican en el primer
puesto en los Estados Unidos, en el segundo y tercer trimestres de 2010, con una
cuota de mercado de 43,6% en el tercer trimestre. Para agosto 2012, Android
lidera la cuota del mercado con aproximadamente 70% de participación.3
Tiene una gran comunidad de desarrolladores escribiendo aplicaciones para
extender la funcionalidad de los dispositivos. Actualmente, octubre 2012, se han
sobrepasado las 400,000 aplicaciones (de las cuales, dos tercios son gratuitas)
disponibles para la tienda de aplicaciones oficial de Android: Google Play , sin
tener en cuenta aplicaciones de otras tiendas no oficiales para Android, como
pueden ser la App Store de Amazon o la tienda de aplicaciones Samsung Apps de
Samsung. Google Play (anteriormente Android Market) es la tienda de
aplicaciones en línea administrada por Google, aunque existe la posibilidad de
obtener software externamente. Los programas están escritos en el lenguaje de
programación Java. No obstante, no es un sistema operativo libre de malware,
aunque la mayoría de ello es descargado de sitios de terceros.
El anuncio del sistema Android se realizó el 5 de noviembre de 2007 junto con la
creación de la Open Handset Alliance, un consorcio de 78 compañías de
hardware, software y telecomunicaciones dedicadas al desarrollo de estándares
abiertos para dispositivos móviles. Google liberó la mayoría del código de Android
bajo la licencia Apache, una licencia libre y de código abierto. Actualmente Android
posee aproximadamente el 32.9% de cuota de mercado a escala mundial de los
teléfonos inteligentes, por delante de Symbian OS que posee una cuota
aproximada del 30.6%. En tercer lugar se sitúa iOS con una cuota de mercado del
16%.
La estructura del sistema operativo Android se compone de aplicaciones que se
ejecutan en un framework Java de aplicaciones orientadas a objetos sobre el
núcleo de las bibliotecas de Java en una máquina virtual Dalvik con compilación
en tiempo de ejecución. Las bibliotecas escritas en lenguaje C incluyen un
administrador de interfaz gráfica (surface manager), un framework OpenCore, una
3 Android controla casi el 70% de la cuota del mercado mundial.
http://www.tuexperto.com/2012/08/09/android -controla-casi-el-70-de-la-cuota-de-mercado-mundial/
base de datos relacional SQLite, una API gráfica OpenGL ES 2.0 3D, un motor de
renderizado WebKit, un motor gráfico SGL, SSL y una biblioteca estándar de
CBionic. El sistema operativo está compuesto por 12 millones de líneas de código,
incluyendo 3 millones de líneas de XML, 2.8 millones de líneas de lenguaje C, 2.1
millones de líneas de Java y 1.75 millones de líneas de C++.
2.5.1 Arquitectura
Los componentes principales del sistema operativo de Android
1. Aplicaciones: las aplicaciones base incluyen un cliente de correo
electrónico, programa de SMS, calendario, mapas, navegador,
contactos y otros. Todas las aplicaciones están escritas en lenguaje de
programación Java.
2. Marco de trabajo de aplicaciones: los desarrolladores tienen acceso
completo a los mismos APIs del framework usados por las aplicaciones
base. La arquitectura está diseñada para simplificar la reutilización de
componentes; cualquier aplicación puede publicar sus capacidades y
cualquier otra aplicación puede luego hacer uso de esas capacidades
(sujeto a reglas de seguridad del framework). Este mismo mecanismo
permite que los componentes sean remplazados por el usuario.
3. Bibliotecas: Android incluye un conjunto de bibliotecas de C/C++ usadas
por varios componentes del sistema. Estas características se exponen a
los desarrolladores a través del marco de trabajo de aplicaciones de
Android; algunas son: System C library (implementación biblioteca C
estándar), bibliotecas de medios, bibliotecas de gráficos, 3D y SQLite,
entre otras.
4. Runtime de Android: Android incluye un set de bibliotecas base que
proporcionan la mayor parte de las funciones disponibles en las
bibliotecas base del lenguaje Java. Cada aplicación Android corre su
propio proceso, con su propia instancia de la máquina virtual Dalvik.
Dalvik ha sido escrito de forma que un dispositivo puede correr múltiples
máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el
formato DalvikExecutable (.dex), el cual está optimizado para memoria
mínima. La Máquina Virtual está basada en registros y corre clases
compiladas por el compilador de Java que han sido transformadas al
formato.dex por la herramienta incluida "dx".
5. Núcleo Linux: Android depende de Linux para los servicios base del
sistema como seguridad, gestión de memoria, gestión de procesos, pila
de red y modelo de controladores. El núcleo también actúa como una
capa de abstracción entre el hardware y el resto de la pila de software.
2.5.2 Aplicaciones para Android
Las aplicaciones se desarrollan habitualmente en el lenguaje Java con Android
Software Development Kit (Android SDK), pero están disponibles otras
herramientas de desarrollo, incluyendo un Kit de Desarrollo Nativo para
aplicaciones o extensiones en C o C++, Google App Inventor, un entorno
visual para programadores novatos.
El desarrollo de aplicaciones para Android no requiere aprender lenguajes
complejos de programación. Todo lo que se necesita es un conocimiento
aceptable de Java y estar en posesión del kit de desarrollo de software o
“SDK” provisto por Google el cual se puede descargar gratuitamente.
Las aplicaciones Android vienen empacadas en archivos con extensión AP K.
Este formato es una variante del formato JAR de Java y se usa para distribuir
e instalar componentes para la plataforma Android para teléfonos inteligentes
y tabletas. Un archivo .apk normalmente contiene lo siguiente:
AndroidManifest.xml
classes.dex
resources.arsc
res (carpeta)
META-INF (carpeta)
El Formato APK es básicamente un archivo comprimido ZIP con diferente
extensión por lo cual pueden ser abiertos e inspeccionados usando un
software.
2.6 Servidor Web
Un servidor web o servidor HTTP es un programa informático que procesa una
aplicación del lado del servidor realizando conexiones bidireccionales y/o
unidireccionales y síncronas o asíncronas con el cliente generando o cediendo
una respuesta en cualquier lenguaje o Aplicación del lado del cliente. El código
recibido por el cliente suele ser compilado y ejecutado por un navegador web.
Para la transmisión de todos estos datos suele utilizarse algún protocolo.
Generalmente se utiliza el protocolo HTTP para estas comunicaciones,
perteneciente a la capa de aplicación del modelo OSI. El término también se
emplea para referirse a la computadora que ejecuta el programa.
2.7 Servicios Web
Es una pieza de software que utiliza un conjunto de protocolos y estándares qu e
sirven para intercambiar datos entre aplicaciones. Distintas aplicaciones de
software desarrolladas en lenguajes de programación diferentes, y ejecutadas
sobre cualquier plataforma, pueden utilizar los servicios web para intercambiar
datos en redes de computadoras como Internet. La interoperabilidad se consigue
mediante la adopción de estándares abiertos. Las organizaciones OASIS y W3C
son los comités responsables de la arquitectura y reglamentación de los servic ios
Web. Para mejorar la interoperabilidad entre distintas implementaciones de
servicios Web se ha creado el organismo WS-I, encargado de desarrollar diversos
perfiles para definir de manera más exhaustiva estos estándares.
i. Web Services Protocol Stack: Así se denomina al conjunto de servicios y
protocolos de los servicios Web.
ii. XML (Extensible Markup Language): Es el formato estándar para los datos
que se vayan a intercambiar.
iii. SOAP (Simple Object Access Protocol) o XML-RPC (XML Remote
Procedure Call): Protocolos sobre los que se establece el in tercambio.
iv. Otros protocolos: los datos en XML también pueden enviarse de una
aplicación a otra mediante protocolos normales como HTTP (Hypertext
Transfer Protocol), FTP (File Transfer Protocol), o SMTP (Simple Mail
Transfer Protocol).
v. WSDL (Web Services Description Language): Es el lenguaje de la interfaz
pública para los servicios Web. Es una descripción basada en XML de los
requisitos funcionales necesarios para establecer una comunicación con
los servicios Web.
vi. UDDI (Universal Description, Discovery and In tegration): Protocolo para
publicar la información de los servicios Web. Permite comprobar qué
servicios web están disponibles.
vii. WS-Security (Web Service Security): Protocolo de seguridad aceptado
como estándar por OASIS (Organization for the Advancement of
Structured Information S tandards). Garantiza la autenticación de los
actores y la confidencialidad de los mensajes enviados.
viii. Aportan interoperabilidad entre aplicaciones de software
independientemente de sus propiedades o de las plataformas sobre las
que se instalen.
ix. Los servicios Web fomentan los estándares y protocolos basados en texto,
que hacen más fácil acceder a su contenido y entender su funcionamiento.
x. Permiten que servicios y software de diferentes compañías ubicadas en
diferentes lugares geográficos puedan ser combinados fácilmente para
proveer servicios integrados.
xi. Para realizar transacciones no pueden compararse en su grado de
desarrollo con los estándares abiertos de computación distribuida como
CORBA (Common Object Request Broker Architecture).
xii. Su rendimiento es bajo si se compara con otros modelos de computación
distribuida, tales como RMI (Remote Method Invocation), CORBA o DCOM
(Distributed Component ObjectModel). Es uno de los inconvenientes
derivados de adoptar un formato basado en texto. Y es que entre los
objetivos de XML no se encuentra la concisión ni la eficacia de
procesamiento.
xiii. Al apoyarse en HTTP, pueden esquivar medidas de seguridad basadas en
firewall cuyas reglas tratan de bloquear o auditar la comunicación entre
programas a ambos lados de la barrera.
La principal razón para usar servicios Web es que se pueden utilizar con HTTP
sobre TCP (Transmission Control Protocol) en el puerto 80. Dado que las
organizaciones protegen sus redes mediante firewalls -que filtran y bloquean gran
parte del tráfico de Internet-, cierran casi todos los puertos TCP salvo el 80, que
es, precisamente, el que usan los navegadores. Los servicios Web utilizan este
puerto, por la simple razón de que no resultan bloqueados. Es importante señalar
que los servicios web se pueden utilizar sobre cualquier protocolo, sin embargo,
TCP es el más común.
Otra razón es que, antes de que existiera SOAP, no había buenas interfaces para
acceder a las funcionalidades de otros ordenadores en red. Las que había eran ad
hoc y poco conocidas, tales como EDI (Electronic Data Interchange), RPC
(Remote Procedure Call), u otras APIs.
Una tercera razón por la que los servicios Web son muy prácticos es que pueden
aportar gran independencia entre la aplicación que usa el servicio Web y el propio
servicio. De esta forma, los cambios a lo largo del tiempo en uno no deben afectar
al otro. Esta flexibilidad será cada vez más importante, dado que la tendencia a
construir grandes aplicaciones a partir de componentes distribuidos más pequeños
es cada día más utilizada.
Se espera que para los próximos años mejoren la calidad y cantidad de servicios
ofrecidos basados en los nuevos estándares.
2.8 Moodle
Moodle es una aplicación web de tipo Ambiente Educativo Virtual, un sistema de
gestión de cursos, de distribución libre, que ayuda a los educadores a crear
comunidades de aprendizaje en línea. Este tipo de plataformas tecnológicas
también se conoce como LMS (Learning Management System) .
Moodle fue creado por Martin Dougiamas, quien fue administrador de WebCT en
la Universidad Tecnológica de Curtin . Basó su diseño en las ideas del
constructivismo en pedagogía que afirman que el conocimiento se construye en la
mente del estudiante en lugar de ser transmitido sin cambios a partir de libros o
enseñanzas y en el aprendizaje colaborativo. Un profesor que opera desde este
punto de vista crea un ambiente centrado en el estudiante que le ayuda a construir
ese conocimiento con base en sus habilidades y conocimientos propios en lugar
de simplemente publicar y transmitir la información que se considera que los
estudiantes deben conocer.
La primera versión de la herramienta apareció el 20 de agosto de 2002, a partir de
allí han aparecido nuevas versiones de forma regular. Hasta julio de 2008, la base
de usuarios registrados incluye más 21 millones, distribuidos en 46.000 sitios en
todo el mundo y está traducido a alrededor de 91 idiomas.
2.8.1 Especificaciones Técnicas
Servidor
En términos de arquitectura, Moodle es una aplicación web que se ejecuta sin
modificaciones en Unix, GNU/Linux, OpenSolaris, FreeBSD, Windows, Mac OS X,
NetWare y otros sistemas que soportan PHP, incluyendo la mayoría de
proveedores de alojamiento web.
En cuanto al servidor web corre principalmente en Apache o IIS. No esta
completamente probado o soportado pero debería funcionar en los siguientes:
lighttpd, nginx, cherokee, zeus and LiteSpeed. La versión mínima de PHP
soportada en la versión de Moodle 2.2 es PHP 5.3.2.
Los datos se almacenan en una base de datos SQL. Los sistemas de gestión de
bases de datos soportados son: MySQL, PostgreSQL, MSSQL, Oracle, SQLite.
Su instalación del servidor no es muy diferente a la de otros sistemas de gestión
de contenido conocidos hasta el momento. Se debe tener en cuenta la forma en
que se desea realizar la instalación: si es de forma integrada (m) o distribuida
(servidor de aplicaciones y de base de datos en servidores físicos diferentes).
Clientes
Al ser una aplicación web el cliente puede ser casi cualquier navegador web
moderno. Se debe contar con las extensiones necesarias para visualizar los
vídeos, audio y demás material multimedia que un curso pueda contener.
2.9 Sistema Gestor de Base de Datos
Una base de datos (BD) se define como un “conjunto de datos relacionados entre
sí”. Los conceptos relevantes en esta definición son “datos” y “relacionados”. Un
sistema gestor de base de datos o SGBD, es un conjunto de programas de
propósito general, que proporcionan funcionalidades horizontales para facilitar la
gestión de la información contenida en una base de datos.
Existen distin tos objetivos que deben cumplir los SGBD:
a) Abstracción de la información . Los SGBD ahorran a los usuarios detalles
acerca del almacenamiento físico de los datos. Da lo mismo si una base de
datos ocupa uno o cientos de archivos, este hecho se hace transparente al
usuario. Así, se definen varios niveles de abstracción .
b) Independencia . La independencia de los datos consiste en la capacidad de
modificar el esquema (físico o lógico) de una base de datos sin tener que
realizar cambios en las aplicaciones que se sirven de ella.
c) Consistencia. En aquellos casos en los que no se ha logrado eliminar la
redundancia, será necesario vigilar que aquella información que aparece
repetida se actualice de forma coherente, es decir, que todos los datos
repetidos se actualicen de forma simultánea. Por otra parte, la base de
datos representa una realidad determinada que tiene determinadas
condiciones, por ejemplo que los menores de edad no pueden tener licencia
de conducir. El sistema no debería aceptar datos de un conductor menor de
edad. En los SGBD existen herramientas que facilitan la programación de
este tipo de condiciones.
d) Seguridad . La información almacenada en una base de datos puede llegar
a tener un gran valor. Los SGBD deben garantizar que esta información se
encuentra segura de permisos a usuarios y grupos de usuarios, que
permiten otorgar diversas categorías de permisos.
e) Manejo de transacciones . Una transacción es un programa que se ejecuta
como una sola operación. Esto quiere decir que luego de una ejecución en
la que se produce una falla es el mismo que se obtendría si el programa no
se hubiera ejecutado. Los SGBD proveen mecanismos para programar las
modificaciones de los datos de una forma mucho más simple que si no se
dispusiera de ellos.
f) Tiempo de respuesta . Lógicamente, es deseable minimizar el tiempo que
el SGBD demora en proporcionar la información solicitada y en almacenar
los cambios realizados.
2.10 Teléfonos Móviles
Los teléfonos móviles obtuvieron su nombre de su primera aplicación: Permitir a
las personas hacer llamadas siendo dispositivos móviles. La arquitectura de la
comunicación era dominada por estaciones de base comunicándose con los
teléfonos. Estas estaciones eran necesarias para entrar a las redes telefónicas
existentes y por lo tanto, permitiendo comunicarse con líneas fijas. Además, las
estaciones base y la red permitían comunicarse con otros usuarios de telefonía
móvil en diferentes células. Al principio, referido como primera generación o 1G de
redes móviles, no había necesidad de funcionalidad adicional, además de los
servicios de voz. Con la segunda generación o 2G se dio el cambio de sistemas
análogos a sistemas digitales, se introdujeron servicios mejorados tales como el
servicio de mensajes cortos o SMS (short message service) y conexiones de datos
a internet, también se dio un cambio importante: la división de la red y los
proveedores de servicio, de tal forma que se tenían cuatro grandes participantes
en el mundo de la tecnología móvil:
1. Proveedores de red.
2. Proveedores de servicio.
3. Cliente.
4. Fabricantes de teléfonos móviles.
Antes de eso el proveedor de red tenía el monopolio para decidir cuales servicios
iban a estar disponibles en los teléfonos. La tercera generación o 3G no trajo
consigo muchos cambios respecto a la segunda. El principal cambio ha sido que
los de tercera generación ofrecen mayor rapidez en las conexiones de datos.
2.11 Generalidades sobre los teléfonos inteligentes o
smartphones.
El teléfono inteligente o smartphone es un término comercial que se utiliza para
referirse a un teléfono que posee más funciones que un teléfono celular común.
Estos soportan clientes de correo electrónico, navegación por Internet y una de
sus características principales es la de soportar aplicaciones para incrementar el
procesamiento de datos y la conectividad. Estas aplicaciones pueden ser
desarrolladas por el fabricante, el operador o por un desarrollador independiente.
Todos los teléfonos celulares no todos son iguales, hay desde los más austeros en
cuanto a funciones, hasta los llamados teléfonos inteligentes o smartphone, los
cuales en un principio estaban dirigidos a usuarios empresariales pues sus
características están dirigidas a l uso profesional pero ahora son de uso común. El
smartphone o teléfono inteligente es un teléfono móvil con características similares
a las de una computadora personal, por lo regular este tipo de los teléfonos
inteligentes pueden soportar por completo un cliente de correo electrónico e
incluyen un organizador personal de características avanzadas para fines
empresariales, incluyendo la conexión a datos. Casi todos los teléfonos
inteligentes permiten la instalación de programas para incrementar el
procesamiento de datos y la conectividad, a veces estas aplicaciones pueden ser
desarrolladas por el fabricante del dispositivo, por el operador o por un tercero4.
En estos teléfonos, también como en las tabletas, podemos encontrar que se
utilizan varios sistemas operativos: Android OS , RIM Blackberry, iOS , Web OS,
Windows Mobile , Symbian entre otros. Los más distribuidos actualmente son
Android e iOS. Aunque para el proyecto que se realizará, se elegirá solamente
Android que aunque no sea la más distribuida en la Universidad Francisco
Gavidia, es la de mayor crecimiento a nivel mundial, este estudio se expone en el
Capítulo IV.
4 Los sistemas operativos de los smartphones. http://ciro-canales-del-razo.suite101.net/sistemas-
operativos-de-smartphone-a2305
2.12 Desarrollo de aplicaciones para dispositivos móviles
El desarrollo de aplicaciones móviles es el proceso por el cual se crea un
programa para dispositivos móviles de baja potencia tales como asistentes
personales (PDA), teléfonos inteligentes y tabletas. Estos programas pueden venir
preinstalados con el sistema operativo del dispositivo o instalados por el usuario
luego de descargarlos.
Estas son desarrolladas en las plataformas: Android, BlackBerry, iOS y Windows
Mobile.
Estas plataformas poseen su Entorno In tegrado de Desarrollo o IDE, los cuales
proveen de las herramientas para perm itir al desarrollador escribir, probar y
desplegar las aplicaciones en el dispositivo destino.
Entre los entornos integrados tenemos: Eclipse y Netbeans para Android (se
requiere la instalación de plugins), XCode para iPhone y iPad, Microsoft Visual
Studio para Windows Mobile y para BlackBerry (se requiere la instalación de
plugins).
2.13 ¿Cómo se prueba una aplicación móvil?
La aplicación es probada en el ambiente de desarrollo utilizando emuladores para
luego ser probadas en el dispositivo destino. Se muestra a continuación un listado
de herramientas gratis para hacer estas pruebas.
Nombre Característica
Emulador Google Android Emulador de Android para ser ejecutado en Windows
Emulador Oficial de Android SDK Se ejecuta imitando las características físicas y de software del dispositivo
MobiOne Emulador para iPhone, BlackBerry y Android
TestiPhone Para probar aplicaciones para iPhone
BlackBerry Simulator Utilizado para comprobar el comportamiento del teclado, pantalla y TrackBall del dispositivo
Tabla 2. Emuladores para aplicaciones móviles
CAPÍTULO III
METODOLOGÍA DE LA INVESTIGACION
3.1 Generalidades
Por medio de la investigación de Campo se busca obtener información que nos
pueda ser útil para la toma de decisiones y el establecimiento de requisitos de
cómo debe estará diseñada la aplicación para el acceso de los estudiantes a la
información, esta nos servirá para conocer las opiniones de la comunidad
universitaria y también que se dé a conocer a potenciales estudiantes que pueda
tener la universidad.
También se espera comprobar si en verdad es necesaria la creación de este
aplicativo móvil y que se espera como resultado de la elaboración del mismo por
parte de las personas beneficiadas.
La información recolectada nos servirá para poder elaborar una mejor estrategia
para el desarrollo del aplicativo móvil.
3.2 Ámbito de la investigación
La investigación se realizará en las instalaciones de la UFG, sede central, San
Salvador.
3.3 Metodología de la investigación
Los tipos de técnica de investigación que se utilizaron son:
a) Investigación de Documental
b) Investigación de Campo
a) Investigación documental
En cuanto a la investigación documental se utilizaron diversos recursos: Internet,
libros sobre desarrollo de aplicaciones móviles, libros sobre lenguaje de
programación java.
b) Investigación de campo
Para la investigación de campo, se realizaron entrevistas a personal de la UFG y
observación de fenómenos como la saturación de las Redes Locales a
determinadas horas. Esta investigación fue fundamental, ya que se obtuvo
información sobre los aspectos relacionados con los objetivos del Proyecto. Los
dos tipos de metodología se implementaron al mismo tiempo, ya que ambos son
compatibles para poderse realizar en conjunto.
3.4 Técnicas e instrumentos de Investigación
Con el nombre genérico de instrumentos de investigación se denomina a todos los
instrumentos que pueden servir para medir las variables, recopilar información con
respecto a ellas o simplemente observar su comportamiento. Los instrumentos
que pueden medir las características de las variables se denominan pruebas, son
los instrumentos que sirven para medir distintas variables conductuales, en
especial los resultados del objeto de la investigación. A través de los datos que
proporcionan los instrumentos se trata de obtener información exacta sobre el
logro de los objetivos y se detectan los éxitos y fracasos. Cuando el investigador
no puede medir directamente las variables debe recopilar información acerca de
los fenómenos que le interesa conocer haciendo uso de ciertos instrumentos. Para
ello emplea listas de cotejo, hace el análisis documental, construye escalas de
opinión, etc. En otros casos, el investigador debe observar el comportamiento de
las variables y entonces empleará instrumentos o guías de observa ción que, a su
vez, pueden ser estructurados o no estructurados.
Técnicas de investigación tenemos:
3.4.1 Recolección Bibliográfica
Técnica para búsqueda en recursos bibliográficos, mediante el uso de libros,
revistas, folletos, internet, e tc. Que permitan en riquecer la investigación a
realizar.
3.4.2 Entrevista
Las entrevistas son un método muy útil para recabar datos y gracias a ciertas
cualidades especiales todavía se usan muchísimo. La flexibilidad es uno de
sus Aspectos más sobresalientes. El “rapport” (relación personal) que se
establece con los sujetos crea una atmósfera de cooperación en la que puede
obtenerse información verídica. Hay que tomar en cuenta la clase de persona
que se va a entrevistar y la situación dentro de la cual se desarrolla la
entrevista. El entrevistador puede explayarse sobre alguna pregunta, explicar
su significado en caso de que a su interlocutor le parezca poco clara. Ninguno
de los otros tipos de recopilación de datos, entre ellos los cuestionarios y las
pruebas, ofrece estas ventajas.
Hay dos tipos de entrevistas: estructuradas y no estructuradas. En las
primeras las preguntas y las respuestas alternativas que están permitidas a los
sujetos se fijan de antemano y se aplican con rigidez a todos ellos. La ventaja
es que se trata de un sistema normalizado, de modo que las respuestas
pueden ser clasificadas y analizadas fácilmente. Su desventaja es la falta de
flexibilidad y que dan la impresión de ser demasiado formales. Las
restricciones impuestas a este tipo de entrevista aumentan su confiabilidad,
pero pueden mermar su profundidad.
3.4.3 Encuesta
En las entrevistas el contacto directo con los sujetos requiere tiempo y dinero.
Una buena parte de esa información puede obtenerse por medio un
cuestionario escrito. Si se le compara con la entrevista, ésta es más eficiente y
práctica y permite usar una muestra más amplia. En la investigación
experimental se utiliza frecuentemente.
He aquí otra de sus ventajas: los sujetos reciben instrucciones normalizadas y
ni la apariencia personal ni el estado de ánimo ni la conducta del examinador
influyen en los resultados finales.
Los cuestionarios son de dos clases: estructurados, o de forma cerrada, y no
estructurados, o de forma abierta. Los primeros contienen preguntas y
respuestas alternativas. Las respuestas dadas a cada pregunta deberán
agotar todas las posibles preguntas y excluirse mutuamente. En los
cuestionarios no estructurados no hay respuestas sugeridas.
La administración y la calificación de un cuestionario estructurado se realizan
en forma directa, y los resultados se prestan a un análisis fácil. Este tipo de
cuestionario tiene la desventaja de obligar a los respondientes a escoger entre
una de varias respuestas alternativas seleccionadas previamente, aunque tal
vez no vislumbren respuestas claras, o a elegir alternativas que no
representen realmente sus actitudes.
Por el contrario, los cuestionarios no estructurados tienen la ventaja de
dejarlos en libertad para que expresen sus opiniones y sus actitudes, sólo que
la información que aportan es difícil de procesar y analizar. Al contestar
cuestionarios no estructurados, los sujetos pueden omitir puntos importantes,
recalcar asuntos que carezcan de interés para el investigador o que no tengan
importancia para el estudio.
Por tal razón la mayoría de los investigadores prefiere los cuestionarios
estructurados. Una desventaja de ambos tipos es la posibilidad de que los
respondientes malinterpreten las preguntas. Es muy difícil elaborar una serie
preguntas cuyo significado sea tan claro como el agua para todos. El
investigador puede saber con exactitud lo que significa una pregunta, pero por
una formulación deficiente o la distinta acepción que se da a los términos, el
sujeto los entiende erróneamente. Esta desventaja puede obviarse mediante
un estudio piloto en el que se ensaya el cuestionario con unos cuantos
sujetos, representativos de aquellos a quienes se aplicará.
Una desventaja peculiar del envío de cuestionarios por correo en su bajo
porcentaje de respuestas. Por lo común cabe esperar que re gresen menos de
la mitad, lo cual no sólo reduce el tamaño de la muestra sino que puede viciar
los resultados, e impedir que se hagan generalizaciones válidas. No es
legítimo suponer que la ausencia de respuestas se distribuye aleatoriamente a
lo largo de un grupo.
Los estudios han mostrado que suele haber diferencias sistemáticas en las
características de los sujetos que responden o no a los cuestionarios. Los que
contestan pueden ser más inteligentes, educados, concienzudos e interesados
en la cuestión y en general más favorables al tema del cuestionario. Una
muestra no representativa como ésta puede dañar la generalización de los
resultados. La meta de un cuestionario es obtener de un 70 a 80 por ciento de
respuestas. Si la ausencia de respuestas supera a l 30 por ciento, el valor de
los resultados se pondrá en duda. Un cuestionario bien construido tiene
mayores probabilidades de producir una buena respuesta que uno que esté
mal elaborado.
3.4.4 Ficha Bibliográfica
Instrumento que se utilizará para recolectar la información encontrada.
3.4.5 Guía de Entrevista
Pasos a seguir para que la entrevista se dé de una forma ordenada.
3.4.6 Guía de Encuesta
Para recolectar información a partir de una serie de preguntas estructuradas.
3.5 Determinación del Universo
Como universo se ha tomado a toda la población universitaria, esto incluye
solamente estudiantes activos.
El tipo de muestreo que se utilizó, fue el muestreo probabilístico simple, ya que
para realizar la investigación todos los estudiantes tenían la mism a probabilidad de
poder ser seleccionados para la muestra que se determinó.
3.6 Tamaño de la muestra
La muestra es, en esencia, un subgrupo de la población. Se puede decir que es un
subconjunto de elementos que pertenecen a ese conjunto definido en sus
necesidades al que llamamos población. De la población es conveniente extraer
muestras representativas del universo. Se debe definir en le plan, y justificar, los
universos en estudio, el tamaño de la muestra, el método a utilizar, y el proceso de
selección de las unidades de análisis. En realidad, pocas veces es posible medir a
la población por lo que obtendremos o seleccionaremos y, desde luego,
esperamos que este subgrupo sea un reflejo fiel de la población.
Básicamente se categorizar las muestras es dos grandes ramas: las
probabilísticas y las no probabilísticas. Entiéndase por muestras probabilísticas
como el subgrupo de la población en el que todos los elemento de este tienen la
misma probabilidad de ser escogidos; por consiguiente, las muestras no
probabilísticas es cuando la elección de los elementos no depende la probabilidad,
sino con causas relacionadas con las características de la investigación o de quien
hace la muestra.
3.6.1 Selección de la muestra
Es la actividad por la cual se toman ciertas muestras de una población de
elementos de los cuales vamos a extraer algunos criterios de decisión, el
muestreo es importante porque a través de él podemos hacer análisis de
situaciones de una empresa o de algún campo de la sociedad. Una muestra
debe ser representativa si va a ser usada para estimar las características de la
población. Los métodos para seleccionar una muestra representativa son
numerosos, dependiendo del tiempo, dinero y habilidad disponibles para tomar
una muestra y la naturaleza de los elementos individuales de la población. Por
lo tanto, se requiere un gran volumen para incluir todos los tipos de métodos
de muestreo.
Entre los tipos de muestra más usados en la investigación tenemos:
i. Muestreo aleatorio simple : la forma más común de obtener una muestra es
la selección al azar. Es decir, cada uno de los individuos de una población
tiene la misma posibilidad de ser elegido. Si no se cumple este requisito, se
dice que la muestra es viciada. Para tener la seguridad de que la muestra
aleatoria no es viciada, debe emplearse para su constitución una tabla de
números aleatorios.
ii. Muestreo estratificado : una muestra es estratificada cuando los elementos
de la muestra son proporcionales a su presencia en la población. La
presencia de un elemento en un estrato excluye su presencia en otro.
Para este tipo de muestreo, se divide a la población en varios grupos o
estratos con el fin de dar representatividad a los distintos factores que
integran el universo de estudio. Para la selección de los elementos o
unidades representantes, se utiliza el método de muestreo aleatorio.
iii. Muestreo por cuotas: se divide a la población en estratos o categorías, y
se asigna una cuota para las diferentes categorías y, a juicio del
investigador, se selecciona las unidades de muestreo. La muestra debe
ser proporcional a la población, y en ella deberán tenerse en cuenta las
diferentes categorías. El muestreo por cuotas se presta a distorsiones, al
quedar a criterio del investigador la selección de las categorías.
iv. Muestreo intencionado : también recibe el nombre de sesgado. El
investigador selecciona los elementos que a su juicio son representativos,
lo que exige un conocimiento previo de la población que se investiga.
v. Muestreo mixto : se combinan diversos tipos de muestreo. Por ejemplo: se
puede seleccionar las unidades de la muestra en forma aleatoria y
después aplicar el muestreo por cuotas.
vi. Muestreo tipo master simple : es una aplicación combinada y especial de
los tipos de muestra existentes. Consiste en seleccionar una muestra
"para ser usada" al disponer de tiempo, la muestra se establece
empleando procedimientos sofisticados; y una vez establecida, constituirá
el módulo general del cual se extraerá la muestra definitiva conforme a la
necesidad específica de cada investigación.
El número de elementos a ser extraídos del universo se determinó utilizando la
fórmula de muestreo aleatorio simple para poblaciones finitas.
Donde
n = muestra z = intervalo de confianza
N = tamaño del universo p = probabilidad de éxito
q = probabilidad de fracaso d = error de estimación
Utilizaremos un nivel de confianza del 95%, por lo tanto, z=1.96. Y utilizando una
probabilidad de éxito del 50% y un error del 5% tenemos:
Determinación de z
El nivel de confianza en el caso de este proyecto lo tomamos al 95%, ya que
necesitábamos validez de los resultados, esto significa que el 95% de la
información obtenida fue viable.
Determinación de N
N es el universo o población donde se realizará la investigación de campo. La
cantidad de estudiantes activos con los que cuenta la Universidad Francisco
Gavidia es 12504. Por lo tanto, ese es el universo.
Determinación de p y q
Se tomaron al 50%1, debido a que no se posee información sobre una
aplicación móvil para el acceso de los estudiantes al contenido académico.
Determinación de d
El error máximo que se puede aceptar debe estar en el in tervalo de 2% a 10%,
ya que las variaciones superiores a 10% reducen la validez de la información,
en este caso se eligió el 6%, ya que es el promedio de 2% y 10%.
El error de estimación se utiliza para saber la precisión obtenida e n una
investigación.
1 Hernández Sampieri, R. “Metodología de la investigación”. Ed. McGraw Hill, 2ª. Edición 1998.
CAPITULO IV
RECOLECCIÓN DE LOS DATOS
1.1 Elaboración del instrumento de investigación
El instrumento de investigación a utilizar será la encuesta, la cual consistió en una
serie de preguntas en una modalidad semicerrada (tenemos respuesta de Si/No
con un por qué para que se de a conocer algo y tres con selección múltiple), para
saber cual era la opinión de los estudiantes.
4.2 Forma de determinar la confiabilidad
Para determinar la confiabilidad de una prueba, por lo gen eral, se compara dos
versiones de la misma prueba. La forma numérica de expresar esta comparación
es a través de un coeficiente de correlación (r) que puede existir entre ellas.
Cuanto más alto sea el coeficiente de correlación positiva entre las dos versiones
de la prueba, la prueba será más confiable. Demás está decir que el coeficiente de
correlación perfecto es 1.00 y para asignar alto grado de confiabilidad a una
prueba se debe esperar obtener coeficientes de, más o menos, 0 .80.
A continuación se presenta la encuesta que fue utilizada para la recolección de
datos:
Encuesta
Indicaciones: Marque con una X su respuesta. Por favor, no deje de contestar ninguna.
Nivel Académico:__________ Fecha:___________
1. ¿Ha tenido contratiempos al no poder encontrar una computadora disponible en alguna red local para
poder tener acceso a la plataforma de la U virtual?
Sí ____ No ______ ¿Por qué?__________________________________________
2. Si la respuesta a la pregunta anterior fue “Sí”: ¿Cuándo le ha sucedido esto, ha accedido al sitio de la
U virtual a través de su teléfono móvil?
Sí ____ No ______ ¿Por qué?__________________________________________
3. ¿Le gustaría acceder a la información sobre sus asignaturas mediante una aplicación insta lada en su
teléfono móvil?
Sí ____ No _____ ¿Por qué?____________________________________________
4. ¿Ha tenido algún problema en las horas de clase debido a la falta de algún documento o información
que solo se encuentra en el sitio de la U virtual?
Sí ____ No _____ ¿Por qué?____________________________________________
5. ¿Considera usted útil el desarrollo de una aplicac ión instalab le en su teléfono para acceder al
contenido de la U virtual?
Sí ____ No _____ ¿Por qué?____________________________________________
6. ¿Qué ventajas tendría el acceder al contenido de la U virtual mediante una aplicación para teléfonos
móviles?
___ Mayor comodidad para el acceso.
___ Obtener rápidamente la información que necesito
___ Evitar congestionamiento de la red local y dejarla para cosas que estrictamente necesita una PC
7. ¿Estaría de acuerdo con la creación de esta aplicación?
Sí ____ No _____ ¿Por qué?____________________________________________
8. ¿Qué opciones le gustaría tener en su aplicación? Puede seleccionar mas de 1 respuesta
1) Acceso a las notas ___
2) Acceso a documentos de la U virtual: _____
3) Mensajes de los docentes: ____
4) Consultar con el docente: ____
5) Envío de correos: ____
6) Calendario Académico: ____
7) Noticias de la Universidad: ____
9. ¿Utilizaría esta aplicación?
Sí ____ No _____ ¿Por qué?____________________________________________
10. ¿Qué sistema operativo utiliza su teléfono?
Android:____ Blackberry:_____ Nokia:_____ no es Smartphone:_____ otros:_____
4.3 Resultados obtenidos
A continuación se muestran los resultados obtenidos de la realización de la
encuesta a los estudiantes de la Universidad Francisco Gavidia.
Pregunta 1:
¿Ha tenido contratiempos al no poder encontrar una computadora disponible en
alguna red local para poder tener acceso a la plataforma de la U virtual?
Objetivo: Conocer si los estudiantes tienen contratiempos para acceder a las redes
locales.
Resultados
Respuestas Si No Total
Resultado 250 145 385
Porcentaje 62.33% 37.66% 100.00%
Tabla 3. Resultados de la pregunta 1.
Conclusión: Por el resultado se infiere que la mayoria de los estudiantes tienen
dificultades para acceder a algun equipo por falta de espacio en las redes locales.
Pregunta 2:
¿Si la respuesta a la pregunta anterior fue “Sí”: ¿Cuándo le ha sucedido esto, ha
accedido al sitio de la U virtual a través de su teléfono móvil?
Objetivo: Saber si los estudiantes acceden al sitio web a través de su dispositivo
móvil.
Respuestas Si No Total
Resultado 57 193 250
Porcentaje 22.80% 77.20% 100.00%
Tabla 4. Resultados de la pregunta 2.
Conclusión: la mayoría de estudiantes no accede al sitio de la universidad a través
de su dispositivo móvil.
Pregunta 3
¿Le gustaría acceder a la información sobre sus asignaturas mediante una
aplicación instalada en su teléfono móvil?
Objetivo: Saber si al estudiante le interesaría tener acceso a sus notas a través de
una aplicación móvil.
Respuestas Si No Total
Resultado 361 24 385
Porcentaje 93.77% 6.23% 100.00%
Tabla 5. Resultados de la pregunta 3.
Conclusión: a aproximadamente el 94% de los estudiantes les gustaría tener
información de sus materias a través de una aplicación móvil.
Pregunta 4
¿Ha tenido algún problema en las horas de clase debido a la falta de algún
documento o información que solo se encuentra en el sitio de la U virtual?
Objetivo: Saber si el estudiante necesita algún recurso que esté disponible en la
red en el momento de sus clases.
Respuestas Si No Total
Resultado 237 148 385
Porcentaje 61.55% 38.44% 100.00%
Tabla 6. Resultados de la pregunta 4.
Conclusión: Si los estudiantes poseyeran este tipo de aplicación en sus
dispositivos móviles les seria más fácil acceder al contenido de sus asignaturas:
documentos, videos, etc.
Pregunta 5
¿Considera usted útil el desarrollo de una aplicación instalable en su teléfono para
acceder al contenido de la U virtual?
Objetivo: Conocer la opinión de los estudiantes si consideran útil el desarrollo de
este tipo de aplicaciones.
Respuestas Si No Total
Resultado 380 5 385
Porcentaje 98.70% 1.30% 100.00%
Tabla 7. Resultados de la pregunta 5.
Conclusión: casi la totalidad de los estudiantes están de acuerdo con la utilidad de
un tipo de aplicación como este. La respuesta “no” puede deberse a que el
estudiante no toma en serio este estudio o no le interesa.
Pregunta 6
¿Qué ventajas tendría el acceder al contenido de la U virtual mediante una
aplicación para teléfonos móviles?
Objetivo: Obtener información sobre cual seria la mayor ventaja de acceder al
contenido mediante una aplicación móvil.
Respuestas Mayor comodidad para el acceso Obtener rápidamente la
información que necesito
Evitar congestionamiento de la red local y
dejarla para cosas que
estrictamente necesita una PC
Resultado 220 310 160
Tabla 8. Resultados de la pregunta 6.
Conclusión: Al observar el resultado se observa que la mayoría de respuestas se
orientan hacia la consecución rápida de la información y facilidad de acceso a la
misma.
Pregunta 7
¿Estaría de acuerdo con la creación de esta aplicación?
Objetivo: Saber si el estudiante está de acuerdo con este desarrollo.
Respuestas Si No Total
Resultado 381 4 385
Porcentaje 98.97% 1.03% 100.00%
Tabla 9. Resultados de la pregunta 7.
Conclusión: La gran mayoría de estudiantes están de acuerdo con el desarrollo.
Los que contestan “no” puede ser que no estén interesados.
Pregunta 8
¿Qué opciones le gustaría tener en su aplicación? Puede seleccionar más de 1
respuesta
Respuestas Resultado
Acceso a las notas 385
Acceso a documentos de la U Virtual 384
Mensajes de los docentes 318
Consultar al docente 154
Envío de Correos 270
Calendario Academico 380
Noticias de la Universidad 341
Tabla 10. Resultados de la pregunta 8.
Conclusión: con estos resultados determinamos las opciones que contendrá la
aplicación, seleccionando las cinco con el mayor número de respuestas: Acceso a
las notas, acceso a documentos de la U Virtual, Calendario Académico, Noticias
de la Universidad y mensajes de los docentes.
Pregunta 9
¿Utilizaría esta aplicación?
Respuestas Si No Total
Resultado 377 15 385
Porcentaje 97.92% 2.08% 100.00%
Tabla 11. Resultados de la pregunta 9.
Conclusión: Casi la totalidad de estudiantes utilizarían la aplicación al estar
disponible. Los que contestan “no” puede ser que no estén interesados.
Pregunta 10.
¿Qué sistema operativo utiliza su teléfono?
Respuestas Android Blackberry (Symbian)
Nokia N/A
Otros
(Bada, iOS,
etc.)
Total
Totales 51 213 40 57 24 385
Porcentaje 13.25% 55.32% 10.39% 14.81% 6.23% 100.00%
Tabla 12. Resultados de la pregunta 10
Con esto se concluye que entre los smartphones presentes entre los estudiantes
de la Universidad Francisco Gavidia el que tiene la mayoría es Blackberry seguido
por Android.
4.4 Conclusión de los resultados
Según los resultados obtenidos se observa que la mayoría de estudiantes poseen
teléfonos Blackberry, pero por lo expuesto en este capítulo, el desarrollo práctico
se hará utilizando Android, por ser el sistema operativo de más alto crecimien to a
nivel mundial.1
4.5 Estudio de Factibilidad
Se necesita realizar un estudio de factibilidad al desarrollar un proyecto ya que por
medio de este se determinan los recursos necesarios.
Con este estudio determinamos si el proyecto es viable (si tenemos o no los
recursos necesarios para el desarrollo) o no y si el mismo es coherente (si es
coherente con sus metas y objetivos).
Para ello necesitamos tres tipos de pruebas:
4.5.1 Factibilidad Técnica.
4.5.2 Factibilidad Operativa.
4.5.3 Factibilidad Económica.
4.5.1 Factibilidad Técnica
Se refiere si los procesos técnicos propuestos y sus posibilidades de
aplicación son compatibles. Según la investigación de campo realizada, se
determinó que la Universidad Francisco Gavidia posee el equipo
computacional necesario para soportar la instalación de los servicios a los
cuales la aplicación móvil accederá vía in ternet.
Las aplicaciones que se utilizan para levantar los servicios web son IIS y
sistema operativo Windows Server 2003 o superior.
1 Android vs. Apple vs. Blackberry ¿Quién está ganando la batalla? http://cultura-
geek.com/noticias/actualidad/dispositivos-moviles/184-android-vs-apple-vs-blackberry-iquien-esta-
ganando-la-batalla.html Fecha: 9/07/2011
A pesar que solo se presentará en una fase de prueba, ya que la
implementación de la misma no depende del responsable del trabajo de
graduación; si posteriormente se decide su implementación por parte de la
Universidad Francisco Gavidia se sabe que no se necesitará un equipo nuevo
ya que el que se posee es lo suficientemente potente para alojar los servicios
necesarios.
4.5.1.1 Razones para la selección de la plataforma móvil
Cabe preguntar cual ha sido el criterio de elección de Android como
plataforma de desarrollo si el sistema operativo que más se encuentra en la
Universidad Francisco Gavidia es Blackberry. A continuación se presentan las
razones.
Según estudios de la firma Nielsen de Estados Unidos, la cual es una
autoridad en estudios de mercado a nivel mundial, ha elaborado un reporte
con fecha de julio de 2012 donde demuestra los porcentajes de los sistemas
operativos móviles mas distribuidos en la actualidad. Colocando a Android en
primer lugar con 51.8%, seguido de iOS con el 34% y Blackberry OS con el
8%.2
2 Fuente: http://www.theverge.com/2012/7/12/3155378/nielsen -smartphones-android-apple-growth
Figura 1. Gráfico de distribución de sistemas operativos móviles. Julio 2012
En marzo de 2012 la compañía RIM, propietaria de Blackberry , anunció
pérdidas por $125 millones, a costa de la preferencia de los usuarios hacia
otras plataformas como Android e iOS. Y muestra un rezago en el desarrollo
de aplicaciones respecto a los dos sistemas operativos antes mencionados.3
Figura. 2. Gráfico de distribución porcentual de las plataformas Android y
Blackberry a nivel mundial . Finales de 20114
Según los datos obtenidos de la investigación, aunque la mayoría de
estudiantes posean teléfonos con sistema operativo Blackberry es aceptable el
desarrollo de la aplicación para este proyecto en el sistema operativo Android,
ya que es el de mayor crecimiento a nivel mundial.
3 http://www.bbc.co.uk/mundo/noticias/2012/03/120322_blackberry_estrategia_cambios_cch.shtml
4 La tormenta que azota a Blackberry. http://www.cnnexpansion.com/tecnologia/2012/03/29/blackberry -
en-la-encrucijada
4.5.1.2 Requerimientos del equipo de los usuarios
Sistema operativo: Android 2.2 o superior.
Conectividad a internet: WiFi de la UFG o paquete de datos de la compañía
telefónica.
Software: Visor de documentos PDF, DOC, XLS
4.5.1.3 Recurso Humano
1. Programador: desarrollo de código Java y servicios web.
2. Diseñador gráfico: para diseñar las interfaces.
En la UFG se encuentra el personal idóneo para el desarrollo e
implementación de la aplicación. Los mismos, están capacitados para realizar
las actividades de mantenimiento en caso de que sea necesario modificar,
agregar o modificar pantallas de la aplicación. Por lo tanto, se entrega n los
manuales técnicos y de usuario.
4.5.1.3 Software
El software a utilizar en este proyecto, es el siguiente:
Tipo Especificaciones Observación
Sistema operativo Windows Server 2003 Para el server
Sistema operativo Android 2.2 o superior
En dispositivo
móvil
Diseño y Programación
Eclipse Indigo* con Android
SDK
Herramientas
gratuitas
Desarrollo de Servicios
Web Visual Basic 2010
Base de datos MySQL Para Moodle
Base de datos SQLite
En el dispositivo
móvil
Tabla 13. Software a utilizar.
Según el estudio, la universidad cuenta con los recursos necesarios marcados
con (*). Para saber acerca de la preparación del entorno del desarrollo, por
favor consulte el anexo 1.
4.5.1.4 Definiciones
SISTEMAS OPERATIVOS
Windows 7 Sistema operativo propiedad de Microsoft ampliamente
extendido.
Android 2.2
Sistema operativo basado en el núcleo Linux especialmente
diseñado para dispositivos móviles como tabletas y teléfonos
inteligentes.
ENTORNOS DE DESARROLLO
Eclipse Indigo Entorno integrado de desarrollo para aplicaciones Java, en este
caso, utilizado para desarrollar en Android.
Android SDK Conjunto de herramientas que se añaden a Eclipse para
hacerlo apto para desarrollo de aplicaciones en Android.
Visual Basic Lenguaje de programación ampliamente utilizado para
desarrollo web y aplicaciones de escritorio.
BASE DE DATOS
MySQL Sistema gestor de base de datos ampliamente extendido a
nivel mundial.
SQLite Sistema gestor de base de datos utilizado por los sistemas
operativos Android y Blackberry
Tabla 14. Descripción del software a utilizar.
4.5.2 Factibilidad Operativa
Si se tiene el recurso humano necesario para ejecutar el proyecto y si será de
fácil uso para los usuarios. El proyecto es factible operativamente ya que este
será diseñado de una manera en la cual le sea fácil la instalación de la
aplicación al usuario. Cuando el estudiante inscriba nuevas materias en el
ciclo, la aplicación automáticamente cargará las materias que el estudiante
esté cursando en ese momento, ya que todos los datos provienen
directamente de la base de datos.
La misma no necesita de conocimientos avanzados para su instalación y uso,
ya que es muy amigable, de fácil instalación y una buena cantidad de alertas y
mensajes que el alumno recibirá.
Según los resultados obtenidos esta aplicación será de amplia aceptación por
parte de los estudiantes ya que ellos ven con agrado la parte de que les
facilitará la consulta de sus notas, de documentos y de videos que el docente
suba a la plataforma virtual de la universidad.
4.5.3 Factibilidad Económica
Mide el rendimiento de los resultados del proyecto frente a otra alternativa del
uso de los recursos. El proyecto es factible económicamente debido a que la
universidad posee el recurso tecnológico necesario para el desarrollo y la
implementación del proyecto. En cuanto al software la universidad posee
licencia de uso de las plataformas Windows y del software Visual Studio, y los
que no posee (Eclipse, Android SDK) son herramientas gratuitas.
En cuanto al recurso humano, no será necesaria más inversión, ya que la
universidad posee el recurso humano idóneo para e l desarrollo y
mantenimiento de la aplicación.
CAPÍTULO V
DISEÑO
5.1 Generalidades
Este capítulo trata de la creación de un prototipo con funcionalidad limitada para el
acceso al contenido multimedia de la plataforma virtual de la Universidad a través
de la plataforma para dispositivos móviles basados en el sistema operativo
Android.
Este prototipo servirá de base para desarrollar una aplicación que estará
disponible en la página web de la Universidad para que los estudiantes puedan
descargarla e instalarla en sus dispositivos móviles, lo cual les permitirá acceder
de una forma más rápida al contenido que necesiten.
El siguiente diseño es el resultado de la exhaustiva investigación realizada en el
campus universitario. En este capítulo se presenta el estudio de factibilidad
técnica, operativa y financiera del proyecto denominado: “DESARROLLO DE
APLICACIONES MÓVILES PARA ACCEDER A CONTENIDO MULTIMEDIA DE
LA UNIVERSIDAD FRANCISCO GAVIDIA ”. Se muestran sus características, los
requerimientos necesarios para llevarlo a cabo, su estructura y otros aspectos que
son relevantes para la realización de este proyecto.
En este capítulo se identifican los aspectos con los que contará este proyecto y va
orientado a contribuir con el bienestar de los estudiantes.
5.1.1. Pasos para el diseño de una aplicación para Android
Para crear una aplicación para Android se debe utilizar preferentemente la
herramienta Eclipse, previamente configurada con el Android SDK (ver anexo
3). Se presentan a continuación los pasos para la creación:
1. Archivo. Nuevo proyecto y seleccionar Android Application Project.
Figura 3a. Creación de un proyecto de Android en Eclipse
Figura 3b. Creación de un proyecto de Android en Eclipse
Figura 3c. Creación de un proyecto de Android en Eclipse
Se le da nombre a la aplicación y se crea el paquete (Package Name), el
cual alojará las clases.
Se aceptan las pantallas que salen a continuación. Se observa luego el
árbol de proyectos ya con la aplicación recientemente instalada.
5.1.2 Estructura física de un proyecto Android
Al crear un proyecto Android en Eclipse, el entorno crea una estructura
compuesta de varios archivos y carpetas, similar al de cualquier proyecto
Java. La estructura está compuesta de los siguientes directorios y
archivos:
Figura 4. Estructura de la Aplicación Android
src: donde se guardan los archivos de clase. Archivos con extensión
.java distribuidas en paquetes.
gen: guarda archivos de clase compilados
bin: archivos compilados de la aplicación
assets: almacena archivos que no se desean modificar
lib o libs: librerías externas en formato .jar
res: carpeta de recursos, aquí se almacenan los identificadores de
los campos que aparecerán en los formularios, imágenes, estilos, y los
formularios xml que se le presentan al usuario, es la interface de la
aplicación.
Archivo de manifiesto: en este archivo se declaran las clases que se
asociarán con los archivos xml, permisos de la aplicación, por ejemplo:
permiso a conectarse a internet, a envío de correos o hasta acceso a
dispositivos de hardware como la cámara.
Proguard-project.txt: archivo de configuración.
project.properties: donde se guardan propiedades y la plataforma de
destino de la aplicación.
Para crear una nueva clase, se le da clic derecho al paquete:
sv.edu.moodle.ufg Se selecciona New > Class
Figura 5a. Creación de clases en Android
Figura 5b. Creación de clases en Android
Los archivos XML son los que la aplicación presenta como interface al usuario.
Los archivos XML son referenciados desde las clases Java. Ya que estas
clases son las que contienen el código que se ejecuta.P ara crearlos se debe
dar click derecho a la carpeta “layout” del proyecto, seleccionar New > Other y
seleccionar “Android XML File”
Figura 6. Creación de archivo XML.
Archivo AndroidManifest.xml: Este es un archivo especial, es generado por el
entorno, en este se declaran permisos que la aplicación necesita (líneas uses-
permission): acceso a internet, acceso a almacenamiento externo, uso de
hardware, etc.
En la parte inferior se observan las líneas activity, en las cuales se colocan los
nombres de las clases que la aplicación va a utilizar en conjunto a los archivos
XML, si las clases no heredan de la superclase Activity no es necesario
incluirlas en este archivo.
Figura 7. Estructura del archivo AndroidManifest.xml
En el anexo 1, se encuentran los códigos fuente de todas las actividades y de los
archivos XML.
5.2 Importancia
El diseño de la aplicación móvil, a partir del prototipo con funcionalidad limitada
aquí presentado, será de gran utilidad a la comunidad universitaria. Los beneficios
que tendrá serán:
a) Estudiantes: Podrán acceder en cualquier momento al contenido multimedia
de la universidad sin tener que utilizar un equipo de cómputo para acceder
al mismo.
b) Docentes: Podrán subir a la plataforma virtual de la universidad
documentos, videos u otras clases de contenidos para que los estudiantes
puedan acceder a ellos en el mismo momento, las consultas a dicho
material serán hechos mediante servicios web que la aplicación consumirá.
5.3 Diseño
5.3.1 Diagrama jerárquico de la aplicación
A continuación se presenta la tabla visual de contenido o VTOC, l a c u a l e s
u n a g r á f i c a j e r á r q u i c a q u e p e r m i t e visualizar los módulos que
constituyen el proyecto.
Figura 8. Diagrama jerárquico.
5.3.2 Diagrama de flujo
Diagrama nivel 0
Figura 9
Diagrama nivel 1
Figura 10
5.3.3 Diseño de los servicios web
Se han desarrollado servicios web los cuales harán una actualización a la base de
datos que posea el dispositivo móvil. Estos serán consumidos por la aplicación
cuando esta cargue. Los servicios web se han diseñado en Visual Studio 2010 en
el lenguaje Visual Basic.
Se presenta un listado de los servicios web que serán utilizados.
a) Autenticarse: esta función permite al usuario poder autenticarse con
el servidor donde se encuentra alojado el sistema Moodle, hace la
consulta y si esta es correcta el estudiante podrá acceder al menú
principal.
b) getIdCurso: para obtener el código de los cursos del estudiante.
c) getMateriasEstudiante: mediante e l uso del carnet, esta función
devolverá las asignaturas que el estudiante posea registradas en el
sistema Moodle.
d) getNombreRecurso: obtiene los nombres de los recursos que hayan
en Moodle relacionados con la asignatura.
e) getMensaje: reúne diversas partes de un mensaje: asunto, remitente,
texto, fecha y se los muestra al usuario.
Para crear un servicio web en Visual Basic 2010 se deben seguir los siguientes
pasos:
1. En Visual Studio seleccionar Archivo > Nuevo Proyecto, seleccionar
el Framework 3.5 y escoger “Aplicación de Servicio Web de
ASP.NET”
Figura 11. Creación de aplicación de servicio web en Visual Basic
2010
2. Crear el servicio web: Clic derecho en la solución (explorador
de soluciones al lado derecho de la pantalla): Agregar Nuevo
Elemento, Servicio Web
Figura 12a. Creación de de servicio web en Visual Basic 2010
Figura 12b. Creación de de servicio web en Visual Basic 2010
3. Agregar referencia a MySQL: Ya que la base de datos a
consumir es la de Moodle, la cual es MySQL se debe agregar
una referencia a la librería DLL para la conexión entre MySQL
y Visual Studio. Esta se descarga desde el sitio web de
MySQL. Se da click derecho en la solución y seleccionar
Agregar Referencia, pestaña examinar y buscar el archivo
MySQL.Data.dll
Figura 13. Agregar referencia en Visual Basic 2010
Con esto, el servicio web puede extraer datos de una base de
datos MySQL y utilizar el espacio de nombres MySQL.
Para ver el código fuente de los servicios web, re fiérase el lector al anexo 1.
5.3.4 Diseño de la base de datos
Se presenta a continuación el diseño de la base de datos que utilizará la
aplicación móvil.
Figura 14. Estructura de la base de datos del dispositivo móvil.
Tabla: USUARIOS
Descripción de la tabla: En este catálogo se almacenarán los datos referentes a
nombre de usuarios, claves y saber si los estudiantes están activos o no.
Llave principal: CARNET
Llave Campo Tipo Nulo Descripción
PK Carnet varchar(20) No Carnet del alumno
Clave varchar(20) No Clave para acceder a la aplicación
Estado Int No 1-activo 0-inactivo
Tabla 15. Descripción de la entidad Usuarios.
Tabla: MATERIA_ESTUDIANTE
Descripción de la tabla: En esta se almacena las materias que un estudiante está
cursando.
Llave principal: ID_ASIGNATURA
Llave Campo Tipo Nulo Descripción
PK Id_Asignatura varchar(4) No Código de la materia
FK Carnet varchar(45) No Carnet del estudiante
Tabla 16. Descripción de la entidad Materia_Estudiante.
Tabla: RECURSOS
Descripción de la tabla: Aquí se almacenan los documentos relacionados de una o
varias materias para un estudiante en un determinado ciclo. Aquí se almacenan
las direcciones donde se encuentran los diversos recursos como: documentos,
presentaciones, videos, etc. Para que los estudiantes puedan acceder a ellos a
través de la aplicación.
Llave principal: ID_RECURSO
Llave Campo Tipo Nulo Descripción
PK id_recurso Int No Identificación del recurso
Id_Asignatura Varchar(4) No Código de la asignatura
FK Carnet varchar(20) No Carnet del estudiante
recursoURL varchar(50) No
dirección donde se encuentra el
recurso
Tabla 17. Descripción de la entidad Recursos.
Tabla: NOTAS
Descripción de la tabla: En esta tabla se guardaran las notas de las asignaturas
que los alumnos están cursando.
Llave principal: ID_NOTA
Llave Campo Tipo Nulo Descripción
PK id_nota Int No Identificar la nota
Id_Asignatura varchar(4) No Código de la asignatura
FK Carnet varchar(20) No Carnet del estudiante
laboratorio1 Decimal(10,2) No Resultado de la nota de laboratorio 1
laboratorio2 Decimal(10,2) No Resultado de la nota de laboratorio 2
laboratorio3 Decimal(10,2) No Resultado de la nota de laboratorio 3
laboratorio4 Decimal(10,2) No Resultado de la nota de laboratorio 4
parcial1 Decimal(10,2) No Resultado de la nota de parcial 1
parcial2 Decimal(10,2) No Resultado de la nota de parcial 2
parcial3 Decimal(10,2) No Resultado de la nota de parcial 3
parcial4 Decimal(10,2) No Resultado de la nota de parcial 4
Tabla 18. Descripción de la entidad Notas.
Tabla: MENSAJES
Descripción de la tabla: En esta tabla se guardaran los mensajes que se envían
entre alumnos o del alumno al profesor o viceversa. Funciona como una especie
de foro.
Llave principal: ID_MENSAJE
Llave Campo Tipo Nulo Descripción
PK id_mensaje Int No Identificar el mensaje
Envia varchar(40) No Nombre del remitente
Recibe Varchar(40) No Nombre del destinatario
Asunto Varchar(20) Si De qué se trata el mensaje.
mensaje Text No Cuerpo del mensaje
Fecha Date No Fecha de envío del mensaje
Tabla 19. Descripción de la entidad Mensajes.
5.3.5 Pasos para la navegación de la aplicación
1. Abrir la aplicación y teclear usuario y clave, se utilizaran las mismas
credenciales de la U Virtual, se ve junto al botón un caja seleccionable o
checkbox. Deberá ser desmarcada si no se utilizará la conexión a Internet o
dejarla marcada si posee conexión y quiera sincronizar la aplicación con el
servidor de la U Virtual.
2. Al acceder a la aplicación, se observa el menú principal que es en donde se
puede acceder a las distintas opciones que ofrece la misma.
3. Para elegir algún elemento del menú principal se debe desplazar utilizando
el trackball o si es un dispositivo táctil, simplemente tocando la pantalla.
4. Para retornar a las pantallas anteriores se debe presionar la tecla menú
para acceder a un menú emergente.
5. Para descargar un elemento bastará con seleccionarlo, y escoger guardar.
6. Si se desea finalizar la sesión, se debe presionar el botón menú y
seleccionar la opción salir.
5.3.6 Sincronización de la base de datos
Mediante el uso de los servicios web, que recogen información a solicitud de la
aplicación, la base de datos interna del teléfono se actualizará con los datos que
provengan del servidor. Esta actualización se hace desde el momento que el
usuario se autentica con la aplicación.
5.3.7 Diseño de Pantallas
En esta parte del proyecto se presenta la propuesta del diseño de pantallas que
tendrá la aplicación móvil para acceder al contenido multimedia.
Las pantallas comparten en común lo siguiente: fácil de usar, presentación
consistente y fácil navegación.
5.3.8 Uso del sistema
5.3.8.1 Acceso al sistema
En esta pantalla se debe que introducir usuario (carnet) y clave, si el
estudiante está inscrito en el ciclo actual y es un estudiante activo, pasará
a la pantalla del menú principal de la aplicación.
Figura 15. Pantalla de inicio de la aplicación .
5.3.8.2 Menú Principal
Aquí se tienen las partes principales de las que se compone la aplicación
Figura 16. Menú Principal
5.3.8.3 Mis asignaturas inscritas
En este submenú se observa las materias que el estudiante tiene inscritas en
el ciclo que cursa actualmente.
Figura 17
5.3.8.4 Mis recursos
Aquí se tienen los distintos recursos disponibles de las materias que el
estudiante cursa: documentos, videos, imágenes, etc. Estos se obtienen
vía servicio web desde los servidores de la UFG. Son descargables al
seleccionarlos.
Figura 18a. Recursos
Figura 18b. Descarga de un recurso
5.3.8.5 Calendario
Se observa el calendario académico del ciclo en curso
Figura 19. Calendario Académico
5.3.8.6 Mis notas
Se accede a ver las notas que cursa el estudiante en el ciclo actual mediante
acceso a servicio proporcionado por la universidad.
Figura 20.
5.3.8.7 Mis mensajes
Se observan mensajes que los docentes quieran hacer llegar a sus
estudiantes vía correo electrónico.
Figura 21. Histórico de mensajes.
En la parte inferior vemos un menú, el cual aparece al presionar la tecla menú
del dispositivo, que permitirá realizar una ordenación, ya sea ascendente o
descendente y búsqueda de mensajes.
5.3.8.8 Mis Noticias
Se ve el listado de noticias que provienen del sitio de la universidad.
Figura 22. Noticias
5.3.9 Actividades para la implementación
Se presentan a continuación una serie de tareas que se considera son
necesarias para la implementación técnica del sistema.
1. Instalación y prueba del sistema.
2. Actualización.
Instalación y prueba del sistema
La instalación y prueba del sistema estará a cargo del equipo técnico de la
Universidad Francisco Gavidia. El cual hará las pruebas pertinentes con las
opciones que el aplicativo posee.
Actualización
Para evitar que el sistema se vuelva obsoleto, se deben estar aplicando mejoras a
la aplicación a medida esta vaya siendo utilizada y salgan a la luz algunas
solicitudes de mejora de la misma.
CAPÍTULO VI
CONCLUSIONES Y RECOMENDACIONES
6.1 Conclusiones
En este documento se demuestra que es factible el desarrollo de un aplicativo
para teléfonos inteligentes para que los estudiantes puedan acceder al contenido
multimedia que la universidad posee.
El aplicativo es una herramienta que puede ser de gran ayuda para los estudiantes
de la universidad, ya que tendrán fácilmente acceso a los recursos.
El sistema se ha diseñado de tal forma que los estudiantes puedan acceder a
través de su teléfono en cualquier lugar donde haya acceso a internet o a través
de 3G, EDGE o 2G, que son las tecnologías de internet móvil y sistema operativo
Android.
Se ha optado por el desarrollo de la aplicación solamente para los dispositivos
Android, que como se ha mencionado en el Capítulo IV. Es el sistema operativo de
mayor crecimiento a nivel mundial, en cambio Blackberry muestra poca
distribución a nivel mundial, aun siendo muy popular en El Salvador.
6.2 Recomendaciones
1. Para el uso adecuado del sistema el teléfono inteligente debe tener acceso a
internet. Se recomienda como mínimo un equipo con tecnología EDGE.
2. Se recomienda el uso de un teléfono con tecnología 3G
3. Estar pendiente de actualizaciones o mejoras del aplicativo que serán
publicadas en el sitio web de la universidad.
8
BIBLIOGRAFIA
1. ROGERS, Rick, et al. Android Application Development. 1a. ed. Sebastopol
CA, EEUU. O’Reilly, 2009. 336p. ISBN: 978-0-596-52147-9
2. FITZEK, Frank and REICHERT, Frank. Mobile Phone Programming . 1a. ed.
Dordrecht, Holanda: Springer, 2007. 474p. ISBN: 978-1-4020-5969-8.
3. BURNETTE, Ed. Hello Android . 3a. ed. Raleigh, EEUU: The Pragmatic
Bookshelf, 2010. 283p. ISBN: 978-1-934356-56-2
4. MURPHY, Mark. The Busy Coder’s Guide to Android Development. 1a.ed.
EEUU: CommonsWare LLC, 2008. 415p. ISBN: 978-0-9816780-0-9
5. SAMPIERI, Roberto et al. Metodología de la Investigación. 2a. ed. Editorial
Mc. Graw – Hill, 1998. 411p. ISBN: 970-1-057538
6. KEEGAN et al. NetBeans IDE Field Guide , Developing J2ME Mobility
Applications. Chapter 11. Developing J2ME Mobility Applications. 1a. ed.
Pearson Education, 2006. 541p. ISBN: 0132395525.
1
Anexo 1
Manual Técnico
1. Introducción
La finalidad del manual técnico es la de proporcionar al lector la lógica con la que
se ha desarrollado alguna aplicación. La cual depende de cada programador, por
lo que es fundamental documentarla.
2. Objetivo
Proporcionar al lector una guía sobre el desarrollo de la aplicación.
3. Desarrollo de la interfaz
Entorno de desarrollo: Eclipse Indigo preparado para el desarrollo en Android (ver
anexo 3).
En el entorno Eclipse se crean los formularios, que para una aplicación Android
son llamados actividades.
2
Figura 1. Actividad de Android
4. Componentes básicos de una actividad android
Las actividades de Android están conformadas en parejas, en las cuales una es el
archivo java y la otra es el archivo xml.
5. Descripción del archivo java
En este archivo se encuentra el código fuente de la aplicación.
En la primera línea tenemos:
package androidUFG.paquetes;
Esto identifca un paquete, que es un orden lógico de la programación Android
(Java).
Luego tenemos lo siguiente:
import java.util.ArrayList;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
import android.widget.ExpandableListView;
import android.widget.TextView;
3
Estas son librerías que tenemos que llamar para poder utilizarlas en algunas
funciones que necesitamos.
Después tenemos la clase, que es el punto de partida de la creación de la
actividad, la cual llama a la superclase Activity que contiene todo lo necesario para
poder crear una actividad.
public class Mis_Mensajes extends Activity {
La siguientes líneas que tenemos son:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
Esta función es la principal de toda actividad de Android, es la que supone la
creación de todos los componentes y hace los llamados a las funciones auxiliares.
6. Descripcion del archivo xml
En este archivo se tiene la estructura visual de como lucirá nuestra actividad.
La primera línea:
<?xml version="1.0" encoding="utf-8"?>
Describe la versión de XML de archivo y el tipo de codificación. Después de estas
líneas tenemos otras que son las que arman la estructura de la actividad.
7. Creación del instalador
El entorno de Eclipse provee la opción “Export” que es la que permite crear el
instalador para poder utilizar la aplicación en los dispositivos móviles.
Se le dá clic derecho al proyecto y seleccionar export.
4
Figura 2. Exportación de aplicación de Android
Luego, se presenta la siguiente pantalla.
Figura 3
5
Seleccionar Next
Figura 4.
Nuevamente Next
Figura 5. Selección del archivo de llave.
6
En esta pantalla se pregunta si se quiere crear una llave, si no existe, debe
crearse, ya que esta sirve como firma digital de la aplicación.
Figura 6. Selección de carpeta de destino
Aquí se puede seleccionar a donde se va a guardar el archivo APK, el cual es el
instalador. Se observan los datos del certificado que se creo anteriormente.
Clic en finish y el proceso esta listo, este archivo APK es el que se ejecuta en el
dispositivo para instalar la aplicación.
8. Seguridad
La seguridad de la aplicación se basa en la obligatoriedad de un usuario y
contraseña, que para mayor seguridad serán los mismos que se utilizan en la
plataforma virtual de la Universidad Francisco Gavidia.
9. Requerimientos Técnicos
9.1 Sistemas Operativos
Para la instalación de este aplicativo se necesita un teléfono inteligente con
sistema operativo Android 2.2 o superior.
7
10. Estructura de la aplicación
La aplicación esta formada por 6 actividades o formularios y 3 paquetes:
sv.edu.ufg.datos, para crear la base de datos y revisar si hay conexión a Internet;
sv.ufg.edu.moodle, este es el paquete principal, donde se almacenan las clases
para las siguientes actividades.
- Acceso
- Menú Principal
- Asignaturas
- Mis Recursos
- Calendario Académico
- Noticias
- Mensajes
Sv.edu.ufg.util, contiene la clase MD5.java que sirve de ayuda para encriptar la
clave del usuario mediante el algoritmo md5, ya que nativamente, SQLite no
posee este método. En este manual se verá de forma detallada las actividades
(formularios) que conforman la aplicación.
Nombre de la actividad Descripcion
Login.java Es la primer actividad. En esta es donde se autentica
el usuario.
Mnu_principal.java
Actividad que muestra el menu principal de la
aplicación. Es el punto de partida del programa
despues de haberse autenticado.
Asignaturas.java Actividad donde se observan las materias cursadas
actualmente por el estudiante.
Calendario.java Actividad que muestra nuestra el calendario de
actividades del ciclo en curso.
Mis_Recursos.java Actividad donde aparecen los recursos
(documentos, videos, imágenes, etc.) asociados a las
materias que el estudiante este cursando.
Mis_Mensajes.java En esta actividad se observaran los mensajes que los
docentes envian a sus alumnos.
8
Noticias.java Actividad que muestra las noticias del acontecer
universitario.
Tabla 1. Actividades de la aplicación
Funciones de las actividades
Actividad: Login
Nombre de la función Valor devuelto Descripción
lanzaMenuPrincipal void
Si el usuario existe, da paso a la carga
del menu principal.
onCreate void Captura usuario y contraseña
onclick void
Revisa si existe conexión a Internet, si el usuario existe no trata de crearlo de
nuevo.
Si el usuario existe y hay conexión a Internet, actualiza la base de datos
interna de la aplicación, si no, solo trabaja con la base que tenga hasta ese
momento.
insUsuario Int Si el usuario no existe lo almacena en la base de datos
existeUsuario Int Verifica si el usuario existe
insAsignatura Int Guarda en la base de datos las asignaturas que el estudiante tenga registradas
en el Moodle de la U Virtual
Actividad: Mnu_Principal
Nombre de la función Valor devuelto Descripción
onCreate void Crea la lista del menu
onItemClick void Captura el ítem que hemos seleccionado
para dar pasada a diferentes actividades.
Actividad: Asignaturas
Nombre de la función Valor devuelto Descripción
onCreate void Llama a los servicios web para recoger
información sobre las materias inscritas
getMaterias Void
Selecciona las asignaturas del estudiante desde la base de datos, utiliza a la
función agregarLista para llenar el listado de las asignaturas.
agregarLista Void Añade los resultados de la consulta al arreglo de la lista de las asignaturas
Actividad: Calendario
9
Nombre de la función Valor devuelto Descripción
onCreate void Carga el listado de las actividades calendarizadas del ciclo en curso.
Actividad: Mis_Mensajes
Nombre de la función Valor devuelto Descripción
onCreate Void Carga la actividad
agregarLista Void Llena lista de los mensajes
delMensaje Void Borra los mensajes
getAsuntos Void Devuelve los asuntos de los mensajes al usuario
getFechaMensaje String Retorna la fecha y hora del mensaje
getTextoMensaje String Retorna el texto del mensaje
insMensaje Void Guarda el mensaje en la base de datos
updMensaje Void Actualizar el mensaje
Actividad: Mis_Recursos
Nombre de la función Valor devuelto Descripción
onCreate Void Carga la actividad
agregarLista Void Llena lista de los recursos
delRecurso Void Borra listado de recursos
getRecursos Void Devuelve los recursos para mostrarlos
getURL String Devuelve la URL del recurso
insRecurso Void Guarda los recursos en la base de datos
updRecurso Void Actualiza el recurso
Actividad: Noticias
Nombre de la función Valor devuelto Descripción
onCreate Void Carga el listado de las noticias del sitio de la Universidad
Tabla 2. Funciones de las actividades.
1. Código fuente de las actividades de la aplicación
Se presenta la estructura de los archivos XML que utiliza la aplicación, así
cómo el archivo de manifiesto de la aplicación donde se colocan los
permisos de la aplicación y la versión del sistema operativo que va a usar.
10
1.1 activity_login.xml
<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:stretchColumns="1">
<TableRow>
<TextView android:text="Usuario: "
android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
</TextView>
<EditText android:text=""
android:id="@+id/txtUsername"
android:layout_width="fill_parent"
android:layout_height="wrap_content">
</EditText>
</TableRow>
<TableRow>
<TextView android:text="Contraseña: "
android:id="@+id/TextView02"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
</TextView>
<EditText android:text=""
android:id="@+id/txtPass"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:password="true">
</EditText>
</TableRow>
<TableRow>
<Button android:text="Conectar"
android:id="@+id/btnLogin"
android:layout_width="fill_parent"
android:layout_height="wrap_content">
</Button>
<CheckBox
android:id="@+id/chkConexion"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:checked="true"
android:text="Conexion a internet" />
</TableRow>
<ImageButton
android:id="@+id/imageButton1"
android:layout_width="wrap_content"
11
android:layout_height="wrap_content"
android:src="@drawable/logo" />
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Plataforma Virtual Móvil UFG"
android:textAppearance="?android:attr/textAppearanceLarge" />
</TableLayout>
1.2 mnu_principal.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<ListView
android:id="@+id/listView1"
style="@layout/list_style"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="@drawable/logo" >
</ListView>
</LinearLayout>
1.3 mis_asignaturas.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<ListView
android:id="@+id/listView1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
</ListView>
</LinearLayout>
1.4 mis_mensajes.xml
<?xml version="1.0" encoding="utf-8"?>
12
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Mensajes"
android:textAppearance="?android:attr/textAppearanceMedium" />
<ListView
android:id="@+id/listView1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
</ListView>
</LinearLayout>
1.5 mis_recursos.xml
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Medium Text"
android:textAppearance="?android:attr/textAppearanceMedium" />
<ListView
android:id="@+id/listView1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
>
</ListView>
</LinearLayout>
13
1.6 ver.xml
Archivo xml utilizado por las clases: Calendario.java y Noticias.java
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<WebView
android:id="@+id/webView1"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</LinearLayout>
1.7 notas.xml
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text=""
/>
<ExpandableListView
android:id="@+id/ExpandableListView01"
android:layout_height="wrap_content"
android:layout_width="fill_parent"
>
</ExpandableListView>
</LinearLayout>
2. Código java de la aplicación
2.1 DBHelper.java
Clase utilizada para la creación de la base de datos y las sentencias para
crear o eliminar las tablas de la misma.
package sv.edu.ufg.datos;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
14
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import android.widget.Toast;
public class DBHelper extends SQLiteOpenHelper
{
public DBHelper(Context context, String name, CursorFactory factory,
int version) {
super(context, name, factory, version);
}
String sqlCrearTablaUsuarios="CREATE TABLE Usuarios(carnet text primary key not
null, clave text unique)";
String sqlCrearTablaAsignaturas="CREATE TABLE Materia_Estudiante(idAsignatura
text primary key not null," +
"carnet text)";
String sqlCrearTablaRecursos="CREATE TABLE Recursos(idRecurso INTEGER PRIMARY
KEY AUTOINCREMENT, idAsignatura text, recursoNombre text, recursoURL text)";
String sqlCrearTablaMensajes="CREATE TABLE Mensajes(idMensaje INTEGER PRIMARY
KEY, para text, enviado_por text, asunto text, mensaje text, fecha text)";
String sqlCrearTablaNotas="CREATE TABLE Notas(idNotas INTEGER primary key
AUTOINCREMENT, idAsignatura text, carnet text, laboratorio1 decimal(10,2)
default 0,laboratorio2 decimal(10,2) default 0," +
"laboratorio3 decimal(10,2) default 0,laboratorio4 decimal(10,2)
default 0, parcial1 decimal(10,2) default 0,parcial2 decimal(10,2) default 0,
parcial3 decimal(10,2) default 0," +
"parcial4 decimal(10,2) default 0)";
String sqlCrearTablaNoticias="CREATE TABLE Noticias(idNoticias INTEGER primary
key AUTOINCREMENT, noticiaTexto text, fecha text)";
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(sqlCrearTablaUsuarios);
db.execSQL(sqlCrearTablaAsignaturas);
db.execSQL(sqlCrearTablaRecursos);
db.execSQL(sqlCrearTablaMensajes);
db.execSQL(sqlCrearTablaNotas);
db.execSQL(sqlCrearTablaNoticias);
}
@Override
15
public void onUpgrade(SQLiteDatabase db, int vAnterior, int vNueva) {
db.execSQL("DROP TABLE Usuarios");
db.execSQL("DROP TABLE Materia_Estudiante");
db.execSQL("DROP TABLE Recursos");
db.execSQL("DROP TABLE Mensajes");
db.execSQL("DROP TABLE Notas");
db.execSQL("DROP TABLE Noticias");
db.execSQL(sqlCrearTablaUsuarios);
db.execSQL(sqlCrearTablaAsignaturas);
db.execSQL(sqlCrearTablaRecursos);
db.execSQL(sqlCrearTablaMensajes);
db.execSQL(sqlCrearTablaNotas);
db.execSQL(sqlCrearTablaNoticias);
}
}
2.2 MD5.java
Clase que posee solo una función, la de encriptar la clave del usuario
mediante el algoritmo md5.
package sv.edu.ufg.util;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5 {
public static String md5(String s) { try {
// Create MD5 Hash
MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
digest.update(s.getBytes());
byte messageDigest[] = digest.digest();
// Create Hex String
StringBuffer hexString = new StringBuffer();
for (int i=0; i<messageDigest.length; i++)
hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
return hexString.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return "";
}
}
16
2.3 Login.java
Esta actividad es la que hace la autenticación del usuario, lo hace
mediante servicio web para llenar la base de datos si hay conexión a
internet, de lo contrario, mediante la base de datos.
package sv.edu.ufg.moodle;
import java.io.IOException;
import java.io.Serializable;
import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Toast;
import android.support.v4.app.NavUtils;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.SoapFault;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;
import sv.edu.ufg.datos.ExisteConexion;
import sv.edu.ufg.datos.DBHelper;
import sv.edu.ufg.util.*;
public class Login extends Activity{
private static final String accionSoap = "http://tempuri.org/";
private static final String Metodo = "autenticar";
private static final String namespace = "http://tempuri.org/";
/*La URL a continuación debe cambiarse por la del servidor al que el usuario
necesite acceder*/
private static final String url = "http://10.0.2.2:7294/svcLogin.asmx";
int usuarioAutenticado = -1;
String existeConexion="0";
String[] items;
17
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
final EditText txtUsuario = (EditText)findViewById(R.id.txtUsername);
final EditText txtPwd = (EditText)findViewById(R.id.txtPass);
Button btnLogin = (Button)findViewById(R.id.btnLogin);
final CheckBox chkConexion = (CheckBox)findViewById(R.id. chkConexion);
btnLogin.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
/*Si existe conexion, autenticarse con los servicios web, si no
existe, con la base de datos*/
if (chkConexion.isChecked())
{
existeConexion="1";
if
(existeUsuario(txtUsuario.getText().toString(),txtPwd.getText().toString())<1)
{
insUsuarios(txtUsuario.getText().toString(),txtPwd.getText().toString());
}
//Actualizar base de datos
/*Si hay conexion a internet y el usuario es válido,
sincronizar la base de datos, luego, pasar
* a las diferentes actividades
* */
if
(existeUsuario(txtUsuario.getText().toString(),txtPwd.getText().toString())==1)
{
/*Sincronizar la tabla de Asignaturas*/
String mGetMateriasEstudiante =
"getMateriasEstudiante";
SoapObject requestMateriasEstudiante = new
SoapObject(namespace, mGetMateriasEstudiante);
requestMateriasEstudiante.addProperty("carnet",txtUsuario.getText().toStr
ing());
SoapSerializationEnvelope sobreMateriasEstudiante =
new SoapSerializationEnvelope(SoapEnvelope.VER12);
sobreMateriasEstudiante.dotNet=true;
sobreMateriasEstudiante.setOutputSoapObject(requestMateriasEstudiante);
18
HttpTransportSE transporteMateriasEstudiante = new
HttpTransportSE(url);
try {
transporteMateriasEstudiante.call(accionSoap,
sobreMateriasEstudiante);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
SoapPrimitive resultadoMateriasEstudiante =
(SoapPrimitive) sobreMateriasEstudiante.getResponse();
String[] res =
resultadoMateriasEstudiante.toString().split(",");
items = new String[res.length];
int i=0;
delAsignatura(txtUsuario.getText().toString());
for (i=0; i<res.length; i++)
{
insAsignatura(res[i],"",txtUsuario.getText().toString());
}
}catch (SoapFault e) {
Toast.makeText(getApplicationContext(),
"Credenciales Inválidas", Toast.LENGTH_LONG).show();
}
}
//autenticarse con la conexion a la red
SoapObject request = new SoapObject(namespace, Metodo);
request.addProperty("carnet",txtUsuario.getText().toString());
request.addProperty("clave",txtPwd.getText().toString());
SoapSerializationEnvelope sobre = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobre.dotNet = true;
sobre.setOutputSoapObject(request);
HttpTransportSE transporte = new HttpTransportSE(url);
try {
transporte.call(accionSoap, sobre);
} catch (IOException e) {
19
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
SoapPrimitive resultado = (SoapPrimitive)
sobre.getResponse();
if (Integer.parseInt(resultado.toString())==1)
{
usuarioAutenticado=1;
Toast.makeText(getApplicationContext(),
"Autenticado correctamente. Utilizando conexion para sincronizar",
Toast.LENGTH_LONG).show();
Intent intent = new
Intent(Login.this,Mnu_Principal.class);
intent.putExtra("carnet",txtUsuario.getText().toString());
intent.putExtra("conectado", existeConexion);
startActivity(intent);
}else{
Toast.makeText(getApplicationContext(),
"Credenciales Inválidas", Toast.LENGTH_LONG).show();
}
} catch (SoapFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else{
//Autenticarse mediante la base de datos
if
(existeUsuario(txtUsuario.getText().toString(),txtPwd.getText().toString())==1)
{
usuarioAutenticado=1;
Toast.makeText(getApplicationContext(), "Autenticado
correctamente. No hay conexion a internet, hasta que haya conexion la aplicación
actualizará los datos", Toast.LENGTH_LONG).show();
Intent intent = new
Intent(Login.this,Mnu_Principal.class);
intent.putExtra("conectado", existeConexion);
intent.putExtra("carnet",txtUsuario.getText().toString());
startActivity(intent);
}
20
}
}
});
}
public int insUsuarios(String carnet, String clave)
{
MD5 md5 = new MD5();
String claveMD5 = md5.md5(clave);
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql ="INSERT INTO Usuarios(carnet,clave) VALUES('" + carnet +
"','" + claveMD5 + "')";
db.execSQL(sql);
db.close();
return 1;
}
public int existeUsuario(String carnet, String clave)
{
int existe=-1;
MD5 md5 = new MD5();
String claveMD5 = md5.md5(clave);
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "SELECT COUNT(*) FROM Usuarios WHERE carnet='" + carnet + "'
AND clave='"+ claveMD5 + "'";
Cursor c = db.rawQuery(sql,null);
c.moveToFirst();
existe=c.getInt(0);
return existe;
}
public void insAsignatura(String idAsignatura, String nomAsignatura, String
carnet)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "INSERT INTO Materia_Estudiante
(idAsignatura,nombreAsignatura,carnet) "+
"
VALUES('"+idAsignatura+"','"+nomAsignatura+"','"+carnet+"')";
db.execSQL(sql);
}
21
public void delAsignatura(String carnet)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "DELETE FROM Materia_Estudiante WHERE carnet='"+carnet+"'";
db.execSQL(sql);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_login, menu);
return true;
}
}
2.4 Mnu_Principal.java: Esta clase es la encargada de mostrar la pantalla de
inicio de la aplicación.
package sv.edu.ufg.moodle;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;
public class Mnu_Principal extends Activity {
ListView lista;
String[] items = {"Mis Asignaturas","Mis Recursos","Mis Mensajes","Mis
Notas","Calendario","Noticias"};
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mnu_principal);
lista = (ListView)findViewById(R.id.listView1);
lista.setAdapter(new
ArrayAdapter(this,android.R.layout.simple_list_item_ 1,items));
Bundle extra = this.getIntent().getExtras();
final String carnet=extra.getString("carnet");
final String conexion=extra.getString("conectado");
22
lista.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
switch(position)
{
case 0:
Intent asignaturas = new
Intent(Mnu_Principal.this,Mis_Asignaturas.class);
asignaturas.putExtra("carnet", carnet);
asignaturas.putExtra("conectado", conexion);
startActivity(asignaturas);
break;
case 1:
Intent rec = new
Intent(Mnu_Principal.this,Mis_Asignaturas.class);
rec.putExtra("carnet", carnet);
rec.putExtra("conectado", conexion);
startActivity(rec);
break;
case 2:
Intent msj = new
Intent(Mnu_Principal.this,Mis_Mensajes.class);
msj.putExtra("carnet", carnet);
msj.putExtra("conectado", conexion);
startActivity(msj);
break;
case 3:
Intent notas = new
Intent(Mnu_Principal.this,Mis_Notas.class);
startActivity(notas);
break;
case 4:
Intent calen = new
Intent(Mnu_Principal.this,Calendario.class);
startActivity(calen);
break;
case 5:
Intent noticias = new
Intent(Mnu_Principal.this,Noticias.class);
startActivity(noticias);
break;
}
}
});
}
}
23
2.5 Mis_Asignaturas.java: Esta clase carga las materias que el alumno tenga
inscritas.
package sv.edu.ufg.moodle;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.SoapFault;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;
import sv.edu.ufg.datos.DBHelper;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;
public class Mis_Asignaturas extends Activity{
ListView lista;
private ArrayList<String> asignaturas = new ArrayList<String>();
//llenar los items desde el webservice
String[] items;
24
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mis_asignaturas);
Bundle extra = this.getIntent().getExtras();
String carnet=extra.getString("carnet");
String estadoConexion = extra.getString("conectado");
getMaterias(carnet);
lista = (ListView)findViewById(R.id.listView1);
lista.setAdapter(new
ArrayAdapter(this,android.R.layout.simple_list_item_1,asignaturas));
lista.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
Context context = getApplicationContext();
Intent intent = new
Intent(Mis_Asignaturas.this,Mis_Recursos.class);
intent.putExtra("item", lista.getItemIdAtPosition(position));
String it = lista.getItemAtPosition(position).toString();
Toast.makeText(getApplicationContext(), it,
Toast.LENGTH_LONG).show();
//startActivity(intent);
}
});
}
public void getMaterias(String carnet)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "select idAsignatura from materia_estudiante where
carnet='"+carnet+"'";
Cursor c = db.rawQuery(sql,null);
if (c.moveToFirst())
{
do{
agregarLista(c);
}while(c.moveToNext());
}
c.close();
}
25
private void agregarLista(Cursor c)
{
asignaturas.add(c.getString(0));
}
}
2.6 Mis_Mensajes.java: Esta clase muestra los mensajes que el usuario
recibe.
package sv.edu.ufg.moodle;
import java.io.IOException;
import java.util.ArrayList;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.SoapFault;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;
import sv.edu.ufg.datos.DBHelper;
import sv.edu.ufg.moodle.Mis_Recursos.DownloadFileFromURL;
import android.app.Activity;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Toast;
public class Mis_Mensajes extends Activity{
private static final String accionSoap = "http://tempuri.org/";
private static final String mGetIdMensaje = "getIdMensaje";
private static final String mGetAsuntoMensaje = "getAsuntoMensaje";
private static final String mGetTextoMensaje = "getTextoMensaje";
private static final String mGetFechaMensaje = "getFechaMensaje";
private static final String namespace = "http://tempuri.org/";
private static final String url = "http://10.0.2.2:7294/svcLogin.asmx";
private ArrayList<String> asuntos = new ArrayList<String>();
String[] res,res1;
String[] items,idMensajes;
ListView lista;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
26
setContentView(R.layout.mis_mensajes);
Bundle extra = this.getIntent().getExtras();
String carnet = extra.getString("carnet");
int con = Integer.parseInt(extra.getString("conectado"));
if (con==1)
{
delMensaje(carnet);
//obtener los asuntos de los mensajes
SoapObject request = new SoapObject(namespace, mGetAsuntoMensaje);
request.addProperty("carnet",carnet);
SoapSerializationEnvelope sobre = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobre.dotNet = true;
sobre.setOutputSoapObject(request);
HttpTransportSE transporte = new HttpTransportSE(url);
try {
transporte.call(accionSoap, sobre);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//obtener el id del mensaje
SoapObject requestIdMensaje = new SoapObject(namespace,
mGetIdMensaje);
requestIdMensaje.addProperty("carnet",carnet);
SoapSerializationEnvelope sobreIdMensaje = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobreIdMensaje.dotNet = true;
sobreIdMensaje.setOutputSoapObject(requestIdMensaje);
HttpTransportSE transporteMensaje = new HttpTransportSE(url);
try {
transporteMensaje.call(accionSoap, sobreIdMensaje);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
27
SoapPrimitive resultado = (SoapPrimitive)
sobre.getResponse();
SoapPrimitive resultadoIdMensaje=
(SoapPrimitive) sobreIdMensaje.getResponse();
res = resultado.toString().split(",");
res1 = resultadoIdMensaje.toString().split(",");
items = new String[res.length];
idMensajes = new String[res1.length];
int i=0;
for (i=0; i<res.length; i++)
{
items[i]=res[i];
idMensajes[i]=res1[i];
insMensaje(Integer.parseInt(idMensajes[i]),carnet,"",items[i],getTextoMen
saje(Integer.parseInt(idMensajes[i])),getFechaMensaje(Integer.parseInt(idMensaje
s[i])));
}
} catch (SoapFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
getAsuntos(carnet);
lista = (ListView)findViewById(R.id.listView1);
lista.setAdapter(new
ArrayAdapter(this,android.R.layout.simple_list_item_1,asuntos));
lista.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
}
});
}
}
public void getAsuntos(String carnet)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "select asunto||': '||mensaje from mensajes where
para='"+carnet+"'";
Cursor c = db.rawQuery(sql,null);
if (c.moveToFirst())
28
{
do{
agregarLista(c);
}while(c.moveToNext());
}
c.close();
}
private void agregarLista(Cursor c)
{
asuntos.add(c.getString(0));
}
public void delMensaje(String carnet)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "DELETE FROM Mensajes WHERE para='"+carnet+"'" ;
db.execSQL(sql);
}
public void insMensaje(int id, String para, String por, String asunto,
String mensaje, String fecha)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql="INSERT INTO
Mensajes(idMensaje,para,enviado_por,asunto,mensaje,fecha) VALUES("+id
+",'"+para+"','"+por+"','"+asunto+"','"+mensaje+"','"+fecha+"')";
db.execSQL(sql);
}
public void updMensaje(int id, String fecha, String mensaje)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql="UPDATE Mensajes SET
fecha='"+fecha+"',mensaje='"+mensaje+"' WHERE idMensaje="+id;
db.execSQL(sql);
}
public String getTextoMensaje(int id)
{
String texto="";
SoapObject request = new SoapObject(namespace, mGetTextoMensaje);
request.addProperty("idMensaje",id);
29
SoapSerializationEnvelope sobre = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobre.dotNet = true;
sobre.setOutputSoapObject(request);
HttpTransportSE transporte = new HttpTransportSE(url);
try {
transporte.call(accionSoap, sobre);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
SoapPrimitive resultado = (SoapPrimitive)
sobre.getResponse();
texto=resultado.toString();
}catch (SoapFault e) {
texto="No se pudo recuperar el mensaje";
e.printStackTrace();
}
return texto;
}
public String getFechaMensaje(int id)
{
String texto="";
SoapObject request = new SoapObject(namespace, mGetFechaMensaje);
request.addProperty("idMensaje",id);
SoapSerializationEnvelope sobre = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobre.dotNet = true;
sobre.setOutputSoapObject(request);
HttpTransportSE transporte = new HttpTransportSE(url);
try {
transporte.call(accionSoap, sobre);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
SoapPrimitive resultado = (SoapPrimitive)
sobre.getResponse();
texto=resultado.toString();
30
}catch (SoapFault e) {
texto="01/01/1900";
e.printStackTrace();
}
return texto;
}
}
2.7 Mis_Notas.java: Esta actividad carga las notas que el estudiante tiene
package sv.edu.ufg;
import java.util.ArrayList;
import sv.edu.ufg.Mis_Recursos.miExpandableAdapter;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseExpandableListAdapter;
import android.widget.ExpandableListView;
import android.widget.TextView;
import android.widget.Toast;
public class Mis_Notas extends Activity {
private ArrayList<String> grupos;
private ArrayList<ArrayList<ArrayList<String>>> hijos;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.recursos);
ExpandableListView l = (ExpandableListView)
findViewById(R.id.ExpandableListView01);
cargarDatos();
31
miExpandableAdapter adaptador = new miExpandableAdapter(this, grupos,
hijos);
l.setAdapter(adaptador);
}
public class miExpandableAdapter extends BaseExpandableListAdapter {
private ArrayList<String> groups;
private ArrayList<ArrayList<ArrayList<String>>> children;
private Context context;
public miExpandableAdapter(Context context, ArrayList<String> groups,
ArrayList<ArrayList<ArrayList<String>>> children) {
this.context = context;
this.groups = grupos;
this.children = hijos;
}
@Override
public boolean areAllItemsEnabled()
{
return true;
}
public ArrayList<String> getChild(int groupPosition, int childPosition)
{
return children.get(groupPosition).get(childPosition);
}
public long getChildId(int groupPosition, int childPosition) {
return childPosition;
}
public View getChildView(int groupPosition, int childPosition, boolean
isLastChild,View convertView, ViewGroup parent) {
String hijo = (String) ((ArrayList<String>)getChild(groupPosition,
childPosition)).get(0);
if (convertView == null) {
LayoutInflater infalInflater = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
convertView = infalInflater.inflate(R.layout. hijos, null);
}
TextView hijotxt = (TextView)
convertView.findViewById(R.id.TextViewHijo01);
32
hijotxt.setText(hijo);
return convertView;
}
public int getChildrenCount(int groupPosition) {
return children.get(groupPosition).size();
}
public String getGroup(int groupPosition) {
return groups.get(groupPosition);
}
public int getGroupCount() {
return groups.size();
}
public long getGroupId(int groupPosition) {
return groupPosition;
}
public View getGroupView(int groupPosition, boolean isExpanded, View
convertView, ViewGroup parent) {
String group = (String) getGroup(groupPosition);
if (convertView == null) {
LayoutInflater infalInflater = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
convertView = infalInflater.inflate(R.layout. grupo, null);
}
TextView grouptxt = (TextView)
convertView.findViewById(R.id.TextViewGrupo);
grouptxt.setText(group);
return convertView;
}
public boolean hasStableIds() {
return true;
}
public boolean isChildSelectable(int arg0, int arg1) {
return true;
}
33
}
private void cargarDatos(){
grupos= new ArrayList<String>();
hijos= new ArrayList<ArrayList<ArrayList<String>>>();
grupos.add("ASI1");
grupos.add("DBD2");
grupos.add("EDD0");
grupos.add("ETP0");
hijos.add(new ArrayList<ArrayList<String>>());
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(0).add("Laboratorio 1: 8.2");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(1).add("Laboratorio 2: 0.0");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(2).add("Laboratorio 3: 0.0");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(3).add("Laboratorio 4: 0.0");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(4).add("Parcial 1: 7.6");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(5).add("Parcial 2: 0.0");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(6).add("Parcial 3: 0.0");
hijos.get(0).add(new ArrayList<String>());
hijos.get(0).get(7).add("Parcial 4: 0.0");
hijos.add(new ArrayList<ArrayList<String>>());
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(0).add("Laboratorio 1: 9.5");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(1).add("Laboratorio 2: 0.0");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(2).add("Laboratorio 3: 0.0");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(3).add("Laboratorio 4: 0.0");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(4).add("Parcial 1: 8.6");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(5).add("Parcial 2: 0.0");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(6).add("Parcial 3: 0.0");
hijos.get(1).add(new ArrayList<String>());
hijos.get(1).get(7).add("Parcial 4: 0.0");
hijos.add(new ArrayList<ArrayList<String>>());
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(0).add("Laboratorio 1: 6.5");
hijos.get(2).add(new ArrayList<String>());
34
hijos.get(2).get(1).add("Laboratorio 2: 0.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(2).add("Laboratorio 3: 0.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(3).add("Laboratorio 4: 0.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(4).add("Parcial 1: 10.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(5).add("Parcial 2: 0.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(6).add("Parcial 3: 0.0");
hijos.get(2).add(new ArrayList<String>());
hijos.get(2).get(7).add("Parcial 4: 0.0");
hijos.add(new ArrayList<ArrayList<String>>());
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(0).add("Laboratorio 1: 9.5");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(1).add("Laboratorio 2: 0.0");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(2).add("Laboratorio 3: 0.0");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(3).add("Laboratorio 4: 0.0");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(4).add("Parcial 1: 8.6");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(5).add("Parcial 2: 0.0");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(6).add("Parcial 3: 0.0");
hijos.get(3).add(new ArrayList<String>());
hijos.get(3).get(7).add("Parcial 4: 0.0");
}
}
2.8 Mis_Recursos.java: esta clase carga los recursos a los que el usuario
puede acceder. public class Mis_Recursos extends Activity{
TextView txtEncabezado;
ListView lista;
private static final String accionSoap = "http://tempuri.org/";
private static final String mGetIdCurso = "getIdCurso";
private static final String mGetNombreRecurso = "getNombreRecurso";
private static final String mGetDireccionRecurso = "getDireccionRecurso";
private static final String namespace = "http://tempuri.org/";
private static final String url = "http://10.0.2.2:7294/svcLogin.asmx";
String[] items;
String[] direcciones;
35
String[] res;
private ArrayList<String> recursos = new ArrayList<String>();
public static final int progress_bar_type = 0;
private ProgressDialog pDialog;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.mis_recursos);
Bundle extra = this.getIntent().getExtras();
txtEncabezado = (TextView)findViewById(R.id.textView1);
txtEncabezado.setText("Recursos de "+extra.getString("item"));
final String asignatura = extra.getString("item");
String conexion = extra.getString("conectado");
int con = Integer.parseInt(extra.getString("conectado"));
if (con==1)
{ //hacer insert a la base, luego con las direcciones, hacer update
delRecurso(asignatura);
//Obtener los recursos de este curso
SoapObject requestRecursos = new SoapObject(namespace,
mGetNombreRecurso);
requestRecursos.addProperty("asignatura",asignatura);
SoapSerializationEnvelope sobreRecursos = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobreRecursos.dotNet = true;
sobreRecursos.setOutputSoapObject(requestRecursos);
HttpTransportSE transporteRecursos = new HttpTransportSE(url);
try {
transporteRecursos.call(accionSoap, sobreRecursos);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Resultados
try {
SoapPrimitive resultado = (SoapPrimitive)
sobreRecursos.getResponse();
res = resultado.toString().split(",");
items = new String[res.length];
int i=0;
for (i=0; i<res.length; i++)
{
36
items[i]=res[i];
//sustituir por un insert a la base
insRecurso(asignatura,res[i],"");
}
} catch (SoapFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//Obtener las direcciones de los recursos
SoapObject requestDirRecursos = new SoapObject(namespace,
mGetDireccionRecurso);
requestDirRecursos.addProperty("asignatura",asignatura);
SoapSerializationEnvelope sobreDirRecursos = new
SoapSerializationEnvelope(SoapEnvelope.VER12);
sobreDirRecursos.dotNet = true;
sobreDirRecursos.setOutputSoapObject(requestDirRecursos);
HttpTransportSE transporteDirRecursos = new HttpTransportSE(url);
try {
transporteDirRecursos.call(accionSoap, sobreDirRecursos);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
SoapPrimitive resultadoDir = (SoapPrimitive)
sobreDirRecursos.getResponse();
String[] resDir = resultadoDir.toString().split(",");
direcciones = new String[resDir.length];
int i=0;
37
for (i=0; i<resDir.length; i++)
{
//update de los recursos
updRecurso(resDir[i],res[i],asignatura);
}
} catch (SoapFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
getRecursos(asignatura);
lista = (ListView)findViewById(R.id.listView1);
lista.setAdapter(new
ArrayAdapter(this,android.R.layout.simple_list_item_1,recursos));
lista.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
String direccion =
getURL(asignatura,lista.getItemAtPosition(position).toString());
//Descargar archivo
new DownloadFileFromURL().execute(direccion);
}
});
}
public String getURL(String asignatura, String recurso)
{
String URL="";
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "SELECT recursoURL from Recursos WHERE idAsignatura=?
and recursoNombre=?";
String[] args = {asignatura,recurso};
Cursor c = db.rawQuery(sql, args);
c.moveToFirst();
38
URL=c.getString(0);
c.close();
return URL;
}
public void insRecurso(String asignatura, String nombre, String URL)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "INSERT INTO
Recursos(idAsignatura,recursoNombre,recursoURL)
VALUES('"+asignatura+"','"+nombre+"','"+URL+"')";
db.execSQL(sql);
}
public void updRecurso(String URL, String nombre, String asignatura)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "UPDATE Recursos SET recursoURL='"+URL+"' WHERE
recursoNombre='"+nombre+"' AND idAsignatura='"+asignatura+"'" ;
db.execSQL(sql);
}
public void delRecurso(String asignatura)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "DELETE FROM Recursos WHERE
idAsignatura='"+asignatura+"'" ;
db.execSQL(sql);
}
public void getRecursos(String asignatura)
{
DBHelper dbh =new DBHelper(this, "db_ufg", null, 1);
SQLiteDatabase db = dbh.getWritableDatabase();
String sql = "select recursoNombre from Recursos where
idAsignatura='"+asignatura+"'";
Cursor c = db.rawQuery(sql,null);
if (c.moveToFirst())
{
do{
agregarLista(c);
}while(c.moveToNext());
}
c.close();
}
private void agregarLista(Cursor c)
39
{
recursos.add(c.getString(0));
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case progress_bar_type: // establecido a 0
pDialog = new ProgressDialog(this);
pDialog.setMessage("Descargando archivo, espere...");
pDialog.setIndeterminate(false);
pDialog.setMax(100);
pDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
pDialog.setCancelable(true);
pDialog.show();
return pDialog;
default:
return null;
}
}
class DownloadFileFromURL extends AsyncTask<String, String, String> {
@Override
protected void onPreExecute() {
super.onPreExecute();
showDialog(progress_bar_type);
}
@Override
protected String doInBackground(String... f_url) {
int count;
try {
URL url = new URL(f_url[0]);
URLConnection conection = url.openConnection();
conection.connect();
int lenghtOfFile = conection.getContentLength();
InputStream input = new
BufferedInputStream(url.openStream(), 8192);
OutputStream output = new FileOutputStream("/sdcard");
byte data[] = new byte[1024];
long total = 0;
while ((count = input.read(data)) != -1) {
total += count;
40
publishProgress(""+(int)((total*100)/lenghtOfFile));
output.write(data, 0, count);
}
output.flush();
output.close();
input.close();
} catch (Exception e) {
Log.e("Error: ", e.getMessage());
}
return null;
}
protected void onProgressUpdate(String... progreso) {
pDialog.setProgress(Integer.parseInt(progreso[0]));
}
@Override
protected void onPostExecute(String file_url) {
dismissDialog(progress_bar_type);
}
}
}
2.9 Calendario.java: Clase para mostrar el calendario académico actual.
package sv.edu.ufg.moodle;
import android.app.Activity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
41
public class Calendario extends Activity{
private WebView webView;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver);
String url = "http://www.ufg.edu.sv/ni.calendario.html";
webView = (WebView)findViewById(R.id.webView1);
WebSettings webSetting= webView.getSettings();
webSetting.setJavaScriptEnabled(true);
webView.setWebViewClient(new WebViewClient());
webView.loadUrl(url);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK) && webView.canGoBack()){
webView.goBack();
return true;
}
return super.onKeyDown(keyCode, event);
}
}
2.10 Noticias.java: Clase que muestra las noticias del sitio web de la
universidad.
package sv.edu.ufg.moodle;
import android.app.Activity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.webkit.WebSettings;
import android.webkit.WebView;
import android.webkit.WebViewClient;
public class Noticias extends Activity{
private WebView webView;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ver);
String url = "http://noticias.ufg.edu.sv";
webView = (WebView)findViewById(R.id.webView1);
WebSettings webSetting= webView.getSettings();
42
webSetting.setJavaScriptEnabled(true);
webView.setWebViewClient(new WebViewClient());
webView.loadUrl(url);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK) && webView.canGoBack()){
webView.goBack();
return true;
}
return super.onKeyDown(keyCode, event);
}
}
3. Estructura de los servicios web
A continuación se presentan los métodos del servicio web que la aplicación utiliza
para comunicarse con la base de datos MySQL que tiene el sistema Moodle.
3.1 Autenticar usuario
<WebMethod()> _ Public Function autenticar(carnet As String, clave As String) As Integer
Dim existe As Integer = 0
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
cnn.Open()
Dim sql As String = "SELECT COUNT(*) FROM ufg_user WHERE username='" &
carnet & "' and password=md5('" & clave & "') and suspended=0 and deleted=0"
Dim cmd As New MySqlCommand(sql, cnn)
existe = cmd.ExecuteScalar()
cnn.Close()
Return existe
End Function
Este método autentica al usuario con la base de datos del sistema
Moodle.
3.2 Obtener las materias del estudiante
<WebMethod()> _ Public Function getMateriasEstudiante(carnet As String) As String
43
Dim materias As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
cnn.Open()
Dim sql As String = "SELECT c.shortname as asignatura FROM ufg_user u,
ufg_role_assignments ra, ufg_context con, ufg_course c, ufg_role r" & _
" WHERE u.id = ra.userid " & _
" AND ra.contextid = con.id " & _
" AND con.contextlevel =50 " & _
" AND con.instanceid = c.id" & _
" AND ra.roleid = r.id" & _
" AND r.shortname = 'student'" & _
" AND u.username='" & carnet & "'"
Dim cmd As New MySqlCommand(sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
materias &= dr.Item(0).ToString & ","
End While
If materias.EndsWith(",") Then
materias = materias.Substring(0, materias.Length - 1)
End If
cnn.Close()
Return materias
End Function
Esta función devuelve las materias que el estudiante tenga inscritas en el
sistema Moodle.
3.3 Obtener el código del curso
<WebMethod()> _ Public Function getIdCurso(nombre As String) As Integer
Dim cursoId As Integer = -1
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
cnn.Open()
Dim sql As String = "select id from ufg_course where shortname='" & nombre &
"'"
Dim cmd As New MySqlCommand(sql, cnn)
cursoId = cmd.ExecuteScalar()
cnn.Close()
Return cursoId
End Function
3.4 Obtener el nombre y la dirección del del recurso
<WebMethod()> _ Public Function getNombreRecurso(asignatura As String) As String
Dim idCurso As Integer = getIdCurso(asignatura)
Dim recurso As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
44
cnn.Open()
Dim sql As String = "select name from ufg_resource where course=" & idCurso
Dim cmd As New MySqlCommand(sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
recurso &= dr.Item(0).ToString & ","
End While
If recurso.EndsWith(",") Then
recurso = recurso.Substring(0, recurso.Length - 1)
End If
cnn.Close()
Return recurso
End Function
<WebMethod()> _
Public Function getDireccionRecurso(asignatura As String) As String
Dim direccion As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
cnn.Open()
Dim sql As String = "SELECT concat(
'http://127.0.0.1/moodle/mod/resource/view.php?id=', cm.id) " & _
"as address,c.shortname " & _
"FROM ufg.ufg_course_modules cm, ufg_course c " & _
"WHERE c.shortname='" & asignatura & "' and cm.module=17 AND c.id=cm.course"
Dim cmd As New MySqlCommand(Sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
direccion &= dr.Item(0).ToString & ","
End While
If direccion.EndsWith(",") Then
direccion = direccion.Substring(0, direccion.Length - 1)
End If
cnn.Close()
Return direccion
End Function
Esta función obtiene a partir de la asignatura, los recursos que el
estudiante posea en esa asignatura y su dirección URL.
3.5 Mensajes
<WebMethod()> _ Public Function personaEnviaMensaje(idPara As String) As String
Dim persona As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
cnn.Open()
Dim sql As String = "SELECT DISTINCT concat(u.firstname+' '+u.lastname) as
persona FROM ufg_user u, ufg_message m WHERE u.id=m.useridfrom and u.username='" &
idPara & "'"
45
Dim cmd As New MySqlCommand(sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
persona &= dr.Item(0).ToString & ","
End While
If persona.EndsWith(",") Then
persona = persona.Substring(0, persona.Length - 1)
End If
cnn.Close()
Return persona
End Function
<WebMethod()> _
Public Function getIdMensaje(carnet As String) As String
Dim idMensajes As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
Dim dr As MySqlDataReader
cnn.Open()
Dim sql As String = "select m.id from ufg_message m, ufg_user u WHERE
m.useridto = u.id AND u.username='" & carnet & "'"
Dim cmd As New MySqlCommand(sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
idMensajes &= dr.Item(0).ToString & ","
End While
If idMensajes.EndsWith(",") Then
idMensajes = idMensajes.Substring(0, idMensajes.Length - 1)
End If
cnn.Close()
Return idMensajes
End Function
<WebMethod()> _
Public Function getAsuntoMensaje(carnet As String) As String
Dim asunto As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
cnn.Open()
Dim dr As MySqlDataReader
'Dim sql As String = "select concat(subject,'- enviado el: ',FROM_UNIXTIME(
timecreated, '%d/%m/%Y %H:%i:%s' )) from ufg_message where username='" & carnet &
"'"
Dim sql As String = "select concat(m.subject,'- enviado el: ',FROM_UNIXTIME(
m.timecreated, '%d/%m/%Y %H:%i:%s' )) from ufg_message m, ufg_user u WHERE
m.useridto = u.id AND u.username='" & carnet & "'"
Dim cmd As New MySqlCommand(Sql, cnn)
dr = cmd.ExecuteReader()
While dr.Read
asunto &= dr.Item(0).ToString & ","
End While
If asunto.EndsWith(",") Then
asunto = asunto.Substring(0, asunto.Length - 1)
End If
cnn.Close()
Return asunto
46
End Function
<WebMethod()> _
Public Function getTextoMensaje(idMensaje As Integer) As String
Dim msj As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
cnn.Open()
Dim sql As String = "select smallmessage from ufg_message where id=" &
idMensaje
Dim cmd As New MySqlCommand(sql, cnn)
msj = cmd.ExecuteScalar()
cnn.Close()
Return msj
End Function
<WebMethod()> _
Public Function getFechaMensaje(idMensaje As Integer) As String
Dim fecha As String = ""
Dim cnn As New MySqlConnection("server=localhost;User Id=root;database=ufg")
cnn.Open()
Dim sql As String = "SELECT FROM_UNIXTIME( timecreated, '%d/%m/%Y %H:%i:%s'
) as fecha FROM ufg_message where id=" & idMensaje
Dim cmd As New MySqlCommand(sql, cnn)
fecha = cmd.ExecuteScalar()
cnn.Close()
Return fecha
End Function
Estas funciones son utilizadas para la composición de los mensajes que el
estudiante reciba de otras personas.
47
Anexo 2
Manual del usuario (Android)
1. Instalación
A continuación se presentan los pasos para poder instalar la aplicación en nuestro
teléfono inteligente. Se presenta el caso práctico para un teléfono con Android 2.2.
Se observan las pantallas en inglés debido a que el emulador para Android no se
encuentra en español. Pero al hacer una instalación en el dispositivo físico se
tiene la instalación en el idioma que tenga configurado el dispositivo.
Paso 1: Descargamos el archivo AndroidUFG.apk desde el sitio de la universidad
directamente desde nuestro teléfono.
Figura 1. Descarga de la aplicación.
Paso 2: Al tenerla descargada se le toca para que comience el proceso de
instalación.
48
Figura 2. Menú de instalación.
Aparece el menú de instalación. Aquí se puede ver los permisos que la aplicación
solicita: Comunicación de red, leer el estado del teléfono y reconocer las
aplicaciones que estén corriendo.
Si el usuario está de acuerdo, se le da clic en install en la parte inferior de la
pantalla.
Figura 3. Instalación.
Al finalizar, aparece la siguiente pantalla que demuestra que se ha instalado
correctamente.
49
Figura 4. Aplicación instalada
Se puede darle “open” para abrirla de inmediato o “done” para aceptar la
instalación y cerrar el dialogo.
Figura 5. Menú principal mostrando la aplicación instalada.
50
En la parte inferior ya se observa que la aplicación se ha instalado de forma
correcta.
2. Uso de la aplicación
2.1 Autenticación
En esta pantalla se debe que introducir el usuario (carnet) y la clave, si el alumno
está inscrito en el ciclo actual y como estudiante activo, se pasa a la pantalla del
menú principal de la aplicación. Para que la aplicación funcione correctamente
debe estar conectado a internet, ya sea por la red móvil del proveedor o a través
de WIFI.
Figura 6. Pantalla de autenticación.
Luego de introducir las credenciales se presionará el botón entrar para pasar al
menú principal o cancelar si se quiere salir de la aplicación .
51
a. Menú Principal
Es el punto de partida de la aplicación, desde aquí se controla lo que el usuario
quiera hacer, da acceso a las opciones del sistema.
Figura 7.
Para acceder a las opciones, simplemente se debe seleccionar la que el usuario
desee para pasar a las distintas actividades.
b. Mis asignaturas inscritas
Esta actividad muestra un listado de las asignaturas que el alumno tenga inscritas
en el ciclo que cursa actualmente, dando click en cada una se puede obtener
información general de la misma: quien la imparte, en que horario es impartida,
donde se imparte y el contenido programático de la misma.
52
Figura 8.
Para acceder a la descripción, bastará con seleccionar la materia que interese.
c. Mis Recursos
Aquí se tienen los distin tos recursos disponibles de las materias: documentos,
videos, imágenes, e tc.
53
Figura 9.
Para descargar los documentos basta seleccionar el botón del lado izquierdo de la
materia para desplegar la lista y seleccionar lo que interese.
d. Mis Notas
A través de este recurso se puede observar las notas de las materias que el
alumno lleve en el ciclo que estudia actualmente.
54
Figura 10.
e. Calendario
En esta actividad se carga el calendario académico de el ciclo actualmente
cursado.
Figura 11. Calendario
55
f. Noticias
Por medio de esta actividad observamos las noticias relevantes provenientes del
sitio web de la universidad.
Figura 12. Noticias.
Para terminar de usar la aplicación bastara dar clic en el botón home del teléfono.
56
Anexo 3
Preparar el entorno para desarrollo con Android
1. Lo primero que se debe hacer es descargar el SDK de Android. Se debe
descargar la versión recomendada por Google. Previamente se habrá
instalado la última versión de JDK (Java Development Key).
Una vez instalado, se abrirá el Android SDK Manager, selecciona ndo las
versiones que se quieran instalar y se le da a Install Packages:
Figura 1. Instalación del paquete Android SDK
57
Tras esto, se acepta la confirmación para todos los paquetes:
Figura 2. Paquetes a instalar.
2. Una vez instalado el SDK de Android, se debe descargar un IDE, en este
caso, se optará por Eclipse. Debe ir a la página de Descarga de Eclipse y
seleccionar el “Eclipse IDE for Java Developers” adecuado a la versión del
sistema operativo (32 ó 64 bits) más adecuada.
Se procede a instalarlo y se ejecuta. Una vez abierto, Se instalará el plugin
para Android, para ello debe dirigirse al menú Help > Install New Software,
pulsar el boton Add e introducir:
·Name: AndroidADT
· Location: https://dl-ssl.google.com/android/eclipse/
Y a continuación seleccionar todos los puntos tal y como señala la imagen
de abajo:
58
Figura 3. Instalación de plug-in para Eclipse.
Hacer clic en Next hasta que termine la instalación y pedirá reiniciar la
aplicación. Una vez reiniciada pide la ubicación del SDK de Android,
seleccionar donde se ha instalado el SDK:
Figura 4
59
3. Por último queda preparar la máquina virtual llamada AVD (Android Virtual
Device). En al menú Window > AVD Manager, hacer click en New para
preparar una nueva AVD, y elegir opciones como: Versión de Android,
tamaño de la tarjeta de memoria, tipo de pantalla y/o resolución
(dependiente de la versión), configuración de hardware (tamaño de
memoria RAM, soporte al acelerómetro, a la cámara, al GPS…):
Figura 5. Creación del emulador.
Una vez creada, se podrá arrancarla e interactuar con ella. Abrir un par de
vistas más, haciendo click en Window > Show View > Emulator Control y
haremos lo propio para Log Cat.
· Emulator Control: Desde aquí se podrá interactuar con la AVD simulando
por ejemplo una llamada entrante.
· Log Cat: Es un log en el que aparecen todos los mensajes que va
lanzando la AVD. Permite crear filtros para encontrar los mensajes
lanzados por la aplicación, por ejemplo.