Introducción. ● Importación del API. ● Un midlet básico. ● Acceso a la pantalla. ● Caja de texto. ● Comando aceptar. ● Constructor para el midlet. ● Método startApp(). ● Problema: CommandListener. ● Manejo de eventos del Command. ● Método pauseApp(). ● Método destroyApp(boolean). ● Fin de la implementación.

1. Disección del midlet HolaMundo en J2ME Jorge Iván Meza Martínez < [email_address] > http://www.jorgeivanmeza.com/ http://educacion.misservicios.net/

3. Introducción En el presente capítulo se estudiará paso a paso el midlet mas simple posible: el HolaMundo cuya única funcionalidad será la de presentar un saludo en la pantalla del dispositivo móvil. El lector probablemente no se encuentre familiarizado aún con algunas de las clases del API de J2ME utilizadas en el ejemplo, sin embargo serán introducidas en esta sección y retomadas en capítulos posteriores para su ampliación. La implementación de este midlet servirá también como insumo necesario para el desarrollo de los capítulos siguientes.

4. Importación del API Para que el código a desarrollarse tenga acceso al API, tanto de CLDC como el de MIDP es necesario se realice de manera explícita la importación de estas librerías ( package en Java). import javax.microedition.lcdui.*; import javax.microedition.midlet.*;

5. Un midlet básico Un midlet es una clase Java que hereda de la superclase MIDlet la cual es abstracta y esto le obliga a implementar los métodos requeridos para realizar la gestión para el paso entre estados (ver capítulo Midlets con J2ME ). public class HolaMundoMidlet extends MIDlet { protected void startApp() {} protected void pauseApp() {} protected void destroyApp( boolean tipo) {} }

6. Acceso a la pantalla El acceso a la pantalla del dispositivo móvil se realiza a través de una referencia al objeto Display . Esta referencia es útil a lo largo de la vida del midlet motivo por el cual se almacena esta referencia como un atributo de instancia. private Display pantalla;

7. Caja de texto Para mostrar el texto al usuario de la manera mas simple se utilizará un objeto de tipo TextBox el cual es un formulario que permite desplegar un mensaje al usuario y realizar su correspondiente edición. Se guardará una referencia a este TextBox como un atributo de instancia para futura manipulación. private TextBox saludo;

8. Comando aceptar Los comandos asignan acciones a los botones de opción del dispositivo móvil que el usuario puede elegir para modificar el comportamiento de la aplicación. Para este ejemplo se requiere un comando que le permita al usuario aceptar el despliegue del mensaje de saludo y continuar con el cliclo de vida de la aplicación. Como es necesario tener identificados los comandos para futuras comparaciones durante el manejo de eventos, se debe guardar una referencia a este como atributo de instancia. private Command aceptarCmd;

9. Constructor para el midlet El constructor de la clase deberá entonces crear las instancias del TextBox y del Command mencionados anteriormente. El primero de ellos se crea especificándole un título, un mensaje inicial, una longitud máxima y una restricción de entrada (ninguna para este caso), mientras que el segundo requiere de un texto, un tipo y una prioridad. public HolaMundoMidlet() { saludo = new TextBox( &quot;Saludo&quot; , &quot;Hola Mundo J2ME!&quot; , 256, 0); aceptarCmd = new Command( &quot;Aceptar&quot; , Command.SCREEN, 1); }

10. Resúmen #1 import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public class HolaMundoMidlet extends MIDlet { private Display pantalla; private TextBox saludo; private Command aceptarCmd; public HolaMundoMidlet() { saludo = new TextBox( &quot;Saludo&quot; , &quot;Hola Mundo J2ME!&quot; , 256, 0); aceptarCmd = new Command( &quot;Aceptar&quot; , Command.SCREEN, 1); } protected void startApp() {} protected void pauseApp() {} protected void destroyApp( boolean tipo) {} }

11. Método startApp() Recuérdese que este método es ejecutado cuando se desea que el midlet pase de estado paused a estado active , por lo que podrá ser ejecutado en múltiples ocasiones. En este método se deberá hacer acopio de los recursos necesarios para la ejecución de la aplicación, en especial, los liberados durante la invocación del método pauseApp() . Como primer paso se debe tomar la referencia a la pantalla del dispositivo para posteriormente poder manipularla. pantalla = Display.getDisplay( this );

12. Método startApp() A continuación se relaciona el comando aceptarCmd con el formulario saludo previamente construídos. El comando se agrega al formulario. saludo.addCommand(aceptarCmd); Se define quien va a ser el manejador de eventos ( listener : quien escucha) de comando para el formulario: el midlet mismo para este caso. saludo.setCommandListener((CommandListener) this ); Como actividad final de este método, se presenta el formulario en la pantalla manipulando el objeto pantalla . pantalla.setCurrent(saludo);

13. Resúmen #2 protected void startApp() { pantalla = Display.getDisplay( this ); saludo.addCommand(aceptarCmd); saludo.setCommandListener((CommandListener) this ); pantalla.setCurrent(saludo); }

14. Problema: CommandListener La siguiente línea, introducida en el método startApp() le indica al midlet que él mismo ( this ) va a ser el oídor ( listener ) de eventos de comando del formulario saludo . saludo.setCommandListener((CommandListener) this ); Para que esto pueda ser una realidad, el midlet deberá estar capacitado para manejar este tipo de eventos, para esto deberá entonces implementar la interfaz CommandListener y como consecuencia implementar el método commandAction(Command, Displayable) incluído en ella.

15. Resúmen #3 En términos generales las modificaciones realizadas a la clase HolaMundoMidlet hacen que tome esta apariencia. public class HolaMundoMidlet extends MIDlet implements CommandListener { // ... public void commandAction( Command c, Displayable d) {} }

16. Manejo de eventos del Command Se desea que cuando el usuario presione el comando aceptarCmd que vienen incluído en saludo se termine entonces la aplicación. Como el método commandAction() va a ser llamado siempre que sucedan eventos de comando de manera indistinta del objeto en que se generaron, el primer paso es determinar si efectivamente provienen del comando aceptarCmd . if (c == aceptarCmd ) { // ... }

17. Manejo de eventos del Command Ahora, teniendo la certeza de que el evento se generó por el comando apropiado, procedemos a indicarle al midlet que termine su ejecución. public void commandAction( Command c, Displayable d) { if (c == aceptarCmd ) { destroyApp( true ); notifyDestroyed (); } }

18. Método pauseApp() Acordes con la regla que se sugirió para la implementación de este método, en él se liberan todos los recursos que no son críticos para el midlet durante su estado paused y que además, van a ser reservados nuevamente cuando se ejecute el método startApp() para pasar al estado active de nuevo. protected void pauseApp() { pantalla = null ; }

19. Método destroyApp(boolean) Este método particularmente simple no cuenta con ningún recurso que deba ser liberado o asegurado durante la terminación del midlet , por esto se deja vacía la implementación del método que recuérdese, es de cualquier manera obligatoria. protected void destroyApp( boolean tipo) {}

20. Resúmen #4 (final) import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public class HolaMundoMidlet extends MIDlet implements CommandListener { private Display pantalla ; private TextBox saludo ; private Command aceptarCmd ; public HolaMundoMidlet() { saludo = new TextBox( &quot;Saludo&quot; , &quot;Hola Mundo J2ME!&quot; , 256, 0); aceptarCmd = new Command( &quot;Aceptar&quot; , Command.SCREEN, 1); } protected void startApp() { pantalla = Display.getDisplay( this ); saludo .addCommand(aceptarCmd); saludo .setCommandListener((CommandListener) this ); pantalla .setCurrent( saludo ); } // Continúa ...

21. Resúmen #4 (final) // Continúa ... protected void pauseApp() { pantalla = null ; } protected void destroyApp( boolean tipo) {} public void commandAction(Command c, Displayable d) { if (c == aceptarCmd ) { destroyApp( true ); notifyDestroyed(); } } }

22. Fin de la implementación Con esto se finaliza el proceso de implementación del midlet de ejemplo y se deberá continuar con los procesos de compilación, preverificación y despliegue de la aplicación ( midlet binario) en el dispositivo móvil.

23. Fin de la presentación. Creative Commons (CC)