Download “Administración de aula virtual para la enseñanza de programación

SEP
SEMS
DGETI
Dirección general de educación tecnológica industrial
Centro de estudios tecnológicos industrial y de servicios no. 166
“Carmen Serdán Alatriste”
C.C.T.
09DCT0049R
“Administración de aula virtual
para la enseñanza de
programación de
equipos móviles”
TESINA
PARA OBTENER EL TÍTULO DE:
TÉCNICO EN INFORMÁTICA
CLAVE: BTCININ07
PRESENTAN:
Acevedo Ortiz Jesús
Añorve Brito Ángel
Breña Cortes Ángel
Cerecedo Noguez Francisco Javier
ASESORES:
Ing. Guillermo García García.
Lic. Víctor Mejía Lavanderos.
JULIO 2012
ii
52
iii
52
iv
52
v
52
vi
Dedicatoria:
A mi Familia
Acevedo Ortiz Jesús
vii
Dedicatoria:
En este libro se la dedico a las personas más importantes que es mi
familia en especial a mis padres ya que por ellos en todo momento me
apoyaron en el transcurso de mis estudios y gracias a eso e salido
adelante, también a mis amigos de la escuela que me ayudaron en las
tareas y trabajos en equipo ya que también sin eso no lo pudiera a
ver logrado.
Gracias a todas esas personas que me apoyaron durante todo el transcurso de mis estudios
Añorve Brito Ángel
viii
Dedicatoria:
A mi familia
Breña Cortes Ángel
ix
Dedicatoria
Agradezco
Eva Noguez Velazquez
Francisco Cerecedo Cervantes
Mayra Denisse Cerecedo Noguez
Les agradezco por todo el apoyo que me han brindado en mis estudios
, principalmente cuando me siento triste ustedes me apoyan con sus
consejos y buenos ánimos que me brindan en mi persona por eso les
dedico con todo mi cariño este titulo que si no fuera por su apoyo no
lo hubiera conseguido gracias
Cerecedo Noguez Francisco Javier
x
Delimitación de tema
La finalidad que persigue el portal e-Learning del Centro de Estudios Tecnológicos industrial y de servicios no. 166 es la de apoyar el proceso de
enseñanza-aprendizaje requeridos por los estudiantes y profesores. Para
este efecto el portal e-Learning se construirá utilizando plataformas de
Gestión de Contenidos (LCMS)
las cuales se centran en la gestión de
los contenidos de aprendizaje. En el caso específico del portal, se contemplará: la creación de cursos, reutilización, desarrollo y gestión de los
contenidos didácticos, gestión de usuarios, evaluación y seguimiento del
aprendizaje y gestión de servicios de comunicación como foros y chats.
Hipótesis
El uso de una plataforma virtual que auxilie a los profesores del centro
de estudios tecnológicos industrial y de servicios no. 166 en el proceso
de enseñanza-aprendizaje puede ser una ventaja competitiva tanto para
los alumnos como para los profesores, además de disminuir los índices
de reprobación.
Justificación
En la actualidad, los teléfonos celulares son un bien a los que accede una
gran parte de la población, hoy cuatro de cada cinco mexicanos cuentan
con una línea móvil, sin embargo, en la opinión de The Competitive Inte-
xi
lligence Unit (CIU).Sin embargo, el país deberá esperar hasta 2014 para
alcanzar una penetración de 100% a medida que la tecnología avanza,
estos aparatos han dejado de ser únicamente un mecanismo de comunicación y se han convertido en herramientas de productividad, y por lo
tanto incorporan nuevas funciones, brindan mas prestaciones y permiten
a los usuarios acceder a diversos servicios.
La mayoría de los fabricantes de dispositivos incorporan la plataforma
Java micro edition en sus productos, especialmente los desarrolladores
crean aplicaciones que funcionen sobre estos equipos. A pesar de disponer de una plataforma estandarizada, la experiencia del usuario se ve
afectada debido a la forma en la que una misma aplicación se presenta e
interactúa con el usuario en uno u otro dispositivo.
Objetivo
El presente proyecto de titulación tiene por objetivo el desarrollo del portal de enseñanza (E-Learning) para el centro de estudios tecnológicos
industrial y de servicios no. 166 “Carmen Serdán Alatriste”, que permitirá
a los estudiantes y profesores conocer y reforzar sus conocimientos en
programación de dispositivos móviles.
Metodología
El presente trabajo se centra en el desarrollo de la programación de dis-
xii
positivos móviles que permitan el manejo de las interfaces graficas de
usuario en aplicaciones basadas en la plataforma Java Me, orientada específicamente a permitir que los desarrolladores tengan las bases y elaboren aplicaciones móviles con una apariencia actualizada y ofrezcan una
experiencia de usuario consistente y estandarizada en cualquier dispositivo en el que se ejecuten.
Problemática
Los elementos del problema son los siguientes:
• Necesidad de “Aulas Virtuales” como una alternativa metodológica en
el quehacer pedagógico al interior de los entornos educativos presenciales.
• Necesidad de expandir los alcances de los programas de La Educación
Media Superior.
• Fortalecer el carácter de internacionalización de los programas de La
Educación Media Superior para compartir video-conferencias, cursos
y procesos mediante el uso de tecnologías que permiten la comunicación a distancia en el tiempo presente inmediato.
• Replanteamiento de las prácticas pedagógicas, mediante un enfoque
de enseñanza más contextualizado y acorde a las nuevas tecnologías
de la información y comunicación.
• Fortalecer la posibilidad de cursos a distancia y programas virtuales.
• Motivar al estudiante y docente para enfrentar nuevas herramientas
que los coloquen en la autopista de la información y la comunicación.
xiii
Cuestionamientos
¿Cuáles son las fortalezas y debilidades de la educación e-learnig?
¿Cuáles son las ventajas e inconvenientes?
¿Qué hay detrás de una propuesta de e -learning?
¿Las nuevas tecnologías propician la aparición de nuevos tipos de aprendizaje?
xiv
Introducción
En el capítulo 1 se muestra un panorama inicial de uso de las plataformas
virtuales en el sistema educativo.
En el capítulo 2 se ofrece una visión general acerca de la plataforma Java
micro Edition, sus características y limitaciones, y se conoce acerca de
la forma en que Java micro Edition gestiona las interfaces graficas de
usuario de forma predeterminada. También se hace una revisión de la
metodología de desarrollo de software Open UP y se repasan las consideraciones que se deben hacer para desarrollar interfaces de usuario
utilizables y funcionales, tomando en cuenta las características generales
de los dispositivos móviles.
En el capítulo 3 se describe el proceso de desarrollo de una aplicación
sencilla siguiendo las practicas establecidas por la metodología de desarrollo de software Open UP.
xv
Contenido
Hipótesis_______________________________________________________________________xiii
Justificación____________________________________________________________________xiii
Objetivo________________________________________________________________________xiv
Metodología____________________________________________________________________xiv
Problemática___________________________________________________________________ xv
Cuestionamientos______________________________________________________________xvi
Introducción___________________________________________________________________ xvii
Capítulo 1 Impacto del uso de las aulas virtuales________________________________ 1
1.1 Introducción________________________________________________________________ 2
1.2 Moodle_____________________________________________________________________ 6
Capítulo 2 Visión general acerca de la plataforma Java micro Edition����������� 7
2.1 Plataforma java micro edition______________________________________________ 8
2.2 Evolución de la plataforma_________________________________________________ 8
2.3 Características de Java micro edition_______________________________________ 8
Capítulo 3 Desarrollo de una aplicación sencilla________________________________ 25
3.1 Concepción________________________________________________________________ 26
3.2 Elaboración________________________________________________________________ 26
3.3 Construcción______________________________________________________________ 34
3.4 Transición_________________________________________________________________ 35
Bibliografía_____________________________________________________________________ 36
xvi
Capítulo 1 Impacto del uso de las aulas virtuales
1
1.1 Introducción
El modelo pedagógico de la Educación Media Superior está basado en
la formación integral del individuo en todos los componentes de conocimiento, procedimentales, actitudinales para poder enfrentarse a un
mundo competitivo y globalizado. La formación académica debe otorgar
herramientas suficientes al estudiante para involucrarlo en el mundo telemático actual, que además involucren el pensamiento superior y lo enfrenten a los retos que la formación empresarial exige.
Por su parte, la educación debe ir en el camino constante de la evolución.
Las tecnologías de la comunicación y la información, como líderes del
nuevo desarrollo, marcan el camino por el cual la educación debe seguir
su sendero. Actualmente las entidades educativas están implementando
estas tecnologías en el quehacer académico, dado que, no sólo apoyan el
trabajo del aula sino que ayudan en la construcción del conocimiento que
hace el estudiante junto con el maestro guía o tutor.
La unión de estos dos conceptos motiva la implementación de Aulas Virtuales en la educación media superior.
El desarrollo del proyecto inicia con el concepto de Entornos Virtuales de
Aprendizaje, es una definición que aclara la utilización de la frase “aula
virtual”, ya que se trata de entornos virtuales dedicados al proceso enseñanza - aprendizaje.
Un entorno de aprendizaje es un espacio o comunidad organizada con
2
el propósito de aprender. Para que tenga lugar de aprendizaje. Han de
estar presentes ciertos componentes que se definen desde una óptica
interdisciplinar.
• Funciones
pedagógicas (actividades de aprendizaje, situaciones de
enseñanza, materiales de aprendizaje, apoyo y autorización, evaluación, entre otros).
• Las tecnologías apropiadas (herramientas seleccionadas que
están
conectadas con el modelo pedagógico).
• La organización social de la educación (espacio, calendario y comunidad).
Esta incorporación al ámbito educativo de la Educación Media Superior
supone una extensión natural de lo que viene siendo la creciente virtualización de la sociedad actual. En este sentido las Tecnologías de la Información y la Comunicación permiten incrustar nuevas dimensiones y vías
de interacción profesor/alumno, compatibles con el modelo integral de la
Institución.
De manera paralela a la caracterización, establece el concepto de constructivismo pedagógico, según el cual, el conocimiento y el aprendizaje
humano, son el producto de una construcción mental donde el “fenómeno real” se produce mediante la interacción sujeto cognoscente-objeto
conocido, siendo desde esta perspectiva inapropiado la separación entre
investigador e investigado, ya que tanto los datos como los hechos científicos surgen de la interacción ininterrumpida del hombre frente a su
entorno.
3
Según la filosofía constructivista el aprendizaje se logra por medio de la
interacción del estudiante con los estímulos que lo rodean, además según
la corriente psicológica conductivista, los individuos actúan de acuerdo
con los estímulos que reciben, esencialmente del orden natural y social,
lo que permite la construcción de significados en la mente. Para el constructivismo, el conocimiento humano no se origina en la pasividad de la
mente, sino que es construido activamente por el sujeto que conoce en
su adaptación con el medio.
En consecuencia, se debe implementar una tecnología específica para
adaptarla al modelo pedagógico de la Educación Media Superior, basada,
no solamente en la inmersión del estudiante en el mundo Informático y
cibernético sino en el constructivismo pedagógico que permite la aprehensión del conocimiento de manera integral.
La ejecución de cualquier tecnología informática debe tener en cuenta los
costos de uso y manejo. Un software tradicional exige a sus usuarios la
legalidad y la compra de licencias por lapsos determinados. Sin embargo,
surge la necesidad, para la Institución, de trabajar con un software de
bajo o ningún costo.
De esta forma, aparece el software libre, que respeta la libertad de los
usuarios para modificar el producto y adaptarlo a sus necesidades, bajo
licencias especiales. Una es conocida como GLP GNU, que le permite al
autor tener el copyrigth pero permite al usuario su estudio, modificación
y distribución.
4
Es, entonces, donde se aplica la herramienta Moodle, bajo licencia GLP
GNU, para la creación de las Aulas Virtuales de Aprendizaje en la Educación Media Superior, dada su característica de constructivismo pedagógico y social.
El proyecto luego de caracterizar los conceptos claves, se centra en la
manipulación, diseño e implementación de esta plataforma, de manera
progresiva, no solo como ayuda de las clases presenciales, sino también
como un organizador de contenidos curriculares, en todas las materias de todos los programas de La Educación Media Superior.
La implementación de Aulas Virtuales de Aprendizaje aparece, de esta
forma no sólo como un espacio de modernización de la educación conforme la exigencia de los tiempos modernos sino como un espacio de
reflexión acerca de la pertinencia y actualidad del modelo educacional
mexicano, dada su aplicabilidad, no solo en la Institución sino en el sistema pedagógico nacional; que debería, en un futuro no muy lejano, migrar
de manera masiva hacia estas tecnologías, casi de manera imperativa, en
todas las entidades educativas.
De esta forma se pretende, crear una herramienta pedagógica que ayude
al quehacer de docentes, al aprendizaje de estudiantes, a la organización
metodológica de contenidos y al mejoramiento del modelo pedagógico
que debe ir acorde con los nuevos retos de la educación y la formación
de empresarios globalizados y globalizantes
5
1.2 Moodle
Moodle es un paquete de software para la creación de cursos y sitios Web
basados en Internet. Es un proyecto en desarrollo diseñado para
dar
soporte a un marco de educación social constructivista. (http://moodle.
org)
Moodle se distribuye gratuitamente como Software libre (Open Source)
(bajo la Licencia pública GNU). Básicamente esto significa que Moodle
tiene derechos de autor (copyright), pero que tiene algunas libertades. Se
puede copiar, usar y modificar Moodle siempre que acepte: proporcionar
el código fuente a otros, no modificar o eliminar la licencia original y los
derechos de autor, y aplicar esta misma licencia a cualquier trabajo derivado de él.
Moodle puede funcionar en cualquier ordenador en el que pueda correr
PHP, y soporta varios tipos de bases de datos (en especial MySQL).
La palabra Moodle es un acrónimo de Modular Object-Oriented Dynamic
Learning Environment (Entorno de Aprendizaje Dinámico Orientado a Objetos y Modular), lo que resulta fundamentalmente útil para programadores y teóricos de la educación.
Para la construcción de Aulas Virtuales de Aprendizaje en el centro de
estudios industrial y de servicios número 166, se implementará la plataforma Moodle.
6
Capítulo 2 Visión general acerca de la plataforma Java
micro Edition
7
2.1 Plataforma java micro edition
La plataforma Java micro edition es una colección de tecnologías y especificaciones diseñadas concretamente para su uso en dispositivos móviles
y sistemas embebidos.
Estas tecnologías se pueden combinar para construir un entorno de tiempo de ejecución java completo, optimizado para ajustarse a los requisitos de un mercado o de equipos específicos, como aparatos industriales,
electrodomésticos, y dispositivos personales. De esta última categoría,
sobresalen por su naturaleza los teléfonos celulares.
2.2 Evolución de la plataforma
Sun Microsystems diseñó java micro edition con la intención de reemplazar una tecnología anterior similar denominada PersonalJava.
El desarrollo de JME se realizó y se liberó como la especificación jcp-68. A
partir de esta especificación se han creado diferentes versiones de java
micro edition, cada una detallada en un JSR diferente.
En diciembre de 2006, Sun Microsystems lanzó el código fuente de JME
bajo la licencia GNU General Public License con el nombre de phoneME.
2.3 Características de Java micro edition
Sun Microsystems creo la tecnología java micro edition con el objetivo
8
de simplificar el desarrollo de aplicaciones para dispositivos pequeños y
manejar adecuadamente sus restricciones.
Las condiciones básicas que se definieron para java Me eran, principalmente, ajustarse a un entorno de trabajo reducido y posibilitar la creación de aplicaciones Java que se ejecuten en dispositivos con memoria
limitada, pantalla pequeña y capacidad energética restringida.
La arquitectura de java micro edition se encuentra compuesta por tres
elementos fundamentales: configuraciones, perfiles y paquetes opcionales.
arquitectura general de java micro edition
Las configuraciones especifican una máquina virtual de java y un conjunto limitado de interfaces de programación (API) para un amplio rango de
dispositivos, similares en memoria y poder de procesamiento. En esencia,
es la capa que minimiza la plataforma Java, removiendo algunos componentes, como partes del lenguaje, requisitos de hardware y bibliotecas
9
adicionales.
Como parte del desarrollo de java micro edition, Sun desarrolló dos configuraciones principales: CDC (connected device configuration y CLDC (connected, limited device configuration)
Las configuraciones permiten que los desarrolladores cuenten con un
conjunto estándar de funcionalidades básicas para cualquier dispositivo.
Los perfiles son un conjunto de APIs especializadas, adicionales a las provistas por las configuraciones, que permiten manejar y estandarizar algunas funcionalidades que los fabricantes de dispositivos móviles pueden
incluir en sus productos.
Los paquetes opcionales son un conjunto de APIs orientados hacia una
tecnología específica, que los fabricantes pueden o no incluir en sus dispositivos.
Perfiles y configuraciones principales
Connected Device Configuration — CDC
Esta configuración se enfoca en dispositivos grandes, como televisores
digitales, consolas de video, aparatos de televisión por cable, sistemas de
navegación vehicular, PDAs de altas prestaciones, y demás dispositivos.
Un dispositivo conectado incluye usualmente un CPU de 32 bits, con al
10
menos 2 MB de memoria RAM y unos 2.5 MB de memoria ROM disponible
para el entorno de aplicación Java.
Las implementaciones de referencia para los perfiles de CDC se basan en
Linux ejecutándose sobre una PC Intel compatible.
CDC especifica que los dispositivos que la implementen deben soportar
una JVM completa de alto rendimiento, conocida como CVM o Compact
Virtual Machine.
CDC contiene tres perfiles principales: foundation profile, personal basis
profile y personal profile.
Connected, Limited Device Configuration — CLDC
Es la configuración diseñada para ser implementada en dispositivos pequeños, como localizadores, teléfonos celulares, algunos tipos de teléfonos inteligentes, o PDAs sencillas. Define un estándar, utilizado por los
fabricantes para construir e implementar un entorno de tiempo de ejecución Java. Los desarrolladores que siguen el estándar, acceden a una
plataforma confiable donde ejecutar sus aplicaciones.
La implementación de referencia de CLDC se basa en una JVM pequeña y
restringida, conocida como KVM o kilobyte Virtual Machine.
CLDC se encarga de regular algunos aspectos del desarrollo Java, como:
• Características de los dispositivos: CLDC define las características mí-
11
nimas que un dispositivo debe poseer, como al menos 192 KB de memoria RAM para la plataforma Java, 160 KB de memoria RAM para la
máquina virtual y las librerías de CLDC, un procesador de 16 o 32 bits
corriendo al menos a 16 MHZ, alguna forma de conectividad intermitente, inalámbrica y con bajo ancho de banda, y alguna fuente de energía, usualmente baterías.
• Modelo de seguridad. Se enfoca en dos aspectos fundamentales:
1. Seguridad de la máquina virtual: protege al dispositivo de posibles daños generados por el código del usuario. Evita la ejecución
de instrucciones invalidas o la creación de escenarios en los cuales la memoria externa al entorno java se corrompa. incluye la
verificación del bytecode de las aplicaciones.
2. Seguridad de la aplicación: protege el uso de los recursos del dispositivo. La plataforma java me incorpora un modelo de seguridad
simplificado basado en un sandbox, donde se ejecuta el código de
las aplicaciones java me.
Fig. 1 Modelo de Seguridad de Aplicaciones Java
ME
12
3. Administración de las aplicaciones. El dispositivo debe incorporar cualquier funcionalidad que permita al usuario revisar, ejecutar o eliminar
las aplicaciones instaladas. CLDC no especifica la forma que debe tener el administrador de aplicaciones.
4. Diferencias del lenguaje. Como Java me es un subconjunto de Java se,
algunas de sus funcionalidades son limitadas o inexistentes. Por ejemplo, no se dispone de aritmética de punto flotante (en CLDC 1.0), la
finalización de los objetos es automática, no se incluyen algunas clases
de manejo de errores de java.lang.error, y demás librerías propias de
Java.
5. Bibliotecas de clases incluidas: Se incluye un subconjunto de las clases
existentes en Java SE, que se clasifican bajo el paquete java.* y clases
propias de Java ME, contenidas en el paquete javax.*. No se incluyen
clases relacionadas con el manejo de interfaz gráfica, como aquellas
de los paquetes javax.awt.* y javax.swing.* ni las relacionadas con la
conectividad, pertenecientes al paquete java.net.*.
Mobile Information Device Profile – MIDP
MIDP es el perfil más común y popular debido a que se convirtió en el
estándar de facto para muchos juegos y aplicaciones.
Específicamente, MIDP extiende las funcionalidades ofrecidas por CLDC y
proporciona funcionalidades específicas para los dispositivos conocidos
como MID (Mobile Information Device).
Desde el punto de vista del entorno de hardware, MIDP, en su versión 2.0,
13
establece las siguientes características.
Pantalla con resolución mínima de 96x54 pixeles, con 1 bit de color y una
relación de aspecto del pixel de casi 1 a 1.
Medios de entrada como un teclado numérico (keypad de teléfono), un
teclado alfanumérico (tipo QWERTY), o pantalla táctil.
Memoria: por lo menos 256 kb de memoria ROM para los componentes
de MIDP, 8 kb de memoria no volátil para los datos persistentes generados por las aplicaciones, 128 kb de memoria RAM para usarse en tiempo
de ejecución.
Red: Conectividad inalámbrica de doble vía, usualmente intermitente, con
un ancho de banda limitado.
El sistema operativo de los MID varia significativamente en funcionalidad
y poder. Por lo tanto, MIDP establece algunas capacidades mínimas que
los sistemas operativos deben cumplir:
Memoria: acceso a alguna forma de memoria no volátil.
Red: suficientes operaciones para el trabajo en red de los componentes
de la API de MIDP.
Gráficos: Capacidad de mostrar alguna forma de gráficos de mapa de bits.
• Medios de entrada y salida: Mecanismos para capturar la entrada de los
usuarios y proveer retroalimentación.
Kernel: Un kernel de sistema operativo funcional básico, capaz de manejar interrupciones, excepciones y con alguna forma de calendarizar procesos.
14
La implementación de MIDP provee algunas bibliotecas de clases que
permiten a los desarrolladores acceder a:
La interfaz de usuario del dispositivo,
El subsistema de sonido del equipo,
Medios de almacenamiento persistentes o record store,
Funciones de red, que implementan el framework de conectividad definido en CLDC, Contadores y temporizadores, Funcionalidades de gestión
de las aplicaciones.
Fig 2. Arquitectura de un sistema basado en MIDP
El desarrollo de aplicaciones móviles para la plataforma java micro edition se ve afectado por las siguientes limitaciones generales de los dispositivos.
• Tamaño de la pantalla. El área disponible de la pantalla usualmente es
reducida, comparado con el tamaño de las pantallas de la computadora.
• Conectividad de red. Los dispositivos usualmente incluyen servicios de
conectividad intermitente y limitada, en capacidad de transferencia de
datos y en ancho de banda.
• Restricciones de memoria. La mayoría de los dispositivos incluyen relativamente poca memoria disponible para uso exclusivo del usuario,
sin tomar en cuenta las tarjetas de expansión extraíbles. Usualmente
15
la memoria del dispositivo es compartida para todas las funciones del
teléfono y no puede utilizarse completamente para instalar aplicaciones.
Al considerar la plataforma de programación disponible para los dispositivos, se tiene que hacer las siguientes precisiones:
• La plataforma Java ME encuentra basada en la versión 1.3 del lenguaje
java, que tiene muchas restricciones en comparación con las versiones
actuales de java.
• Debido al modelo de seguridad implementado, Java ME no puede acceder a ciertas funciones nativas de los teléfonos.
• Las aplicaciones no pueden acceder sin autorización del usuario a funciones específicas, como conectividad, datos del usuario, sistema de
archivos, a menos que se encuentren firmadas digitalmente.
• Cada fabricante especifica la manera de implementar la funcionalidad
de interfaz de usuario de alto nivel que pueden utilizar las aplicaciones.
• En algunos casos, los fabricantes no implementan o incluyen los paquetes opcionales que podrían ser requeridos para desarrollar exitosamente una aplicación móvil.
Modelos de interfaz gráfica
Las interfaces de programación que permiten a las aplicaciones acceder a
la interfaz gráfica de los dispositivos que implementan la plataforma Java
Micro Edition no forman parte de la configuración CLDC, sino que son
proporcionadas por el perfil MIDP.
16
Las clases para el manejo de la interfaz gráfica que MIDP proporciona no
se basan en las tecnologías existentes para Java SE, como AWT (Abstract
Window Toolkit) o SWING, debido a algunas restricciones funcionales propias de los dispositivos móviles, como el tamaño reducido de la pantalla,
la resolución o la profundidad de colores, o los tipos de medios de entrada disponibles.
MIDP proporciona a los desarrolladores interfaces de programación de
alto y bajo nivel, en el paquete javax.microedition.lcdui, que permiten
administrar la interfaz gráfica de las aplicaciones basadas en este perfil.
El API de alto nivel, que se encuentra implementado en las diferentes
subclases de javax.microedition.lcduí.screen, se centra en permitir y facilitar el desarrollo de aplicaciones portables entre las diferentes marcas y
modelos de dispositivos. Para lograr la portabilidad, se emplea un alto nivel de abstracción y, en consecuencia, el desarrollador obtiene muy poco
control de la apariencia visual de la aplicación.
El sistema operativo del dispositivo se encarga de adaptar la interfaz de
usuario de la aplicación al hardware específico del dispositivo y a su estilo
y diseño gráfico nativo. Como resultado, la interfaz de usuario generada
para la aplicación será completamente diferente, en dispositivos de diferentes marcas y modelos.
En contraste, el API de bajo nivel provee muy poca abstracción. Este API
se diseñó para las aplicaciones que requieren acceder a los eventos de
entrada de bajo nivel o que necesitan ubicar elementos con mayor preci-
17
sión, permitiendo a los desarrolladores controlar completamente lo que
se va a dibujar en la pantalla del dispositivo.
Este API se encuentra implementado en las clases Canvas y Graphics presentes dentro del paquete javax.microedition.lcduí. Cuando se utilizan
estas clases no se garantiza la portabilidad de la aplicación, ya que el API
provee algunos mecanismos para acceder a funcionalidades específicas
de los dispositivos.
Metodología Open Up
Open Up es una variante sencilla y extensible del proceso unificado, que
aplica un enfoque iterativo e incremental al ciclo de vida estructurado de
un proyecto de desarrollo. Open Up contempla una filosofía ágil y pragmática que se enfoca en aprovechar la naturaleza colaborativa del desarrollo de software.
El esfuerzo personal se organiza en micro incrementos, que representan
unidades de trabajo cortas, que permiten que el proyecto avance a un
ritmo continuo y medible, típicamente en horas o pocos días. El proceso
promueve la colaboración intensiva de un equipo de trabajo comprometido y organizado a medida que se desarrolla el sistema. Cada micro incremento proporciona un periodo de retroalimentación muy corto que
permite tomar decisiones de adaptación dentro de cada iteración.
Open Up divide al proyecto en iteraciones planeadas con duraciones medidas casi siempre en semanas. Las iteraciones enfocan al equipo de tra-
18
bajo en entregar incrementos con valor, de una manera predecible, de
acuerdo a un plan de iteraciones definido. El resultado final es un producto que puede ser mostrado.
Los equipos de trabajo de Open Up se organizan por su cuenta para cumplir los objetivos de la iteración y se comprometen a entregar los resultados, definiendo y tomando tareas detalladas de una lista de elementos
de trabajo. Open Up aplica un ciclo de vida de la iteración que estructura
la forma de aplicar cada uno de los micros incrementos, y de esta manera, entregar productos estables que permitan que el sistema progrese de
manera incremental para lograr los objetivos de la iteración.
El ciclo de vida de un proyecto Open Up se divide en cuatro fases principales: inicio, elaboración, construcción y transición. Durante todo el
transcurso del proyecto, existen puntos de visibilidad y de decisión para
los interesados y miembros del equipo. De esta manera, se puede hacer
Fig 3. Estructura de OpenUP
19
un seguimiento efectivo y tomar decisiones en tiempos apropiados.
Un plan del proyecto define el ciclo de vida, que tiene como resultado
final una aplicación terminada.
Entorno de desarrollo Android
En este apartado vamos a describir los pasos básicos para disponer en
nuestra PC del entorno y las herramientas necesarias para comenzar a
programar aplicaciones para la plataforma Android.
No vamos a ser exhaustivo, ya que existen muy buenos tutoriales sobre
la instalación de Eclipse y Android, incluida la documentación oficial de
la plataforma. Además, si has llegado hasta aquí queremos suponer que
tienes unos conocimientos básicos de Eclipse y Java, por lo que tan sólo
enumeraremos los pasos necesarios de instalación y configuración, y proporcionaremos los enlaces a las distintas herramientas.
Paso 1. Descarga e instalación de Eclipse.
Si aún no tienes instalado Eclipse, puedes descargar la última versión (3.7
en el momento de escribir estas líneas) desde este enlace. Recomiendo
descargar por ejemplo la versión “Eclipse IDE for Java Developers”. La
instalación consiste simplemente en descomprimir el ZIP en la ubicación
deseada.
Paso 2. Descargar el SDK de Android.
20
El SDK de la plataforma Android se puede descargar desde este enlace
(la última versión disponible en el momento de escribir este tema es la
r15). Una vez descargado, de nuevo bastará con descomprimir el zip en
cualquier ubicación.
Paso 3. Descargar el plugin Android para Eclipse.
Google pone a disposición de los desarrolladores un plugin para Eclipse
llamado Android Development Tools (ADT) que facilita en gran medida
el desarrollo de aplicaciones para la plataforma. Puedes descargarlo mediante las opciones de actualización de Eclipse, accediendo
al menú “Help / Install new software…” e indicando la URL de descarga:
https://dl-ssl.google.com/android/eclipse/
Se debe seleccionar e instalar el paquete completo Developer Tools, formado por Android
DDMS y Android Development Tools.
Paso 4. Configurar el plugin ADT.
Fig 4. Selección de Pligin ADT
21
En la ventana de configuración de Eclipse, se debe acceder a la sección de
Android e indicar la ruta en la que se ha instalado el SDK (paso 2).
Paso 5. Descargar los targets necesarios.
Además del SDK de Android comentado en el paso 2, también debemos descargar los llamados SDK Targets de Android, que no son más
que las librerías necesarias para desarrollar en cada una de las versiones
concretas de Android. Así, si queremos desarrollar por ejemplo para An-
Fig 5 Descarga de elementos necesarios
droid 1.6 tendremos que descargar su target correspondiente. Para ello,
desde Eclipse debemos acceder al menú “Window / Android SDK and
AVD Manager“, y en la sección Available Packages seleccionar e instalar
todos los paquetes deseados.
Paso 6. Configurar un AVD.
A la hora de probar y depurar aplicaciones Android no tendremos que
hacerlo necesariamente sobre un dispositivo físico, sino que podremos
configurar un emulador o dispositivo virtual (Android Virtual Device, o
AVD) donde poder realizar fácilmente estas tareas. Para ello, volveremos
22
a acceder al AVD Manager, y en la sección Virtual Devices podremos añadir tantos AVD como se necesiten (por ejemplo, configurados para distintas versiones de Android). Para configurar el AVD tan sólo tendremos
Fig. 6 Configuración del dispositivo
que indicar un nombre descriptivo, el target de Android que utilizará, y
las características de hardware del dispositivo virtual, como por ejemplo
su resolución de pantalla, el tamaño de la tarjeta SD, o la disponibilidad
de GPS.
Paso 7. ¡Hola Mundo! en Android.
Creamos un nuevo proyecto de tipo Android Project. Indicamos su nom-
Fig 7 Creación del proyecto
23
bre, el target deseado, el nombre de la aplicación, el paquete java por
defecto para nuestras clases y el nombre de la clase (activity) principal.
Esta acción creará toda la estructura de carpetas necesaria para compilar
un proyecto para Android. Hablaremos de ella más adelante.
Para ejecutar el proyecto tal cual podremos hacerlo como cualquier otro
proyecto java configurando una nueva entrada de tipo Android Applications en la ventana de Run Configurations. Al ejecutar el proyecto, se
abrirá un nuevo emulador Android y se cargará automáticamente nuestra
aplicación.
Estructura de un proyecto Android
Para empezar a comprender cómo se construye una aplicación Android
vamos a echar un vistazo a la estructura general de un proyecto tipo.
Cuando creamos un nuevo proyecto Android en Eclipse se genera automáticamente la estructura de carpetas necesaria para poder generar posteriormente la aplicación. Esta estructura será común a cualquier aplicación, independientemente de su tamaño y complejidad.
En la siguiente imagen vemos los elementos creados inicialmente para un
Fig 8. Exploración de rutas
24
Capítulo 3 Desarrollo de una aplicación sencilla
25
nuevo proyecto Android:
3.1 Concepción
Desarrollo de una aplicación la cual mostrara el nombre de un usuario
cualquiera en el dispositivo móvil en este caso se usará un emulador instalado previamente.
3.2 Elaboración
La aplicación constará de dos pantallas, por un lado la pantalla principal
que solicitará un nombre al usuario y una segunda pantalla en la que se
mostrará un mensaje personalizado para el usuario.
En primer lugar vamos a crear un nuevo proyecto Android lo. Llamaremos
al proyecto “HolaUsuario”, indicaremos como target por ejemplo “Android
1.6″, daremos un nombre a la aplicación e indicaremos que se cree una
actividad llamada HolaUsuario.
Esto nos crea la estructura de carpetas del proyecto y todos los ficheros
necesarios de un Hola Mundo básico, es decir, una sola pantalla donde se
muestra únicamente un mensaje fijo.
Lo primero que vamos a hacer es diseñar nuestra pantalla principal modificando la que Eclipse nos ha creado por defecto. En Android, el diseño
y la lógica de una pantalla están separados en dos ficheros distintos. Por
un lado, en el fichero /res/layout/main.xml tendremos el diseño puramente visual de la pantalla definido como fichero XML y por otro lado, en
el fichero /src/paquetejava/HolaUsuario.java, encontraremos el código
26
java que determina la lógica de la pantalla.
Vamos a modificar en primer lugar el aspecto de la ventana principal de
la aplicación añadiendo los controles (views) que vemos en la primera
captura de pantalla. Para ello, vamos a sustituir el contenido del fichero
main.xml por el siguiente:
<?xml version=”1.0” encoding=”utf-8”?>
<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical” android:layout_width=”fill_parent”
android:layout_height=”fill_parent” >
<TextView android:text=”@string/nombre” android:layout_width=”fill_parent” android:layout_height=”wrap_content” />
<EditText android:id=”@+id/TxtNombre” android:layout_height=”wrap_
content” android:layout_width=”fill_parent” />
<Button android:id=”@+id/BtnHola” android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:text=”@string/hola”
/>
</LinearLayout>
En este XML se definen los elementos visuales que componen la interfaz
de nuestra pantalla principal y se especifican todas sus propiedades. No
nos detendremos mucho por ahora en cada detalle, pero expliquemos un
poco lo que vemos en el fichero.
Lo primero que nos encontramos es un elemento LinearLayout. Los layout
son elementos no visibles que determinan cómo se van a distribuir en el
27
espacio los controles que incluyamos en su interior. Los programadores
java, y más concretamente de Swing, conocerán este concepto perfectamente. En este caso, un LinearLayout distribuirá los controles uno tras
otro y en la orientación que indique su propiedad android:orientation.
Dentro del layout hemos incluido 3 controles: una etiqueta (TextView),
un cuadro de texto (EditText), y un botón (Button). En todos ellos hemos
establecido las siguientes propiedades:
• android:id. ID del control, con el que podremos identificarlo más tarde
en nuestro código. Vemos que el identificador lo escribimos precedido
de “@+id/”. Esto tendrá como efecto que al compilarse el proyecto se
genere automáticamente una nueva constante en la clase R para dicho
control.
• android:text. Texto del control. En Android, el texto de un control se
puede especificar directamente, o bien utilizar alguna de las cadenas
de texto definidas en los recursos del proyecto (fichero strings.xml),
en cuyo caso indicaremos su identificador precedido del prefijo “@
string/”.
• android:layout_height y android:layout_width. Dimensiones del control con respecto al layout que lo contiene. Esta propiedad tomará
normalmente los valores “wrap_content” para indicar que las dimensiones del control se ajustarán al contenido del mismo, o bien
“fill_parent” para indicar que el ancho o el alto del control se ajustará
al ancho o alto del layout contenedor respectivamente.
Con esto ya tenemos definida la presentación visual de nuestra ventana
28
principal de la aplicación. De igual forma definiremos la interfaz de la
segunda pantalla, creando un nuevo fichero llamado frmmensaje.xml, y
añadiendo esta vez tan solo una etiqueta (TextView) para mostrar el mensaje personalizado al usuario. Veamos cómo quedaría nuestro siguiente
código
<?xml version=”1.0” encoding=”utf-8”?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/
res/android” android:layout_width=”wrap_content” android:layout_
height=”wrap_content”>
<TextView android:id=”@+id/TxtMensaje” android:layout_height=”wrap_
content” android:layout_width=”fill_parent” android:text=”$mensaje”></
TextView>
</LinearLayout>
Una vez definida la interfaz de las pantallas de la aplicación deberemos
implementar la lógica de la misma. Como ya hemos comentado, la lógica
de la aplicación se definirá en archivos de java independientes.
Ahora podemos utilizar el archivo llamado HolaUsuario.java. Empecemos
por comentar su código por defecto:
public class HolaUsuario extends Activity {
/** Called when the activity is first created. */
@Override
29
public void onCreate(Bundle savedInstanceState) { super.
onCreate(savedInstanceState); setContentView(R.layout.main);
}
}
Una aplicación Android se definen mediante objetos de tipo Activity. Por
tanto, lo primero que encontramos en nuestro archivo java es la definición de una nueva clase HolaUsuario que extiende a Activity.
El único método que sobrescribiremos de esta clase será el método OnCreate, llamado cuando se crea por primera vez la actividad. En
este método lo único que encontramos en principio, además de la llamada a su implementación en la clase padre, es la llamada al método
setContentView(R.layout.main). Con esta llamada estaremos indicando a
Android que debe establecer como interfaz gráfica de esta actividad la
definida en el recurso R.layout.main, que no es más que la que hemos
especificado en el archivo /res/layout/main.xml.
En principio vamos a crear una nueva actividad para la segunda pantalla
de la aplicación análoga a ésta primera, para lo que crearemos una nueva
clase FrmMensaje que extienda de Activity y que implemente el método
onCreate indicando que utilice la interfaz definida en R.layout.frmmensaje.
public class FrmMensaje extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) { super.
onCreate(savedInstanceState); setContentView(R.layout.frmmensaje);
30
}
}
El código incluido por defecto en estas clases lo único que hace es generar la interfaz de la actividad. A partir de aquí nosotros tendremos que
incluir el resto de la lógica de la aplicación. Y vamos a empezar con la actividad principal HolaUsuario, obteniendo una referencia a los diferentes
controles de la interfaz que necesitemos manipular, en nuestro caso sólo
el cuadro de texto y el botón. Para ello utilizaremos el método findViewById() indicando el ID de cada control, definidos como siempre en la clase
R:
final EditText txtNombre = (EditText)findViewById(R.id.TxtNombre);
final Button btnHola = (Button)findViewById(R.id.BtnHola);
Una vez tenemos acceso a los diferentes controles, ya sólo nos queda implementar las acciones a tomar cuando pulsemos el botón de la pantalla.
Para ello implementaremos el evento onClick de dicho botón, como sigue:
btnHola.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
Intent intent = new Intent(HolaUsuario.this, FrmMensaje.class);
Bundle bundle = new Bundle();
bundle.putString(“NOMBRE”, txtNombre.getText().toString());
intent.putExtras(bundle);
startActivity(intent);
}
});
31
La comunicación entre los distintos componentes y aplicaciones en Android se realiza mediante intents, por lo que el primer paso será crear un
objeto de este tipo. Existen varias variantes del constructor de la clase
Intent, cada una de ellas dirigida a unas determinadas acciones, pero en
nuestro caso particular vamos a utilizar el intent para llamar a una actividad desde otra de la misma aplicación, para lo que pasaremos al constructor una referencia a la propia actividad llamadora (HolaUsuario.this),
y la clase de la actividad llamada (FrmMensaje.class).
Si quisiéramos tan sólo mostrar una nueva actividad ya tan sólo nos quedaría llamar a startActivity() pasándole como parámetro el intent creado.
Pero en nuestro ejemplo queremos también pasarle cierta información
a la actividad, concretamente el nombre que introduzca el usuario en el
cuadro de texto. Para hacer esto vamos a crear un objeto Bundle, que
puede contener una lista de pares clave-valor con toda la información a
pasar entre las actividades. En nuestro caso sólo añadiremos un dato de
tipo String mediante el método putString(clave, valor). Tras esto añadiremos la información al intent mediante el método putExtras(bundle).
Finalizada la actividad principal de la aplicación pasamos ya a la secundaria. Comenzaremos de forma análoga a la anterior, ampliando el método
onCreate obteniendo las referencias a los objetos que manipularemos,
esta vez sólo la etiqueta de texto. Tras esto viene lo más interesante,
debemos recuperar la información pasada desde la actividad principal
y asignarla como texto de la etiqueta. Para ello accederemos en primer
lugar al intent que ha originado la actividad actual mediante el método
32
getIntent() y recuperaremos su información asociada (objeto Bundle)
mediante el método getExtras().
Hecho esto tan sólo nos queda construir el texto de la etiqueta mediante su método setText(texto) y recuperando el valor de nuestra clave
almacenada en el objeto Bundle mediante getString(clave).
public class FrmMensaje extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) { super.
onCreate(savedInstanceState); setContentView(R.layout.frmmensaje);
TextView txtMensaje = (TextView)findViewById(R.id.TxtMensaje);
Bundle bundle = getIntent().getExtras();
txtMensaje.setText(“Hola “ + bundle.getString(“NOMBRE”));
}
}
3.3 Construcción
Toda aplicación Android utiliza un archivo especial en formato XML (AndroidManifest.xml) para definir, entre otras cosas, los diferentes elementos que la componen. Por tanto, todas las actividades de nuestra
aplicación deben quedar convenientemente recogidas en este archivo.
La actividad principal ya debe aparecer puesto que se creó de forma automática al crear el nuevo proyecto Android, por lo que debemos añadir
tan sólo la segunda. Para este ejemplo nos limitaremos a incluir la actividad en el XML.
33
<?xml version=”1.0” encoding=”utf-8”?>
<manifest xmlns:android=”http://schemas.android.com/apk/
res/android” package=”net.sgoliver” android:versionCode=”1”
android:versionName=”1.0”>
<application android:icon=”@drawable/icon” android:label=”@string/
app_name”>
<activity android:name=”.HolaUsuario”
android:label=”@string/app_name”>
<intent-filter>
<action android:name=”android.intent.action.MAIN” />
<category android:name=”android.intent.category.LAUNCHER” />
</intent-filter>
</activity>
<activity android:name=”.FrmMensaje”></activity>
</application>
<uses-sdk android:minSdkVersion=”4” />
</manifest>
3.4 Transición
Ahora podemos ejecutar el proyecto sin errores y probar nuestra aplicación en el emulador.
34
Bibliografía
Haseman, C. (2008). Android Essentials. New York, USA: Apress.
Coad, P. and E. Yourdon, Object-Oriented Analysis, Second Edition, Yourdon
Press, Prentice Hall, Englewood Cliffs, 1991.
Kendall, J. & Kendall, K. (1997). Análisis y diseño de sistemas. (3ra. ed.). México: Prentice Hall Inc.
Gargenta, M. (2011). Learning Android. CA, USA: O’Reilly.
35
36