Diseño y Desarrollo de Una Aplicación Movil para La Enseñananza de Las Matemáticas en La ESO

Diseo y desarrollo de una aplicacin mvil para la enseanza de las matemticas en la ESO
Pg. 1
Resumen
Este proyecto de final de carrera tiene el objetivo de desarrollar una aplicacin basada en
dispositivos mviles para el aprendizaje de las matemticas. Se trata de una aplicacin que
facilite al alumno la resolucin de ejercicios y problemas del nivel educativo en el que se
encuentra. El rango de edades hacia las que est dirigida la aplicacin son de 11 a 15 aos,
es decir, las edades
que comprenden la enseanza secundara del actual sistema
educativo.
El desarrollo de la aplicacin ha sido enfocado, en todo momento, desde un punto de vista
educativo y pensando en su finalidad inmediata, es decir, proporcionar una ayuda a los
estudiantes en su proceso de aprendizaje de las matemticas.
A lo largo de esta memoria se explica detalladamente todo el proceso de creacin de la
aplicacin, as como las herramientas y recursos utilizados para ello. Tambin se recoge
otra informacin como el anlisis econmico de este proceso, su planificacin temporal y su
impacto medioambiental.
En los anexos se encuentra toda la informacin tcnica que se ha utilizado para llegar a
nuestro objetivo. Tambin se ha incluido todo el cdigo de programacin empleado para la
implementacin de la aplicacin.
En soporte informtico se proporcionan todos los ficheros utilizados para la programacin de
la aplicacin, as como la memoria y sus anexos en soporte electrnico.
La aplicacin fruto de este proyecto es un prototipo que deber ser depurado y puesto a
prueba en posteriores fases que se escapan al objeto del presente proyecto. An siendo as,
se han indicado una serie de mejoras que se pueden llevar a cabo tras la creacin del
primer prototipo.
Pg. 2
Memoria
Pg. 3
Sumario
RESUMEN ___________________________________________________ 1
SUMARIO ____________________________________________________ 3
1.
GLOSARIO _______________________________________________ 7
2.
PREFACIO _______________________________________________ 9
1.1
Motivacin ...................................................................................................... 9
INTRODUCCIN _________________________________________ 11
2.1
Objetivos del proyecto .................................................................................. 11
2.2
Alcance del proyecto .................................................................................... 11
SISTEMA OPERATIVO Y ENTORNO DE DESARROLLO _________ 13

3.1
Sistema operativo ......................................................................................... 13
3.2
Lenguaje y entorno de programacin........................................................... 14
3.2.1
ActionScript ..................................................................................................... 14
3.2.2
FlashDevelop .................................................................................................. 16
3.2.3
Adobe Air ........................................................................................................ 17
3.2.4
Interfaz de programacin de aplicaciones (API).............................................. 18
3.2.5
Motor de ejecucin .......................................................................................... 19
FUNCIONALIDAD, DISEO Y ESTRUCTURA __________________ 21

4.1
Funcionalidad y Diseo ................................................................................ 21
4.1.1
Funciones del profesor.................................................................................... 23
4.1.1.1 Gestin del fichero de ejercicios ..................................................................... 23

4.1.1.2 Creacin del fichero de deberes ..................................................................... 25
4.1.1.3 Gestin del fichero de alumnos ....................................................................... 27
4.1.1.4 Visualizacin de resultados ............................................................................. 29
4.1.2
Funciones del alumno ..................................................................................... 31
4.1.2.1 Resolucin de ejercicios ................................................................................. 31

4.1.2.2 Competicin entre alumnos ............................................................................ 34
4.2
Estructura. .................................................................................................... 36
Pg. 4
Memoria
GESTIN Y ESTRUCTURA DE LOS FICHEROS DE DATOS ______39

5.1
XML: eXtensible Markup Lenguage............................................................. 39
5.1.1
Estructura y funcionamiento del cdigo XML ...................................................39
5.1.2
Otras alternativas .............................................................................................41
5.2
Cdigo para la gestin de XML.................................................................... 41
5.2.1
Creacin de una variable XML .........................................................................42
5.2.2
Aadir registros nuevos a un fichero ................................................................42
5.2.3
Conversin de un archivo en una variable XML...............................................43
5.2.4
Consulta de datos dentro de los ficheros .........................................................43
5.2.5
Recorrer toda la estructura de una variable XML .............................................44
5.2.6
Eliminar registros de una variable XML............................................................44
5.3
Contenido de los ficheros ............................................................................ 45
5.3.1
Fichero de alumnos .........................................................................................45
5.3.2
Fichero de Ejercicios ........................................................................................47
5.3.3
Fichero de deberes ..........................................................................................48
CDIGO Y ARQUITECTURA________________________________49
6.1
La clase principal: Sprite .............................................................................. 49
6.1.1
6.2
Carga de imgenes externas ....................................................................... 51
6.2.1
6.3
Cdigo para los cuadros de texto.....................................................................56
La clase SharedObject................................................................................. 57
6.5.1
6.6
Cdigo para la gestin de eventos...................................................................54
Cuadros de texto.......................................................................................... 55
6.4.1
6.5
Cdigo para la visualizacin ............................................................................51
Eventos ........................................................................................................ 54
6.3.1
6.4
Cdigo de la clase Sprite .................................................................................49
Cdigo para guardar archivos en el dispositivo................................................58
Descarga de archivos del servidor............................................................... 58
PLANIFICACIN TEMPORAL _______________________________60

7.1
Fases de desarrollo ..................................................................................... 60
7.1.1
7.2
Duracin de las fases.......................................................................................61
Cronologa ................................................................................................... 62
Pg. 5
COSTE DEL PROYECTO___________________________________ 63

8.1
Costes de recursos humanos....................................................................... 63
8.2
Costes de las herramientas utilizadas .......................................................... 64
8.3
Coste total del proyecto ................................................................................ 65
IMPACTO MEDIOAMBIENTAL ______________________________ 67
CONCLUSIONES _____________________________________________ 69
AGRADECIMIENTOS __________________________________________ 71
BIBLIOGRAFA ______________________________________________ 73
9.1
Referencias bibliogrficas ............................................................................ 73
ANEXOS ____________________________________________________ 75
Anexo I: Cdigo de programacin ......................................................................... 75
Pg. 7
1. Glosario
iOS: iPhone/iPod/iPad Operative System. Sistema operativo utilizado por los dispositivos
mviles de Apple
app: Aplicacin mvil.
TIC: Tecnologas de la Informacin y la comunicacin.
OS: Sistema Operativo
AS: ActionScript
POO: Programacin orientada a objetos
API: Application Programming Interface
Pg. 9
2. Prefacio
Se podra afirmar que la educacin es uno de los pilares ms importantes de la sociedad. Y
de la misma manera que sta, evoluciona y cambia para adaptarse a los nuevos modos de
hacer y avances tecnolgicos. En la actualidad, la educacin est experimentando un gran
cambio con la entrada en las aulas de las nuevas tecnologas. Este cambio precisa de
nuevos elementos que tradicionalmente no han sido utilizados en este mbito. Un grupo de
estos elementos son los dispositivos mviles. Hoy da no estn excesivamente integrados
en la educacin, pero, segn la comunidad educativa, irn adquiriendo cada vez ms peso
dentro de las aulas.
1.1 Motivacin
Ciertos centros educativos, con el nico objetivo de mantener y aumentar su excelencia
acadmica, estn desarrollando planes estratgicos de innovacin tecnolgica en diferentes
mbitos de los centro. La columna vertebral en la mayora de estos planes es la introduccin
de los dispositivos mviles en las aulas, as como convertirlos en la principal herramienta de
trabajo para el alumno. Esta es una de las realidades educativas del estado espaol en
estos momentos. Hay muchos debates abiertos sobre la conveniencia de estos planes de
innovacin, pero no los abordaremos porque no son el objeto de este proyecto.
La presencia de los dispositivos mviles en las aulas, as como la necesidad de disponer de
aplicaciones (apps) que le den una verdadera utilidad a estos dispositivos, es la principal
motivacin de este proyecto. Desde el punto de vista de la educacin, el mtodo utilizado
para transmitir conocimientos es adecuado en la medida que se adapta a lo que el profesor
necesita para realizar, de manera eficaz, esta transmisin. Es por esto, que la tecnologa en
s, los dispositivos mviles en este caso, no son ninguna ayuda para la docencia. Sin
embargo, la tecnologa actual combinada con apps adecuadas a las diferentes necesidades
de los docentes significan una gran herramienta para la educacin.
Pg. 11
2 Introduccin
Este proyecto pretende resaltar los rasgos ms relevantes del proceso de diseo y creacin
de una app para dispositivos mviles.
2.1 Objetivos del proyecto

El principal objetivo del proyecto es el desarrollo de una app para dispositivos mviles capaz
de proporcionar a los estudiantes de la ESO ejercicios prcticos para el estudio y
comprensin de las diferentes reas en las que se divide la asignatura de matemticas.
Adems, se persigue la bsqueda de un entorno amigable e intuitivo para que el alumno sea
capaz de centrar toda su atencin en los ejercicios a realizar. Se pretende reducir a la
mnima expresin la atencin a aspectos tcnicos por parte del estudiante de tal manera
que no se desve del objetivo, es decir, el aprendizaje de las matemticas.
La gestin de las diferentes ficheros de datos es uno de los temas principales del proyecto.
Su gestin eficiente y con las herramientas de programacin adecuadas es fundamental
para el buen funcionamiento de la app.
Un objetivo tcnico del proyecto es conseguir que la app corra de forma fluida. Para ejercitar
la agilidad mental de clculo en los alumnos, es necesario que la plataforma responda en
consecuencia.
Tambin desde un punto de vista tcnico uno de los objetivos consiste en desarrollar la app
de una forma poco convencional. Esto se debe a que el sistema operativo escogido para
implementar la app ha sido iOS y las app para este sistema operativo suelen desarrollarse
desde computadoras de Apple (Mac). Pero uno de los objetivos de este proyecto consiste
en buscar una alternativa a este desarrollo convencional y conseguir desarrollar la app
desde un PC con sistema operativo Windows.
2.2 Alcance del proyecto

El actual proyecto pretende analizar y describir el proceso y las herramientas utilizadas para
el diseo y desarrollo de una app basada en dispositivos mviles. La app est orientada al
aprendizaje de las matemticas en educacin secundaria. El usuario final de la app es tanto
Pg. 12
Memoria
el profesor como el alumno. A lo largo de todas las fases de desarrollo de la app se tiene
presente su posterior implementacin en el mbito del colegio, pero el estudio y anlisis de
esta implementacin se escapa a los objetivos de este proyecto.
Pg. 13
3 Sistema operativo y entorno de desarrollo

3.1
Sistema operativo
Existen tres principales sistemas operativos (a partir de ahora OS) para dispositivos mviles
que dominan actualmente el mercado mundial y, por supuesto, el espaol: iOS, Android y
Windows Phone/Windows 8. Como puede verse en la Imagen 3.1, dentro del territorio del
estado Espaol, las cuotas de mercado son del 88,1% para Android, el 7,5% para iOS y el
4,2% para Windows.
Imagen 3.1: Cuotas de mercado de los OS mviles para el estado Espaol.

De entre estas posibilidades, el sistema operativo elegido para implementar la app ha sido
iOS. ste es el sistema utilizado por los dispositivos mviles de Apple: iPod, iPhone y iPad.
A la hora de elegir este sistema operativo se han tenido en cuenta dos razones principales
que se han considerado relevantes:
1. Apple est realizando una gran promocin de sus productos en el mbito educativo
(1) y est teniendo xito en gran cantidad de centros educativos. Estos centros
desarrollan sus planes de TIC basndose, total o parcialmente, en la tecnologa
Pg. 14
Memoria
proporcionada por Apple. Por tanto, esta plataforma es una de las que necesitan
respuesta a su demanda de apps para la implementacin de sus planes.
2. De los tres OS citados, el que presenta ms dificultades para el desarrollo de una
app es iOS. Apple requiere una serie de certificados y requisitos para el testeo de
apps que parece ms interesante de investigar que otros OS. Por esto se pens que
aprendiendo a implementar apps en este OS sera ms fcil pasarse al resto de
plataformas. En realidad es as y finalmente se opt por un sistema multiplataforma
que ser explicado en siguiente apartado.
3.2 Lenguaje y entorno de programacin

La programacin de aplicaciones para iOS se lleva a cabo utilizando el lenguaje objective-C
y el entorno de programacin utilizado normalmente es X-Code. Este programa es
proporcionado por Apple de forma gratuita y corre en Mac OS. Por lo tanto el desarrollo de
apps para iOS est diseado para llevarlo a cabo con un computador de Apple.
Uno de los objetivos de este proyecto es buscar una alternativa a los dispositivos Apple
para el desarrollo de la app. Es por esto que se ha desarrollado desde un PC con OS
Windows. Se ha elegido este OS por ser el que tiene ms cuota de mercado mundial. Al
desarrollar desde esta alternativa, se ha tenido que buscar tambin una solucin alternativa
a la de programar en lenguaje Objective-C y desde la plataforma X-Code.
Tras investigar y buscar alternativas a la programacin desde Mac, se encontr un lenguaje
de programacin y un entorno adecuado a los requerimientos del proyecto. El lenguaje de
programacin elegido ha sido ActionScript (AS) y el entorno de programacin utilizado ha
sido FlashDevelop y Adobe Air.
3.2.1 ActionScript
El lenguaje de programacin AS es un lenguaje orientado a objetos. Este lenguaje fue
utilizado en sus inicios en el ao 2000 por Macromedia, aunque ms adelante pas a ser el
lenguaje utilizado por Adobe (2). Se trata de un lenguaje sencillo basado en la programacin
de Scripts y bastante influenciado por otro de los lenguajes ms populares en la actualidad:
Javascript.
Pg. 15
La versin actual de este lenguaje apareci en el ao 2006 e incorpora gran cantidad de

recursos para la gestin de datos, haciendo posible la programacin de aplicaciones de
mayor envergadura.
Programacin orientada a objetos
La programacin orientada a objetos (POO) es un tipo de programacin que utiliza las
interacciones entre los objetos para disear la estructura del programa. Un objeto es una
entidad que tiene un estado (datos), un comportamiento (mtodos o funciones) y una
identidad (identificador que lo diferencia del resto de objetos) (3).
Este tipo de programacin se empez a utilizar por la necesidad de ver como afectaban
los cambios de unos elementos (datos) con otros. A diferencia de la programacin
estructurada tradicional, que slo busca procesar unos datos de entrada y devolverlos, la
POO crea los objetos y despus les manda mensajes solicitndoles que realicen las
acciones (mtodos) que ellos mismos tienen definidos.
Los mtodos y propiedades comunes de los diferentes objetos estn encapsulados en las
clases. Por tanto, un objeto y su comportamiento estn definidos por lo que contiene su
clase. Estas clases pueden ser creadas por el programador o simplemente las
proporcionan
las
diferentes
libreras
disponibles
dependiendo
del
entorno
de
programacin.
Uno de los rasgos interesantes y tiles de este tipo de programacin es la herencia. La
herencia se utiliza para crear nuevas clases a partir de las ya existentes, de tal manera
que la nueva clase hereda todos los mtodos y caractersticas de la clase dentro de la
que se ha creado. Se trata de una caracterstica muy prctica porque para crear un nuevo
objeto con ciertos mtodos existentes en otra clase, que son de inters para el
programador, lo nico que ha de hacer es aadir dos palabras de cdigo en la nueva
clas. De esta manera, todos los mtodos de la clase existente, son heredados y pueden
ser utilizados por la nueva (4).
ltima versin de ActionScript : AS 3.0
La versin 3.0 del lenguaje de Adobe vio la luz en 2006. Esta versin incluye un nuevo
motor para la maquina virtual que ejecuta AS. El nuevo motor AVM2 consigui multiplicar
por 10 la velocidad de procesamiento de su predecesor AVM1 (5). Este aumento de
Pg. 16
Memoria
velocidad, unido a las nuevas caractersticas del leguaje, hacen posible desarrollar
complejas aplicaciones y procesar cantidades de datos considerables de manera ms
eficiente y fcil.
Durante aos AS ha sido considerado un lenguaje de programacin pobre. Sin embargo,
actualmente se ha convertido en un lenguaje utilizado por una importante cantidad de
programadores. En Agosto de 2014 AS ha entrado en la lista de los 20 lenguajes ms
utilizados por los programadores (6). Esto se debe a las mejoras introducidas por esta ltima
versin y al esfuerzo realizado por Adobe para conseguir acompaar el lenguaje de una
serie de plataformas que le dan mayo utilidad. Una de estas plataformas es Adobe Air, la
cual se ha utilizado para desarrollar este proyecto y se explicar al final de este captulo.
3.2.2 FlashDevelop
El entorno de programacin elegido para el desarrollo de la app es FlashDevelop. Se trata
de un entorno de programacin de cdigo libre promocionado por una comunidad de
desarrolladores (7). Durante aos, para programar con AS slo se poda hacer mediante los
programas de Adobe, es por esto que nacieron plataformas alternativas que ofrecen soporte
a este lenguaje. FlashDevelop naci en 2005 y actualmente es una alternativa importante
para cualquier programador que utilice AS 3.
La plataforma FlashDevelop permite corregir la sintaxis del cdigo en tiempo real. Tambin
es capaz de compilar y ejecutar el programa, as como la posibilidad de depurarlo. Por
ltimo, aparte de otras caractersticas, nos permite empaquetar el programa para su
posterior testeo o depuracin en el dispositivo.
Pg. 17
Imagen 3.2: Interfaz grfica de la plataforma FlashDevelop V4.6.2.5

Una caracterstica importante por la que se eligi esta plataforma es que tiene la posibilidad
tambin de trabajar con Adobe Air.
3.2.3 Adobe Air

Adobe AIR (Adobe Integrated Runtime) (8) es un entorno de ejecucin multiplataforma para
permitir que aplicaciones RIA (Rich Internet Applications) puedan ejecutarse como
aplicaciones de escritorio. Aplicaciones enriquecidas de internet (RIA), es el trmino segn
el cual se define a las aplicaciones web que se comportan del mismo modo que las
tradicionales aplicaciones de escritorio, pero con la capacidad de ser ejecutadas en
cualquier navegador web independientemente del OS utilizado por el dispositivo (9).
Adobe define su plataforma AIR as:
"Adobe AIR es un motor de ejecucin multipantalla vlido para todos los sistemas operativos que
le permite aprovechar sus habilidades de desarrollo web para crear e implementar aplicaciones
enriquecidas de Internet (RIA) en el escritorio y dispositivos mviles. Las aplicaciones de AIR mviles,
de televisin y escritorio se pueden crear con ActionScript 3.0 utilizando Adobe Flex y Adobe
Flash (basado en SWF). Las aplicaciones de AIR de escritorio tambin se pueden crear con HTML,
JavaScript y Ajax (basado en HTML)." (10)
Pg. 18
Memoria
Por tanto, lo que hace posible Adobe AIR es que el cdigo empaquetado para una
aplicacin web pueda ejecutarse como una aplicacin nativa para varios OS: Windows,
MacOS, Linux, iOS, android, etc. De esta manera escribiendo un nico cdigo puedes hacer
que la app corra en todas las plataformas ms utilizadas actualmente.
El objetivo del proyecto no es hacer correr en el escritorio app de internet, ni realizar app
multiplataforma, pero la plataforma Adobe AIR permite realizar el desarrollo de la app en un
dispositivo con Windows y posteriormente hacerla correr en dispositivos con iOS. Por lo
tanto permite que se alcance uno de los objetivos del proyecto.
3.2.4 Interfaz de programacin de aplicaciones (API)

Las interfaces de programacin son una herramienta utilizada en la programacin de
aplicaciones como capa de abstraccin. Se habla de que son una capa de abstraccin
porque permite al programador no tener que descender a niveles inferiores en la
programacin. Los niveles inferiores son los que dan las instrucciones al dispositivo sobre
las acciones que ha de realizar. Por tanto, las APIs son las encargadas de contener las
funciones que controlan el dispositivo y el programador solamente ha de invocar a las APIs
para que ejecuten sus funciones.
Como ejemplo de abstraccin en la programacin y del trabajo realizado por las APIs se
podra explicar el hecho de mostrar una frase por pantalla. El dispositivo, a la hora de
mostrar la frase, ha de crear pixel a pixel cada letra, pero el programador no desciende a
este detalle, sino que utiliza la API de texto que se encargar de realizar todo ese trabajo.
El ejemplo anterior muestra dos niveles de programacin (abstraccin) muy lejanos entre s.
Un ejemplo intermedio sera el caso en el que hay que indicarle al dispositivo los caracteres
que ha de mostrar por pantalla. El programador tendra que indicar carcter a carcter todos
los que se han de mostrar. Pero para realizar este trabajo utilizar una API que le separe
una cadena de caracteres introducida en caracteres sueltos y se los indique al dispositivo.
En definitiva, los diferentes niveles de abstraccin en la programacin son el hecho
descender a programar hasta las tareas ms automticas o no. El programador se ocupa de
los niveles altos, donde ha de organizar el cdigo y las diferentes acciones a realizar por el
programa.
Un problema que aparece a la hora de utilizar APIs de alto nivel (alto nivel de abstraccin)
es la prdida de flexibilidad. La flexibilidad se refiere a que lo ejecutado por la app sea
exactamente lo que el programador est pensando, es decir, que se pueda detallar todo, a
travs de la API, hasta el nivel deseado. Por ejemplo, si se programa desplazar una imagen
Pg. 19
que se muestra por pantalla a travs de una API, sta mover la imagen segn el mtodo
que contenga, pero a lo mejor el programador prefiere realizar la accin con ms fotogramas
por segundo. En estos casos, se debera descender al nivel de la API para recuperar esa
flexibilidad.
Las APIs suelen estar agrupadas en bibliotecas que los programadores tienen disponibles.
Cada OS tiene sus APIs especficas dependiendo de cmo se programe y el lenguaje
utilizado para ese OS concreto.
Las APIs son un elemento clave para entender cmo funciona Adobe AIR porque sin ellas
no sera posible el propsito de AIR. A diferencia de otras bibliotecas de APIs, Adobe AIR
incorpora unas cuantas muy tiles para ejecutar ciertas acciones de modo nativo en los
dispositivos mviles. Un ejemplo de estas sera la API del teclado nativo del OS.
El motor de ejecucin de Adobe AIR se encarga de gestionar estas APIs para conseguir
ejecutar los programas en varias plataformas.
3.2.5 Motor de ejecucin

El funcionamiento de adobe AIR se basa en su motor de ejecucin. ste se instala en el
dispositivo para poder ejecutar posteriormente las aplicaciones que se vayan instalando. Los
dispositivos que utilizan iOS son una excepcin porque no se instala una vez, sino que cada
aplicacin funciona de modo independiente, es decir, la app incorpora el motor de ejecucin
y lo instala.
El trabajo que realiza el motor de ejecucin cosiste en gestionar las APIs segn la
plataforma en la que se est ejecutando la app. Este hecho es muy importante, porque al
utilizar Adobe AIR no ests programando para un OS sino para un motor de ejecucin, el
cual entiende los lenguajes de programacin Script antes mencionados. El motor ser el
encargado de interpretar el cdigo y transmitirlo a las APIs correspondientes. Estas API s
que estn escritas en el lenguaje del dispositivo. En la Imagen 3.3 se muestra un esquema
de funcionamiento de la plataforma Adobe AIR.
Pg. 20
Memoria
Imagen 3.3: Esquema de funcionamiento de Adobe AIR.

En el actual proyecto se ha desarrollado para iOS pero, gracias a esta herramienta de
Adobe, la app se podra implementar en cualquiera de los OS anteriormente citados.
Como se ha dicho anteriormente, Adobe AIR permite implementar las app de forma nativa
en los diferentes OS. Esto consigue que el rendimiento de las app sea considerablemente
bueno y que puedas utilizar todas las posibilidades nativas del dispositivo donde se
implementa.
Pg. 21
4 Funcionalidad, Diseo y Estructura

El principal objetivo de este proyecto es que la app sea una ayuda real al alumno, se ha
diseado todo desde un punto de vista educativo y particularmente se han pensado todas
las funciones que tiene que llevar a cabo la app con esta perspectiva. Se trata de buscar la
mayor simplicidad posible para el alumno, de tal manera que se pueda centrar totalmente en
su trabajo y motivarlo para que lo realice.
4.1 Funcionalidad y Diseo

En este apartado se describirn las diferentes funciones que ha de desarrollar la app. La
mayor parte de estas funciones estn orientadas a la gestin de los ficheros de datos
existentes en el programa. Por un lado est el fichero que contiene los ejercicios y por otro el
que contiene los alumno. El modo concreto de gestionar estos ficheros, as como su cdigo
de programacin son explicados en profundidad en el captulo 5 (pg. 39) debido a su
profundidad e importancia para el buen funcionamiento de la app.
Las funcionalidades de la app se han dividido segn si es utilizada por el alumno o por el
profesor. La actual aplicacin incluye todas las funcionalidades, pero para su implantacin
en una entidad educativa se utilizan por separado en dos app diferentes. Una de ellas es
para el profesor y la otra para el alumno. La app del alumno utiliza los ficheros de datos
confeccionados desde la app del profesor y tiene menos opciones que sta.
En el Esquema 4.1 se muestran las funciones principales de la app, as como el flujo de
datos que existe entre ellas.
Pg. 22
Memoria
Esquema 4.1: Flujo de datos entre las funciones
Pg. 23
Como se ha explicado, el diseo de la app depende, en su gran mayora, de la estructura

elegida, pero un componente que tambin marca el diseo es su carcter educativo. En este
sentido se procura conseguir que sea una herramienta para el aprendizaje. Es por esto que
se han evitado todo tipo de distracciones para el alumno pero a la vez con un diseo
prctico y amigable.
El pblico hacia el que va dirigido tambin marca la lnea de un diseo totalmente intuitivo.
Es verdad que la app ser utilizada tanto por alumnos como profesores, pero el usuario final
preferente es el alumno, por lo tanto el diseo ser lo ms intuitivo posible. Debido a esto se
ha optado por un diseo con iconos grandes y claros y sin muchas explicaciones.
A continuacin se explican con ms detalle las funciones y diseo de la app. El cdigo de
programacin utilizado para llevar a cabo todas estas funciones se encuentra detallado en el
captulo 6 (pg. 49).
4.1.1 Funciones del profesor

4.1.1.1 Gestin del fichero de ejercicios
La app ha de ser capaz de gestionar el fichero de ejercicios, los cuales constituyen el
contenido principal de la app. Este fichero se encuentra disponible en un servidor. Se trata
de un archivo de texto plano guardado como XML. El formato XML ser el utilizado para
guardar todos los datos de la app. En el captulo 5 se explica con detalle cmo funciona este
formato. Las funciones fundamentales que ha de llevar a cabo la app son crear nuevos
ejercicios, poder cambiar alguno ya existente y eliminar los que se desee. Para poder
realizar estas funciones, ha de poder acceder al fichero que contiene los ejercicios
existentes y mostrarlos por pantalla.
Desde la app se da la opcin de gestionar el fichero de ejercicios, pero tambin se puede
realizar esta gestin desde fuera de la app utilizando cualquier software capaz de gestionar
archivos XML. Existen muchos programas de ofimtica capaces de trabajar con este tipo de
archivos. Lo nico que ha de realizar el usuario tras gestionar el archivo es colgarlo en el
servidor para que la app pueda acceder a l.
Pg. 24
Memoria
Imagen 4.1: Pantalla diseada para la gestin del fichero de ejercicios
Pg. 25
En el Esquema 4.2 se muestra el flujo de datos entre el servidor y la app.
Esquema 4.2: Flujo de datos generado por la gestin de la BD de ejercicios
4.1.1.2 Creacin del fichero de deberes

El profesor dispone de un fichero general, creado y gestionado por l, que contiene todos los
ejercicios. Pero al alumno slo se le presentarn unos ejercicios concretos a modo de
deberes dependiendo del da. Por tanto, otra de las funciones que tendr que hacer la app
es seleccionar los tems que desee el profesor y confeccionar una nuevo fichero que ser
puesta a disposicin del alumno. De esta manera, el archivo creado desde la app del
profesor ser utilizado tambin por la app del alumno.
Pg. 26
Memoria
Imagen 4.2 a) Pantalla donde se crea o selecciona el archivo de datos y b) Pantalla donde se
seleccionan los ejercicios para el nuevo fichero
Pg. 27
El flujo de datos correspondiente a la generacin de este nuevo fichero queda reflejado en el

Esquema 4.3.
Esquema 4.3: Flujo de datos generado por la creacin de la BD de deberes
4.1.1.3 Gestin del fichero de alumnos

Igual que el fichero que contiene los ejercicios, existen otros que contienen los datos de los
alumnos que tendrn acceso a la app. stos tambin se encuentran albergados en el
servidor y de la misma manera que el anterior podr ser gestionado tanto desde dentro de la
app como desde fuera. La app tendr que poder crear nuevos registros con alumnos,
modificar alguno de los existentes y eliminar otros.
Los ficheros de alumnos se han organizado segn su forma natural, es decir, por clases. De
cara al diseo de la app esto implica que para visualizar el fichero de una clase antes se ha
de seleccionar la clase a la que se quiere acceder. Por este motivo existen las pantallas
mostradas en la Imagen 4.3 (a y b). Se trata de las pantallas para seleccionar la clase.
Pg. 28
Memoria
Imagen 4.3: a) Pantalla de seleccin de curso, b) pantalla de seleccin de clase y c) pantalla para la
gestin de los alumnos
Pg. 29
En el Esquema 4.4 se muestra el flujo de datos que genera la gestin de este fichero.
Esquema 4.4: Flujo de datos generado por la gestin de la BD de alumnos
4.1.1.4 Visualizacin de resultados

La app se propone ser una herramienta de evaluacin para los profesores, por tanto, stos
han de tener acceso a los resultados obtenidos por los alumnos. Esos resultados se
encuentras en el fichero de alumnos, as que esta funcin ha de tener acceso a l. No ha de
gestionar el contenido del fichero, sino mostrar los datos por pantalla con una cierta
estructura.
Se ha realizado una pantalla sencilla que muestra los datos principales de cada alumno,
pero dependiendo de los profesores se programarn unos datos para mostrar u otros.
Pg. 30
Memoria
Imagen 4.4:Pantalla de visualizacin de resultados

En el Esquema 4.5: Flujo de datos generado para visualizar los resultados por pantalla.
Esquema 4.5: Flujo de datos generado para visualizar los resultados por pantalla
Pg. 31
4.1.2 Funciones del alumno

4.1.2.1 Resolucin de ejercicios
Esta parte ser la encargada de llevar a cabo el objetivo principal de toda la app porque es
la que proporciona al alumno la posibilidad de resolver los ejercicios. Se trata de la funcin
que presenta al alumno los ejercicios propuestos por el profesor y los va corrigiendo a
medida que son realizados. Esta funcin ha de tener acceso a dos ficheros: el de deberes y
el de alumnos. A travs del fichero de deberes podr obtener los ejercicios para presentarlos
al alumno y el fichero de alumnos ser utilizado para guardar los resultados de stos.
Para esta funcin se han diseado dos pantallas. La que se visualiza en primer lugar es
para recoger los datos del alumno que resolver los ejercicios. En esta el alumno a de
escribir su nombre y contrasea. La siguiente pantalla se visualiza tras introducir los datos
del usuario. Esta ltima es propiamente la pantalla donde se resolvern los ejercicios.
Pg. 32
Memoria
Imagen 4.5: a) Pantalla de introduccin de usuario; b) pantalla de resolucin de ejercicios; c)

pantalla de solucin correcta y d) pantalla de solucin incorrecta
Pg. 33
Imagen 4.6: Pantalla de deberes finalizados
En la Esquema 4.6 se explica detalladamente el flujo de datos que genera la app para llevar
a cabo esta funcin de la app.
Pg. 34
Memoria
Esquema 4.6: Flujo de datos generado para que los alumnos resuelvan los ejercicios
4.1.2.2 Competicin entre alumnos

Los resultados obtenidos por los alumnos, contando el numero de aciertos y errores de cada
uno, se utiliza para confeccionar una competicin. La competicin que se ha pensado para
el primer lanzamiento de la app ha sido una simple carrera de motos. Esta funcin de la app
debe calcular la puntuacin de cada alumno de una misma clase segn sus resultados y
generar la visualizacin de la carrera. Para esto necesita acceder al fichero de alumnos.
Pg. 35
Imagen 4.7: Competicin entre alumnos

En el Esquema 4.7 se puede observar el flujo de datos que generes la construccin de la
competicin entre alumnos.
Pg. 36
Memoria
Esquema 4.7: Flujo de datos generado para construir la competicin entre alumnos
4.2 Estructura.
La estructura se ha desarrollado basndose en las diferentes funciones que tendr que
desarrollar la app. Se ha estructurado todo a travs de un men principal desde el cual se
accede a las funciones explicadas anteriormente. A partir de este men toda la estructura
est basada en diferentes niveles de pantallas. Desde el men principal se va accediendo a
pantallas ms profundas en la estructura.
Desde un punto de vista prctico y de accesibilidad sera ms recomendable una estructura
con un men permanentemente visible desde el que seleccionar la funcin a la que se
desea acceder, pero al no tener una estructura muy profunda de pantallas, ni muchas ms
funciones, no se ha visto conveniente utilizar este tipo de estructura.
Las pantallas de la estructura, excepto el men principal, incorpora un botn para retroceder
a la pantalla anterior. Adems, cada pantalla cuenta con todos los botones necesarios para
realizar las funciones que se requieren en esa pantalla.
Imagen 4.8: Pantalla del men principal

En el Esquema 4.8 se muestra el esquema de pantallas de la app.
Pg. 37
Pg. 38
Memoria
Esquema 4.8: Estructura de pantallas
Pg. 39
5 Gestin y estructura de los ficheros de datos

Como se ha explicado en el captulo 4, hay tres ficheros que se han de gestionar: el que
contiene todos los ejercicios, los creados para los deberes de los alumnos y el que contiene
todos los datos de los alumnos. Cmo tambin se ha explicado, el mtodo utilizado para
organizar los ficheros es el formato XML.
5.1 XML: eXtensible Markup Lenguage

El lenguaje XML es la evolucin de un lenguaje que fue inventado por IBM en la poca de
los ochenta con el nombre de GML (Generalized Markup Lenguage). Se trata de un
lenguaje que funciona a base de etiquetas. Un ejemplo de lenguaje marcado por etiquetas
es el famoso HTML. El lenguaje GML surgi de la necesidad, por parte de las empresas, de
almacenar gran cantidad de informacin. El actual lenguaje XML se diferencia de sus
predecesores en que permite combinar elementos del vocabulario de lenguajes distintos y
de esta manera no se cierra a un nico lenguaje como sera HTML y otros. Adems, puede
ser ledo y escrito por cantidad de editores ya que es fcil de entender incluso por terceros.
En cuanto a su almacenamiento no presenta problemas ya que es un archivo de texto plano
que ocupa poca memoria. Por tanto, se trata de una herramienta muy eficaz para el
almacenamiento y transmisin de informacin.
5.1.1 Estructura y funcionamiento del cdigo XML

Este lenguaje, como su nombre indica, trabaja a base de marcado, es decir, de etiquetas.
Estas etiquetas son utilizadas para estructurar la informacin del documento y, por tanto,
poder tener acceso posteriormente (9). Para crear una etiqueta, es tan simple como abrirla,
introducir la informacin que ha de contener la etiqueta y cerrarla:
1
<texto>esto es un ejemplo</texto>
La etiqueta "texto" tendra el contenido "Esto es un ejemplo" dentro de ella porque entre la
marca que abre la etiqueta y la que cierra se encuentra dicho contenido. Siguiendo esta
estructura se pueden introducir unas etiquetas dentro de otras, de tal manera que se puede
crear una estructura por niveles:
Pg. 40
1
2
3
4
5
6
Memoria
<todoslosejemplos>
<datosejemplo>
<texto>Esto es un ejemplo</texto>
<esbueno>Si</esbueno>
</datosejemplo>
</todoslosejemplos>
Por tanto, se podra acceder a la informacin de la etiqueta "esbueno" descendiendo a

travs de la estructura de etiquetas:
datosejemplo.esbueno
El valor de este acceso devolvera la cadena de texto: Si
Por medio de las etiquetas se puede crear una estructura tan compleja como se requiera,
sabiendo que se podr acceder a la informacin posteriormente descendiendo por la
estructura hasta la etiqueta deseada.
Por ltimo, en cada etiqueta se puede incorporar uno o ms atributos que caractericen esa
etiqueta:
1
2
3
4
5
6
<todoslosejemplos>
<datosejemplo id="1">
</datosejemplo>
</todoslosejemplos>
En el ejemplo anterior se define el atributo "id", que se podra utilizar para identificar cada
uno de los ejemplos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<todoslosejemplos>
</datosejemplo>
<texto>Este es otro ejemplo</texto>
<esbueno>No</esbueno>
</datosejemplo>
<texto>Y otro ejemplo</texto>
<esbueno>No</esbueno>
</datosejemplo>
<texto>Ms ejemplos</texto>
</datosejemplo>
</todoslosejemplos>
Por tanto, y resumiendo, se trata de un lenguaje que almacena la informacin por partes,
delimitadas por marcas, de tal manera que se puede manejar la informacin al nivel que se
Pg. 41
requiera. Se pueden almacenar grandes cantidades de informacin de forma ordenada para

su acceso. Adems, al tratarse de archivos de texto plano ocupan muy poca memoria.
5.1.2 Otras alternativas

Existen otras alternativas, tambin dentro de los lenguajes de marcado, que se podran
utilizar. Quiz la mejor alternativa que se tiene a XML es JSON. Este lenguaje es el utilizado
por Java para el almacenamiento de datos. La principal ventaja que tiene respecto a XML es
que los archivos son ms sencillos, y por tanto ocupan menos espacio.
Se ha decidido utilizar XML principalmente por dos motivos. En primer lugar JSON es un
lenguaje pensado para Java, mientras que ActionScript, aunque tambin tiene la posibilidad
de utilizarlo, est ms orientado y facilita el uso de XML mediante funciones directas que
permiten gestionar los archivos (10).
Y en segundo lugar, la cantidad de informacin
enviada y recibida no es excesivamente extensa, por tanto, el nivel de trfico de datos no es

una caracterstica preocupante en este proyecto.
5.2 Cdigo para la gestin de XML

En este apartado se explicar cmo se gestiona, desde el punto de vista de la
programacin, los ficheros en formato XML.
Desde el punto de vista de la programacin la gestin de los ficheros de datos no plantea
grandes problemas. Las operaciones a realizar son principalmente asignaciones de objetos
tipo cadena de un cuadro de texto a los archivos XML. Aquello que s puede presentar
problemas a la hora de gestionar los ficheros es el tamao y la cantidad de datos que
contiene. Por esto hay que estudiar bien los campos que ha de contener cada registro. Esto
ser explicado en el apartado 5.3.
Para la creacin de los archivos XML se utiliza la clase XML. Esta clase crea una variable
tipo XML en la que se pueden ir aadiendo nuevas cadenas de texto que ella interpreta
como cdigo XML. Tambin permite eliminar registros dentro de la variable segn diferentes
parmetros como pueden ser las etiquetas del cdigo XML o el ndice en el que se
encuentra el registro. Estas dos caractersticas de la clase XML son las que se han utilizado
para la gestin de los archivos XML, el resto son asignaciones de cadenas de texto dentro
de la variable XML.
Se ha de remarcar que lo explicado anteriormente gestiona el cdigo XML dentro de la app
y en tiempo de ejecucin, pero no crea el archivo para almacenarlo en la memoria del
Pg. 42
Memoria
dispositivo o enviarlo al servidor. De esta forma, las herramientas que nos proporciona la
clase XML simplemente son para poder estructurar e interpretar el cdigo XML, pero no crea
ningn archivo de salida con formato XML, sino que utiliza una variable en tiempo de
ejecucin que es eliminada al cerrar la app. Por tanto, una vez finalizada la gestin del
cdigo se ha de guardar en un archivo externo para poder ser utilizado con posterioridad. El
mtodo utilizado para guardar el archivo ser explicado en el captulo 6.5.
5.2.1 Creacin de una variable XML

A continuacin se muestra como se crea la estructura XML de un nuevo registro para un
fichero de datos a travs de los datos introducidos por el usuario:
451 var xml:XML =
452 <problema id={iGuardar}>
453 <dificultad>{dificultad.text}</dificultad>
454 <tema>{tema.text}</tema>
455 <enunciado>{enunciado.text}</enunciado>
456 <solucion>{solucion.text}</solucion>
457 </problema>;
En la primera lnea se crea la variable XML y se le asigna directamente una cadena de texto.
Esta cadena contiene todas las etiquetas necesarias para encajar en la estructura del
fichero al que se introducir despus. Los corchetes utilizados dentro de las etiquetas son
para hacer referencia al texto que contienen los cuadros de texto correspondientes. Este
texto es el introducido por el usuario.
Por tanto, lo que se ha creado con este cdigo es una variable con el nombre "xml" que
contiene los datos de un registro que se introducir posterior mente en el fichero.
5.2.2 Aadir registros nuevos a un fichero

Con la lnea de cdigo que se presenta a continuacin se introduce la pequea estructura
XML que se ha creado anteriormente dentro del fichero (el cual es otra variable XML de
mayor tamao) que contiene todos los ejercicios. Se introduce la variable "xml" dentro de
"problemas".
458 problemas.appendChild(xml);
La operacin que lleva a cabo la funcin appendChild es introducir una variable XML como
un elemento ms (un hijo) de otra variable XML. La variable "problemas" que aparece en el
cdigo es el fichero de ejercicios. ste se obtiene del servidor y se convierte en una variable
XML de la app para poder introducir, eliminar o modificar registros de la estructura.
Posteriormente se vuelve a guardar en un archivo para poder enviarlo al servidor de nuevo.
Pg. 43
5.2.3 Conversin de un archivo en una variable XML

En los esquemas Esquema 4.2 yEsquema 4.4 se explica los flujos de datos generados para
gestionar los ficheros de ejercicios y alumnos respectivamente. El fichero se obtiene del
servidor, pero una vez descargados hay que convertirlos en una variable XML para poder
trabajar con ellos. Para transformar un archivo de texto plano en variable XML se utiliza la
siguiente funcin:
43
var registro:XML = new XML();
65
registro = XML(Reg.data);
En la primera lnea se crea una variable XML llamada "registro" y en la siguiente lnea se le
asigna el contenido. El archivo se llama "Reg". A travs de la funcin XML(Reg.data)se
convierte el contenido del archivo en una estructura XML. Esta estructura se le asigna a la
variable "registro".
De esta forma, a la variable "registro" se le aadirn, eliminarn y modificarn datos de su
estructura. Una vez realizados los cambios en la variable se vuelve a guardar en el archivo:
461
Reg.data = registro;
5.2.4 Consulta de datos dentro de los ficheros

Una de las funciones de los ficheros es que se puedan consultar los datos. Para obtener
datos de una estructura XML es tan sencillo como navegar por su estructura buscando algo
concreto. En el captulo 5.1.1 se ha explicado cmo funciona la estructura XML. En las
siguientes lneas de cdigo se muestra como buscar datos dentro de una estructura XML:
366 regxml.datosalumnos.alumno.(nombre == Us.text).curso;
367 regxml.datosalumnos.alumno.(nombre == Us.text).clase;
En estas lneas se est consultando un dato cuyo campo "nombre" coincida con el que se
busca (nombre == Us.text). El dato que se quiere obtener en la primera lnea es el
curso del registro cuyo nombre coincide con el que se encuentra en el cuadro de texto
llamado "Us". Para obtener este dato hemos de descender por toda la estructura desde el
nombre de la variable XML ("regxml") hasta el dato que queremos "curso" o "clase".
A base de comparar campos del archivo XML se pueden buscar los datos, pero tambin se
puede consultar por el "nudo" de la estructura que contiene la informacin que se necesita.
A continuacin se muestra un ejemplo:
202 registro.alumno[3].nombre;
En esta lnea de cdigo se busca el nombre del alumno que est en el nodo (posicin) 3 de
la estructura.
Pg. 44
Memoria
Tras consultar un dato dentro de la estructura tambin se puede modificar:

202 registro.alumno[index].nombre = nombretext.text;
203 registro.alumno[index].contrasea = contrasea.text;
En las lneas anteriores se asigna el contenido de un cuadro de texto a campos ya
existentes de la variable "registro". En concreto se cambia el campo "nombre" y
"contrasea". Para eso, primero se ha seleccionado el registro a cambiar realizando la
bsqueda del nudo que tiene el mismo valor que la variable "index".
5.2.5 Recorrer toda la estructura de una variable XML

Los ndices de los registro introducidos en los ficheros es una de los aspectos complicados
de solucionar. Para conseguir el ndice del siguiente registro a introducir, o para re-numerar
los ndices si se ha eliminado un registro, se utiliza otra opcin de la clase XML:
83 //Selecciona la id del problema a introducir//
84
var iGuardar:int = 0;
85
for (var pname:String in problemas.problema)
86
{
87
if (problemas.problema.@id[pname] < iGuardar)
88
{
89
} else {
90
iGuardar = problemas.problema.@id[pname];
91
}
92
}
93 //Selecciona la id del problema a introducir//
Con este cdigo se recorren todos los registros de XML a travs del bucle for y se
comprueban los ndices. Esta herramienta ha sido utilizada en varias ocasiones durante la
programacin de la app porque es la nica alternativa para encontrar un registro concreto
sin conocer su posicin en la estructura XML.
5.2.6 Eliminar registros de una variable XML

Para eliminar registros existentes dentro de una variable XML se utiliza el siguiente cdigo:
delete problemas.problema[4];
En la lnea de cdigo anterior se elimina el problema que se encuentra en el nudo 4 de la
estructura. Para eliminar un registro previamente se ha de conocer su posicin dentro de la
estructura.
Pg. 45
5.3 Contenido de los ficheros

5.3.1 Fichero de alumnos
El fichero de alumnos es la que se encarga de almacenar los datos de todos los posibles
usuarios de la app. Este fichero es gestionado desde la app del profesor y tanto ste como
la app del alumno la utilizan para introducir y visualizar resultados.
La informacin que debe almacenar este fichero es:
Curso al que pertenece el alumno: se indica con un nmero
Letra de la clase: una letra mayscula de la "A" a la "D"
Datos de los alumnos

o
Nombre del alumno: cadena con el nombre del alumno
Contrasea para acceder a su sesin: cadena con la contrasea
La puntuacin actual del alumno

Nmero de aciertos acumulados al resolver los ejercicios
Nmero de errores acumulados al resolver los ejercicios
Intentos acumulados para realizar todos los ejercicios
Como se ha explicado anteriormente, se almacenarn estos datos en formato XML. Por

tanto, utilizando las herramientas anteriores, se la estructura del archivo que sera la
siguiente:
Pg. 46
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Memoria
<datosalumnos>
<curso>1</curso>
<clase>A</clase>
<alumno>
<nombre>Miguel el Bueno</nombre>
<contrasea/>
<puntos>
<aciertos>1</aciertos>
<errores>0</errores>
<intentos>1</intentos>
</puntos>
</alumno>
<alumno>
<nombre>a</nombre>
<contrasea>a</contrasea>
<puntos>
</puntos>
</alumno>
<alumno>
<nombre>Paco Martinez</nombre>
<contrasea>123456</contrasea>
<puntos>
</puntos>
</alumno>
</datosalumnos>
Todos los datos se introducen en un tipo de dato llamado cadena (String). Se trata de una
cadena de caracteres seguidos que posteriormente cualquier programa puede interpretar,
segn se requiera, como numero o como texto.
El fichero se ha organizado segn las clases del centro educativo en el que se implemente.
De tal manera que cada clase de cada curso tiene un archivo propio para guardar sus datos.
La razn para separarlas es que la app del alumno slo utiliza la informacin de una clase y
sera innecesario hacerle utilizar un archivo ms extenso de los datos que estrictamente
necesite.
Con el fin de que el fichero no se sature de datos innecesarios al introducir una nueva
entrada, se comprueba que no exista. Y cada vez que se le manda la orden de eliminar un
registro, se borra toda la informacin de ese registro. Se ha programado cada actualizacin
del fichero para que todo quede estructurado y sin datos que la distorsionen.
Pg. 47
5.3.2 Fichero de Ejercicios

El fichero de ejercicios quiz es el que ha de gestionar mayor cantidad de datos porque de
ella dependen todos los ejercicios que utilizarn los alumnos. Su gestin es muy parecida al
de alumnos, pero en este s que cobra vital importancia el hecho de que no haya elementos
repetidos. Que ocurra esto es bastante fcil, ya que el profesor si no encuentra el ejercicio
que quiere, lo introducir, y la app ha de ser capaz de indicarle que ese ejercicio ya existe.
Este fichero debe almacenar los siguientes datos de cada ejercicio:
Nmero de identificacin del ejercicio: se aade como un atributo del problema
Enunciado: cadena con el enunciado del problema
Solucin: cadena con la solucin del problema
Tema en el que se encuadra el ejercicio
Nivel de dificultad: existen tres niveles valorados de 1 a 3
Por tanto el archivo que guarda los ejercicios quedara as:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<datos>
<problema id="1">
<dificultad>1</dificultad>
<tema>Numeros enteros</tema>
<enunciado>Calcula: 2+2</enunciado>
<solucion>4</solucion>
</problema>
<problema id="2">
<tema>Raices y potencias</tema>
<enunciado>Calcula la raiz cuadrada de
cuatro</enunciado>
</problema>
<problema id="3">
<tema>Proporcionalidad</tema>
<enunciado>El 20% de 150 es:</enunciado>
</problema>
</datos>
En este caso se almacenan todos los ejercicios existentes en un nico archivo. El tamao de
este archivo no es un dato determinante para la app, ya que se gestiona solamente desde la
app del profesor. A partir de este archivo el profesor selecciona los ejercicios que quiere
utilizar para algo en concreto y genera otro de menor tamao, que ser la utilizada por el
alumno en su app.
Pg. 48
Memoria
5.3.3 Fichero de deberes

Como se ha explicado, este fichero es creado a partir del que contiene todos los ejercicios.
El profesor selecciona los ejercicios que quiere incorporar al nuevo fichero. La app del
alumno ha sido programada para que cada da del ao utilice el archivo cuyo nombre se
corresponde con la fecha de ese da. De esta manera los profesores pueden decidir que
deberes han de hacer los alumnos cada da del ao, o los das que simplemente no hay
deberes, porque no crearn un archivo con esa fecha.
El modo de creacin de este fichero es tan sencillo como copiar el cdigo XML de cada
ejercicio al nuevo fichero, as se acaba confeccionando una nueva estructura XML que
contiene slo los elementos seleccionados. Debido a esto, la estructura de este nuevo
fichero es exactamente igual que el que contiene todos los ejercicios, pero de menor
extensin.
Pg. 49
6 Cdigo y arquitectura
En este apartado se explicar de manera detallada los rasgos importantes del cdigo
utilizado para la creacin de la app.
En el captulo 3.2.1 del presente documento se ha explicado el funcionamiento de las clases
dentro del lenguaje de programacin utilizado. Esta es una de las caractersticas principales
de este lenguaje. Para la estructura de la app se ha tratado cada pantalla (o capa) como una
clase diferente que incluye toda la funcionalidad necesaria para esa pantalla. De esta
manera tenemos una clase independiente para cada capa.
6.1 La clase principal: Sprite

Desde los inicios de AS las herramientas utilizadas para la visualizacin de elementos por la
pantalla del dispositivo han estado basadas en la lnea de tiempo. Por tanto, todo lo que el
usuario visualizaba por pantalla dependa del estado de esta lnea de tiempo. En la ltima
versin de AS (AS3) ha aparecido un elemento de programacin denominado Sprite, el cual
no depende de la lnea del tiempo. Este elemento no es ms que una clase que contiene las
funcionalidades necesarias para mostrar elementos sin necesidad de lnea de tiempo.
Esta clase es la que ha sido utilizada para poder visualizar por pantalla los elementos de la
app. Se puede decir que es la clase principal porque sin ella no sera posible utilizar la app.
Adems, de ella depende lo que se quiere mostrar por pantalla y lo que no, por lo tanto es
un elemento bsico para gestionar todos los elementos que intervienen en la app.
6.1.1 Cdigo de la clase Sprite

Al tratarse de una clase que est incluida en las bibliotecas de AS, es decir, que viene
construida por defecto debemos hacer que las clases que creemos hereden las funciones
de la clase Sprite. El concepto de "herencia" se explic en el captulo 3.2.1. Esto lo
conseguimos introduciendo la palabra extends al inicio de la clase:
15
16
17
18
19
import flash.text.TextFormatAlign;
import flash.net.SharedObject;
public class Ejercicios extends Sprite
{
Pg. 50
Memoria
Una vez que la nueva clase funciona como una clase heredada de Sprite se pueden utilizar
las listas de visualizacin. Una lista de visualizacin, como su propio nombre indica, es una
lista donde aparecen los elementos que se quieren mostrar por pantalla, de tal manera que
el orden de la lista indica que elemento se visualiza antes o despus. Esta lista es todo lo
que hay que gestionar para mostrar los diferentes elementos por pantalla. Se pueden aadir
o eliminar elementos, as como cambiar el orden entre elementos (11).
En una clase heredada de tipo Sprite existe siempre un escenario (stage) de fondo sobre el
que se pueden ir aadiendo objetos de visualizacin. Este escenario de fondo no es ms
que un Sprite, pero que viene definido por defecto. Tambin se pueden crear otros Sprite,
pero siempre se han de aadir al escenario.
32
addChild(pantalla);
Con esta funcin se introduce el objeto "pantalla" dentro de la lista de visualizacin del
escenario.
168
removeChild(botonera);
La anterior lnea de cdigo elimina el objeto "botonera" de la lista de visualizacin del

escenario.
La clase Sprite tambin puede ser utilizada dentro de la clases creando nuevos objetos
Sprite. Estos objetos Sprite se crean con el fin de agrupar objetos de visualizacin que, por
ejemplo, se quieren eliminar a la vez de la lista de visualizacin. Se trata de una lista de
visualizacin dentro de otra lista ms general. En la app desarrollada se utiliza esta tcnica
por ejemplo al tener que borrar los cuadros de texto para crear un nuevo ejercicio.
27
var texto:Sprite = new Sprite();
161
texto.addChild(dificultad);
460
461
462
463
464
465
466
467
468
texto.removeChild(dificultad);
texto.removeChild(solucion);
texto.removeChild(enunciado);
texto.removeChild(tema);
texto.removeChild(Tid);
enunciado = new TextField();
enunciado.type = TextFieldType.INPUT;
enunciado.border = true;
En las lneas de cdigo se puede ver como se aaden los cuadros de texto (dificultad,
solucin, enunciado, tema y Tid) al Sprite "texto". Ms adelante se pueden dejar de
visualizar todos con una nica lnea de cdigo que elimine el Sprite "texto" del escenario.
Pg. 51
6.2 Carga de imgenes externas

Despus del Sprite, el elemento ms utilizado en la app son las imgenes externas. Todos
los elementos que aparecen por pantalla, exceptuando los cuadros de texto, son imgenes
externas a la app, que se van cargando segn se requieren.
Para la carga de imgenes (12) se utilizan tres clases incluidas en las bibliotecas: Loader,
BitmapData y Bitmap. La clase Loader se encarga de cargar la informacin de la imagen
desde un archivo existente en la memoria del dispositivo. Al finalizarse la carga, esta
informacin pasa a un mapa de bits mediante la clase BitmapData y por ltimo la clase
Bitmap crea su representacin visual para poder mostrar la imagen por pantalla.
Las imgenes cargadas mediante este mtodo utilizan la clase Spirte para poder ser
visualizadas por pantalla. Como se ha explicado anteriormente, mediante la lista de
visualizacin de la clase Sprite se controla qu imgenes se muestran por pantalla.
Todas las imgenes se han organizado por grupos segn la pantalla que se est
visualizando de la app y los elementos que requiere dicha pantalla. A cada grupo le
corresponde un elemento Sprite, de tal forma que con una nica lnea de cdigo se pueden
visualizar, o dejar de visualizar, varas imgenes por pantalla.
Las imgenes que son utilizadas por la app se empaquetan junto al cdigo de sta. De esta
forma se pueden transferir al dispositivo mvil junto a toda la app. Las imgenes cargadas
estn diseadas para que ocupen poca memoria, de tal manera que el empaquetado de la
app no sea demasiado pesado y poder transferirlo por la red.
6.2.1 Cdigo para la visualizacin

Segn lo explicado anteriormente, el cdigo utilizado para cargar imgenes es el siguiente:
689 //Boton aadir ejercicio//
690
var loadAdd:Loader = new Loader();
691
loadAdd.contentLoaderInfo.addEventListener(
Event.COMPLETE, onCompleteAdd);
692
loadAdd.load(new URLRequest("app:/Aadir.jpg"));
693
function onCompleteAdd(event:Event):void {
694
var image:Bitmap = Bitmap(loadAdd.content);
695
var bitmap:BitmapData = image.bitmapData;
696
image.x = 295;
697
image.y = 820;
698
image.width = 50;
699
image.height = 50;
Pg. 52
Memoria
700
Add.addChild(image);
701
}
704 //Boton aadir ejercicio//
En este cdigo se carga una imagen que servir como botn para aadir nuevos ejercicios a
los fichero de datos. Lo primero que se hace es crear un objeto Loader mediante la llamada
new Loader,. A continuacin se le aade una escucha a este Loader (este elemento de la
programacin se explicar ms adelante). En la siguiente lnea de cdigo (692) se le indica
al Loader que empiece a cargar (load) la imagen y se le seala la ubicacin donde se
encuentra. Una vez finalizada la carga de la informacin se ejecuta la funcin
onCompleteAdd, la cual crea un nuevo objeto de clase BitmapData (lnea 695) y le pasa la
informacin cargada. Despus se crea un objeto Bitmap (lnea 694) al que se le pasa el
objeto BitmapData y crea la representacin de la imagen que se mostrar por pantalla. Por
ltimo, se aade la imagen a la lista de visualizacin de un Sprite creado anteriormente
(lnea 700) para poder visualizar la imagen por pantalla.
Pg. 53
Esquema 6.1: Esquema de la utilizacin de los Sprite y las imgenes de la app

En el Esquema 6.1 se muestra cmo se utilizan los Sprite (listas de visualizacin) en
algunas pantallas de la app. Cmo puede observarse existe una lista de visualizacin
principal, la cual va pasando de una pantalla a otra y se le aaden otras listas de
visualizacin o se eliminan segn sea necesario.
Las lneas de cdigo siguientes muestran como sera la transicin entre la pantalla de la
competicin entre alumnos y el men:
48 function onClickBack(evt:Event):void {
49
coches.addEventListener(Event.ENTER_FRAME, mPantallaBack);
50
function mPantallaBack(evt:Event):void {
51
coches.x += 80;
52
botonera.x += 80;
53
if (coches.x == 80) {
54
new Menu(pan);
55
} else if (coches.x >= 640) {
56
coches.removeEventListener(Event.ENTER_FRAME, mPantallaBack);
57
pan.removeChild(botonera);
58
pan.removeChild(coches);
59
}
60
}
61 }
Pg. 54
Memoria
En las lneas 57 y 58 se eliminan los botones y las imgenes, como se indica en el Esquema
6.1. En la lnea 54 se hace una llamada a la clase "Menu" que cargar la pantalla del men
as como los botones de este. El funcionamiento del resto de pantallas es idntico a este
pero con sus propios elementos.
6.3 Eventos
Los eventos son los responsables de ejecutar las diferentes acciones que ha de realizar la
app dependiendo de la interaccin del usuario o de otras muchas acciones que se ejecutan
internamente sin intervencin del usuario. Un evento se puede comparar a una alarma
interna lanzada por la app. Esta alarma avisa al motor de ejecucin de que algn suceso,
que nosotros hemos definido previamente, se ha completado. Es por esto que los eventos
son la herramienta fundamental utilizada para la interaccin de la app con el usuario.
Los eventos se empaquetan en una clase principal llamada Events (13) (14). Esta clase es
la encargada de escuchar las alarmas de los diferentes eventos a travs de los
EventListeners y de disparar algunos eventos genricos. Para disparar la alarma de un
evento, y que pueda ser escuchada, se utilizan las clases especficas de los diferentes
eventos dependiendo de su naturaleza. Por ejemplo, para detectar un toque en la pantalla
se utiliza la clase TouchEvent o bien MouseEvent. La clase de cada evento se encarga tanto
de controlar las acciones que dispararn un evento as como de dispararlo. Para indicarle a
la app los eventos que han de ser escuchados se utilizan las escuchas (listeners). Estas
escuchas se aaden en los diferentes objetos de programacin segn interese. De esta
manera ser el objeto al que est asociado la escucha el que me proporcione la informacin
necesaria para realizar la accin indicada.
Todos los botones utilizan los eventos para realizar la funcin que les corresponde. A travs
de las imgenes externas cargadas se crea la imagen de los botones y posteriormente se
les aade un listener al Sprite que las contiene. Cada botn ha de estar en un Sprite
diferente porque a un mapa de bits no se le puede poner un listener, pero a un Sprite s.
6.3.1 Cdigo para la gestin de eventos

A continuacin se muestra un ejemplo de la utilizacin de los eventos:
197
198
199
lista1.addEventListener(MouseEvent.CLICK, onClickRegistro1);
200
201
Pg. 55
En este ejemplo se puede observar como a los objetos lista1 - lista5 se les ha aadido una
escucha para eventos tipo MouseEvent.CLICK. A continuacin del evento se indica la
funcin que se ejecutar cuando se escuche ese evento. Dentro de esta funcin se aaden
todas las acciones que se quieran ejecutar tras escuchar el evento. Las cinco escuchas
ejecutan la misma funcin "onClickRegitro1", pero desde objetos diferentes. Esto es debido
a que cada objeto proporciona informacin especfica de l mismo para que la funcin acte
en consecuencia. En concreto en este cdigo, los objetos lista1 - lista5 son los elementos de
la lista de ejercicios que se est mostrando por pantalla. A tocar uno de ellos con el dedo la
app tiene informacin de qu elemento se ha tocado y, por lo tanto, sobre que elemento se
actuar.
Una de las caractersticas singulares de los eventos en AS3 y que dificulta un poco su
programacin es que las funciones que son ejecutadas por las escuchas, en nuestro caso
sera la funcin "onClickRegistro1", no admiten la entrada de parmetros ni devuelven
parmetros, es decir, no se les puede pasar ninguna variable para que la utilicen y tampoco
pueden devolver ninguna informacin. La programacin cuenta con que se le pase toda la
informacin a la funcin a travs del objeto que tiene la escucha.
Esquema 6.2: Flujo de acciones que desencadena la interaccin del usuario
6.4 Cuadros de texto

Los cuadros de texto han sido utilizados en la app tanto para transmitir informacin al
usuario como para recoger la informacin introducida por ste, incluso algunos han sido
Pg. 56
Memoria
utilizados como botones. Se trata, por tanto, de otro de los elementos ms utilizados en el
cdigo de la app.
La clase que agrupa y gestiona los cuadros de texto es TextField. Esta clase controla el
texto que debe ser mostrado por pantalla y con qu caractersticas se ha de hacer. Adems,
el teclado nativo del dispositivo tambin est gestionado por esta clase. Existen tres modos
en los que puede trabajar esta clase: Output, Input o Dynamic. En la presente app slo se
han utilizado los dos primeros modos, de tal manera que para mostrar el texto al usuario se
utiliza el modo Output y para recoger los datos de texto introducidos por el usuario se utiliza
el modo Input.
Existen varias clases que complementan la funcionalidad de la clase TextField. Por ejemplo,
para dar un formato concreto al texto se utilizan las clases TextFormat y TextFormatAlign o
para indicar como se han de modificar las dimensiones del cuadro de texto, se utiliza la
clase TextFieldAutoSize.
6.4.1 Cdigo para los cuadros de texto

A continuacin se muestra un ejemplo del cdigo utilizado para los cuadros de texto:
95
var titulo:TextField = new TextField();
96
titulo.x = 0;
97
titulo.y = 10;
98
titulo.width = 640;
99
titulo.height = 40;
100 titulo.text = "SELECCIONE LOS EJERCICIOS";
101 titulo.setTextFormat(formatoTitulo);
102 texto.addChild(titulo);
En el ejemplo primero se crea un nuevo cuadro de texto y a continuacin se le configuran
una serie de caractersticas como puede ser la posicin, la anchura, la altura, as como el
texto que ha de mostrar. Despus se le ha impuesto un formato de texto concreto creado
con anterioridad. Y por ltimo se aade el cuadro a la lista de visualizacin de un Sprite
denominado texto. En este cdigo no se indica que el cuadro de texto es de tipo Output
porque este es el valor por defecto de cualquier cuadro creado.
El ejemplo mostrado a continuacin es de un cuadro de texto de tipo Input:
71
72
73
74
75
76
77
78
79
80
var enunciado:TextField = new TextField();

enunciado.x = 20;
enunciado.y = 100;
enunciado.width = 600;
enunciado.height = 300;
enunciado.wordWrap = true;
enunciado.setTextFormat(formato);
enunciado.defaultTextFormat = formato;
81
Pg. 57
texto.addChild(enunciado);
En la lnea 72 se configura el cuadro de texto como Input. En este cdigo se configuran ms

caractersticas del cuadro de texto que en el ejemplo anterior como puede ser el ajuste del
texto al cuadro (wordWrap). Tambin se ve una nueva caracterstica que es el
defaultTextFormat, la cual configura el formato por defecto del texto que se puede mostrar
por pantalla antes de que el usuario introduzca uno nuevo. En concreto este cuadro de texto
muestra por pantalla un enunciado ya existente en el fichero de ejericios y le da la opcin al
usuario de modificarlo.
Igual que todos los elementos que se han de mostrar por pantalla, los cuadros de texto
requieren de una lista de visualizacin que les d soporte para ser vistos por pantalla.
6.5 La clase SharedObject

Cuando se programa para iOS se ha de tener en cuenta cmo funciona la estructura del
sistema de archivos porque no funciona como cualquier otro sistema operativo y adems
est pensado para que no se pueda acceder a l. Los archivos se han de guardar en unas
carpetas concretas a las que el sistema te deja acceso: la carpeta de documentos o la
carpeta de archivos de la propia app. Una de las soluciones que utilizan los programadores
para no tener problemas con el sistema de archivos es albergar todos los elementos en la
propia carpeta de archivos de la app y por medio de la clase SharedObject. Es utilizado este
mtodo porque el hecho de guardar documentos fuera de la carpeta de la app tambin
requiere una serie de requisitos de seguridad que le pueden ocasionar problemas a la app.
Al programar para otros OS es mucho ms sencillo porque el sistema te muestra la
estructura de archivos y se puede decidir con ms facilidad donde albergar tus archivos.
Adems no tienen polticas de restricciones tan severas para ciertos archivos.
La clase SharedObject est diseada para guardar archivos en el dispositivo sin un formato
determinado (15). El formato que utiliza es el de un objeto genrico de programacin (.obj).
Dentro del objeto SharedObject se pueden almacenar todo tipo de datos, los cuales al
extraerlos han de ser interpretados por la app.
Una de las caractersticas interesantes de este tipo de objeto es que puede ser compartido y
transferido a travs de las redes con facilidad.
Pg. 58
Memoria
6.5.1 Cdigo para guardar archivos en el dispositivo

En las siguientes lneas de cdigo se muestra como se guardara la variable XML llamada
"problemas" en un archivo SharedObject:
38
var Prob:SharedObject = SharedObject.getLocal("problemas");
525 Prob.data.xml = problemas;
526 Prob.flush(3000);
En la primera lnea se muestra como se crea un archivo de este formato en el dispositivo. La
funcin getLocal busca en la carpeta de la app algn archivo de formato SharedObject con
el nombre problemas y si no existe lo crea. En la programacin de la app se hace referencia
a este archivo mediante la variable "Prob". En la lnea siguiente se crea un apartado dentro
de los datos del la variable "Prob" llamado "xml" y se le asigna el contenido de la variable
XML llamada "problemas" (esta variable ha sido creada anteriormente y no tiene que ver
con el nombre del archivo SharedObject). Al guardar el contenido de la variable XML en el
archivo SharedObject, se convierte en una cadena de texto, la cual no habr dificultad para
interpretar cuando se haya de recuperar, porque de esto ya se encarga la clase XML.
Finalmente se graba el contenido de la variable "Prob" en el archivo SharedObject del
dispositivo mediante la funcin flush y se le reserva un espacio en memoria de 3000 bytes a
dicho archivo, aunque ocupe menos.
En el caso de que queramos recuperar un archivo de estas caractersticas guardado en el
dispositivo se ha de conocer el nombre de ste. Es por eso, que la app se ha programado
para guardar los nombres de los archivos creados en otro archivo al que se le ha puesto el
nombre de "registro", de tal manera que cuando la app necesita ensear al usuario los
archivos existentes pueda mostrar por pantalla sus nombres y recuperarlos de la memoria
del dispositivo.
6.6 Descarga de archivos del servidor

Para el primer lanzamiento de la app, se ha optado por realizar toda la gestin de ficheros
de datos de forma local. Esto es debido a que interesa ms el buen funcionamiento de todas
las funciones que ha de llevar a cabo la app que su implementacin posterior en una
institucin, momento en el que sera necesario la transmisin de ficheros al servidor.
Adems el hecho de transferir y descargar los ficheros del servidor no presenta mayores
problemas de programacin.
En este apartado se explica cmo se llevara a cabo este flujo de datos entre el servidor y la
app para futuras versiones. Se trata de herramientas de programacin que han sido
probadas durante el desarrollo de este proyecto, pero que no se han considerado
indispensables para la primera versin.
Pg. 59
La clase utilizada para comunicarse con el servidor es URLRequest y la clase para enviar y
descargar los archivos es URLLoader. La primera es la encargada de contener la
informacin de la conexin a la que acceder la segunda. La clase URLRequest es la
encargada de indicar si la conexin ser para descargar archivos (get) o envo de archivos
al servidor (post). Por defecto est configurada como mtodo "get". Una vez realizada la
conexin con el servidor es la clase URLLoader la que se encarga de iniciar la descarga y
gestionar la informacin obtenida.
A continuacin se muestra un ejemplo de obtencin de ficheros XML de un servidor:
32
33
34
35
36
37
var loader:URLLoader = new URLLoader();

loader.addEventListener(Event.COMPLETE, onComplete);
loader.load(new URLRequest("http://murcis.hostei.com/problemas.xml"));
function onComplete(evt:Event):void {
problemas = XML(evt.target.data);
Puede observarse como se crean las variables URLLoader y URLRequest. Se le pone un

listener al URLLoader para saber cuando acaba la descarga y poder utilizar la informacin
descargada. Lo que se hace con la informacin es convertirla en una variable XML.
Pg. 60
Memoria
7 Planificacin temporal
En este captulo se dar una visin temporal del proyecto, as como la planificacin que se
ha seguido a lo largo de su desarrollo. Se describen las fases principales del proyecto y las
acciones llevadas a cabo en cada una de ellas.
7.1 Fases de desarrollo

Para llevar a cabo el proyecto se han diferenciado y llevado a cabo cuatro fases segn la
naturaleza de las acciones realizadas:
1. Fase de definicin de la app y requisitos: aunque desde el principio estaba clara la
temtica de la app, se ha llevado a cabo un trabajo de brainstorm para conseguir
nuevas ideas y orientaciones de las diferentes funcionalidades. Tras recoger las
ideas ms valoradas del proceso anterior se han definido los objetivos principales
del proyecto, as como las principales funcionalidades y requisitos que se esperan
de la app. Con estos objetivos y requisitos fijados se ha procedido a la siguiente
fase.
2. Fase de diseo de las funcionalidades: durante esta fase se han estudiado las
funcionalidades que se proponen para la app con el objetivo de facilitar las fases
posteriores. Se han analizado los datos y recursos que ha de tener disponible
cada funcin, as como la relacin entre las diferentes funciones y el modo de
presentacin de datos al usuario de cada una de las funciones.
3. Fase de diseo grfico: esta fase est en estrecha relacin con la anterior.
Dependiendo del diseo de las funcionalidades y su estructura de datos el diseo
grfico se ve afectado radicalmente. En esta fase se han diseado la apariencia
de las diferentes pantallas y botones de cada una.
4. Fase de desarrollo: en esta fase se lleva a cabo la programacin de la app, es
decir, la implementacin de la app. Se trata de la fase que ms tiempo requiere.
Se ha intentado reducir al mximo el tiempo de esta fase haciendo muy bien las
anteriores y facilitando as la programacin.
7.1.1 Duracin de las fases
acumulada (h)
Valoracin de ideas
10
Definicin de objetivos,
funcionalidades y requisitos
20
30
Datos y recursos
20
50
Relacin entre funciones
10
60
Modo de presentacin de
datos
20
80
Diseo Grfico
Duracin
5
Distribucin de pantallas y
botones
10
90
Diseo de botones y
pantallas
30
120
Aprendizaje
150
270
Programacin
250
520
40
560
funcionalidades
Diseo de
Brainstorm
Desarrollo
Definicin y requisitos
Duracin (h)
El tiempo invertido en cada tarea del proyecto se resume en el siguiente cuadro:
Redaccin de la memoria
Tabla 7-1: Tiempo invertido en cada fase del proyecto
Pg. 61
Pg. 62
Memoria
7.2 Cronologa
Imagen 7.1: Diagrama de Pert del proyecto
Pg. 63
8 Coste del proyecto

En este captulo se realizar el estudio de la viabilidad econmica del proyecto . Se trata de
un proyecto en el que la mayor parte de los costes son de recursos humanos y que no
requiere grandes inversiones en materiales ni infraestructuras.
8.1 Costes de recursos humanos

La mano de obra se contabilizar separando el trabajo del ingeniero implicado, el
programador y el diseador de tal forma que el precio por hora del ingeniero es de 30 y el
programador 20 y el diseador 15. Esta separacin es conveniente porque, aunque en
este caso sean el mismo trabajador, no se trata del mismo trabajo ni responsabilidad.
Coste acumulado ()
30
Ingeniero
900
900
Diseo de funcionalidades
50
Ingeniero
1.500
2.400
Diseo Grfico
40
Diseador
600
3.000
Desarrollo
400
Programador
8.000
11.000
Redaccin de la memoria
40
Ingeniero
1.200
12.200
Responsable
Definicin y requisitos
Duracin (h)
Coste ()
A continuacin se muestra una tabla con el desglose del tiempo invertido por fase del
proyecto:
Tabla 8-1: Coste de recursos humanos del proyecto
Pg. 64
Memoria
A la vista del anterior cuadro, el coste total de los recursos humanos asciende a 12.200.
Cabe destacar que las horas dedicadas al desarrollo de la app es elevado porque incluye el
aprendizaje previo del lenguaje de programacin.
8.2 Costes de las herramientas utilizadas

En la siguiente tabla se muestran los costes materiales del proyecto, as como la
Valor ()
Amortizacin (meses)
Tiempo de utilizacin (meses)
Coste ()
Coste acumulado ()
amortizacin estimada:
PC
600
24
3.5
88
88
Dispositivo mvil
500
12
2.5
105
193
Licencia de iOS developer
100
--
--
100
293
20/mes
--
20
313
Licencia Adobe Creative Cloud
Tabla 8-2: Coste material del proyecto

El coste material del proyecto asciende a 313. No se trata de una importante partida
comparado con el coste humano del proyecto.
A la hora de realizar el clculo del tiempo que se utiliza cada recurso se ha considerado que
las jornadas laborales son de 8 horas diarias y los meses de 20 das laborales. Por lo tanto,
Pg. 65
se ha realizado el clculo por meses de utilizacin del recurso y de acuerdo a los meses que
se han considerado para su amortizacin.
Para la realizacin de este proyecto se utilizan ms herramientas que se pueden conseguir
de forma gratuita. Se explic, en el apartado 3.2, que tanto el entorno de desarrollo
FlashDevelop como la plataforma Adobe Air son gratuitas.
8.3 Coste total del proyecto
Coste ()
Finalmente, el coste total del proyecto queda reflejado en la siguiente tabla:
Costes de recursos humanos
Costes materiales
TOTAL
12.200
313
12.513
Tabla 8-3: Coste total del proyecto

El coste total del proyecto es de 12.513.
Pg. 67
9 Impacto medioambiental
El cambio tecnolgico que est experimentando la sociedad se traduce en un impacto
ambiental grave. Las tecnologas abarcan cada vez ms ambientes de la sociedad y se
convierten en un elemento indispensable. La necesidad de ciertos recursos minerales para
la fabricacin de dispositivos electrnicos as como toda la energa empleada por estos,
tanto en su fabricacin como su utilizacin, aumenta a medida que lo hace la demanda de
estos dispositivos.
Existen programas de reciclaje, as como directivas de la UE. La directiva de Residuos de
Aparatos Elctricos y Electrnicos (Directiva 2002/96/CE del Parlamento Europeo (18)), as
como el Real Decreto 208/2005 (19), regulan el reciclaje de aparatos electrnicos. En este
sentido, el impacto ambiental de la tecnologa se intenta paliar con el reciclaje de ciertos
componentes que forman parte de los aparatos electrnicos.
El presente proyecto tiene un impacto ambiental positivo. El hecho de incorporar a la
educacin la tecnologa presente en la sociedad no implica un aumento considerable de
dispositivos electrnicos. El impacto positivo se desprende de darle a la tecnologa presente
en la educacin ms herramientas para disminuir el consumo de otros recursos como puede
ser el papel.
Pg. 69
Conclusiones
A la hora de concluir este proyecto y reflexionar sobre todo lo que se ha realizado en l,
resalta un aspecto que ha sido fundamental para llevarlo a cabo. Se trata de todo lo
aprendido a lo largo de su ejecucin. A medida que se ha ido desarrollando se han adquirido
nuevos conocimientos. Para desarrollar algunas partes de este proyecto se ha requerido de
una investigacin intensa que ha aportado nuevos conocimientos y puntos de vista a su
ejecutor. Ha sido una gran oportunidad para introducirse en el mundo de la programacin y
aprender sobre el desarrollo de apps.
Por otro lado, la app resultante de todo el trabajo realizado es un elemento que podr
utilizarse en un futuro prximo. Actualmente se trata de una herramienta para la enseanza
de las matemticas, pero gracias a la estructura utilizada para su programacin puede
convertirse fcilmente en una herramienta transversal para ms asignaturas.
Tambin hay que considerar que el resultado de este proyecto est enfocado y programado
para un sistema operativo concreto, pero, una vez ms, gracias a las herramientas utilizadas
puede implementarse fcilmente en otros sistemas operativos.
Tras realizar este proyecto queda por delante el trabajo de puesta a punto y mejora de la
app. Se trata de un trabajo no menos importante que el realizado a lo largo de estas
pginas. Actualmente existen posibilidades de introducir una prueba piloto durante el curso
2015/2016 en una institucin educativa. Durante un tiempo se realizara su testeo y puesta a
punto en esta institucin. Una vez realizadas estas pruebas se decidir si se puede
comercializar, incluso si se puede lanzar acompaada de otras apps que puedan surgir a
raz de esta y de su utilizacin.
El desarrollo de este proyecto y todo el esfuerzo puesto en l ha sido una oportunidad para
poner en prctica gran cantidad de conocimientos y habilidades aprendidas durante estos
aos de estudio.
Pg. 71
Agradecimientos
A Llus Solano, director de este proyecto, por la buena acogida que dio a la idea que se le
propuso y por su dedicacin de tiempo para guiarlo y llevarlo a buen puerto.
Pg. 73
Bibliografa
9.1 Referencias bibliogrficas
1. 2014 Apple Inc. Apple Education. [En lnea]
https://www.apple.com/es/education/mac/resources/.
2. Richardson, Darren y Milbourne, Paul. A brief history of ActionScript. Fundation
ActionScript 3.0 for Flash an Flex. EEUU : s.n., 2009.
3. 2008 Adobe Systems Incorporated. Trabajo con objetos. Programacin con ADOBE
ACTIONSCRIPT 3.0. California 95110, USA : s.n., 2008.
4. . Herencia. Programacin con ADOBE ACTIONSCRIPT 3.0. California 95110,
USA : s.n., 2008, pgs. 111-119.
5. 2014 Adobe Systems Incorporated. Adobe. [En lnea] 27 de Junio de 2006.
http://www.adobe.com/devnet/actionscript/articles/actionscript3_overview.html.
6. TIOBE. TIBOE software BV. [En lnea]
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html.
7. FLASHDEVELOP.ORG 2005-2013. FlashDevelop Open source code editor. [En lnea]
http://www.flashdevelop.org/.
8. 2014 Adobe Systems Software Ireland Ltd. Adobe. [En lnea]
http://get.adobe.com/es/air/.
9. S.L., Edertone Advanced Solutions. Edertone Software Engineering. [En lnea]
http://www.edertone.com/es/Services_ria/.
10. 2014 Adobe Systems Incorporated and its licensors. Captulo 1: Acerca de Adobe
AIR. Creacin de aplicaciones de ADOBE AIR. California 95110, USA : s.n., Ultima
modificacin 18/11/2013, pg. 1.
11. Lott, Joey, Schall, Darron y Peters, Keith. XML. ActionScript 3.0 para desarrolladores
Flash. Madrid, Espaa : ANAYA MULTIMEDIA (GRUPO ANAYA, S.A.), 2007, pg. 539 y ss.
12. 2008 Adobe Systems Incorporated. Captulo 11: Trabajo con XML. Programacin
con ACTIONSCRIPT 3.0. California 95110, USA : s.n., 2008, pg. 232 y ss.
Pg. 74
Memoria
13. Lott, Joey, Schall, Darron y Peters, Keith. Capitulo 6: Lista de visualizacin.
ActionScript 3.0 para desarrolladores Flash. Madrid, Espaa : ANAYA MULTIMEDIA
(GRUPO ANAYA, S.A.), 2007, pg. 185 y ss.
14. . Carga de imagen externa en un mapa de bits. ActionScript 3.0 para desarrolladores
Flash. Madrid, Espaa : ANAYA MULTIMEDIA (GRUPO ANAYA, S.A.), 2007, pg. 257 y ss.
15. . Gestionar eventos. ActionScript 3.0 para desarrolladores Flash. Madrid, Espaa :
ANAYA MULTIMEDIA (GRUPO ANAYA, S.A.), 2007, pg. 37 y ss.
16. 2008 Adobe Systems Incorporated. Captulo 12 Gestin de eventos. Programacin
con ADOBE ACTIONSCRIPT 3.0. California 95110, USA : s.n., 2008, pg. 254 y ss.
17. Lott, Joey, Schall, Darron y Peters, Keith. Capitulo 17: Almacenar datos persistentes.
ActionScript 3.0 para desarrolladores Flash. Madrid, Espaa : ANAYA MULTIMEDIA
(GRUPO ANAYA, S.A.), 2007, pg. 489 y ss.
18. Diario Oficial de la Unin Europea. DIRECTIVA 2002/96/CE DEL PARLAMENTO
EUROPEO Y DEL CONSEJO de 27 de enero de 2003 sobre residuos de aparatos
elctricos y electrnicos (RAEE). 2003.
19. BOE. REAL DECRETO 208/2005, de 25 de febrero, sobre aparatos elctricos y
electrnicos y la gestin de sus residuos. Madrid : s.n., 2005.
Pg. 75
Anexos
Anexo I: Cdigo de programacin
En este anexo se recoge todo el cdigo utilizado para la programacin de la app. Se ha
incluido al final del cdigo el archivo descriptor de la app.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
flash.display.Bitmap;
flash.display.BitmapData;
flash.display.Loader;
flash.display.Sprite;
flash.events.Event;
flash.events.MouseEvent;
flash.filesystem.File;
flash.filesystem.FileMode;
flash.filesystem.FileStream;
flash.net.FileReference;
flash.net.URLRequest;
flash.text.TextField;
flash.text.TextFieldAutoSize;
flash.text.TextFieldType;
flash.ui.Multitouch;
flash.ui.MultitouchInputMode;
public class Main extends Sprite

{
//Variables//
public var pantalla:Sprite = new Sprite();
//Variables//
public function Main():void
{
Multitouch.inputMode = MultitouchInputMode.NONE;
new Menu(pantalla);
addChild(pantalla);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
flash.events.Event;
public class Menu extends Sprite

{
var problemas:XML = new XML();
var botonera:Sprite = new Sprite();
var P:Sprite = new Sprite();
var RA:Sprite = new Sprite();
var E:Sprite = new Sprite();
var D:Sprite = new Sprite();
var C:Sprite = new Sprite();
var V:Sprite = new Sprite();
public var capa:int =0;
public function Menu(pantalla:Sprite)
{
botonera.x = -640;
botonera.addEventListener(Event.ENTER_FRAME, mPantalla);
function mPantalla(evt:Event):void {
botonera.x += 80;
if (botonera.x == 0) {
botonera.removeEventListener(Event.ENTER_FRAME, mPantalla);
}
}
//Registrar alumnos//
var loadRA:Loader = new Loader();
loadRA.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteRegistroAlumnos);
loadRA.load(new URLRequest("app:/Alumnos.png"));
function oncompleteRegistroAlumnos(event:Event):void {
var image:Bitmap = Bitmap(loadRA.content);
image.x = 95;
image.y = 50;
image.width = 200;
image.height = 200;
RA.addChild(image);
}
RA.buttonMode = true;
RA.name = "RA";
RA.addEventListener(MouseEvent.CLICK, onClickRegistroAlumnos);
botonera.addChild(RA);
function onClickRegistroAlumnos(event:MouseEvent):void {
botonera.name = event.target.name;
botonera.addEventListener(Event.ENTER_FRAME, mBotones);
}
//Regsitrar alumnos//
//Ejercicios//
var loadE:Loader = new Loader();
loadE.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteEjercicios);
loadE.load(new URLRequest("app:/Ejercicios.jpg"));
function oncompleteEjercicios(event:Event):void {
var image:Bitmap = Bitmap(loadE.content);
image.x = 345;
image.y = 50;
image.width = 200;
image.height = 200;
E.addChild(image);
}
E.buttonMode = true;
E.name = "E";
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
E.addEventListener(MouseEvent.CLICK, onClickEjercicios);
botonera.addChild(E);
function onClickEjercicios(evt:MouseEvent):void {
botonera.name = evt.target.name;
}
//Ejercicios//
//Prueba app alumnos//
var loadP:Loader = new Loader();
loadP.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompletePrueba);
loadP.load(new URLRequest("app:/Prueba.png"));
function oncompletePrueba(event:Event):void {
var image:Bitmap = Bitmap(loadP.content);
image.x = 95;
image.y = 300;
image.width = 200;
image.height = 200;
P.addChild(image);
}
P.buttonMode = true;
P.name = "P";
P.addEventListener(MouseEvent.CLICK, onClickPrueba);
botonera.addChild(P);
function onClickPrueba(event:MouseEvent):void {
}
//Prueba app alumnos//
//Crear deberes//
var loadD:Loader = new Loader();
loadD.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteDeberes);
loadD.load(new URLRequest("app:/CrearDeberes.png"));
function oncompleteDeberes(event:Event):void {
var image:Bitmap = Bitmap(loadD.content);
image.x = 345;
image.y = 300;
image.width = 200;
image.height = 200;
D.addChild(image);
}
D.buttonMode = true;
D.name = "D";
D.addEventListener(MouseEvent.CLICK, onClickCrear);
botonera.addChild(D);
function onClickCrear(event:MouseEvent):void {
}
//Crear deberes//
//Carrera//
var loadC:Loader = new Loader();
loadC.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteCarrera);
loadC.load(new URLRequest("app:/Carrera.png"));
function oncompleteCarrera(event:Event):void {
var image:Bitmap = Bitmap(loadC.content);
image.x = 95;
image.y = 550;
image.width = 200;
image.height = 200;
C.addChild(image);
}
C.buttonMode = true;
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
C.name = "C";
C.addEventListener(MouseEvent.CLICK, onClickCarrera);
botonera.addChild(C);
function onClickCarrera(event:MouseEvent):void {
}
//Carrera//
//Carga archivos al servidor//
var loadV:Loader = new Loader();
loadV.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteVisualizar);
loadV.load(new URLRequest("app:/Visualizar.jpg"));
function oncompleteVisualizar(event:Event):void {
var image:Bitmap = Bitmap(loadV.content);
image.x = 345;
image.y = 550;
image.width = 200;
image.height = 200;
V.addChild(image);
}
V.buttonMode = true;
V.name = "V";
V.addEventListener(MouseEvent.CLICK, onClickVisualizar);
botonera.addChild(V);
function onClickVisualizar(event:MouseEvent):void {
}
//Carga archivos al servidor//
//Funcion servidor//
function mBotones(evt:Event):void {
botonera.x -= 80;
if (botonera.x == -80) {
var boton:String = evt.target.name;
if (boton == "RA") {
new CursosAlumnos(pantalla, capa);
}else if (boton == "E") {
new Ejercicios(pantalla);
}else if (boton == "P") {
new ProbarApp(pantalla, capa);
} else if (boton == "D") {
new SeleccionArchivo(pantalla, capa);
}else if(boton=="C") {
new Carrera(pantalla);
} else if (boton == "V") {
new VerResultados(pantalla);
}
} else if (botonera.x <= -640) {
botonera.removeEventListener(Event.ENTER_FRAME, mBotones);
pantalla.removeChild(botonera);
}
}
//Pantallazos//
pantalla.addChild(botonera);
//Pantallazos//
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
flash.events.Event;
flash.text.StyleSheet;
flash.text.TextFormat;
public class CursosAlumnos extends Sprite

{
var primero:Sprite = new Sprite();
var segundo:Sprite = new Sprite();
var tercero:Sprite = new Sprite();
var cuarto:Sprite = new Sprite();
var back:Sprite = new Sprite();
var c:int;
public function CursosAlumnos(pan:Sprite, capa:int)
{
if (capa == 0){
botonera.x = 640;
botonera.addEventListener(Event.ENTER_FRAME, mBotones0);
function mBotones0(evt:Event):void {
botonera.x -= 80;
botonera.removeEventListener(Event.ENTER_FRAME, mBotones0);
}
}
} else if (capa == 2) {
botonera.x = -640;
botonera.x += 80;
}
}
}
capa = 1;
var tfomatTitulo:TextFormat = new TextFormat("arial", 40, 0x000000);
titulo.x = 20;
titulo.y = 20;
titulo.text = "ELIJA UN CURSO:";
titulo.width = 500;
titulo.height = 60;
titulo.setTextFormat(tfomatTitulo);
botonera.addChild(titulo);
var tformat:TextFormat = new TextFormat("arial", 30, 0xffffff, true);
var loader1:Loader = new Loader();
loader1.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteRegistro1);
loader1.load(new URLRequest("app:/Alumnos.png"));
function oncompleteRegistro1(event:Event):void
{
var image1:Bitmap = Bitmap(loader1.content);
var bitmap1:BitmapData = image1.bitmapData;
image1.width = 250;
image1.height = 250;
image1.x = 45;
image1.y = 100;
primero.addChild(image1);
var pri:TextField = new TextField();
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
pri.text = "1 ESO";

pri.wordWrap = true;
pri.width = 150;
pri.x = 180;
pri.y = 150;
pri.setTextFormat(tformat);
primero.name = "1";
primero.addChild(pri);
primero.buttonMode = true;
primero.mouseChildren = false;
primero.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(primero);
}
function oncompleteRegistro2(evt:Event):void
{
image2.width = 250;
image2.x = 345;
image2.y = 100;
segundo.addChild(image2);
segundo.buttonMode = true;
var seg:TextField = new TextField();
seg.text = "2 ESO";
seg.wordWrap = true;
seg.width = 150;
seg.x = 480;
seg.y = 150;
seg.setTextFormat(tformat);
segundo.name = "2";
segundo.addChild(seg);
segundo.mouseChildren = false;
segundo.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(segundo);
}
{
image3.width = 250;
image3.x = 45;
image3.y = 400;
tercero.addChild(image3);
tercero.buttonMode = true;
var ter:TextField = new TextField();
ter.text = "3 ESO";
ter.wordWrap = true;
ter.width = 150;
ter.x = 180;
ter.y = 450;
ter.setTextFormat(tformat);
tercero.name = "3";
tercero.addChild(ter);
tercero.mouseChildren = false;
tercero.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(tercero);
}
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
{
image4.width = 250;
image4.x = 345;
image4.y = 400;
cuarto.addChild(image4);
var cua:TextField = new TextField();
cua.text = "4 ESO";
cua.wordWrap = true;
cua.width = 150;
cua.x = 480;
cua.y = 450;
cua.setTextFormat(tformat);
cuarto.name = "4";
cuarto.addChild(cua);
cuarto.buttonMode = true;
cuarto.mouseChildren = false;
cuarto.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(cuarto);
}
function onClick(evt:MouseEvent):void {
c = int(evt.target.name);
}
botonera.x -= 80;
new ClasesAlumnos(pan, c, capa);
}
}
}
var loaderBack:Loader = new Loader();
loaderBack.load(new URLRequest("app:/Back.png"));
loaderBack.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteBack);
function oncompleteBack(evt:Event):void
{
var imageBack:Bitmap = Bitmap(loaderBack.content);
var bitmapBack:BitmapData = imageBack.bitmapData;
imageBack.width = 100;
imageBack.height = 100;
imageBack.x = 0;
imageBack.y = 860;
back.addChild(imageBack);
back.buttonMode = true;
back.addEventListener(MouseEvent.CLICK, onClickBack);
botonera.addChild(back);
}
function onClickBack(event:MouseEvent):void
{
botonera.addEventListener(Event.ENTER_FRAME, mPantallaBack);
botonera.x += 80;
new Menu(pan);
} else if (botonera.x >= 640) {
botonera.removeEventListener(Event.ENTER_FRAME, mPantallaBack);
}
}
}
pan.addChild(botonera);
214
215
216
217
218
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
flash.events.Event;
flash.text.StyleSheet;
public class ClasesAlumnos extends Sprite

{
var A:Sprite = new Sprite();
var B:Sprite = new Sprite();
var C:Sprite = new Sprite();
var D:Sprite = new Sprite();
var c:String;
public function ClasesAlumnos(pan:Sprite, curso:int, capa:int)
{
if(capa==1){
botonera.x = 640;
botonera.x -= 80;
if (botonera.x <= 0) {
}
}
}else if (capa == 3) {
botonera.x = -640;
botonera.x += 80;
}
}
}
capa = 2;
var tfomatTitulo:TextFormat = new TextFormat("arial", 40, 0x000000);
titulo.x = 20;
titulo.y = 20;
titulo.text = "ELIJA UNA CLASE:";
titulo.width = 500;
titulo.height = 60;
titulo.setTextFormat(tfomatTitulo);
botonera.addChild(titulo);
var tformat:TextFormat = new TextFormat("arial", 30, 0xffffff, true);
function oncompleteRegistro1(event:Event):void
{
image1.width = 250;
image1.x = 45;
image1.y = 100;
A.addChild(image1);
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
A.mouseChildren = false;
var pri:TextField = new TextField();
pri.text = curso +" ESO A";
pri.wordWrap = true;
pri.width = 150;
pri.x = 150;
pri.y = 150;
pri.setTextFormat(tformat);
A.name = "A";
A.addChild(pri);
A.buttonMode = true;
A.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(A);
}
{
image2.width = 250;
image2.x = 345;
image2.y = 100;
B.addChild(image2);
B.buttonMode = true;
B.mouseChildren = false;
var seg:TextField = new TextField();
seg.text = curso + " ESO B";
seg.wordWrap = true;
seg.width = 150;
seg.x = 450;
seg.y = 150;
seg.setTextFormat(tformat);
B.name = "B";
B.addChild(seg);
B.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(B);
}
{
image3.width = 250;
image3.x = 45;
image3.y = 400;
C.addChild(image3);
C.buttonMode = true;
C.mouseChildren = false;
var ter:TextField = new TextField();
ter.text = curso + " ESO C";
ter.wordWrap = true;
ter.width = 150;
ter.x = 150;
ter.y = 450;
ter.setTextFormat(tformat);
C.name = "C";
C.addChild(ter);
C.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(C);
}
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
{
image4.width = 250;
image4.x = 345;
image4.y = 400;
D.addChild(image4);
var cua:TextField = new TextField();
cua.text = curso + " ESO D";
cua.wordWrap = true;
cua.width = 150;
cua.x = 450;
cua.y = 450;
cua.setTextFormat(tformat);
D.addChild(cua);
D.buttonMode = true;
D.name = "D";
D.mouseChildren = false;
D.addEventListener(MouseEvent.CLICK, onClick);
botonera.addChild(D);
}
function onClick(evt:MouseEvent):void {
c = evt.target.name;
}
botonera.x -= 80;
new RegistroAlumnos(pan,curso, c, capa);
}
}
}
var loaderBack:Loader = new Loader();
loaderBack.load(new URLRequest("app:/Back.png"));
loaderBack.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteBack);
function oncompleteBack(evt:Event):void
{
var imageBack:Bitmap = Bitmap(loaderBack.content);
var bitmapBack:BitmapData = imageBack.bitmapData;
imageBack.width = 100;
imageBack.height = 100;
imageBack.x = 0;
imageBack.y = 860;
back.addChild(imageBack);
}
function onClickBack(event:MouseEvent):void
{
botonera.x += 80;
new CursosAlumnos(pan, capa);
}
}
}
214
215
216
217
218
219
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
adobe.utils.ProductManager;
flash.desktop.InteractiveIcon;
flash.display.DisplayObject;
flash.globalization.Collator;
flash.net.SharedObject;
flash.net.URLLoader;
flash.events.Event;
flash.text.TextFormatAlign;
flash.ui.Mouse;
flash.events.EventDispatcher;
public class RegistroAlumnos extends Sprite

{
var NA:Sprite = new Sprite();
var GA:Sprite = new Sprite();
var GR:Sprite = new Sprite();
var CR:Sprite = new Sprite();
var Adelante:Sprite = new Sprite();
var Atras:Sprite = new Sprite();
var registro:XML = new XML();
public function RegistroAlumnos(pan:Sprite, cursoid:int, claseid:String, capa:int):void
{
botonera.x = 640;
texto.x = 640;
botonera.x -= 80;
texto.x-=80
if (botonera.x <= 0) {
}
}
capa = 3;
//Inicializar con registro existente//
var Reg:SharedObject = SharedObject.getLocal("registro"+cursoid.toString()+claseid);
if (Reg.size == 0) {
registro =
<datosalumnos>
<curso>{cursoid}</curso>
<clase>{claseid}</clase>
</datosalumnos>
}else {
registro = XML(Reg.data.xml);
}
var formato:TextFormat = new TextFormat("arial", 30);
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
var formatoTitulo:TextFormat = new TextFormat("arial", 30, null, null, null,true);

formatoTitulo.align = TextFormatAlign.CENTER;
titulo.x = 0;
titulo.y = 10;
titulo.width = 640;
titulo.height = 40;
titulo.text = "NUEVO ALUMNO";
titulo.setTextFormat(formatoTitulo);
texto.addChild(titulo);
var Tnombre:TextField = new TextField();
Tnombre.x = 20;
Tnombre.y = 60;
Tnombre.text = "Nombre:"
Tnombre.autoSize = TextFieldAutoSize.LEFT;
Tnombre.setTextFormat(formato);
texto.addChild(Tnombre);
var Tnombre1:TextField = new TextField();
Tnombre1.x = 20;
Tnombre1.y = 180;
Tnombre1.text = "Nombre"
Tnombre1.autoSize = TextFieldAutoSize.LEFT;
Tnombre1.setTextFormat(formato);
texto.addChild(Tnombre1);
var nombretext:TextField = new TextField();
nombretext.type = TextFieldType.INPUT;
nombretext.border = true;
nombretext.x = 185;
nombretext.y = 60;
nombretext.width = 400;
nombretext.height = 40;
nombretext.setTextFormat(formato);
nombretext.defaultTextFormat = formato;
texto.addChild(nombretext);
var Tcurso:TextField = new TextField();
Tcurso.x = 450;
Tcurso.y = 120;
Tcurso.text = "Curso:"+cursoid.toString()+""+claseid;
Tcurso.autoSize = TextFieldAutoSize.LEFT;
Tcurso.setTextFormat(formato);
texto.addChild(Tcurso);
var Tcontrasea:TextField = new TextField();
Tcontrasea.x = 20;
Tcontrasea.y = 120;
Tcontrasea.text = "Contrasea:";
Tcontrasea.autoSize = TextFieldAutoSize.LEFT;
Tcontrasea.setTextFormat(formato);
texto.addChild(Tcontrasea);
var Tcontrasea1:TextField = new TextField();
Tcontrasea1.x = 430;
Tcontrasea1.y = 180;
Tcontrasea1.text = "Contrasea";
Tcontrasea1.autoSize = TextFieldAutoSize.LEFT;
Tcontrasea1.setTextFormat(formato);
texto.addChild(Tcontrasea1);
var contrasea:TextField = new TextField();
contrasea.x = 185;
contrasea.y = 120;
contrasea.width = 150;
contrasea.height = 40;
contrasea.border = true;
contrasea.type = TextFieldType.INPUT;
contrasea.setTextFormat(formato);
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
contrasea.maxChars = 8;
contrasea.defaultTextFormat=formato;
texto.addChild(contrasea);
pan.addChild(texto);
//Listado de alumnos//
//primera pantalla//
var i:int;
var offsety:int;
var n:int = 0;
var j:int = 0;
var dis:int = 0;
var lista:Sprite = new Sprite();
var lista1:Sprite = new Sprite();
var nom:TextField;
var cont:TextField;
actualizarpantalla();
lista.addEventListener(MouseEvent.CLICK, onClickRegistro);
lista1.addEventListener(MouseEvent.CLICK, onClickRegistro);
botonera.addChild(lista);
botonera.addChild(lista1);
function onClickAdelante(evt:MouseEvent):void {
j++;
}
function onClickAtras(evt:MouseEvent):void {
j--;
}
var index:int;
var display:int;
function onClickRegistro(evt:MouseEvent):void {
if (i >0 && display<=dis-1) {
TextField(lista.getChildAt(display)).background = false;
TextField(lista1.getChildAt(display)).background = false;
}
display = int(evt.target.name);
index = display + 12 * j;
var str:String = TextField(lista.getChildAt(display)).text;
var str1:String = TextField(lista1.getChildAt(display)).text;
nombretext.text = str;
contrasea.text = str1;
TextField(lista.getChildAt(display)).background = true;
TextField(lista.getChildAt(display)).backgroundColor = 0x99ccff;
TextField(lista1.getChildAt(display)).background = true;
TextField(lista1.getChildAt(display)).backgroundColor = 0x99ccff;
GA.removeEventListener(MouseEvent.CLICK, onClickGuardarAlumno);
if (!GA.hasEventListener(MouseEvent.CLICK)){
GA.addEventListener(MouseEvent.CLICK, onCambiarAlumno);
}
if (!E.hasEventListener(MouseEvent.CLICK)){
E.addEventListener(MouseEvent.CLICK, onClickE);
}
}
function onCambiarAlumno(evt:MouseEvent):void {
registro.alumno[index].nombre = nombretext.text;
registro.alumno[index].contrasea = contrasea.text;
GA.removeEventListener(MouseEvent.CLICK, onCambiarAlumno);
GA.addEventListener(MouseEvent.CLICK, onClickGuardarAlumno);
E.removeEventListener(MouseEvent.CLICK, onClickE);
}
function onClickE(evt:MouseEvent):void {
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
delete registro.alumno[index];
texto.removeChild(nombretext);
texto.removeChild(contrasea);
nombretext = new TextField();
nombretext.x = 185;
nombretext.y = 60;
contrasea= new TextField();
contrasea.x = 185;
contrasea.y = 120;
GA.removeEventListener(MouseEvent.CLICK, onCambiarAlumno);
}
function actualizarpantalla():void {
if (dis > 0) {
lista.removeChildren(0, dis - 1);
lista1.removeChildren(0, dis - 1);
}
var iactual:int = 12 * j;
offsety = 0;
i = 0;
dis = 0;
for (var pname:String in registro.alumno)
{
if(iactual<=i && i<iactual+12){
nom = new TextField();
cont = new TextField();
nom.name = dis.toString();
cont.name = dis.toString();
nom.x = 20;
nom.y = 220 + offsety;
cont.x = 430;
cont.y = 220 + offsety;
nom.width = 410;
nom.height = 40;
cont.width = 150;
cont.height = 40;
nom.setTextFormat(formato);
nom.defaultTextFormat = formato;
cont.setTextFormat(formato);
cont.defaultTextFormat = formato;
nom.text = registro.alumno.nombre[pname];
cont.text = registro.alumno.contrasea[pname];
lista.addChild(nom);
lista1.addChild(cont);
offsety = offsety + 50;
dis++;
}
i++;
actualizarn();
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
}
if (n>j && !Adelante.hasEventListener(MouseEvent.CLICK) ) {
Adelante.addEventListener(MouseEvent.CLICK, onClickAdelante);
}else if(n==j && Adelante.hasEventListener(MouseEvent.CLICK)){
Adelante.removeEventListener(MouseEvent.CLICK, onClickAdelante);
}
if (j > 0 && !Atras.hasEventListener(MouseEvent.CLICK)) {
Atras.addEventListener(MouseEvent.CLICK, onClickAtras);
}else if (j == 0 && Atras.hasEventListener(MouseEvent.CLICK)) {
Atras.removeEventListener(MouseEvent.CLICK, onClickAtras);
}
}
function actualizarn():void {
n = Math.floor((i-1) / 12);
}
//Listado de alumnos//
//Nuevo Alumno//
var loadNA:Loader = new Loader();
loadNA.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteNuevoAlumno);
loadNA.load(new URLRequest("app:/Nuevo.png"));
function oncompleteNuevoAlumno(event:Event):void {
var image:Bitmap = Bitmap(loadNA.content);
image.x = 540;
image.y = 860;
image.width = 100;
image.height = 100;
NA.addChild(image);
}
NA.buttonMode = true;
NA.addEventListener(MouseEvent.CLICK, onClickNuevoAlumno);
botonera.addChild(NA);
function onClickNuevoAlumno(evt:MouseEvent):void {
var xml:XML =
<alumno>
<nombre>{nombretext.text}</nombre>
<contrasea>{contrasea.text}</contrasea>
<puntos>
<aciertos></aciertos>
<errores></errores>
<intentos></intentos>
</puntos>
</alumno>;
if ((nombretext.length>0 || contrasea.length>0)){
texto.removeChild(nombretext);
texto.removeChild(contrasea);
registro.appendChild(xml);
nombretext = new TextField();
nombretext.x = 185;
nombretext.y = 60;
contrasea= new TextField();
contrasea.x = 185;
contrasea.y = 120;
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
}
}
//Nuevo Alumno//
//Guardar Alumno//
var loadGA:Loader = new Loader();
loadGA.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteGuardarAlumno);
loadGA.load(new URLRequest("app:/Guardar.jpg"));
function oncompleteGuardarAlumno(event:Event):void {
var image:Bitmap = Bitmap(loadGA.content);
image.x = 430;
image.y = 860;
image.width = 100;
image.height = 100;
GA.addChild(image);
}
GA.buttonMode = true;
botonera.addChild(GA);
function onClickGuardarAlumno(evt:MouseEvent):void {
var xml:XML =
<alumno>
<nombre>{nombretext.text}</nombre>
<contrasea>{contrasea.text}</contrasea>
<puntos>
<aciertos></aciertos>
<errores></errores>
<intentos></intentos>
</puntos>
</alumno>;
registro.appendChild(xml);
}
//Guardar Alumno//
//Eliminar Alumno//
loadE.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteE);
loadE.load(new URLRequest("app:/Eliminar.png"));
function onCompleteE(event:Event):void {
image.x = 320;
image.y = 860;
image.width = 100;
image.height = 100;
E.addChild(image);
}
//Eliminar Archivo//
//Botones navegacin por los registros//
var loadAdelante:Loader = new Loader();
loadAdelante.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteAdelante);
loadAdelante.load(new URLRequest("app:/RegistroAdelante.jpg"));
function onCompleteAdelante(event:Event):void {
var image:Bitmap = Bitmap(loadAdelante.content);
image.x = 210;
image.y = 860;
image.width = 100;
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
image.height = 100;
Adelante.addChild(image);
}
Adelante.buttonMode = true;
botonera.addChild(Adelante);
var loadAtras:Loader = new Loader();
loadAtras.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteAtras);
loadAtras.load(new URLRequest("app:/RegistroAtras.png"));
function onCompleteAtras(event:Event):void {
var image:Bitmap = Bitmap(loadAtras.content);
image.x = 110;
image.y = 860;
image.width = 100;
image.height = 100;
Atras.addChild(image);
}
Atras.buttonMode = true;
botonera.addChild(Atras);
//Volver al menu//
var loadBack:Loader = new Loader();
loadBack.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteBack);
loadBack.load(new URLRequest("app:/Back.png"));
function onCompleteBack(event:Event):void {
var image:Bitmap = Bitmap(loadBack.content);
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
back.addChild(image);
}
function onClickBack(evt:MouseEvent):void {
Reg.data.xml = registro;
Reg.flush(3000);
botonera.x += 80;
texto.x += 80;
new ClasesAlumnos(pan, cursoid, capa);
pan.removeChild(texto);
}
}
}
//Volver al menu//
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
flash.events.Event;
flash.net.NetConnection;
flash.net.navigateToURL;
public class Ejercicios extends Sprite

{
public var G:Sprite = new Sprite();
var N:Sprite = new Sprite();
var A:Sprite = new Sprite();
var CA:Sprite = new Sprite();
public function Ejercicios(pan:Sprite)
{
botonera.x = 640;
texto.x = 640;
if (Prob.size < 0) {
problemas =
<datos>
</datos>
} else {
problemas = XML(Prob.data.xml);
}
//Variables de texto//
var formatoTitulo:TextFormat = new TextFormat("arial", 30, null, null, null, true);
titulo.x = 0;
titulo.y = 10;
titulo.width = 640;
titulo.height = 40;
titulo.text = "NUEVO EJERCICIO";
var Tenunciado:TextField = new TextField();
Tenunciado.x = 20;
Tenunciado.y = 60;
Tenunciado.text = "Introduzca aqu el enunciado:";
Tenunciado.autoSize = TextFieldAutoSize.LEFT;
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
Tenunciado.setTextFormat(formato);
texto.addChild(Tenunciado);
enunciado.x = 20;
enunciado.y = 100;
//Selecciona la id del problema a introducir//
{
if (problemas.problema.@id[pname] < iGuardar)
{
} else {
iGuardar = problemas.problema.@id[pname];
}
}
var Tid:TextField = new TextField();
Tid.x = 570;
Tid.y = 60;
Tid.text = "Id:"+iGuardar;
Tid.autoSize = TextFieldAutoSize.LEFT;
Tid.setTextFormat(formato);
Tid.defaultTextFormat = formato;
texto.addChild(Tid);
var Tsolucion:TextField = new TextField();
Tsolucion.x = 20;
Tsolucion.y = 410;
Tsolucion.text = "Solucin:";
Tsolucion.autoSize = TextFieldAutoSize.LEFT;
Tsolucion.setTextFormat(formato);
texto.addChild(Tsolucion);
var solucion:TextField = new TextField();
solucion.type = TextFieldType.INPUT;
solucion.border = true;
solucion.x = 150;
solucion.y = 410;
solucion.width = 100;
solucion.height = 40;
solucion.setTextFormat(formato);
solucion.defaultTextFormat = formato;
texto.addChild(solucion);
var Ttema:TextField = new TextField();
Ttema.x = 260;
Ttema.y = 410;
Ttema.text = "Tema:";
Ttema.autoSize = TextFieldAutoSize.LEFT;
Ttema.setTextFormat(formato);
texto.addChild(Ttema);
var tema:TextField = new TextField();
tema.type = TextFieldType.INPUT;
tema.border = true;
tema.x = 350;
tema.y = 410;
tema.border;
tema.width = 100;
tema.height = 40;
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
tema.setTextFormat(formato);
tema.defaultTextFormat = formato;
texto.addChild(tema);
var Tdificultad:TextField = new TextField();
Tdificultad.x = 460;
Tdificultad.y = 410;
Tdificultad.text = "Dificultad:"
Tdificultad.autoSize = TextFieldAutoSize.LEFT;
Tdificultad.setTextFormat(formato);
texto.addChild(Tdificultad);
var dificultad:TextField = new TextField();
dificultad.type = TextFieldType.INPUT;
dificultad.border = true;
dificultad.x = 592;
dificultad.y = 410;
dificultad.width = 30;
dificultad.height = 40;
dificultad.restrict = "1-3";
dificultad.setTextFormat(formato);
dificultad.defaultTextFormat = formato;
var i:int;
var offsety:int;
var n:int = 0;
var j:int = 0;
var dis:int = 0;
var idm:TextField;
var enun:TextField;
var sol:TextField;
var dif:TextField;
var tem:TextField;
var adelante:Boolean;
var atras:Boolean;
var index:int;
var display:int;
}
var str:String = TextField(lista.getChildAt(display)).text;
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

Tid.text = "Id:" + str;
enunciado.text = str1;
solucion.text = str2;
dificultad.text = str3;
tema.text = str4;
G.removeEventListener(MouseEvent.CLICK, onClickGuardar);
if (!G.hasEventListener(MouseEvent.CLICK)){
G.addEventListener(MouseEvent.CLICK, onCambiarAlumno);
}
if (!E.hasEventListener(MouseEvent.CLICK)){
}
}
function onCambiarAlumno(evt:MouseEvent):void {
problemas.problema[index].enunciado = enunciado.text;
problemas.problema[index].solucion = solucion.text;
problemas.problema[index].tema = tema.text;
problemas.problema[index].dificultad = dificultad.text;
G.removeEventListener(MouseEvent.CLICK, onCambiarAlumno);
G.addEventListener(MouseEvent.CLICK, onClickGuardar);
}
delete problemas.problema[index];
var count:int = 1;
for (var pname:String in problemas.problema){
problemas.problema.@id[pname] = count.toString();
count++;
}
enunciado.x = 20;
enunciado.y = 100;
Tid = new TextField();
Tid.x = 570;
Tid.y = 60;
Tid.text = "Id:"+iGuardar.toString();
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
solucion = new TextField();
solucion.x = 150;
solucion.y = 410;
tema = new TextField();
tema.border = true;
tema.x = 350;
tema.y = 410;
tema.border;
tema.width = 100;
tema.height = 40;
dificultad = new TextField();
dificultad.x = 592;
dificultad.y = 410;
G.removeEventListener(MouseEvent.CLICK, onCambiarAlumno);
}
j++;
}
j--;
}
if (dis>0){
}
offsety = 0;
i = 0;
dis = 0;
{
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426

enun = new TextField();
idm = new TextField();
sol = new TextField();
dif = new TextField();
tem = new TextField();
lista.name = dis.toString();
enun.name = dis.toString();
sol.name = dis.toString();
dif.name = dis.toString();
tem.name = dis.toString();
idm.x = 20;
idm.y = 460 + offsety;
idm.width = 40;
idm.height = 100;
idm.setTextFormat(formato);
idm.defaultTextFormat = formato;
idm.text = problemas.problema.@id[pname];
enun.x = 55;
enun.y = 460 + offsety;
enun.width = 350;
enun.height = 100;
enun.setTextFormat(formato);
enun.defaultTextFormat = formato;
enun.wordWrap = true;
enun.text = problemas.problema.enunciado[pname];
sol.x = 400;
sol.y = 460 + offsety;
sol.width = 150;
sol.height = 50;
sol.setTextFormat(formato);
sol.defaultTextFormat = formato;
sol.text = problemas.problema.solucion[pname];
tem.x = 400;
tem.y = 510 + offsety;
tem.width = 150;
tem.height = 49;
tem.setTextFormat(formato);
tem.defaultTextFormat = formato;
tem.text = problemas.problema.tema[pname];
dif.x = 550;
dif.y = 460 + offsety;
dif.width = 70;
dif.height = 100;
dif.setTextFormat(formato);
dif.defaultTextFormat = formato;
dif.text = problemas.problema.dificultad[pname];
lista.addChild(idm);
lista1.addChild(enun);
lista2.addChild(sol);
lista3.addChild(dif);
lista4.addChild(tem);
dis++;
}
i++;
actualizarn();
}
if (n>j && !Adelante.hasEventListener(MouseEvent.CLICK) ) {
}else if(n==j && Adelante.hasEventListener(MouseEvent.CLICK)){
}
if (j > 0 && !Atras.hasEventListener(MouseEvent.CLICK)) {
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
}else if (j == 0 && Atras.hasEventListener(MouseEvent.CLICK)) {

}
}
}
function onClickGuardar(event:MouseEvent):void {
//Guarda el problema en el archivo//
iGuardar++;
var xml:XML =
<problema id={iGuardar}>
<dificultad>{dificultad.text}</dificultad>
<tema>{tema.text}</tema>
<enunciado>{enunciado.text}</enunciado>
<solucion>{solucion.text}</solucion>
</problema>;
problemas.appendChild(xml);
}
function onClickNuevo(event:MouseEvent):void {
adelante = false;
atras = true;
iGuardar++;
var xml:XML =
</problema>;
problemas.appendChild(xml);
enunciado.x = 20;
enunciado.y = 100;
Tid = new TextField();
Tid.x = 570;
Tid.y = 60;
Tid.text = "Id:"+iGuardar.toString();
solucion.x = 150;
solucion.y = 410;
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
tema.border = true;
tema.x = 350;
tema.y = 410;
tema.border;
tema.width = 100;
tema.height = 40;
dificultad.x = 592;
dificultad.y = 410;
}
Prob.data.xml = problemas;
Prob.flush(3000);
botonera.x += 80;
texto.x += 80;
new Menu(pan);
}
}
}
var loadG:Loader = new Loader();
loadG.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteGuardar);
loadG.load(new URLRequest("app:/Guardar.jpg"));
function oncompleteGuardar(event:Event):void {
var image:Bitmap = Bitmap(loadG.content);
image.x = 430;
image.y = 860;
image.width = 100;
image.height = 100;
G.addChild(image)
}
G.buttonMode = true;
botonera.addChild(G);
var loadN:Loader = new Loader();
loadN.contentLoaderInfo.addEventListener(Event.COMPLETE, oncompleteNuevo);
loadN.load(new URLRequest("app:/Nuevo.png"));
function oncompleteNuevo(event:Event):void {
var image:Bitmap = Bitmap(loadN.content);
image.x = 540;
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
image.y = 860;
image.width = 100;
image.height = 100;
N.addChild(image);
}
N.buttonMode = true;
N.addEventListener(MouseEvent.CLICK, onClickNuevo);
botonera.addChild(N);
//Eliminar Alumno//
image.x = 320;
image.y = 860;
image.width = 100;
image.height = 100;
E.addChild(image);
}
image.x = 210;
image.y = 860;
image.width = 100;
image.height = 100;
}
image.x = 110;
image.y = 860;
image.width = 100;
image.height = 100;
}
//Volver al menu//
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
//Volver al menu//
botonera.x -= 80;
texto.x -= 80;
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
flash.events.Event;
flash.events.TimerEvent;
flash.geom.Point;
flash.net.URLLoaderDataFormat;
flash.net.URLRequestMethod;
flash.net.URLStream;
flash.net.XMLSocket;
flash.display.DisplayObject;
flash.display.Graphics;
flash.events.KeyboardEvent;
flash.utils.Timer;
Menu;
public class ProbarApp extends Sprite

{
var go:Sprite = new Sprite();
var fecha:Date = new Date();
var i:int = 0;
var aciertos:int = 0;
var errores:int = 0;
var intentos:int;
var curso:String;
var clase:String;
public function ProbarApp(pan:Sprite, capa:int)
{
//Entrada//
capa = 1;
texto.x = 640 ;
botonera.x = 640;
texto.addEventListener(Event.ENTER_FRAME, mPantalla);
texto.x -= 80;
botonera.x -= 80;
if (texto.x <= 0) {
texto.removeEventListener(Event.ENTER_FRAME, mPantalla);
}
}
//Entrada//
//Carga registros//
var regxml:XML = new XML();
var Reg1a:SharedObject = SharedObject.getLocal("registro1A");
var Reg1b:SharedObject = SharedObject.getLocal("registro1B");
var Reg1c:SharedObject = SharedObject.getLocal("registro1C");
var Reg1d:SharedObject = SharedObject.getLocal("registro1D");
var Reg2a:SharedObject = SharedObject.getLocal("registro2A");
var Reg2b:SharedObject = SharedObject.getLocal("registro2B");
var Reg2c:SharedObject = SharedObject.getLocal("registro2C");
var Reg2d:SharedObject = SharedObject.getLocal("registro2D");
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
var
var
var
var
var
var
var
var
Reg3a:SharedObject
Reg3b:SharedObject
Reg3c:SharedObject
Reg3d:SharedObject
Reg4a:SharedObject
Reg4b:SharedObject
Reg4c:SharedObject
Reg4d:SharedObject
=
=
=
=
=
=
=
=
SharedObject.getLocal("registro3A");
SharedObject.getLocal("registro3B");
SharedObject.getLocal("registro3C");
SharedObject.getLocal("registro3D");
SharedObject.getLocal("registro4A");
SharedObject.getLocal("registro4B");
SharedObject.getLocal("registro4C");
SharedObject.getLocal("registro4D");
regxml =
<registrocompleto>
{XML(Reg1a.data.xml)}
{XML(Reg1b.data.xml)}
{XML(Reg1c.data.xml)}
{XML(Reg1d.data.xml)}
</registrocompleto>;
//Carga registros//
//Pantalla principal//
var formatoTitulo:TextFormat = new TextFormat("arial", 30);
titulo.x = 0;
titulo.y = 50;
titulo.text = "Introduzca su nombre de usuario y contrasea";
titulo.width = 640;
titulo.height = 40;
var Tus:TextField = new TextField();
Tus.x = 170;
Tus.y = 100;
Tus.width = 300;
Tus.height = 40;
Tus.text = "Usuario";
Tus.setTextFormat(formatoTitulo);
Tus.defaultTextFormat = formatoTitulo;
texto.addChild(Tus);
var Us:TextField = new TextField();
Us.border = true;
Us.type = TextFieldType.INPUT;
Us.width = 300;
Us.height = 40;
Us.x = 170;
Us.y = 140;
Us.setTextFormat(formato);
Us.defaultTextFormat = formato;
texto.addChild(Us);
var Tcon:TextField = new TextField();
Tcon.x = 170;
Tcon.y = 220;
Tcon.text = "Contrasea";
Tcon.width = 300;
Tcon.height = 40;
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
Tcon.setTextFormat(formatoTitulo);
Tcon.defaultTextFormat = formatoTitulo;
texto.addChild(Tcon);
var Con:TextField = new TextField();
Con.border = true;
Con.x = 170;
Con.y = 260;
Con.width = 300;
Con.height = 40;
Con.type = TextFieldType.INPUT;
Con.displayAsPassword = true;
Con.setTextFormat(formato);
Con.defaultTextFormat = formato;
texto.addChild(Con);
//Pantalla principal//
Con.addEventListener(KeyboardEvent.KEY_UP, onContra);
//Pantallazo//
//Pantallazo//
//Funciones//
//Comprueba la contrasea//
function onContra(evt:KeyboardEvent):void{
if (Con.text == regxml.datosalumnos.alumno.(nombre == Us.text).contrasea)
{
aciertos = int(regxml.datosalumnos.alumno.(nombre == Us.text).puntos.
aciertos);
errores = int(regxml.datosalumnos.alumno.(nombre == Us.text).puntos.errores);
intentos = int(regxml.datosalumnos.alumno.(nombre == Us.text).puntos.
intentos);
texto.removeChild(Us);
texto.removeChild(Con);
texto.removeChild(titulo);
texto.removeChild(Tus),
texto.removeChild(Tcon);
correcto();
} else {
}
}
//Comprueba la contrasea//
//Despues de introducir usuario//
function correcto():void {
var Prob:SharedObject = SharedObject.getLocal((fecha.date).toString()+"/"+(
fecha.month+1).toString());
var problemas:XML = new XML(Prob.data.xml);
back.removeEventListener(MouseEvent.CLICK, onClickBackIni);
var
var
var
var
var
var
e:TextField = new TextField();

c:TextField = new TextField();
s:TextField = new TextField();
n:TextField = new TextField();
finish:TextField = new TextField();
id:int = 1;
//Cargar archivo de ejercicios ya introducidos//

e.border = true;
e.width = 600;
e.height = 200;
e.x = 20;
e.y = 20;
e.multiline = true;
e.wordWrap = true;
e.setTextFormat(formato);
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
e.defaultTextFormat = formato;
texto.addChild(e);
c.x = 220;
c.y = 240;
c.autoSize = TextFieldAutoSize.LEFT;
c.setTextFormat(formato);
c.defaultTextFormat = formato;
texto.addChild(c);
s.type = TextFieldType.INPUT;
s.border = true;
s.width = 200;
s.height=50
s.x = 220;
s.y = 290;
s.setTextFormat(formato);
s.defaultTextFormat = formato;
texto.addChild(s);
n.width =20;
n.height = 40;
n.x = 600;
n.y = 180;
n.text = id.toString();
texto.addChild(n);
n.setTextFormat(formato);
n.defaultTextFormat = formato;
finish.x = 20;
finish.y = 200;
finish.width = 600;
finish.height = 200;
finish.setTextFormat(formatoTitulo);
finish.defaultTextFormat = formatoTitulo;
var dato:String=problemas.problema.(@id == id).enunciado;
e.text = dato;
for (var pname:String in problemas.problema) {
i = problemas.problema.@id[pname];
}
var loadGo:Loader = new Loader();
loadGo.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteGo);
loadGo.load(new URLRequest("app:/Go.jpg"));
function onCompleteGo(event:Event):void {
var image:Bitmap = Bitmap(loadGo.content);
image.x = 220;
image.y = 370;
image.width = 200;
image.height = 200;
go.addChild(image);
}
go.buttonMode = true;
go.addEventListener(MouseEvent.CLICK, onClickGo);
botonera.addChild(go);
var tim:Timer = new Timer(500, 1);
tim.addEventListener(TimerEvent.TIMER, onTimer);
function onClickGo(evt:Event):void {
var str:String = problemas.problema.(@id == id).solucion;
if (str == s.text && e.length > 0) {
aciertos = aciertos + int(problemas.problema.(@id == id).dificultad);
intentos++;
c.text = "CORRECTO!";
tim.start();
} else {
errores++;
intentos++;
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
c.text = "NOOOO!";
}
}
function onTimer(evt:TimerEvent):void {
id++;
if (id<=i){
texto.removeChild(e);
texto.removeChild(s);
texto.removeChild(n);
texto.removeChild(c);
e = new TextField();
e.border = true;
e.width = 600;
e.height = 200;
e.x = 20;
e.y = 20;
e.multiline = true;
e.wordWrap = true;
e.setTextFormat(formato);
e.defaultTextFormat = formato;
texto.addChild(e);
c = new TextField();
c.x = 220;
c.y = 240;
c.autoSize = TextFieldAutoSize.LEFT;
c.setTextFormat(formato);
c.defaultTextFormat = formato;
texto.addChild(c);
s = new TextField();
s.type = TextFieldType.INPUT;
s.border = true;
s.width = 200;
s.height = 50;
s.x = 220;
s.y = 290;
s.setTextFormat(formato);
s.defaultTextFormat = formato;
texto.addChild(s);
n = new TextField();
n.width =20;
n.height = 40;
n.x = 600;
n.y = 180;
n.text = id.toString();
n.setTextFormat(formato);
n.defaultTextFormat = formato;
texto.addChild(n);
var dato:String=problemas.problema.(@id == id).enunciado;
e.text = dato;
} else {
texto.removeChild(e);
texto.removeChild(n);
texto.removeChild(c);
texto.removeChild(s);
botonera.removeChild(go);
finish.text = "Buen trabajo!";
texto.addChild(finish);
}
}
}
//Despues de introducir usuario//
//Volver al menu desde la contrasea//
function onClickBackIni(evt:MouseEvent):void {
texto.addEventListener(Event.ENTER_FRAME, mPantallaBack);
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
texto.x += 80;
botonera.x += 80;
if (texto.x == 80) {
new Menu(pan);
} else if (texto.x >= 640) {
texto.removeEventListener(Event.ENTER_FRAME, mPantallaBack);
}
}
}
//Volver al menu desde la contrasea//
//Volver al menu desde los ejercicios//
curso = regxml.datosalumnos.alumno.(nombre == Us.text).parent().curso;
clase = regxml.datosalumnos.alumno.(nombre == Us.text).parent().clase;
var guardar:SharedObject = SharedObject.getLocal("registro" + curso + clase);
var newreg:XML = XML(guardar.data.xml);
newreg.alumno.(nombre == Us.text).puntos.aciertos = aciertos.toString();
newreg.alumno.(nombre == Us.text).puntos.errores = errores.toString();
newreg.alumno.(nombre == Us.text).puntos.intentos = intentos.toString();
guardar.data.xml = newreg;
guardar.flush(3000);
texto.x += 80;
botonera.x += 80;
new Menu(pan);
}
}
}
//Volver al menu desde los ejercicios//
//Funciones//
//Carga de imagenes//
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
back.addEventListener(MouseEvent.CLICK, onClickBackIni);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
flash.automation.StageCaptureEvent;
flash.events.Event;
flash.events.KeyboardEvent;
flash.events.TimerEvent;
flash.utils.Timer;
public class SeleccionArchivo extends Sprite

{
var existentes:XML = new XML();
var crear:Sprite = new Sprite();
var archivo:TextField;
var i:int;
var n:int = 0;
var j:int = 0;
var dis:int = 0;
var index:int;
var offsety:int;
var display:int;
public function SeleccionArchivo(pan:Sprite, capa:int)
{
if (capa==0){
texto.x = 640 ;
botonera.x = 640;
texto.x -= 80;
botonera.x -= 80;
if (texto.x <= 0) {
}
}
} else if (capa == 2) {
texto.x = -640;
botonera.x = -640;
botonera.x += 80;
texto.x += 80;
}
}
}
capa = 1;
var archivos:SharedObject = SharedObject.getLocal("RegistroArchivos");
if (archivos.size >0){
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
existentes = XML(archivos.data.existentes);
} else {
existentes =
<datos>
</datos>;
}
var Tnuevo:TextField = new TextField();

Tnuevo.x = 20;
Tnuevo.y = 50;
Tnuevo.width = 200;
Tnuevo.height = 40;
Tnuevo.text = "Nuevo archivo:";
Tnuevo.setTextFormat(formato);
Tnuevo.defaultTextFormat = formato;
texto.addChild(Tnuevo);
var nuevo:TextField = new TextField();
nuevo.x = 200;
nuevo.y = 50;
nuevo.width = 200;
nuevo.height = 40;
nuevo.border = true;
nuevo.type = TextFieldType.INPUT;
nuevo.setTextFormat(formato);
nuevo.defaultTextFormat = formato;
texto.addChild(nuevo);
nuevo.addEventListener(MouseEvent.CLICK, onNuevo);
function onNuevo(evt:MouseEvent):void {
crear.removeEventListener(MouseEvent.CLICK, onClickSeleccionar);
crear.addEventListener(MouseEvent.CLICK, onClickCrear);
}
}
if (dis>0){
}
offsety = 0;
i = 0;
dis = 0;
for (var pname:String in existentes.item)
{
archivo = new TextField();
archivo.name = dis.toString();
archivo.x = 20;
archivo.y = 100 + offsety;
archivo.width = 350;
archivo.height = 50;
archivo.setTextFormat(formato);
archivo.defaultTextFormat = formato;
archivo.wordWrap = true;
archivo.text = existentes.item[pname];
lista.addChild(archivo);
dis++;
}
i++;
actualizarn();
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
}
}
}
}
crear.removeEventListener(MouseEvent.CLICK, onClickCrear);
crear.addEventListener(MouseEvent.CLICK, onClickSeleccionar);
}
function onClickCrear(evt:MouseEvent):void {
var xml:XML =
<item>{nuevo.text}</item>;
existentes.appendChild(xml);
archivos.data.existentes = existentes;
archivos.flush(3000);
botonera.x -= 80;
texto.x -= 80;
new CrearDeberes(pan, capa, nuevo.text);
} else if (botonera.x == -640) {
}
}
}
function onClickSeleccionar(evt:MouseEvent):void {
botonera.x -= 80;
texto.x -= 80;
new CrearDeberes(pan, capa, TextField(lista.getChildAt(display)).text);
trace(TextField(lista.getChildAt(display)).text);
} else if (botonera.x == -640) {
}
}
}
delete existentes.item[display];
}
texto.x += 80;
botonera.x += 80;
new Menu(pan);
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

}
}
}
//Pantallazos//
//Pantallazos//
//Cargar Imagenes//
//Eliminar Alumno//
image.x = 440;
image.y = 860;
image.width = 100;
image.height = 100;
E.addChild(image);
}
//Crear Archivo//
var loadCrear:Loader = new Loader();
loadCrear.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteCrear);
loadCrear.load(new URLRequest("app:/RegistroAdelante.jpg"));
function onCompleteCrear(event:Event):void {
var image:Bitmap = Bitmap(loadCrear.content);
image.x = 540;
image.y = 860;
image.width = 100;
image.height = 100;
crear.addChild(image);
}
crear.buttonMode = true;
botonera.addChild(crear);
//Crear Archivo//
//Volver al menu//
loadBack.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteArchivo);
function onCompleteArchivo(event:Event):void {
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
//Volver al menu//
//Cargar Imagenes//
}
}
285
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
import
import
flash.events.Event;
public class CrearDeberes

{
var deberes:XML = new XML();
var Adelante1:Sprite = new Sprite();
var Atras1:Sprite = new Sprite();
var Archivo:Sprite = new Sprite();
var Add:Sprite = new Sprite();
var i1:int;
var i2:int;
var n1:int = 0;
var n2:int = 0;
var j1:int = 0;
var j2:int = 0;
var dis1:int;
var dis2:int;
var idm:TextField;
var enun:TextField;
var sol:TextField;
var dif:TextField;
var tem:TextField;
var index1:int;
var index2:int;
var display1:int;
var display2:int;
public function CrearDeberes(pan:Sprite, capa:int, archivo:String)
{
capa = 2;
texto.x = 640 ;
botonera.x = 640;
texto.x -= 80;
botonera.x -= 80;
if (texto.x <= 0) {
}
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
}
problemas = XML(Prob.data.xml);
var Deb:SharedObject = SharedObject.getLocal(archivo);
if (Deb.size>0){
deberes = XML(Deb.data.xml);
}else {
deberes =
<datos>
</datos>;
}
var formato1:TextFormat = new TextFormat("arial", 20);
formato1.align = TextFormatAlign.CENTER;
titulo.x = 0;
titulo.y = 10;
titulo.width = 640;
titulo.height = 40;
titulo.text = "SELECCIONE LOS EJERCICIOS";
var Tenunciado:TextField = new TextField();
Tenunciado.x = 20;
Tenunciado.y = 50;
Tenunciado.text = "Ejercicio "+iGuardar+":";
Tenunciado.defaultTextFormat = formato;
enunciado.x = 20;
enunciado.y = 80;
var Tsolucion:TextField = new TextField();
Tsolucion.x = 525;
Tsolucion.y = 80;
Tsolucion.text = "Solucin:";
Tsolucion.autoSize = TextFieldAutoSize.LEFT;
Tsolucion.setTextFormat(formato);
texto.addChild(Tsolucion);
var solucion:TextField = new TextField();
solucion.x = 525;
solucion.y = 110;
var Ttema:TextField = new TextField();
Ttema.x = 525;
Ttema.y = 140;
Ttema.text = "Tema:";
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
Ttema.autoSize = TextFieldAutoSize.LEFT;
Ttema.setTextFormat(formato);
texto.addChild(Ttema);
var tema:TextField = new TextField();
tema.x = 525;
tema.y = 170;
tema.border;
tema.width = 100;
tema.height = 30;
var Tdificultad:TextField = new TextField();
Tdificultad.x = 525;
Tdificultad.y = 200;
Tdificultad.text = "Dificultad:"
Tdificultad.autoSize = TextFieldAutoSize.LEFT;
Tdificultad.setTextFormat(formato);
texto.addChild(Tdificultad);
var dificultad:TextField = new TextField();
dificultad.x = 525;
dificultad.y = 230;
var ejercicios1:TextField = new TextField();
ejercicios1.x = 10;
ejercicios1.y = 285;
ejercicios1.width = 300;
ejercicios1.height = 30;
ejercicios1.text = "PROBLEMAS INTRODUCIDOS";
ejercicios1.setTextFormat(formato1);
ejercicios1.defaultTextFormat = formato1;
texto.addChild(ejercicios1);
var ejercicios2:TextField = new TextField();
ejercicios2.x = 330;
ejercicios2.y = 285;
ejercicios2.width = 300;
ejercicios2.height = 30;
ejercicios2.text = "PROBLEMAS SELECCIONADOS";
ejercicios2.setTextFormat(formato1);
ejercicios2.defaultTextFormat = formato1;
texto.addChild(ejercicios2);
botonera.graphics.lineStyle(2);
botonera.graphics.drawRect(10, 315, 300, 415);
botonera.graphics.drawRect(330, 315, 300, 415);
//pantalla problemas profesor//
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
actualizarpantalla1();
function onClickRegistro1(evt:MouseEvent):void {
if (i1 >0 && display1<=dis1-1) {
TextField(lista1.getChildAt(display1)).background = false;
}
if (i2 > 0 && display2<=dis2-1){
}
display1 = int(evt.target.name);
index1 = display1 + 4 * j1;
var str:String = TextField(lista1.getChildAt(display1)).text;
var str1:String = TextField(lista2.getChildAt(display1)).text;
Tenunciado.text = "Ejercicio "+str+":";
tema.text = str4;
Add.addEventListener(MouseEvent.CLICK, onClickAadir);
TextField(lista1.getChildAt(display1)).background = true;
TextField(lista1.getChildAt(display1)).backgroundColor = 0x99ccff;
}
function onClickRegistro2(evt:MouseEvent):void {
if (i1 > 0 && display1<=dis1-1) {
}
if(i2>0 && display2<=dis2-1){
}
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
display2 = int(evt.target.name);
index2 = display2 + 4 * j2;
var str:String = TextField(lista6.getChildAt(display2)).text;
Tenunciado.text = "Ejercicio "+str+":";
tema.text = str4;
}
function actualizarpantalla1():void {
var offsety:int = 0;
var iactual:int = 4 * j1;
if (i1>1){
lista1.removeChildren(0, dis1 - 1);
}
i1 = 0;
dis1 = 0;
{
if(iactual<=i1 && i1<iactual+4){
idm.name = dis1.toString();
enun.name = dis1.toString();
sol.name = dis1.toString();
dif.name = dis1.toString();
tem.name = dis1.toString();
idm.x = 20;
idm.width = 32;
idm.height = 100;
idm.text = problemas.problema.@id[pname];
enun.x = 50;
enun.width = 170;
enun.height = 100;
enun.text = problemas.problema.enunciado[pname];
sol.x = 220;
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426

sol.width = 80;
sol.height = 32;
sol.text = problemas.problema.solucion[pname];
tem.x = 220;
tem.width = 80;
tem.height = 32;
tem.text = problemas.problema.tema[pname];
dif.x = 220;
dif.width = 80;
dif.height = 40;
dif.text = problemas.problema.dificultad[pname];
lista1.addChild(idm);
dis1++;
}
i1++;
}
actualizarn1();
if (n1>j1 && !Adelante.hasEventListener(MouseEvent.CLICK) ) {
}else if(n1==j1 && Adelante.hasEventListener(MouseEvent.CLICK)){
}
if (j1 > 0 && !Atras.hasEventListener(MouseEvent.CLICK)) {
}else if (j1 == 0 && Atras.hasEventListener(MouseEvent.CLICK)) {
}
}
function actualizarn1():void {
n1 = Math.floor((i1-1) / 4);
}
function actualizarpantalla2():void {
var offsety:int = 0;
var iactual:int = 4 * j2;
if (dis2 > 0){
}
i2 = 0;
dis2 = 0;
for (var pname:String in deberes.problema){
if(iactual<=i2 && i2<iactual+4){
idm.name = dis2.toString();
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
enun.name = dis2.toString();
sol.name = dis2.toString();
dif.name = dis2.toString();
tem.name = dis2.toString();
idm.x = 340;
idm.width = 32;
idm.height = 100;
idm.text = deberes.problema.@id[pname];
enun.x = 370;
enun.width = 170;
enun.height = 100;
enun.text = deberes.problema.enunciado[pname];
sol.x = 540;
sol.width = 80;
sol.height = 32;
sol.text = deberes.problema.solucion[pname];
tem.x = 540;
tem.width = 80;
tem.height = 32;
tem.text = deberes.problema.tema[pname];
dif.x = 540;
dif.width = 80;
dif.height = 40;
dif.text = deberes.problema.dificultad[pname];
lista6.addChild(idm);
dis2++;
}
i2++;
}
actualizarn2();
if (n2>j2 && !Adelante1.hasEventListener(MouseEvent.CLICK) ) {
Adelante1.addEventListener(MouseEvent.CLICK, onClickAdelante1);
}else if(n2==j2 && Adelante1.hasEventListener(MouseEvent.CLICK)){
Adelante1.removeEventListener(MouseEvent.CLICK, onClickAdelante1);
}
if (j2 > 0 && !Atras1.hasEventListener(MouseEvent.CLICK)) {
Atras1.addEventListener(MouseEvent.CLICK, onClickAtras1);
}else if (j2 == 0 && Atras1.hasEventListener(MouseEvent.CLICK)) {
Atras1.removeEventListener(MouseEvent.CLICK, onClickAtras1);
}
}
function actualizarn2():void {
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
n2 = Math.floor((i2-1) / 4);
}
j1++;
}
function onClickAdelante1(evt:MouseEvent):void {
j2++;
}
j1--;
}
function onClickAtras1(evt:MouseEvent):void {
j2--;
}
function onClickAadir(evt:MouseEvent):void {
for (var pname:String in deberes.problema)
{
if (deberes.problema.@id[pname] < iGuardar)
{
} else {
iGuardar = deberes.problema.@id[pname];
}
}
iGuardar++;
var xml:XML =
</problema>;
deberes.appendChild(xml);
}
delete deberes.problema[index2];
var count:int = 1;
for (var pname:String in deberes.problema){
deberes.problema.@id[pname] = count.toString();
count++;
}
texto.removeChild(Tenunciado);
Tenunciado = new TextField();
Tenunciado.x = 20;
Tenunciado.y = 50;
Tenunciado.text = "Ejercicio :";
Tenunciado.defaultTextFormat = formato;
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639

enunciado.x = 20;
enunciado.y = 80;
solucion.x = 525;
solucion.y = 110;
tema.x = 525;
tema.y = 170;
tema.border;
tema.width = 100;
tema.height = 30;
dificultad.x = 525;
dificultad.y = 230;
}
Deb.data.xml = deberes;
Deb.flush(3000);
botonera.x += 80;
texto.x += 80;
new SeleccionArchivo(pan, capa);
if (dis2 > 0){
}
}
}
}
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
image.x = 190;
image.y = 740;
image.width = 70;
image.height = 70;
var bitmap2:BitmapData = bitmap.clone();
var image2:Bitmap = new Bitmap(bitmap2);
image2.x = 510;
image2.y = 740;
image2.width = 70;
image2.height = 70;
Adelante1.addChild(image2);
}
Adelante1.buttonMode = true;
botonera.addChild(Adelante1);
image.x = 60;
image.y = 740;
image.width = 70;
image.height = 70;
var bitmap2:BitmapData = bitmap.clone();
var image2:Bitmap = new Bitmap(bitmap2);
image2.x = 380;
image2.y = 740;
image2.width = 70;
image2.height = 70;
Atras1.addChild(image2);
}
Atras1.buttonMode = true;
botonera.addChild(Atras1);
//Boton aadir ejercicio//
var loadAdd:Loader = new Loader();
loadAdd.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteAdd);
loadAdd.load(new URLRequest("app:/Aadir.jpg"));
function onCompleteAdd(event:Event):void {
var image:Bitmap = Bitmap(loadAdd.content);
image.x = 295;
image.y = 820;
image.width = 50;
image.height = 50;
Add.addChild(image);
}
Add.buttonMode = true;
botonera.addChild(Add);
//Boton aadir ejercicio//
//Eliminar Alumno//
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749

image.x = 455;
image.y = 750;
image.width = 50;
image.height = 50;
E.addChild(image);
}
//Volver al menu//
loadBack.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteArchivo);
function onCompleteArchivo(event:Event):void {
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
//Volver al menu//
//Pantallazos//
//Pantallazos//
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package
{
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Loader;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.net.SharedObject;
import flash.net.URLRequest;
/**
* ...
* @author Murcis
*/
public class Carrera extends Sprite
{
var registro:XML;
var metros:int;
var offset:int = 0;
var coches:Sprite = new Sprite();
var image:Bitmap;
var bitmap:BitmapData;
public function Carrera(pan:Sprite)
{
var Reg:SharedObject = SharedObject.getLocal("registro1A");
registro = XML(Reg.data.xml);
var loadCoches:Loader = new Loader();
loadCoches.contentLoaderInfo.addEventListener(Event.COMPLETE, onCompleteCoches);
loadCoches.load(new URLRequest("app:/Moto1.jpg"));
function onCompleteCoches(event:Event):void {
image = Bitmap(loadCoches.content);
bitmap = image.bitmapData;
for (var pname:String in registro.alumno) {
metros = registro.alumno.puntos.aciertos[pname]*20-registro.alumno.puntos.
errores[pname]*5;
bitmap = bitmap.clone();
image = new Bitmap(bitmap);
image.x = 20 + metros;
image.y = 50+offset;
image.width = 50;
image.height = 50;
coches.addChild(image);
offset += 50;
}
}
function onClickBack(evt:Event):void {
coches.addEventListener(Event.ENTER_FRAME, mPantallaBack);
coches.x += 80;
botonera.x += 80;
if (coches.x == 80) {
new Menu(pan);
} else if (coches.x >= 640) {
coches.removeEventListener(Event.ENTER_FRAME, mPantallaBack);
pan.removeChild(coches);
}
}
}
//pantallazos//
pan.addChild(coches);
//pantallazos//
//Cargar imagenes//
//Volver al menu//
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
//Volver al Menu//
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package
{
import
import
import
import
import
import
import
import
import
import
import
flash.display3D.textures.Texture;
flash.events.Event;
public class VerResultados extends Sprite

{
var alumnos:XML;
public function VerResultados(pan:Sprite)
{
//Entrada//
texto.x = 640 ;
botonera.x = 640;
texto.x -= 80;
botonera.x -= 80;
if (texto.x <= 0) {
}
}
//Entrada//
//Alumnos//
var reg1A:SharedObject = SharedObject.getLocal("registro1A");
alumnos = XML(reg1A.data.xml);
var
var
var
var
var
var
formato:TextFormat = new TextFormat("arial", 30);

nombre:TextField = new TextField();
aciertos:TextField = new TextField();
errores:TextField = new TextField();
efectividad:TextField = new TextField();
offsety:int = 20;
for (var pname:String in alumnos.alumno) {

nombre = new TextField();
aciertos = new TextField();
errores = new TextField();
efectividad = new TextField();
nombre.x = 20;
nombre.width = 300;
nombre.height = 50;
nombre.setTextFormat(formato);
nombre.defaultTextFormat = formato;
aciertos.x = 320;
aciertos.width = 50;
aciertos.height = 50;
aciertos.setTextFormat(formato);
aciertos.defaultTextFormat = formato;
errores.x = 390;
errores.width = 50;
errores.height = 50;
errores.setTextFormat(formato);
errores.defaultTextFormat = formato;
efectividad.x = 460;
efectividad.width = 80;
efectividad.height = 50;
efectividad.setTextFormat(formato);
efectividad.defaultTextFormat = formato;
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
nombre.y = offsety;
aciertos.y = offsety;
errores.y = offsety;
efectividad.y = offsety;
nombre.text = alumnos.alumno.nombre[pname];
aciertos.text = alumnos.alumno.puntos.aciertos[pname];
errores.text = alumnos.alumno.puntos.errores[pname];
efectividad.text = (int(aciertos.text) / int(alumnos.alumno.puntos.intentos[
pname])).toString();
texto.addChild(nombre);
texto.addChild(aciertos);
texto.addChild(errores);
texto.addChild(efectividad);
offsety += 50;
}
//pantallazos//
//pantallazos//
//Volver al menu//
image.x = 0;
image.y = 860;
image.width = 100;
image.height = 100;
}
botonera.x += 80;
texto.x += 80;
new Menu(pan);
}
}
}
//Volver al menu//
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<?xml version="1.0" encoding="utf-8"?>

<application xmlns="http://ns.adobe.com/air/application/4.0">
<id>com.upc.TFGJMMellado</id>
<versionNumber>0.1.0</versionNumber>
<supportedProfiles>mobileDevice</supportedProfiles>
<filename>App</filename>
<name>App</name>
<android>
<manifestAdditions><![CDATA[<manifest android:installLocation="auto">
<uses-sdk android:minSdkVersion="8" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-feature android:required="true"
android:name="android.hardware.touchscreen.multitouch" />
</manifest>]]></manifestAdditions>
</android>
<iPhone>
<InfoAdditions><![CDATA[<key>UIStatusBarStyle</key>
<string>UIStatusBarStyleBlackOpaque</string>
<key>UIRequiresPersistentWiFi</key>
<string>NO</string>
<key>UIPrerenderedIcon</key>
<true />
<key>UIApplicationExitsOnSuspend</key>
<true />
<key>UIDeviceFamily</key>
<array>

<string>1</string>


</array>]]></InfoAdditions>
<requestedDisplayResolution>high</requestedDisplayResolution>
</iPhone>
<initialWindow>
<title>App</title>
<content>Tablas.swf</content>
<visible>true</visible>
<fullScreen>true</fullScreen>


<renderMode>direct</renderMode>


<systemChrome>standard</systemChrome>
<width>960</width>
<height>640</height>
</initialWindow>
<icon>
<image48x48>icons/icon_48.png</image48x48>

</icon>
<!-AIR options:
http://livedocs.adobe.com/flex/3/html/File_formats_1.html#1043413
AIR mobile options:
http://help.adobe.com/en_US/air/build/WSfffb011ac560372f-5d0f4f25128cc9cd0cb-7ffe.html
iOS icons guidelines:
http://developer.apple.com/library/ios/#documentation/userexperience/conceptual/mobilehig/Ic
onsImages/IconsImages.html
68
69
70
71
72
Android manifest documentation:

http://developer.android.com/guide/topics/manifest/manifest-intro.html
-->
</application>

Diseño y Desarrollo de Una Aplicación Movil para La Enseñananza de Las Matemáticas en La ESO

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Diseño y Desarrollo de Una Aplicación Movil para La Enseñananza de Las Matemáticas en La ESO

Uploaded by

Copyright:

Available Formats

Diseo y desarrollo de una aplicacin mvil para la enseanza de las matemticas en la ESO

que comprenden la enseanza secundara del actual sistema

Objetivos del proyecto .................................................................................. 11

Alcance del proyecto .................................................................................... 11

SISTEMA OPERATIVO Y ENTORNO DE DESARROLLO _________ 13

Sistema operativo ......................................................................................... 13

Lenguaje y entorno de programacin........................................................... 14

Adobe Air ........................................................................................................ 17

Interfaz de programacin de aplicaciones (API).............................................. 18

Motor de ejecucin .......................................................................................... 19

FUNCIONALIDAD, DISEO Y ESTRUCTURA __________________ 21

Funcionalidad y Diseo ................................................................................ 21

Funciones del profesor.................................................................................... 23

4.1.1.1 Gestin del fichero de ejercicios ..................................................................... 23

Funciones del alumno ..................................................................................... 31

4.1.2.1 Resolucin de ejercicios ................................................................................. 31

GESTIN Y ESTRUCTURA DE LOS FICHEROS DE DATOS ______39

XML: eXtensible Markup Lenguage............................................................. 39

Estructura y funcionamiento del cdigo XML ...................................................39

Otras alternativas .............................................................................................41

Cdigo para la gestin de XML.................................................................... 41

Creacin de una variable XML .........................................................................42

Aadir registros nuevos a un fichero ................................................................42

Conversin de un archivo en una variable XML...............................................43

Consulta de datos dentro de los ficheros .........................................................43

Recorrer toda la estructura de una variable XML .............................................44

Eliminar registros de una variable XML............................................................44

Contenido de los ficheros ............................................................................ 45

Fichero de alumnos .........................................................................................45

Fichero de Ejercicios ........................................................................................47

Fichero de deberes ..........................................................................................48

La clase principal: Sprite .............................................................................. 49

Carga de imgenes externas ....................................................................... 51

Cdigo para los cuadros de texto.....................................................................56

Cdigo para la gestin de eventos...................................................................54

Cdigo para la visualizacin ............................................................................51

Cdigo de la clase Sprite .................................................................................49

Cdigo para guardar archivos en el dispositivo................................................58

Descarga de archivos del servidor............................................................... 58

PLANIFICACIN TEMPORAL _______________________________60

Fases de desarrollo ..................................................................................... 60

Duracin de las fases.......................................................................................61

COSTE DEL PROYECTO___________________________________ 63

Costes de recursos humanos....................................................................... 63

Costes de las herramientas utilizadas .......................................................... 64

Coste total del proyecto ................................................................................ 65

IMPACTO MEDIOAMBIENTAL ______________________________ 67

Referencias bibliogrficas ............................................................................ 73

2.1 Objetivos del proyecto

2.2 Alcance del proyecto

3 Sistema operativo y entorno de desarrollo

Imagen 3.1: Cuotas de mercado de los OS mviles para el estado Espaol.

3.2 Lenguaje y entorno de programacin

La versin actual de este lenguaje apareci en el ao 2006 e incorpora gran cantidad de

Imagen 3.2: Interfaz grfica de la plataforma FlashDevelop V4.6.2.5

3.2.3 Adobe Air

3.2.4 Interfaz de programacin de aplicaciones (API)

3.2.5 Motor de ejecucin

Imagen 3.3: Esquema de funcionamiento de Adobe AIR.

4 Funcionalidad, Diseo y Estructura

4.1 Funcionalidad y Diseo

Esquema 4.1: Flujo de datos entre las funciones

Como se ha explicado, el diseo de la app depende, en su gran mayora, de la estructura