Embed Size (px)
Citation preview
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y MATEMÁTICA
CARRERA DE INGENIERÍA EN COMPUTACIÓN GRÁFICA
“DISEÑO Y DESARROLLO DE UNA APLICACIÓN MÓVIL PARA
DOCENTES DE LA ESCUELA FISCAL MIXTA “DR. ALFONSO MORA
BOWEN”, DEL BARRIO INCHAPICHO, PARROQUIA NAYÓN, PARA EL
PROCESO DE CONTROL Y EVALUACIÓN DE LOS ESTUDIANTES”
TRABAJO DE GRADUACIÓN PREVIO A LA OBTENCIÓN DEL
TÍTULO DE INGENIERO EN COMPUTACIÓN GRÁFICA.
AUTOR:
PILLAJO PILLAJO LUIS DARIO
TUTOR: ING. SALVADOR MENESES JAIME OSWALDO
QUITO – ECUADOR
2015
ii
DEDICATORIA
Quiero dedicar este trabajo en primer lugar a Dios, por ser quien guía mi vida,
por darme la fortaleza y así lograr alcanzar esta meta. A mis padres Amada
Pillajo y Leonardo Pillajo, quienes han sido el pilar fundamental de mi vida, los
admiro y los amo con todo mi corazón, gracias por su apoyo, por su amor, por
su esfuerzo y por sus ánimos.
A mi hijo Thiago Martin, a quien quiero mucho y es la mejor bendición que
Dios me ha dado.
A una persona especial, Myriam Chirán quien me ha brindado siempre su
apoyo incondicional y me ha motivado en todo momento para culminar mis
estudios y cumplir esta meta.
iii
AGRADECIMIENTO
Como prioridad en mi vida agradezco a Dios por su infinita bondad, y por haber
estado conmigo en los momentos que más lo necesitaba, por darme salud,
fortaleza, responsabilidad y sabiduría, por haberme permitido culminar un
peldaño más de mis metas, y porque tengo la certeza y el gozo de que siempre
va a estar conmigo.
A mi director de tesis, Ing. Jaime Salvador por su esfuerzo y dedicación, quien
con sus conocimientos, su experiencia, su paciencia y su motivación ha
logrado en mí que pueda terminar mis estudios con éxito.
También me gustaría agradecer a mis profesores durante toda mi carrera
profesional porque todos han aportado con un granito de arena a mi
formación, y en especial a mis profes la Ing. Zoila Ruiz, Fis. Bayardo
Campusano, Ing. Roberto Rosero, Lic. Gabriela Mafla por sus consejos, su
enseñanza y más que todo por su amistad.
iv
AUTORIZACIÓN DE LA AUTORIA INTELECTUAL
v
CERTIFICACIÓN DEL TUTOR SOBRE LA CONLUSION DEL TRABAJO
DE GRADUACIÓN
vi
INFORME SOBRE LA CONCLUSIÓN DEL TRABAJO DE GRADUACIÓN
vii
RESULTADO DEL TRABAJO DE GRADUACIÓN
viii
CONTENIDO
DEDICATORIA .............................................................................................. ii
AGRADECIMIENTO ..................................................................................... iii
AUTORIZACIÓN DE LA AUTORIA INTELECTUAL ...................................... iv
INFORME SOBRE LA CONCLUSIÓN DEL TRABAJO DE GRADUACIÓN .. vi
RESULTADO DEL TRABAJO DE GRADUACIÓN ....................................... vii
LISTADO DE GRÁFICOS ............................................................................. xi
LISTADO DE TABLAS .................................................................................xiii
RESUMEN.................................................................................................. xiv
ABSTRACT ................................................................................................. xv
CERTIFICACIÓN DEL TRADUCTOR ......................................................... xvi
TITULO DEL TRADUCTOR ........................................................................xvii
CAPITULO I ................................................................................................... 1
1. PRESENTACIÓN DEL PROBLEMA ................................................... 1
1.1. Planteamiento del problema .......................................................... 1
1.2. Formulación del problema ............................................................. 2
1.3. Objetivos de la Investigación ......................................................... 3
1.3.1. Objetivo General .................................................................. 3
1.3.2. Objetivos Específicos........................................................... 3
1.4. Alcance ......................................................................................... 3
1.5. Limitaciones .................................................................................. 5
1.6. Justificación ................................................................................... 6
CAPITULO 2 .................................................................................................. 7
2. MARCO TEÓRICO ............................................................................. 7
2.1. Antecedentes ................................................................................ 7
2.2. Bases Teóricas .............................................................................. 8
2.2.1. Dispositivo Móvil .................................................................. 8
2.2.2. Sistema Operativo Móvil ...................................................... 8
2.3. Plataforma Android ...................................................................... 12
2.3.1. Un poco de Historia ........................................................... 12
2.3.2. Evolución de Android ......................................................... 13
2.3.3. Arquitectura ....................................................................... 16
2.3.4. La Máquina Virtual Dalvik .................................................. 21
2.3.5. La Máquina Virtual ART ..................................................... 22
ix
2.3.6. Herramientas de Desarrollo ............................................... 22
2.3.7. Componentes en una aplicación Android ........................... 27
2.3.8. Ciclo de vida de las aplicaciones Android .......................... 29
2.4. Plataforma de Desarrollo ............................................................. 31
2.4.1. MySQL............................................................................... 32
2.4.2. PHP ................................................................................... 34
2.4.3. Json ................................................................................... 35
2.4.4. Apache .............................................................................. 35
2.5. Diseño Gráfico ............................................................................. 36
CAPÍTULO 3 ................................................................................................ 38
3. Diseño General de la Solución .......................................................... 38
3.1. Metodología ágil de desarrollo de software ................................. 38
3.1.1. ¿Qué es una Metodología?................................................ 38
3.1.2. Metodología Ágil ................................................................ 39
3.1.3. Ventajas de la Metodología Ágil ......................................... 40
3.1.4. Beneficios del Método Ágil ................................................. 40
3.1.5. Metodología SCRUM ......................................................... 41
3.2. Fase Preliminar ........................................................................... 46
3.2.1. Planteamiento del problema .............................................. 47
3.2.2. Planteamiento de la Solución ............................................. 47
3.2.3. Alcance de la Solución ....................................................... 48
3.2.4. Restricción ......................................................................... 48
3.3. Fase de Planeación ..................................................................... 49
3.3.1. Factibilidad ........................................................................ 49
3.3.2. Arquitectura de la Solución ................................................ 52
3.3.3. Diseño de la Base de Datos............................................... 54
3.3.4. Diseño del Mapa de Navegación ....................................... 62
3.3.5. Guía de estilos ................................................................... 62
3.4. Fase de Desarrollo ...................................................................... 65
3.4.1. “Capas” de la aplicación .................................................... 65
3.4.2. Web Service ...................................................................... 67
3.4.3. Diseño de los bocetos de las pantallas de la aplicación ..... 73
3.4.4. Diseño de Interfaz de Usuario ............................................ 76
3.4.5. Reciclaje ............................................................................ 89
3.5. Fase de Implementación ............................................................. 89
3.5.1. Web Hosting ...................................................................... 89
x
3.5.2. Instalación apk ................................................................... 94
3.5.3. Manual de Usuario ............................................................. 95
CAPÍTULO 4 ................................................................................................ 96
4. Conclusiones y Recomendaciones ................................................... 96
4.1. Conclusiones ............................................................................... 96
4.2. Recomendaciones ....................................................................... 97
Bibliografía................................................................................................... 99
ANEXO ...................................................................................................... 100
xi
LISTADO DE GRÁFICOS
Figura 1. Características de los dispositivos móviles ................................................................... 8
Figura 2. Cuota de mercado Sistemas Operativos Móviles ...................................................... 10
Figura 3. Evolución de Android .................................................................................................... 14
Figura 4. Android 4.4: KitKat ......................................................................................................... 15
Figura 5. Android 5.0: LolliPop ..................................................................................................... 16
Figura 6. Arquitectura de Android ................................................................................................ 17
Figura 7. Android Runtime ............................................................................................................ 19
Figura 8. Sitio de descargar de JDK ............................................................................................ 24
Figura 9. Ilustración de la página de descarga de Android Studio .......................................... 25
Figura 10. Componentes que se instalaran ................................................................................ 25
Figura 11. Configuración del Intel Hardware Accelerated Execution Manager ....................... 26
Figura 12. Rutas para guardar el SDK de Android ..................................................................... 26
Figura 13. Confirmación de versiones anteriores ....................................................................... 27
Figura 14. Ilustración de la descarga de Componentes ............................................................ 27
Figura 15. Diagrama de flujo del ciclo de vida de una Actividad en Android ........................... 30
Figura 16. Estructura del desarrollo aplicando SCRUM ............................................................ 42
Figura 17. Proceso Metodología Ágil Scrum............................................................................... 43
Figura 18. Arquitectura cliente-servidor ....................................................................................... 53
Figura 19. Modelo del esquema de la Base de Datos ............................................................... 55
Figura 20. Interfaz del programa PHPMyAdmin ......................................................................... 56
Figura 21. Mapa de Navegación .................................................................................................. 62
Figura 22. Gama de colores a usar ............................................................................................. 64
Figura 23.Tipografía a usar........................................................................................................... 64
Figura 24. Esquema des capas de la aplicación ........................................................................ 66
Figura 25. Archivo de configuración – Login.php ....................................................................... 70
Figura 26. Pantalla de Presentación o Splash ............................................................................ 74
Figura 27. Pantalla de Inicio Sesión ............................................................................................ 74
Figura 28. Pantalla de Menú ......................................................................................................... 75
Figura 29. Pantalla de Menú de Notas ........................................................................................ 75
Figura 30. Pantalla de Notas ........................................................................................................ 76
xii
Figura 31. Pantalla de Detalle Notas ................................................ ¡Error! Marcador no definido.
Figura 32. Pantalla de Asitencias ................................................................................................. 76
Figura 33. Pantalla de Detalle Notas. ............................................... ¡Error! Marcador no definido.
Figura 34. Lista de archivos layouts y código XML del layout .................................................. 77
Figura 35. Interfaz de Usuario – Login ........................................................................................ 79
Figura 36. Pantalla principal del Hostinger.................................................................................. 90
Figura 37. Configuración MySQL ................................................................................................. 90
Figura 38. Crear una nueva Base de Datos ................................................................................ 91
Figura 39. Configuración de la Base de Datos MySQL ............................................................. 92
Figura 40. Administrador de Archivos .......................................................................................... 92
Figura 41. Pantalla de Administrador de Archivos ................................................................ 93
Figura 42. Pantalla para subir archivos PHP......................................................................... 93
Figura 43. Pantalla de aplicaciones ...................................................................................... 94
Figura 44. Pantalla de aceptación o no de instalación de aplicaciones de fuentes desconocidas ........................................................................................................................ 94
Figura 45. Aceptación de fuetes desconocidos ..................................................................... 95
Figura 46. Icono de la aplicación ......................................................................................... 100
Figura 47. Splash de la aplicación ...................................................................................... 100
Figura 48. Pantalla de Login ............................................................................................... 101
Figura 49. Menú principal de la aplicación .......................................................................... 101
Figura 50. Pantalla Menú de Notas ..................................................................................... 101
Figura 51. Pantalla Notas .................................................................................................... 102
Figura 52. Icono guardar ..................................................................................................... 102
Figura 53. Icono Detalle Nota .............................................................................................. 103
Figura 54. Pantalla Detalle Nota ......................................................................................... 103
Figura 55.Pantalla Asistencias ............................................................................................ 103
xiii
LISTADO DE TABLAS
Tabla 1. Hardware existente ................................................................................................. 50
Tabla 2. Hardware Disponible ............................................................................................... 51
Tabla 3. Software existente ................................................................................................... 51
Tabla 4. Recurso humano requerido ..................................................................................... 52
Tabla 5. Recurso Humano .................................................................................................... 52
Tabla 6. Tabla Alumno .......................................................................................................... 57
Tabla 7. Tabla Asistencia ...................................................................................................... 58
Tabla 8. Tabla Curso ............................................................................................................. 58
Tabla 9. Tabla Año Lectivo.................................................................................................... 58
Tabla 10. Tabla Materia ........................................................................................................ 59
Tabla 11. Tabla Nota ............................................................................................................. 59
Tabla 12.Tabla Paralelo ........................................................................................................ 60
Tabla 13. Tabla Parcial ......................................................................................................... 60
Tabla 14. Tabla Quimestre .................................................................................................... 60
Tabla 15. Tabla Profesor ....................................................................................................... 61
Tabla 16. Tabla de Registro Notas ........................................................................................ 61
xiv
RESUMEN
DISEÑO Y DESARROLLO DE UNA APLICACIÓN MÓVIL PARA
DOCENTES DE LA ESCUELA FISCAL MIXTA “DR. ALFONSO MORA
BOWEN”, DEL BARRIO INCHAPICHO, PARROQUIA NAYÓN, PARA EL
PROCESO DE CONTROL Y EVALUACIÓN DE LOS ESTUDIANTES
En este mundo cada vez más competitivo, donde el desarrollo de nuevas
tecnologías va en crecimiento, surge la necesidad de que las empresas se
desarrollen y fortalezcan tecnológicamente.
Las empresas, tanto públicas como privadas, tienen un papel muy importante
en el desarrollo del país, porque son las que buscan distintas formas para
estar a la par con las nuevas tecnologías.
Este sistema se convierte en un aspecto de vital importancia en el régimen
educativo porque ofrece la facilidad de automatizar los recursos. En la
actualidad existen nuevas tendencias tecnológicas que facilitan el proceso de
control y evaluación de los docentes y estudiantes en escuelas y colegios.
Es por eso que el presente proyecto de titulación tiene como objetivo el
desarrollo y diseño de una aplicación móvil para dispositivos con sistema
operativo Android que permita minimizar recursos de los docentes, y que no
comprometan a la seguridad de la información académica en el proceso de
control y evaluación de los estudiantes de la escuela fiscal mixta “Dr. Alfonso
Mora Bowen”.
DESCRIPTORES:
SISTEMA OPERATIVO ANDROID / BASE DE DATOS MYSQL / JSON /
SERVICIOS WEB / DISEÑO GRÁFICO / ENTORNO DE DESARROLLO /
DISPOSITIVOS MÓVILES / PHP / METODOLOGÍA SCRUM
xv
ABSTRACT
THE DESIGN AND DEVELOPMENT OF A MOBILE APPLICATION FOR
TEACHERS FROM THE MIXED FISCAL SCHOOL “DR. ALFONSO MORA
BOWEN” FROM THE INCHAPICHO NEIGHBORHOOD, NAYON PARISH,
FOR THE CONTROL PROCESS AND EVALUATION OF THE STUDENTS.
In this world that is turning more competitive each and every day, where the
development of new technology is growing, a need surges for businesses to
develop and strengthen themselves technologically.
Both public and private businesses have an important role in the development
of the country because they are the ones who search for distinct forms of
remaining updated with the new technologies.
This system turns into an aspect of vital importance in the educative regiment
because the system offers an easy access for automating courses. In actuality,
new technological tendencies that facilitate the process of control and
evaluation for teachers and students in elementary schools and high schools
exist.
This is why the present certification project has as an objective the
development and design of a mobile application for devices with an android
operating system that permits the facilitation of a teacher’s course work and
that does not compromise the security of the academic information in the
control and evaluation process of the students from the mixed fiscal school
“Dr. Alfonso Mora Bowen.”
DESCRIPTORS:
ANDROID OPERATING SYSTEM / MYSQL BASE OF DATA / JSON / WEB
SERVICES / GRAPHIC DESIGN / SURROUNDING DEVELOPMENT /
MOBILE DEVICES / PHP / METHODOLOGY SCRUM
xvi
CERTIFICACIÓN DEL TRADUCTOR
xvii
TITULO DEL TRADUCTOR
1
CAPITULO I
1. PRESENTACIÓN DEL PROBLEMA
En los últimos años, las nuevas tecnologías de la información y comunicación
(TIC) están en su mayor auge, y se están convirtiendo en un elemento clave
dentro del sistema educativo. La incorporación de las TICs en las aulas admite
nuevas formas de acceder, generar y transmitir información y conocimiento,
al mismo tiempo permite minimizar recursos dentro del desarrollo educativo.
En la actualidad la presencia de las nuevas tecnologías móviles en la
educación presentan beneficios y ventajas que exigen el replanteamiento de
metodologías y estándares de educación y comunicación con los estudiantes.
La verificación de asistencias, detalle de las calificaciones tanto de prácticas
calificadas como de exámenes parciales y finales, son las que más son
utilizadas por el docente, las opciones descritas con anterioridad se
presentarán en la aplicación.
1.1. Planteamiento del problema
Las nuevas tecnologías, usos y aplicaciones disponibles para la creación y
distribución del conocimiento siguen apareciendo día a día, debemos
examinar si estamos adaptándonos estructural y organizacionalmente a estas
nuevas herramientas para mejorar el alcance, cobertura y uso de las mismas
para la difusión y optimización de recursos en nuestras instituciones
educativas.
En la actualidad se ha despertado un gran interés por diseñar y desarrollar
aplicaciones que aporten en el proceso de evaluación y control en el sistema
educativo tanto primaria como secundaria, ante dicho panorama se propone
realizar una aplicación para docentes de las Escuela Fiscal Mixta “Dr. Alfonso
Mora Bowen” que permitirá minimizar recursos tanto financieros como
materiales y genere seguridad de la información académica de los
estudiantes.
2
1.2. Formulación del problema
La escuela fiscal mixta “Dr. Alfonso Mora Bowen”, del Barrio Inchapicho,
Parroquia Nayón, fundada el 16 de Febrero de 1969, comenzó brindando sus
servicios con el nombre de “América” y el 16 de Febrero de 1990 se lo cambia
por el que actualmente posee.
En sus inicios la Institución Educativa fue Unidocente, después de cambiarse
de nombre se convierte en un Institución Educativa Pluridocente, en la
actualidad posee 10 docentes repartidos en las diferentes áreas de la
institución.
Actualmente el registro de asistencia y notas lo hacen manualmente en papel,
ya que no poseen un sistema que automatice estos procesos, siendo esto una
debilidad tecnológica que compromete la seguridad de la información
académica. Al realizar los procesos de forma manual genera pérdida de
tiempo y recursos humanos, que podrían ocupar este tiempo en fortalecer
otras actividades relacionadas con la academia.
Bajo este escenario, los docentes entregan sus registros manuales tanto de
asistencia como de notas, que en casos fortuitos se pueden extraviar o
modificar, por ello ningún docente puede realizar a largo plazo una revisión
del histórico entregado.
Desde esta perspectiva, la presente investigación pretende insertar la
tecnología digital a través del uso dispositivos móviles, como una solución
efectiva y eficiente para el manejo automático de estos procesos. Esto en
coherencia con el rápido crecimiento tecnológico que permite solventar las
nuevas demandas del sistema educativo y tomando en cuenta que en la
actualidad la mayoría de personas poseen algún tipo de dispositivos móviles
que ahora pueden ser utilizados para mejorar su trabajo cotidiano y su vida
diaria.
3
1.3. Objetivos de la Investigación
1.3.1. Objetivo General
Diseñar y desarrollar una aplicación para dispositivos móviles que permita
optimizar recursos del proceso de control y evaluación del alumnado de la
Escuela Fiscal Mixta “Dr. Alfonso Mora Bowen” haciendo uso de la plataforma
tecnológica Android.
1.3.2. Objetivos Específicos
Diseñar y desarrollar aplicaciones móviles para dispositivos con
sistema Android.
Elaborar una estructura lógica que contenga metodologías de
validación debidamente documentada, con una interfaz gráfica
atractiva, interesante y amigable en cuanto a contenido y calidad que
cumpla con las necesidades que se han establecido previamente.
Fomentar la creación de aplicaciones móviles que automaticen los
procesos de control y evaluación del alumnado en colegios y escuelas,
mediante nuevas tecnologías acorde al desarrollo del sistema
educativo.
Presentar una aplicación móvil que satisfaga las necesidades de
docentes y directivos de la Escuela Fiscal Mixta “Dr. Alfonso Mora
Bowen”, previa verificación y evaluación del correcto funcionamiento
del aplicativo.
1.4. Alcance
El propósito de esta aplicación móvil para tecnologías Android es satisfacer
las necesidades de docentes de la Escuela Fiscal Mixta “Dr. Alfonso Mora
Bowen”, para registrar información de control y evaluación del alumnado de
manera rápida y sencilla utilizando equipos tecnológicos de última generación.
La aplicación móvil para tecnologías Android permitirá registrar la información
del alumnado de manera rápida y sencilla, gracias a su interfaz atractiva,
4
amigable y funcional, logrando que el usuario se sienta a gusto con la misma
a la hora de navegar.
La aplicación móvil está diseñada para todos los dispositivos móviles que
cuenten mínimo con la versión 4.0 de Android, pero para una mejor
visualización y funcionalidad se recomienda utilizar versiones superiores a la
antes mencionada y con un tamaño mínimo de 4” (pulgadas).
La información requerida del alumnado de la escuela “Dr. Alfonso Mora
Bowen” será generado mediante una réplica, ya que la base de datos de los
alumnos se encuentra almacenada en la base de datos del Ministerio de
Educación, y para el funcionamiento de la aplicación se generará solo
información necesaria.
La aplicación a desarrollarse no estará en la tienda de Google Play para su
publicación, ya que está diseñada específicamente para docentes de la
escuela fiscal mixta “Dr. Alfonso Mora Bowen”.
El ambiente de desarrollo integrado se compondrá con las siguientes
herramientas:
Android SDK, que cuenta con un conjunto de librerías (API1)
necesarias para la construcción, testeo y depuración de aplicaciones
Android.
Android Studio, es un entorno de desarrollo integrado (IDE2) para la
plataforma Android.
JDK (Java Development Kit), necesario para el funcionamiento de
Android Studio, que se utiliza como entorno de desarrollo para compilar
y ejecutar aplicaciones.
1 API Interfaz de Programación de Aplicaciones
2 IDE ambiente de desarrollo integrado
5
JSON, formato ligero para el intercambio de datos que no requiere el
uso de XML3 y que será utilizado para devolver el contenido de las
peticiones al motor de disponibilidad.
MySQL, es un sistema de gestión de base de datos. Es decir, una base
es una colección estructurada de datos y el usuario necesita un
administrador para poder agregar, acceder o procesar esta información
guardada en el ordenador y se puede usar de forma gratuita.
PHP, permite la conexión a todo tipo de servidores de base de datos,
específicamente nos permitirá conectar con MySQL para el desarrollo
de la aplicación, y la ventaja es que totalmente gratis.
1.5. Limitaciones
El desarrollo de la aplicación está proyectada para el uso de docentes de la
Escuela Fiscal Mixta “Dr. Alfonso Mora Bowen”, ya que de aquí se recopilará
información necesaria para el correcto avance de la misma, con información
necesaria.
El contenido del estudiante al cual se accede es limitado, es decir no
tendremos todos los datos disponibles, puesto que la base de datos del
alumnado de la escuela está alojado en el Ministerio de Educación, y el
aplicativo solo será para dispositivos móviles con sistema operativo Android y
con conexión a internet.
La selección tanto del protocolo de interconexión como el lenguaje empleado
para la elaboración de la base de datos, se reservó al criterio del autor del
proyecto, la base de datos sólo contempla una carga básica de datos (nombre,
cédula, fecha-hora, notas).
La aplicación solo permitirá realizar operaciones básicas como la suma, resta
multiplicación y división, y se podrá visualizar los registros de notas y
asistencias de los alumnos de la escuela “Dr. Alfonso Mora Bowen”.
3 XML Lenguaje de Etiquetado Extensible
6
1.6. Justificación
Debido a que la Escuela Fiscal Mixta “Dr. Alfonso Mora Bowen” carece de
desarrollo informático que esté a la par con el crecimiento tecnológico, es una
necesidad contar con un aplicativo que facilite el mejoramiento de las
actividades académicas dentro de la institución, convirtiéndose en una
herramienta tecnológica que brinde seguridad de la información almacenada
y mejore notablemente los procesos de registro de asistencias y notas.
La aplicación contribuirá con el personal docente de la Escuela Fiscal Mixta
“Dr. Alfonso Mora Bowen”, brindándole herramientas que ayuden en su labor
docente, que se convierte en una alternativa acorde con los avances
tecnológicos, para el cumplimiento de los procesos a cargo del personal
docente, siendo una opción para cambiar del sistema de registro manual de
información a un sistema automatizado.
7
CAPITULO 2
2. MARCO TEÓRICO
El Objetivo de este capítulo es abordar los conceptos relacionados con los
procesos y tecnologías que se utilizaron con el fin de cumplir los objetivos
propuestos en este documento.
A continuación se presenta detalladamente los fundamentos teóricos más
importantes requeridos para la elaboración del proyecto, considerando que se
tuvieron muy en cuenta para el diseño del modelo de la aplicación, tales como
los dispositivos móviles, sistemas operativos móviles, sistema operativo
Android, plataforma Android, plataforma de desarrollo y diseño gráfico.
2.1. Antecedentes
La iniciativa de este proyecto surge por la necesidad tecnológica en la Escuela
Fiscal Mixta “Dr. Alfonso Mora Bowen”, teniendo en cuenta que los
dispositivos móviles se constituyen en una realidad que ofrece al usuario
funciones de comunicación y procesamiento de datos, en un reducido tamaño
y que va más allá de las llamadas y mensajes telefónicos.
El desarrollo de aplicaciones para dispositivos móviles, en los últimos años ha
ido en auge de acuerdo a las necesidades de los usuarios, por ende ha dejado
de ser un lujo y se ha convertido en una necesidad.
Existe variedad de plataformas que permiten el desarrollo de aplicaciones
móviles, las mismas que cuentan con herramientas que facilitan dicho
desarrollo, tanto propietarias como open source (software libre).
Al relacionar el desarrollo tecnológico en aplicaciones móviles con la
necesidad de automatizar procesos educativos, el propósito de este proyecto
es introducir nuevas formas de agilitar el proceso de registro de información
estudiantil por parte del docente, mediante el mejor aprovechamiento de
dichos dispositivos.
8
2.2. Bases Teóricas
2.2.1. Dispositivo Móvil
Los dispositivos móviles son aparatos de tamaño pequeño que cuenta con las
siguientes características:
Figura 1. Características de los dispositivos móviles4
Una característica importante de los dispositivos móviles es la movilidad, ya
que son suficientemente pequeños para ser transportados y pueden ser
utilizados durante su transporte, también se lo conoce como computadoras de
mano.
2.2.2. Sistema Operativo Móvil
Desde principios del siglo XXI, los avances tecnológicos han ido en auge en
poco tiempo, un ejemplo claro es la telefonía móvil, que se volvió cada vez
más popular y su innovación tecnológica ha permitido convertirse en
4 http://es.slideshare.net/vanesarasti/taller-33223506 (05/02/2015)
9
pequeñas computadoras de bolsillo, algunas pueden conectarse a internet y
permiten a los usuarios realizar distintos tipos de actividades.
El sistema operativo destinado a correr en un dispositivo móvil necesita ser
fiable y debe tener gran estabilidad, además, ha de adaptarse adecuadamente
a las limitaciones de memoria y procesamiento de datos, proporcionando una
ejecución rápida y exacta al usuario.
Para incorporarse definitivamente en la línea de producción, estos sistemas
deben estar debidamente probados y libres de errores, ya que en un
dispositivo móvil, la necesidad de realizar actualizaciones y reinstalar mejores
versiones del sistema para cubrir fallos o deficiencias son limitadas.
El consumo de energía es un tema muy delicado, porque estos aparatos
deben estar funcionando ininterrumpidamente durante semanas e incluso
meses antes de ser apagado o reiniciado, por eso es importante que el
sistema operativo haga uso de lo más racional y provechoso de la batería, ya
que es limitada.
Estos y otros aspectos de los dispositivos móviles, han de ser tomados muy
en cuenta al momento de desarrollar un sistema operativo competente en el
mercado, y sea atractivo para los fabricantes y les permita a los usuarios sacar
el mejor provecho.
Un sistema operativo móvil o SO móvil es aquel que nos permite controlar un
dispositivo móvil de manera simple y está orientado a la conectividad
inalámbrica, a los formatos multimedia para móviles y a las diferentes maneras
de introducir información en ellos.
Mercado
Las empresas desarrolladoras de teléfonos móviles utilizan distintos tipos de
sistemas operativos, que, en el fondo cumplen las mismas funciones, pero
poseen importantes diferencias. Y a medida que los dispositivos móviles
crecen en popularidad, los sistemas operativos con los que funcionan
adquieren mayor importancia.
10
De acuerdo con los más recientes resultados de ventas y cuota de mercado
de Strategy Analytics nos presenta un informe para el segundo trimestre del
2014, ver en la figura siguiente.
Figura 2. Cuota de mercado Sistemas Operativos Móviles5
Características de los tres sistemas operativos móviles más utilizados
Android
El sistema operativo número uno en cuanto a popularidad. Con una cuota de
mercado cercana al 85%, el sistema operativo de Google se caracteriza por
ser abierto y disponible para cualquier fabricante interesando en utilizarlo para
sus dispositivos móviles.
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, tabletas, Google TV y otros dispositivos. Es
desarrollado por la Open Handset Alliance6, la cual es liderada por Google.
5 http://www.xataka.com/moviles/android-domino-el-segundo-trimestre-con-el-85-de-la-cuota-segun-strategy-analytics.
6 Open Handset Alliance es un grupo de 84 empresas de tecnología
11
Sin duda su evolución y apoyo de la comunidad, ha llevado a consolidarse en
el mercado. Al ser un sistema abierto puede ser implementado por cualquier
dispositivo que lo soporte.
Una penetración de mercado tan grande, ha propiciado por otro lado, que
aunque en un primer momento iOS fuera el más popular de los SO para los
desarrolladores, cada vez más, estos dedican grandes esfuerzos a diseñar
sus aplicaciones para los usuarios de Android.
iOS
Es un sistema operativo móvil de Apple. Originalmente desarrollado para el
iPhone, siendo después usado en dispositivos como iPod Touch, iPad y el
Apple TV. Este sistema operativo móvil está basado en el concepto de
manipulación directa. Es decir, que el usuario puede interactuar directamente
con la pantalla del dispositivo por medio de gestos como toques, pellizcos y
deslices.
Este sistema operativo está orientado específicamente para su uso mediante
dispositivos móviles con pantalla Táctil. iOS es una variante del Mac OS
X, que es el sistema operativo para computadoras de la marca Apple y, al
igual que él, está basado en Unix.
El sistema Unix es el utilizado en publicaciones de Linux, así que iOS, OS
X y Linux, guardan más similitudes de las que nos podemos imaginar, tan solo
que los dos primeros son sistemas operativos propiedad de Apple y cerrados
al uso en dispositivos de la propia compañía, mientras que Linux es un código
abierto y valido para multitud de dispositivos, abierto a implementaciones y al
uso e inclusión en los dispositivos y marcas que lo consideren.
Windows Phone
Anteriormente llamado Windows Mobile es un SO móvil compacto
desarrollado por Microsoft, se basa en el núcleo del sistema operativo
Windows CE y cuenta con un conjunto de aplicaciones básicas. Está diseñado
para su uso en teléfonos inteligentes, con una interfaz similar a las versiones
de escritorio de Windows estéticamente.
12
Este sistema está dirigido principalmente al mercado de usuarios de consumo
en lugar del mercado empresarial como el viejo Windows Mobile. Windows
Phone fue lanzado directamente usando el número 7 como versión. Luego se
lanzó una nueva línea de sistemas operativos llamados Windows Phone 8
para soportar móviles más poderosos.
2.3. Plataforma Android
2.3.1. Un poco de Historia
Hace algunos años, Google decidió que debía expandir su negocio hacia los
móviles, así que su mejor estrategia fue crear un sistema operativo móvil
propio, gratis y con varios de los más grandes fabricantes de celulares como
respaldo, de esta manera nace Android.
Android constituye un stack de software desarrollada especialmente para
dispositivos móviles, que incluye un sistema operativo, un middleware y
conjunto de aplicaciones bases. Es la primera plataforma móvil de código
abierto que está basada en el Kernel de Linux, y aunque los componentes del
SO se escriban en C o C++ las aplicaciones para Android se desarrollan con
una interfaz de programación Java, diseñado para ser utilizado en dispositivos
móviles (Smartphone, Tablets, Google TV y otros), desarrollado por Open
Handset Alliance que es capitaneado por Google.
Los desarrolladores pueden crear aplicaciones para la plataforma usando el
SDK de Android y son ejecutadas en una máquina virtual especialmente
diseñada para esta plataforma y que se le conoce con el nombre de Dalvik
para las versiones anteriores al 4.4 KitKat, y para las nuevas versiones de
Android incluyen una nueva máquina virtual llamado ART.
La licencia de distribución optada por Android ha sido Apache 2.0, que le
convierte en un software de distribución gratuita y también un SDK
incorporado en el nuevo IDE de desarrollo Android Studio, que posee todas
las APIs necesarias para la creación de aplicaciones.
Con Android se busca reunir en una misma plataforma todos los elementos
necesarios que permitan al desarrollador controlar y aprovechar al máximo
13
todas las funcionalidades ofrecidas por los dispositivos móviles, tanto en
hardware como en software.
2.3.2. Evolución de Android
Muchos usuarios creen que Android es un sistema operativo relativamente
nuevo en comparación con otros sistemas operativos, sin embargo este tiene
una historia mucho más grande de la todos podemos imaginar, pues su
existencia data del año 2005 cuando aún era propiedad de Android Inc.7
Su desarrollador y hasta hace poco ex vicepresidente de Android, había
pasado ya por Apple y Microsoft cuando Google compro su empresa en
Agosto del 2005, fecha en la cual Android Inc. ya contaba con 22 meses de
vida.
Desde esta fecha comienza toda una época de ocultismo que dio pie al
surgimiento de grandes rumores y mitos en torno a lo que Google se
encontraba preparando en secreto, pero no fue hasta el 5 de Noviembre de
2007 en que el anuncio oficial de Android llego a los medios.
La evolución del sistema operativo ha sido notable y vamos a hacer un breve
repaso de la misma destacando las novedades principales de cada nueva
versión.
7 Android Inc. Fue una compañía de software.
14
Figura 3. Evolución de Android8
Android 4.4: KitKat
La penúltima versión del sistema operativo de Google optimizada para
dispositivos con 512 MB de memoria RAM, mejora su rendimiento para que
funcione en los dispositivos de menos prestaciones, añade importantes
funcionalidades tanto para el usuario como para los desarrolladores.
Android 4.4 se integra aún más con la nube. Permite que las aplicaciones
puedan acceder fácilmente a los archivos que tenemos guardado en la nube
de cualquier servicio, para lograr una mejor integración. Podremos acceder
nuestras carpetas y archivos de Google Drive, Dropbox y Box, con la misma
facilidad que en las carpetas y archivos que tenemos en la memoria.
El WebView ahora está basado en Chromium, proporcionando un amplio
soporte para HTML5, CSS3 y JavaScript (V8), y algunas más sobre pequeñas
mejoras internas y destinadas para los desarrolladores con nuevas APIs.
Otras novedades son más información sobre las notificaciones entrantes,
mejores animaciones, mejoras en la gestión de música para consumir menos
batería y muchas más mejoras.
8 http://repositorio.utn.edu.ec/bitstream/123456789/2614/1/04%20ISC%20284%20TESIS.pdf (25/02/2015)
15
Figura 4. Android 4.4: KitKat9
Android 5.0: LolliPop
La nueva versión del sistema operativo de Google, posee una nueva interfaz
estilo Material Design, cambiando completamente el sistema de
notificaciones, la multitarea también ha sido renovada ahora con un sistema
de ventanas flotantes en carrusel, y añade nuevos soportes para animaciones,
nuevos temas y posibilidades de personalización.
Una de las áreas en las que Google ha puesto mucho énfasis es Chrome, en
concreto en la mejora de las opciones de animación y diseño de las páginas
web móviles. La multitarea también se renueva, y ahora se llama "recientes".
Las aplicaciones abiertas y las pestañas del navegador tienen ahora el mismo
diseño en multitarea, en forma de tarjeta, por lo que es mucho más sencillo e
intuitivo cambiar de actividad en el carrusel de apps y pestañas de Chrome.
Android LolliPop también trae mejoras en rendimiento y sí, es compatible con
procesadores de 64-bit. Esto significa que, entre otras cosas, las capacidades
gráficas suben un peldaño.
9 http://ibnlive.in.com/news/top-10-new-features-in-android-44-kitkat/431666-11.html (25/02/2015)
16
Figura 5. Android 5.0: LolliPop10
2.3.3. Arquitectura
Como ya se ha mencionado, Android es una plataforma para dispositivos
móviles que contiene una pila de software donde se incluye un sistema
operativo, middleware y aplicaciones básicas para el usuario.
La arquitectura interna de la plataforma Android, está básicamente formada
por 5 capas: las Aplicaciones y Widgets, la del Framework de Aplicaciones,
las Librerías, el Runtime de Android y el Kernel de Linux.
10 http://es.gizmodo.com/hoy-llega-android-5-0-lollipop-todo-lo-que-necesitas-s-1653955590 (25/02/2015)
17
Figura 6. Arquitectura de Android11
A continuación se muestra cada detalle de la arquitectura empleada por
Android, comenzando con la superior, y descendiendo hasta el Kernel.
El núcleo Linux
El Kernel (Núcleo) es la parte fundamental del sistema operativo y es el que
se encarga de dar acceso del hardware a los programas. Digamos que es el
encargado de recoger y gestionar las ordenes que le llegan de las aplicaciones
y mandárselas al hardware para después recoger las respuestas y devolverlas
a las aplicaciones, en otras palabras el Kernel del equipo es un conjunto de
programas que logran conectar el hardware del equipo con el software.
Android utiliza el núcleo de Linux 2.6.36 por ser robusto, y sus funciones se
simplifican en:
Administración de la memoria, para todos los programas en ejecución.
Administración del tiempo de procesador, que estos programas en
ejecución utilizan.
11 http://blog.jorgeluis.com.mx/CMobile/#/41 (25/02/2015)
18
Acceder a los periféricos y hardware de entrada y salida de una forma
práctica y cómoda.
Runtime de Android
Junto a las librerías base que proporcionan la mayor parte de las funciones
del lenguaje Java, encontramos lo necesario para la ejecución de las
aplicaciones a través de la máquina virtual Dalvik y para versiones más
resientes de Android la máquina virtual ART, dado que los dispositivos tiene
una limitaciones que no son posibles utilizar una máquina virtual Java
estándar.
Algunas características de la máquina virtual Dalvik que facilitan esta
optimización de recursos son: que ejecuta ficheros Dalvik ejecutables (.dex),
formato optimizado para ahorrar memoria, encargando al núcleo la gestión de
hilos (multithreading). El bajo consumo de memoria también se debe a que
Dalvik se basa en registros y que cada aplicación se ejecute en una instancia
diferente de la máquina virtual.
A partir de Android 4.4 se reemplaza Dalvik por ART. Esta nueva máquina
virtual consigue reducir el tiempo de ejecución del código Java hasta en un
33% y también se incluye en el Runtime de Android con la mayoría de las
librerías disponibles en el lenguaje Java.
ART es el sucesor de Dalvik Runtime y su principal diferencia es que el
primero elimina la necesidad de una máquina virtual o de interpretar el código
de las aplicaciones lo cual se ve reflejado en mejoras en el desempeño de la
aplicación desde el lanzamiento. Esto lo hace por medio del compilador de
código, el cual es diferente que en Dalvik.
19
Figura 7. Android Runtime12
Librerías
Sobre el Kernel, tenemos un conjunto de librerías de C y C++ utilizadas en
varios componentes Android, muchas de estas librerías son compiladas en
código nativo del procesador y utilizadas para proyectos de código abierto,
algunas de ellas son:
Media Framework: librería basada en PacketVideo's Open CORE;
soporta códec de reproducción y grabación de multitud de formatos
de audio vídeo e imágenes MPEG4, H.264, MP3, AAC, AMR, JPG y
PNG.
Surface Manager: Es la encargada de componer los diferentes
elementos de navegación de pantalla, también gestiona las ventanas
pertenecientes a las distintas aplicaciones activas en cada momento.
Web Kit: soporta un moderno navegador Web utilizado en el
navegador Android y en la vista WebView. Se trata de la misma
librería que utiliza Google Chrome y Safari de Apple.
FreeType: Permite trabajar de forma rápida y sencilla con distintos
tipos de fuentes, sea en bitmap o rende rizado vectorial.
SSL: proporciona servicios de encriptación Secure Socket Layer (capa
de conexión segura).
12 http://jayandroidblogs.blogspot.com/2013/07/dalvik-virtual-machine.html (25/02/2015)
20
Framework de Aplicaciones
La arquitectura está diseñada para simplificar la reutilización de componentes,
que permiten a los desarrolladores tener acceso completo a los APIs del
framework usados por las aplicaciones base, facilitando el desarrollo para no
empezar de cero las aplicaciones.
Los paquetes con más preponderancia son los android.*, en ellos se alojan
todas las características necesarias para construir una aplicación Android.
Las principales API que esta capa contiene y que serán utilizadas para el
desarrollo de la aplicación son las siguientes:
Activity Manager: Conjunto de API que gestiona el ciclo de vida de
las aplicaciones en Android.
Window Manager: Gestiona las ventanas de las aplicaciones y se
encarga de organizar lo que se mostrará en pantalla. Básicamente
crea las superficies en la pantalla que posteriormente pasarán a ser
ocupadas por las actividades.
View System: Proporciona un gran número de elementos para poder
construir interfaces de usuario (GUI), como listas, mosaicos, botones
tamaño de ventanas, control de las interfaces mediante teclado, etc.
Location Manager: Posibilita a las aplicaciones la obtención de
información de localización y posicionamiento.
Notification Manager: Permite a todas las aplicaciones mostrar
alertas en la barra de estado de Android, lo cual usan un mismo
formato, el cual, comunican al usuario eventos que ocurran durante su
ejecución: una llamada entrante, un mensaje recibido, conexión Wi-Fi
disponible, ubicación en un punto determinado, etc.
Resource Manager: Con esta librería podremos gestionar todos los
elementos que forman parte de la aplicación y que están fuera del
código, es decir, cadenas de texto traducidas a diferentes idiomas,
imágenes, sonidos o layouts.
21
Aplicaciones
Este nivel contiene aplicaciones, tanto las incluidas por defecto de Android
como aquellas que el usuario vaya añadiendo, ya sean de terceras
empresas o de su propio desarrollo. Todas estas aplicaciones utilizan los
servicios, las API y librerías de los niveles anteriores.
Las aplicaciones son procesos Linux que se ejecutan sobre la máquina
virtual y se le asigna un ID de usuario único. Estas aplicaciones están
escritas en el lenguaje de programación Java y sus archivos ejecutables
tienen la extensión .apk.
2.3.4. La Máquina Virtual Dalvik
Dalvik es distribuida como software libre (bajo licencia Apache 2.0) fue
diseñada por Dan Bornstein junto con otros diseñadores de Google
específicamente para el sistema operativo móviles Android, está optimizada
para tener bajos requerimientos de memoria y permitir múltiples instancias
de la VM (Virtual Machine) funcionando de manera simultánea, dejando para
el sistema operativo subyacente tareas como la gestión de la memoria y la
gestión de procesos e hilos. Dalvik utiliza un bytecode muy similar pero no
igual que el Java Byte Code por lo que en la práctica no son compatibles,
por lo que es necesario que las clases (.class) sean transformadas por una
utilidad llamada dx (incluida en el Android SDK) que las transforma en el
bytecode de Dalvik en clases .dex, las cuales finalmente son comprimidas en
ficheros .apk que son los que conforman los paquetes de Android.
La creación de esta máquina virtual por parte de google para su sistema
operativo Android ha permitido tener una VM muy bien adaptada a las
características de los dispositivos móviles con sus limitaciones de memoria ,
procesamiento y batería y ha permitido a Google mantener un cierto grado
de independencia respecto a otras tecnologías como Java y su máquina
virtual JVM13.
13 JVM Java Virtual Machine – Máquina Virtual Java
22
2.3.5. La Máquina Virtual ART
Para el desarrollo de la aplicación utilizaremos la nueva máquina virtual
llamado ART (Android Runtime) que trabaja en modo AOD (Ahead Of Time),
lo que significa que hace una pre-compilación en el momento de instalar la
aplicación, por lo que a la hora de ejecutarla, se ahorra ese trabajo de tener
que ejecutar e interpretar.
El uso de ART puede hacer que las aplicaciones tarden un poco más en
instalarse, pero una vez hecho, se ejecutarán mucho más rápido, casi como
si fueran nativas y estuvieran embebidas en el código. Esto se traduce en una
mejora importante de la multitarea y en un significativo ahorro de batería.
2.3.6. Herramientas de Desarrollo
El desarrollo de aplicaciones para Android se he convertido una pieza clave,
debido a la cantidad de Smartphones y Tablets que hay con este sistema
operativo. Sin embargo desarrollar aplicaciones para Android no es tan fácil si
no contamos con una base clara y para eso contamos con una herramienta
muy útil, Android Studio proporciona herramientas que permite el desarrollo
de una manera muy amigable con una interfaz rediseñada si lo comparamos
con eclipse.
Android Studio
Android Studio es un entorno de desarrollo integrado (IDE), basado en IntelliJ
IDEA14 de la compañía JetBrains15, que proporciona varias mejoras con
respecto al plugin ADT (Android Developer Tools) para Eclipse. Android
Studio utiliza una licencia de software libre Apache 2.0, está programado en
Java y es multiplataforma.
14 IntelliJ IDEA es una ambiente de desarrollo integrado para el desarrollo de programas informáticos.
15 JetBrains (antes IntelliJ ) es una empresa de desarrollo de software
23
Características
Herramientas Lint (detecta código no compatible entre arquitecturas
diferentes o código confuso que no es capaz de controlar el compilador)
para detectar problemas de rendimiento, usabilidad y compatibilidad de
versiones.
Utiliza ProGuard para optimizar y reducir el código del proyecto al
exportar a APK (muy útil para dispositivos de gama baja con
limitaciones de memoria interna).
Integración de la herramienta Gradle16 encargada de gestionar y
automatizar la construcción de proyectos, como pueden ser las tareas
de testing, compilación o empaquetado.
Nuevo diseño del editor con soporte para la edición de temas.
Nueva interfaz específica para el desarrollo en Android.
Permite la importación de proyectos realizados en el entorno Eclipse,
que a diferencia de Android Studio (Gradle) utiliza ANT.
Alertas en tiempo real de errores sintácticos, compatibilidad o
rendimiento antes de compilar la aplicación.
Vista previa en diferentes dispositivos y resoluciones.
Integración con Google Cloud Platform, para el acceso a los
diferentes servicios que proporciona Google en la nube.
Editor de diseño que muestra una vista previa de los cambios
realizados directamente en el archivo xml.
SDK de Android
SDK son las siglas de Software Development Kit, lo que traduciéndolo sería
un Kit de Desarrollo de Software, con él podremos desarrollar aplicaciones y
16 Gradle es una automatización de compilación
24
ejecutar un emulador del sistema Android de la versión que sea. Todas las
aplicaciones Android se desarrollan en lenguaje Java con este kit.
Descarga e instalación de Java
Para poder descargar el JDK (Java Development Kit) no dirigimos a la web de
Oracle y escogemos la versión adecuada para nuestro sistema operativo, en
este caso será Windows 64 bits cuyo nombre del fichero es “jdk-8u45-
windows-x64.exe“
Figura 8. Sitio de descargar de JDK17
La instalación no tiene ninguna dificultad, ya que se trata de un instalador
estándar de Windows donde tan sólo hay que aceptar, pantalla por pantalla,
las opciones que ofrece por defecto.
Descarga e instalación de Android Studio y el SDK de Android
Para descargar Android Studio accederemos a la web de desarrolladores
de Android, y nos dirigiremos a la sección dedicada al SDK de la
plataforma. Descargaremos el instalador correspondiente a nuestro sistema
operativo pulsando el botón verde “Download Android Studio” y aceptando en
la pantalla siguiente los términos de la licencia.
17 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
25
Figura 9. Ilustración de la página de descarga de Android Studio18
Para instalar la aplicación ejecutamos el instalador descargado y seguimos el
asistente aceptando todas las opciones seleccionadas por defecto. Durante el
proceso se instalará el SDK de Android, los componentes adicionales para el
desarrollo sobre Android 5.0, un dispositivo virtual pre configurado para dicha
versión de Android, y por supuesto el entorno de desarrollo Android Studio.
Figura 10. Componentes que se instalaran19
Como puede verse en la imagen anterior, también se instalará y configurará
durante la instalación (si tu PC es compatible) el llamado Intel Hardware
Accelerated Execution Manager (o “HAXM”), que nos ayudará a mejorar el
rendimiento del emulador de Android.
18 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
19 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
26
Figura 11. Configuración del Intel Hardware Accelerated Execution Manager20
Durante la instalación tendremos que indicar también las rutas donde
queremos instalar tanto Android Studio como el SDK de Android.
Figura 12. Rutas para guardar el SDK de Android21
Una vez finalizada la instalación se iniciará automáticamente Android Studio.
Es posible que nos aparezca en este momento un cuadro de diálogo
consultando si queremos reutilizar la configuración de alguna versión anterior
del entorno. Para realizar una instalación limpia seleccionaremos la opción “I
do not have a previous version…“.
20 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
21 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
27
Figura 13. Confirmación de versiones anteriores22
Durante la primera ejecución aparecerá el asistente de inicio que se encarga
de descargar e instalar/actualizar algunos componentes importantes del SDK
de Android (si existieran).
Figura 14. Ilustración de la descarga de Componentes23
2.3.7. Componentes en una aplicación Android
Todas las aplicaciones en Android pueden descomponerse en bloques o
componentes principales. Cada aplicación será una combinación de uno o
más de estos componentes, que deberán ser declarados de forma explícita
en un fichero con formato XML denominado “AndroidManifest.xml”, junto a
22 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
23 http://www.sgoliver.net/blog/entorno-de-desarrollo-android-android-studio/ (10/03/2015)
28
otros datos asociados como valores globales, clases que implementa, datos
que puede manejar, permisos, etc.
Este fichero es básico en cualquier aplicación en Android y permite al sistema
desplegar y ejecutar correctamente la aplicación. A continuación se exponen
los tipos de componentes en los que puede dividirse una aplicación para
Android.
Activity
Es el componente principal de la interfaz gráfica y sirve para crear las distintas
pantallas de la aplicación. Cada pantalla estaría representada por su
Actividad, que está conformada por dos archivos, un archivo XML (parte
gráfica) y un archivo .Java (la parte lógica) de nuestra ventana.
Cada actividad tiene asociada una vista o view. La vista constituye el conjunto
de elementos gráficos que se presentan al usuario para que interaccione con
el sistema.
Intent
Una intención o intent es un componente básico de Android que permite el
envío de mensajes entre componentes, también se pueden entender como
los mensajes o peticiones que son enviados entre los distintos componentes
de una aplicación o entre distintas aplicaciones.
Mediante un intent se puede mostrar una actividad desde cualquier otra, iniciar
un servicio, enviar un mensaje broadcast, iniciar otra aplicación, etc.".
Una intención representa la voluntad de realizar alguna acción o tarea, como
realizar una llamada de teléfono o visualizar una página web. Una intención
nos permite lanzar una actividad o servicio de nuestra aplicación o de una
aplicación diferente.
Widget
Un widget (o control) es un elemento de una interfaz (interfaz gráfica de
usuario o GUI) que muestra información con la cual el usuario puede
29
interactuar, o permiten mostrar al usuario una información (o una especie de
interfaz reducida) sin necesidad de abrir una aplicación.
Layout
Un layout es un objeto no visual que representa el espacio contenedor de
todas las vistas (Views) dentro de la actividad. En él se define la estructura y
el orden de los elementos para que el usuario pueda interactuar con la interfaz.
Processes and Threads
Cuando una aplicación se inicia crea un proceso y todo lo que se ejecuta
dentro de esa aplicación es parte del mismo proceso de ejecución. Un hilo es
otra forma de dividir el trabajo, un proceso puede tener varios hilos de
ejecución, el hilo lo podemos tomar como una secuencia de control dentro de
cualquier proceso y este ejecuta lo que indiquemos de manera independiente.
2.3.8. Ciclo de vida de las aplicaciones Android
En Android, cada aplicación se ejecuta en su propio proceso, esto aporta
beneficios en cuestiones básicas como seguridad, gestión de memoria, o la
ocupación de la CPU del dispositivo móvil. Android se ocupa de lanzar y parar
todos estos procesos, gestionar su ejecución y decidir qué hacer en función
de los recursos disponibles y de las órdenes dadas por el usuario.
El usuario desconoce este comportamiento de Android, simplemente es
consciente de que mediante un simple clic pasa de una a otra aplicación y
puede volver a cualquiera de ellas en el momento que lo desee.
No debe preocuparse sobre cuál es la aplicación que realmente está activa,
cuánta memoria está consumiendo, ni si existen o no recursos suficientes para
abrir una aplicación adicional.
Android lanza tantos procesos como permitan los recursos del dispositivo.
Cada proceso, correspondiente a una aplicación, estará formado por una o
varias actividades independientes (componentes Activity) de esa aplicación.
30
Cuando el usuario navega de una actividad a otra, o abre una nueva
aplicación, el sistema duerme dicho proceso y realiza una copia de su estado
para poder recuperarlo más tarde. El proceso y la actividad siguen existiendo
en el sistema, pero están dormidos y su estado ha sido guardado.
Cada uno de los componentes básicos de Android tiene un ciclo de vida bien
definido; esto implica que el desarrollador puede controlar en cada momento
en qué estado se encuentra dicho componente, pudiendo así programar las
acciones que mejor convengan.
El componente Activity, probablemente el más importante, tiene un ciclo de
vida como se observa en la Figura.
Figura 15. Diagrama de flujo del ciclo de vida de una Actividad en Android24
onCreate():
Se dispara cuando el Activity es llamado por primera vez, es aquí donde
debemos crear la inicialización normal de la aplicación. Este método te
24 http://jarroba.com/activity-entender-y-usar-una-actividad/ (10/03/2015)
31
da el acceso al estado de la aplicación cuando se cerró, después de
esta llamada siempre se llama al método onStar().
onStar():
Este método se ejecuta cuando el sistema tiene intención de hacer
visible la actividad, aunque luego no llegue a ocurrir.
onRestart():
Se ejecuta cuando la actividad ha sido parada o detenido, quieres
volver a utilizarlo.
onPause():
Se ejecuta cuando el usuario deja de interactuar con la actividad actual,
ya sea porque lo remplazará por la anterior o por la que se superponga.
onResumen():
Este método se ejecuta justo antes de que la actividad sea
completamente visible y el usuario pueda empezar a interactuar con
ella.
onStop():
Se ejecuta cuando la Actividad ya no es visible para el usuario porque
otra Actividad ha pasado a primer plano.
onDestroy():
El sistema ejecuta este método cuando ya no tiene intención de
reutilizar más el objeto que contiene la actividad, porque el sistema está
tratando de liberar memoria o solicita terminar el proceso.
2.4. Plataforma de Desarrollo
Un Sistema Gestor de Base de Datos (SGBD) o DBMA (DataBase
Management System) es una colección de programas que permite servir de
32
interfaz entre la base de datos, el usuario y las aplicaciones, asegurando su
integridad, confidencialidad y seguridad.
La toma de decisión sobre el gestor de base de datos a utilizar para el
desarrollo de la aplicación, se ha visto influenciada por varios motivos:
Las opciones comerciales como Oracle de Oracle Corporation, SQL S
erver de Microsoft o DB2 de IBM fueron descartadas desde un principio
por tratarse de productos cerrados y no gratuitos. Si bien podría no
haber sido determinante, en este caso, teniendo alternativas libres
extendidas y de gran calidad se ha decidido elegir entre las opciones
open source y gratuitas disponibles.
La utilización de este gestor de BBDD viene determinada
principalmente por experiencias en su manipulación, la cantidad de
recursos y documentación en red que existe, y en las que se comprobó
la facilidad de desarrollo y acceso a la base de datos desde el código
Java.
La base de datos creada para este proyecto de fin de carrera, junto con
los servicios Web (web service), no son más que un entorno de
ejemplo, y no pretende ser muy completo, ni manejar una gran cantidad
de usuarios.
Para el desarrollo de la presente Tesis se ha optado por MySQL, como
manejador de base de datos, pues estaba basada en licencia GLP de la
GNU25 y por su diseño multihilo permite soportar una gran cantidad de
información de forma muy eficiente, como servidor web utilizaremos Apache
y como lenguaje para servidor web PHP.
2.4.1. MySQL
Una base de datos es un sistema de información formado por un conjunto de
datos almacenados en discos duros y un programa encargado de manipular
25 GNU Licencia Pública General
33
éste conjunto de datos. Cada base de datos está conformada por una o más
tablas y a su vez cada tabla tiene una o más filas y columnas, en la cuales se
almacena la información de manera organizada.
MySQL es un software Open Source, lo que significa que es posible para
cualquier desarrollador descargar el software y utilizarlo sin costo para
modificar a su conveniencia, y además, existen lenguajes de programación
que permite hacer consultas a la base de datos MySQL, pues es soportada
de manera eficiente y en el caso particular de la desarrollo del presente
proyecto, por PHP.
Características
Aprovecha la potencia de sistemas multiprocesador, gracias a su
implementación multihilo.
Soporta gran cantidad de tipos de datos para las columnas.
Gran portabilidad entre sistemas.
Soporta hasta 32 índices por tabla.
Gestión de usuarios y contraseña, manteniendo un muy buen nivel de
seguridad en los datos.
Condición de open source de MySQL hace que la utilización sea
gratuita y se puede modificar con total libertad.
Es una de las herramientas más utilizadas por los programadores
orientados a Internet.
Infinidad de librerías y otras herramientas que permiten su uso a través
de gran cantidad de lenguajes de programación.
MYSQL, es el manejador de base de datos considerado como el más
rápido de Internet.
Gran rapidez, facilidad de uso y sobre todo la facilidad de instalación y
configuración.
34
Dispone de APIs en gran cantidad de lenguajes (C, C++, Java, PHP,
etc.).
Se puede descargar su código fuente. Esto ha favorecido muy
positivamente en su desarrollo y continuas actualizaciones.
2.4.2. PHP
PHP (acrónimo recursivo de PHP: Hypertext Preprocessor) es un lenguaje de
programación de código abierto interpretado o framework para HTML,
diseñado originalmente para la creación de páginas web dinámicas.
PHP ofrece la integración con las varias bibliotecas externas, que permiten
que el desarrollador haga casi cualquier cosa desde generar documentos en
pdf hasta analizar código XML y su sintaxis es muy similar a la del ASP, pues
el código PHP va incrustado dentro del código HTML.
La razón principal para utilizar un lenguaje de script como PHP, es debido a
la interacción con bases de datos que puede ofrecer. En este proyecto se ha
utilizado PHP para recuperar información de una base de datos MySQL.
Características PHP
Orientado al desarrollo de aplicaciones web dinámicas con acceso a
información almacenada en una base de datos.
Es considerado un lenguaje fácil de aprender, ya que en su desarrollo
se simplificaron distintas especificaciones, como es el caso de la
definición de las variables primitivas, ejemplo que se hace evidente en
el uso de PHP arrays.
Capacidad de conexión con la mayoría de los motores de base de datos
que se utilizan en la actualidad, destaca su conectividad con MySQL y
PostgreSQL22.
Capacidad de expandir su potencial utilizando módulos (llamados ext's
o extensiones).
35
Posee una amplia documentación en su sitio web oficial, entre la cual
se destaca que todas las funciones del sistema están explicadas y
ejemplificadas en un único archivo de ayuda.
Es libre, por lo que se presenta como una alternativa de fácil acceso
para todos.
No requiere definición de tipos de variables aunque sus variables se
pueden evaluar también por el tipo que estén manejando en tiempo de
ejecución.
Tiene manejo de excepciones (desde PHP5).
2.4.3. Json
JSON (JavaScript Object Notation) es un formato sencillo para el intercambio
de información. El formato JSON permite representar estructuras de datos
(arrays) y objetos (arrays asociativos) en forma de texto. La notación de
objetos mediante JSON es una de las características principales de JavaScript
y es un mecanismo definido en los fundamentos básicos del lenguaje.
JSON es un formato alternativo de envío y recepción de datos, es decir
remplaza a XML o el envío de texto plano.
JSON no es un lenguaje de programación. Es una manera de estructurar
datos y de acceder a ellos mediante JavaScript (o JScript).
2.4.4. Apache
Como servidor Web utilizaremos el modulo Apache, el cual es el más popular
y es un servidor de red para el protocolo HTTP (Hyper Text Tranfer Protocol),
elegido para poder funcionar como un proceso independiente, sin que solicite
el apoyo de otras aplicaciones.
Características
Multiplataforma: Corre en una multitud de sistemas Operativos, lo que
lo hace prácticamente universal.
36
Libre: Apache es una tecnología gratuita de código fuente abierta.
Esto le da una transparencia a este software de manera que si
queremos ver que es lo que estamos instalando como servidor lo
podemos saber, sin ningún secreto sin ninguna puerta trasera.
Configurable: Apache es un servidor altamente configurable de diseño
modular. Es muy sencillo ampliar las capacidades del servidor Web
Apache.
Multilenguaje: Apache soporta gran cantidad de lenguajes PERL,
PHP, Java.
Estas y otras características han convertido al servidor Web Apache en el más
utilizado actualmente, avalado por compañías élite como Google y superando
ampliamente a sus similares en lo que a seguridad y agilidad se refiere.
2.5. Diseño Gráfico
No todo el mundo es consciente de la importancia que el diseño posee ante
la sociedad, el diseño tiene la responsabilidad de producir mensajes que
contribuyan positivamente a la sociedad, así mismos la creación de objetos
visuales que ayuden al desarrollo y la posibilidad de identificar problemas con
la capacidad de transformarlos.
El diseño es un proceso de creación visual con un propósito, que cumple una
función muy importante con respecto a la comunicación y que puede afectar
el conocimiento, las actitudes, los afectos y el comportamiento en las
personas.
La interfaz de una aplicación es como la ropa que viste para salir a la calle. Es
también la capa que hay entre el usuario y el corazón funcional de la app, el
lugar donde nacen las interacciones.
Las aplicaciones se plantean a partir de una serie de requisitos funcionales
bastante generales que, desde el diseño se encarga de convertir en una
aplicación funcional y atractiva visualmente.
37
El diseño en Android está basado en una pulcritud26 brillante en la
composición de la interfaz. Cada gráfico, botón y texto está acompañado por
la idea de limpieza visual pero, a la vez, deslumbra con pequeños detalles.
El diseño ayudará a la aplicación tener una oportunidad para extender la
identidad del producto, y que las diferentes pantallas de la app, los colores,
tipografías y fondos actúan como elementos que reflejan esa identidad.
26 Pulcritud e la manera pulcra, limpia y cuidada de hacer una cosa.
38
CAPÍTULO 3
3. Diseño General de la Solución
En este capítulo se detallan los procesos, metodologías, fases, herramientas
y APIs utilizadas en el desarrollo de la aplicación propuesta. Dichos conceptos
abarcan bases teóricas que han facilitado la construcción de la aplicación.
Se toma ciertas consideraciones sobre la metodología elegida que satisfaga
las necesidades planteadas en la etapa de análisis, de forma eficaz y cumplir
con cada uno de los objetivos propuestos para esta aplicación móvil.
3.1. Metodología ágil de desarrollo de software
El desarrollo de aplicaciones está relacionado con el desarrollo de software
tradicional, por lo que debería implementarse un proceso similar para lograr
un trabajo más organizado.
El desarrollo de aplicaciones en general no tiene estandarizado una
metodología para el desarrollo, es por eso que en muchas ocasiones los
costos superan lo planificado, los tiempos de entrega se alargan y los
desarrolladores son acumulados con excesivo trabajo.
Debido a esta situación muchas empresas se han dedicado a plantearse una
metodología que permita un desarrollo adecuado y estandarizado; estas
metodologías no son más que adaptaciones de las ya existentes para el
desarrollo de software tradicional, solo que ajustadas a las especificidades del
proceso de desarrollo de aplicaciones móviles.
Este capítulo trata sobre el desarrollo de una aplicación móvil para el proceso
de control y asistencia de la escuela “Dr. Alfonso Mora Bowen”, para lo cual
el diseño y su desarrollo se lo realizará en base a la metodología Scrum y
considerando las características del sistema operativo Android.
3.1.1. ¿Qué es una Metodología?
“Una metodología es una colección de procedimientos, técnicas, herramientas
y documentos auxiliares que ayudan a los desarrolladores de software en sus
39
esfuerzos por implementar nuevos sistemas de información. Una metodología
está formada por fases, cada una de las cuales se puede dividir en sub-fases,
que guiarán a los desarrolladores de sistemas a elegir las técnicas más
apropiadas en cada momento del proyecto y también a planificarlo,
gestionarlo, controlarlo y evaluarlo.”27
Una metodología está compuesta por:
Identificación del problema.
Definición de la pregunta-problema (que será el eje de toda la
investigación, responde al “qué investigamos”).
Cómo dividir un proyecto en etapas.
Qué tareas se llevan a cabo en cada etapa.
Qué restricciones deben aplicarse.
Qué técnicas y herramientas se emplean.
Cómo se controla y gestiona un proyecto.
3.1.2. Metodología Ágil
Un proceso es ágil cuando el desarrollo de software es incremental (entregas
pequeñas de software, con ciclos rápidos), cooperativo (cliente y
desarrolladores trabajan juntos constantemente con una cercana
comunicación), sencillo (el método en sí mismo es fácil de aprender y
modificar), y adaptable (permite realizar cambios de último momento sin
alterar la planificación).
Esta metodología ofrece oportunidades para evaluar la dirección del proyecto
durante todo el ciclo de vida de desarrollo, esto se logra a través de
27 D. E. Avison y G. Fitzgerald, Information system development. Maidenhead: McGraw-Hill Education, 2006
40
cadencias28 regulares de trabajo, conocidos como los sprints o iteraciones, al
final de las cuales el desarrollador deben presentar un incremento del
producto potencialmente entregable, y tomando en cuenta con los cambios de
última hora que se les pueda dar.
3.1.3. Ventajas de la Metodología Ágil
Las metodologías ágiles presentan diversas ventajas como:
Rápida respuesta a cambios de requisitos a lo largo del desarrollo.
Entrega continua y en plazos cortos de software funcional.
Trabajo conjunto entre el cliente (unidad educativa) y el desarrollador.
Importancia de la simplicidad, al eliminar el trabajo innecesario.
Atención a la excelencia técnica y al buen diseño.
Cada componente del producto final ha sido probado y satisface los
requerimientos.
3.1.4. Beneficios del Método Ágil
Estos son los algunos de los principales beneficios que reportan los casos de
éxito al utilizar metodologías ágiles en el desarrollo de aplicaciones:
Al ser metodologías iterativas e incrementales se obtienen versiones
del producto en intervalos regulares de tiempo, lo cual reduce la
probabilidad de cambios de requerimientos en forma.
Permiten tener una mayor visión y control del avance del proyecto,
tanto al cliente como a los desarrolladores.
28 Cadencia: f. Serie de sonidos, movimientos, acciones que se suceden de un modo regular o armónico o ritmo de un trabajo.
41
3.1.5. Metodología SCRUM
La metodología propuesta para el desarrollo de la aplicación móvil se
fundamenta en la experiencia de investigaciones previas en aplicaciones
móviles, por ende el presente trabajo se describe la metodología ágil SCRUM,
la cual ofrece un conjunto de fases y roles, que nos permite tomar un punto
de partida en el proceso de desarrollo que se ejecutará durante el proyecto.
Scrum es una metodología ágil, y como tal es un modo de desarrollo de
carácter adaptable más que predictivo, basadas en iteraciones y revisiones al
gestionar el desarrollo de software.
Para el cumplimiento de las metas propuestas, es importante adquirir una
clara noción del ámbito al cual se hace referencia, y determinar el conjunto de
técnicas, procedimientos y herramientas para lograr culminar con un sistema
que genere procesos automatizados de información en el régimen educativo
de alta calidad.
Con la metodología Scrum la escuela “Dr. Alfonso Mora Bowen” se
compromete con el proyecto, ya que se nota un avance iteración tras iteración.
Así mismo, le permite en cualquier momento realinear la aplicación con los
objetivos dependiendo la visión y misión de la escuela, ya que puede introducir
cambios funcionales o de prioridad en el inicio de cada nueva iteración sin
ningún problema.
Scrum incrementa significativamente la productividad y reduce el tiempo de
espera para ver la calidad en la aplicación, y una pieza fundamental para
lograr el éxito es la comunicación, pues permite el intercambio de información
entre todos los miembros involucrados en el desarrollo de la aplicación, y así
evitar posibles inconvenientes, dando una solución adecuada.
Independientemente del tipo de metodología que se utilice, cualquier
desarrollo siempre parte de un mismo problema: conocer las necesidades de
los clientes.
Proceso
42
Figura 16. Estructura del desarrollo aplicando SCRUM29
En primer lugar se define el Product Backlog, lo que nos permitirá realizar
nuestros Sprints más adelante.
Product Backlog (Pila del Producto): Es una “wish list” sobre las
funcionalidades del producto. Es elaborado por el Product Owner y las
funciones están priorizadas según lo que es más y menos importante
para el negocio.
Sprint Backlog (Pila del Sprint): Es un subconjunto de ítems del
Product Backlog, que son seleccionados por el equipo para realizar
durante el Sprint sobre el que se va a trabajar. El equipo establece la
duración de cada Sprint.
Sprint Planning Meeting (Planificación del Sprint): Esta reunión se
hace al comienzo de cada Sprint y se define cómo se va a enfocar el
proyecto que viene del Product Backlog las etapas y los plazos. Cada
Sprint está compuesto por diferentes features. Por ejemplo, decidimos
que los features del primer Sprint son: diseño del logo, definición
colores y contenido multimedia.
29 http://www.palentino.es/blog/resumen-de-la-metodologia-scrum-para-el-desarrollo-del-software-historia-caracteristicas-roles (25/03/2015)
43
Daily Scrum o Stand-up Meeting (Reunión Diaria): Es una reunión
breve que se realiza a diario mientras dura el periodo de Sprint. El
Scrum Master debe tratar de solucionar los problemas u obstáculos que
se presenten.
Sprint Review (Revisión del Sprint): Se revisa el sprint terminado, y
ya debería haber un avance claro y tangible para presentárselo al
cliente.
Sprint Retrospective: El equipo revisa los objetivos cumplidos del
Sprint terminado. Se anota lo bueno y lo malo, para no volver a repetir
los errores. Esta etapa sirve para implementar mejoras desde el punto
de vista del proceso del desarrollo.
Figura 17. Proceso Metodología Ágil Scrum30
Los roles principales de la metodología Scrum son:
Scrum master (Director de proyecto): Persona que lidera al equipo
guiándolo para que cumpla las reglas y procesos de la metodología es
30 http://www.i2btech.com/blog-i2b/tech-deployment/para-que-sirve-el-scrum-en-la-metogologia-agil/ (25/03/2015)
44
decir, el encargado de fomentar e instruir sobre los principios ágiles de
Scrum.
Product owner (PO): Es quien representa al cliente, usuarios del
software y todas aquellas partes interesadas en el producto, es decir,
es el encargado de recoger las opiniones y sugerencias de todos los
involucrados en el desarrollo y decidir si las aplica a la definición del
proyecto (Product Backlog) y crear una lista de objetivos.
Team: Grupo de profesionales con los conocimientos técnicos
necesarios y que desarrollan el proyecto de manera conjunta llevando
a cabo las historias a las que se comprometen al inicio de cada sprint.
Debido a que el equipo de desarrollo va a ser de una sola persona los roles
mencionados en Scrum se los modificará para ser desarrollados por una sola
persona como parte del equipo.
Características
Scrum es un marco de trabajo ágil que se basa en la iteración y entrega de
incrementales de desarrollo de un producto o servicio. Posee las siguientes
características:
Puede ser aplicado teóricamente a cualquier contexto en donde un
grupo de gente necesita trabajar junta para lograr una meta común.
Su prioridad es la satisfacción del cliente, que se da con la continua
interacción entre éste y el equipo de desarrolladores.
Enfocado a conseguir pequeños incrementos de software
completamente funcionales.
Hace uso de equipos auto-dirigidos y auto-organizados.
Orientado a las personas, más que a los procesos.
Alta flexibilidad.
45
Enfatiza valores y prácticas de gestión, sin pronunciarse sobre
requerimientos, prácticas de desarrollo, implementación y demás
cuestiones técnicas.
Ventajas
Incremento en la productividad.
Mejoras constantes.
El producto total se convierte en una serie de pequeños pedazos
manejables.
Existe un progreso, inclusive si los requerimientos no están bien
definidos.
Se comparte los éxitos desde el principio hasta el final.
El cliente (Institución Educativa) se mantiene informado en cada mejora
del producto.
Entrega de un producto funcional al finalizar cada sprint.
Capacidad para aceptar modificaciones sobre la marcha sin influir en
el desarrollo.
Desventajas
No genera toda la evidencia o documentación de otras metodologías.
Si no se tiene experiencia en seguir procesos de desarrollo, puede ser
caótica su uso.
Si una tarea no está bien definida puede incrementar costes y tiempos.
Solo funciona cuando el Scrum Manager confía en su equipo.
Si no existe una fecha definitiva de finalización del proyecto es posible
que se siga solicitando, y añadiendo, nueva funcionalidad.
Si el equipo no se compromete hay mucha probabilidad de fracasar.
46
Que un miembro abandone el equipo durante el desarrollo puede
conllevar grandes problemas.
Valores
Scrum es una metodología muy simple en su composición, pero necesita una
base firme de valores que sirvan como fundamento para el proceso y los
principios del equipo.
Foco.- Porque nos enfocamos en sólo unas pocas cosas a la vez,
trabajamos bien juntos y producimos un resultado excelente. De este
modo logramos entregar ítems antes.
Coraje.- Porque no estamos solos, nos sentimos apoyados y tenemos
más recursos a nuestra disposición. Esto nos da el coraje para
enfrentar desafíos más grandes.
Apertura.- Durante el trabajo en conjunto expresamos cotidianamente
cómo nos va y qué problemas encontramos. Aprendemos que es bueno
manifestar las preocupaciones, para que éstas puedan ser tomadas en
cuenta.
Compromiso.- Porque tenemos gran control sobre nuestro destino,
nos comprometemos más al éxito. La metodología da a las personas la
autoridad que necesitan para cumplir con sus compromisos.
Respeto.- A medida que trabajamos juntos, compartiendo éxitos y
fracasos, llegamos a respetarnos los unos a los otros, y a ayudarnos
mutuamente a convertirnos en merecedores de respeto.
3.2. Fase Preliminar
En esta fase identificamos las necesidades de crear la aplicación para
dispositivos móviles, qué usuarios intervienen, la plataforma en la que se
desarrollara y el alcance de la aplicación.
47
3.2.1. Planteamiento del problema
Actualmente la escuela fiscal mixta “Dr. Alfonso Mora Bowen“ no posee un
proceso de control y evaluación automatizada, dado que la escuela, realiza
dicho proceso de forma manual, entonces dicho proceso genera una pérdida
de tiempo e información del estudiante no son suficientemente efectivos a la
hora de controlar el desarrollo del estudiante.
El problema de dicha automatización radica en que la base de datos de todos
los estudiantes se encuentran almacenados en el Ministerio de Educación, y
por ende no existen una base interna almacenada en la escuela que permita
la creación de un software y agilite dicho proceso y no genere una pérdida de
recursos humanos, financieros, tiempos e información.
La evolución de las tecnologías de la información y comunicación plantea
nuevos desafíos en la educación, razón por la cual, el empleo de las tics exige
nuevas cambios en los objetivos que puedan lograr, lo que significa desarrollar
en los educandos los conocimientos, hábitos y habilidades que le permitan
agilitar procesos de control y evaluación del estudiante.
3.2.2. Planteamiento de la Solución
Actualmente el avance de la tecnología en los teléfonos móviles nos permite
tener acceso a internet, para poder enviar y recibir información de manera más
rápida en cualquier momento y lugar, pero las tecnologías que existen
actualmente en el mercado no son aprovechadas por la institución educativa
“Dr. Alfonso Mora Bowen“, originando una desventaja competitiva en el ámbito
de aprovechamiento de tecnología, por ende pierde prestigio frente a las
demás instituciones.
Conocido ya el problema a resolver, y sabiendo que la penetración de
mercado de los smartphones es muy alta, se ha decidido optar por utilizar una
plataforma móvil para el desarrollo de una aplicación, que genere procesos de
control y evaluación de manera automatizada para profesores, ya que posee
múltiples herramientas con las que contamos para desarrollar aplicaciones
para estos dispositivos.
48
La solución plateada para los profesores que tenga un dispositivo móvil con
sistema operativo Android, es un sistema que les permitirá procesar el control
de asistencias y evaluaciones de los alumnos, mediante una petición directa
a un servidor web, que se enlazará a su vez a una base de datos y finalmente
obtendrá la información requerida de los estudiantes.
3.2.3. Alcance de la Solución
Para conseguir información del alumnado que existe en la institución
educativa a realizar, se generará una réplica de la base de datos adquirida de
los registros del Ministerio de Educación, y solo obtendremos información
necesaria de los estudiantes y docentes para poder desarrollar la aplicación
móvil.
El sistema brindará soporte a las funciones realizadas por el profesorado
como elaboración del registro de notas y control de asistencia del alumnado.
3.2.4. Restricción
El diseño del aplicativo móvil está proyectado solo para el uso de los
profesores de la institución educativa “Dr. Alfonso Mora Bowen“, con el
objetivo de dinamizar el proceso de control y asistencia de los alumnos.
El dispositivo móvil en donde se ejecutará la aplicación para su correcto
funcionamiento deberá tener los siguientes requisitos mínimos, debido a que
necesitamos velocidad de procesamiento al manejar una gran cantidad de
información y tener una buena interfaz gráfica.
Procesador: 1 GHz Dual Core.
Memoria RAM: un mínimo de 512 Mb aunque he de reconocer que con
1 Gb mejora muchísimo el rendimiento.
Almacenamiento: 30 MB disponibles.
Pantalla de 4” pulgadas en adelante.
Sistema operativo. Android 4.0 o superior.
49
Se ha considerado la versión de Android 4.0 Ice Cream Sándwich o superior
ya que la aplicación será programada con el API 15 como mínima,
correspondiente a esta versión.
Para poder enviar y recibir la información, que posteriormente se grabe en la
base de datos y visualizar en el dispositivo móvil se necesita de una conexión
a Internet ya sea:
Wifi.
Plan de Datos móviles.
Cabe recalcar que todas las restricciones descritas y analizadas
anteriormente es solo una sugerencia para el óptimo funcionamiento de la
aplicación es decir que sea rápida y tenga una buena visualización, y no
quita o restringe que la aplicación pueda funcionar en dispositivos de menor
gama o que tengan las pantallas más pequeñas que la mínima
recomendada.
3.3. Fase de Planeación
Se elaborarán diseños breves que sirven de referencia para la desarrollo. El
principio es utilizar el diseño más sencillo que consiga que todo funcione
evitando diseñar características extra y que tomaran demasiado tiempo y
demore el proceso de desarrollo de la aplicación.
3.3.1. Factibilidad
La propuesta es factible puesto que cuenta con el permiso de las autoridades
de entidad educativa beneficiada, además existen los recursos humanos,
materiales, técnicos y tecnológicos para ejecutarlo, a través de la aplicación
se logrará optimizar el proceso de control y asistencia de los estudiantes de
la escuela fiscal mixta “Dr. Alfonso Mora Bowen”.
Es factible puesto que existe suficiente información científica y bibliográfica
para lograr el diseño y desarrollo de la aplicación móvil. Esta puede ser
realizada y puesta en práctica, porque contamos con el elemento humano y
técnico, la infraestructura física adecuada, los instrumentos necesarios para
50
la puesta en marcha de la propuesta, y la predisposición de prestar toda la
ayuda y colaboración por parte de las autoridades de la institución educativa,
para llevar a cabo la investigación.
Factibilidad Técnica
Permite determinar si la propuesta puede ser implementada con el hardware,
software y recurso humano disponible. Para el desarrollo de la aplicación móvil
propuesta, se cuenta con casi todos los recursos hardware y software
necesarios. A continuación se detalla el hardware, software existente,
requerido así como también el personal técnico requerido para el desarrollo
del mismo.
Hardware Existente
Hardware con el que se cuenta para el desarrollo de la aplicación es:
Cantidad Descripción Observación
1 Laptop
Desarrollo de la aplicación y
Documentación
1 Impresora Imprimir Avances
1 Modem de telefonía
Acceder al internet para consultar las
dudas en el desarrollo de la aplicación
y realizar las pruebas respectivas.
Tabla 1. Hardware existente
Hardware Requerido
Hardware requerido para el desarrollo de la aplicación es el siguiente:
Cantidad Descripción Observación
1 Hosting
Para almacenar la información la base
de datos
51
1 Dispositivo Móvil Probar la aplicación móvil
1 Router inalámbrico Para generar una Wireless
Tabla 2. Hardware Disponible
Software Existente
Las características que debe cumplir el software instalado en una
computadora para soportar el desarrollo y/o ejecutar una aplicación es el
siguiente:
Nombre Descripción
Windows 8.1 Sistema Operativo
Adobe Ilustrador Herramienta de diseño
Android Studio IDE de desarrollo móvil
PHP Lenguaje de programación
Hostinger
Servidor independiente de
distribución gratuita
MySQL Motor de base de datos
Tabla 3. Software existente
Recurso Humano Requerido
El Recurso Humano requerido para el desarrollo de la aplicación es el
siguiente:
Función Formación
52
Equipo de desarrolladores
Estudiante de Ingeniería en
Computación Gráfica
Diseñador
Estudiante de Ingeniería en
Computación Gráfica
Tabla 4. Recurso humano requerido
Recurso Humano
El recurso humano que participará en la operación del sistema son:
Nombre Función
U. Administrador
Encargado de la Institución
Educativa
U. Técnico
Técnicos de evaluación de la
Institución Educativa
Tabla 5. Recurso Humano
3.3.2. Arquitectura de la Solución
La arquitectura a utilizar será cliente - servidor que facilita que las personas
puedan utilizarlo desde cualquier dispositivo móvil Android con conexión a
internet. En esta Arquitectura se identifican dos secciones, el cliente, donde
se encuentra la persona que utilizara el sistema y que accederá a la aplicación
gracias a la ayuda del internet, y el servidor, en donde se encuentran los
datos, se gestiona las reglas y lógicas de uso para los usuarios finales
(cliente).
53
Figura 18. Arquitectura cliente-servidor31
Esta arquitectura permitirá principalmente en el acceso remoto a los datos, y
el procesamiento y manejo de los mismos, se lo realiza en un gran porcentaje
en el lado del cliente, esto nos lleva a pensar en varias posibilidades:
a) Acceso de varios clientes al servidor.
b) Capacidad y ancho de banda de la red por la que circularán los datos.
c) Bloqueos sobre los datos que están en escritura.
Las respuestas a estas interrogantes son variadas y no están enmarcadas en
algo rígido, y se tomará matices intermedios, y no extremos.
La aplicación móvil tiene una capa de presentación, que es mostrada al
usuario, y permite que interactúen. La capa de presentación, o interfaz de
usuario, consiste de varios elementos visuales, y el código de la aplicación
que quien controla la interacción del usuario con estos elementos.
Características
Entre las principales características que ofrece este sistema tenemos los
siguientes:
31 http://www.forosdelweb.com/f165/android-tc-1073002/ (07/04/2015)
54
a) Servicio: se refiere a que en esta relación, debe existir
comunicación entre procesos que corren en dispositivos diferentes.
EL proceso SERVIDOR: Proveedor de servicios a los clientes.
El proceso CLIENTE: Consumidor de servicios brindados por el
servidor.
b) Recursos Compartidos: un servidor puede servir (en base a los
recursos que el servidor tiene) a varios clientes al mismo tiempo, es
decir, soporta varias conexiones con los clientes, siendo en servidor
el ente regulador de acceso a los recursos que requieren los
clientes.
c) El cliente y el servidor se comunican en base a mensajes, que
son iniciados por el cliente. Si en una arquitectura cliente/servidor,
se cambia la parte del servidor, el cliente no debe sufrir impacto
alguno, si el medio y la forma de comunicarse entre los dos no
cambia.
La base de datos del servicio será desarrollada en MySQL y estará alojada
en un servidor web. La aplicación se conectará a dicha base de datos desde
el dispositivo móvil, el cuál requerirá de una conexión de datos activada.
3.3.3. Diseño de la Base de Datos
El esquema de la base de datos de la aplicación se ha obtenido usando
ingeniería inversa por medio del MySQL Workbench.
Denominado también Estructura de Datos, se trata de un gráfico que
presenta de forma estandarizada la manera en la cual se almacenarán los
datos de la aplicación, cada una con sus respectivos campos y entrelazadas
con líneas que representan las relaciones que se mantienen entre estas, así
también se muestra los identificadores principales (clave principal) y
secundarios (clave foráneo) que identifica a cada tabla.
55
Figura 19. Modelo del esquema de la Base de Datos32
Se observa en la figura anterior el esquema de base de datos, que permitirá
la interconexión del sistema, tanto para los eventos como para los usuarios.
Para hacer el manejo de MySQL un poco más amigable, se utilizó la
herramienta PHPMyAdmin, que es un terminal vía Web para el acceso a las
bases de datos y sus tablas. Una vez instalado el programa basta con poner
en el navegador la dirección adecuada del servidor y se nos pedirá un usuario
root y una contraseña para acceder a las base de datos. Permitido el acceso,
se tiene la posibilidad de crear las tablas, eliminarlas, consultarla, insertar las
filas, modificarlas y varias opciones más muy cómodas. En la siguiente figura
se muestra la interfaz del programa PHPMyAdmin.
32 Autor: Dario Pillajo
56
Figura 20. Interfaz del programa PHPMyAdmin33
La base de datos de nuestro sistema permite almacenar la información de
forma organizada y detallada, al mismo tiempo permite interactuar entre los
diferentes procesos que se pueden generar como consultas y reportes que
requiere el usuario.
El detalle de cada tabla se encuentra a continuación, siendo de gran
importancia su revisión para comprender la función que realiza cada campo
de las tablas mostradas en la figura anterior, como parte de la interconexión
de los sistemas.
Diccionario de datos
Un diccionario de datos no es más que un conjunto de metadatos, el cual
posee las características lógicas y puntuales de los datos que se utilizarán en
la aplicación. En un diccionario de datos se encuentra la lista de todos los
elementos que forman parte de todo el sistema. Los elementos más
importantes son flujos de datos, almacenes de datos y procesos. El diccionario
de datos guarda los detalles y descripción de todas las tablas.
Descripción de Tablas
33 http://sql9.hostinger.es/phpmyadmin/index.php?db=u623083737_mora&token=8d5045c660eeb63cd8626461b68afb33&phpMyAdmin=eaf86812b8de4988f7a5e6050f9c0da32a4ed949 (20/04/2015)
57
Tabla Alumno, registra la información básica del alumno de la institución
Nombres Atributos Descripción
IdAlumno Código
Nombre Nombre
Apellido Apellido
Teléfono Celular
TelefonoRepresentante Teléfono
Cedula Cédua
Direccion Dirección
FechaNacimiento Fecha Nacimiento
Paralelo_idParalelo Código
Tabla 6. Tabla Alumno
Tabla Asistencia, registra las asistencias de los alumno
Nombre Atributo Descripción
IdAsistencia Código
Hora Hora
58
Fecha Fecha
Tabla 7. Tabla Asistencia
Tabla Curso, registra los cursos que tiene la institución
Nombre Atributo Descripción
IdCurso Código
Nombre Nombre
Codigo Código Curso
Tabla 8. Tabla Curso
Tabla Año_Lectivo, registra datos de año inicio
Nombre Atributo Descripción
IdAnioLectivo Código
AnioInicio Año Inicio
AñoFin Año Fin
Tabla 9. Tabla Año Lectivo
Tabla Materia, registra las asignaturas o materias
Nombre Atributo Descripción
IdMateria Código
59
Nombre Nombre
Materia_IdProfesor Código Materia
paralelo_IdParalelo Código Paralelo
Parcial_IdPparcial Código Parcial
Tabla 10. Tabla Materia
Tabla Nota, registra las notas del alumno
Nombre Atributo Descripción
IdNota Código
Nota Nota
exmenQuimestre Exámen Quimestral
Materia_IdMateria Código Materia
Alumno_IdAlumno Código Alumn
Tabla 11. Tabla Nota
Tabla Paralelo, registra el paralelo de cada curso
Nombre Atributo Descripción
IdParalelo Código
Curso_IdCurso Código curso
60
Paralelo Nombre
Tabla 12.Tabla Paralelo
Tabla Parcial, registra los parciales del año lectivo
Nombre Atributo Descripción
IdParcial Código
Parcial Número del parcial
Quimestre_idQuimestre Quimestres
Tabla 13. Tabla Parcial
Tabla Quimestre, registra los quimestres del año lectivo
Nombre Atributo Descripción
IdQuimestre Código
AnioLectivo_idAnioLectivo Código Año Lectivo
Tabla 14. Tabla Quimestre
Tabla Profesor, registra los docentes
Nombre Atributo Descripción
IdProfesor Código
Nombre Nombre
61
Apellido Apellido
Cedula Cédula
Teléfono Teléfono
Dirección Dirección
Especialidad Especialidad del docente
FechaNacimiento Fecha Nacimiento
Usuario_Profesor Usuario
Pasword_Profesor Password
Tipo Tipo de Docente
Tabla 15. Tabla Profesor
Tabla Registro
Nombre Atributo Descripción
IdRegistro Código
Profesor_IdProfesor Código Profesor
Asistencia_IdAsistencia Código Asistencia
Tabla 16. Tabla de Registro Notas
62
3.3.4. Diseño del Mapa de Navegación
El mapa de navegación muestra el camino que el usuario normalmente
tomaría para hacer uso del sistema de Control de Asistencia. Ésta se
representa de una forma jerárquica en donde el número de niveles representa
el número de clics necesarios para llegar a una pantalla.
Figura 21. Mapa de Navegación
3.3.5. Guía de estilos
Los contenidos y/o elementos que integran la aplicación deben ser normados
a través de un manual de estilo, para que posean coherencia en su
presentación visual, estableciendo directrices que permitan conservar el
diseño original y mantener la homogeneidad, para facilitar el desarrollo de
contenidos.
La aplicación se identifica por el uso de elementos como: el color, el tipo de
letra, el tamaño de sus elementos, etc., fijando condiciones y esquemas para
la producción de estos elementos, siguiendo una estructura lógica y fácil de
usar.
63
El manual de estilo presentado tiene como principio gráfico “la elegancia y
simplicidad”, teniendo enunciados establecidos como claridad, precisión,
concreción y sencillez, en el que se establecen las normas a seguir para el
manejo de contenidos gráficos.
Introducción
Esta guía, pretende plantear una arquitectura más clara y navegable,
ordenando de la mejor manera posible las pantallas de la aplicación,
metodología de programación, bases de datos.
A lo largo de la guía se citarán diferentes medidas y tamaños para los
elementos que componen la aplicación, dichas medidas vienen definidas en
las siguientes unidades:
dp (Density-independent Pixels): “un pixel independiente de la
densidad corresponde al tamaño físico de un pixel en 160 dpi (dots per
inch «puntos por pulgada»). Así, la densidad de la pantalla está
relacionada directamente proporcional con los pixeles utilizados, es
decir a mayor densidad de pantalla, se aumentan el número de pixeles,
y viceversa.
sp (Scale-independent Pixels): Esta unidad se escala según el
tamaño de fuente configurada, por lo que se ajusta tanto para la
densidad de pantalla y como a las preferencia del usuario.
px (Pixels): Corresponde a un píxel real en la pantalla.
Color
La estética de la aplicación está definida por el uso de la gama de los colores
mostrados en la siguiente figura:
64
Figura 22. Gama de colores a usar
Tipografía
La tipografía predominante en la aplicación es BernardoModalBold y la
complementaria es Abbey-Medium, que asegura una legibilidad en los
tamaños medianos y grandes utilizados. Para el texto estándar se utiliza un
tamaño de 18sp, los destacados irán en negrita.
Figura 23.Tipografía a usar
Guía Técnica
Definir un buen estilo de programación es subjetivo, es por ello, que para el
desarrollo de la aplicación se han seguido estándares y especificaciones
técnicas, los mismos que definen y describen aspectos como la
interoperabilidad, la accesibilidad y la usabilidad de aplicaciones Android, de
tal manera que se proporciona ventajas como: mejor organización y
entendimiento del código, ahorro de problemas de compatibilidad, etc.
Algunos estándares utilizados son los siguientes:
65
Nombres apropiados: elección adecuada de nombres descriptivos
para variables, constantes, funciones, métodos, objetos, etc.
Estilo de indentación34: mediante el buen marcado semántico y el
uso de un estilo lógico y consistente para permitir la legibilidad con
mayor claridad, debido a que los bloques de código se agrupan y se
representan de forma más clara, ofreciendo una mejor lectura y
entendimiento del código.
Bucles y estructuras de control lógicas: ayuda a la comprensión
de las secuencias de ejecución.
Uso de comentarios: El código contiene comentarios, para aclarar el
funcionamiento, los cuales están escritos en idioma español y
debidamente aclarados.
3.4. Fase de Desarrollo
Mediante reuniones mantenidas con los docentes se determinará las
necesidades reales en los procesos de registro de asistencia y notas,
obteniendo información relevante que permita generar un bosquejo de la
funcionalidad de la aplicación.
Una vez elaborado y aprobado la navegación, es necesario centrarse en los
bocetos de la aplicación, tomando en cuenta la tecnología que se utilizará
para la plataforma de programación y los entornos de desarrollo que
permitan cumplir con los objetivos de manera óptima.
3.4.1. “Capas” de la aplicación
Con el fin de seguir explicando lo mejor posible la estructura y funcionamiento
del prototipo que se va a desarrollar a lo largo de la presente tesis, a
continuación tenemos un esquema en el que se trata de simplificar al máximo
34 Indentación es un anglicismo de uso común en informática, que significa mover un bloque de texto hacia la derecha insertando espacios o tabuladores, para así separarlo del margen izquierdo y mejor distinguirlo del texto adyacente
66
el conjunto de “paquetes” o “bloques” requeridos para el funcionamiento del
sistema.
Figura 24. Esquema de capas de la aplicación
Como se observa en la figura anterior, se ha tratado de separar la aplicación
según la arquitectura en tres capas: interfaz, lógica de negocio y persistencia:
Interfaz: Este “paquete” contiene todo el conjunto de interfaces de
usuario en formato XML, tal y como requiere cualquier aplicación
desarrollada para Android. Es fácil suponer que este conjunto de
documentos se almacenaran en el dispositivo móvil.
Lógica: esta “capa” contiene un conjunto de paquetes que son los
encargados de gestionar la mayor parte de la aplicación. Dentro de ella
encontramos:
Clases: Contiene el conjunto de clases, en formato java.
Conexión: Esta clase java, servirá para realizar las peticiones
HTTP al servidor web, procesar las respuestas, en formato
JSON, del mismo y devolver la información recuperad.
App: El “bloque” App contiene un archivo java, complementario,
por cada archivo XML contenido en Layout (Interfaz). Esto es así
por restricciones del propio Android, que requiere una serie de
67
métodos para gestionar y configurar las interfaces definidas en
Layout.
Persistencia:
MySQL: Contiene el código SQL referente a las tablas y
relaciones entre ellas. Estos archivos en formato PHP realizan
las consultas, conocidas como “querys” sobre el sistema gestor
de bases de datos, recogen su respuesta y la codifican en
formato JSON para devolverla al solicitante.
3.4.2. Web Service
Un Web Service o Servicio Web es un aplicativo que facilita la
interoperabilidad entre varios sistemas independientemente del lenguaje de
programación o plataforma en que fueron desarrollados. Este debe tener una
interfaz basada en un formato estándar entendible por las maquinas como lo
es XML o JSON.
Un web service es un conjunto de protocolos y estándares que sirven para
intercambiar datos entre aplicaciones, o dicho de otra manera un ws es un
conjunto de métodos que se pueden invocar por alguna aplicación para
realizar una tarea compleja.
Los servicios web, no son por tanto aplicaciones con una interfaz gráfica con
la que las personas puedan interaccionar, sino que son software accesible en
internet por otras aplicaciones. De esta forma podemos desarrollar
aplicaciones que hagan uso de otras aplicaciones que estén disponibles en
internet interaccionando con ellas.
El web service se comporta como medio de conexión remota entre la
aplicación móvil y la base de datos alojada en el hosting. El proceso que
efectúa es: la aplicación realiza peticiones a través de la librería HttpPost, la
mima que solicita la conexión con un servicio web que ejecuta los archivos
PHP para generar las consultas, si existe respuestas del servidor envía la
información encriptada en código JSON.
68
Código de Acceso desde Android
Cada vez que la aplicación requiere realizar consultas, inserciones o
eliminaciones en la base de datos, emplea la siguiente función:
public class Conexion extends AsyncTask<String, String, String> {
public String login(String url, String accion, String user,
String pass) {
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion, user, pass).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public String alumnos(String url, String accion, String paralelo)
{
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion, paralelo).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public String notas(String url, String accion, int paralelo, int
parcial) {
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion,
String.valueOf(paralelo), String.valueOf(parcial)).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
@Override
protected String doInBackground(String... params) {
69
try {
for (int i = 1; i < params.length; i++) {
if (i == 1) {
params[0] = params[0] + "?param" + i + "=" +
params[i];
} else {
params[0] = params[0] + "¶m" + i + "=" +
params[i];
}
}
HttpPost httppost = new HttpPost(params[0]);
HttpClient httpclient = new DefaultHttpClient();
HttpResponse response = httpclient.execute(httppost);
BufferedReader reader = new BufferedReader(new
InputStreamReader(
response.getEntity().getContent(), "UTF-8"));
String json_response = "", linea = "";
while ((linea = reader.readLine()) != null) {
json_response += linea;
}
return json_response;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
Crear archivos de configuración PHP para acceder a la base de datos
El archivo de configuración para acceder a la conexión con el servidor web
debe ser en formato PHP y contener lo siguiente:
70
Figura 25. Archivo de configuración – Login.php
$db_server='mysql.hostinger.es';
$db_username='u623083737_mora';
$db_password='jh162404';
$db_db='u623083737_mora';
$db = new mysqli($db_server,$db_username,$db_password, $db_db);
if($db->connect_errno){
echo("No Conectado");
}else{
echo("Conectado");
}
Crear los casos para ejecutar peticiones a la base de datos en un archivo
PHP
A continuación detallamos cada uno de los diferentes casos en un archivo
PHP para facilitar la conexión a la base de datos:
71
Login:
case 'login':{
$id_user=$_GET["param2"];
$id_pass=$_GET["param3"];
$json = array();
$sql ="select distinct p.IdProfesor,
p.Nombre,p.Apellido,p.Tipo,pa.IdParalelo,c.Nombre
from profesor p
join materia m on p.IdProfesor=m.materia_IdProfesor
join paralelo pa on m.paralelo_IdParalelo=pa.IdParalelo
join curso c on pa.curso_IdCurso=c.IdCurso
and p.Usuario_Profesor='$id_user' and
p.Password_Profesor='$id_pass';";
if ($result=mysqli_query($db,$sql)){
while ($row = mysqli_fetch_assoc($result)){
$row['flag']='si';
$json['profesor'][]=$row;
}else{
$row['flag']='no';
$json['profesor'][]=$row;
}
break;
Alumnos:
case 'alumnosparalelo':{
$idParalelo=$_GET["param2"];
$json = array();
72
$sql ="select DISTINCT a.IdAlumno,a.Nombre
,a.Apellido,c.Nombre Curso
from profesor p, materia m,curso c, paralelo pa,alumno a
where p.IdProfesor=m.materia_IdProfesor
and m.paralelo_IdParalelo=pa.IdParalelo
and pa.curso_IdCurso=c.IdCurso
and pa.IdParalelo=a.paralelo_IdParalelo
and pa.IdParalelo=$idParalelo
group by a.IdAlumno
";
if ($result=mysqli_query($db,$sql)){
while ($row = mysqli_fetch_assoc($result)){
$json['alumno'][]=$row;
}
}else{
$row['flag']='no';
$json['alumno'][]=$row;
}
break;
Materias:
case 'materiascurso':{
$idParalelo=$_GET["param2"];
$json = array();
73
$sql ="select distinct m.IdMateria,m.Nombre
Materia,c.Nombre Curso
from profesor p
join materia m on p.IdProfesor=m.materia_IdProfesor
join paralelo pa on m.paralelo_IdParalelo=pa.IdParalelo
join curso c on pa.curso_IdCurso=c.IdCurso
join parcial par on m.parcial_IdParcial=par.IdParcial
and pa.IdParalelo='$idParalelo'
group by m.Nombre;";
if ($result=mysqli_query($db,$sql))
{
while ($row = mysqli_fetch_assoc($result)){
$row['flag']='si';
$json['materia'][]=$row;
}
}else{
$row['flag']='no';
$json['materia'][]=$row;
}
break;
3.4.3. Diseño de los bocetos de las pantallas de la aplicación
Para la parte de diseño de prototipos, fondo e iconos de nuestro proyecto lo
realizaremos gracias a la ayuda de la herramienta Adobe Ilustrador.
Al ser una herramienta que sirve para la creación de toda la parte gráfica de
la aplicación. Nos permitirá crear un diseño rápido y eficiente para lo que
buscamos en el proyecto.
74
Boceto de la pantalla de Presentación
Nuestro primer boceto es la pantalla de Presentación o Splash, la cual va ser
muy simple, ya que solo requiere un fondo en una ventana o Activity.
Figura 26. Pantalla de Presentación o Splash
Boceto de la pantalla inicio de Sesión
Nuestro segundo boceto va ser la pantalla de Logueo o inicio de sesión la cual
solo requiere de una ventana o Activity.
Figura 27. Pantalla de Inicio Sesión
Boceto de la pantalla de Menú
Continuando con los bocetos, vamos a realizar la pantalla del Menú, esta será
muy importante porque siempre estará visible para el usuario, ya que en el
accederemos a las diferentes opciones que tiene nuestra aplicación por lo que
será muy intuitiva, sencilla y muy agradable a la vista.
75
Figura 28. Pantalla de Menú
Boceto de la pantalla de Menú de Notas
Vamos a ver el prototipo para la pantalla de Menú de Notas, este contendrá
los diferentes tipos de notas que podrá ingresar el docente. Podría ser así más
o menos:
Figura 29. Pantalla de Menú de Notas
Boceto de la pantalla Notas
Vamos a ver el prototipo para la pantalla de Notas, este contendrá toda la
información sobre curso, año lectivo, periodo, materia, lista de estudiantes y
espacios donde editar las notas de cada estudiante. Podría ser así más o
menos:
76
Figura 30. Pantalla de Notas
Boceto de la pantalla de Asistencia
Vamos a ver el prototipo para la pantalla de Asistencia, este contendrá toda
la información sobre curso, año lectivo, periodo, materia, lista de estudiantes
y espacios donde escoger los diferentes tipos de asistencias de cada
estudiante. Podría ser así más o menos:
Figura 31. Pantalla de Asitencias
3.4.4. Diseño de Interfaz de Usuario
Una vez ilustrado todo el contenido de código alojado en el servidor web,
ahora se desarrollara la parte de software que recae sobre el dispositivo móvil.
Android organiza todas las interfaces de usuario en views y layouts, cada
layout organiza las distintas views, como puede ser botones o cuadros de
texto, se podría decir que los Layouts son los contenedores de los views.
77
Layouts: Los layouts pueden ser creados mediante código directamente en
Java, o utilizando archivos XML. Los layouts en formato XML son
considerados los recursos de la aplicación, por lo cual se ubicaran en el
directorio res/layout del proyecto, en ellos se describe las propiedades así
como el aspecto que tendrá la interfaz de usuario.
Figura 32. Lista de archivos layouts y código XML del layout
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/fondo_login"
android:baselineAligned="true"
android:orientation="horizontal" >
<LinearLayout
android:background="@android:color/transparent"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:layout_weight="1" />
<LinearLayout
android:layout_width="fill_parent"
78
android:layout_height="fill_parent"
android:layout_weight="0.4"
android:background="@android:color/transparent"
android:orientation="vertical" >
</LinearLayout>
<LinearLayout
android:background="@android:color/transparent"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:layout_weight="1" />
</LinearLayout>
Como se ve en la figura y código anterior, este tipo de documentos XML para
la interfaz, suelen constar de un gran “contenedor” (LinearLayout), éste puede
contener a su vez otros objetos de interfaz, organizándolos todos de forma
lineal, bien de manera horizontal, o bien vertical.
De esta manera, es como se implementan la gran mayoría de interfaces de la
aplicación y a continuación se detalla algunas de las interfaces de la aplicación
creadas para su desarrollo.
Diseño del Login
El Login debe cumplir con el ingreso a la aplicación, la cual se le mostrará una
sola vez al usuario final, mientras este no haya cerrado sesión.
Los objetos que componen esta interfaz son:
LinearLayout
imageView
editText
editTex(contraseña)
button
79
Figura 33. Interfaz de Usuario – Login
Diseño del Menú
La aplicación consta de 2 botones que nos permite ingresar a diferentes
actividades.
Los objetos que componen esta interfaz son:
LinearLayout
TextView
imageView
Figura 34. Interfaz de Usuario - Menú
Diseño de Listas
En toda la aplicación se tendrá 1 lista, las cuales muestran los alumnos.
El diseño de las listas son diferentes para cada actividad según corresponda
y contiene los siguientes objetos:
80
LinearLayout
Listview
ImageView
TextView
EditText
Spinner
Figura 35. Interfaz de Usuario - Listas
Conexión HTTP:
HTTP es un protocolo de transferencia de hipertexto que se usa en la Web.
HTTP es una sigla que significa Hypertext Transfer Protocol, o Protocolo de
Transferencia de Hipertexto. Este protocolo opera por petición y respuesta
entre el cliente y el servidor. A menudo las peticiones tienen que ver con la
ejecución de un programa, consulta a una base de datos, y otras
funcionalidades. Toda la información que opera en la Web mediante este
protocolo es identificada mediante el URL o dirección.
Los intercambios de información en formato XML entre la aplicación y el
servidor se realizan mediante el protocolo HTTP. En las peticiones se utiliza
el método POST de dicho protocolo, encapsulando el documento XML
correspondiente dentro de un campo de nombre “xml”.
81
Esta clase contiene un conjunto de métodos, que son los encargados de
conectarse al servidor donde se encuentra alojados los scripts PHP,
pasándoles los parámetros necesarios para la inserción, edición, borrado o
actualización de los valores de la base de datos, dependiendo de la necesidad
del usuario.
A continuación se muestra los métodos implementados para conectarse a la
base de datos.
package com.conexion;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import android.os.AsyncTask;
import android.util.Log;
/**
* AsyncTask que conecta a la URL que contiene el documento JSON y
añade los datos al Adapter.
*/
public class Conexion extends AsyncTask<String, String, String> {
// Métodos para el envío de peticiones a la base de datos desde
nuestra aplicación
public String login(String url, String accion, String user,
String pass) {
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion, user, pass).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public String alumnos(String url, String accion, String paralelo)
{
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion, paralelo).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public String materias(String url, String accion, String
paralelo) {
Conexion conexion = new Conexion();
try {
82
return conexion.execute(url, accion, paralelo).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
public String anioLectivo(String url, String accion) {
Conexion conexion = new Conexion();
try {
return conexion.execute(url, accion).get();
} catch (Exception e) {// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
@Override
protected String doInBackground(String... params) {
try {
for (int i = 1; i < params.length; i++) {
if (i == 1) {
params[0] = params[0] + "?param" + i + "=" +
params[i];
} else {
params[0] = params[0] + "¶m" + i + "=" +
params[i];
}
}
/* Definimos la ruta al servidor. */
HttpPost httppost = new HttpPost(params[0]);
/* Creamos el objeto cliente que realiza la petición al
servidor */
HttpClient httpclient = new DefaultHttpClient();
/* Ejecuto la petición, y guardo la respuesta */
HttpResponse response = httpclient.execute(httppost);
// Recogemos el String que devuelve el servidor.
// Guardamos la dirección en un buffer de lectura
BufferedReader reader = new BufferedReader(new
InputStreamReader(
response.getEntity().getContent(), "UTF-8"));
String json_response = "";
String linea = "";
// Leer el buffer de entrada hasta el final
while ((linea = reader.readLine()) != null) {
json_response += linea;
}
//Log.v("Pajarito Buscando", json_response);
// Devolvemos todo lo leido
return json_response;
} catch (Exception e) {
83
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
App:
Para esta parte vamos a ver los requerimientos de desarrollo que se necesitan
para empezar a programar en Android, así como una breve descripción del
código de las clases más relevantes dentro de la aplicación como son:
La Clase Java Login (Conexión y autentificaión en labase de datos
mediante web service).
Para crear una Actividad en Android se recomienda realizar tres pasos: crear
la clase en java que contendrá la interfaz de usuario derivando de la clase
Activity, crear la GUI en un archivo con extensión xml (también se lo puede
hacer de manera programática) y finalmente especificar en el archivo de
configuración AndroidManifest.xml la nueva actividad a ser utilizada.
A continuación se presenta el código java de la aplicación Login que establece
la comunicación con el WebService, llamar al Activity o ventana principal y
valida la conexión del usuario con la aplicación:
package com.asistenciamorabowen;
import org.json.JSONArray;
import org.json.JSONObject;
import android.app.Activity;
import android.content.Intent;
import android.graphics.Typeface;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import com.conexion.Conexion;
import com.conexion.DatosConexion;
import com.entidades.Profesor;
public class Login extends Activity {
84
static String paralelo;
public int tipo_profesor;
EditText user, pass;
String String_user, String_pass;
Button boton;
public static Profesor profesor = new Profesor();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.login);
//Sincronizamos los layout
user = (EditText) findViewById(R.id.idUserName);
pass = (EditText) findViewById(R.id.idPass);
boton = (Button) findViewById(R.id.idbutton_send);
Typeface face =
Typeface.createFromAsset(getAssets(),"font/Bernardo Moda Bold.ttf");
user.setTypeface(face);
pass.setTypeface(face);
boton.setTypeface(face);
}
//Metodo para comparar si esta vacio los campos o si los datos
son correctos
public void logearse(View v){
if (user.getText().toString().isEmpty()
&& pass.getText().toString().isEmpty()) {
Toast toast1 = Toast.makeText(this,
getString(R.string.llenardatos),
Toast.LENGTH_SHORT);
toast1.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast1.show();
} else {
if (comprobarLogin()) {
String_user = user.getText().toString();
String_pass = pass.getText().toString();
Intent i = new Intent(this, Menus.class);
i.putExtra("profesor", profesor);
startActivity(i);
} else {
Toast toast1 =Toast.makeText(this,
getString(R.string.login),
Toast.LENGTH_SHORT);
toast1.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast1.show();
}
}
}
//Metodo que verifica si en la base de datos existe el usuario
con su contrasena
public boolean comprobarLogin() {
String url = new DatosConexion().getUrl();
String accion = "login";
Conexion conexion = new Conexion();
String con = conexion.login(url, accion,
user.getText().toString(), pass.getText()
85
.toString());
if (con != null) {
Log.v("Pajarito Login", con);
} else {
Log.v("null conexion null", "null");
}
try {
JSONObject obj = new JSONObject(con);
JSONArray jsonArray = obj.getJSONArray("profesor");
JSONObject jsonObject = jsonArray.getJSONObject(0);
profesor.setCodigoProfesor((jsonObject.getString("IdProfesor")));
profesor.setNombre(jsonObject.getString("Nombre"));
profesor.setApellido(jsonObject.getString("Apellido"));
profesor.setTipo(jsonObject.getString("Tipo"));
paralelo = jsonObject.getString("IdParalelo");
} catch (Exception e) {
e.printStackTrace();
}
try {
if (!profesor.getCodigoProfesor().isEmpty()) {
this.finish();
return true;
}
} catch (Exception e) {
return false;
}
return false;
}
//Metodo para cambiar de página o nueva actividad
public void navegarBotones(View v) {
Intent i = new Intent(this, Menus.class);
startActivity(i);
}
}
Este tipo de clases extienden de “Activity”, que como ya se ha comentado,
podrían compararse a las ventanas típicas de una aplicación de escritorio.
La característica principal de las clases JAVA con extensión Activity es que
deben de tener un método llamado “onCreate” que se ejecuta al iniciar una
determinada Activity.
Básicamente lo que se hace en este método es inicializar los diferentes
controles declarados en el documento XML correspondiente a cada interfaz.
En el método booleano comprobarLogin descrito anteriormente, utilizamos la
clase conexión creada previamente para obtener los datos en formato Json.
86
Para eso primeramente creamos un objeto JSONObject donde le pasaremos
por constructor la información que obtuvimos de
nuestro WebService almacenada en la variable de tipo String "con".
Posteriormente pasamos JSONObject a JSONArray, indicándole por
parámetro el nombre del array de nuestro JSON, en nuestro caso "profesor".
Un pequeño detalle, puedes recordar en el WebService creado, que al json le
daba un nombre de parámetro:
$json['profesor'][]=$row;
Ese nombre, que va entre comillas simples y corchetes (profesor), es la
referencia que le hago a JSONArray en su parámetro.
Bien, con esto tendríamos almacenado en JSONArray diferentes objetos
JSON, cada uno con la información de cada fila de nuestra tabla, por lo que
para ir recorriendo cada uno deberíamos utilizar un for, ya que en su esencia,
lo que vamos a hacer es recorrer un array.
Una vez dentro del for, crearemos un objeto de tipo profesor con cada ciclo
del for, crearemos un objeto de tipo JSONObject por cada ciclo, recogiendo
así todos los datos que tenemos almacenados en JSONArray, en este caso
solo tenemos un elemento en el array por lo que no es necesario el for.
Una vez hecho esto, sería ir dándole a cada atributo de profesor su
correspondiente valor, posteriormente agregamos el objeto personas a
nuestro ArrayList, en este caso no es necesario el ArrayList porque solo
tenemos un elemento.
Si fuera el caso de tener un ArrayList ya tendríamos los datos de nuestro
servidor almacenados en objetos de tipo profesor que a su vez están
almacenados en un ArrayList, listos para ser mostrados por pantalla.
Archivo AndroidManifest.xml
EL AndroidManifest.xml es un archivo ubicado en la el nodo raíz de la
jerarquía del proyecto, en el cual se almacenan configuraciones globales.
87
Contiene información necesaria que el sistema debe conocer antes y durante
la ejecución de una aplicación.
En este archivo también se especifican todos los posibles permisos que se
pueden conceder a una aplicación: utilización de Wi-Fi, Bluetooth, llamadas
telefónicas, cámara, Internet, mensajes SMS y MMS, vibrador, etc.
Todas y cada una de las activitys de la app deben ser declaradas en esta
sección, sino no funcionarán. La actividad inicial de la aplicación debe ser
declarada de tipo "LAUNCHER":
En el siguiente código se muestra la estructura del archivo
AndroidManifest.xml:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.asistenciamorabowen"
android:versionCode="1"
android:versionName="1.0" >
// El número de versiones debe irse modificando en el android
manifest con cada versión "publicada".
// Icono de la aplicación que aparecerá posteriormente al instalarse
en los menus y nombre de la //misma almacenador en el archivo de
strings. <application android:icon="@drawable/icon"
//android:label="@string/app_name">
//Configuración de las versiones soportadas.
<uses-sdk
android:minSdkVersion="14"
android:targetSdkVersion="22" />
//Permisos que el usuario debe aceptar al instalar
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission
android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >
<!-- android:theme="@android:style/Theme.Black.NoTitleBar" -
->
88
Declaración de todas las activities de la app:
<activity
android:name="com.asistenciamorabowen.Splash"
android:label="@string/app_name"
android:screenOrientation="landscape">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Login"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Menus"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Notas"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Menu_Notas"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Asistencia"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".DetalleNotas"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".DetalleAsistencias"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
89
<activity
android:name=".Examen_Parcial"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
<activity
android:name=".Examen_Final"
android:label="@string/app_name"
android:screenOrientation="landscape">
</activity>
</application>
</manifest>
3.4.5. Reciclaje
El código desarrollado para este proyecto ha sido debidamente comentado,
optimizado y lo más limpio posible, para su buen funcionamiento y
comprensión.
3.5. Fase de Implementación
Una vez terminada la aplicación se la somete a pruebas por parte de los
usuarios para su validación y aprobación. Una vez aprobado se implementará
la aplicación para ser utilizada por los docentes.
3.5.1. Web Hosting
Un web hosting es un tipo de alojamiento de internet que permite a individuos
y organizaciones realizar su propia página web accesible a través de la World
Wide Web.
Los servicios web y base de datos que requiere el proyecto se encuentran
alojados en el web host denominador Hostinger, que es gratuito y
extremadamente limitado, tanto para un espacio como para el tráfico de
información.
Es importante recalcar que cada proveedor presenta la configuración de forma
muy independiente, pero para este proyecto en particular se siguieron los
siguientes pasos, luego de ingresar en la dirección http://www.hostinger.es/ y
se procede con la autentificación de usuario.
90
Figura 36. Pantalla principal del Hostinger35
Para crear una nueva base de datos, nos dirigimos a Bases de Datos y
hacemos clic en el icono de bases de datos MySQL como se indica en la figura
siguiente:
Figura 37. Configuración MySQL36
35 http://www.hostinger.es/
36 https://cpanel.hostinger.es/hosting/index/aid/12134549
91
En la siguiente pestaña, podemos crear una nueva base de datos y que se
proporcionara la siguiente información en el formulario, es muy importante en
este punto recordar la contraseña.
Figura 38. Crear una nueva Base de Datos37
Una vez creado se ingresa presionando el botón phpMyAdmin, para importar
y configurar la base de datos requerida por el proyecto en curso.
37 https://cpanel.hostinger.es/databases/mysql-databases/aid/12134549
92
Figura 39. Configuración de la Base de Datos MySQL38
Para subir los archivos PHP nos dirigimos a la parte de Archivos como se
indica la figura y hacemos clic en Administrador de Archivos
Figura 40. Administrador de Archivos39
Luego en la pantalla siguiente damos clic en abrir administrador de archivos
38 http://sql9.hostinger.es/phpmyadmin/index.php?db=u623083737_base2&token=af53743419e5f91525
79b1773f781951&phpMyAdmin=5fa4be837fe6eda7231cce6ad7271d572963528f
39 https://cpanel.hostinger.es/hosting/index/aid/12134549
93
Figura 41. Pantalla de Administrador de Archivos40
En la siguiente pantalla creamos una carpeta, luego hacemos doble clic sobre
ella y una vez dentro de la carpeta, hacemos clic derecho y elegimos subir
archivos y finalmente escogemos los archivos PHP.
Figura 42. Pantalla para subir archivos PHP41
40 https://cpanel.hostinger.es/files/file-manager/aid/12134549
41 http://developerdario.hol.es/_file-manager/elfinder.php?access=190.152.179.92_a74d1b2523b883d04f71ae34f2e4f0a83ba78aee
94
3.5.2. Instalación apk
Los dispositivos móviles Android por defecto no instalan APKs que no vienen
del Play Store, sin embargo marcando una opción en la configuración, puedes
indicar al dispositivo que sí permita instalar APKs de orígenes desconocidos.
A continuación una explicación de cómo hacerlo.
Nos dirigimos a Ajustes >Aplicaciones
Figura 43. Pantalla de aplicaciones42
En este apartado activamos la opción de “Fuentes desconocidas”.
Figura 44. Pantalla de aceptación o no de instalación de aplicaciones de fuentes desconocidas43
42 http://tabletzona.es/tutoriales/tablets-android/root/como-instalar-aplicaciones-no-firmadas-por-google-en-tu-tablet/
43 http://tabletzona.es/tutoriales/tablets-android/root/como-instalar-aplicaciones-no-firmadas-por-google-en-tu-tablet/
95
Hacemos clic en aceptar si queremos que nos permita instalar apk de fuentes
desconocidas, caso contrario hacemos clic en cancelar.
Figura 45. Aceptación de fuetes desconocidos44
Con esto, ya podremos instalar aplicaciones descargadas desde su paquete
apk, para ello desde un gestor de archivos buscamos el directorio donde
guardamos el apk copiado desde el ordenador, seguimos los pasos que nos
indica para la instalación.
Con este modo las aplicaciones no están vinculadas a la tienda de Google,
por lo que no obtendremos actualizaciones automáticas, y para ello habría
que bajarse el nuevo apk de la web del desarrollador y volver a instalarlo con
este procedimiento.
3.5.3. Manual de Usuario
Revisar Anexo.
44 http://tabletzona.es/tutoriales/tablets-android/root/como-instalar-aplicaciones-no-firmadas-por-google-en-tu-tablet/
96
CAPÍTULO 4
4. Conclusiones y Recomendaciones
En este capítulo se presentará las conclusiones finales en comparación con
los objetivos marcados inicialmente y las recomendaciones necesarias del
proyecto realizado.
4.1. Conclusiones
Para la creación de la aplicación móvil para el proceso de control y
asistencia de la escuela “Dr. Alfonso Mora Bowen “, se utilizó Andriod
Studio el cual usa un conjunto de APIs que facilitan el correcto
desarrollo de dicha aplicación, resultando un gran aporte para la
institución, ya que permite dar solución, optimizando recursos en el
proceso de control y asistencia y evitando perdidas de información de
los estudiantes.
Durante el desarrollo de la aplicación se ha obtenido un gran
conocimiento sobre desarrollo en dispositivos móviles basados en
Android, así como su arquitectura, características, componentes y
funcionamiento. Cabe resaltar que el desarrollo en Android es muy
parecido al desarrollo en lenguaje Java, ya que incluye algunos APIs
de este lenguaje, por ello el aprendizaje y el desarrollo se realizó de
forma óptima.
La utilización de la metodología de desarrollo Scrum fue de gran ayuda
en el desarrollo de la aplicación móvil, ya que permitió optimizar
tiempos de revisión y entrega ante el coordinador de la escuela fiscal
mixta “Dr. Alfonso Mora Bowen“.
El proyecto ha causado una gran satisfacción en los docentes de la
institución educativa debido a las buenas repercusiones que este
sistema ha realiza en el proceso de control de notas, así como también
los de control de asistencias del alumnado.
97
Se concluye que para alcanzar los objetivos propuestos, fue necesario
adquirir nuevos conocimientos de los ya recibidos en la facultad, debido
a que el desarrollo de aplicaciones con conexión a bases de datos es
muy común, lo que ha hecho que se vaya fortaleciendo la industria de
aplicaciones móviles en nuestro país.
Finalmente cabe destacar que, gracias al desarrollo de la aplicación,
he adquirido una valiosa auto-formación en programación para el
sistema operativo Android, pero no solo eso, sino también experiencia
en PHP, XML, SQL y servidores. Durante todos estos meses, he ido
encontrando obstáculos y barreras que inicialmente no podía superar,
como la conexión con el servidor. Gracias al esfuerzo dedicado para
superar las dificultades y poder implementar todas las funcionalidades
de la aplicación, he adquirido una experiencia muy valiosa de cara al
futuro.
4.2. Recomendaciones
Al momento de desarrollar aplicaciones para dispositivos móviles
Android considerar su adaptación y funcionamiento para todas las
versiones con las que cuenta esta plataforma, puesto que existe
una alta gama de dispositivos en el mercado de distintas
especificaciones.
Los dispositivos móviles a usarse dentro de la institución educativa
debe tener conexión a internet o datos, para que haya un buen
funcionamiento.
Capacitar a los docentes de la institución educativa, para el uso
correcto de la aplicación, orientándolos en el buen manejo del
dispositivo móvil con la aplicación.
Se recomienda a la institución educativa conseguir un host pagado
para un mejor servicio y no haya problemas en la perfecto
funcionamiento de la aplicación.
98
Promover la implementación de nuevos módulos dentro de la
aplicación.
Dentro de la malla curricular de la carrera de Ingeniería en
Computación Gráfica, se incluyan tópicos avanzados en Base de
Datos enfocados a los dispositivos móviles, que es la tendencia
actual en el uso masivo de aparatos electrónicos para la
comunicación y entretenimiento.
Finalmente se recomienda fomentar el desarrollo de aplicaciones y
juegos para dispositivos móviles, ya que se han convertido en el
instrumento principal en el acceso a información y entretenimiento
en todos los países, particularmente en Ecuador.
99
Bibliografía
Alliance, O. H. (18 de Julio de 2011). Open Handset Alliance. Obtenido de
http://www.openhandsetalliance.com/index.html
Balaguera, Y. D. (2013). Metodologías ágiles en el desarrollo de
aplicaciones. En Y. D. Balaguera.
Bornstein, D. (15 de 02 de 2008). Google I/O. Obtenido de
https://sites.google.com/site/io/dalvik-vm-internals
GCF. (s.f.). Sistema operativo Móvil iOS. Obtenido de
http://www.gcfaprendelibre.org/tecnologia/curso/ipad/caracteristicas_general
es_del_ipad/3.do
Gironés, T. (2012). El Gran Libro de Android (Segunda Edición).
MARCOMBO, S.A.
Hernán., S. M. (2004). Diseño de una Metodología Ágil de. En S. M. Hernán..
Menéndez, R. I. (s.f.). Android 100%.
sgoliver. (8 de Julio de 2015). Obtenido de sgoliver.net blog:
http://www.sgoliver.net/blog/
Soriano, A. G. (6 de Agosto de 2010). Seguridad. Obtenido de Dispositivos
Móviles: http://revista.seguridad.unam.mx/numero-07/dispositivos-
m%C3%B3viles
wikipedia. (14 de Abril de 2015). Dispositivo móvil. Obtenido de
https://es.wikipedia.org/wiki/Dispositivo_m%C3%B3vil
100
ANEXO
Manual de Usuario de la Aplicación
A continuación se presenta, en modo de anexo, el manual de usuario para la
aplicación Asistencias Mora Bowen, en el que se describe el manejo de la
aplicación y sus funcionalidades.
Una vez instalada el apk, nos dirigimos al menú de aplicaciones y
presionamos en el icono de la aplicación, el icono se muestra en la siguiente
figura.
Figura 46. Icono de la aplicación
Pantalla que se visualiza mientras se carga la aplicación.
Figura 47. Splash de la aplicación
101
Luego se nos presenta la pantalla de Login, como se muestra en la figura 48,
en donde el docente debe introducir su usuario y contraseña en los campos
respectivos, el cual verifica si es o no un docente autorizado, para poder
ingresar a la aplicación.
Figura 48. Pantalla de Login
Una vez verificado al docente, ingresamos a la pantalla de Menú, donde
podemos elegir el tipo de acción que se quiere realizar.
Figura 49. Menú principal de la aplicación
Si se elige el botón de Notas, nos dirigimos a otra pantalla donde tenemos el
submenú de notas como se muestra en la figura.
Figura 50. Pantalla Menú de Notas
102
Una vez seleccionado el menú de notas, podemos elegir los diferentes tipos
de calificaciones asignadas a cada botón, la cual contendrá toda la
información necesaria para efectuar la calificación de notas, ver la figura
siguiente.
Figura 51. Pantalla Notas
En esta ventana el docente podrá elegir el año lectivo, el quimestre, el parcial,
la materia y la diferente nota de cada estudiante inscrito en su grado.
Una vez lleno el listado de notas de cada estudiante (cave recalcar que se
recomienda escoger una sola nota en cada ingreso), y debemos dar clic en el
botón de guardar, que está representado por el icono que se muestra a
continuación.
Figura 52. Icono guardar
Luego si queremos hacer clic en el otro icono representado como se muestra
la figura siguiente, nos trasladara a la siguiente página donde podemos ver
las notas final de cada semestres.
103
Figura 53. Icono Detalle Nota
Una vez que estamos en la pantalla de detalle nota, el docente puede elegir
el año lectivo, el quimestre, la materia y se le desplegara el listado de los
estudiantes con sus respectivas notas, como se muestra la figura.
Figura 54. Pantalla Detalle Nota
Para el icono de Asistencia tendremos el mismo procedimiento para realizar
la calificación de asistencias de los estudiantes y poder ver el detalle de
asistencia.
Figura 55.Pantalla Asistencias
