Nuestro primer MIDlet
En
este capítulo vamos a construir y ejecutar nuestro primer MIDlet.
Existen diferentes herramientas válidas para construir programas bajo
el standard J2ME, como el propio “Sun One Studio” de Sun Microsystems o
“Jbuilder” de Borland. Nosotros vamos a valernos del “J2ME Wireless
Toolkit 2.0” que proporciona Sun. Este entorno es el más sencillo de
utilizar, y aunque no nos ofrece una gran potencia a la hora de
desarrollar aplicaciones, no nos distraerá con grandes complejidades
del principal objetivo que es aprender a hacer aplicaciones (juegos) en
J2ME.
Para
instalar J2ME Wireless Toolkit, primero hemos de instalar el entorno de
programación de J2SE (JDK). Puedes descargar la última versión de JDK
desde la URL http://java.sun.com/j2se/downloads.html. Una vez descargado e instalado, estaremos en condiciones de descargar e instalar J2ME desde la URL http://java.sun.com/j2me/download.html. El entorno de desarrollo que nos provee el Wireless Toolkit se llama KToolBar.
Compilando el primer MIDlet
Vamos
a construir paso a paso nuestro primer MIDlet usando esta herramienta.
Tras la instalación del wireless toolkit, tendremos un nuevo submenú en
el menú inicio con un aspecto similar a éste:
Selecciona la aplicación KToolBar e inicializa el entorno. Verás aparecer la ventana del entorno.
Vamos a crear un nuevo proyecto, así que pulsamos el botón New Project. Nos solicitará un nombre para el proyecto y otro para la clase principal de la aplicación.
Tanto el proyecto como la clase principal se llamarán HelloWorld, así que introducimos este nombre en ambos cuadros de texto y pulsamos el botón Create Project. En este momento KToolBar crea la estructura de directorios necesaria para albergar el proyecto.
Cada
una de las carpetas creadas tiene una misión concreta. Por ahora nos
bastará saber que nuestros archivos fuente irán emplazados en el
directorio src, y los recursos necesarios como gráficos, sonidos, etc... se alojarán en el directorio res.
A diferencia de otros entornos de programación, KToolBar
no cuenta con un editor integrado para editar los programas, por lo
tanto vamos a utilizar uno externo. Puedes utilizar el bloc de notas de
Windows o tu editor favorito. Personalmente utilizo Crimson Editor (http://www.crimsoneditor.com/), que tiene soporte para Java.
Utilizando tu editor favorito introduce el programa siguiente:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class HelloWorld extends MIDlet implements CommandListener {
private Command exitCommand;
private Display display;
private Form screen;
public HelloWorld() {
// Obtenemos el objeto Display del midlet.
display = Display.getDisplay(this);
// Creamos el comando Salir.
exitCommand = new Command("Salir", Command.EXIT,2);
// Creamos la pantalla principal (un formulario)
screen = new Form("HelloWorld");
// Creamos y añadimos la cadena de texto a la pantalla
StringItem saludo = new StringItem("","Hola Mundo...");
screen.append(saludo);
// Añadimos el comando Salir e indicamos que clase lo manejará
screen.addCommand(exitCommand);
screen.setCommandListener(this);
}
public void startApp() throws MIDletStateChangeException {
// Seleccionamos la pantalla a mostrar
display.setCurrent(screen);
}
public void pauseApp() {
}
public void destroyApp(boolean incondicional) {
}
public void commandAction(Command c, Displayable s) {
// Salir
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}
No es necesario que trates
de comprender el programa ahora. Entraremos en más detalles un poco
más adelante. Por ahora simplemente lo vamos a almacenar en el
directorio src que ha creado KToolBar con el nombre HelloWorld.java.
Es importante que el nombre sea exactamente éste incluidas mayúsculas y
minúsculas. Esto es así, ya que el nombre de la clase principal tiene
que ser idéntico al nombre del archivo que lo contiene. Una vez hecho
esto, volvemos al entorno KTooBar y pulsamos el botón Build. Si todo va bien, aparecerá el texto Build Complete.
Ya tenemos nuestro programa compilado y podemos ejecutarlo en el
emulador. En el desplegable Device puedes seleccionar el emulador que
quieres utilizar. El DefaultColorPhone tiene soporte de color, así que
te resultará más atractivo. Pulsa el botón Run. Verás aparecer
un emulador con forma de teléfono móvil. En la pantalla del móvil
aparece un menú con un sólo programa llamado HelloWorld. Pulsa select para ejecutarlo.
Deberías ver como aparece la frase Hola Mundo... en la pantalla.
Ahora
que hemos comprobado que el programa funciona en el emulador, estamos
listos para empaquetar el programa y dejarlo listo para descargar a un
dispositivo real. En KToolBar despliega el menú project, y selecciona create package del submenú package. KToolBar nos informa de que ha creado los archivos HelloWorld.jar y HelloWorld.jad dentro del directorio bin. Estos son los archivos que habremos de transferir al teléfono móvil.
Desarrollo de MIDlets
Lo
que acabamos de hacer es crear un MIDlet desde cero, aunque sin saber
muy bien que es lo que estábamos haciendo. Vamos a profundizar en los
pasos que hemos seguido hasta conseguir nuestro MIDlet. El ciclo de
desarrollo de un MIDlet es el siguiente:
- Editar
- Compilar
- Preverificar MIDlet
- Ejecución en el emulador
- Ejecución en el dispositivo
Como
hemos visto en la primera parte del capítulo, utilizamos un editor de
textos común para editar el programa. La compilación la llevamos a cabo
con el comando Build de la herramienta KTooBar. Cuando compilamos un
programa Java, y por lo tanto un MIDlet, se genera un archivo con la
extensión .class por cada clase, que contiene el código
intermedio que es capaz de ejecutar la máquina virtual de Java. Estos
archivos son almacenados en el directorio classes. El paso que
sigue a la compilación es preverificar las clases que se han generado.
Sin esta preverificación no será posible la ejecución del MIDlet.
Pero, ¿para qué sirve este paso? La preverificación nos asegura que no
existe ningún tipo de código malintencionado que pueda dañar o crear un
comportamiento extraño en nuestro dispositivo o en la máquina virtual.
Lo habitual es que la máquina Java sea lo suficientemente robusta como
para que no haya ningún problema en este sentido, pero debido a que los
dispositivos J2ME no tienen demasiada capacidad de proceso, es
necesario que la máquina virtual sobre la que se ejecutan los MIDlets
(llamada K Virtual Machine o KVM) sea lo más eficiente posible, por lo
que se han eliminado muchas de las comprobaciones que realizan las
máquinas virtuales habitualmente.
Ahora
que hemos compilado y preverificado nuestro MIDlet, ya podemos
ejecutarlo en el emulador. Esto lo hacemos con el comando Run de la
herramienta KTooBar. Si ahora queremos ejecutarlo en el dispositivo
real, hemos de realizar un paso más. Los MIDlets tienen que ser
distribuidos en dos archivos especiales. Son los archivos JAR y los
archivos JAD. Un archivo JAR es un archivo comprimido (en formato ZIP)
que contiene las clases (.class) que ha generado la compilación de
nuestro programa. Además puede contener los recursos necesarios para el
MIDlet como sonidos, gráficos, etc... Finalmente, contiene un archivo
con extensión .mf., es lo que se llama un archivo de manifiesto. Este
archivo contiene información sobre las clases contenidas en el archivo
JAR.
El
segundo archivo necesario para la distribución de MIDlets son los
archivos JAD. El archivo JAD contiene información necesaria para la
instalación de los MIDlets contenidos en el archivo JAR. Un archivo
puede contener más de un MIDlet. Cuando ocurre esto, hablamos de un
MIDlet suite. Podemos editar los parámetros contenidos en el archivo
JAD mediante el botón Settings de KTooBar. Aquí podemos editar
información del MIDlet como el nombre, la versión o el autor del MIDlet
(o de los MIDlets).
Sólo
nos resta transferir los archivos JAR y JAD al dispositivo J2ME. Hay
varias formas de hacerlo dependiendo de la marca y modelo del
dispositivo. Si el teléfono tiene soporte de infrarrojos o bluetooth, y
tu ordenador tiene puerto IrDA o bluetooth, podrás transferirlo
fácilmente sin necesidad de cable alguno. Si no, tendrás que recurrir a
un cable de datos (consulta el manual de tu teléfono). Otra
posibilidad es poner los archivos JAR y JAD en un servidor wap o un
espacio web y descargarlo desde tu móvil. Para ello es necesario que el
dispositivo tenga un navegador wap o web y soporte GPRS para una
descarga fiable.
Anatomía de un MIDlet
Si
estas familiarizado con la programación de applets, conoces las
diferencias que tiene con respecto a una aplicación Java normal. La
primera es que un applet se ejecuta sobre un navegador web. Otra
importante es que, a diferencia de un programa Java estándar, un applet
no tiene un método main(), además, un applet tiene que ser una subclase de la clase Applet, e implementar unos métodos concretos (init, start, stop, destroy).
En este sentido, un MIDlet es más parecido a un applet que a una
aplicación Java estándar. Un MIDlet tiene que ejecutarse en un entorno
muy concreto (un dispositivo con soporte J2ME), y tampoco cuenta con un
método main(). Un MIDlet tiene que heredar de la clase MIDlet e implementar una serie de métodos de dicha clase.
Concretamente, la clase de la que ha de heredar cualquier MIDlet es javax.microedition.midlet.MIDlet Hay tres métodos heredados que son particularmente importantes:
- startApp()
- pauseApp()
- destroyApp()
Un
MIDlet puede estar en tres estados diferentes: en ejecución, en pausa o
finalizado. Dependiendo del estado en el que esté, la máquina virtual
llamará al método correspondiente, es decir, startApp() cuando entre en ejecución, pauseApp() cuando el MIDlet entre en pausa y destroyApp()
a la finalización del MIDlet. Fíjate en nuestro ejemplo cómo hemos
implementado los tres métodos. Incluso si no vamos a hacer uso de
ellos, es obligatorio declararlos.
En nuestro programa de ejemplo, no sólo importamos la clase MIDlet, también hemos importado las clases de javax.microedition.lcdui.*.
Estas clases dan soporte para la interfaz de usuario. Nos va a
permitir controlar la pantalla del dispositivo y también la
entrada/salida desde el teclado. En el siguiente capítulo nos
introduciremos en más profundidad en la interfaz de usuario
No hay comentarios.:
Publicar un comentario