Upload
vuongdien
View
213
Download
0
Embed Size (px)
Citation preview
ALUMNO: Juan García Piosa.
TITULO DEL PROYECTO: Personal trainer, entrenador
personal para android.
TUTORA: María Teresa Ariza Gómez.
Departamento de Telemática.
Escuela Técnica Superior de Ingeniería.
Universidad de Sevilla.
Índice
1. Introducción. .......................................................................................... 1
1.1 Motivaciones. .................................................................................... 2
1.2 Objetivos. .......................................................................................... 3
1.3 Aplicación desarrollada. .................................................................... 6
1.4 Estructura de la memoria. ................................................................ 9
2. Entorno de desarrollo. .......................................................................... 11
2.1 Eclipse. ............................................................................................ 11
2.2 Servidor Apache. ............................................................................. 11
2.3 Base de datos MYSQL. ..................................................................... 12
2.4 MYSQL Workbench....................................................................... 13
2.5 PhpMyAdmin................................................................................... 13
2.6 Notepad ++...................................................................................... 16
3. Base de datos para el entrenamiento personal. ................................... 17
3.1 Base de datos MYSQL. ..................................................................... 17
3.2 Especificaciones y requerimientos de la base de datos. .................. 20
3.2.1 Usuarios. ................................................................................... 20
3.2.2 Estado de forma. ....................................................................... 22
3.2.3 Rutinas. ..................................................................................... 22
3.2.4 Rutinas de usuarios. .................................................................. 23
3.2.5 Histórico de Usuarios. ............................................................... 24
3.2.6 Ejercicios. .................................................................................. 25
3.2.7 Ejercicios de rutinas................................................................... 26
3.2.8 Tipos. ......................................................................................... 27
3.2.9 Tipos de ejercicios. ................................................................... 28
3.2.10 Útiles. ..................................................................................... 29
3.2.12 Recomendaciones de ejercicios. .............................................. 30
3.2.14 Propiedades de ejercicios. ....................................................... 32
3.2.15 Músculos. ............................................................................... 33
3.2.17 Recursos. ................................................................................. 34
3.2.18 Recursos de ejercicios. ............................................................ 35
3.3 Diagrama EER de la base de datos. .................................................. 36
4 Entrenador. ........................................................................................... 43
4.1 Objetivos y descripción de la aplicación java del entrenador. ......... 43
4.2 Diseño de la aplicación. ................................................................... 45
4.2.1 Diagramas UML. ........................................................................ 47
4.3 Descripción y funcionalidad de las clases. ....................................... 53
4.3.1 Importaciones. .......................................................................... 53
4.3.2 Conexión con la base de datos. ................................................. 54
4.3.3 Gestión de la base de datos. ...................................................... 55
4.3.4 Interfaz. ..................................................................................... 60
5 Usuario. ................................................................................................ 85
5.1 Objetivos y descripción de la aplicación android del usuario. .......... 85
5.1.1 Funcionamiento del servidor y módulos php. ............................ 86
5.1.2 Json. .......................................................................................... 89
5.2 Diseño de la aplicación. ................................................................... 93
5.2.1 Android Manifiest...................................................................... 96
5.2.2 Diagramas UML. ........................................................................ 96
5.3 Descripción y funcionalidad de las clases. ..................................... 104
5.3.2 Importaciones. ........................................................................ 104
5.3.2 Petición HTTP. ......................................................................... 107
5.3.3 Interfaz y gestión de datos. ..................................................... 108
6. Conclusiones. ..................................................................................... 141
7. Bibliografía. ........................................................................................ 143
8. Anexo. ................................................................................................ 147
8.1 Manual de instalación de la base de datos. ................................... 147
8.2 Manual de instalación de la aplicación Java .................................. 148
8.3 Manual de instalación de la aplicación Android............................. 149
8.3.1 API youtube para android. ....................................................... 150
1
1. Introducción.
A lo largo de la historia, el ser humano se ha caracterizado por
varios aspectos, pero sin duda alguna el más destacado, es su capacidad
para crear herramientas para satisfacer sus necesidades, facilitar el
trabajo y mejorar la calidad de vida. Los lenguajes de programación son
herramientas utilizadas para controlar el comportamiento de una
máquina, especialmente una computadora. Son muchos los lenguajes de
programación que hoy día se utilizan en dispositivos informáticos, pero
por su versatilidad, sencillez y aplicaciones tenemos que destacar el
lenguaje de programación orientado a objetos, Java (1).
Entre los sistemas operativos utilizados a día de hoy, destaca el
sistema operativo de Google, android (basado en java). Se ha introducido
en el mercado de los sistemas operativos de dispositivos móviles
ocupando una enorme cuota del mercado (2).
Ilustración 1: Cuota de mercado.
2
Tal aceptación por parte del mercado ha conllevado la aparición de
millones de aplicaciones de todo tipo. Si hay algo que caracteriza a la
plataforma android es que las aplicaciones no requieren ser desarrolladas
exclusivamente por profesionales, dando oportunidad a programadores
principiantes que intentando hacerse un hueco en el mercado laboral, o
simplemente como hobby, publiquen sus aplicaciones beneficiándose de
ellas todo aquel que tenga un dispositivo android y acceso a la aplicación.
Son muchas las funcionalidades que presentan las aplicaciones
desarrolladas para dispositivos android, entre ellas destacamos:
aplicaciones orientadas al entretenimiento, a recopilar información, a
facilitar el desarrollo de un trabajo, a ver televisión por internet,
aplicaciones que sustituyen a herramientas informática, e incluso
aplicaciones orientadas al desarrollo de ejercicio físico. Entre estas últimas
existen aplicaciones que indican una serie de ejercicios básicos, para
entrenar una parte concreta del cuerpo. Pero ninguna de ellas se encarga
de realizar un entrenamiento completo y personalizado, donde las rutinas
son propuestas por un entrenador profesional, y asignadas en función de
la necesidad del entrenado. Esa es la diferencia entre las aplicaciones ya
existentes enfocadas al desarrollo de ejercicio físico y Personal Trainer.
1.1 Motivaciones.
El gran desarrollo tecnológico sufrido en las últimas décadas ha
facilitado las labores que antes considerábamos tediosas, mejorando
nuestra calidad de vida y haciendo la vida cotidiana más sencilla. El estilo
de vida instaurado en nuestra época es sin duda un estilo sedentario
donde el ejercicio físico queda relegado a un segundo plano; poder
comprar desde el domicilio, revisar una cuenta bancaria desde un
ordenador en casa, e incluso trabajar desde el hogar, son ejemplos claros
de como las tecnologías han influido en nuestro estilo de vida.
3
La falta de actividad física no solo afecta al aspecto físico, también afecta
al estado mental y autoestima, influyendo negativamente en el desarrollo
de nuestra vida tanto en el ámbito laboral, como en el personal.
La manera en que llevamos nuestras vidas en el trabajo y en la
familia provoca en nuestro organismo un estado de ansiedad difícil de
sostener lo que deriva en angustia o depresión con los consiguientes
efectos sobre el organismo. El ejercicio ayuda a equilibrar todo este
proceso.
El Colegio Americano de Medicina del Deporte, la Organización
Mundial de la Salud y la Federación Internacional de Cardiología afirman
que la actividad física frecuente protege el avance de enfermedades
crónicas, evita la pérdida de resistencia, fuerza muscular y movilidad de
las articulaciones, favorece la pérdida de peso, mejora la autoestima y la
confianza.
Actualmente el problema no solo radica en el hecho de realizar
ejercicio físico y el esfuerzo que conlleva. El estilo de vida actual supone
una barrera para ello, limitando el tiempo que se requiere y reduciendo
las expectativas. Es en este contexto cuando surge la aplicación Personal
Trainer, cuyo enfoque facilita la práctica del ejercicio físico.
En la aplicación Personal Trainer, se lleva a cabo un seguimiento
personalizado por parte de un entrenador personal, donde los ejercicios y
rutinas son propuestas en función de los requerimientos del entrenado (el
usuario de la aplicación android), y en función de los resultados obtenidos
al realizar las rutinas propuestas. Al ser una aplicación para dispositivos
móviles, la aplicación Personal Trainer permite la práctica de ejercicio
físico personal en cualquier lugar y en cualquier momento, incentivando la
práctica de ejercicio y mejorando la calidad de vida.
1.2 Objetivos.
La aplicación Personal Trainer facilita la práctica de ejercicio físico
4
controlado y personalizado a personas que por cuestiones de tiempo y
situación le es imposible realizar. Lo único que se requiere es un terminal
móvil con sistema operativo android y una conexión a internet. Los
objetivos básicos de la aplicación son dos:
El seguimiento por parte de un entrenador personal.
La posibilidad de realizar ejercicio físico en cualquier momento y
lugar.
La aplicación consta de dos partes bien diferenciadas: la del
entrenador y la del usuario.
El entrenador, desde un ordenador con la aplicación instalada,
gestiona todos los aspectos relacionados con el entrenamiento del
usuario: datos personales, estado de forma, rutinas, histórico de rutinas,
ejercicios, tipos de ejercicios, recomendaciones, músculos implicados en
los ejercicios, etc. En la ilustración 2 se muestra el escenario completo con
los elementos básicos.
Ilustración 2 : Escenario básico de la aplicación.
5
La aplicación java del entrenador presenta un entorno gráfico con
dos menús: uno para los usuarios y otro para las rutinas. En el menú de
rutinas se muestran las rutinas y los ejercicios definidos y una serie de
opciones:
Definir nueva rutina.
Añadir ejercicio a rutina.
Eliminar rutina.
Eliminar ejercicio de rutina.
Rutinas de usuario.
El menú de usuario muestra los usuarios registrados en la aplicación
y las rutinas definidas. Entre las opciones del menú de usuario, se
encuentran:
Añadir nuevo usuario.
Eliminar usuario.
Asignar rutina a usuario.
Consultar historial
Mostrar rutinas de usuarios.
El usuario, desde un dispositivo móvil accede a las rutinas
propuestas por el entrenador. Las rutinas están compuestas de una serie
de ejercicios descritos e ilustrados mediante imágenes y videos. Para
acceder a la aplicación el usuario debe identificarse, habiéndose
registrado previamente, poniéndose en contacto con el entrenador. Una
vez que se ha accedido a la aplicación, se acceden a los contenidos
previamente planificados por el entrenador personal. Al finalizar la rutina,
el usuario rellenará un formulario con datos correspondientes a los
ejercicios realizados, que el entrenador evaluará, y tendrá en cuenta para
futuros entrenos.
6
1.3 Aplicación desarrollada.
La aplicación Personal Trainer basa su funcionamiento en la gestión
de los entrenamientos, rutinas y ejercicios por parte del entrenador,
utilizando para ello la interfaz gráfica java, y en la consulta y envío de
datos por parte del usuario, desde la aplicación android. Para facilitar la
labor se ha optado por almacenar los datos en una base de datos MYSQL
(3) que consta de una serie de registros y tablas relacionadas que facilitan
la labor de gestión. La aplicación Java utilizada por el entrenador es la
encargada de gestionar la base de datos localmente, desde un pc con la
aplicación instalada. La base de datos está instalada en un servidor web,
apache (4), que recibe todas las consultas, las ejecuta, y envía de vuelta
los resultados. La aplicación del entrenador se conecta a la base de datos
haciendo uso de una librería específica, el conector mysql-connector-java-
5.1.17-bin-jar (5). Esta librería permite, de forma local, establecer una
conexión con la base de datos y gestionarla ejecutando consultas SQL. En
la ilustración 3 se muestra el esquema del entrenador mostrando las
tecnologías utilizadas.
Ilustración 3.Tecnología aplicación del entrenador.
7
La aplicación del usuario es una aplicación para terminales android
que realiza las consultas a la base de datos mediante peticiones http. En
las peticiones se especifica el tipo de consulta y todos los datos relativos a
esta. Para cada consulta se establecerá una conexión con el servidor, y se
cerrara al finalizar. A diferencia de la aplicación del entrenador, la
aplicación android establece una conexión independiente cada vez se
interacciona con la base de datos, ya que por su diseño, puede estar un
tiempo determinado sin interactuar con ella. En la conexión se especifica
el fichero PHP (6), que debe ejecutar el servidor web, donde se almacena
la consulta SQL, que variara dependiendo de los datos que se desee
consultar en ese momento. Para encapsular la respuesta del servidor se
utiliza la codificación JSON (7), que facilita la obtención de los datos y la
fácil interpretación de estos. La aplicación android además de recibir las
rutinas y ejercicios que la componen, dispone de una sección donde se
muestran imágenes y video del ejercicio. Las imágenes son descargadas
directamente utilizando la url donde se almacena. Para los videos se ha
optado por la implementación de la aplicación youtube, haciendo uso de
las apis proporcionadas por google. En la ilustración 4 se muestra el
esquema de la aplicación android junto con las tecnologías utilizadas.
8
Ilustración 4: Tecnología aplicación del usuario.
El escenario completo de la aplicación con las tecnologías utilizadas
se muestra en la ilustración 5.
Ilustración 5: Escenario de la aplicación con las tecnologías.
9
1.4 Estructura de la memoria.
La memoria consta de una serie de capítulos donde se desarrolla la
aplicación; desde el contexto donde surge, pasando por un desarrollo
técnico detallado y finalizando con las conclusiones. En los capítulos se
desarrollan los siguientes conceptos:
Introducción: se muestra el contexto donde aparece la aplicación,
los objetivos de esta, y las tecnologías en las que se apoya.
Entorno de desarrollo: Los programas y tecnologías utilizados para
el desarrollo de la aplicación.
Base de datos: En este capítulo se muestran tablas, registros y
relaciones de la base de datos, todos necesarios para un correcto
seguimiento de los ejercicios por parte del entrenador.
Entrenador: La aplicación java del entrenador, y su desarrollo
técnico.
Usuario: La aplicación android del usuario y su desarrollo técnico.
Anexos: donde se muestran aspectos relacionados con las
instalaciones de las herramientas necesarias y librerías adicionales.
11
2. Entorno de desarrollo.
Para el desarrollo del proyecto se han usado una gran diversidad de
herramientas, desde editores de texto orientados a la programación
(notepad ++), hasta base de datos para almacenar la información
necesaria para que el entrenador elabore sus rutinas. A continuación se
mencionan brevemente los programas utilizados, indicando su
funcionalidad e implementación.
2.1 Eclipse.
La plataforma Eclipse se define como un Entorno de Desarrollo
Integrado (IDE, Integrated Development Environment) abierto y
extensible. Eclipse sirve como IDE Java y cuenta con numerosas
herramientas de desarrollo de software. También da soporte a otros
lenguajes de programación, como son C/C++, Cobol, Fortran, PHP o
Python. A la plataforma base de Eclipse se le pueden añadir extensiones
(APIS) para extender la funcionalidad. En el caso que nos ocupa se han
utilizado las APIS de android transformando eclipse en una herramienta
apta para el desarrollo de la aplicación del usuario. El término Eclipse
además identifica a la comunidad de software libre para el desarrollo de la
plataforma Eclipse. Este trabajo se divide en proyectos que tienen el
objetivo de proporcionar una plataforma robusta, escalable y de calidad
para el desarrollo de software.
2.2 Servidor Apache.
Apache es un proyecto de código abierto y uso gratuito,
multiplataforma (hay versiones para todos los sistemas operativos más
importantes), muy robusto y que destaca por su seguridad y rendimiento.
Lo primero que debemos aclarar es que estamos hablando de software,
12
aunque el equipo donde se ejecuta recibe la misma denominación
(servidor). La función del servidor es la de aceptar las peticiones de
recursos, que provienen de los clientes que acceden, y gestionar su
entrega o denegación, de acuerdo a las políticas establecidas. Apache
dispone de un archivo donde se muestra todos los parámetros de
configuración que definen su comportamiento, el fichero httpd.conf. Entre
los parámetros que contiene el fichero, destacamos: La dirección IP y el
puerto, el timeout, el KeepAlive (para permitir más de una petición en una
misma conexión), AccessFileName.htaccess (fichero de configuración
auxiliar), log de errores, etc.
En este proyecto el servidor apache es el encargado de ejecutar las
consultas SQL que se realizan en la base de datos, tanto las provenientes
de la aplicación del entrenador, como las del usuario.
2.3 Base de datos MYSQL.
MySQL es un sistema de administración de bases de datos
(Database Management System, DBMS) para bases de datos relacionales.
Existen muchos tipos de bases de datos, desde un simple archivo
hasta sistemas relacionales orientados a objetos. MySQL, como base de
datos relacional, utiliza múltiples tablas para almacenar y organizar la
información. MySQL está desarrollada en C y C++ y destaca por su gran
adaptación a diferentes entornos de desarrollo, permitiendo su
interactuación con los lenguajes de programación más utilizados como
PHP y Java favoreciendo a su integración en multitud de sistemas
operativos.
También es muy destacable, la condición de open source de MySQL,
que hace que su utilización sea gratuita e incluso se pueda modificar con
total libertad, pudiendo descargar su código fuente. Esto ha favorecido
muy positivamente en su desarrollo y continuas actualizaciones, para
hacer de MySQL una de las herramientas más utilizadas por los
programadores orientados a Internet.
13
2.4 MYSQL Workbench.
MySQL Workbench es un software que permite modelar diagramas
de Entidad-Relación para bases de datos MySQL.
Con esta herramienta se puede elaborar una representación visual
de las tablas, vistas, procedimientos almacenados y claves foráneas de la
base de datos. Además, permite sincronizar el modelo en desarrollo con la
base de datos real, lo que facilita el diseño y la implementación. Se puede
realizar una ingeniería directa e ingeniería inversa para exportar e
importar el esquema de una base de datos ya existente. Para el desarrollo
de la aplicación, se ha diseñado la base de datos y se ha utilizado la
ingeniería inversa, para exportar la base de datos y hacerla accesible a la
herramienta PhpMyAdmin.
2.5 PhpMyAdmin.
PHP (acrónimo recursivo de PHP: Hypertext Preprocessor) es un
lenguaje de código abierto muy popular especialmente adecuado para el
desarrollo web. PHP se caracteriza porque el código es ejecutado en el
lado del servidor, generando una respuesta y enviándola al cliente. El
cliente recibirá el resultado de ejecutar el código (script PHP), sin conocer
como es este. Las características de PHP hacen posible la creación de
programas basados en scripts que se ejecutan en el servidor, entre ellos
destaca PhpMyAdmin, herramienta utilizada para gestionar base de datos.
La interfaz de phpMyAdmin está basada íntegramente en su
navegador, necesitará un servidor web (Apache en nuestro caso) en el que
instalar los archivos PHP y una base de datos MYSQL.
Para facilitar el proceso de instalación y configuración, existe una
aplicación Appserv que instala todos los componentes necesarios para su
inmediata puesta en marcha:
El servidor Apache.
14
PHP.
Una base de datos MYSQL.
PhpMyAdmin.
En la ilustración 6 se muestran los componentes del paquete AppServ.
Ilustración 6: Componentes de AppServ.7.
A continuación se muestra como interaccionan los distintos
componentes de AppServ, para gestionar desde PhpMyAdmin la base de
datos MySQL. EL proceso se muestra en la ilustración 7.
15
Ilustración 7: Gestión de la base de datos.
1. Desde el explorador web entramos en apache (localhost o 127.0.0.1) y
ejecutamos el script PHP de PhpMyAdmin.
2. Se requerirá una contraseña, que será solicitada durante la instalación
de la aplicación. Una vez introducida la contraseña, se mostrará en el
navegador la interfaz gráfica de PhpMyAdmin.
3. Desde la interfaz podemos gestionar la base de datos. Todas las
modificaciones realizadas llevan implícita una petición al servidor web.
4. Esta petición se materializa como la ejecución de un fichero PHP, con
las variables que la consulta SQL requiera.
5. Finalmente la consulta realizada desde PhpMyAdmin se ejecuta en la
base de datos.
La aplicación PhpMyAdmin se ha utilizado para gestionar la base de
datos y comprobar el correcto funcionamiento de las aplicaciones, java y
android durante su desarrollo.
16
2.6 Notepad ++.
Editor de texto orientado a la programación. Permite elegir entre
una gran cantidad de lenguajes de programación, facilitando su escritura.
Se ha utilizado para crear los ficheros php instalados en el servidor y para
crear los archivos HTML para comprobar el correcto funcionamiento de
estos.
17
3. Base de datos para el entrenamiento personal.
3.1 Base de datos MYSQL.
MYSQL es un sistema de administración de bases de datos. Si hay
algo que la diferencia sobre las demás, es que permite relacionar los
distintos elementos que componen la base de datos. Esta característica
conforma a MYSQL como un sistema flexible, intuitivo y de rápida
ejecución. Para definir las relaciones entre los elementos de la base de
datos, se define un motor de almacenamiento. La elección de uno u otro
permitirá crear una base de datos relacional, o no. Entre los motores que
implemente MYSQL destacan: MyISAM, Falcon, InnoDB, MySQL Cluster,
Federated, Archive, CSV, Blackhole, etc. Para la base de datos de la
aplicación se ha utilizado el motor InnoDB (8), que permite establecer las
relaciones requeridas. La elección del motor ha de hacerse de forma
manual en PhpMyAdmin, y se realiza de forma automática cuando
definimos relaciones en el diagrama EER de la base de datos, por lo que no
tenemos que preocuparnos por ello.
Los componentes de la base de datos MYSQL son las tablas. Son
elementos ordenados y compuestos de registros. Es en los registros donde
se introducen los valores que se desean almacenar en la base de datos. En
la ilustración 8 se muestra como ejemplo la tabla Músculos. Para crearla
hemos creado el diagrama EER en MYSQL workbech y lo hemos exportado
para manejarla con PhpMyAdmin. Se podría haber creado utilizando
PhpMyAdmin directamente, pero no es recomendable, ya que para casos
sencillos como este es relativamente fácil, pero para base de datos más
complejas se vuelve muy tedioso.
18
Ilustración 8: Exportación de la tabla Músculos.
La tabla de Músculos está compuesta por 3 columnas, y tiene 2
registros insertados (en este ejemplo). Estos registros pueden borrarse,
modificarse y consultarse, dependiendo de lo que la aplicación requiera,
en el caso de la aplicación del entrenador, se podrá realizar las tres
acciones y en el caso de la aplicación android solo se podrán consultar.
Para establecer las relaciones entre las tablas se tiene que definir al
menos una clave primaria o un índice en la tabla referenciada (la tabla con
la que queremos establecer una relación). Cuando se define una columna
como clave primaria, los valores de la columna son únicos, es decir, no
pueden repetirse en la tabla. Las relaciones se establecen con las foreign
keys (9). La relación se basa en que los valores que puede tomar una clave
primaria de una tabla, estarán condicionados por los valores definidos en
la clave primaria de la tabla con la que está relacionada. Estas relaciones
llevan implícitas una actualización (en nuestro caso en cascada) de los
registros, atendiendo a la modificación o la eliminación de la clave
19
primaria de una tabla, cuyo valor depende de la clave primaria de la tabla
referenciada. Aunque parece algo complejo, con un ejemplo quedará todo
más claro. Supongamos tres tablas definidas en la base de datos. La tabla
RutinasDeUsuarios, que tiene una dependencia con las tablas Rutinas y
Usuarios, como se muestra en la ilustración 9.
Ilustración 9: Relación entre tablas.
La tabla RutinasDeUsuarios tiene definidas dos claves primarias
(Id_Usuario y Id_Rutina) que dependen de los valores de las claves
primarias definidas en las tablas Usuarios (que toma el mismo nombre,
Id_Usuario) y Rutinas (Id_Rutinas), de tal forma que si existe algún registro
en la tabla RutinasDeUsuarios, y en la tabla de Usuarios o Rutinas se
elimina o modifica alguna de las claves primarias, provocará una
actualización en cascada de la tabla RutinasDeUsuarios. Por ejemplo:
supongamos que están definidas dos rutinas: la 1 y la 2, y en la tabla de
usuarios tenemos 3 usuarios, el 1 el 2 y el 3. El entrenador ha asignado la
rutina 2 al usuario 1. Si se produce alguna modificación en el Id de la
rutina 2 o en el Id del usuario 1, conllevará a la actualización automática
de la tabla RutinasDeUsuarios, reflejándose la modificación.
20
3.2 Especificaciones y requerimientos de la base de datos.
Las tablas y registros que componen la base de datos han sido
creadas atendiendo a las necesidades del entrenador personal para
diseñar un entrenamiento personalizado, que permita, un correcto
seguimiento de los ejercicios realizados por parte del usuario. En este
capítulo se detallan las tablas que conforman la base de datos y las
foreigns keys establecidas.
3.2.1 Usuarios.
La tabla de los usuarios incluye toda la información personal
necesaria para la correcta identificación del usuario, además, incluye el
estado de forma inicial, el deseado y el final, necesarios para que el
entrenador planifique el entrenamiento. También se incluye el password
para que el usuario pueda acceder al entrenamiento desde la aplicación
android. El Id_Usuario ha sido definido como auto incremental (no
tenemos que introducir el Id_Usuario por cada usuario nuevo, la acción se
realiza automáticamente incrementando en 1 el valor del Id_Usuario
anterior). En la ilustración 10 se muestra todas las columnas que
componen la tabla de usuarios.
21
Ilustración 10: Tabla Usuarios.
Se define una clave primaria Id_Usuario que servirá de referencia a
las tablas RutinasDeUsuarios y HistoricoRutinasDeUsuarios. También
dispondrá de tres Foreigns keys, los estados de forma, que tomarán
únicamente los valores indicados en la clave primaria de la tabla
EstadoForma.
Ilustración 11: Foreign Keys tabla Usuarios.
22
3.2.2 Estado de forma.
La tabla de estado de forma incluye los posibles estado de formas
definidos por el entrenador junto con su descripción. El entrenador hará
uso del estado de forma de los usuarios para la asignación de ejercicios y
rutinas
Ilustración 12: Tabla EstadoForma.
En la tabla EstadoForma está definida la clave primaria Id_EstForm
que sirve como referencia para los valores de estado de forma de la tabla
de usuarios: Id_est_forma_inicial, Id_est_forma_deseado e
Id_est_forma_final. No existen foreign keys en esta tabla.
3.2.3 Rutinas.
En la tabla de rutinas se definen las rutinas, junto con una
descripción introducida por el entrenador. A las rutinas definidas se
añadirán ejercicios en función de la finalidad de la rutina. Se define una
clave primaria, Id_Rutina, definida como auto incremental.
23
Ilustración 13: Tabla Rutinas.
Se define una clave primaria, Id_Rutina, que sirve como referencia a
las tablas RutinasDeUsuarios, HistoricoRutinasDeUsuarios y
EjerciciosDeRutinas. La tabla de rutinas no tiene ninguna foreign key
definida.
3.2.4 Rutinas de usuarios.
En esta tabla quedan reflejadas las rutinas que están ejercitando
cada usuario, hasta que el entrenador decida cambiarlas. Se definen dos
claves primarias: Id_Usuario e Id_Rutina.
Ilustración 14: Tabla RutinasDeUsuarios.
En la tabla RutinasDeUsuarios, se definen dos foreigns keys donde
se referencian las claves primarias Id_Rutina e Id_Usuario con las claves
primarias de las tablas Usuarios y Rutina (Id_Rutina e Id_Usuario).
24
Ilustración 15: Foreigns keys tabla RutinasDeUsuarios.
3.2.5 Histórico de Usuarios.
En esta tabla se detallan los resultados de las rutinas ejercitadas por
el usuario, que se envían a través del formulario en la aplicación android.
El Entrenador se servirá de estos resultados para planificar futuros
entrenamientos y rutinas. Se definen dos claves primarias: Id_Usuario e
Id_Rutina.
Ilustración 16: Tabla HistoricoRutinasDeUsuarios.
25
Se definen dos foreigns keys donde se referencian las dos claves
primarias Id_Usuario e Id_Rutina al Id_Usuario de la tabla de usuarios, y al
Id_Rutina de la tabla Rutinas.
Ilustración 17: Foreigns keys tabla HistoricoRutinasDeUsuarios.
3.2.6 Ejercicios.
En la tabla de ejercicios se define los ejercicios planificados por el
entrenador. Incluye el identificador de ejercicios, la descripción, la
finalidad y la duración. Id_Ejercicio ha sido definido como auto
incremental.
Ilustración 18: Tabla Ejercicios.
26
La tabla de ejercicios tiene la clave primaria Id_Ejercicio que sirve
como referencia a las tablas: EjerciciosDeRutinas, Tipos de Ejercicios,
UtilesDeEjercicios,RecomendacionesDeEjercicios,CaracteristicasDeEjercici-
os, PropiedadesDeEjercicios, MusculosDeEjercicios y RecursosDeEjercicios.
No hay ninguna foreign key en la tabla de ejercicios.
3.2.7 Ejercicios de rutinas.
En esta tabla se muestran los ejercicios asignados a las rutinas
definidas por el entrenador. El entrenador asigna ejercicios a una rutina en
función de la finalidad de esta. Id_Rutina e Id_Ejecicio son claves
primarias.
Ilustración 19: Tabla EjerciciosDeRutinas.
Se definen dos foreigns keys, donde las claves primarias toman
como referencia a las claves primarias definidas en la tabla Rutina
(Id_Rutina) y Ejercicio (Id_Ejercicio) respectivamente.
27
Ilustración 20: Tabla EjerciciosDeRutinas.
3.2.8 Tipos.
Esta tabla define el tipo de ejercicio junto con una descripción.
Varios ejercicios pueden pertenecer a un mismo tipo. Id_Tipo ha sido
definido como auto incremental.
Ilustración 21: Tabla Tipos.
Se define una clave primaria en la tabla Tipos, Id_Tipo, que sirve
como referencia a la tabla TiposDeEjercicios. No existe foreign key
definida en esta tabla.
28
3.2.9 Tipos de ejercicios.
En esta tabla se definen los ejercicios que pertenecen a un tipo
definido en la tabla Tipos.
Ilustración 22: Tabla TiposDeEjercicios.
Son dos las foreigns keys definidas, donde se referencian las claves
primarias a las claves primarias de las tablas Tipo (Id_tipo) y Ejercicios
(Id_Ejercicio).
Ilustración 23: Foreigns keys tabla TiposDeEjercicios.
29
3.2.10 Útiles.
En la tabla Útiles se definen los útiles ya definidos junto con una
descripción. Id_Util ha sido definido como auto incremental.
Ilustración 24: Tabla Útiles.
La tabla Útiles tiene definida una clave primaria, Id_Util, que sirve
como referencia a la tabla UtilesDeEjercicios. No se ha definido ninguna
foreign key en esta tabla.
3.2.11 Útiles de ejercicios.
En esta tabla se reflejan todos los ejercicios asignados a útiles, ya
definidos.
Ilustración 25: Tabla UtilesDeEjercicios.
30
Se han definido dos claves primarias en esta tabla: Id_Util e
Id_Ejercicio, que están referenciadas a las claves primarias de la tabla
Útiles y la tabla Ejercicios respectivamente.
Ilustración 26: Foreign keys UtilesDeEjercicios.
3.2.12 Recomendaciones de ejercicios.
En esta tabla se muestran recomendaciones para ejercicios ya
definidos en la base de datos. Id_Recomendacion ha sido definido como
auto incremental.
Ilustración 27: Tabla RecomendacionesDeEjercicios.
31
En esta tabla se definen dos foreigns keys, donde se referencian las
claves primarias Id_Recomendacion e Id_Ejercicio, con la clave primaria
de la tabla ejercicios, Id_Ejercicio.
Ilustración 28: Foreign key tabla RecomendacionesDeEjercicios.
3.2.13 Características de los ejercicios.
En esta tabla se muestran las características de los ejercicios ya
definidos junto con una descripción. Id_Caracteristica ha sido definido
como auto incremental.
Ilustración 29: Tabla CaracteristicasDeEjercicios.
32
En la tabla CaracteristicasDeEjercicios se definen dos claves
primarias: Id_Caracteristica y el Id_Ejercicio, que toma como referencia a
la clave primaria de la tabla Ejercicios, Id_Ejercicio.
Ilustración 30: Foreign key tabla CaracteristicasDeEjercicios.
3.2.14 Propiedades de ejercicios.
En esta tabla se muestran las propiedades de los ejercicios ya
definidos junto con una descripción. Id_Propiedad ha sido definido como
auto incremental.
Ilustración 31: Tabla PropiedadesDeEjercicios.
33
En la tabla PropiedadesDeEjercicios se definen dos claves primarias:
Id_Propiedades y el Id_Ejercicio, que toma como referencia a la clave
primaria de la tabla de Ejercicios, Id_Ejercicio
Ilustración 32: Foreign key tabla ProipiedadesDeEjercicios.
3.2.15 Músculos.
En esta tabla se definen los músculos que van a estar implicados
durante el desarrollo de los ejercicios. Junto al identificador y el nombre,
se añade una descripción del mismo. Id_Musculo ha sido definido como
auto incremental.
Ilustración 33: Tabla Músculos.
La tabla Músculos define una clave primaria, el Id_Musculo, que
sirve como referencia a la tabla MusculosDeEjercicios. No se define ningún
foreign key en esta tabla.
34
3.2.16 Músculos de ejercicios.
En esta tabla se reflejan los músculos implicados en un ejercicio ya
definido.
Ilustración 34: Tabla MusculosDeEjercicios.
En la tabla MusculosDeEjercicios se definen dos claves primarias:
Id_Ejercicio e Id_Musculo, que están referenciadas a las claves primarias
de las tablas Ejercicios y Músculos respectivamente.
Ilustración 35: Foreigns keys de la tabla MusculosDeEjercicios.
3.2.17 Recursos.
En la tabla de recursos se muestran todos los recursos referentes a
un ejercicio físico. Como recurso definimos en nuestra base de datos, a
35
videos e imágenes que ilustran un determinado ejercicio. La tabla de
recursos incluye una columna con el título del recurso, una descripción,
una url donde se alojará el video o la imagen, la duración (únicamente
utilizado en caso de que el recurso sea un video), la resolución y el tipo de
recurso, indispensable para poder diferenciar las imágenes (imag) y los
videos (video), para mostrarlos correctamente al usuario en la aplicación
android. Id_Recurso ha sido definido como auto incremental.
Ilustración 36: Tabla Recursos.
En la tabla de Recursos se define una clave primaria, Id_Recurso,
que sirve como referencia a la clave primaria Id_Recurso definida en la
tabla RecursosDeEjercicios. No se definen ninguna foreign key en esta
tabla.
3.2.18 Recursos de ejercicios.
En esta tabla se asignan recursos ya definidos en la tabla de
recursos, a ejercicios ya definidos en la tabla de ejercicios.
36
Ilustración 37: Tabla RecusrsosDeEjercicios.
En la tabla RecursosDeEjercicios se definen dos claves primarias:
Id_Ejercicio e Id_Recurso, que toman como referencia a las claves
primarias de las tablas Ejercicios y Recursos, Id_Ejercicio e Id_Recurso
respectivamente.
Ilustración 38: Foreigns keys tabla RecursosDeEjercicios.
3.3 Diagrama EER de la base de datos.
Para la creación del diagrama EER de la base de datos se ha utilizado
la herramienta MYSQL Workbench, con el que se han definido las claves
primarias y las foreigns keys ya explicadas. En el diagrama final se
muestran todas las tablas y las relaciones entre estas, además, se han
37
insertado algunos ejemplo para comprobar las relaciones y restricciones
impuestas. En la ilustración 39 se muestra la base de datos completa.
39
Para exportar el diagrama a la base de datos MYSQL utilizamos la
herramienta Fordwar Engineer dentro de las opciones de la base de datos.
Para realizar la exportación correctamente debemos indicar la ip donde
está el servidor apache que da soporte a la base de datos MYSQL, en
nuestro caso es local, por lo que la dirección IP será 127.0.0.1. En las
opciones de debemos marcar la opción de generar INSERT Stataments for
tables, para que una vez creada la base de datos, se inserten los registros
creados en el modelo EER. Posteriormente se generará el script SQL que
creará la base de datos y los registros (el script se incluye en el anexo). El
proceso de creación de la base de datos tiene dos partes:
La primera, donde se conecta a la base de datos utilizando la
contraseña y la IP del servidor apache.
La segunda, donde se ejecuta el script SQL que crea la base de
datos.
Al finalizar el proceso se muestra un mensaje donde refleja que los dos
procesos se han realizado correctamente, y que no se ha producido
ningún error. Podemos ver el log creado durante el proceso, donde se
muestran los fallos y las ejecuciones. En la ilustración 40 se refleja el final
del proceso.
Ilustración 40: Resultado ejecución diagrama EER.
40
3.4 Administración de la base de datos con PhpMyAdmin.
Una vez exportada la base de datos, procedemos a su gestión
mediante la herramienta PhpMyAdmin. Para acceder, en la barra del
navegador introducimos localhost o 127.0.0.1 para acceder al servidor
apache. Se mostrará una interfaz de la aplicación AppServ, donde
podremos seleccionar phpMyAdmin database manager. Para acceder
necesitamos introducir el usuario y la contraseña, ya definidos durante la
instalación de los programas. Una vez ejecutado, se muestra el entorno
gráfico de PhpMyAdmin. A la izquierda se selecciona la base de datos, en
nuestro caso personaltrainerdb, que consta de 18 tablas. Al seleccionar
una tabla podemos consultar su estructura y los registros insertados.
PhpMyAdmin permite realizar todas las operaciones que gráficamente
realizamos con mysql workbench; definición de tablas, establecer las
relaciones (hay que elegir el motor de almacenamiento innodb
manualmente), insertar registros, etc.
La herramienta PhpMyAdmin se ha utilizado durante el desarrollo
de la aplicación para controlar el correcto funcionamiento de las
aplicaciones del entrenador y del usuario, además de gestionar la base de
datos y de comprobar el correcto funcionamiento de ésta. A continuación
se muestra con un ejemplo como se ha utilizado la herramienta durante el
desarrollo del proyecto.
41
Ilustración 41: Consulta con PhpMyAdmin.
Supongamos que en la base de datos únicamente hay registrado un
usuario tal y como se muestra en la ilustración. La captura ha sido tomada
de la interfaz de PhpMyAdmin. Vamos a comprobar si la opción de agregar
un nuevo usuario de la aplicación java del entrenador funciona
correctamente. Para ello abrimos la aplicación del entrenador y pulsamos
la opción de añadir nuevo usuario, apareciendo una interfaz que nos invita
a introducir los datos del nuevo usuario. Los introducimos y pulsamos
continuar.
Ilustración 42: Añadir nuevo usuario.
42
Según lo programado, la operación ha debido realizarse con éxito.
Para comprobar su correcto funcionamiento, consultamos con
PhpMyAdmin los registros de la tabla Usuarios. En la ilustración 43 se
muestra como tras realizar la operación, en PhpMyAdmin ya se muestra el
nuevo usuario agregado, indicando que la operación se ha realizado con
éxito.
Ilustración 43: Consulta con PhpMyAdmin, usuario añadido.
43
4 Entrenador.
4.1 Objetivos y descripción de la aplicación java del entrenador.
La aplicación java del entrenador está basada en una interfaz gráfica
donde se presentan las opciones necesarias para que el entrenador realice
una gestión personalizada de los usuarios inscritos en el programa de
entrenamiento. La interfaz presenta dos secciones:
La sección de los usuarios, donde se muestran en una tabla los
usuarios y las rutinas definidas, además, se presentan una serie de
opciones como son: añadir nuevo usuario, eliminar usuario, asignar
rutina a usuario, consultar historial y mostrar las rutinas de un
usuario.
La sección de rutinas muestra las rutinas y los ejercicios ya
definidos, además de una serie de opciones que permiten la gestión
de las rutinas por parte del entrenador. Entre las opciones,
encontramos: definir una nueva rutina, añadir un ejercicio a una
rutina, eliminar un ejercicio de una rutina, eliminar una rutina y
consultar los ejercicios de una rutina ya definida.
La programación de la aplicación está dividida en 6 paquetes.
Primero, los paquetes que definen la interfaz gráfica de la aplicación, esto
son los paquetes com.InterfazMenu, donde se muestra el menú principal
de la aplicación, com.InterfazUsuario, donde se muestra la sección de los
usuarios y com.InterfazRutina, donde se muestra la sección de las rutinas.
En esto paquetes se diseña el entorno gráfico de la aplicación, y se
muestran los resultados obtenidos con las consultas SQL realizadas a la
base de datos.
El paquete com.Clases, donde se ejecutan todas las consultas SQL
que se realizan en la aplicación. Este paquete incluye una clase específica
para los usuarios y otra para las rutinas.
El paquete com.Conexion, donde se crea la conexión con la base de
datos haciendo uso del conector MSQL.
44
Se ha añadido además el paquete com.menuconsola, que permite
ejecutar la aplicación desde la consola, sin hacer uso de la interfaz gráfica.
En la ilustración 44 se muestra cómo interactúan las clases de los
paquetes para conseguir el correcto funcionamiento de la aplicación.
Ilustración 44: Funcionamiento aplicación del entrenador.
Desde la clase MenuPrincipal en los paquetes de la interfaz se
instancia una conexión, previamente configurada con los parámetros
necesarios para conectarse a la base de datos. Definida la conexión, se
instancia las clases Usuario y Rutina, desde las que realizaremos las
consultas a la base de datos. Una vez que se han obtenido los datos de la
base de datos, estos serán devueltos a las clases de la interfaz gráfica, que
mostrarán los resultados.
45
4.2 Diseño de la aplicación.
En este apartado se detallan las clases que constituyen la aplicación,
además, se mostrarán las instancias y relaciones con otras clases a través
de diagramas UML. Debido al gran número de clases, se mostrarán los
diagramas UML por secciones y funcionalidad.
La aplicación consta de 6 paquetes, ya explicados en el apartado
4.1. En la ilustración 45 se muestran los paquetes definidos.
Ilustración 45: Paquetes de la aplicación
Las clases están agrupadas atendiendo a su funcionalidad:
com. Conexión:
ConexionDB.
46
com.InterfazMenu:
MenuPrincipal.
com.InterfazUsuario:
GestorUsuarios.
AñadirNuevoUsuario.
AsignarRutinaAUsuario.
ConsultarHistorial.
EliminarUsuario.
HistorialDeUnUsuario.
MostrarRutinaDeUsuario.
RutinaAgregadaAUsuario.
RutinaOUsuarioNoDefinido.
RutinaYaAñadida.
TablaHistorialDeUsuarios.
TablaRutinasDeUsuario.
UsuarioAñadido.
UsuarioEliminado.
com.InterfazRutina:
GestorRutinas.
AñadirEjercicioARutina.
DefinirRutina.
EjercicioAñadido.
EjercicioEliminado.
EjerciciosDeRutina.
EjercicioYaAñadido.
EliminaEjercicioDeRutina.
EliminaRutina.
RutinaCreada.
47
RutinaEliminada.
RutinaOEjercicioNoDefinido.
TablaEjerciciosDeRutina.
com.Clases:
Usuario.
Rutina.
com.menuconsola:
menú.
4.2.1 Diagramas UML.
A continuación de mostraran los diagramas UML de las clases que
componen la aplicación java del entrenador. En los diagramas se muestran
las clases sin sus variables ni sus funciones, los diagramas completos se
incluyen en el DVD adjunto. Para facilitar la compresión se ha optado por
separar los diagramas atendiendo a la funcionalidad de las clases.
48
4.2.1.1 Menú principal, conexión y gestores de usuarios y rutinas.
En el menú principal de la aplicación se instancia una conexión que será la
que se pasará como parámetro a las clases GestorUsuarios y
GestorRutinas, para gestionar las rutinas y los usuarios de la base de
datos. Desde el menú principal se pueden elegir los dos menús de gestión:
el del usuario (GestorUsuarios) y el de las rutinas (GestorRutinas), que a
su vez incluyen distintas opciones de gestión. En la ilustración 46 se
muestra el diagrama UML de MenuPrincipal, conexión y los gestores.
Ilustración 46: Diagrama UML del menú principal, conexión y gestores
4.2.1.2 Gestor de usuarios.
Cada opción disponible en el gestor de usuarios, está definida por
una clase, que recogerá los datos de la interfaz y los tratará para realizar la
consulta. Las clases de la interfaz del usuario son:
GestorUsuarios.
AsignarRutinaAUsuario.
ConsultarHistorial.
EliminarUsuario.
MostrarRutinaDeUsuario.
AñadirNuevoUsuario.
49
En la ilustración 47 se muestra el diagrama UML de la clase
GestorUsuarios, junto con las clases que representan las opciones del
menú de usuarios.
Ilustración 47: Diagrama UML de la gestión de usuarios.
Una vez recogido los datos, se instancia la clase Usuario donde se
ejecutará la consulta. El diagrama UML con la clase usuario se muestra en
la ilustración 48.
Ilustración 48: Diagrama UML clase Usuario en la consulta.
50
Una vez realizada la consulta, los resultados obtenidos se
devolverán a la interfaz gráfica donde serán tratados y posteriormente
mostrados. Las clases que muestran los resultados de la consulta son:
UsuarioAñadido.
TablaHistorialDeUsuarios.
UsuarioEliminado.
TablaRutinasDeUsuario.
RutinaAgregadaAUsuario.
RutinaYaAñadida.
GestorUsuarios.
El diagrama UML con las clases de la interfaz que muestran los
resultados de la consulta se refleja en la ilustración 49
Ilustración 49: Diagrama UML clase Usuario en la respuesta.
51
4.2.1.3 Gestor de rutinas.
Cada opción disponible en el gestor de rutinas, está definida por una clase,
que recogerá los datos de la interfaz y los tratará para poder realizar la
consulta. Las clases de la interfaz de rutinas son:
AñadirEjercicioARutina.
DefinirRutina.
EliminarEjercicioDeRutina.
EliminaRutina.
EjerciciosDeRutina
Ilustración 50: Diagrama UML GestorRutinas.
Una vez recogidos los datos, se instancia la clase Rutina, donde se
ejecutará la consulta. El diagrama UML con la clase Rutina se muestra en
la ilustración 51.
52
Ilustración 51: Diagrama UML de la clase Rutina en la consulta.
Una vez realizada la consulta, los resultados obtenidos se
devolverán a la interfaz gráfica donde serán tratados y posteriormente
mostrados. Las clases que muestran los resultados de la consulta son:
EjercicioAñadido.
EjercicioEliminado
EjercicioYaAñadido
RutinaCreada.
RutinaEliminada.
RutinaOEjercicioNoDefinido.
TablaEjerciciosDeRutina.
GestorRutinas
El diagrama UML con las clases de la interfaz que muestran los
resultados de la consulta se refleja en la ilustración 52.
53
Ilustración 52: Diagrama UML de la clase Rutina en la respuesta.
Todos los diagramas UML se encuentran en el proyecto
PersonalTrainer que se incluye en el DVD adjunto.
4.3 Descripción y funcionalidad de las clases.
En este apartado se describirá todos los elementos que componen
las clases de la aplicación java del entrenador, incluyendo referencias a los
códigos incluidos en el DVD adjunto.
4.3.1 Importaciones.
54
Para el correcto funcionamiento de la aplicación del entrenador, es
necesario la utilización de clases que no se encuentran directamente
accesible mediante su instanciación y tenemos que importarlas. Las
importaciones realizadas en la programación java son:
java.sql.Connection: para crear la conexión con la base de datos.
java.sql.DriverManager: para agregar a la conexión los parámetros
necesarios para acceder a la base de datos.
java.sql.PreparedStatement: para agregar la consulta sql a la
conexión.
java.sql.ResultSet: donde se recogen los resultados de la consulta.
java.sql.SQLException: para capturar las excepciones SQL.
javax.swing.*: para la utilización de los componentes gráficos
proporcionados por swing.
java.awt.*: para la utilización de los componentes gráficos
proporcionados por awt.
java.awt.event.*: para capturar los eventos producidos por la
pulsación de botones.
4.3.2 Conexión con la base de datos.
4.3.2.1 ConexionDB.
La clase ConexionDB, única clase del paquete com.Conexion, es la
encargada de establecer la conexión con la base de datos MYSQL. Para
ello, hace uso del conector mysql-connector-java-5.1.17-bin-jar tal y como
se comentó en el apartado 1.3. Para la correcta creación de la conexión,
primero instanciamos la clase ConexionDB y posteriormente creamos una
conexión haciendo uso de los parámetros de la conexión y del conector
mysql. La clase ConexionDB consta de las siguientes funciones:
configurarConexion() : donde se definen los parámetros de la
conexión ( host, user, pass y dtbs) y se hace uso del conector para
crear una conexión con la base de datos.
55
creaInstancia(): para crear una instancia de la clase ConexionDB.
obtenerInstancia(): donde se devuelve la instancia si ya está creada,
o se crea una nueva.
cerrarConexion(): para cerrar la conexión.
devuelveConexion : para devolver la conexión creada.
4.3.3 Gestión de la base de datos.
De la gestión de la base de datos se encargan las clases Rutina y
Usuario, pertenecientes al paquete com.Clases.
4.3.3.1 Rutina.
La clase rutina se encarga de gestionar todas las consultas recibidas
desde el menú de rutinas (GestorRutinas). Recibe todos los parámetros
necesarios para la consulta, las ejecuta y devuelve los resultados. Los
parámetros de la consulta se reciben a través de la interfaz gráfica,
introducidos por el entrenador. Una vez recibidos los datos, la clase Rutina
ejecuta la consulta. Previamente comprueba si se cumplen los requisitos
necesarios para realizarla: si existe la rutina que se quiere consultar, si el
ejercicio que se quiere añadir a la rutina está definido, etc. Los requisitos
se detallarán a continuación, en la función donde se requieran. Una vez
realizada la consulta, la clase Rutina envía los resultados para ser
mostrados por la interfaz gráfica.
Las funciones de la clase Rutina han sido implementadas
atendiendo a la gestión de la base de datos que estas realizan. A
continuación se detallan las funciones:
mostrarRutinasYEjercicios(connection con): Esta función recibe de
MenuPrincipal la conexión, y consulta en la base de datos todas las
rutinas y ejercicios definidos. Los resultados son mostrados en una
tabla, en GestorRutinas, facilitando el trabajo al entrenador al estar
56
en todo momento a la vista. En la función se declara un string con la
sintaxis de la consulta, se prepara para ejecutarla vinculando la
consulta a la conexión. Finalmente se ejecuta, guardando el
resultado en un ResultSet que se enviará como parámetro a
GestorRutinas, mostrándolo este, en una tabla. Para los ejercicios la
metodología es la misma, mostrándose los ejercicios en una tabla
junto a las rutinas. Los resultados devueltos a la interfaz, son
obtenidos de las tablas rutinas y ejercicios.
añadirEjercicioARutina(Connection con, int Id_Rutina, int
Id_Ejercicio): La función añade un ejercicio definido y dado por
Id_Ejercicio, a una rutina definida, Id_Rutina. Previamente se
comprueba si tanto el ejercicio como la rutina están definidos. Si lo
están, se procede con la ejecución de la consulta. La manera de
preparar y ejecutar la consulta es similar a la función anterior: se
declara un string con la sintaxis de la consulta sql, se prepara la
consulta para utilizar la conexión obtenida como parámetro, y
finalmente se ejecuta. Dependiendo del resultado de la ejecución,
se mostrará en la interfaz un mensaje u otro, representado cada
uno con una clase. Si no se ha podido realizar la consulta, se
mostrará por la interfaz que la rutina o el ejercicio no están
definidos. Si la consulta se ha realizado correctamente se mostrará
por pantalla que el ejercicio ha sido añadido a la rutina. Los
resultados devueltos a la interfaz, son obtenidos de las tablas
rutinas, ejercicios y ejerciciosderutinas.
creaRutina(Connection con, String descripcion): Esta función define
una nueva rutina. Recibe como parámetro la conexión y la
descripción de la nueva rutina. Para ejecutar la consulta se sigue el
mismo mecanismo descrito hasta ahora: en un string se define la
sintaxis de la consulta, se prepara la consulta para ser ejecutada y
finalmente se ejecuta. Como resultado, se muestra por la interfaz
que la rutina se ha creado correctamente. Los resultados devueltos
a la interfaz, son obtenidos de la tabla rutinas
57
eliminaRutina(int Id_Rutina,Connection con) : esta función es la
encargada de eliminar la rutina indicada por el entrenador
(Id_Rutina). Previamente comprueba que la rutina introducida está
definida, para posteriormente ejecutar la consulta sql. El resultado
es mostrado por la interfaz utilizando la clase que convenga (si se ha
eliminado o si la rutina introducida no estaba definida). Los
resultados devueltos a la interfaz, son obtenidos de la tabla rutinas.
eliminaEjercicioDeRutina (int Id_Rutina,int Id_Ejercicio,Connection
con): esta función elimina un ejercicio de una rutina. Para ello debe
cumplirse la condición de que el ejercicio pertenezca a la rutina,
requisito que se comprueba antes de ejecutar la consulta. Una vez
comprobado se dispone a definir el string donde se almacena la
consulta, se prepara, y se ejecuta. El resultado se muestra por la
interfaz del entrenador. Los resultados devueltos a la interfaz, son
obtenidos de la tabla ejerciciosderutinas.
muestraEjerciciosDeRutina(int Id_Rutina,Connection con): muestra
todos los ejercicios asignados a una rutina. Primero comprueba que
la rutina (Id_Rutina) está definida. Posteriormente se prepara la
consulta y se ejecuta. El resultado se muestra en una tabla, si la
rutina está definida, o aparece un mensaje indicando que la rutina
indicada no está definida en la base de datos. Los resultados
devueltos a la interfaz, son obtenidos de las tablas rutinas y
ejerciciosderutina.
4.3.3.2 Usuario.
La clase Usuario se encarga de gestionar todas las consultas
relacionadas con los usuarios. Recibe todos los parámetros necesarios
para la consulta, las ejecuta y devuelve los resultados. Los parámetros de
la consulta se reciben a través de la interfaz gráfica, introducidos por el
entrenador. Una vez recibidos los datos, la clase Usuario ejecuta la
58
consulta. Previamente comprueba si se cumplen los requisitos necesarios
para realizarla: si existe el usuario que se quiere eliminar, si la rutina que
se quiere añadir al usuario está definida, etc. Los requisitos se detallarán a
continuación, en la función donde se requieran. Una vez realizada la
consulta, la clase Usuario envía los resultados para ser mostrados por la
interfaz gráfica. La clase Usuario consta de las siguientes funciones, cada
una de ellas definida para realizar una operación en la base de datos. A
continuación se detallan las funciones pertenecientes a la clase Usuario:
mostrarUsuariosYRutinas(Connection con): Esta función recibe de
MenuPrincipal la conexión, para después consultar en la base de
datos todos los usuarios y rutinas definidas. Los resultados son
mostrados en una tabla, en GestorUsuarios, facilitando el trabajo al
entrenador al estar en todo momento a la vista. En la función se
declara un string con la sintaxis de la consulta, se prepara para
ejecutarla, y finalmente se ejecuta, guardando el resultado en un
ResultSet que se enviará como parámetro a GestorUsuarios,
mostrándolo este, en una tabla. Para las rutinas la metodología es la
misma, mostrándose las rutinas en una tabla junto a los usuarios.
Los resultados devueltos a la interfaz, son obtenidos de las tablas
rutinas y usuarios.
insertaUsuario(String nom, String priape, String segape, int DNI, int
est_for_ini, int est_for_des, int est_for_fin, Connection con) :
introduce un nuevo usuario en la base de datos. Se sirve de los
parámetros introducidos por la interfaz, para rellenar los datos
personales necesarios para que el entrenador elabore un
entrenamiento específico, creando nuevas rutinas, o sirviéndose de
las que ya están definidas. En la función se define un string que
contiene la consulta sql, a la que posteriormente añadiremos los
parámetros recibidos en la función. Una vez preparada la consulta,
se ejecuta y se muestra por la interfaz un mensaje indicando si todo
ha ido correctamente. Los resultados devueltos a la interfaz, son
obtenidos de la tabla usuarios de la base de datos.
59
eliminaUsuario(int Id_Usuario,Connection con) : Elimina un usuario
definido en la base de datos. Previamente se comprueba si el
usuario, Id_Usuario, está en la base de datos. Una vez comprobado,
se ejecuta la consulta mostrándose por la interfaz un mensaje
indicando que se ha eliminado correctamente el usuario. Los
resultados devueltos a la interfaz, son obtenidos de la tabla
usuarios.
asignarRutina(Connection con, int Id_Usuario, int Id_Rutina) : En
esta función se asigna una rutina ( Id_Rutina) a un usuario
(Id_Usuario). Primero se comprueba si la rutina y el usuario están
definidos en la base de datos, y después comprobamos si la rutina
esta ya asignada al usuario. Una vez realizadas las comprobaciones,
se procede a definir un string donde se aloja la sintaxis de la
consulta sql, se prepara ligando la consulta con la conexión y
finalmente se ejecuta. Todos los posibles resultados de la ejecución
de asignarRutina se muestran por la interfaz una vez finalizada esta.
Los resultados devueltos a la interfaz, son obtenidos de las tablas
usuarios, rutinas y rutinasdeusuarios.
mostrarHistorialDeUsuarios(Connection con, int opcion, int
Id_Usuario): con esta función se muestra el historial de los usuarios.
En la interfaz se da la opción de mostrar el historial de todos los
usuarios, o el de uno concreto. Una vez ejecutada la consulta
,utilizando la metodología ya explicada anteriormente, se muestra
en una tabla en la interfaz. Los resultados que devuelve esta función
son obtenidos de la tabla Historicorutinasdeusuarios.
mostrarEjerciciosDeRutina(int Id_Rutina,Connection con): con esta
función se muestran todos los ejercicios pertenecientes a una
rutina. Primero se comprueba que la rutina introducida está
definida en la base de datos, para después ejecutar la consulta. Los
resultados devueltos por esta función, son obtenidos de las tablas
rutinas y ejerciciosderutinas.
60
4.3.4 Interfaz.
Las clases de la interfaz son las encargadas de recoger los datos
introducidos por el entrenador, pasarlos como parámetros a las clases que
se encargan de la gestión de la base de datos, la clase usuario y rutina, y
finalmente mostrar los resultados por pantalla. Todas las clases de la
interfaz tienen una estructura común: un gestor de diseño definido en
todo el marco de la clase, gridlayout, dividido en celdas. En las celdas del
gestor principal se podrán introducir paneles o elementos gráficos. Los
paneles introducidos incorporan su propio gestor de diseño que define la
disposición de los elementos que se van a incorporar en los paneles:
botones, cuadros de texto, etc. En el desarrollo de las clases, se expondrá
los gestores de diseño utilizados, así como todos los elementos que lo
componen. Las clases de la interfaz se agrupan en tres paquetes:
com.InterfazMenu, com.InterfazUsuario y com.InterfazRutina. Todas las
clases de la interfaz extenderán de la clase JFrame e implementaran
ActionListener, para capturar los eventos producidos por la pulsación de
botones.
4.3.4.1 Com.InterfazMenu.
En el paquete Com.InterfazMenu se encuentra la clase
MenuPrincipal, donde se muestran los dos menus de operación: gestión
de usuarios y gestión de rutinas.
4.3.4.1.1 MenuPrincipal
La clase MenuPrincipal es la encargada de crear la conexión que
utilizarán las clases usuario y rutina para mostrar los dos menús
representados por las clases GestorUsuario y GestorRutina. Presenta
como gestor principal un gridlayout, dividido en 4 celdas. Desde la clase
MenuPrincipal se instancia la clase Usuarios y Rutinas, para que al pulsar
61
el menú correspondiente se muestren los usuarios, rutinas y ejercicios
definidos en la base de datos.
Para la interfaz gráfica del menú principal se definen dos paneles:
P_Titulo y P_Salir y en ambos se incluyen como gestores de diseño,
flowlayout. En el panel P_Titulo se incluye el mensaje de bienvenida de la
aplicación, en forma de JLabel. En el panel P_Salir se incluye el botón de
salir, para salir de la aplicación. Se definen dos botones que darán paso a
los menú de usuarios y de rutinas: botonUsuarios y botonRutinas. Una vez
definidos todos los elementos, se añaden al gestor grafico principal:
primero el panel de título, después el botón de usuarios, el de rutina, y
finalmente el panel que incluye el botón salir. Se ha optado por no incluir
los botones de usuarios y rutinas en paneles independientes para que
estos ocupen toda la celda de la que disponen. En la ilustración 53 se
muestran como quedan distribuidos los componentes.
Ilustración 53: MenuPrincipal.
4.3.4.2 Com.InterfazUsuario.
En el paquete Com.InterfazUsuario se agrupan todas las clases que
constituyen la interfaz del menú de usuarios.
62
4.3.4.2.1 GestorUsuarios.
La clase GestorUsuarios es la encargada de mostrar los usuarios y
las rutinas definidas en la base de datos. Además muestra las opciones
disponibles para la gestión de los usuarios. Presenta como gestor principal
un gridlayout con 8 celdas. Desde la clase GestorUsuarios no se instancia
directamente la clase Usuario, sino que para las opciones dadas, se
requerirá la introducción de parámetros en una clase ‘’intermediaria’’ que
se encargará de recoger los parámetros introducidos en la interfaz y de
instanciar la clase Usuarios que ejecutará la consulta. Una vez ejecutada,
se muestra un mensaje con el resultado de la misma. En la ilustración 54
se puede ver cómo funciona la clase GestorUsuarios con un ejemplo.
Ilustración 54: Funcionamiento clase GestorUsuarios.
63
Para la interfaz gráfica de la clase GestorUsuarios se definen 3
paneles: Uno para el título de las tablas, otro para las tablas de usuarios y
de rutinas y otro para el botón salir. En el panel del botón salir se define el
gestor gráfico, flowlayout y en el resto gridlayout. En el panel para los
títulos de las tablas se añaden dos JLabel con el nombre de las tablas:
rutinas y usuarios. En el panel de las tablas se muestran los usuarios y
rutinas definidos en la base de datos. Las tablas se construyen con el
resultado que devuelve la clase usuario tras consultarlos. Se definen 5
botones que servirán para mostrar las posibles opciones para la gestión de
los usuarios: añadir nuevo usuario, eliminar usuario, asignar rutina a
usuario, consultar historial y mostrar las rutinas de un usuario. Una vez
definidos todos los componentes, se añaden al gestor gráfico principal en
orden: panel título de tablas, panel de tablas, los 5 botones con las
opciones y el panel con el botón salir. Para gestionar el pulsado de los
botones se hace uso de ActionListeners, haciendo uso de la función
actionPerformed, donde se identificará el botón pulsado, y se instanciará
la clase necesaria. La distribución de los componentes de la clase
GestorUsuarios se muestra en la ilustración 55.
Ilustración 55: GestorUsuarios.
64
4.3.4.2.2 AñadirNuevoUsuario.
La clase AñadirNuevoUsuario se encarga de recoger todos los datos
personales del nuevo usuario introducidos por el entrenador y de
instanciar la clase Usuario, a quien se le pasará todos los parámetros
recogidos para ejecutar la consulta sql. Presenta como gestor grafico un
gridlayout con 9 celdas, en las que se colocaran los distintos paneles
donde se definen los datos personales a introducir. Una vez ejecutada la
consulta se muestra un mensaje con el resultado.
Se definen 9 paneles donde se añadirán las Jlabel y los JTextField
necesarios para recopilar todos los datos requeridos por el entrenador. En
las Jlabel se indicará el dato que se requiere y en los JTextField será donde
se introducirán por parte del entrenador. Todos los paneles tendrán como
gestor grafico un gridlayout de 2 celdas, exceptuando el panel del título y
el de los botones atrás y continuar, que será un flowlayout. Para añadir el
usuario a la base de datos se rellenará el formulario y se pulsará el botón
continuar, mostrándose un mensaje con el resultado de la operación. En la
ilustración 56 se muestra la interfaz de la clase AñadirNuevoUsuario.
65
Ilustración 56: Clase AñadirNuevoUsuario
4.3.4.2.3 UsuarioAñadido.
La clase UsuarioAñadido muestra un mensaje donde se indica que el
usuario se ha añadido correctamente a la base de datos.
Para la interfaz gráfica de la clase UsuarioAñadido se define como
gestor de diseño principal un gridlayout con dos celdas donde se insertan
dos paneles: uno con el texto (Jlabel), y otro con el botón continuar, que
nos devuelve al menú principal.
66
Ilustración 57: Clase UsuarioAñadido.
4.3.4.2.4 AsignarRutinaAUsuario.
En esta clase se asigna una rutina a un usuario, ambos definidos en
la base de datos. Se introducen como parámetros el Id de la rutina y del
usuario, se instancia la clase usuario, a la que se le pasa los parámetros y
esta ejecuta la consulta SQL. El resultado de la consulta se muestra por
pantalla una vez ejecutada la operación.
Para la interfaz gráfica de la clase AsignarRutinaAUsuario, se definen
4 paneles: uno para el título, con un flowlayot como gestor gráfico, dos
paneles para introducir los Id del usuario y de la rutina, con gridlayout
como gestor, y un panel para los botones atrás y continuar, con flowlayout
como gestor gráfico. En los paneles para introducir el Id del usuario y la
rutina, se añaden una etiqueta para cada Id, y un cuadro de texto para
recoger los datos introducidos por el entrenador. Una vez introducidos los
datos y pulsado el botón continuar, se instancia la clase Usuario y se hace
uso de la función asignarRutina, donde se ejecuta la operación. En la
ilustración 58 se muestra la interfaz de la clase AsignarRutinaAUsuario.
67
Ilustración 58: Clase AsignarRutinaAUsuario.
4.3.4.2.5 RutinaAgregadaAUsuario.
La clase RutinaAgregadaAUsuario muestra el resultado de la
correcta ejecución al asignar una rutina a un usuario.
Para la interfaz gráfica se define como gestor principal un gridlayout
con dos celdas. Se definen dos paneles: uno con el texto que indica que la
resolución de la consulta SQL ha sido satisfactoria (Jlabel), y otro con el
botón continuar que vuelve al menú principal de la interfaz. Ambos
paneles tienen como gestor gráfico flowlayout.
Ilustración 59: Clase RutinaAgregadaAUsuario.
68
4.3.4.2.6 RutinaOUsuarioNoDefinido.
La clase RutinaAgregadaAUsuario muestra el resultado de la
ejecución al asignar una rutina a un usuario, cuando el usuario o la rutina
no están definidos en la base de datos
Se define como gestor principal un gridlayout con dos celdas. Se
definen dos paneles: uno con el texto que indica que la resolución de la
consulta SQL (Jlabel), y otro con el botón continuar que vuelve al menú
principal de la interfaz. Ambos paneles tienen como gestor gráfico
flowlayout.
Ilustración 60: Clase RutinaOUsuarioNoDefinido.
4.3.4.2.7 RutinaYaAñadida.
Muestra un mensaje indicando que el usuario ya está ejercitando la
rutina.
El gestor gráfico principal es un gridlayout dividido en dos celdas. En
la primera se inserta un panel con un JLabel con el mensaje: el usuario ya
está ejercitando la rutina. En la segunda se inserta el botón continuar que
devuelve a la pantalla del menú principal.
69
Ilustración 61: Clase RutinaYaAñadida.
4.3.4.2.8 EliminarUsuario
En esta clase se elimina un usuario definido en la base de datos. Se
introducen como parámetro el Id del usuario, se instancia la clase usuario,
a la que se le pasa los parámetros y esta ejecuta la consulta sql. El
resultado de la consulta se muestra por pantalla una vez ejecutada la
operación.
Se definen 3 paneles: uno para el titulo con flowlayout como gestor,
un panel para introducir el Id del usuario a eliminar en el que se inserta un
JLabel y un JTextField para capturar la id del usuario, y un panel para los
botones atrás y continuar, ambos con gridlayout como gestor.
Ilustración 62: Clase EliminarUsuario.
70
4.3.4.2.9 UsuarioEliminado.
La clase UsuarioEliminado muestra el mensaje confirmando que se
ha ejecutado correctamente la eliminación del usuario de la base de
datos.
Para la interfaz gráfica se designa como gestor principal un
gridlayout con 2 celdas: En la primera se inserta un panel que incluye un
JLabel con el mensaje usuario eliminado con éxito, pulse continuar, en la
segunda se inserta un panel con el botón continuar que nos llevará de
vuelta al menú principal.
Ilustración 63: Clase UsuarioEliminado.
4.3.4.2.10 ConsultaHistorial.
La clase ConsultaHistorial presenta dos opciones: consultar el
historial de todos los usuarios y consultar el historial de un usuario. Para
mostrar el historial de todos los usuarios, instancia la clase usuario donde
se ejecutará la consulta sql. Para consultar el historial de un usuario en
concreto, se instancia la clase HistorialDeUnUsuario, donde se introduce el
Id del usuario a consultar, se instancia la clase usuarios y se ejecuta la
sentencia. El resultado de la consulta se muestra en la clase
TablaHistoriualDeUsuarios.
71
Se define como gestor gráfico principal un gridlayout con 4 celdas,
donde se insertaran dos paneles y 2 botones: un panel para el título, con
un JLabel, otro panel para los botones atrás y continuar, y dos botones con
las opciones; todos los historiales o un solo historial.
Ilustración 64: Clase ConsultaHistorial.
4.3.4.2.11 HistorialDeUnUsuario.
La clase HistorialDeUnUsuario muestra una interfaz donde se recoge
el id del usuario a consultar. Se instancia la clase usuario a la que se le
pasa como parámetro el id, y este ejecuta la consulta.
Para la interfaz gráfica de la clase HistorialDeUnUsuario, se define
como gestor gráfico principal un gridlayout, con tres celdas: en la primera
se inserta un panel con un JLabel con el título, en la segunda se inserta un
segundo panel con un JLabel y un JTextField para introducir el id del
usuario a consultar, y en la tercera se inserta un panel que incluye los
botones atrás y continuar.
72
Ilustración 65: Clase HistorialDeUnUsuario.
4.3.4.2.12 TablaHistorialDeUsuarios.
En la TablaHistorialDeUsuarios se muestra el resultado de la
ejecución de la sentencia sql que consulta el historial de usuarios. La clase
Usuarios instancia la clase TablaHistorialDeUsuarios, y envía como
parámetro el resultado de la consulta que es mostrado en una tabla. En
TablaHistorialDeUsuarios se muestra el resultado tanto de todos los
historiales, como de un historial en concreto. EL entrenador consulta el
histórico de los usuarios para programar futuras rutinas y ejercicios.
Se define un gridlayout con dos celdas como gestor grafico principal.
En la primera se inserta un panel con la tabla de resultados. En la segunda
se inserta un panel con el botón continuar. El diseño de la clase permite
cambiar el orden de las tablas a gusto del entrenador
Ilustración 66: Clase TablaHistorialDeUsuarios.
73
4.3.4.2.13 MostrarRutinasDeUsuario.
La clase muestra las rutinas que actualmente está ejercitando un
usuario. Para ello recoge de la interfaz el id del usuario, instancia la clase
usuario a la que pasa los parámetros, y ejecuta la operación. Los
resultados se muestran en una tabla, en la clase TablaRutinasDeUsuario.
Se define como gestor grafico principal un gridlayout con 3 celdas.
En la primera se inserta un panel con un JLabel con el título, en la segunda
se inserta un panel con un JLabel y un JTextField para introducir el id del
usuario, y en la tercera celda se inserta un panel con los botones atrás y
continuar.
Ilustración 67: Clase MostrarRutinasDeUsuario.
4.3.4.2.14 TablaRutinasDeUsuarios.
En la clase TablaRutinasDEUsuarios se muestran los resultados de la
consulta realizada en la clase MostrarRutinasDeUsuario. Se muestran
todas las rutinas asignadas actualmente a los usuarios definidos en la base
de datos.
Para la interfaz gráfica de la clase TablaRutinasDeUsuarios, se
define un gridlayout con dos celdas como gestor grafico principal. En la
primera se inserta un panel con la tabla de resultados. En la segunda se
74
inserta un panel con el botón continuar. El diseño de la clase permite
cambiar el orden de las tablas a gusto del entrenador.
Ilustración 68: TablaRutinasDeusuarios.
4.3.4.3 Com.InterfazRutina.
4.3.4.3.1 GestorRutinas.
El funcionamiento es idéntico al explicado en la clase
GestorUsuarios. Es la encargada de mostrar los usuarios y los ejercicios
definidos en la base de datos. Además muestra las opciones disponibles
para la gestión de las rutinas. Presenta como gestor principal un gridlayout
con 8 celdas. Desde la clase GestorRutinas no se instancia directamente la
clase Rutina, sino que para las opciones dadas, se requerirá la
introducción de parámetros en una clase ‘’intermediaria’’ que se
encargará de recoger los parámetros introducidos en la interfaz y de
instanciar la clase Rutinas que ejecutará la consulta. Una vez ejecutada, se
muestra un mensaje con el resultado de la misma. En la ilustración 66 se
puede ver cómo funciona la clase GestorRutinas con un ejemplo.
75
Ilustración 69: Clase GestorRutinas.
En la clase GestorRutinas se definen 3 paneles: uno para el título de
las tablas, otro para las tablas de usuarios y de ejercicios, y otro para el
botón salir. En el panel del botón salir se define el gestor gráfico,
flowlayout y en el resto gridlayout. En el panel para los títulos de las tablas
se añaden dos JLabel con el nombre de las tablas: rutinas y usuarios. En el
panel de las tablas se muestran los usuarios y ejercicios definidos en la
base de datos. Las tablas se construyen con el resultado que devuelve la
clase Rutina tras consultarlos. Se definen 5 botones que servirán para
mostrar las posibles opciones para la gestión de las rutinas: definir nueva
rutina, añadir ejercicio a rutina, eliminar rutina, eliminar ejercicio de
rutina y ejercicios de rutina. Una vez definidos todos los componentes, se
añaden al gestor grafico principal en orden: panel título de tablas, panel
de tablas, los 5 botones con las opciones y el panel con el botón salir. Para
gestionar el pulsado de los botones se hace uso de ActionListeners,
haciendo uso de la función actionPerformed, donde se identificará el
76
botón pulsado, y se instanciará la clase necesaria. La distribución de los
componentes de la clase GestorUsuarios se muestra en la ilustración 70.
Ilustración 70: Clase GestorRutinas.
4.3.4.3.2 DefinirRutina.
La clase DefinirRutinas nos permite introducir la descripción de la
nueva rutina a definir. Recoge de la interfaz la descripción introducida por
el entrenador, instancia la clase Rutina, y ejecuta la función creaRutina,
utilizando la descripción como parámetro. Finalmente se instancia la clase
RutinaCreada indicando la correcta ejecución de la operación.
El gestor gráfico principal es un gridlayout de 3 celdas donde se
insertan 3 paneles: un panel para el título, con flowlayout como gestor, un
panel para introducir la descripción, con gridlayout de 2 celdas como
gestor, y un panel donde se añade el botón atrás que vuelve a la pantalla
anterior. Se muestra la interfaz en la ilustración 71.
77
Ilustración 71: Clase DefinirRutina.
4.3.4.3.3 RutinaCreada.
En esta clase se muestra el mensaje indicando que la rutina se ha
creado correctamente.
El gestor grafico principal es un gridlayout de 2 celdas, donde se
insertan 2 paneles; uno con el mensaje, en un JLabel, y otro con el botón
continuar, que devuelve al menú principal.
Ilustración 72: Clase RutinaCreada.
4.3.4.3.4 AñadirEjercicioARutina.
La clase AñadirEjercicioARutina permite añadir un ejercicio a una
rutina, ambos definidos en la base de datos. Para ello se comprueba
78
inicialmente si tanto el ejercicio como la rutina están definidos. Si lo están,
se comprueba que el ejercicio no esté ya añadido a la rutina. Una vez
ejecutada la operación, se muestra el mensaje con la resolución por
pantalla.
Se utiliza un gridlayout de 4 celdas como gestor gráfico principal
donde se insertan 4 paneles: un panel para el título con un JLabel, un
panel para introducir el id de la rutina, con un JLabel y un JTextField, un
panel para introducir el id del ejercicio a añadir, con un JLabel y un
JTextField, y finalmente un panel donde se insertan los botones atrás y
continuar. En la ilustración 73 se muestra como quedan dispuestos los
elementos.
Ilustración 73: Clase AñadirEjercicioARutina.
4.3.4.3.5 EjercicioAñadido.
La clase Rutina instancia esta clase cuando el ejercicio se ha añadido
correctamente a la rutina.
Se define como gestor gráfico principal un gridlayout de 2 celdas,
donde se insertan 2 paneles: el del mensaje, donde se inserta como
componente un JLabel con el mensaje, y el del botón continuar, donde se
añade un botón para volver al menú principal. La interfaz mostrada con la
clase EjercicioAñadido se muestra en la ilustración 74.
79
Ilustración 74: Clase EjercicioAñadido
4.3.4.3.6 EjercicioYaAñadido.
En esta clase se indica que el ejercicio que se quiere añadir a una
rutina ya ha sido agregado anteriormente. Es instanciada por la clase
Rutina cuando se comprueba que el ejercicio ya ha sido añadido
anteriormente.
Se define un gridlayout como gestor grafico principal, donde se
insertan dos paneles: uno para el mensaje, encapsulado en un JLabel, y
otro donde se inserta el botón continuar, que devuelve al menú principal
de la aplicación.
Ilustración 75: Clase EjercicioYaAñadido
4.3.4.3.7 RutinaOEjercicioNoDefinido.
80
La clase RutinaOEjercicioNoDefinido es instanciada por la clase
Rutina cuando la rutina o el ejercicio que se intenta añadir no están
definidos en la base de datos.
Se define un gridlayout como gestor grafico principal, donde se
insertan dos paneles: uno para el mensaje, encapsulado en un JLabel, y
otro donde se inserta el botón continuar, que devuelve al menú principal
de la aplicación.
Ilustración 76: Clase RutinaOEjercicioNoDefinido
4.3.4.3.8 EliminaRutina.
La clase EliminaRutina, instanciada en GestorRutina, presenta una
interfaz donde se introduce la rutina a eliminar, para posteriormente
instanciar la clase Rutina donde se ejecuta la operación. Como requisito, la
rutina a eliminar debe estar definida en la base de datos, de no ser así, se
mostrará un mensaje indicando que la rutina no está definida.
Se define como gestor grafico principal un gridlayout con 3 celdas,
donde se insertan 3 paneles: uno panel con el título, insertado en un
JLabel, otro donde se inserta un JLabel y un JTextField para introducir el id
de la rutina a eliminar, y finalmente otro panel donde se añaden los
botones continuar y atrás, que ejecutara la operación y volverá al menú
principal respectivamente. En la ilustración 77 se muestra la interfaz de la
clase.
81
Ilustración 77: Clase EliminaRutina.
4.3.4.3.9 RutinaEliminada.
En esta clase se muestra el resultado de la operación al eliminar una
rutina definida en la base de datos. Es instanciada por la clase Rutina.
Se define un gridlayout como gestor grafico principal, donde se
insertan dos paneles: uno para el mensaje, encapsulado en un JLabel, y
otro donde se inserta el botón continuar, que devuelve al menú principal
de la aplicación.
Ilustración 78: Clase RutinaEliminada.
82
4.3.4.3.10 EliminaEjercicioDeRutina.
En la clase EliminaEjercicioDeRutina, instanciada por la clase Rutina,
se procede a la eliminación de un ejercicio perteneciente a una rutina.
Previamente se comprueba que tanto la rutina como el ejercicio están
definidos en la base de datos, después, se comprueba que el ejercicio esta
añadido a la rutina. Una vez comprobado todo, se procede a la ejecución
de la consulta SQL y a mostrar el resultado de la operación por pantalla.
El gestor principal es un gridlayout de 4 celdas donde se insertan 4
paneles: en el primero se muestra una JLabel con el título, en el segundo
se inserta una JLabel y un JTextField para introducir el id de la rutina, en el
tercero se introduce el id del ejercicio, y el cuarto panel, utilizado para
mostrar los botones atrás y continuar. En la ilustración 79 se muestra la
distribución de los componentes en la clase EliminaEjercicioDeRutina.
Ilustración 79: Clase EliminaEjercicioDeRutina.
4.3.4.3.11 EjercicioEliminado.
En esta clase se muestra el resultado de la operación al eliminar un
ejercicio de una rutina, ambos definidos en la base de datos.
83
Se define un gridlayout como gestor grafico principal, donde se
insertan dos paneles: uno para el mensaje, encapsulado en un JLabel, y
otro donde se inserta el botón continuar, que devuelve al menú principal
de la aplicación. En la ilustración 80 se muestra la interfaz de la clase.
Ilustración 80: Clase EjercicioEliminado.
4.3.4.3.12 EjerciciosDeRutina.
En esta clase se introduce el id de la rutina que se desea consultar.
Una vez introducido, se instancia la clase Rutina y se ejecuta la función
mostrarEjerciciosDeRutina, utilizando como parámetro el id de la rutina.
La clase Rutina ejecuta la consulta y almacena los resultados.
Posteriormente instancia la clase TablaEjerciciosDeRutina, donde se
mostrara los ejercicios asociados a la rutina.
El gestor principal es un gridlayout de 3 celdas donde se insertan 3
paneles: en el primero se muestra una JLabel con el título, en el segundo
se inserta una JLabel y un JTextField para introducir el id de la rutina, y el
tercer panel, utilizado para mostrar los botones atrás y continuar. En la
siguiente ilustración se muestra la distribución de los componentes en la
clase EjerciciosDeRutinas
84
Ilustración 81: Clase EjerciciosDeRutina.
4.3.4.3.13 TablaEjerciciosDeRutina.
En la clase TablaEjerciciosDeRutina se muestran los resultados de la
consulta realizada en la clase EjerciciosDeRutina. Se muestran todos los
ejercicios asignados actualmente a la rutina.
Se define un gridlayout con dos celdas, como gestor grafico
principal. En la primera se inserta un panel con la tabla de resultados. En la
segunda se inserta un panel con el botón continuar. El diseño de la clase
permite cambiar el orden de las tablas a gusto del entrenador.
Ilustración 82: Clase TablaEjerciciosDeRutina.
85
5 Usuario.
5.1 Objetivos y descripción de la aplicación android del usuario.
La aplicación android del usuario presenta una interfaz donde se
muestran las rutinas y ejercicios que el entrenador ha asignado desde la
aplicación java. Para poder acceder al entrenamiento personalizado, se
realizará un login, para después consultar las rutinas propuestas. Las
rutinas se componen de ejercicios, todos con una descripción, duración y
finalidad, ilustrados mediante imágenes y videos. Las imágenes son
descargadas desde internet y almacenadas en la memoria interna del
dispositivo móvil. Para el visionado de los videos se ha implementado la
aplicación youtube (10)mediante las Apis proporcionadas por google.
La conexión entre la aplicación android y la base de datos se realiza
mediantes peticiones http, donde se incluirán los datos de la consulta y el
modulo php que debe ejecutar el servidor apache. El servidor encapsulará
la respuesta mediante la codificación JSON y será enviada de vuelta al
terminal android. En la aplicación android, se tratará la respuesta
atendiendo a los datos requeridos. En la ilustración 83 se muestra el
funcionamiento de la aplicación.
86
Ilustración 83: Funcionamiento aplicación android.
5.1.1 Funcionamiento del servidor y módulos php.
El servidor apache se encarga de recibir, ejecutar y responder a las
peticiones http que se realizan desde la aplicación android. En la petición
http se incluye la ruta del fichero php a ejecutar y los parámetros
necesarios.
Los ficheros php son módulos que se alojan en el directorio del
servidor, con una ruta definida. Para acceder a ellos solo es necesario
introducir la ruta en el navegador. Los ficheros php se encuentran dentro
de carpetas con el nombre de la función que realizan, además, se incluyen
los ficheros HTML oportunos para comprobar su correcto funcionamiento.
En el código de los ficheros php se incluye: las variables necesarias para
utilizar los parámetros que se mandan en la petición http, la conexión con
la base de datos, la consulta SQL a realizar, y el encapsulamiento de los
resultados con JSON. Para establecer la conexión se necesita la ip del
87
servidor, el usuario y la contraseña (estos parámetros están definidos en
los ficheros php). Una vez establecida la conexión se selecciona la base de
datos y se procede con la consulta. Todos los módulos php cierran la
conexión al final del archivo. A continuación se detallan los directorios de
la carpeta WWW del servidor y sus archivos:
Login: donde se encuentran los ficheros login.php y loginhtml.html.
En el fichero login.php se utilizan los parámetros password y usuario
para comprobar si el usuario que está utilizando la aplicación está
registrado en la base de datos. Se crea una conexión con la base de
datos y se comprueba si en la tabla de usuarios existe un usuario
con ese nombre y password. Posteriormente se confecciona la
respuesta, se utiliza una variable local logstatus a la que se le dará
un valor: ’’1’’ si el login es correcto (si hay un registro con los
parámetros indicados), o ‘’0’’ si no se ha encontrado ningún
registro. Finalmente se encapsula con JSON y es mandando de
vuelta al dispositivo donde será interpretada.
ConsultaIdUsuario: donde se encuentran los ficheros
consultaidusuario.php y consultaidusuariohtml.html. El fichero
consultaidusuario.php utiliza el nombre del usuario para consultar
el Id del usuario. Para ello crea una conexión con la base de datos y
consulta en la tabla Usuarios el id del usuario. Una vez obtenido el
id, se encapsula con JSON y se envía de nuevo a la aplicación
android.
ConsultaRutinasUsuario: contiene los ficheros consultarutinas.php y
consultarutinashtml.html. Este fichero hace uso del id del usuario
para comprobar todas las rutinas que están asignadas a este. En el
fichero se crea una conexión con la base de datos, se consulta en la
tabla rutinasdeusuarios para obtener las rutinas asignadas. El
resultado se codifica con JSON y se devuelve a la aplicación.
ConsultaDescripcionYEjercicios: con los ficheros
consultaejercicios.php y consultaejercicioshtml.html. Este fichero
utiliza el id de la rutina seleccionada para consultar de la tabla
rutinas, la descripción, y de la tabla ejerciciosderutinas los ejercicios
asociados a la rutina. Inicialmente crea una conexión con la base de
datos, después consulta la descripción de la rutina seleccionada y
88
finalmente los ejercicios. El resultado es almacenado en una
variable local del fichero y codificado con JSON.
ConsultaDescripcionEjercicio: contiene los ficheros
consultadescripcionejercicio.php y
consultadescripcionejerciciohtml.html. En este fichero se hace uso
del id del ejercicio seleccionado para consultar los datos que existen
en la tabla ejercicios: descripción, duración y finalidad. El resultado
es devuelto a la aplicación encapsulado con JSON.
ConsultaImagenes: donde se encuentran los ficheros
consultaidrecurso.php, consultaidrecursohtml.html,
consultaimagenes.php y consultaimageneshtml.html. Con el fichero
consultaidrecurso.php se utiliza el id del ejercicio seleccionado para
consultar el id de los recursos asignados a el ejercicio.
Posteriormente con el fichero consultaimagenes.php comprobamos
cual de esos recursos son imágenes. El parámetro que recibe el
fichero consultaimagenes.php es el tipo de recurso, en este caso
‘’imag’’ y el identificador del recurso.
ConsultaVideos: donde se encuentran los ficheros
consultaidrecurso.php, consultaidrecursohtml.html,
consultavideos.php y consultavideoshtml.html. Con el fichero
consultaidrecurso.php se utiliza el id del ejercicio seleccionado para
consultar el id de los recursos asignados a el ejercicio.
Posteriormente con el fichero consultavideos.php comprobamos
cual de esos recursos son videos, devolviendo el registro del video.
El parámetro que recibe el fichero consultavideos.php es el tipo de
recurso, en este caso ‘’video’’ y el identificador del recurso.
Formulario: donde se incluyen los archivos
compruebaHistoricoRutinasDeUsuarios.php, formulariohtml.html e
historicoRutinasDeUsuarios.php. En
compruebaHistoricoRutinasDeUsuarios.php se utilizan los
parámetros id_usuario e id_Rutina, para comprobar si existe el
histórico correspondiente. Para ello se crea una conexión y se
consulta en la tabla historicorutinasdeusuarios si existe un registro
con esos valores. El resultado es reflejado en la variable formulario,
que se envía de vuelta a la aplicación android encapsulada en
89
formato JSON. El fichero historicoRutinasDeUsuarios.php se ejecuta
una vez comprobado que no existe ningún registro con el id usuario
y el id rutina señalados anteriormente. En este módulo se definen
todas las variables necesarias para utilizar los parámetros enviados
en la petición http. Se crea una conexión con la base de datos, y se
insertan los datos del formulario en la tabla
historicorutinasdeusuarios. Se devuelve una variable indicando si se
ha realizado correctamente la operación
5.1.2 Json.
Json es una herramienta de codificación basada en el intercambio
de datos estructurados entre diferentes sistemas sobre protocolos de
nivel de aplicación, en el caso que nos ocupa http. Json define como se
deben encapsular los objetos para convertirlos en cadenas de texto con el
propósito de enviarlos a otras aplicaciones, y que estas, siguiendo el
protocolo de decodificación, puedan obtener los objetos requeridos.
En los ficheros php, los resultados son encapsulados con Json. El
flujo de datos se convierte en una cadena de caracteres, donde se
muestran los datos como si de una matriz se tratase. Para obtener los
datos, en la aplicación destino se definen JsonObject. Los distintos objetos
que componen la matriz están totalmente identificados, es aquí donde
radica la facilidad de trabajar con Json, solo con indicar el identificador del
objeto podemos almacenarlo en un JsonObject definido y manejarlo a
nuestro antojo. Cada elemento que compone la matriz puede a su vez
disponer de varios parámetros.
Json se presenta como una alternativa a XML (11)o SOAP (12).
Aplicaciones actuales como twiiter ya implementan Json, desechando las
clásicas técnicas de XML. En la ilustración 84 se muestra cómo funciona
Json.
90
Ilustración 84: Json con un elemento.
En la ilustración se muestra un ejemplo en el que se obtiene los
parámetros que conforman un ejercicio (obtenidos de la tabla ejercicios).
El servidor devuelve a la aplicación destino la respuesta encapsulada con
Json, cuyo formato es el de una matriz con un solo elemento que a su vez
se compone de 4 parámetros. El resultado es almacenado en el
JasonArray, jdataConsultaDesEjercicio. Para poder obtener el valor de los
parámetros se define un JsonObject, json_data, donde se almacena el
único objeto de la matriz.
json_data = jdataConsultaDesEjercicio.getJSONObject(0);
Una vez almacenado el objeto, se dispone a obtener los parámetros
que se requieran, en este caso son string que se almacenarán en variables
definidas: descripcionEjercicio, duracionEjercicio y finalidadEjercicio. Para
obtenerlos solo tenemos que utilizar el identificador:
descripcionEjercicio =json_data.getString("Descripcion"); duracionEjercicio =json_data.getString("Duracion"); finalidadEjercicio =json_data.getString("Finalidad");
91
Ahora ya tenemos accesibles en variable locales los datos obtenidos
de la cadena de caracteres Json.
En la ilustración 85 se muestra un ejemplo con una matriz con más
de un objeto, es el caso de la obtención de los recursos de los que dispone
un ejercicio, obtenidos de la tabla recursos. Su tratamiento es el mismo,
solo que en este caso obtendremos los objetos uno a uno. De cada objeto
obtendremos los parámetros que se necesiten utilizando la metodología
explicada en el ejemplo anterior. En este caso, de cada objeto vamos a
obtener el id del recurso y vamos a guardarlos en una tabla
Id_Recurso_int[].
Ilustración 85: Json con 3 elementos.
92
5.1.2.1 Json vs XML
La utilización de tecnologías para el intercambio de datos entre
servicios web u otras arquitecturas de software está sufriendo un debate
de opiniones entre, la utilizada desde los inicios de la implementación de
servicios web, XML y una nueva herramienta que sin duda esta
predestinada a sustituirla en un futuro no muy lejano, JSON.
Una de las grandes ventajas de JSON sobre XML como formato de
intercambio de datos se trata de que escribir un analizador
sintáctico mediante JSON es mucho más sencillo que utilizando XML,
además de procesarse más rápido. Son 5 las razones principales por las
que JSON está dejando en desuso a XML:
JSON soporta dos tipos de estructuras, una de ellas son objetos que
contienen una colección de pares llave-valor y el otro tipo se trata
de arrays de valores. Esto proporciona una gran sencillez en las
estructuras.
JSON no tiene espacios de nombres, cada objeto es un conjunto de
claves independientes de cualquier otro objeto.
JSON no necesita ser extensible porque es flexible por sí solo. Puede
representar cualquier estructura de datos pudiendo añadir nuevos
campos con total facilidad.
JSON es mucho más simple que XML.
JSON es optimista y no requiere de este tipo de tecnologías, confía
en el desarrollador(es el encargado de tratar y procesar la
respuesta).
En resumen JSON es el mecanismo empleado en entornos web
donde el flujo de los datos es alto entre el cliente y el servidor, y donde los
tiempos de procesamiento de los datos son de vital importancia.
93
5.2 Diseño de la aplicación.
La aplicación está compuesta por una interfaz que recoge los datos
del usuario y realiza las consultas a la base de datos. La interfaz esta
implementada mediante clases que extienden de la clase Activity. Las
activities representan en android una interfaz donde podemos mostrar
todos los elementos gráficos que queramos: botones, cuadros de texto,
imágenes, mapa de bits, videos, etc. Por lo tanto, todas las clases que
implementen la interfaz deben heredar la clase Activity.
En android, a diferencia de java, el diseño de la interfaz no está
ligado a la programación en sí, el diseño se realiza en un archivo XML,
donde se implementara el aspecto que tendrá la activity. Los archivos XML
se alojan en la carpeta res (concretamente en las carpetas layout-land y
layout-port), donde se encuentran tantos los archivos de la interfaz
cuando el dispositivo está orientado verticalmente, como cuando está
orientado horizontalmente. Para trabajar con los elementos gráficos
añadidos en los archivos XML, se referencian en la clase java a través de la
clase R.java, que se crea automáticamente y se actualiza a medida que
creamos nuevos elementos gráficos.
Además de extender la clase activity, la mayor parte de las clases
implementan OnCLickListener para capturar los eventos relacionados con
el pulsado de un botón. Para gestionar el pulsado, se hace uso de la
función OnClick (view v), donde v es la fuente de pulsado (muy útil cuando
hay varios botones en la interfaz).
A diferencia de la aplicación java del entrenador, para pasar de una
pantalla de la interfaz a otra no se instancia la clase de la interfaz a
mostrar, se utiliza la clase intent. La clase intent permite cambiar de una
actividad a otra, para ello, únicamente tenemos que indicar la activity que
se está ejecutando actualmente, y la clase que queremos mostrar. La
sintaxis genérica es la siguiente:
Intent i=newIntent(Activity_actual.this,Activity_a_la_que_pasamos.class); i.putExtra("etiqueta datos",datos); startActivity(i);
94
En la primera sentencia, definimos el intent, con la clase actual y la
clase a la que queremos dar paso (ambas tienen que extender de activity).
Con la función putExtra, pasamos datos entre activities. Datos es una
variable de la activity actual y etiqueta datos es un identificador, para
facilitar la obtención en la segunda activity. Finalmente damos paso a la
nueva actividad con startActivity. Una vez en marcha la ejecución de la
nueva activity, para obtener los datos del intent utilizamos la sentencia:
Bundle extras = getIntent().getExtras();
String datos = extras.getString("user");
Guardamos los datos que venían junto con el intent en una variable
Bundle, para después obtener los distintos parámetros y guardarlos en
variable locales a la activity, en este caso es un String, de ahí la utilización
de la función getString. Las aplicaciones android permiten el manejo de hilos mediante la
clase Asynctask. En la clase se ejecuta todo el código contenido en uno o
varios hilos secundarios, evitando así que el hilo principal se detenga a
causa de tareas laboriosas, fallos en funciones o procesos que duren más
de lo normal. En la aplicación android del usuario, se utilizara esta clase
para realizar las consultas en la base de datos. Las consultas no tardan un
tiempo definido, y ejecutarlas en el hilo principal de la aplicación puede
conllevar a un mal funcionamiento de este. Asynctask se caracteriza por
tener una serie de funciones ya definidas. Las más importantes y las que
utilizaremos en la aplicación son:
onPreExecute(): Donde se preparan las variables donde se van a
guardar los resultados. En nuestra aplicación lo utilizamos para
mostrar el mensaje de consulta. En esta función aún estamos en el
hilo principal del programa.
doInBackground(String[]params): A partir de este punto, la
ejecución del código pasa a un hilo secundario, dejando el hilo
principal en stand by hasta que se ejecute toda la función.
onPostExecute(String resultado): En esta función volvemos de
nuevo al hilo principal, pudiendo utilizar los resultados obtenidos en
el hilo secundario.
95
En la ilustración 86 se muestra cómo funciona la clase Asynctask.
En resumen, la mayor parte de las clases siguen una estructura con
los elementos descritos:
Extienden de la clase Activity.
Implementan OnClickListener(para detectar el pulsado de los
botones).
Hacen uso de la clase Intent.
Utilizan hilos secundarios (Clase Asynctask).
En la aplicación existen clases que no siguen la estructura descrita:
imagen_i, video_i, entre otras, que se detallaran cuando lleguemos al
apartado correspondiente, pero la mayor parte de las clases siguen el
patrón descrito.
Ilustración 86: Funcionamiento de la clase Asynctask.
96
5.2.1 Android Manifiest.
El AndroidManifiest es un archivo XML donde se especifican todos
los aspectos técnicos relacionados con la aplicación, junto con todas las
activities que la componen. Entre los aspectos que se reflejan se
encuentran:
XML versión : 1.0
Codificación: utf-8.
La versión del código : 1.0.
La imagen de la aplicación.
La etiqueta de la aplicación ( Personal Trainer).
La versión mínima del SDK para ejecutar el programa: 8.
Los permisos necesarios: Internet y vibración.
Además debemos incluir en el manifiest, todas las activities que
conforman la interfaz, junto con la etiqueta (la misma en todas, Personal
Trainer) y con el tipo de intent que incluyen. Es muy importante conocer
los tipos de intent que se pueden utilizar. Para la interfaz inicial
(Login.java) he designado un intent launcher(al instalar la aplicación se
genera un icono por cada intent launcher, de ahí que solo deba existir
uno), pues es donde debe comenzar la aplicación, mientras que para el
resto se han definido los intent como default.
5.2.2 Diagramas UML.
La organización de las clases se ha hecho atendiendo a su
funcionalidad. Se han definido dos paquetes:
consulta_db_personaltrainerdb, que contiene la clase encargada de enviar
la petición http y procesar el resultado, y personal_trainer, compuesto por
todas las activities encargadas de la interfaz gráfica de la aplicación.
97
Ilustración 87: Paquetes de la aplicación android.
consulta_db_personaltrainerdb:
ConsultaDB.
Personal_trainer:
Login.
Bienvenida.
MuestraRutinas.
Rutina_i.
Ejercicio_i.
Imágenes_ejercicio_i.
Videos_ejercicio_i.
Formulario
Imagen_i
Video_i
A continuación se muestran los diagramas UML de las clases que
componen la aplicación android. En los diagramas donde las clases
contienen un gran número de funciones y variables, se ha optado, para
mayor claridad, por representar las clases únicamente por su nombre y
paquete al que pertenece. En el DVD del proyecto se incluyen todos los
diagramas UML completos.
98
5.2.2.1 ConsultaDB.
La clase ConsultaDB es la encargada de preparar la petición http,
enviarla y procesar la respuesta. Todas las clases que necesitan consultar
la base de datos instancian esta clase pasándole los parámetros
correspondientes. ConsultaDB devuelve la respuesta encapsulada en un
JSONArray que la clase procesará dependiendo del caso.
Ilustración 88: ConsultaDB.
5.2.2.2 Login.
En la clase login se presenta una interfaz donde el usuario debe
ingresar el nombre y el password, para comprobar que está registrado en
la base de datos. Para realizar la consulta se instancia la clase ConsultaDB,
que utilizará los parámetros usuario, password y url del fichero php a
ejecutar en el servidor, para enviar la petición http. El proceso de consulta
se realizara en un hilo secundario definido por la clase asynlogin que
extiende de asynctask
99
Ilustración 89: Diagrama UML de la clase Login.
5.2.2.3 Bienvenida.
La clase Bienvenida presenta una interfaz resultado del correcto
login por parte del usuario. Se muestra el nombre del usuario y se muestra
el botón para consultar las rutinas. En esta activity no se realiza ninguna
consulta ni se instancia clase alguna.
Ilustración 90: Diagrama UML de la clase Bienvenida.
100
5.2.2.4 MuestraRutinas.
La clase MuestraRutinas muestra las rutinas que el entrenado ha
asignado al usuario. Para ello hace uso de la clase ConsultaDB para realizar
dos consultas: el id del usuario, de la tabla Usuarios, para posteriormente
consultar las rutinas asociadas a ese usuario en la tabla RutinasDeUsuarios
(utilizando para la consulta el id del usuario obtenido antes). Tras realizar
la consulta se muestran las rutinas asignadas, si las hubiese. Las consultas
se ejecutaran en hilos secundarios generados por las clases
asyncIdUsuario y AsyncRutina, donde se consultan el id del usuario y las
rutinas respectivamente
Ilustración 91: Diagrama de la clase MuestraRutinas.
5.2.2.5 Rutina_i.
En la clase Rutina_i se consulta en la base de datos los ejercicios
asignados a la rutina pulsada. Para ello se instancia la clase ConsultaDB y
se crea la clase asyncEjercicios, donde se desarrollará todo el proceso de
la consulta. Se incluye un botón para iniciar un formulario, que será
enviado a la base de datos y consultado posteriormente por el
entrenador. Los datos mostrados en esta clase se obtienen de la tabla
ejercicios.
101
Ilustración 92: Diagrama UML de la clase Rutina_i.
5.2.2.6 Formulario.
La clase Formulario muestra una interfaz, donde el usuario tiene
que rellenar una serie de apartados para la futura evaluación por parte del
entrenador. Se instancia la clase ConsultaDB, con la que se enviará la
petición http. Todo el proceso de la consulta se realiza en un hilo
secundario generado por la clase asyncEnviarFormulario, donde primero
se comprueba si ya se ha enviado anteriormente el formulario. La consulta
para comprobar si se ha enviado anteriormente se realiza en la tabla
HistoricoRutinasDeUsuarios.
Ilustración 93: Diagrama UML de la clase Formulario.
102
5.2.2.7 Ejercicio_i.
La clase Ejercicio_i, muestra las características del ejercicio
seleccionado: el nombre, duración y finalidad. También se muestra dos
botones para consultar videos e imágenes. Para consultar los datos del
ejercicio se instancia la clase ConsultaDB. Todo el proceso de consulta se
realizará en un hilo secundario creado por la clase asyncEjercicios, que
extiende a asynctask. Los datos obtenidos en esta activity se obtienen de
la tabla ejercicios.
Ilustración 94: Diagrama UML de la clase Ejercicio_i.
5.2.2.8 Imagenes_ejercicio_i.
En la clase Imagenes_ejercicio_i, se muestran las imágenes
correspondientes al ejercicio pulsado. La consulta se realiza instanciando
la clase ConsultaDB. El proceso se realiza en un hilo secundario generado
por la clase asyncImagenes, que extiende de la clase AsyncTask. Los
resultados mostrados en esta clase son el resultado de la consulta de la
tabla recursosdeejercicios y recursos.
103
Ilustración 95: Diagrama UML de la clase Imagenes_ejercicio_i.
5.2.2.9 Imagen_i.
La clase Imagen_i muestra la imagen seleccionada en la activity
anterior. La imagen es descargada desde internet y debe ser decodificada
para mostrarla en la interfaz. El proceso de decodificación se realiza en la
clase asyncDecodificaImagen, en un hilo secundario.
Ilustración 96: Diagrama UML de la clase imagen_i.
5.2.2.10 Videos_ejercicio_i.
En la clase videos_ejercicio_i, se muestran los videos correspondientes al
ejercicio pulsado. La consulta se realiza instanciando la clase ConsultaDB.
El proceso se realiza en un hilo secundario generado por la clase
asyncVideos, que extiende de la clase AsyncTask. Los resultados
mostrados en esta clase son el resultado de la consulta de la tabla
recursosdeejercicios y recursos.
104
Ilustración 97: Diagrama UML de la clase Videos_ejercicio_i.
5.2.2.10 Video _i.
La clase Video_i hace uso de las Apis de youtube y de la url para
mostrar en el reproductor youtube el video seleccionado.
Ilustración 98: Diagrama UML de la clase Video_i.
5.3 Descripción y funcionalidad de las clases.
5.3.2 Importaciones.
Para el correcto funcionamiento de la aplicación del usuario, es
necesario la utilización de clases y componentes que no se encuentran
105
directamente accesible mediante su instanciación y tenemos que
importarlas. Las importaciones realizadas en la programación android son:
java.io.BufferedReader: para tratar la información devuelta por el
servidor.
java.io.InputStream: para tratar la información devuelta por el
servidor.
java.io.InputStreamReader: para tratar la información devuelta por
el servidor.
java.util.ArrayList : para tratar la lista de NamesValuePair.
org.apache.http.HttpEntity: para obtener la entidad de la respuesta
dada por el servidor.
org.apache.http.HttpResponse: donde se guarda el resultado de una
consulta al servidor apache.
org.apache.http.NameValuePair : variable que permite almacenar
valores por pares.
org.apache.http.client.HttpClient: variable a la que se añaden todos
los parámetros de la consulta, para su posterior ejecución.
org.apache.http.client.entity.UrlEncodedFormEntity: para preparar
los parámetros que se necesitan para la consulta, entre ellos la url
del fichero php.
org.apache.http.client.methods.HttpPost: es la variable que ejecuta
la consulta al servidor (se utiliza el mensaje POST).
org.json.JSONArray: donde se almacena el resultado del servidor,
encapsulado en codificación JSON.
org.json.JSONException: permite capturar las excepciones
relacionadas con el almacenamiento de la respuesta en un
JSONArray.
org.json.JSONObject : para obtener los objetos JSON de JSONArray.
android.util.Log: para mostrar logs.
android.app.Activity : permite la utilización de elementos gráficos
en una clase.
android.app.ProgressDialog: utilizado en la clase AsyncTask,
muestra un mensaje por pantalla indicando el proceso en ejecución
106
android.content.Intent: permite el paso de una activity a otra.
Además facilita el intercambio de parámetros entre activities.
android.os.AsyncTask: es una clase que ejecuta procesos
secundarios fuera del hilo principal, en hilos creado por la propia
clase.
android.os.Bundle: variable donde se almacenan los parámetros
pasados entre activities.
android.os.SystemClock: permite que la aplicación este un tiempo
ficticio ejecutando un proceso (en la aplicación android se ha
utilizado para que las consultas tarden más tiempo en ejecutarse, ya
que al trabajar en modo local, son prácticamente instantáneas).
android.view.View.OnClickListener: los listener son utilizados para
capturar las pulsaciones de los botones.
android.widget.Button: para implementar los botones añadidos en
el archivo XML.
android.widget.TextView; para implementar los TextView añadidos
en el archivo XML
org.apache.http.NameValuePair: variable utilizada para añadir los
parámetros necesarios para la consulta a la base de datos. Se
agrupan en pares, el nombre y la variable. El nombre será utilizado
para extraer los datos necesarios en el servidor.
android.os.Vibrator: Utilizado para que el dispositivo android vibre.
android.content.Context: necesario para la utilización de la vibración.
android.content.Intent: variable utilizada para la sucesión entre activities y el paso de parámetros entre ellas.
org.apache.http.message.BasicNameValuePair: para agregar nuevos
pares de valores.
android.widget.Toast: para mostrar mensajes por pantalla.
java.io.IOException; para capturar las excepciones provocadas por
los procesos de entra y salida del sistema.
java.net.MalformedURLException; para capturar las excepciones
relacionadas con el mal funcionamiento de la URL de imagines.
java.net.URL : para tratar con la URL obtenida de la base de datos.
107
android.graphics.Bitmap: para el tratamiento del mapa de bits de la
imagen.
android.graphics.BitmapFactory: para decodificar la imagen
obtenida.
com.google.android.youtube.player.YouTubeBaseActivity: clase necesaria para la utilización de la aplicación youtube.
com.google.android.youtube.player.YouTubeInitializationResult: para inicializar la aplicación youtube.
com.google.android.youtube.player.YouTubePlayer; reproductor youtube.
com.google.android.youtube.player.YouTubePlayerView: visor del reproductor youtube.
com.google.android.youtube.player.YouTubePlayer.Provider;
5.3.2 Petición HTTP.
5.3.2.1 ConsultaDB.
La clase ConsultaDB se encarga de preparar, ejecutar y tratar los
resultados de la consulta a la base de datos. Son dos los parámetros que
se utilizan en la clase: la url del fichero php a ejecutar, y un ArrayList de
NameValuePair, donde se almacenan todos los pares de parámetros
necesarios para la consulta. En la clase se incluyen 3 funciones que
realizan las tareas de preparación y ejecución de la consulta, obtención de
los datos, y finalmente introducir los datos en un JSONArray, para facilitar
la posterior obtención de los datos necesarios con un JSONObject.
Las funciones definidas en la clase ConsultaDB son:
getserverdata(ArrayList<NameValuePair> parameters2, String
urlwebserver2 ) : donde se hace uso de los parámetros recibidos y
de la url del fichero php para enviar el mensaje http al servidor.
Para ello se utilizan las funciones httppostconnect, getpostresponse
y getjsonarray. httppostconnect(ArrayList<NameValuePair> parámetros, String
urlwebserver): En esta función se prepara la consulta con los dos
108
parámetros recibidos, se ejecuta mediante una variable POST y
finalmente se almacenan los resultados en un InputStream.
getpostresponse() : En esta función se trata la respuesta
almacenada en el InputStream. Para ello se van leyendo y
almacenando uno a uno los caracteres, hasta que se llega al final de
los datos. Una vez finalizado los datos se convierten en una cadena
de texto y guardados en una variable.
getjsonarray() : Se convierte la cadena de texto con los resultados
de la consulta en un JSONArray y se devuelve a la función, donde
con una variable JSONObject se obtendrán los parámetros
requeridos.
5.3.3 Interfaz y gestión de datos.
5.3.3.1 Login.
La clase login es la interfaz de inicio de la aplicación android del
usuario, en ella se invita al usuario a introducir su nombre y la clave para
acceder a al entrenamiento personalizado. Desde la clase login se
comprueba si el usuario está registrado en la base de datos del
entrenador. Si es así, se muestra la activity de bienvenida, y si no, se
muestra un mensaje (toast) indicando que la contraseña o el usuario no
son correctos.
La interfaz de la clase Login está diseñada en el archivo bienvenida.xml y
se compone de:
TextView: donde se muestra el nombre de la aplicación.
ImageView: donde se muestra una imagen de un gimnasio.
TextView: Con el texto Usuario.
EditText: Para introducir el nombre del usuario.
TextView: Con el texto Password.
EditText: Para introducir la contraseña.
JButton: El botón para iniciar el login.
109
Todos los elementos son referenciados en la clase Login.java, para ser
utilizados en la interfaz de la aplicación. El aspecto de la interfaz de la
clase login se muestra en la ilustración 99.
Ilustración 99: Interfaz de la clase Login.
Como se ha indicado al inicio de este punto, la clase Login es la
encargada de recoger el usuario y la clave de la interfaz, y enviarlos vía
http al servidor para que este compruebe si el usuario está registrado en
la base de datos. Se definen dos editText que serán referenciados a los
dos EditText definidos en el archivo XML, para poder obtener el texto
introducido en ellos y almacenarlo en un string, que serán enviados para
la consulta. Además, se incluyen dos string, uno con la ip local en android
(10.0.2.2, en caso de no hacerlo de forma local, se utilizará la ip del equipo
donde resida apache y la base de datos) y otra con la url donde se
encuentra el archivo php a ejecutar por parte del servidor. Se instancia la
clase ConsultaDB, que será utilizada para enviar la petición http al
servidor.
110
Para iniciar el proceso de captura de datos y consulta http, se asigna
al botón login un listener, que controlará en todo momento el pulsado del
botón. Cuando se produce el pulsado del botón, se comprueba que se han
introducido datos en los dos EditText, (con la función checklogindata) y si
es así se recogen y se inicia la clase asyncLogin, que generara un hilo
secundario donde se ejecutara todo el proceso de consulta a la base de
datos.
En la clase AsyncLogin se definen las 3 funciones básicas para el
trato de hilos secundarios.
onPreExecute(): donde se muestra el mensaje ‘’Autenticando…’’ ,
mostrado durante la ejecución de la consulta.
doInBackground(String[]params) : donde se hace uso del usuario y
del password recogidos en la interfaz, para ejecutar la función
logstatus, que indicará si el usuario está registrado en la base de
datos.
onPostExecute(String result) : donde desaparece el mensaje de
autenticado, y se decide en función del resultado obtenido en
logstatus si se pasa a la siguiente activity pasando como parámetro
el nombre del usuario, o se ejecuta la función err_login, mostrando
un mensaje por pantalla indicando que el usuario o contraseña no
son correctos.
El resto de funciones que componen la clase login data son:
err_login(): donde se muestra un mensaje de usuario o contraseña
incorrectos. Además se produce una vibración del dispositivo.
loginstatus(String username ,String password ): donde se
comprueba si el usuario está en la base de datos. Para ejecutar la
consulta se prepara un ArrayList<NameValuePair>
(postparametersLogin) donde se añaden los pares etiqueta, valor:
‘’usuario’’,username y ‘’pasword’’,pasword utilizados en el fichero
php del servidor. Una vez preparados los datos de la consulta, se
ejecuta la petición http, haciendo uso de la clase ConsultaDB
(postLogin) y de su función getserverdata, almacenando el
resultado en un JSONArray:
111
JSONArray jdata=postLogin.getserverdata(postparameters2send,
URL_connect);
En URL_connect se almacena la url del fichero php a ejecutar en
el servidor. Una vez ejecutada la consulta se comprueba si se han
obtenido datos de la respuesta, y si es así, se procede al
tratamiento de estos. Para obtener los datos del JSONArray, se
define un JSONObject. Como se comentó en el apartado 5.1.1,
la respuesta del servidor solo dispone de un objeto
‘’logstatus’’, que es almacenado en el JSONObject para su
futura comprobación: si el resultado es ‘’0’’ no se habrá
encontrado ningún registro con los datos introducidos y se
devolverá ‘’false’’, y si se encuentra algún registro se devuelve
‘’true’’, valores necesarios para evaluar el paso a la siguiente
activity, o mostrar el mensaje de error.
checklogindata(String username ,String password ) : donde se
comprueba si se han introducido datos en los EditText de usuario y
contraseña.
5.3.3.2 Bienvenida.
La clase bienvenida es el resultado de la introducción correcta del
nombre del usuario y del password. En ella se muestra un mensaje de
bienvenida al usuario, junto con un botón para consultar las rutinas
propuestas por el entrenador. Al pulsar el botón, se da paso a la clase
MuestraRutinas donde se iniciara la consulta y se mostraran los resultados
en la interfaz.
La interfaz de la clase Bienvenida está diseñada en el archivo
bienvenida.xml y se compone de:
TextView: donde se muestra el título de la interfaz.
ImageView: Con una imagen ilustrativa de un gimnasio.
TextView: donde se muestra el mensaje de bienvenida.
TexTView: donde se muestra el nombre del usuario.
112
Button: Botón para iniciar la consulta de las rutinas.
Todos los elementos son referenciados en la clase Bienvenida.java,
para ser utilizados en la interfaz de la aplicación. El aspecto de la interfaz
de la clase Bienvenida se muestra en la ilustración 100.
Ilustración 100: Interfaz de la clase Bienvenida.
Se referencia el botón diseñado en el archivo bienvenida.xml y se
habilita la pulsación. En la clase bienvenida se recibe de la actividad
anterior (login) el nombre del usuario, utilizado en el mensaje de
bienvenida. Para iniciar la consulta de las rutinas se pulsa el botón
Consultar Rutinas, donde se pasa a la actividad MuestraRutinas, pasándole
como parámetro el nombre del usuario.
113
5.3.3.3 MuestraRutinas.
La clase MuestraRutinas consulta en la base de datos las rutinas
asignadas al usuario, haciendo uso del parámetro recibido de la clase
Bienvenida, el nombre del usuario. Primero se consulta cual es el Id del
usuario, para después utilizarlo para consultar las rutinas. Las rutinas se
muestran en botones, cuya pulsación dirige a la interfaz de la rutina. El
número de rutinas asignadas a un usuario está limitado a 5 debido al
diseño de la interfaz.
La interfaz de la clase MuestraRutinas está diseñada en el archivo
muestrarutinas.xml y se compone de:
TextView: donde se muestra el título de la interfaz.
5 Button: donde se muestran las rutinas asignadas, si las hubiera.
Button: con el botón atrás, para volver a la activity anterior
haciendo uso de la función finish().
Todos los elementos son referenciados en la clase
MuestraRutinas.java, para ser utilizados en la interfaz de la aplicación. El
aspecto de la interfaz de la clase MuestraRutinas se muestra en la
ilustración 98, todos los botones muestran una X como estado inicial,
hasta que se consultan las rutinas y se asignan a los botones. El estado
inicial de la interfaz puede consultarse en el fichero muestrarutinas.xml.
114
Ilustración 101: Interfaz clase MuestraRutinas.
La clase MuestraRutinas hace uso del nombre del usuario obtenido
de la activity anterior para hacer dos consultas: obtener el id del usuario
consultando la tabla usuario (para ello ejecuta en la petición el fichero
consulltaidusuario.php, utilizando el nombre del usuario como parámetro)
y consultar las rutinas asignadas al usuario, sirviéndose del id del usuario y
de la tabla RutinasDeUsuarios (ejecutando el fichero consultarutinas.php
utilizando como parámetro el id del usuario).
Se definen 6 JButton y se referencian con los botones diseñados en
el archivo muestrarutinas.xml, y se habilita el pulsado.
El inicio de la consulta de rutinas comienza justo al pasar a esta
activity. Al realizarse dos consultas a la base de datos, se instancian 2
veces la clase consultaDB: postConsultaIdUsuario y postConsultaRutina,
cada una para consultar el id del usuario y las rutinas respectivamente. Las
dos consultas tienen lugar en dos hilos secundarios generados por las
clases asyncIdUsuario y asyncRutinas que extienden a la clase asyncTask.
Se comienza ejecutando asyncIdUsuario que consta de las funciones:
115
onPreExecute(): no se ejecuta ninguna operación en esta función.
doInBackground(String[]params): donde se utiliza la función
CompruebaIdUsuario (string usuario) para obtener el id del usuario.
Una vez obtenido, lo pasamos como parámetro a la función
onPostExecute.
onPostExecute(string idUsuario): se utiliza el id del usuario
obtenido, para iniciar la consulta de las rutinas con la clase
asyncRutinas, utilizando como parámetro el id del usuario.
La función onPostExecute de la clase asyncIdUsuario instancia la
clase asyncRutinas comenzando la búsqueda de las rutinas asignadas al
usuario. La finalidad de la clase asyncRutinas consiste en consultar en la
base de datos (en la tabla RutinasDeUsuario) las rutinas asignadas al
usuario, almacenar sus identificadores en una tabla, y mostrar las rutinas
en la interfaz, en los botones asignados. Para ello se hace uso de las tres
funciones de la clase heredada asynTask:
onPreExecute(): se prepara la variable ProgressDialog con el
mensaje ‘’consultando rutinas…’’ y se muestra por pantalla. El
mensaje estará mostrándose por pantalla todo el tiempo que
requiera la consulta.
doInBackground(String[]params): se hace uso de la función
compruebaRutinas(string Id_Usuario) para rellenar la tabla de
rutinas.
onPostExecute(string idUsuario) : se comprueba si la tabla de
rutinas tiene algún elemento, y si es así se procede a actualizar la
interfaz. Se comprueban todos los casos posibles, 1, 2, 3, 4 o 5
rutinas, y dependiendo del caso, se actualizan los botones que se
necesiten, habilitando su pulsado. Una vez actualizada la interfaz, se
detiene el mensaje de consulta de rutinas iniciado en la función
onPreExecute.
Terminada la ejecución de las clases asyncIdUsuario y asyncRutinas,
se espera a que el usuario pulse uno de los botones con rutina asignada,
ejecutándose la función onClick(View v), donde se identificará el botón
pulsado. Una vez pulsado, se comprueba si ese botón tiene asignada una
rutina, para ello se hace comprueba si el número de rutinas es mayor o
116
igual que el botón pulsado, ( si hay 1 rutina y el botón pulsado es el 0, se
procederá, si el número de rutinas es 2 y se pulsa el botón 3, no pasará
nada) si es así, se procede llamando a la función llamaARutina(int
rutinaseleccionada). En la función llamaARutina, se almacena la rutina
seleccionada en un string y se añade al intent. Una vez añadido, se da paso
a la siguiente activity, Rutina_i.
A continuación se detallan el resto de funciones utilizadas.
CompruebaIdUsuario(String usuario): donde se hace uso del
nombre del usuario para consultar en la tabla Usuarios, su
identificador. Para ejecutar la consulta se prepara un ArrayList
<NameValuePair> (postparametersConsultaIdUsuario) donde se
añaden los pares etiqueta, valor: ‘’nombre’’, usuario utilizado en el
fichero php del servidor para ejecutar la consulta. Una vez
preparados los datos de la consulta, se procede a iniciar la petición,
haciendo uso de la clase ConsultaDB (postConsultaIdUsuario) y de
su función getserverdata, almacenando el resultado en un
JSONArray:
JSONArrayjdata= postparametersConsultaIdUsuario.getserverdata
(postConsultaIdUsuario, URL_connect);
Una vez ejecutada la consulta se comprueba si se han obtenido
datos de la respuesta, y si es así, se procede al tratamiento de
estos. Para obtener los datos del JSONArray, se define un
JSONObject. Como se comentó en el apartado 5.1.1, la respuesta
del servidor solo dispone de un objeto donde se muestra el id del
usuario. Una vez obtenido, se almacena en un string y se
devuelve.
CompruebaRutinas(String id_usuario): donde se utiliza el
identificador del usuario obtenido en la función
CompruebaIdUsuario para consultar las rutinas asignadas al usuario.
Para ejecutar la consulta se prepara un ArrayList <NameValuePair>
(postparametersCompruebaRutinas) donde se añaden los pares
etiqueta, valor: ‘’id_usuario’’,id_usuario utilizado en el fichero php
del servidor para ejecutar la consulta. Una vez preparados los datos
117
de la consulta, se procede con la petición http, haciendo uso de la
clase ConsultaDB (postConsultaRutina) y de su función
getserverdata, almacenando el resultado en un JSONArray:
JSONArray jdata= postparametersCompruebaRutinas.getserverdata
(postConsultaIdUsuario, URL_connect);
En URL_connect se almacena la url del fichero php a ejecutar en
el servidor. Una vez ejecutada la consulta se comprueba si se han
obtenido datos de la respuesta, y si es así, se procede al tratamiento
de estos. Los datos devueltos vienen encapsulados en una matriz
con una etiqueta cada uno. Para obtenerlos declaramos un
JSONObject donde iremos extrayendo cada objeto de la matriz. Se
declara una tabla con el mismo tamaño que el JSONArray de
respuesta (rutinas2) donde se irán almacenando todos los
identificadores de las rutinas obtenidas. La obtención y
almacenamiento de los identificadores de las rutinas, se hará en un
bucle for, con el mismo número de iteraciones que el tamaño del
JSONArray de respuesta. Una vez almacenador los identificadores
en la tabla, se devuelve.
LlamaArutina(int rutinaSeleccionada): se declara un intent al que se
le añade el identificador de la rutina seleccionada. El intent da paso
a la nueva activity, Rutina_i, donde se utilizara el identificador de la
rutina para obtener todos los datos referente a esta.
5.3.3.4 Rutina_i.
En la clase Rutina_i se hace uso del parámetro recibido de la clase
MuestraRutinas, (Id_Rutina) para consultar la descripción de la rutina y
los ejercicios que la componen. Los resultados son mostrados en la
interfaz, donde el usuario debe seleccionar uno de los ejercicios para dar
paso a la activity siguiente, ejercicio_i. Junto a los botones de los
ejercicios, se ha añadido el botón de formulario, que dirige a la clase
118
formulario. El número de ejercicios asignadas a un usuario está limitado a
6 debido al diseño de la interfaz.
La interfaz de la clase rutina_i está diseñada en el archivo
rutina_i.xml y se compone de:
TextView: donde se muestra la rutina consultada.
TextView: donde se muestra la descripción de la rutina
6 Button: donde se muestran los ejercicios asignados, si los hubiera.
Button: con el botón atrás, para volver a la activity anterior
haciendo uso de la función finish().
Button: con el botón formulario.
Todos los elementos son referenciados en la clase Rutina_i.java,
para ser utilizados en la interfaz de la aplicación. El aspecto de la interfaz
de la clase rutina_i se muestra en la ilustración 102. El número de la
rutina, la descripción y todos los botones de ejercicios presentan un
estado inicial que se actualiza una vez consultados los datos de la rutina. El
estado inicial de la interfaz de la clase Rutina_i puede consultarse en el
archivo Rutina_i.xml.
119
Ilustración 102: Interfaz de la clase Rutina_i.
Rutina_i hace uso del parámetro recibido de la clase
MuestraRutinas, Id_Rutina, para consultar la descripción y los ejercicios
asignados a la rutina seleccionada. Para ejecutar la consulta se hace uso
de la clase ConsultaDB (postConsultaEjercicio), donde se ejecutará la
petición http utilizando como parámetros la url del fichero php a ejecutar
en el servidor y el id de la rutina. En la ejecución del fichero php,
(consultaEjercicios.php) se consultaran la tabla de Rutinas, para obtener la
descripción, y la tabla ejerciciosDeRutinas, de donde obtendremos los
identificadores de los ejercicios asignados a la rutina. Todo el proceso de
envió de petición http y consulta de la base de datos se realiza en un hilo
secundario generado por la clase asyncEjercicios, que extiende a la clase
asyncTask.
Se definen 8 JButton, que se referencian con los botones diseñados
en el archivo rutina_i.xml.
120
Se realizarán dos consultas en la base de datos. Esta vez se ha
optado por realizar las dos consultas en el mismo fichero php guardando
los resultados en la misma variable. La ejecución de la consulta se realiza
en el hilo secundario generado por la clase asyncEjercicios, cuyas
funciones son:
onPreExecute(): donde se prepara y se muestra la variable
ProgressDialog con el mensaje ‘’Consultando ejercicios…’’
doInBackground(String[]params): donde se ejecuta la función
CompruebaEjercicios(string Id_Rutina), para almacenar en una tabla
los identificadores de los ejercicios.
onPostExecute(string id_Rutina) : se comprueba si la tabla de los
ejercicios tiene algún elemento, y si es así se procede a actualizar la
interfaz. Se comprueban todos los casos posibles, 1, 2, 3, 4, 5 o 6
ejercicios, y dependiendo del caso, se actualizan los botones que se
necesiten, habilitando su pulsado. Una vez actualizada la interfaz, se
detiene el mensaje de consulta de ejercicios iniciado en la función
onPreExecute.
Terminada la ejecución de la clase asyncEjercicios, se espera a que
el usuario pulse uno de los botones con ejercicio asignado, o los botones
atrás y formulario, ejecutándose la función onClick(View v), donde se
identificará el botón pulsado. Una vez pulsado, se comprueba el botón
pulsado. Si es uno de los botones de ejercicios se comprueba si tiene un
ejercicio asignado, para ello se hace comprueba si el número de ejercicios
es mayor o igual que el botón pulsado, (si hay 1 ejercicio y el botón
pulsado es el 0, se procederá, si el número de ejercicios es 2 y se pulsa el
botón 3, no pasará nada y así en todos los casos). Si es así, se procede
llamando a la función LlamaEjercicio(int ejercicioSeleccionado). En la
función LlamaEjercicio, se almacena el ejercicio seleccionado en un string
y se añade al intent. Una vez añadido, se da paso a la siguiente activity,
Ejercicio_i.
A continuación se detallan las funciones definidas en la clase
Rutina_i:
121
CompruebaEjercicios(String id_rutina) : donde se utiliza el
identificador de la rutina recibido de la clase anterior
MuestraRutinas para consultar los ejercicios asignados a la rutina.
Para ejecutar la consulta se prepara un ArrayList <NameValuePair>
(postparametersCompruebaEjercicios) donde se añaden los pares
etiqueta, valor: ‘’id_rutina’’,id_rutina utilizado en el fichero php del
servidor para ejecutar la consulta. Una vez preparados los datos de
la consulta, se procede con la petición http, haciendo uso de la clase
ConsultaDB (postConsultaEjercicios) y de su función getserverdata,
almacenando el resultado en un JSONArray:
JSONArray jdataConsultaEjercicios=
postparametersCompruebaEjercicios.getserverdata
(postConsultaIdUsuario, URL_connect);
En URL_connect se almacena la url del fichero php a ejecutar en
el servidor. Una vez ejecutada la consulta se comprueba si se han
obtenido datos de la respuesta, y si es así, se procede al tratamiento
de estos. Los datos devueltos vienen encapsulados en una matriz
con una etiqueta cada uno. Para obtenerlos declaramos un
JSONObject donde iremos extrayendo cada objeto de la matriz.
Primero guardamos la descripción de la rutina en un string y
después se procede a guardar los identificadores de los ejercicios en
una tabla, con el tamaño del JSONArray-1 (ya hemos obtenido un
objeto, la descripción). La obtención y almacenamiento de los
identificadores de los ejercicios, se hará en un bucle for, con el
mismo número de iteraciones que el tamaño del JSONArray-1.
Una vez almacenador los identificadores en la tabla, se devuelve.
LlamaAEjercicio(int ejercicioSeleccionado): se declara un intent al
que se le añade el identificador del ejercicio seleccionado. El intent
da paso a la nueva activity, Ejercicio_i, donde se utilizara el
identificador del ejercicio para obtener todos los datos referentes a
este.
122
5.3.3.5 Formulario.
La clase Formulario muestra un cuestionario que el usuario debe
rellenar una vez finalizada la rutina. Se rellenaran los huecos para cada
cuestión y se pulsará el botón enviar. Para el envío del cuestionario
primero se comprueba si el cuestionario ha sido enviado anteriormente. Si
no es así, se procederá a envío de la petición http para ejecutar la consulta
en el servidor, de lo contrario se mostrará un mensaje por pantalla
indicando que el formulario ya fue enviado anteriormente.
La interfaz de la clase rutina_i está diseñada en el archivo
rutina_i.xml y se compone de:
TextView: donde se muestra el formulario de la rutina_i.
TextView: donde se muestra el texto ‘’duración total de la rutina’’.
EditText: para rellenar los datos de la duración.
TextView: con el texto ‘’Número total de ejercicios realizados’’.
EditText: para rellenar los datos del número de ejercicios.
TextView: con el texto ‘’Número total de repeticiones’’.
EditText: para rellenar el número de repeticiones.
TextView: con el texto ‘’Estado físico al acabar la rutina’’.
EditText: para rellenar con el estado físico.
TextView: con el texto ‘’comentarios’’.
EditText: para rellenar con los comentarios.
Button: con el botón atrás, para volver a la activity anterior
haciendo uso de la función finish().
Button: con el botón enviar.
Todos los elementos son referenciados en la clase Formulario.java,
para ser utilizados en la interfaz de la aplicación. Al pulsar el botón enviar
se procede con el envío de la petición http y la ejecución de las consultas
en el servidor. En la ilustración 103 se muestra la interfaz de la clase
Formulario.
123
Ilustración 103: Interfaz de la clase Formulario.
La clase formulario comprueba inicialmente si existe el historial del
usuario, y posteriormente se envía el formulario en caso de que la
comprobación sea negativa. Se utilizan los parámetros Id_Usuario e
Id_Rutina, recibidos de la activity anterior, Rutina_i. La clase ConsultaDB
(postConsultaFormulario) será la encargada de enviar las peticiones http
indicando que archivos php se ejecutaran en el servidor.
Para comprobar si el formulario se ha rellenado anteriormente se
ejecutara en el servidor el fichero
compruebaHistoricoRutinasDeUsuarios.php, donde se consultará la tabla
HistoricoRutinasDeUsuarios de la base de datos. En caso de que no exista
ningún registro, se procede a enviar los datos del formulario a la base de
datos, para ello se envía una petición http para ejecutar el fichero
HistoricoRutinasDeUsuario.php, junto con los parámetros del
cuestionario. El resultado de la consulta se muestra por pantalla en un
124
mensaje indicándose si se ha enviado correctamente, o si ya se había
rellenado anteriormente.
Se definen todas las variables necesarias para referenciar todos los
elementos gráficos introducidos en formulario.xml. Estas variables serán
utilizadas para obtener los datos introducidos por el usuario en los
espacios del formulario.
Todo el proceso de envío de peticiones http y de ejecución de la
consulta SQL se realiza en un hilo secundario generado por la clase
asyncEnviarFormulario, que extiende de la clase asynctask, cuyas
funciones son:
OnPreExecute(): donde se prepara y se muestra la variable
progressDialog mostrando el mensaje ‘’ Enviando formulario…’’,
que se mostrará durante todo el proceso de consulta a la base de
datos.
doInBackground(String[]params): donde se utiliza el identificador de
la rutina y el del usuario recibido de la clase anterior Rutina_i, para
consultar si se ha rellenado anteriormente el formulario y si no es
así para enviar los datos introducidos en el cuestionario. Para
ejecutar la consulta se prepara un ArrayList <NameValuePair>
(postparametersFormulario) donde se añaden los pares etiqueta,
valor: ‘’id_rutina’’,id_rutina_string e ‘’id_usuario’’, id_usuario_string
y junto a la url del fichero php. Posteriormente se envía la petición
http ejecutándose la consulta en el servidor. El resultado es
almacenado en un JSONArray:
JSONArray jdataCompruebaFormulario=
postConsultaFormulario.getserverdata(postparametersFormulario,
URL_connect_comprueba_formulario);
Una vez recibida la respuesta del servidor, se evalúa. La respuesta
se compone de una variable ‘’formulario’’ que toma el valor de ‘’0’’
si no se ha encontrado registro, o ‘’1’’ si se ha encontrado. En caso
de no haberse encontrado, se procede a enviar los datos del
formulario introducidos por el usuario. Para ello se agregan los
125
datos introducidos en los EditText (previa conversión a string) a el
ArrayList <NameValuePair> creado inicialmente y donde ya se
encuentran el id del usuario y el id de la rutina. Una vez preparado
el ArrayList, se procede con el envío de la petición http haciendo
uso de la función getserverdata de la clase ConsultaDB y la
consecuente ejecución de la petición en el servidor. El resultado es
almacenado en un JSONArray:
JSONArray jdataFormulario=
postConsultaFormulario.getserverdata(postparametersFormulario,
URL_connect_enviar_formulario);
El resultado muestra si el formulario se ha enviado correctamente o
no. Para ello se utiliza la variable formulario, que toma el valor de
‘’ok’’ si el proceso se ha realizado correctamente, mostrándose el
mensaje por pantalla ‘’formulario enviado correctamente’’.
onPostExecute(string resultado): En esta función cesa el mensaje de
consulta en la base de datos y se muestra un mensaje indicando el
resultado de la consulta que será: ‘’Formulario enviado
correctamente’’, si se comprueba que no se ha enviado
anteriormente y la consulta de inserción del formulario se ha
realizado correctamente, o, ‘’El formulario ya se había rellenado
anteriormente’’ en caso de comprobar que el formulario ya ha sido
enviado con anterioridad.
5.3.3.6 Ejercicio_i.
En la clase Ejercicio_i se muestra al usuario la descripción del
ejercicio junto con sus características. Además se incluyen dos botones
que muestran los videos e imágenes que ilustran el ejercicio. Para obtener
la información de la base de datos, se hace uso del identificador del
ejercicio, recibido de la activity anterior Rutina_i. Con el identificador del
ejercicio se consulta la tabla ejercicios de la base de datos, obteniéndose
la descripción, la duración y la finalidad, mostrándose por pantalla al
126
usuario. Al pulsar los botones videos o imágenes, se da paso a las activities
videos_ejercicio_i e imágenes_ejercicio_i, donde se consultaran los videos
e imágenes que ilustran al ejercicio.
La interfaz de la clase Ejercicio_i está diseñada en el archivo
ejercicio_i.xml y se compone de:
TextView: donde se muestra el ejercicio consultado.
TextViev: donde se muestra la descripción del ejercicio.
TextView: donde se muestra la duración del ejercicio.
TextView: donde se muestra la finalidad del ejercicio.
Button: para consultar los videos.
Button: para consultar las imágenes.
Button: para volver a la activity anterior, haciendo uso de la función
finish().
Todos los elementos son referenciados en la clase Ejercicio_i.java,
para ser utilizados en la interfaz de la aplicación. En la ilustración 104 se
muestra la interfaz de la clase Formulario.
127
Ilustración 104: Interfaz clase Ejercicio_i.
En la clase Ejercicio_i se hace uso del identificador del ejercicio
pulsado para consultar todas sus características en la base de datos. El
servidor será el encargado de recibir el parámetro (el id del ejercicio) y la
url del fichero php que debe ejecutar. Una vez ejecutada la consulta y
encapsulada en formato JSON (proceso realizado en el fichero
descriciónEjecicio.php) el servidor devuelve el resultado de la consulta a la
aplicación android, encargada de interpretarla y mostrar los resultados en
la interfaz.
Se definen todas las variables necesarias para referenciar todos los
elementos gráficos introducidos en ejercicio_i.xml, para la actualización de
la interfaz una vez realizada la consulta.
Para la ejecución de la consulta, se enviara un mensaje http al
servidor, donde se incluirá el id del ejercicio, y la ruta del fichero php a
ejecutar. La encargada de enviar la petición http y de tratar la respuesta
es la clase ConsultaDB (postConsultaEjercicio), que almacena la respuesta
128
en un JSONArray que devuelve a la clase Ejercicio_i, donde se obtienen los
datos y se muestran por pantalla.
Todo el proceso de envío del mensaje http y ejecución de la
consulta en el servidor se realiza en un hilo secundario generado por la
clase asyncConsultaDescripcion, que extiende de la clase asyncTask y
cuyas funciones son:
OnPreExecute(): donde se prepara y se muestra la variable
progressDialog mostrando el mensaje ‘’Consultando datos del
ejercicio…’’, que se mostrará durante todo el proceso de consulta a
la base de datos.
doInBackground(String[]params): donde se utiliza el identificador
del ejercicio recibido de la clase anterior Rutina_i, para consultar los
datos del ejercicio. Para ejecutar la consulta se prepara un ArrayList
<NameValuePair> (postparametersdescripcionEjercicio) donde se
añaden los pares etiqueta, valor: ‘’id_ejercicio’’,id_ejercicio, junto a
la url del fichero php. Posteriormente se envía la petición http
haciendo uso de la función getserverdata de la clase ConsultaDB
ejecutándose la consulta en el servidor. El resultado es almacenado
en un JSONArray:
JSONArray jdataConsultaDesEjercicio =
postConsultaEjercicio.getserverdata(postparametersDescripcionEjer
cicio, URL_connect_consult_des_ejercicios);
En URL_connect_consult_des_ejercicios se almacena la url del
fichero php a ejecutar en el servidor. Una vez ejecutada la consulta
se comprueba si se han obtenido datos de la respuesta, y si es así,
se procede al tratamiento de estos. Los datos devueltos vienen
encapsulados en una matriz con una etiqueta cada uno. Para
obtenerlos declaramos un JSONObject donde iremos extrayendo
cada objeto de la matriz. Obtendremos los datos uno a uno, y se
irán guardando en unas variables string.
onPostExecute(string resultado): donde se actualiza la interfaz con
los datos obtenidos en la consulta.
129
Una vez concluida la consulta y la actualización de la interfaz, se
habilitan los botones de imágenes y videos, capturándose su pulsado con
la función OnCLick(View v). En OnClick se identificara el botón pulsado y
en caso de ser imágenes o videos, se añadirá al intent el identificador del
ejercicio y se pasara a la activity correspondiente.
5.3.3.7 Videos_ejercicio_i.
La clase Videos_ejercicio_i realiza dos consultas en la base de datos.
Primero busca todos los recursos asignados a un ejercicio(los recursos se
clasifican en imágenes y videos). Una vez consultados y guardados en una
tabla los recursos, se pasa a comprobar si el recurso es un video. Todos los
identificadores de recursos videos son almacenados en una tabla, y sus url
en otra distinta, que se utilizara como parámetro a la hora de reproducir
el video en la activity siguiente, Video_i. Una vez almacenados todos los
identificadores de los videos asignados al ejercicio, se actualiza la interfaz
mostrando en los botones el identificador del video. La interfaz consta de
6 botones para videos, por lo tanto el número máximo de videos que
puede asignar el entrenador a un ejercicio es de 6.
La interfaz de la clase Videos_ejercicio_i está diseñada en el archivo
Videos_ejercicio_i.xml y se compone de:
TextView: con el ejercicio consultado.
6 Button: con los videos asignados al ejercicio, en caso de que
tenga.
Button: para volver a la activity anterior, haciendo uso de la función
finish().
Todos los elementos son referenciados en la clase
Videos_ejercicio_i.java, para ser utilizados en la interfaz de la aplicación. El
identificador del ejercicio y todos los botones de los videos presentan un
estado inicial, que se actualiza una vez consultados los datos de los videos.
El estado inicial de la interfaz de la clase Videos_ejercicio_i puede
130
consultarse en el archivo Videos_ejercicio_i _i.xml. En la ilustración 105 se
muestra la interfaz de la clase una vez ejecutada la consulta.
Ilustración 105: Interfaz de la clase Videos_ejercicio_i
En la clase Videos_ejercicio_i se hace uso del identificador del
ejercicio proporcionado por la activity anterior, ejercicio_i, para consultar
todos los recursos asignados al ejercicio. Una vez recogidos todos los
identificadores de los recursos, se procede a identificar cuáles son videos
para mostrar su identificador en los botones de la interfaz. El pulsado de
un botón de video direcciona a la activity video_i, donde se hace uso de la
aplicación youtube para mostrar el video.
En la clase Videos_ejercicio_i.java se definen todas las variables
necesarias para referenciar todos los elementos gráficos introducidos en
Videos_ejercicio_i.xml, para la actualización de la interfaz una vez
realizada la consulta.
131
La clase ConsultaDB (postConsultaVideosEjercicios) es la encargada
de enviar la petición http para que el servidor ejecute las consultas
correspondientes, de tratar la respuesta, y almacenarla en un JSONArray.
Son dos los ficheros php que el servidor debe ejecutar: primero para
identificar los recursos del ejercicio (consultaidrecursos.php) y después
para consultar cuales son videos (consultavideos.php). Todo el proceso del
envío del mensaje http y de la ejecución de las consultas se hace en un
hilo secundario generado por la clase asyncVideos, que extiende de la
clase asyncTask, cuyas funciones son:
OnPreExecute(): donde se prepara y se muestra la variable
progressDialog mostrando el mensaje ‘’ Consultando videos…’’, que
se mostrará durante todo el proceso de consulta a la base de datos.
doInBackground(String[]params): En esta función se hace uso de las
funciones CompruebaIdRecurso(String Id_Ejercicio), para almacenar
en una tabla (Id_Recurso_int) los identificadores de los recursos
asignados al ejercicio. La función CompruebaVideos(String
Id_Recurso), donde se comprueba, uno a uno, si un recurso es un
video. Una vez comprobado si es un video, se procede a almacenar
su identificador en una tabla (videos_ejercicioi) que será utilizada
para actualizar la interfaz en la función OnPostExecute.
OnPostExecute(String resultado): donde se utiliza la tabla de
recursos videos obtenida en doInBackground para actualizar la
interfaz. Primero se comprueba si existe algún elemento en la tabla,
para después proceder a actualizar los textos de los botones en
función del número de video que haya. Una vez actualizada la
interfaz, cesa el mensaje mostrado por la variable progressDialog.
Terminada la ejecución de la clase asyncVideos, se espera a que el
usuario pulse uno de los botones con video asignado, o el botón atrás,
ejecutándose la función onClick(View v), donde se identificará el botón
pulsado. Una vez pulsado, se procede a identificar el botón. Si es uno de
los botones de videos se comprueba si tiene un video asignado, para ello
se comprueba si el número de videos es mayor o igual que el botón
pulsado (si hay 1 video y el botón pulsado es el 0, se procederá, si el
número de videos es 2 y se pulsa el botón 3, no pasará nada y así en todos
132
los casos). Si es así, se procede a añadir al intent la url del video pulsado,
que será utilizada por la clase video_i para mostrar el video en la interfaz.
El resto de funciones utilizadas en la clase son:
CompruebaIdRecurso( String Id_Ejercicio): donde se utiliza el
identificador del ejercicio recibido de la clase anterior Rutina_i, para
consultar los recursos asignados al ejercicio. Para ejecutar la
consulta se prepara un ArrayList <NameValuePair>
(postparametersConsultaIdRecurso) donde se añaden los pares
etiqueta, valor: ‘’id_ejercicio’’,id_ejercicio, junto a la url del fichero
php. Posteriormente se envía la petición http haciendo uso de la
función getserverdata de la clase ConsultaDB
(postConsultaVideosEjercisios) ejecutándose la consulta en el
servidor. El resultado es almacenado en un JSONArray:
JSONArray jdataConsultaIdRecursos=
postConsultaVideosEjercicios.getserverdata
(postparametersConsultaIdRecurso,
URL_connect_consulta_IdRecurso);
En URL_connect_consulta_IdRecurso se almacena la url del fichero
php a ejecutar en el servidor. Una vez ejecutada la consulta se
comprueba si se han obtenido datos de la respuesta, y si es así, se
procede al tratamiento de estos. Los datos devueltos vienen
encapsulados en una matriz con una etiqueta cada uno. Para
obtenerlos declaramos un JSONObject donde iremos extrayendo
cada objeto de la matriz. Se hará uso de un bucle for con un numero
de iteraciones igual al tamaño del JSONArray devuelto en la
consulta (el tamaño se corresponde con el número de
identificadores). Con la longitud del JSONArray también definimos el
tamaño de la tabla (Id_Recurso_int) donde se almacenaran los id de
los recursos. Una vez finalizado el bucle for, tenemos la tabla con los
identificadores de los recursos asignados al ejercicio.
133
CompruebaVideos(String Id_Recurso): Por cada identificador de
recurso almacenado en la tabla de recursos se comprobara si es un
recurso video o imagen. Todos las url de los recursos videos se
almacenaran en una tabla (urlVideo_auxiliar) que servirá como
parámetro para reproducir los videos. Para ejecutar la consulta en
el servidor, se prepara un ArrayList <NameValuePair>
(postparametersConsultaVideos) donde se añaden los pares
etiqueta, valor: ‘’id_recurso’’,id_Recurso y ‘tipo_recurso’’, video,
junto a la url del fichero php. Se hace uso de la clase ConsultaDB
(postConsultaVideosEjercisios) y de su función getserverdata para
enviar la petición http cuya respuesta se almacena en un
JSONArray:
JSONArray jdataConsultaVideos =
postConsultaVideosEjercicios.getserverdata
(postparametersConsultaVideos, URL_connect_consulta_videos);
Si en el JSONArray devuelto existe algún registro, es que la
comprobación ha resultado positiva, es decir, el recurso consultado
es un video y por lo tanto se procede a guardar su url y a devolver la
variable Id_Video con el valor ‘’1’’. En caso contrario, no se guarda
la url y el valor de la variable Id_Video es de ‘’0’’.
5.3.3.8 Video _i.
La Clase Video_i recibe de Videos_ejercicio_i la url del video
seleccionado, utilizada para descargar el video y reproducirlo por
streaming en el reproductor multimedia de youtube.
La interfaz de la clase Video _i está diseñada en el archivo
Video_i.xml y se compone de:
YouTubePlayerView : el reproductor multimedia de youtube.
Button: para volver a la activity anterior, haciendo uso de la función
finish().
134
Todos los elementos son referenciados en la clase Video _i.java,
para ser utilizados en la interfaz de la aplicación. El reproductor
multimedia de youtube contiene una barra de herramientas para realizar
las típicas operaciones con el video: pausar, reanudar y parar.
No se realiza ninguna consulta en la base de datos, únicamente se
obtiene de la activity anterior la url del video para descargarlo y mostrarlo
por streaming en el reproductor. Se define el botón atrás y el reproductor
multimedia. Una vez definido el reproductor multimedia, para poder
utilizarlo en la aplicación debemos inicializarlo utilizando la clave
proporcionada por google al certificar la aplicación.
Las funciones que se utilizan en la clase:
onInitializationFailure(Provider arg0, YouTubeInitializationResult
arg1): donde se muestra un mensaje indicando un error al iniciar el
reproductor.
onInitializationSuccess(Provider provider, YouTubePlayer player,
boolean wasRestored): donde se utiliza la url del video para
comenzar la descarga streaming en el reproductor.
5.3.3.9 Imágenes_ejercicio _i.
La clase Imagenes_ejercicio_i realiza dos consultas en la base de datos.
Primero busca todos los recursos asignados a un ejercicio. Una vez
consultados y guardados en una tabla los recursos, se pasa a comprobar si
el recurso es un imagen. Todos los identificadores de recursos imágenes
son almacenados en una tabla, y sus url en otra distinta, que se utilizara
como parámetro a la hora de reproducir el video en la activity siguiente,
Imagen_i. Una vez almacenados todos los identificadores se actualiza la
interfaz mostrando en los botones los identificadores de las imágenes
asignadas al ejercicio. La interfaz consta de 6 botones para imágenes, por
lo tanto el número máximo de imágenes que puede asignar el entrenador
a un ejercicio es de 6.
135
La interfaz de la clase Imagenes_ejercicio_i está diseñada en el
archivo imagenes_ejercicio_i.xml y se compone de:
TextView: con el ejercicio consultado.
6 Button: con las imágenes asignadas al ejercicio, en caso de que
tenga.
Button: para volver a la activity anterior, haciendo uso de la función
finish().
Todos los elementos son referenciados en la clase
Imagenes_ejercicio_i.java, para ser utilizados en la interfaz de la
aplicación. El identificador del ejercicio y todos los botones de los videos
presentan un estado inicial, que se actualiza una vez consultados los datos
de los videos. El estado inicial de la interfaz de la clase
Imagenes_ejercicio_i puede consultarse en el archivo
Imagenes_ejercicio_i.xml. En la ilustración 106 se muestra la interfaz de la
clase una vez ejecutada la consulta.
Ilustración 106: Interfaz de la clase Imagenes_ejercicio_i
136
En la clase Imagenes_ejercicio_i se hace uso del identificador del
ejercicio proporcionado por la activity anterior, ejercicio_i, para consultar
todos los recursos asignados al ejercicio. Una vez recogidos todos los
identificadores de los recursos, se procede a identificar cuáles son
imágenes para mostrar su identificador en los botones de la interfaz. El
pulsado de un botón de video direcciona a la activity Imagen_i, donde se
muestra la imagen.
En la clase Imagenes_ejercicio_i.java se definen todas las variables
necesarias para referenciar todos los elementos gráficos introducidos en
Imagenes_ejercicio_i.xml, para la actualización de la interfaz una vez
realizada la consulta.
La clase ConsultaDB (postConsultaImagenesEjercicios) es la
encargada de enviar la petición http para que el servidor ejecute las
consultas correspondientes, de tratar la respuesta, y almacenarla en un
JSONArray. Son dos los ficheros php que el servidor debe ejecutar:
primero para identificar los recursos del ejercicio (consultaidrecursos.php)
y después para consultar cuales son imágenes (consultaimagenes.php).
Todo el proceso del envío del mensaje http y de la ejecución de las
consultas se hace en un hilo secundario generado por la clase
asyncImagenes, que extiende de la clase asyncTask, cuyas funciones son:
OnPreExecute(): donde se prepara y se muestra la variable
progressDialog mostrando el mensaje ‘’ Consultando imágenes…’’,
que se mostrará durante todo el proceso de consulta a la base de
datos.
doInBackground(String[]params): En esta función se hace uso de las
funciones CompruebaIdRecurso(String Id_Ejercicio), para almacenar
en una tabla (Id_Recurso_int) los identificadores de los recursos
asignados al ejercicio. La función CompruebaImagenes(String
Id_Recurso), donde se comprueba, uno a uno, si un recurso es una
imagen. Una vez comprobado si un recurso es una imagen, se
procede a almacenar su identificador en una tabla
(imagenes_ejercicioi) que será utilizada para actualizar la interfaz en
la función OnPostExecute.
137
OnPostExecute(String resultado): donde se utiliza la tabla de
recursos imágenes obtenida en doInBackground para actualizar la
interfaz. Primero se comprueba si existe algún elemento en la tabla,
para después proceder a actualizar los textos de los botones en
función del número de imágenes que haya. Una vez actualizada la
interfaz, cesa el mensaje mostrado por la variable progressDialog.
Terminada la ejecución de la clase asyncImagenes, se espera a que
el usuario pulse uno de los botones con video asignado, o el botón atrás,
ejecutándose la función onClick(View v), donde se identificará el botón
pulsado. Una vez pulsado, se procede a identificar el botón. Si es uno de
los botones de videos se comprueba si tiene un video asignado, para ello
se comprueba si el número de Imágenes es mayor o igual que el botón
pulsado (si hay 1 video y el botón pulsado es el 0, se procederá, si el
número de videos es 2 y se pulsa el botón 3, no pasará nada y así en todos
los casos). Si es así, se procede a añadir al intent la url del video pulsado,
que será utilizada por la clase Imagen_i para mostrar la imagen en la
interfaz.
El resto de funciones utilizadas en la clase son:
CompruebaIdRecurso( String Id_Ejercicio): donde se utiliza el
identificador del ejercicio recibido de la clase anterior Rutina_i, para
consultar los recursos asignados al ejercicio. Para ejecutar la
consulta se prepara un ArrayList <NameValuePair>
(postparametersConsultaIdRecurso) donde se añaden los pares
etiqueta, valor: ‘’id_ejercicio’’,id_ejercicio, junto a la url del fichero
php. Posteriormente se envía la petición http haciendo uso de la
función getserverdata de la clase ConsultaDB
(postConsultaImagenesEjercicios) ejecutándose la consulta en el
servidor. El resultado es almacenado en un JSONArray:
JSONArray jdataConsultaIdRecursos=
postConsultaImagenesEjercicios.getserverdata
(postparametersConsultaIdRecurso,
URL_connect_consulta_IdRecurso);
138
En URL_connect_consulta_IdRecurso se almacena la url del fichero
php a ejecutar en el servidor. Una vez ejecutada la consulta se
comprueba si se han obtenido datos de la respuesta, y si es así, se
procede al tratamiento de estos. Los datos devueltos vienen
encapsulados en una matriz con una etiqueta cada uno. Para
obtenerlos declaramos un JSONObject donde iremos extrayendo
cada objeto uno a uno. Se hará uso de un bucle for con un número
de iteraciones igual al tamaño del JSONArray devuelto en la
consulta (el tamaño se corresponde con el número de
identificadores). Con la longitud del JSONArray también definimos el
tamaño de la tabla (Id_Recurso_int) donde se almacenaran los id de
los recursos. Una vez finalizado el bucle for, tenemos la tabla con los
identificadores de los recursos asignados al ejercicio.
CompruebaImagenes(String Id_Recurso): Por cada identificador de
recurso almacenado en la tabla de recursos se comprobara si es un
recurso video o imagen. Todos las url de los recursos imágenes se
almacenarán en una tabla (urlImagen_auxiliar) que servirá como
parámetro para que la clase Imagen_i muestre la imagen en la
interfaz. Para ejecutar la consulta en el servidor, se prepara un
ArrayList <NameValuePair> (postparametersConsultaImagenes)
donde se añaden los pares etiqueta, valor: ‘’id_recurso’’,id_Recurso
y ‘tipo_recurso’’, imag, junto a la url del fichero php. Se hace uso de
la clase ConsultaDB (postConsultaImagenesEjercicios) y de su
función getserverdata para enviar la petición http cuya respuesta se
almacena en un JSONArray:
JSONArray jdataConsultaImagenes =
postConsultaImagenesEjercicios.getserverdata
(postparametersConsultaImagenes,
URL_connect_consulta_imagenes);
Si en el JSONArray devuelto existe algún registro, es que la
comprobación ha resultado positiva, es decir, el recurso consultado
es una imagen y por lo tanto se procede a guardar su url y a
139
devolver la variable Id_Imagen con el valor ‘’1’’. En caso contrario,
no se guarda la url y el valor de la variable Id_Video es de ‘’0’’.
5.3.3.10 Imagen_i.
La clase Imagen_i hace uso de la url proporcionada por la activity
anterior, imágenes_ejercicio_i, para descargar la imagen y mostrarla por
pantalla.
La interfaz de la clase Imagen_i está diseñada en el archivo
imagen_i.xml y se compone de:
ImageView: donde se muestra la imagen.
Button: para volver a la activity anterior, haciendo uso de la función
finish().
Todos los elementos son referenciados en la clase imageni.java,
para ser utilizados en la interfaz de la aplicación. El estado inicial de la
interfaz de la clase imagen_i puede consultarse en el archivo
Imagenes_ejercicio_i.xml.
Se declaran y referencian todas las variables necesarias para
manejar los elementos gráficos diseñados en el archivo imagen_i.xml. Se
extrae la url de la imagen del intent de la clase anterior, y se procede con
la descarga y decodificación de esta. Todo el proceso de decodificación de
la imagen se realiza en un hilo secundario generado por la clase
asyncDecodificaImagen, que extiende de la clase asyncTask. Las funciones
de la clase DecodeImage son:
doInBackground(String[]params): donde se descarga la imagen , se
decodifica y se almacena en un bitmap.
OnPostExecute(String resultado): donde se utiliza el ImageView
para mostrar la imagen descargada.
Terminada la ejecución de la clase asyncDecodificaImagen, se
espera a que el usuario pulse el botón atrás, ejecutándose la función
onClick(View v), y volviendo a la activity anterior.
141
6. Conclusiones.
El desarrollo de aplicaciones para dispositivos móviles se encuentra
en auge hoy día. El posibilitar a todo tipo de usuarios el desarrollo y dar a
conocer el trabajo realizado en este tipo de aplicaciones, motiva en gran
medida a que diariamente aparezcan nuevas aplicaciones, algunas
dedicadas al entretenimiento y otras que satisfacen las necesidades que
surgen durante el desarrollo de la vida personal y laboral. Con la aplicación
Personal Trainer he intentado facilitar y motivar la práctica de ejercicio
físico en cualquier momento del día, incentivando a aquellas personas que
por motivos de trabajo o simplemente personales no disponen de tiempo
para realizar deporte o ejercicios físicos.
Durante el desarrollo de la aplicación se ha puesto en práctica lo
que, por mi formación universitaria, realizaré durante toda mi vida laboral,
la autoformación. Muchos han sido los conceptos nuevos aprendidos a
medida que se desarrollaba la aplicación, además, de poner en práctica
conocimientos adquiridos durante mis estudios universitarios:
programación php, HTML, java, android, base de datos, servidor apache,
etc. Pero sin lugar a duda la mayor satisfacción la produce el haber
desarrollado una aplicación real, útil, que podrá servir para que personas
que antes eran incapaces de realizar ejercicio físico personalizado por
determinadas causas, puedan ahora desarrollar un entrenamiento
personalizado por parte de un entrenador que evalúe los resultados y que
en base a ellos planifique los entrenamientos e incentive continuar con la
práctica del ejercicio físico.
143
7. Bibliografía.
1. Ladrón, Jorge Martínez. Fundamentos de programación Java.
2. Martín, Iván. androidayuda.com. [En línea]
http://androidayuda.com/2012/11/02/android-alcanza-el-75-de-cuota-
de-mercado-mundial/.
3. MYSQL. http://www.mysql.com/. [En línea]
4. Apache., Servidor. http://httpd.apache.org/. [En línea]
5. JAVA., Conector MYSQL para.
http://dev.mysql.com/downloads/connector/j/. [En línea]
6. PHP. www.php.net. [En línea]
7. Json. http://www.json.org/. [En línea]
8. INNODB. http://dev.mysql.com/doc/refman/5.0/es/innodb.html. [En
línea]
9. MYSQL, FOREIGNS KEYS.
http://dev.mysql.com/doc/refman/5.0/es/innodb-foreign-key-
constraints.html. [En línea]
10. Google. https://developers.google.com/youtube/android/player/. [En
línea]
11. Rosa, Antonio de la. http://www.upf.edu/hipertextnet/numero-
1/xml.html. [En línea]
12. Konigsberg, Paul. http://www.eveandersson.com/arsdigita/asj/soap/.
[En línea]
144
Javier García de Jalón, José Ignacio Rodríguez, Iñigo Migno, Aitor Imaz,
Alfonso Brazalet, Alberto Larzabal, Jesús Calleja, Jon García (2000). Java.
http://www.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/Java/J
ava2.pdf
Jorge Sánchez (2004). Java2: Swing, Threads, programación en red,
JavaBeans, JDBC y JSP / Servlets.
http://www.jorgesanchez.net/programacion/manuales/Java.pdf
www.mysql.com, http://dev.mysql.com/doc/refman/5.6/en/connector-
j.html
Jazna Meza Hidalgo (Mayo 2010). Tutorial Java con acceso a datos e
Interfaces gráficas.
http://yasnameza.files.wordpress.com/2010/08/javada-swing.pdf
Franklin García. Usando efectivamente el AsyncTask Parte 1
http://www.fr4gus.com/2011/05/13/usando-efectivamente-el-asynctask-
parte-1/ http://www.fr4gus.com/2011/05/24/usando-efectivamente-el-
asynctask-parte-2/
Alberto Hernández Akkari. Android,json,php y mysql. http://fsvelectronicainformatica.blogspot.com.es/2011/04/android-json-
php-y-mysql-enviar-datos.html
William J. Francis. Using Google's YouTube API in your Android apps
http://www.techrepublic.com/blog/android-app-builder/using-googles-
youtube-api-in-your-android-apps/
Jesús Bobadilla Sancho. Interfaz gráfico de usuario.
http://eui.upm.es/~jbobi/jbobi/LibroJava/193-246.pdf
http://tabasco.torreingenieria.unam.mx/gch/Curso%20de%20Java%20CD/
Documentos/froufe/parte13/cap13-1.html
sgoliver.net blog. Tareas en segundo plano en Android (I): Thread y
AsyncTask http://www.sgoliver.net/blog/?p=3099
Luis A. González Ares, Miguel Rodríguez Penabad. Minitutorial de MySQL
Workbench.
145
http://coba.dc.fi.udc.es/~bd/bd2/MySQLWB/tutorialWB.html
Cristina Puente, Javier Palacios. PHPMYADMIN Y MYSQL.
http://www.iit.upcomillas.es/palacios/cursoAppWeb/guia_mysql.pdf
www.ajpdsoft.com. Acceso a MYSQL desde android con eclipse, java y
JDBC.
http://www.ajpdsoft.com/modules.php?name=News&file=article&sid=65
6
sgoliver.net blog. Tareas en segundo plano en Android (I): Thread y
AsyncTask http://www.sgoliver.net/blog/?p=3099
http://developer.android.com/index.html
http://www.php.net/
http://httpd.apache.org/docs/2.2/es/
http://docs.phpmyadmin.net/en/latest/
http://www.mysql.com/services/
http://dev.mysql.com/doc/refman/5.0/es/
http://dev.mysql.com/doc/workbench/en/
www.JSON.org
http://developer.android.com/reference/packages.html
http://developer.android.com/reference/android/os/AsyncTask.html
www.androidsis.com. http://www.androidsis.com/programacion-android-
iii-interfaz/
https://developers.google.com/youtube/android/player/
https://developers.google.com/youtube/android/player/reference/com/g
oogle/android/youtube/player/package-summary
147
8. Anexo.
8.1 Manual de instalación de la base de datos.
Para la instalación de la base de datos se ha hecho uso de la
aplicación AppServ, donde se incluye:
El servidor web apache.
La base de datos MySQL.
PHP
La aplicación para gestión de bases de datos PhpMyAdmin.
Descargamos la aplicación desde su página web oficial,
http://www.appservnetwork.com/?newlang=spanish, y la instalamos en el
ordenador donde se vaya a instalar el servidor. Durante el proceso de
instalación se pedirá un usuario y una contraseña necesarios para ejecutar
la aplicación PhpMyAdmin. Una vez finalizada la instalación, podemos
acceder a la aplicación PhpMyAdmin desde el explorador. Para la creación
de base de datos relacionales es necesario la utilización del motor de
almacenamiento innoDB. En su configuración por defecto, PhpMyAdmin
no incluye el motor de almacenamiento innoDB entre sus opciones. Para
habilitarlo editaremos el fichero de configuración my.ini en la ruta,
C:\AppServ\MySQLC:\AppServ \MySQL. En el apartado INNODB Specific
options, habilitamos la utilización del motor de almacenamiento innoDB:
engine=INNODB. Ahora ya tendremos accesible el motor desde
phpMyadmin.
148
8.2 Manual de instalación de la aplicación Java
Para la programación de la aplicación Java del entrenador se ha
hecho uso del entorno de desarrollo eclipse y del conector MYSQL para
java.
En primer lugar, instalamos eclipse en nuestro ordenador,
descargándolo de la url http://www.eclipse.org/downloads/. Una vez
iniciada la instalación, seguimos todos los pasos que propone el asistente.
Una vez finalizado, ejecutamos el programa. Eclipse aún no se encuentra
preparado para conectar con la base de datos y ejecutar consultas SQL, es
necesario la instalación del conector MySQL para java.
Para la instalación del conector, primero descargamos el paquete
Zip de la página oficial de MySQL, en el apartado download elegimos
MySQL connector y connector/J. La url para la descarga del conector es
http://dev.mysql.com/downloads/connector/j/. Una vez descargado el
archivo y desempaquetado seleccionamos el archivo mysql-connector-
java-5.1.17-bin.jar que será el único de utilidad. Para utilizar las librerías
del conector hacemos click con el botón derecho sobre el proyecto, build
path y add external archives. Seleccionamos el archivo del conector java y
lo agregamos. Una vez finalizado el procedimiento, tendremos acceso a
las clases que permiten conectar con la base de datos MYSQL.
Una vez finalizada la instalación del conector MySQL, para ejecutar
la aplicación en eclipse, hacemos click con el botón derecho del ratón en
el espacio Package Explorer, donde se desplegara una lista ofreciendo una
serie de opciones, se seleccionará la opción importar proyecto. Buscamos
el directorio donde se encuentra nuestro proyecto, PersonalTrainer y
seleccionamos aceptar. Ahora el proyecto aparecerá en la lista Package
Explorer, donde podrá ser ejecutado.
149
8.3 Manual de instalación de la aplicación Android.
Para el desarrollo de la aplicación android es necesario instalar los
plugins de android para eclipse. Para ello tenemos dos opciones:
Bajar e instalar el plugin de android manualmente. El plugin de
google para el desarrollo de aplicaciones android se denomina ADT
(Android Developers Tools). Para su instalación pulsamos en la
pestaña help de eclipse , señalamos Install new software e
introducimos la url del plugin de android para eclipse: http://dl-
ssl.google.com/android/eclipse. Una vez finalizado el proceso se
reiniciará eclipse.
Bajar el paquete de desarrollo completo proporcionado por android
que incluye:
Eclipse + ADT plugin.
Android SDK Tools.
Android Plataforms-tools.
The latest Android platform.
The latest Android System image for the emulator.
El paquete lo descargamos desde http://developer.android.com/sdk
/index.html.
Una vez instaladas las APIS de android para eclipse ya podemos
importar y ejecutar el proyecto PersonalTrainerAndroid_1. La metodología
a seguir es la misma que para la aplicación java, hacemos click con el
botón derecho del ratón en el espacio Package Explorer, donde se
desplegará una lista ofreciendo una serie de opciones ,se seleccionará la
opción importar proyecto. Buscamos el directorio donde se encuentra
nuestro proyecto, PersonalTrainerAndroid_1 y seleccionamos aceptar.
Ahora el proyecto aparecerá en la lista Package Explorer, donde podrá ser
ejecutado. A diferencia de la aplicación java, la aplicación android necesita
ser instalada en un dispositivo con el sistema operativo android instalado.
150
Se ofrecen dos métodos para comprobar el funcionamiento de la
aplicación:
El emulador incluido en las librerías de android.
Depuración de la aplicación en un dispositivo android.
La segunda opción es la más recomendable. La aplicación se instala y se
ejecuta instantáneamente, mientras que con el emulador la aplicación se
ejecuta de forma poco fluida ocasionándose fallos continuamente.
8.3.1 API youtube para android.
Para utilizar las APIS de youtube seguimos el mismo mecanismo
utilizado en el conector mysql. Añadimos al proyecto android el fichero
descargado desde la dirección
https://developers.google.com/youtube/android/player/downloads/. La
utilización de estas librerías requiere más pasos que la instalación de una
librería normal. Además de añadir el archivo al proyecto es necesario
registrar la aplicación en la plataforma de desarrollo de android. Los pasos
para utilizar las librerías youtube son:
Primero debemos obtener la ruta donde está almacenado el
certificado digital de depuración, para ello pulsamos en la pestaña
de Windows y en preferences, en eclipse. Una vez abierta la
ventana pulsamos en android y en build. Se mostrará la ruta donde
está almacenado el certificado de depuración.
Localizar la huella SHA1 de nuestra aplicación, para ello nos
servimos de la aplicación keytool localizado en la carpeta
C:\Program Files (x86)\Java\jre7\bin. Para ello ejecutamos en la
consola de Windows los comandos:
151
cd C:\Program Files (x86)\Java\jre7\bin keytool -v -list –keystore
C:\Users\Juan\.android\debug.keystore (donde
C:\Users\Juan\.android\debug.keystore es la ruta donde se
encuentra almacenado el certificado de depuración).
En la ilustración 107 se muestra el resultado de ejecutar los dos
comandos, mostrándose la huella SHA1 requerida.
Ilustración 107: Huella SHA1.
Una vez localizada la huella procedemos a registrar la aplicación en
la plataforma de desarrollo de google. Para ello accedemos a la
dirección
https://developers.google.com/youtube/android/player/register y
pulsamos en google apis console. Creamos un nuevo proyecto,
utilizando el botón create y le damos nombre. Es necesario ser
usuario de google para todo el procedimiento.
En la pestaña services marcamos el servicio que vamos a utilizar, en
nuestro caso youtube.
Una vez activado, seleccionamos la pestaña de API Access y
hacemos click en el botón Create new Android key.
152
Ahora introducimos la clave SHA1 obtenida seguida de un punto y
coma, y del nombre de paquete de vuestra aplicación si se desea.
Pulsamos el botón Create y aparecerá un nuevo elemento indicando
la API key que tendrás que usar en la aplicación.
La key será utilizada en la activity que implementa la aplicación
youtube.
Para que la aplicación youtube funcione correctamente en la aplicación es
necesario tener instalada una versión de la aplicación youtube igual o
superior a la versión 4.2.16.