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.

10

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.

38

Ilustración 39: Diagrama base de datos.

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.

140

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.

142

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

146

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.