La clase Graphics

Hoy vamos a hablar más acerca de la clase Graphics. Está clase me permite dibujar en pantalla, mostrar incluso imágenes y como se vio en el post anterior es posible mostrar textos. La clase Graphics se crea justo en el método paint() como se vio en la clase HelloCanvas del ejemplo pasado, este método lo reproduzco enseguida:

public void paint(Graphics g) {
 g.drawString("Hola mundo, en modo gráfico",0,0,Graphics.TOP|Graphics.LEFT);
}

Otra vez, la declaración del objeto de la clase Graphics es así:
                                            Graphics  g

Con la declaración anterior, por medio del objeto g, ya puedo usar los métodos de la clase, uno de estos métodos es 

                                           drawString

pero existen muchos métodos más basta con ver la documentación de la clase Graphics, para conocer algunos de sus métodos. La figura siguiente muestra algunos de ellos directamente de la documentación de J2ME (puedes dar clic en la imagen para verla mas grande).

 

Claro que para ver la documentación como se muestra en la imagen se debe tener instalado el SonyEricsson SDK, dando clic aquí   ver el post para su instalación, por si todavía no lo tienes.

 

Método drawLine

 

Como se ve en la figura la clase Graphics tiene infinidad de métodos, ya conocemos uno el drawString, vemos otro:

 drawLine

 

En la documentación dando clic en el método nos lleva a su descripción la cual es mostrada en la siguiente imagen:

La descripción nos dice que el método dibuja una línea entre las coordenadas (x1, y1) y ( x2, y2). Por ejemplo:

                                 drawLine(0, 0, 100, 100);

Dibuja una línea de la coordenada (0,0) a la (100, 100), como se usa el método así:

public void paint(Graphics g) {
   g.drawLine(0, 0, 100, 100);
}

Para usar cualquier método de la clase Graphics, se debe hacer por medio del objeto esa es la razón de que se le agregue la g y el punto y todo lo anterior debe estar dentro del método paint. La figura siguiente muestra la línea en el emulador:

Note como en el emulador no se borran las letras, cuando lo programe físicamente en el celular ahí si se borraba todo y aparecía solo la línea. Más adelante vemos como cambiar eso, para que no aparezcan esas letras.

 

Método setColor

 

En la figura siguiente muestro el método setColor tal y como está en la documentación de J2ME:

 

Este método establece el color en términos de valores RGB (dando clic en el hipervínculo podemos ver la explicación desde la WikiPedia, e incluso se pueden ver los valores para los distintos colores), estos valores son pasados por medio de los parámetros por ejemplo:
.

Negro                         setColor(0, 0, 0)

Blanco                        setColor(255, 255, 255)

 

Este Si se vio el enlace desde la wikipedia está dice qué el color blanco es con el numero FF FF FF, esos valores están en  hexadecimal, según dicen, es mejor manejarlos así, entonces el FF es igual al 255 en decimal. Por cierto si deseo escribirlo en hexadecimal también es posible en java usando el operador 0x, así quedaría el color blanco en hexadecimal

 

                               setColor(0xFF, 0xFF, 0xFF)

 

 Los tres colores básicos se forman así:

Color      en decimal                en hexadecimal                           
Rojo     setColor(255, 0, 0)       setColor(0xFF, 0, 0)
Verde    setColor(0, 255, 0)       setColor(0, 0xFF, 0)  
Azul     setColor(0, 0, 255)       setColor(0, 0, 0xFF)  

Combinando los valores RGB podemos obtener prácticamente cualquier color, la misma wikipedia nos da ejemplos de otros colores por ejemplo:

 

Amarillo                     setColor(0xFF, 0xFF, 0x00)

Purpura                     setColor(0x80, 0x00, 80)

 

Puedes ver más colores desde el artículo de la wikipedia si lo deseas.

 

Como hago uso del método, ya te lo has de imaginar, por ejemplo si deseo crear tres líneas dos horizontales y una vertical, una roja, otra verde y la otra azul, escribo dentro del método paint así:

public void paint(Graphics g) {

     g.setColor(0xFF, 0, 0);  // Se establece el color rojo
     g.drawLine(0, 50, 100, 50); // Se dibuja la primer línea horizontal
     g.setColor(0, 0xFF, 0);  // Se establece el color verde
     g.drawLine(0, 150, 100, 150); // Se dibuja la segunda línea horizontal
     g.setColor(0, 0, 0xFF);  // Se establece el color azul
     g.drawLine(100, 50, 100, 150); // Se dibuja la línea vertical
}

Al ejecutar el código se vería lo siguiente:

Método fillRect

 

La figura siguiente muestra la documentación de este método:

Dibuja un rectángulo relleno con el color actual, a partir de la coordenada (x,y) con un ancho y un alto especificado en los parámetros width y height. Por ejemplo:

public void paint(Graphics g) {
 g.setColor(0xFF, 0, 0);  // Se establece el color rojo
 g.fillRect(45, 60, 100, 100); // rectángulo relleno
}

Al ejecutar el código se muestra la figura siguiente

En este caso dibuja el rectángulo a partir de la coordenada (25, 60) con un ancho de 100 pixeles y con un alto también de 100 pixeles.

 

Ahora te toca a ti, nos llevaría mucho tiempo ver todos y cada uno de los métodos de la clase Graphics, son más de 20, así que no lo voy a hacer, más adelante usare algunos métodos y los explicaré pero hay muchos con los cuales tu puedes practicar, aquí les muestro como se hace, simplemente ver la documentación y a probar como se comporta, así que tu experimenta con los otros métodos.

 

Ancho y Alto de la Pantalla

 

Para finalizar este post, veré dos métodos que me permiten obtener el ancho y alto de la pantalla del celular en el modo gráfico:

 

getWidth(): Obtiene el ancho en pixeles de la pantalla disponible del celular

getheight(): Obtiene el alto en pixeles de la pantalla disponible del celular

 

Estos métodos se heredan a la clase Canvas por eso no tengo que crear ningún objeto, son métodos que puede usar directamente, así por ejemplo si deseo rellenar la pantalla con un color de fondo hago lo siguiente:

public void paint(Graphics g) {
     g.setColor(0xFF, 0, 0);  // Se establece el color rojo
     g.fillRect(0, 0, getWidth(), getHeight);
}

El resultado es el siguiente:

Se acostumbra iniciar el método paint con una llamada a ese par de instrucciones, esto con la finalidad de “borrar” toda la pantalla, se acostumbra el blanco pero puede ser el que cada quien desee.

 

Así por ejemplo si me piden dibujar una línea, un cuadrado sin rellenar, y un cuadrado relleno este sería el código:

 

public void paint(Graphics g) {
      g.setColor(255,255,255); // se establece el color blanco
      g.fillRect (0, 0, getWidth(), getHeight()); // "borra" la pantalla
      g.setColor(10,200,100);
      g.drawLine (0, 0, 100, 100);
      g.drawRect(90, 50, 30, 30);
      g.fillRect (50, 50, 30, 30);
}

Note como ya no se ve ninguna de las letras que aparecía antes, ahora si esta el área de dibujo libre, solo aparece lo que yo mande dibujar.



Clic AQUI para leer más...!

Aplicación de la programación de teléfonos celulares usando J2ME

Ups por fin, terminamos los proyectos finales, ya voy a “postear” más seguido. Hoy les muestro una aplicación practica que se hizo aquí en el ITESI por los alumnos del Grupo de Sistemas Digitales de la carrera de Ingeniería electrónica.

Proyecto: Sistema Electrónico de Identificación por Radio-Frecuencia

Objetivo

Desarrollar un Sistema de hardware y software capaz de identificar y almacenar identificación relevante a la crianza de ganado usando la identificación por radiofrecuencia (RFid). Cabe mencionar que el seguimiento se realiza por un MIDlet programado en un teléfono celular.

La figura siguiente muestra un diagrama a bloques del sistema que se desarrollo.

No voy a entrar en detalle sobre la descripción de cada uno de los bloques, pero el sistema funciona agrandes rasgos así:

1.- Una etiqueta de radiofrecuencia se coloca en el ganado bovino (como si fuera un arete como los que comúnmente se usan) pero la etiqueta tiene un chip especial que contiene un número.

2. Al acercar el lector de RFid, se detecta el número de la etiqueta de RFid que es irrepetible para cada bovino.

3.- El lector de RFid envía el número de etiqueta a la tarjeta DLP-TXRX que se encarga de pasarlo a una PC via puerto USB.

4.- La PC recibe en un programa creado en Java Estándar Edition (J2SE) el número de etiqueta y se lo transfiere (con el mismo programa) a un módulo Bluetooth  conectado al puerto USB de la PC (incluso se hicieron pruebas con PCs que tienen internamente un módulo Bluetooth y el sistema igual funciono muy bien).

5.- El teléfono celular recibe el número de etiqueta vía Bluetooth con un programa creado en Java Micro Edition y registra los datos del bovino.

En el video siguiente se muestran más detalles de los componentes usados y del programa en el celular.

Enseguida se muestran algunas fotos del proyecto.

La figura siguiente muestra la fotografía de las etiquetas de RFid y del lector de RFid, estos fueron adquiridos desde la compañá Parallax

En la figura siguiente se ve el módulo USB que fue comprado a la compañía DLP-Design

Finalmente se ve el programa creado para el celular, obviamente fue programado con Java Micro Edition usando el NetBeans.

En la figura se muestra cuando se inicia la busqueda de dispositivos Bluetooth, esto también fue programado en J2ME.

Aqui muestra la lista de dispositivos Bluetooth encontrados, se elije uno y se conecta para poder recibir el dato de la etiqueta

Enseguida se muestra cuando se detecto la etiqueta y se procede a registrar los datos del bovino.

Bueno aqui dejo este post, solamente fue con fines demostrativos en el siguiente post seguiremos con las lecciones de java.

Clic AQUI para leer más...!

Ejemplo #14 Hola Mundo en modo gráfico

Bueno por fin se va a explicar en este post como se realiza un ejemplo completo usando las interfaces de bajo nivel del celular o también conocido como modo gráfico. Se va a realizar el clásico ejemplo “hola mundo” así que comencemos.

Paso 1. Crear el MIDlet

Este paso ya se analizó, dando clic aquí se puede ver el post, casi al final se indica como crear el MIDlet desde NetBeans, puedes ver el post si no te acuerdas del procedimiento. El resultado de haber realizado este paso es mostrado en la figura siguiente:

Paso #2 Crear la clase que deriva de Canvas

El siguiente paso es crear la clase que hereda de la clase Canvas, este paso también ya se analizo en un post anterior, dando clic aquí puedes acceder a el. También ahí vienen los pasos requeridos para crear la clase llamada HelloCanvas, el resultado de este paso es mostrado en la imagen siguiente:

Paso #3 Agregar el “Hola mundo” a la clase HelloCanvas

El siguiente paso es con la clase HelloCanvas, identificamos el método paint(), y justo en el método drawString, se modifican dos parámetros, uno es el string que se va a dibujar, el “Sample Text” lo modifico por “Hola Mundo, en modo Grafico” y el otro parámetro es el de las coordenadas las que usare son (20, 100) entonces la instrucción queda así:

g.drawString("Hola Mundo en modo Grafico", 50, 100,Graphics.TOP|

Graphics.LEFT);

Paso #4 Crear el objeto de la clase HelloCanvas

Existen dos códigos, dos archivos de java, generados hasta el momento:

• El MIDlet

• La clase HelloCanvas

La pregunta es: ¿como los relaciono? ¿Cómo puedo usar el método paint para que se dibuje el mensaje en la pantalla del celular?, recuerde el celular sigue los métodos que están en el MIDlet, esto significa que el código del MIDlet es el que se ejecuta primero, pero el método de dibujo está en la clase HelloCanvas, si se ve el problema, como puedo desde el MIDlet llamar el método paint.

La solución es sencilla y quizá muchos ya lo saben, recuerde las clases son plantillas para crear objetos, HelloCanvas es una clase, entonces es posible crear un objeto de la clase HelloCanvas y usarlo en la clase MIDlet, déjenme repetirlo, se puede crear un objeto de la clase HelloCanvas y usarlo desde el MIDlet.

Para crear un objeto, primero hay que declararlo, le llamaramos myCanvas, para hacerlo simplemente se coloca el nombre de la clase seguido del nombre del objeto, así:

HelloCanvas miCanvas;

Lo anterior es la declaración, para realmente crearlo se usa el comando new así:

miCanvas = new HelloCanvas();

Después de esa instrucción el objeto llamado miCanvas, está completamente creado y listo para usarse.

Solo falta un detalle, para mostrar cualquier cosa en la pantalla del celular se usa la clase Display, nunca se ha visto en este blog, por que como se recordara NetBenas creaba todo el código incluyendo los objetos de la clase Display, la siguiente instrucción:

Display.getDisplay(this).setCurrent(miCanvas);

Permite dibujar lo que esté en el método paint de la clase Canvas, la clase Display representa el hardware, la pantalla del celular, para acceder a esta pantalla se usa el método getdisplay(this) se usa el this, para indicar que el MIDlet actual es el que se envía como parámetro, finalmente el método setCurrent(HelloCanvas) es usado para indicar que la pantalla actual será la definida por el objeto miCanvas, bueno en resumen el código queda así:

public class Midlet extends MIDlet {
   HelloCanvas miCanvas
   
   public void startApp() {
       miCanvas = new HelloCanvas();
       Display.getDisplay(this).setCurrent(HelloCanvas);
   }
   public void pauseApp() {
   
   }
   public void destroyApp(boolean unconditional) {
   
   }
}

Y listo al ejecutar el código se mostrará en la pantalla el mensaje “hola mundo, en modo gráfico”. Para que quede más claro y lo puedas hacer mucho más fácil se muestra el video tutorial completo para este ejemplo, tal y como se acostumbra en el blog.

En este caso no voy a anexar el código fuente hasta la siguiente entrada, ya que se va a modificar por que el comando exit no funciona como lo puedes ver en el emulador.

Clic AQUI para leer más...!

La Clase Canvas Parte II

En el post anterior aprendimos a crear una clase que hereda de la clase Canvas, NetBeans crea el código, en este post se va a analizar el código generado. En primer lugar está la definición de la clase la cual ya se hablo mucho en el post anterior, aquí se reproduce:

Public class HelloCanvas extends Canvas implements CommandListener {

     //Aqui va el código generado por NetBeans

}

Esta clase contiene varios métodos generados por NetBeans como ya se mencionó, los cuales se analizan de una forma un tanto superficial porque hay código que no interesa ver en detalle, al menos no ahora pero que NetBeans lo agrega, asi que iniciemos.

Constructor de la Clase HelloCanvas

No se había mencionado nunca en este blog, pero una clase consta de atributos y métodos pero también lleva un método especial llamado constructor.

El nombre del constructor es igual al nombre de la clase, generalmente se usa para inicializar los objetos con valores iníciales, recuerde todo el código analizado en este post, es creado por NetBeans, en el caso del constructor su código generado es el siguiente:

public HelloCanvas() {
  try {
     // Set up this canvas to listen to command events
     setCommandListener(this);
     // Add the Exit command
     addCommand(new Command("Exit", Command.EXIT, 1));
  } catch(Exception e) {
     e.printStackTrace();
  }
 }

Hay mucho código que no es el momento de explicar en detalle todavía, por ejemplo la pareja de instrucciones:

Try {

}
Catch (exeption e) {

}

Sirven para manejar las llamadas excepciones, esto es código que puede lanzar un error en tiempo de ejecución, no nos interesan detalles de esto ahora, recuerde nos interesa realizar el primer ejemplo con interfaces de bajo nivel, así que por lo pronto no diremos más de estas instrucciones

Además el constructor también lleva las siguientes sentencias:

// Set up this canvas to listen to command events
  setCommandListener(this);
// Add the Exit command
  addCommand(new Command("Exit", Command.EXIT, 1));

Con comentarios NetBeans nos explica cada instrucción, en resumen, agrega un exitCommand al Canvas, así al ejecutar el código aparece en la sección de comandos un botón que puede servir para salir de la ejecución, antes no me preocupaba por el código puesto que yo solo arrastraba y soltaba el comando, pero recuerde al usar la clase Canvas hay que hacer todo con código. Entonces el código anterior agrega exitCommand y con la instrucción: setCommandListener deja listo al Canvas para “escuchar” los comandos, en otras palabras para detectar cuando se presiona el exitCommand.

El método paint

Otro método de la clase HelloCanvas es el método paint, se usa para dibujar en el Canvas y mostrarse en la pantalla del celular, en este método se pueden dibujar líneas rectángulos, imágenes etc. pero esto solo se puede hacer por medio de la clase Graphics. Vea el código que genera NetBeans de este método:

public void paint(Graphics g) {
   g.drawString("Sample Text",0,0,Graphics.TOP|Graphics.LEFT);
}

El método lleva entre ( ) lo siguiente:

Graphics g

Esa sentencia crea un objeto de la clase Graphics, el objeto se llama g.

La clase Graphics

La clase Graphics posee todos los métodos necesarios para dibujar en pantalla, mostrar gráficos y mostrar textos. Recuerde, g es el objeto de la clase Graphics, con el objeto creado se pueden usar los métodos de la clase. Por cierto, la clase Graphics tiene muchísimos métodos que me permiten dibujar en el Canvas, como se verá después, por lo pronto entre estos métodos está el método drawString(), que es el que se muestra en el método paint como se ve en la sección anterior.

El método se llama drawString y sirve para dibujar una cadena de caracteres dentro del Canvas, La figura siguiente muestra la descripción de cada parámetro del drawString:

El texto “Sample Text” es el que aparece en la pantalla del celular, después siguen las coordenadas de ubicación del texto que en este caso es (0, 0), después sigue el punto de referencia para situar el texto, en este post no nos interesa ese punto de referencia, luego se discute más a detalle.

Por cierto J2ME divide la pantalla del celular en puntos denominados pixeles el primer punto se ubica en la coordenada (0, 0), la figura siguiente muestra el sistema de coordenadas de Java Micro Edition:

Bueno después de los detalles sigamos con el código que genera NetBeans para la clase HelloCanvas

Métodos para detectar eventos relacionados con las pulsaciones de una tecla

Siguiendo con el código de la clase HelloCanvas se tienen los siguientes métodos en la clase:

protected  void keyPressed(int keyCode) {
}
protected  void keyReleased(int keyCode) {
}
protected  void keyRepeated(int keyCode) {
}

La siguiente tabla describe que hace cada método:

   Método                            Descripción                 
keyPressed()              Se ejecuta cuando se presiona una tecla
keyReleased()             Se ejecuta cuando se suelta una tecla
keyRepeated()             Se ejecuta cuando se deja presionada una tecla

Métodos para detectar eventos relacionados con apuntadores

También la clase Canvas tiene métodos para detectar los eventos relacionados con

apuntadores o mouse estos los genera Netbeans y son:

protected  void pointerDragged(int x, int y) {
}
protected  void pointerPressed(int x, int y) {
}
protected  void pointerReleased(int x, int y) {
}

Cabe aclarar que estos métodos solo son validos en dispositivos que lo soportan, no todos los celulares tienen un apuntador, asi que no se ven más detalles de estos métodos.

Metodo para procesar comandos

El último método de la clase es mostrado en seguida:

public void commandAction(Command command, Displayable displayable) {

}

Cuando se presiona un comando ya sea un okCommnad o un exitCommand se invoca o se ejecuta el método commandAction(), entonces este método me sirve para procesar los comandos.

Bueno ahora si por fin se tienen todos los medios para realizar un ejemplo completo que muestre el mensaje "Hola Mundo" usando Canvas, pero esto lo dejamos para el siguiente post.

Clic AQUI para leer más...!

La Clase Canvas

Introducción

La siguiente figura muestra la ya conocida jerarquía de clases de Java Micro Edition. Ahí se ve claramente las clases que se han usado a lo largo de este blog, con las cuales se crean programas con las llamadas interfaces de alto nivel.

Vea la figura, también está la clase Canvas usada para crear las interfaces de bajo nivel, desgraciadamente esta clase se maneja diferente a lo visto hasta ahorita en el blog, la clase Canvas, NO SE PUEDE ARRASTRAR Y SOLTAR, como las clases que crean interfaces de alto nivel vistas en los ejemplos de este blog, el tratamiento es diferente como se ve a continuación, así que comencemos a analizarla.

La clase Canvas

La clase Canvas es usada para crear las interfaces de bajo nivel. Esta clase contiene los mecanismos necesarios para usar la pantalla del celular como una zona de dibujo, se puede dibujar cualquier cosa en la pantalla, esta clase es usada por los desarrolladores de juegos para celulares porque permite tener control total sobre lo que se dibuja en la pantalla del celular, se tiene un control incluso sobre cada punto de la pantalla (por cierto cada punto en la pantalla es llamado pixel).

Con objetos de esta clase se tiene acceso directo a la pantalla del celular la cual tiene una área de dibujo y un área de comandos, como se observa en la figura siguiente:

La clase Canvas fue diseñada por los creadores de Java como una CLASE ABSTRACTA esto según las reglas de la programación orientada a objetos significa que no se pueden crear objetos (o instancias) a partir de ellas.

Recordemos un poquito los conceptos de la programación orientada a objetos, una clase contiene la definición de atributos y métodos que hacen algo, por ejemplo, la clase TextField, que se ha usado en muchos ejemplos, contiene el método que también ya se ha visto muchas veces: getString(). Este método lo que hace es obtener los caracteres que se han ingresado en el TextField, y los asigna a una variable.

Veamos, La clase se llama TextField, uno de sus método se llama getString(), pero recuerde, una clase es una plantilla para crear objetos, entonces para usar el método getString(), Yo necesito un objeto (o instancia) de la clase, el objeto es creado automáticamente por NetBeans, y como se ha visto en los ejemplos Netbeans le asigna el nombre de textField, si hay mas Netbeans les llama textField1, textField2, etc. Estos objetos NetBeans los genera yo no me preocupo por crearlos, yo lo único que hacía era escribir:

textField.getString();

para obtener el texto ingresado en el textField.

Otra vez, la clase se llama TextField, uno de sus métodos se llama getString(), para usarlo se requiere un objeto o instancia llamado textField, pues la clase Canvas no acepta la creación de instancias, entonces yo no puedo hacer uso de sus métodos, por ejemplo la clase Canvas tiene un método llamado paint( ). Este método me permite realizar dibujos en la pantalla del celular, pero no lo puedo usar por que la clase Canvas es abstracta, entonces estamos en un problema, por un lado necesito de la clase Canvas para dibujar en la pantalla, pero por otro lado no puedo usar la clase por que es abstracta. Pero todo se soluciona bien simple, como a continuación se explica.

Creación de clases en java

Para solucionar el problema de las clases abstractas, se crea otra clase por ejemplo una clase llamada miCanvas o el nombre que se desee.

El código para crear una clase en java es bien simple, así:

class miCanvas {

   // aqui van los atributos y métodos de la clase

}

Esa es la sintaxis para crear clases en java: la palabra reservada class, el nombre de la clase y las { }.

Otro ejemplo es:

class HelloCanvas {

}

La clase se llama HelloCanvas, recuerde ese nombre yo se lo asigno como yo lo desee.

Vemos, por un lado se tiene la clase HelloCanvas (o como se llame) y por otro lado se tiene la clase Canvas, obviamente no existe relación alguna entre ellas, son entidades diferentes, para relacionarlas se usa la HERENCIA, la herencia se agrega con la palabra “extends” de la siguiente forma:

class HelloCanvas extends Canvas {

}

Significa que la clase HelloCanvas, hereda todos los métodos y atributos de la clase Canvas, en otras palabras, con la herencia ya puedo usar el método paint() de la clase Canvas, porque ya hay una relación con la clase miCanvas. ¿Me explique?

Recuerde, la clase Canvas no permite crear instancias a partir de ella, pero la clase miCanvas creada por nosotros si permite crear objetos, por que no es abstracta, y como llevan una relación de herencia, puedo usar el método paint() para dibujar en la pantalla cualquier gráfico.

Otra cosa, la clase Canvas es “public” por eso yo puedo agregar la herencia desde la clase miCanvas, por lo que se recomienda que las clases creadas por nosotros sean públicas también, para crearlas públicas simplemente anteponga la palabra “public” así:

public class HelloCanvas extends Canvas {

}

“public” significa que la clase es pública y puede ser usada desde otra clase o desde otro paquete de clases.

Creación de la clase HelloCanvas desde NetBeans

Para crear la clase HelloCanvas desde NetBeans, primero se debe crear un proyecto, déspues se pueden seguir dos opciones similares a las del post anterior:

1. Desde el menú de NetBeans presionar:

                   File> New file…

Al hacerlo aparece el cuadro de dialogo para crear un nuevo archivo, ahí se elije como en la figura siguiente:

2. Otra opción para crear la clase HelloCanvas, es dando clic derecho en el proyecto que se creó y eligiendo New y luego la opción MIDP Canvas, tal y como se observa en la figura siguiente:

Cualquiera de las dos opciones anteriores me lleva a la pantalla siguiente para asignar el nombre a la clase:

Simplemente se da clic en el botón de Finish, para que termine la creación de la clase HelloCanvas, al proyecto se le agrega el archivo llamado HelloCanvas.java, al dar doble clic en el nombre, esté se abre en la pantalla del netBeans apareciendo el código de la clase HelloCanvas como lo muestra la figura siguiente:

Vea el código que genera NetBeans para la clase HelloCanvas, vea la definición de la clase, al iniciar el código se puede ver, es así:

Public class HelloCanvas extends Canvas implements CommandListener {

     // Aquí va el código generado por NetBeans

}

Es exactamente lo que mencionamos arriba más “implements CommandListener”. Esa instrucción permite que el celular detecte los exitCommand, o los okCommand, nunca se había visto esto porque, en los ejemplos realizados NetBeans generaba automáticamente esas instrucciones.

No se va a hablar mucho del “implements” nos llevaría un post completo, ahorita no me interesa los detalles, basta con decir que sirve para detectar los comandos en el celular.

Hasta aqui le vamos a dejar hoy, ya casi se acaba la teoria, nos falta analizar el código que generó NetBeans en la clase HelloCanvas y finalmente enlazar el código del MIDlet con el código de la clase HelloCanvas, para crear el primer programa usando las interfaces de bajo nivel, les ruego paciencia.

Clic AQUI para leer más...!

Ciclo de vida de un MIDlet

Introducción

Todos los 13 ejemplos completos vistos en este blog han sido creados usando, Form, TextField, StringItem, List, etc. objetos usados para crear las interfaces de usuario, en Java ME, las interfaces creadas con esos objetos se les conoce como Interfaces de alto nivel.

Pero aquí hacemos un paréntesis, lo fuerte de Java Micro Edition no son las interfaces de alto nivel, y los programas que se pudieran realizar con ellas, lo fuerte de java es la programación de juegos, es el campo donde Java ME ha tenido el mayor éxito, vea su celular ¿Cuántos juegos tiene? Pues la mayoría de esos juegos son programados en java, para programarlos se requiere tener control completo de prácticamente cualquier punto de la pantalla del celular, esto se le conoce como programación de interfaces de usuario de bajo nivel.

“El blog que te enseña a programar teléfonos celulares” no estaría completo si no enseña la programación de bajo nivel. Justo el post de hoy y los subsiguientes hablaran de este tipo de programación, incluso es más interesante (bueno a mi me parece) este tipo de programación que lo que se ha visto ahora, así que si, los ejemplos anteriores les han parecido interesantes pues ahora los ejemplos que vienen les gustarán más ya lo verán. Pero antes hay que ver algo de teoría :(

Ciclo de vida de un MIDlet

Los 13 ejemplos completos que se han visto en el blog tienen un ciclo de vida, nunca les había mencionado esto, pero todos, absolutamente todos los programas de Java Micro Edition, siguen ese ciclo de vida, nosotros no nos percatamos de ello porque el ciclo de vida del MIDlet, lo maneja el dispositivo donde se está ejecutando, en la mayoría de los casos un teléfono celular.

El ciclo de vida de un MIDlet consta de tres estados

• Pausa

• Activo

• Destrucción

La figura siguiente muestra un diagrama de estos tres estados:

Descripción del ciclo de vida

Debe quedar claro que el ciclo de vida del MIDlet es gestionado por el sistema operativo del teléfono celular. Cuando se carga el archivo JAR al celular el sistema operativo del teléfono detecta que es un MIDlet y pregunta si deseas iniciarlo, al aceptar es cuando inician los estados anteriores.

Primero el MIDlet se coloca en pausa, un instante después el sistema operativo hace que el MIDlet pase al estado activo, justo es cuando se manda llamar un método llamado startAPP(), en este estado, se muestra la interfaz de usuario el Form, los StringItem o los TextField o lo que lleva la aplicación.

El MIDlet en el estado activo se queda haciendo lo que se le programo. Pero puede haber eventos externos que interrumpan al MIDlet, por ejemplo, si se recibe una llamada cuando se está ejecutando el MIDlet este se coloca en pausa llamando al método pauseAPP (por eso en la figura se ve una flecha de regreso al estado de pausa) y pues el usuario puede contestar la llamada y después volver a regresar al MIDlet, finalmente cuando el usuario desea salir del MIDlet es cuando este se destruye de la memoria y es cuando pasa al estado de destrucción y se liberan los recursos ocupados por él.

Vuelvo a repetir, estos estados los gestiona el sistema operativo del celular, yo no tengo nada que ver así que estrictamente hablando el ciclo de vida del MIDlet no me importa  o ¿acaso nos ha importado ya después de haber realizado 13 ejercicios completos desde que inicio el blog? Entonces ¿porque lo vemos?, quizá se estén preguntando, la razón es sencilla si quiero programar las interfaces de bajo nivel, los gráficos y en un futuro los juegos necesito hacer uso de los métodos involucrados en los ciclos de vida del MIDlet.

Estructura más básica de un midlet

Regresemos a la figura anterior, cuando se lanzan cada uno de los estados, se ejecutan también los métodos que ahí se indican y que aquí los vuelvo a escribir:

• startAPP()

• pauseAPP()

• destroyAPP()

Esos métodos son parte del código del MIDlet, en todos nuestros ejemplos que se han realizado, estos métodos son generados por el NetBeans cuando se crea el proyecto para un MIDlet nuevo, por eso yo ni me preocupaba por ellos porque el NetBeans los genera automáticamente, si lo deseas puedes ver el código de alguno de los ejemplos que hayas realizado, en algún lado puedes identificar esos métodos.

NetBeans genera mucho código automáticamente para crear un MIDlet, este código generado me permite simplemente arrastrar y soltar elementos o comandos desde la vista de flujo, pero es posible crear un MIDlet con muy poquito código, el listado que a continuación se muestra crea un MIDlet que no hace absolutamente nada, pero contiene los elementos más básicos que debe tener el MIDlet.

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

public class Midlet extends MIDlet {

   public void startApp() {

   }

   public void pauseApp() {

   } 

   public void destroyApp(boolean unconditional) {

   }

}

Ahora se procede a analizar el código, por ejemplo las siguientes instrucciones

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

Sirven para poder usar la gran cantidad de clases ya diseñadas por los creadores de Java, por ejemplo las clases que ya se han usado en los programas como la clase TextField, StingItem, CohiceGroup etc. están definidas dentro del paquete de clases: javax.microedition.lcdui.*; por eso si yo las voy a utilizar en mi programa debo importar ese paquete de clases, otra vez lo repito en nuestros ejemplos no se hizo la importación por que NetBeans lo realiza por nosotros, cuando creamos el proyecto.

Después de importar las librerías o paquetes, viene la declaración de la clase para crear un MIDlet, el código es así:

public class Midlet extends MIDlet {

}

Recuerde, en java todo absolutamente todo es o proviene de una clase, así que un MIDlet no es la excepción, para su creación se crea una clase, en este caso la clase es llamada Midlet (class Midlet), es de tipo “public”, el echo de que sea public significa que se puede acceder a ella desde otras clases, pero estos conceptos ahorita no nos interesan, en su momento se detallaran más.

Igual pasa con la palabra “extends”, que en java significa herencia (luego se verá con más detalle). La herencia significa que la clase Midlet, hereda todos los atributos y métodos de la clase MIDlet, esto es por regla general, los creadores de Java fueron bien claros, todos absolutamente todos los MIDlets desarrollados por los usuarios tienen que heredar de la clase base, la clase MIDlet. En pocas palabras si yo no defino el MIDlet así no funciona nada, es la regla, así está diseñado el lenguaje y pues nosotros que apenas iniciamos nos apegamos a esas reglas, a esa sintaxis aun cuando todavía no me quede claro la herencia o las clases públicas, más adelante se entenderán.

Después de declarar la clase vienen los métodos, el primero es así:

public void startApp() {

}

Ese es el método que se ejecuta cuando el sistema operativo del celular pase al MIDlet del estado de pausa al estado activo. Por regla general este método se agrega siempre, lleve o no lleve código, bueno y también los otros métodos: pauseAPP y destoyAPP(), si no los agrego al código se tendrá un error de compilación, el porqué tienen que ir a fuerzas, no nos interesa por el momento, nos llevaría un buen rato la explicación y no es el momento, por lo pronto yo me conformo con saber que se tienen que agregar y listo.

Como crear un MIDlet con el código básico desde NetBeans

Desde NetBeans es posible crear un MIDlet con el código base, y esto lo hacemos porque ahora para los ejemplos que siguen nos interesan las interfaces de bajo nivel, así que simplemente necesitamos el código básico para ello, para obtenerlo, basta con seguir los pasos siguientes:

Paso 1 crear un nuevo proyecto

El primer paso es crear un nuevo proyecto desde NetBeans, pero ahora se hace lo que indica la figura:

No se selecciona el HelloMidlet, los 13 ejemplos si lo hacían, recuerde por lo pronto no nos interesa la interfaz de alto nivel, aunque en un futuro vamos a mezclar las dos he¡¡ pero por lo pronto no.

Lo que se muestra en la figura es lo único diferente que se realiza con respecto a los 13 ejemplos anteriores, con eso basta para que NetBeans no genere el código automáticamente

Paso 2 Agregar el MIDlet al proyecto

Con lo anterior se crea el proyecto para NetBeans pero sin código alguno así que podemos seguir dos caminos que nos llevan a la creación del archivo más básico de java:

1. Desde el menú de NetBeans presionar:

File> New file…

Al hacerlo aparece el cuadro de dialogo para crear un nuevo archivo, ahí se elije como en la figura siguiente:

2. Otra opción para crear el archivo más básico es dando clic derecho en el proyecto que se creó y eligiendo New… y luego la opción MIDlet, tal y como se observa en la figura siguiente:

Cualquiera de las dos opciones anteriores me lleva a la pantalla siguiente para asignar el nombre al MIDLet

Por defaul viene el nombre del MIDlet como Midlet si lo deseamos se deja así y simplemente se da clic en el botón de Finish, para que termine la creación, al proyecto se le agrega el archivo llamado Midlet, esté se abre en la pantalla del netBeans pareciendo el código más básico para un MIDlet como lo muestra la figura siguiente:

Eso es todo lo del post de hoy, ya son las 12:46, creo que es hora de dormir, en la siguiente entrada realizaremos el clásico ejemplo del Hola mundo, versión gráfico, o sea usando la interfaz de bajo nivel.

Clic AQUI para leer más...!

Estructuras de Repetición: Ciclo While y Ciclo Do-while

Seguimos viendo más sintaxis de java. Hace varias entradas del blog se inicio con las estructuras de repetición, específicamente con el ciclo for, pero existen otras, hoy vamos a ver dos más.

Ciclo While

Una estructura de repetición permite repetir una o varias instrucciones un determinado número de veces. El ciclo “while” repite las instrucciones “mientras” la condición de terminación sea verdadera, si es falsa se termina el ciclo y se pasa a la siguiente instrucción. Su sintaxis se muestra con un ejemplo:

     x = 0; // Inicialización de la variable de control
     while (x <10) {  // condición, repite mientras x sea < 10
         // Aquí van las instrucciones que se repiten
         x++; // Incremento de la variable de control
     }

Este ciclo requiere de una variable de control, esta es la encargada de indicar si se siguen repitiendo las instrucciones o ya no, en el ejemplo se llama “x” pero puede ser cualquier nombre de variable, generalmente es de tipo entero y se inicializa en 0, aunque esto no es obligatorio, puede ser de otro tipo o puede inicializarse con otro valor diferente a cero, depende del ejercicio que haga, pero en este ejemplo se inicializa en 0 con la instrucción:

x = 0;

Después sigue la palabra reservada “while” que significa “mientras” y un paréntesis donde se escribe la condición de terminación del ciclo, después se abre la { que agrupa el total de instrucciones a repetir, en el ejemplo el código del que se habla es este:

        while (x <10) {

        }

En este caso la condición de terminación es:

x < 10

Lo que significa que el ciclo se va a repetir “mientras” x sea menor a 10, cuando x es mayor a 10 se termina el ciclo y se siguen las instrucciones que van después de la }.

Después se ingresan las instrucciones que se van a repetir y antes de terminar el ciclo se debe incrementar la variable de control, esto es:

x++

Sin ese incremento no se terminaría nunca el ciclo, porque entonces la x nunca sería mayor a 10. Bueno eso es todo, lo del ciclo while por supuesto que todo se aclara más con ejemplos, así que iniciemos:

Problema #1

Realizar el segmento de código en Java que sume los primeros 50 números positivos, mostrar el resultado en un stringItem. Usar el ciclo while.

Solución

Como se indica arriba, todo inicia con la variable de control, hay que inicializarla en 0, como se van a sumar los números se requiere de otra variable, la llamaremos suma, también se inicia en 0. La inicialización queda entonces así:

        x = 0;
        suma = 0;

Enseguida va la palabra reservada “while” junto con la condición de terminación, en este caso se desea sumar los primeros 50 números positivos, entonces se requiere un ciclo de 0 a 50, la condición de terminación es pues x <= 50, el código seria:

        while (x <= 50) {

        }
 

La variable de control debe incrementarse dentro del ciclo, esta inicia en 0, luego se incrementa a 1, 2, 3, etc., hasta 50, así que basta con una instrucción como esta para acumular la suma cada que x toma un valor:

suma = suma + x;

Despues se debe incrementar la variable de control, usando la instrucción de incremento:

x++

Para mostrar el resultado se usa el método setText del Stringitem. Finalmente el código completo seria:

        x = 0;
        suma = 0;
        while (x <= 50) {
           suma = suma + x;
           x++;
        }
        stringItem.setText(“la suma de los primeros 50 números es : “ + suma);

Ciclo Do-While

Este ciclo es idéntico al anterior, se repiten las instrucciones “mientras” la condición es verdadera, la diferencia es que la condición de terminación se evalúa hasta el final, la sintaxis se muestra con un ejemplo.

       x = 0;  // Inicialización de la variable de control
       do {
           // aquí van las instrucciones que se repiten
           x++;  // Incremento de la variable de control
       } while ( x<10)   ;  // evaluación de la condición de terminación

Igual que el ciclo anterior todo empieza con la inicialización de la variable de control, en 0.

x = 0;

Después se escribe la palabra reservada do con una { que junto con la otra } agrupan las instrucciones que se repiten, justo antes de cerrar con la } se debe incrementar la variable de control con la instrucción ya conocida:

x++

Después de } se agrega el while y la condición que en este caso es x < 10, entonces en este caso el ciclo se estará repitiendo “mientras x sea menor o igual a 10”.

A continuación se muestra el mismo ejercicio que el ciclo anterior.

Problema #1

Realizar el segmento de código en Java que sume los primeros 50 números positivos, mostrar el resultado en un stringItem. Usar el ciclo do-while

Solución

Como se indica arriba, se inicializan las variables con el código siguiente:

           x = 0;
           suma = 0;

Enseguida se abre el ciclo con la instrucción

do {

En el cuerpo del ciclo van las instrucciones para sumar los números y el incremento de la variable de control:

           suma = suma + x;
           x++

Al final va la palabra while junto con la condición de terminación, así:

} while ( x <= 50);

La sentencia finaliza con ; el código completo es:

                 suma = 0;
                 x = 0;
                 do {
                     suma = suma + x;
                     x++;
                 } while ( x<= 50)   ;
                 stringItem1.setText(" la suma es:" + suma);

Bueno se presenta en esta entrada dos ciclos más, solo se ve un ejemplo pero a lo largo de este blog se presentarán muchos más.

¿Cual ciclo elegir?

Como ya se vio, existen tres tipos diferentes de estructuras de repetición, ¿cual usar?, depende de la aplicación, del problema que se desea resolver, pareciera que el ciclo for es más fácil de usar, y si lo es, por facilidad se recurre a el, pero los otros ciclos tienen sus ventajas sobre el for, una de ellas es que puedo evaluar dos o más condiciones, cosa que con el for resulta imposible, en conclusión la elección del ciclo depende del programa que se desea solucionar, pero esto con la practica, realizando programas y mas programas uno mismo sabrá cual ciclo conviene más. Hasta la próxima.

Clic AQUI para leer más...!