PDF de programación - Tesis: Gasulla Mestre - Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles - Laberinto

TESINA PARA LA
OBTENCIÓN DEL TÍTULO DE:

Máster en Desarrollo de
Aplicaciones sobre Dispositivos
Móviles



Título del
Proyecto:

Laberinto

Autor:

Gasulla Mestre,

Javier

Director:

Albiol Colomer,

Antonio

Septiembre de 2015

Proyecto: Laberinto
Alumno: Javier Gasulla Mestre



Contenido



Introducción .................................................................................................................................. 3

Descripción de la aplicación ...................................................................................................... 3

Objetivos ................................................................................................................................... 3

Motivación ................................................................................................................................ 3

Arquitectura de la aplicación ........................................................................................................ 4

Esquema del diseño .................................................................................................................. 4

Código Java ................................................................................................................................ 5

Código nativo ............................................................................................................................ 9

Librerías generadas ................................................................................................................. 10

Recursos .................................................................................................................................. 10

Modelo de datos ..................................................................................................................... 10

Vistas ....................................................................................................................................... 11

Conclusiones ............................................................................................................................... 19

Anexos ......................................................................................................................................... 20

Listado de fuentes entregadas ................................................................................................ 20



Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles

2

Proyecto: Laberinto
Alumno: Javier Gasulla Mestre



Introducción

Descripción de la aplicación

El proyecto consiste en el desarrollo de una aplicación en Android, utilizando Eclipse.

La aplicación constituye un juego en el que hay que mover una pelota por un laberinto para

recoger monedas y dirigirse a la meta. Al llegar a la meta pasamos al siguiente nivel, en el que

aparece otro laberinto diferente. En total la aplicación consta de dos niveles.

La pelota puede moverse de tres maneras diferentes a elegir en preferencias:

- Detección de cara. Se utiliza para ello la funcionalidad proporcionada por OpenCV,

así como implementación de funcionalidad en código nativo.

-

-

Pantalla táctil.

Sensores de aceleración.



Objetivos

El principal objetivo de la aplicación es utilizar OpenCV para procesar el movimiento de

la cara del usuario (captado por la cámara del dispositivo) y en consecuencia ejecutar acciones

sobre otros elementos (en este caso desplazar una pelota por un laberinto).

La implementación del juego constituye una excusa para plasmar el objetivo buscado.



Motivación

La motivación de este proyecto ha sido integrar el tratamiento de imagen con otros

aspectos vistos a lo largo del curso (código nativo, threads, acelerómetros, pantalla táctil,

ajuste del tamaño de imágenes, layouts para diferentes tipos de pantalla, multiidioma, etc.),

en una aplicación que pueda servir de base para futuras aplicaciones de uso tanto lúdico como

profesional.



Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles

3

Proyecto: Laberinto
Alumno: Javier Gasulla Mestre



Arquitectura de la aplicación

En los apartados siguientes se va a detallar los principales elementos que forman la

aplicación (clases Java, código nativo, librerías, recursos), describiendo su funcionalidad para

mostrar el funcionamiento de la aplicación.

Por otra parte, en la librería externa “OpenCV Library – 2.4.10”, utilizada por la

aplicación, hay que modificar la clase org.opencv.android.AsyncServiceHelper para convertir el

intent implícito existente en explícito. De este modo la aplicación puede usarse para

terminales con nivel de API 21 o superior.



Esquema del diseño

En el esquema siguiente se muestra la relación de las diferentes clases entre sí.



Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles

4

Proyecto: Laberinto
Alumno: Javier Gasulla Mestre



Código Java



A continuación se relaciona, por orden alfabético, las diferentes clases que forman la

aplicación, detallando la función de cada una de ellas.

- AcercaDe.java

Lanza el Dialog con los créditos de la aplicación.

- AdaptadorCursor.java

Adaptador del ListView que contiene las puntuaciones.

- AjustesDrawables.java

Implementa el código necesario para ajustar el drawable indicado al tamaño

deseado. Se utiliza en las clases MainActivity, VistaJuego y TabInstruccionesManejo

para dimensionar los drawables en función del tamaño de pantalla del dispositivo. De

este modo, independientemente del tamaño de dicha pantalla, las vistas mostradas

mantendrán el mismo aspecto.

- AlmacenPuntuaciones.java

Interfaz que

indica

los métodos para guardar una puntuación o mostrar

puntuaciones, que debe implementar la clase AlmacenPuntuacionesSQLite.

- AlmacenPuntuacionesSQLite.java

Se encarga de crear la base de datos que contiene las puntuaciones de los

jugadores y gestionar los accesos a la misma (para guardar una nueva puntuación u

obtener la relación de puntuaciones).

- Bloque.java

Extiende de la clase Grafico. A esta clase pertenecen los bloques que forman las

paredes del laberinto. Contiene características particulares de los bloques, como por

ejemplo los diferentes tipos de bloque.

El aspecto de los bloques es el mismo, pero se les asigna un tipo distinto en

función de los lados del bloque con los que puede chocar la pelota (los lados contiguos

a otro bloque no son susceptibles de que la pelota choque con ellos).

El tipo de cada bloque, junto con la posición relativa de pelota y bloque, se utilizará

para determinar si la pelota ha chocado con el bloque. Se determina también que

parte de la pelota (inferior, superior, derecha o izquierda) es la que ha chocado con el

bloque. La detección de colisiones implementada en la clase Grafico sirve para

detectar colisiones entre objetos de forma redondeada. Al ser los bloques cuadrados y

querer determinar el sentido del choque, se implementa una función particularizada

en esta clase.



Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles

5

Proyecto: Laberinto
Alumno: Javier Gasulla Mestre



- DetectionBasedTracker.java



Utilizada para la detección de caras en modo “nativo”. Proporcionada en el

ejemplo face-detection de OpenCV.

- Grafico.java

Implementa los métodos necesarios para dibujar, posicionar y mover objetos de

esta clase creados a partir de drawables. También detecta colisiones con otro objeto

de la clase Grafico (se utiliza para detectar colisiones de pelota con moneda, o pelota

con la meta).

Se utiliza en la clase VistaJuego ya que la pelota, monedas y meta allí creados son

objetos de la clase Grafico. También derivan de esta clase los objetos de tipo bloque

que forman las paredes del laberinto.

-

Instrucciones.java

FragmentActivity que muestra los dos tabs que contienen las instrucciones para

utilizar la aplicación, definidos en TabInstrucciones.java y TabInstruccionesMix.java.

-

JuegoyFaceDetect.java

Esta clase es llamada por MainActivity.java cuando se elige la opción de jugar una

partida. Se encarga de inicializar OpenCV, cargar las librerías, realizar la detección cara,

lanzar la pantalla del juego (gestionando el thread que maneja el juego, definido en el

fichero VistaJuego.java), establecer la dirección y sentido del movimiento de la pelota

(si se ha elegido la detección de cara como modo de manejo de la misma) y activar o

desactivar los sensores de aceleración (en caso de que sea el modo elegido para

manejar la pelota). También gestiona la pulsación de los botones existentes en la

pantalla del juego, descritos en el apartado de vistas.

Para realizar la detección de cara se ha utilizado el método descrito en el ejemplo

face-detection de OpenCV. Para ello se utiliza un fichero LBPCascade optimizado para

detección frontal de cara. Este tipo de ficheros contienen los patrones que permiten

realizar la detección de cara en una imagen. Los dos tipos más utilizados son

LBPCascade y HaarCascade. En nuestro caso es LBPCascade el idóneo, ya que siendo

algo menos preciso, es más rápido. Esta última característica resulta fundamental, al

tratarse de una aplicación que realiza el tratamiento de una imagen de video para

obtener una respuesta en tiempo real (el movimiento de la pelota).

De entre las diferentes caras detectadas, nos queda