Un MIDlet

(Imagen: Edgar Degas - La clase de danza)

Hola, queridos lectores. Primero, es necesario disculpar la ausencia de post de los últimos meses, sólamente explicable por el hecho de que no he estado estudiando nada (aunque les dije que me iba tomar un descanso); y segundo, que ya tengo en mente la siguiente certificación que pienso agregar a mi palmarés: Sun Certified Mobile Application Developer (SCMAD).

Pienso tomarmelo con calma, dado que aún no he adquirido el voucher, así que los posts serán menos frecuentes (pero espero que más sustanciosos). Para esta tarea, me he planteado leer Wireless Java Developing with J2ME de Jonathan Knudsen y una vez asimilado todo probar mis destrezas con los simuladores de uCertify para SCMAD. Al menos, ese es el plan.

Entonces,ya basta de palabrería y vayamos a lo nuestro. Un MIDLet es una aplicación MIDP, y MIDP (Mobile Information Device Profile) es una especificación para el uso de Java en dispositivos móviles, como celulares y PDA. Esto implica que desarrollamos en nuestro lenguaje favorito (ya saben la respuesta) y podemos hacer uso de API's que ya conocemos como java.lang y java.io; aunque con algunas diferencias que ya veremos luego.

Ahora, el proceso de desarrollo de MIDLets es un poquito más complicado que el de una aplicación J2SE, e incluye pasos de preverificación y empaquetamiento antes de poder ejecutar la aplicación. Para evitarnos estas molestias, es mejor utilizar un IDE que nos simplifique la vida. Yo estoy utilizando el Java Platform Micro Edition SDK 3.0 , si tienen otra IDE favorita, siéntanse libres de usarla. Entonces, sin más preámbulos, les presento a un MIDlet tomado del libro de Knudsen:

package test;

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.TextBox;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.*;

/**
* @author cgavidia
*/
public class TwoAlerts extends MIDlet implements CommandListener {

private Display mDisplay;
private TextBox mTextBox;
private Alert mTimedAlert;
private Alert mModalAlert;
private Command mAboutCommand, mGoCommand, mExitCommand;

public TwoAlerts() {
  mAboutCommand = new Command("About", Command.SCREEN, 1);
  mGoCommand = new Command ("Go", Command.SCREEN, 1);
  mExitCommand = new Command("Exit", Command.EXIT, 2);
  mTextBox = new TextBox ("TwoAlerts", "", 32, TextField.ANY);
  mTextBox.addCommand(mAboutCommand);
  mTextBox.addCommand(mGoCommand);
  mTextBox.addCommand(mExitCommand);
  mTextBox.setCommandListener(this);

  mTimedAlert = new Alert("Network Error", "A network error ocurred. Please try again.", null, AlertType.INFO);
  mModalAlert = new Alert("About TwoAlerts", "TwoAlerts is a simple MIDlet that demostrates the use of alerts.",null, AlertType.INFO );
  mModalAlert.setTimeout(Alert.FOREVER);

}


public void startApp() {
  mDisplay = Display.getDisplay(this);
  mDisplay.setCurrent(mTextBox);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

public void commandAction(Command c, Displayable d) {
 if (c == this.mAboutCommand){
     mDisplay.setCurrent(mModalAlert);
 }else if (c == this.mGoCommand){
     mDisplay.setCurrent(mTimedAlert, mTextBox);
 }else if (c == this.mExitCommand){
     this.notifyDestroyed();
 }
}
}

Las aplicaciones MIDP están representadas por instancias de la clase javax.microedition. midlet.MIDlet, y es por esto que nuestra clase la extiende. Antes de ejecutar la aplicación, es necesario crear la instancia y por ende el constructor es invocado. En nuestro constructor, inicializamos todos los atributos de nuestro MIDlet, pero mejor veamos a cada uno de ellos con paciencia:

• Asignamos valores a los tres atributos Command que tenemos. Un command, es algo con lo que el usuario puede interactuar: es algo así como un botón. El constructor de Command que usamos nos solicita un nombre, un tipo y una prioridad. Los dos primeros son de tipo SCREEN (tipo Genérico) y el último es del tipo EXIT (para finalizar la aplicación).
• Nuestro MIDlet también tiene un atributo TextBox, que le permite al usuario ingresar una cadena de texto. Para poder crear el TextBox, hemos necesitado especificar un título, el texto inicial , la cantidad máxima de caracteres y sus restricciones. Como hemos utilizado TextField.ANY como restricción, el usuario es libre de ingresar cualquier texto.
• Toda instancia de Displayable está asociada a los Commands con los que interactúa. La clase TextBox hereda de Displayable, por lo que vamos a asociar los Commands creados con el TextBox mTextBox haciendo uso de su método addCommand.
• También es necesario saber que hacer cuando un usuario interactúa con un Command. Para esto se define un objeto listener, que es notificado cuando el usuario invoca a cualquier Command de nuestro Displayable (en nuestro caso, nuestra TextBox). Se requiere que el listener implemente la interfaz CommandListener, y eso es lo que está haciendo nuestra clase. Para registrar el listener mTextBox, invocamos a su método setListener.
• Después es necesario asiganarle valores a los dos atributos Alert del MIDlet. Un Alert es un mensaje informativo para el usuario, y MIDP nos permite utilizar dos tipos de Alert's: los que se muestran en pantalla por un período de tiempo para después desaparecer y los que son mostrados hasta que el usuario realice alguna acción (por ejemplo, seleccionar OK). El atributo mTimedAlert es del primer tipo y mModalAlert es del segundo (mediante la sentencia mModalAlert.setTimeout(Alert.FOREVER) le indicamos que se muestre por un tiempo indeterminado.

Después de ejecutado el constructor, el ciclo de vida del MIDlet nos indica que el método startApp es ejecutado. Lo primero que hacemos es obtener una instancia de Display mediante getDisplay. La clase Display es la que nos va a permitir administrar la pantalla del disposivo. Nota importante: El método getDisplay no puede ser invocado en el constructor, y tiene que invocarse al inicio del método startAp.

Una vez que tenemos una referencia a Display, le indicamos que elementos mostrar mediante el método setCurrent, que recibe como parámetros instancias de Displayable. Entonces, hacemos que se muestre en pantalla el TextBox que hemos inicializado, ya que TextBox es una clase que hereda de Displayable.

Hemos implementado el método commandAction debido a nuestra interfaz CommandListener. El método es bastante sencillo, y nos muestra los alerts que hemos creado en función al Command seleccionado mediante el método setCurrent, que ya explicamos. Si es que el usuario selecciona el botón EXIT se invoca a notifyDestroyed, con lo que nuestro MIDlet comete harakiri y es destruido.

Ahora ya tenemos todo listo para ejecutar el MIDlet,lo compilamos, ejecutamos y si están usando el IDE que les recomendé, nuestra aplicación se ejecutaría en el emulador y verían algo como esto:



Y una vez más, esto ya se hizo demasiado largo. Nos vemos la próxima!

Basado en Wireless Java Developing with J2ME de Jonathan Knudsen.