Maty Java Me

Interceptar las teclas que se presionan!

2010-08-21T14:53:00.000-07:00

Buenas amigos.

Primero quiero pedirles disculpas, que hace mucho no posteo nada, pero por algunos trabajos no tuve demasiado tiempo.

Hoy veremos como saber que teclas se presionan cuando tenemos en pantalla nuestro propio Canvas.

1 - Creamos nuestro MIDlet:

public class ClaseSeisMidlet extends MIDlet {

    Display pantalla;
    boolean inicio = false;

    protected void startApp() {
        if(!inicio){

            pantalla = Display.getDisplay(this);

            inicio = true;
        }
    }

    protected void pauseApp() {

    }

    protected void destroyApp(boolean unconditional) {
       
    }

}

2 - Creamos la clase MiCanvas:

public class MiCanvas extends Canvas {

    protected void paint(Graphics g) {
    }
}

3 - En este Canvas, dibujaremos un rectángulo, que podremos mover por toda la pantalla. Primero creamos 4 atributos de tipo entero:

int width;
    int height;
    int x;
    int y;

4 - Creamos un constructor para inicializar las variables:

Nota: Para recordar, un Constructor es un método que se llama automáticamente al momento de crear un nuevo objeto de nuestro clase. Este debe poseer el mismo nombre que la clase.

public MiCanvas() {
        // Seteamos que nuestro Canvas ocupe toda la pantalla
        setFullScreenMode(true);
        // Tamaño de ancho de nuestro rectangulo
        width = 50;
        // Tamaño de alto del rectangulo
        height = 60;
        // Coordenadas donde se dibujara por primera vez
        x = 0;
        y = 0;
    }

5 - Ya tenemos las medidas, pasamos a dibujar el Rectángulo:

protected void paint(Graphics g) {
        // Pintamos todo el fondo de blanco
        int colorBlanco = 0xFFFFFF;
        // Ponemos el color que vamos a usar
        g.setColor(colorBlanco);
        // Dibujamos un rectangulo del tamaño de toda la pantalla
        g.fillRect(0, 0, getWidth(), getHeight());

        // Color que usaremos para el rectangulo
        int colorRojo = 0xFF0000;
        g.setColor(colorRojo);
        // Dibujamos el rectangulo
        g.fillRect(x, y, width, height);
}

6 - Pongamos nuestro Canvas en pantalla, para eso volvemos a nuestra MIDlet:

public class ClaseSeisMidlet extends MIDlet {
    Display pantalla;
    MiCanvas canvas;
    boolean inicio = false;

    protected void startApp() {
        if(!inicio){

            pantalla = Display.getDisplay(this);

            canvas = new MiCanvas();

            inicio = true;
        }

        pantalla.setCurrent(canvas);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Esto tendría que mostrar algo así:

7 - Ahora es el momento de hacer que el rectángulo pueda moverse por la pantalla, para escuchar las teclas que se presionan debemos reescribir el método: keyPressed de nuestro Canvas:

protected void keyPressed(int keyCode) {

}

8 - Dentro de este método verificaremos que tecla se presiono y haremos lo que corresponda para cada una.

protected void keyPressed(int keyCode) {
        // getGameAction(keyCode) nos devuelve si se presiono una tecla de juego
        // las teclas de juego son ARRIBA - ABAJO - DERECHA - IZQUIERDA - FIRE
        int key = getGameAction(keyCode);

        switch(key){
            case UP:
                y -= 5;
                break;
            case DOWN:
                y += 5;
                break;
            case LEFT:
                x -= 5;
                break;
            case RIGHT:
                x += 5;
                break;
        }

        repaint();
 }

Como podrán comprobar con las teclas de dirección podrán mover el rectángulo por la pantalla.

Bueno esto ha sido todo por hoy.

Saludos...

Matias

www.matydeveloper.com.ar

Anotador de Truco (J2ME)

2010-08-03T19:59:00.000-07:00

Buenas gente.

Hoy les traigo otra aplicación desarrollada en J2ME (Java ME), que es compatible con casi todos los celulares del mercado.

Descripcion: Seguramente si estan aqui es porque mas de una vez se juntaron entre amigos y se pusieron a jugar al tan famoso juego de cartas, el Truco. Y como nunca hay a mano algo para anotar agarraron el celular y empezaron a anotar ahi. Por este motivo les desarrolle esta aplicacion muy util, un simple contador, que te resolvera ese problema de no tener donde anotar.

Visitar web de Anotador de Truco!

Saludos...
Maty.

Dibujando en Canvas 2

2010-07-30T09:28:00.000-07:00

Hola. Hoy seguiremos mostrando cuales son las demás primitivas gráficas para dibujar.

1 - Ya tenemos nuestra clase que hereda de Canvas y por supuesto nuestro MIDlet:

import java.io.IOException;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public class Dibujando extends Canvas {

    Image imagen;

    public Dibujando() {
        try {
            imagen = Image.createImage("/book.png");
        } catch (IOException ex) {
        }
    }

    protected void paint(Graphics g) {
       
    }

}

2 - Como pueden ver en nuestro código hemos creado una imagen para después poder pintarla en pantalla:

Creamos una atributo de tipo Image donde se almacenara la imagen en memoria.
Dentro del constructor de nuestra clase abrimos la imagen para esto, desde la clase Image tenemos un método:

Image.createImage("/book.png")

Este método recibe como parámetro un String que seria la ruta de la imagen, como nuestra imagen esta en la carpeta raíz del proyecto ponemos "/" si la imagen estaría en la carpeta res seria: "/res/book.png".

Esta instrucción debe ir en un bloque try-catch, ya que esto puede generar un error al no poder encontrar o abrir la imagen.

3 - Ya tenemos nuestra clase y la imagen abierta, empecemos a dibujar:

// Pintamos todo el fondo de Blanco
g.setColor(0xFFFFFF);
g.fillRect(0, 0, getWidth(), getHeight());

Hemos pintado todo el fondo de la pantalla de blanco. Esto se hace porque en algunos teléfonos, el fondo no se pinta solo y nos dejara lo ultimo que teníamos en pantalla.

4 - Seteamos el color que utilizaremos para dibujar:

// Ponemos el color en Negro
g.setColor(0x000000);

Así sencillo podemos cambiar de color en cualquier momento.

5 - Dibujando nuestro primer circulo sin relleno:

// Dibujando un Circulo sin Relleno
g.drawArc(10, 10, 50, 50, 0, 360);

Este método recibe los mismo parámetros que el fillArc que nos permite dibujar círculos rellenos.

* int x : Coordenada X donde empezar a dibujar el circulo.
* int y: Coordenada Y donde empezar a dibujar el circulo.
* int width: Tamaño de ancho del circulo.
* int height: Tamaño de alto del circulo.
* int startAngle: El angulo donde comenzara el circulo.
* int arcAngle: El total hasta donde llegara el circulo.

6 - Dibujamos nuestra imagen:

g.drawImage(imagen, 30, 30, Graphics.TOP | Graphics.LEFT);

* Image imagen : Imagen que dibujaremos.
* int x : Coordenada X donde empezar a dibujar.
* int y : Coordenada Y donde empezar a dibujar.
* int anchor : Como se dibujara la imagen.

7 - Dibujar una linea

g.drawLine(60, 60, 60, 120);

* int x1 : Coordenada X del punto 1.
* int y1 : Coordenada Y del punto 1.
* int x2 : Coordenada X del punto 2.
* int y2 : Coordenada Y del punto 2.

Aquí se unirán esos dos puntos para formar la linea.

8 - Rectangulo sin relleno.

g.drawRect(70, 10, 50, 50);

* int x : Punto del ancho de la pantalla donde empezara a dibujar el rectángulo.
* int y: Punto del alto de la pantalla donde empezara a dibujar el rectángulo.
* int width: Tamaño de ancho del rectángulo.
* int height: Tamaño de alto del rectángulo.

9 - Dibujando Texto.

g.drawString("Java ME", 30, 122, Graphics.TOP | Graphics.LEFT);

* String texto : Texto que dibujaremos.
* int x : Coordenada X.
* int y : Coordenada Y.
* int anchor : Como dibujar el texto.

Y así ya tenemos casi todos los métodos que podemos utilizar para dibujar. Como pueden observar son pocos y nada muy complejos, Si quieren dibujar cosas mas avanzadas tendrán que pensar un poquito mas...

Les dejo el codigo completo:

import java.io.IOException;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public class Dibujando extends Canvas {

    Image imagen;

    public Dibujando() {
        try {
            imagen = Image.createImage("/book.png");
        } catch (IOException ex) {
        }
    }

    protected void paint(Graphics g) {
        // Pintamos todo el fondo de Blanco
        g.setColor(0xFFFFFF);
        g.fillRect(0, 0, getWidth(), getHeight());

        // Ponemos el color en Negro
        g.setColor(0x000000);

        // Dibujando un Circulo sin Relleno
        g.drawArc(10, 10, 50, 50, 0, 360);

        // Dibujando un Imagen
        g.drawImage(imagen, 30, 30, Graphics.TOP | Graphics.LEFT);

        // Dibujamos una Linea
        g.drawLine(60, 60, 60, 120);

        // Dibujamos un Rectangulo sin relleno
        g.drawRect(70, 10, 50, 50);

        // Dibujamos un String
        g.drawString("Java ME", 30, 122, Graphics.TOP | Graphics.LEFT);
    }

}

Saludos
Maty...

Dibujando en Canvas

2010-07-20T23:18:00.000-07:00

Buenas gente, hoy les mostrare como empezar a dibujar en canvas.

1 - Creamos una clase Canvas y la extendemos de Canvas:

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;

public class Dibujando extends Canvas {

    protected void paint(Graphics g) {
       
    }

}

Como ya hemos mostrado la clase Canvas obliga a crear el método paint.

2 - Ya podemos ponernos a dibujar:

// Dibujamos un Cuadrado
g.fillRect(10, 10, 100, 100);
// Dibujamos un Rectangulo
g.fillRect(120, 120, 200, 50);

Con el método fillRect dibujamos rectángulos, recibe como parámetros:

* int x : Punto del ancho de la pantalla donde empezara a dibujar el rectángulo.
* int y: Punto del alto de la pantalla donde empezara a dibujar el rectángulo.
* int width: Tamaño de ancho del rectángulo.
* int height: Tamaño de alto del rectángulo.

// Dibujamos un Cuadrado con bordes redondeados
g.fillRoundRect(10, 10, 100, 100, 20, 20);
// Dibujamos un Rectangulo con bordes redondeados
g.fillRoundRect(50, 120, 150, 50, 10, 20);

Para dibujar rectángulos con bordes redondeados usamos fillRoundRect:

* int x : Punto del ancho de la pantalla donde empezara a dibujar el rectángulo.

* int y: Punto del alto de la pantalla donde empezara a dibujar el rectángulo.

* int width: Tamaño de ancho del rectángulo.

* int height: Tamaño de alto del rectángulo.

* int arcWidth: Tamaño del redondeo horizontal

* int arcHeight: Tamaño del redondeo vertical

// Dibujando un Triangulo
g.fillTriangle(150, 10, 100, 60, 200, 60);

Aquí dibujamos un triangulo:

* int x1 : La coordenada X del primer vértice.
* int y1 : La coordenada Y del primer vértice.

* int x2 : La coordenada X del segundo vértice.

* int y2 : La coordenada Y del segundo vértice.

* int x3 : La coordenada X del tercer vértice.

* int y3 : La coordenada Y del tercer vértice.

// Dibujando un Circulo
g.fillArc(10, 10, 90, 90, 0, 360);
// Dibujando medio circulo
g.fillArc(110, 10, 80, 80, 0, 180);
// Dibujando un Pac-Man
g.fillArc(10, 110, 90, 90, 45, 315);

Con el método fillArc podremos dibujar círculos.

* int x : Coordenada X donde empezar a dibujar el circulo.

* int y: Coordenada Y donde empezar a dibujar el circulo.

* int width: Tamaño de ancho del circulo.

* int height: Tamaño de alto del circulo.

* int startAngle: El angulo donde comenzara el circulo.

* int arcAngle: El total hasta donde llegara el circulo.

Como verán es muy sencillo dibujar, en la próxima les sigo mostrando que mas podremos hacer con Canvas.

Saludos...
Maty!

Juego para Java ME(J2ME): Ta-Te-Ti

2010-07-16T10:00:00.000-07:00

Buenas, aquí les presento mi primer juego Mobile. Si un Ta-Te-Ti. ¿Ustedes se preguntaran porque un juego tan simple como este?, la respuesta es muy simple, he descargado varios juegos de Ta-Te-Ti y todos tenían pésimos gráficos, entonces cree el mio un poco mas lindo.

Esta es la primer versión y solo dispone la versión de jugar Humano Vs Humano. En la siguiente versión se incluirá el Juego Vs Computer, con varios niveles de dificultad.

Recomendado para resolución: 240 x 320.

Descargar Ta-Te-Ti v1.0.0

Acepto cualquier sugerencia y opiniones para mejorar el juego.

Imágenes:

Escuchar los cambios en un Formulario

2010-07-08T19:12:00.000-07:00

Hola, ayer un usuario le surgió la duda de como modificar un TextField desde la opción que se elija de un ChoiceGroup y aquí les dejo un pequeño tuto que muestra como realizar cambios a partir de cambios que sufra el formulario, como por ejemplo: el usuario elije una opción de un ChoiceGroup, el usuario escribe en un TextField y cualquier otro cambio que el usuario produzca sobre el formulario.

1- Creamos nuestro MIDlet y creamos un Formulario:

public class InicioMidlet extends MIDlet {
    Display pantalla;
    Form formulario;
    boolean inicio = false;

    public void startApp() {
        if(!inicio){
            pantalla = Display.getDisplay(this);
            inicio = true;

            formulario = new Form("Mi Formulario");
        }

        pantalla.setCurrent(formulario);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

}

2 - Ahora creamos los items del Formulario, en este caso un TextField y un ChoiceGroup:

// choice y text, están declarados como atributos



choice = new ChoiceGroup("Choice:", ChoiceGroup.EXCLUSIVE);
choice.append("Opcion A", null);
choice.append("Opcion B", null);
choice.append("Opcion C", null);

text = new TextField("Texto:", "", 30, TextField.ANY);

3 - Agregamos estos items al formulario:

formulario.append(text);
formulario.append(choice);

4 - Para poder escuchar los cambios en el formulario, nuestra clase debe implementar la interface: ItemStateListener, así que la implementamos en nuestra clase MIDlet:

public class InicioMidlet extends MIDlet implements ItemStateListener {

5 - Al implementar ItemStateListener, deberemos crear el método: itemStateChanged

public void itemStateChanged(Item item) {

}

6 - Ahora le agregamos al formulario que nuestra clase escuchara estos cambios:

formulario.setItemStateListener(this);

7 - Ya tenemos nuestro formulario capaz de escuchar todos los cambios que se produzcan. Si se elije una opción en el ChoiceGroup agregamos un texto predeterminado al TextField entonces:

// Si el item que cambio fue el ChoiceGroup

if(item == choice){

            // Segun el item seleccionado en el ChoiceGroup agregamos el texto
            switch(choice.getSelectedIndex()){
                case 0:
                    // Si eligió la opcion A escribimos "Lola" en el TextField
                    text.setString("lola");
                    break;
                case 1:
                     // Si eligió la opcion B escribimos "mono" en el TextField
                    text.setString("mono");
                    break;
                case 2:
                     // Si eligió la opcion C escribimos "caso" en el TextField
                    text.setString("caso");
                    break;
            }
        }

8 - Así podemos escuchar los distintos cambios que se producen en un Formulario. Cualquier duda que tuvieran pueden dejarla aquí o directamente en el Grupo de Java ME.

Codigo Completo:

public class InicioMidlet extends MIDlet implements ItemStateListener {
    Display pantalla;
    Form formulario;
    ChoiceGroup choice;
    TextField text;
    boolean inicio = false;

    public void startApp() {
        if(!inicio){
            pantalla = Display.getDisplay(this);
            inicio = true;

            choice = new ChoiceGroup("Choice:", ChoiceGroup.EXCLUSIVE);
            choice.append("Opcion A", null);
            choice.append("Opcion B", null);
            choice.append("Opcion C", null);

            text = new TextField("Texto:", "", 30, TextField.ANY);

            formulario = new Form("Mi Formulario");
            formulario.setItemStateListener(this);
            formulario.append(text);
            formulario.append(choice);
        }

        pantalla.setCurrent(formulario);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void itemStateChanged(Item item) {
        if(item == choice){
            switch(choice.getSelectedIndex()){
                case 0:
                    text.setString("lola");
                    break;
                case 1:
                    text.setString("mono");
                    break;
                case 2:
                    text.setString("caso");
                    break;
            }
        }
    }

}

Saludos...
Maty!

Degradado para Java Me

2010-07-05T13:30:00.000-07:00

Hola gente. Aquí les traigo una clase para puedan dibujar degradados en Java ME. Puedes descargarla haciendo clic aquí. Igual mas abajo les dejo el código.

Con esta clase podrán crear degradados en Canvas, la clase Degradado dispone de un método estático llamado pintar. que recibe como parámetros:

* Graphics g : El objeto que se necesita para dibujar
* int Color 1 : El color inicial del degradado
* int Color 2 : El color final del degradado
* int x : Punto desde donde comenzara el degradado
* int y : Punto desde donde comenzara el degradado
* int ancho : El total del ancho del degradado
* int alto : El Alto del degradado
* int orientación : La orientación del degradado, puede ser Degradado.HORIZONTAL o Degradado.VERTICAL

les dejo unos ejemplos:

// Ejemplo 1 - Toda la pantalla de Blanco a Negro
Degradado.pintar(g, 0xFFFFFF, 0x000000, 0, 0, getWidth(), getHeight(), Degradado.HORIZONTAL);
// Ejemplo 2 - Toda la pantalla de Rojo a Negro
Degradado.pintar(g, 0xFF0000, 0x000000, 0, 0, getWidth(), getHeight(), Degradado.VERTICAL);
// Ejemplo 3 - Un cuadrado de 100x100 de Verde a Azul
Degradado.pintar(g, 0x00FF00, 0x0000FF, 10, 10, 100, 100, Degradado.HORIZONTAL);
// Ejemplo 4 - Un cuadrado de 100x100 dibujado en la mitad de la pantalla
Degradado.pintar(g, 0x0000FF, 0xFFFFFF, getWidth()/2-50, getHeight()/2-50, 100, 100, Degradado.VERTICAL);

Esta clase es muy útil si quieren darle un mejor aspecto a su aplicación o juego en Java ME. Esta clase ha sido obtenida de Forum Nokia. Yo solo la he traducido.

Código:

import javax.microedition.lcdui.Graphics;

public class Degradado {
    public static final int HORIZONTAL = 0;
    public static final int VERTICAL = 1;

    public static void pintar(Graphics g, int color1, int color2, int x, int y, int ancho, int alto, int orientacion){
        int max;
        if(orientacion == HORIZONTAL){
            max = ancho;
        }else{
            max = alto;
        }

        for (int i = 0; i < max; i++) {
            int color = midColor(color1, color2, max * (max - 1 - i) / (max - 1), max);
            g.setColor(color);

            if(orientacion == HORIZONTAL){
                g.drawLine(x + i, y, x + i, y + alto - 1);
            }else{
                g.drawLine(x, y + i, x + ancho - 1, y + i);
            }
        }
    }

    protected static int midColor(int color1, int color2, int prop, int max) {
        int red =
                (((color1 >> 16) & 0xff) * prop
                + ((color2 >> 16) & 0xff) * (max - prop)) / max;

        int green =
                (((color1 >> 8) & 0xff) * prop
                + ((color2 >> 8) & 0xff) * (max - prop)) / max;

        int blue =
                (((color1 >> 0) & 0xff) * prop
                + ((color2 >> 0) & 0xff) * (max - prop)) / max;

        int color = red << 16 | green << 8 | blue;

        return color;
    }
}

Saludos...
Maty!

Hola Mundo en Canvas

2010-07-01T20:11:00.000-07:00

Buenas, después de varios días sin actualizar, disculpen fueron días de parciales y no tuve mucho tiempo para poder escribirles...

Hoy les mostrare como iniciar su proyecto a bajo nivel, la forma de crear todo por nosotros mismos.

1 - Primero creamos un proyecto, y creamos un MIDlet vació.

2 - Creamos una Nueva clase de java:

public class CanvasHolaMundo {

}

3 - Hacemos que nuestra clase herede (extends) de Canvas:

public class CanvasHolaMundo extends Canvas {

}

Deberán importar la librería: "import javax.microedition.lcdui.Canvas;", como logran ver solo anteponiendo la palabra "extends" y el nombre de la clase ya se logra hacer una herencia.

4 - Al heredar de Canvas esta clase nos obliga a crear un método:

public class CanvasHolaMundo extends Canvas {

    protected void paint(Graphics g) {
       
    }

}

Este método paint recibe el objeto Graphics que nos permitirá disponer de las primitivas para poder dibujar sobre nuestra pantalla.

5 - Dibujamos ahora "Hola mundo" en la mitad de nuestra pantalla:

protected void paint(Graphics g) {
        // Obtenemos el ancho de la pantalla y la dividimos para obtener la mitad
        int mitadAncho = getWidth()/2;
        // Obtenemos la mitad de alto de la pantalla
        int mitadAlto = getHeight()/2;
       
        g.drawString("Hola Mundo", mitadAncho, mitadAlto, Graphics.LEFT | Graphics.TOP);
    }

Primero obtenemos las medidas de las pantalla (getWidth() y getHeight()) y luego con la clase Graphics disponemos un método "drawString" que nos permitirá dibujar texto. Como parámetros:

a) String: El texto que queremos que se escriba
b) int: El ancho en pixeles donde se dibujara el texto
c) int: El alto en pixeles donde se dibujara el texto
d) El modo que se dibujara el texto, en este caso desde la posición que le hemos pasado el texto se dibujara de ese punto hacia la derecha y desde el punto hacia abajo.

6 - Solo nos queda mostrar nuestro Canvas por pantalla:

import javax.microedition.lcdui.Display;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseCuatroMidlet extends MIDlet {
    Display pantalla;
    CanvasHolaMundo canvas;

    public ClaseCuatroMidlet() {
        pantalla = Display.getDisplay(this);
        canvas = new CanvasHolaMundo();
    }

    public void startApp() {
        pantalla.setCurrent(canvas);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Sencillo obtenemos el Display para poner en pantalla nuestro canvas, instanciamos nuestro canvas y por ultimo lo mostramos por pantalla.

Muestra:

Por ultimo les dejo el código completo del canvas:

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;

/**
 *
 * @author matias
 */
public class CanvasHolaMundo extends Canvas {

    protected void paint(Graphics g) {
        // Obtenemos el ancho de la pantalla y la dividimos para obtener la mitad
        int mitadAncho = getWidth()/2;
        // Obtenemos la mitad de alto de la pantalla
        int mitadAlto = getHeight()/2;
        
        g.drawString("Hola Mundo", mitadAncho, mitadAlto, Graphics.LEFT | Graphics.TOP);
    }

}

Todo por hoy, Saludos desde Argentina, esperemos que este Sábado ganemos.

Maty.

Video de LWUIT

2010-06-24T09:41:00.003-07:00

Les dejo rápido un vídeo donde pueden ver el potencia de la librería mencionada anteriormente...

Saludos...

Introducción a LWUIT

2010-06-24T07:20:00.000-07:00

Buenas, hoy les presentare una libreria para Java ME, que mejora notablemente la interfaz de usuario: Lightweight UI Toolkit Library, mejor dicho LWUIT.

Primero para poder utilizar esta librería tendremos que descargarla. Hacer clic aqui para descargar.

Una vez descargada y descomprimida, en cualquier lugar. Procedemos a crear un proyecto nuevo en nuestro NetBeans. y Ingresamos a las propiedades haciendo clic derecho sobre el proyecto:

Ingresamos a Librerías y Recursos, y hacemos clic en Agregar Jar/Zip:

Y buscamos en donde descomprimimos el archivo: LWUIT.jar

Hacemos clic en aceptar y ya tendremos disponible la librería para trabajar en nuestro proyecto. Les dejo un pequeño código de muestra para que se fijen si les funciona todo bien:

import com.sun.lwuit.Command;
import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Label;
import com.sun.lwuit.animations.CommonTransitions;
import com.sun.lwuit.layouts.BorderLayout;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class HolaMundoMidlet extends MIDlet  {

    public void startApp() {
        // Iniciamos el Display
        Display.init(this);
        // Creamos el Formulario Principal
        Form mainForm = new Form("Titulo Formulario");
        // Seteamos el Layout
        mainForm.setLayout(new BorderLayout());
        // Agregamos un Label en el centro del Layout
        mainForm.addComponent(BorderLayout.CENTER, new Label("Hola Mundo"));
        // Seteamos una Animacion
        mainForm.setTransitionOutAnimator(CommonTransitions.createFade(400));
        // Agregamos un Comando
        mainForm.addCommand(new Command("Salir", 2));
        // Mostramos el Formulario
        mainForm.show();
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Saludos...
Maty

Leyendo los datos del Form

2010-06-22T12:48:00.000-07:00

Buenas, hoy continuaremos nuestro ejemplo: Trabajando con la Clase Form. Ahora le agregamos alguna funcionalidad a nuestro formulario y mostraremos como obtener los datos que el usuario ingrese.

1 - Primero crearemos un atributo de Tipo: Command

private Command guardar;

2 - Creamos nuestro Comando guardar:

guardar = new Command("Guardar", Command.OK, 0);

La clase Command recibe por parámetros:

* Titulo : El nombre del comando
* Tipo: El tipo de Comando podrás elegir entre:

Command.BACK
Command.CANCEL
Command.EXIT
Command.HELP
Command.ITEM
Command.OK
Command.SCREEN
Command.STOP

Según tu comando deberás elegir el que mas corresponda con la acción de tu comando.

3 - Ahora tendremos que agregar nuestro comando al formulario, pero primero deberemos implementar la interface de CommandListener a nuestro MIDlet para que pueda recibir los comandos que agreguemos:

public class ClaseTresMidlet extends MIDlet implements CommandListener

Al implementar esta interface nos pedirá que es necesario que nuestra clase tenga un método: commandAction, así que deberemos crearlo:

public void commandAction(Command c, Displayable d) {
       
}

4 - Ahora agregamos nuestro comando al formulario:

formulario.setCommandListener(this);
formulario.addCommand(guardar);

Con la primera linea definimos quien responderá por los comandos, en este caso sera nuestra propia clase (o MIDlet), y después en la otra linea agregamos el comando creado anteriormente.

5 - Ya teniendo agregado nuestro comando al formulario lo único que nos queda por realizar son las acciones cuando el usuario seleccione el comando, tendremos que trabajar ahora dentro del método commandAction:

if(c == guardar){
            // obtenemos lo que se escribio en el TextFIeld
            campo.getString();
            // Obtenemos la fecha que el usuario introducio
            fecha.getDate();
            // Devuelve el valor del Gauge
            volumen.getValue();
            // Devuelve el numero de item seleccionado de la lista
            lista.getSelectedIndex();
}

Entonces primero comparamos el comando ejecutado con nuestro comando, esto se realiza para saber que comando ejecuto el usuario. Si el comando "c" es igual a "guardar" entonces el usuario hizo clic en el comando guardar, y ahí adentro tendríamos que realizar lo correspondiente con los datos.

6 - Ahora creamos un comando para salir de la aplicación, primero creamos un atributo:

private Command salir;

Creamos el comando:

salir = new Command("Salir", Command.EXIT, 0);

y lo Agregamos al formulario:

formulario.addCommand(salir);

Ahora dentro del método commandAction verificaremos si se ejecuto el comando salir:

if(c == guardar){
            // obtenemos lo que se escribio en el TextFIeld
            campo.getString();
            // Obtenemos la fecha que el usuario introducio
            fecha.getDate();
            // Devuelve el valor del Gauge
            volumen.getValue();
            // Devuelve el numero de item seleccionado de la lista
            lista.getSelectedIndex();
}else if(c == salir){
            // salimos de la Aplicacion
            notifyDestroyed();
}

Codigo Completo:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseTresMidlet extends MIDlet implements CommandListener {
    private Display pantalla;
    private Form formulario;

    private ChoiceGroup lista;
    private DateField fecha;
    private Gauge volumen;
    private StringItem texto;
    private TextField campo;

    private Command guardar;
    private Command salir;

    public ClaseTresMidlet(){
        pantalla = Display.getDisplay(this);

        guardar = new Command("Guardar", Command.OK, 0);
        salir = new Command("Salir", Command.EXIT, 0);

        formulario = new Form("Mi Formulario");
        formulario.setCommandListener(this);
        formulario.addCommand(guardar);
        formulario.addCommand(salir);

        lista = new ChoiceGroup("Opciones", ChoiceGroup.EXCLUSIVE);
        lista.append("Opcion 1", null);
        lista.append("Opcion 2", null);
        lista.append("Opcion 3", null);
        lista.append("Opcion 4", null);

        fecha = new DateField("Aniversario", DateField.DATE);
        volumen = new Gauge("Volumen", true, 10, 5);
        texto = new StringItem("Mi texto", "USted esta completando nuestro formulario, Gracias");
        campo = new TextField("Nombre", "", 30, TextField.ANY);

        formulario.append(campo);
        formulario.append(lista);
        formulario.append(volumen);
        formulario.append(texto);
        formulario.append(fecha);
    }

    public void startApp() {
        pantalla.setCurrent(formulario);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable d) {
        if(c == guardar){
            // obtenemos lo que se escribio en el TextFIeld
            campo.getString();
            // Obtenemos la fecha que el usuario introducio
            fecha.getDate();
            // Devuelve el valor del Gauge
            volumen.getValue();
            // Devuelve el numero de item seleccionado de la lista
            lista.getSelectedIndex();
        }else if(c == salir){
            // salimos de la Aplicacion
            notifyDestroyed();
        }
    }
}

Y así podemos obtener los datos que el usuario introduce en el formulario.

Seguiremos con mas tutoriales...

Saludos
Maty!

Grupo Java ME

2010-06-18T12:40:00.000-07:00

Buenas Gente!

Quería comentarles que he abierto un grupo de Java ME, para que si tienen alguna duda, comentarla ahí y tratare de ayudarlos...

Visitar y Participar del Grupo Java ME

Saludos...
Maty!

Trabajando con la Clase Form

2010-06-16T14:55:00.000-07:00

Buenas, Hoy participe de un webinar de Nokia con Maximiliano Firtman (Desarrollador Mobile desde 2000), Fernando Freytes (Nokia Argentina) y Robert (de Forum Nokia Internacional). Donde maxi nos comentaba que muchos consideraban a Java ME una plataforma muerta, porque ya hace mas de 10 años que se encuentra en el mercado, pero ¿ podemos considerar muerta a una plataforma que tiene soporte en mas de mil millones de móviles en el mercado actualmente ?

Sin dudarlo si quieres que tu aplicación se encuentre para la mayor cantidad posible de móviles, tendrás que utilizar Java ME ;)

Así que hoy veremos como usar la clase Form.

1 - Como siempre lo primero que haremos es crear nuestro MIDlet, y obtener nuestro objeto pantalla:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseTresMidlet extends MIDlet {
    private Display pantalla;

    public ClaseTresMidlet(){
        pantalla = Display.getDisplay(this);
    }

    public void startApp() {
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

2 - Primero creamos un atributo de tipo Form:

private Display pantalla;
private Form formulario;

3 - ahora dentro de nuestro Constructor, crearemos nuestro formulario:

formulario = new Form("Mi Formulario");

La Clase Form tiene 2 constructores:
a) Que recibe solo el Titulo del formulario (es el que utilizaremos)
b) Ademas del titulo recibe un array de Items.

Ahora les dejare un pequeña introducción de todos los Items que podemos crear para agregar dentro del formulario:

* ChoiceGroup = Una lista igual que las listas Exclusivas y PopUp, que vimos en entradas anteriores.
* DateField = Un campo para ingresar una fecha
* Gauge = Un slider.
* ImageItem = Podemos también agregar imágenes dentro de nuestro formulario.
* StringItem = Un texto.
* TextField = Un campo para ingresar texto. Identico al TextBox pero este se puede agregar al formulario.

4 - Bueno ahora iremos creando uno de cada uno para mostrarles como se crea cada uno, acuérdate que cada elemento que crearemos, primero crearemos un atributo.

lista = new ChoiceGroup("Opciones", ChoiceGroup.EXCLUSIVE);
lista.append("Opcion 1", null);
lista.append("Opcion 2", null);
lista.append("Opcion 3", null);
lista.append("Opcion 4", null);

El primer item que hemos creado a sido una lista, como ven es idéntico al List. El ChoiceGroup recibe como parámetro el Titulo y el Tipo de Lista (Exclusive, Multiple, PopUp). Y para agregar opciones a la lista tenemos el método "append" que recibe el texto y una imagen, que como no queremos usar imágenes, dejamos el campo en null.

Ahora creamos un DateField:

fecha = new DateField("Aniversario", DateField.DATE);

El DateField recibe como parámetros:

* Titulo = String
* Tipo de Fecha, que podremos usar: DateField.DATE (Dia, Mes, Año). DateField.DATE_TIME (Dia, Mes, Año, Hora y Minutos) y DateField.TIME (Hora y minutos).

Procedemos a crear un Slider (Gauge):

volumen = new Gauge("Volumen", true, 10, 5);

Parámetros que recibe el Gauge:

* Titulo del item (String)
* Si nuestro control sera interactivo (True) o si solo se mostrara sin poder modificarse (False).
* El valor máximo permitido.
* El valor inicial, en donde se encontrara posicionado al momento de crearse.

Nos toca la hora de crear un StringItem:

texto = new StringItem("Mi texto", "USted esta completando nuestro formulario, Gracias");

Muy sencillo, nuestro StringItem recibe como parámetro un titulo y el texto que se mostrara.

Por ultimo creamos un TextField:

campo = new TextField("Nombre", "", 30, TextField.ANY);

Lo detallamos rápido ya que es idéntico al TextBox. Puedes leer nuestro post anterior si todavía no lo has leído ;).
Primero el titulo de nuestro Campo para introducir texto, el segundo parámetro es un valor predefinido, normalmente no se pone nada, es un poco molesto para el usuario tener que borrar lo que halla escrito para empezar a introducir texto. Después el total de Caracteres y por ultimo el tipo de caracteres que se permitirá. ( Mas info leer nuestro post: Comenzando con Java ME)

La imagen la dejamos, para un futuro post, así vemos como se trabaja con las imágenes en Java Me.

5 - Nuestro próximo paso sera agregar todos estos items a nuestro formulario:

formulario.append(campo);
formulario.append(lista);
formulario.append(volumen);
formulario.append(texto);
formulario.append(fecha);

Así de sencillo nuestro formulario tiene un método "append" para agregar los items.

6 - Ahora dentro de nuestro método startApp mostraremos este formulario:

pantalla.setCurrent(formulario);

Esto ha sido todo por hoy, la próxima les mostrare como poder obtener los datos ingresados por el usuario y como interactuar con ellos.

Les dejo el Código Completo:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseTresMidlet extends MIDlet {
    private Display pantalla;
    private Form formulario;

    private ChoiceGroup lista;
    private DateField fecha;
    private Gauge volumen;
    private StringItem texto;
    private TextField campo;

    public ClaseTresMidlet(){
        pantalla = Display.getDisplay(this);

        formulario = new Form("Mi Formulario");

        lista = new ChoiceGroup("Opciones", ChoiceGroup.EXCLUSIVE);
        lista.append("Opcion 1", null);
        lista.append("Opcion 2", null);
        lista.append("Opcion 3", null);
        lista.append("Opcion 4", null);

        fecha = new DateField("Aniversario", DateField.DATE);
        volumen = new Gauge("Volumen", true, 10, 5);
        texto = new StringItem("Mi texto", "USted esta completando nuestro formulario, Gracias");
        campo = new TextField("Nombre", "", 30, TextField.ANY);

        formulario.append(campo);
        formulario.append(lista);
        formulario.append(volumen);
        formulario.append(texto);
        formulario.append(fecha);
    }

    public void startApp() {
        pantalla.setCurrent(formulario);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Saludos
Maty...

Creando un Menú Principal

2010-06-12T08:22:00.000-07:00

Hoy un ejemplo de como crear un menú principal donde el usuario podrá navegar desde allí.

Lo primero es crear nuestro MIDlet, si todavía no conoces esto, te recomiendo que visites: Hola Mundo con Java ME y Comenzando con Java ME.

1 - Como toda aplicación en Java Me, primero creamos un atributo, Display y obtenemos la pantalla:

Display pantalla;
   
    public void startApp() {
        pantalla = Display.getDisplay(this);
    }

2 - Ahora creamos un atributo List y creamos una Lista Implicita:

Display pantalla;
    List menu;
   
    public void startApp() {
        pantalla = Display.getDisplay(this);
       
        menu = new List("Menu Principal", List.IMPLICIT);
    }

3 - Nos toca el turno de agregar los elementos a la lista, que serán nuestros items del menú Principal y mostrar este menú por pantalla:

menu = new List("Menu Principal", List.IMPLICIT);
menu.append("Iniciar Juego", null);
menu.append("Cargar Partida", null);
menu.append("Configuraciones", null);
menu.append("Ayuda", null);
menu.append("Salir", null);

pantalla.setCurrent(menu);

4 - Ya tenemos nuestro menú principal creado, pero todavía no tiene ninguna interacción, tendremos que obtener de alguna manera, el evento cuando el usuario hace clic en algún item del menú, para realizar esto debemos decirle al menú que intercepte este evento, esto lo hacemos:

menu.setCommandListener(this);

Este método configurara la clase que manejara este evento, normalmente se pone que la misma clase maneje el evento, pero podrían hacer que cualquier clase lo realice.

5 - Pero al escribir esa linea nos tirara error, es porque la clase para manejar eventos debe implementar la interface: CommandListener:

public class ClaseDosMidlet extends MIDlet implements CommandListener {

}

Solo debemos agregar implements, que se utiliza para implementar interfaces y el nombre de la clase que maneja el evento.

6 - Todavía siguen apareciendo errores, esto se debe a que a implementar una interface, esta contiene métodos obligatorios que debemos escribir, así que escribimos el siguiente método:

public void commandAction(Command c, Displayable d) {
       
}

Este metodo recibe por parametros:

* Command c : devuelve el comando que ha sido ejecutado.
* Displayable d : devuelve el objeto que se encontraba en pantalla en el momento que se realizo el evento.

7 - Así que dentro de commandAction, debemos primero preguntar si cuando se realizo el evento fue desde el menú, solo hacemos un if comparando el parámetro Displayable con nuestro menú. Y dentro de el un switch del menú y según que opción selecciono el usuario realizara lo que corresponda:

public void commandAction(Command c, Displayable d) {
        if(menu == d){
            switch(menu.getSelectedIndex()){
                case 0:
                    // Iniciar Juego
                    break;
                case 1:
                    // Cargar Partidas
                    break;
                case 2:
                    List nivel = new List("Elegir nivel", List.EXCLUSIVE);
                    nivel.append("Nivel 1", null);
                    nivel.append("Nivel 2", null);
                    nivel.append("Nivel 3", null);
                    nivel.append("Nivel 4", null);
                    nivel.append("Nivel 5", null);

                    pantalla.setCurrent(nivel);
                    break;
                case 3:
                    // Ayuda
                    break;
                case 4:
                    // Salimos de la Aplicacion
                    notifyDestroyed();
                    break;
            }
        }
    }

como pueden observar el switch, se realiza del case 0 al case 4, porque en nuestro menú solo existen 5 elementos, así que eso depende de la cantidad de opciones en el menú.
Dentro de cada Case, podemos hacer lo que sea, aquí le dejamos un pequeño ejemplo de como mostrar otro menú para seleccionar el nivel.

8 - Pero hay un problema al entrar a la opción Configuraciones que nos muestra el menú para elegir el nivel, no podemos volver al menú principal, así que lo primero sera crear un atributo:

Command volver;

Y dentro de startApp(): creamos nuestro comando volver:

volver = new Command("Volver", Command.BACK, 0);

La clase Command recibe por parámetro:

* Titulo : El titulo del comando
* Tipo: El tipo de Comando, se pueden elegir:

Command.BACK
Command.CANCEL
Command.EXIT
Command.HELP
Command.ITEM
Command.OK
Command.SCREEN
Command.STOP

* Prioridad : el nivel de prioridad

Nos queda setear a la lista nivel que se manejen los eventos y agregar nuestro comando volver:

nivel.setCommandListener(this);
nivel.addCommand(volver);

Desde ahora nuestro lista nivel, mostrara por pantalla el comando volver, pero todavía no realiza ninguna acción.

9 - Vamos a darle una acción al comando volver, nos dirigimos al método commandAction: y comparamos si el comando que se presiono es el comando volver:

if(volver == c){
      pantalla.setCurrent(menu);
}

Si el comando que se presiono es igual al comando volver, entonces volvemos a mostrar el menú principal.

Y así pudimos crear nuestro menú principal y manejar sus eventos.

Codigo Completo:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseDosMidlet extends MIDlet implements CommandListener {
    Display pantalla;
    List menu;
    Command volver;

    public void startApp() {
        pantalla = Display.getDisplay(this);

        volver = new Command("Volver", Command.BACK, 0);

        menu = new List("Menu Principal", List.IMPLICIT);
        menu.append("Iniciar Juego", null);
        menu.append("Cargar Partida", null);
        menu.append("Configuraciones", null);
        menu.append("Ayuda", null);
        menu.append("Salir", null);
       
        menu.setCommandListener(this);

        pantalla.setCurrent(menu);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable d) {
        if(volver == c){
            pantalla.setCurrent(menu);
        }else if(menu == d){
            switch(menu.getSelectedIndex()){
                case 0:
                    // Iniciar Juego
                    break;
                case 1:
                    // Cargar Partidas
                    break;
                case 2:
                    List nivel = new List("Elegir nivel", List.EXCLUSIVE);
                    nivel.append("Nivel 1", null);
                    nivel.append("Nivel 2", null);
                    nivel.append("Nivel 3", null);
                    nivel.append("Nivel 4", null);
                    nivel.append("Nivel 5", null);

                    nivel.setCommandListener(this);
                    nivel.addCommand(volver);

                    pantalla.setCurrent(nivel);
                    break;
                case 3:
                    // Ayuda
                    break;
                case 4:
                    // Salimos de la Aplicacion
                    notifyDestroyed();
                    break;
            }
        }
    }
}

Saludos...
Maty!

Comenzando con Java ME

2010-06-08T09:26:00.000-07:00

Hola gente!

Hoy les mostrare como crear Alertas, Listas y Cuadros de Textos.

1 - Abrimos NetBeans y creamos un Proyecto Nuevo: Mobile Application y MIDP 2.0.
Si tienen dudas de como crear un proyecto nuevo, visiten: Hola Mundo con Java ME

2 - Creamos un Nuevo MIDlet.

3 - Se nos creara el Codigo:

import javax.microedition.midlet.*;

/**
 * @author matias
 */
public class ClaseUnoMidlet extends MIDlet {
    public void startApp() {
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

4 - Lo primero que deberemos hacer es obtener nuestro Objeto Pantalla (Display) para poder poner en pantalla nuestros Objetos, en este caso las Alertas, Listas y Cuadros de Textos. Así que solo escribimos la siguiente linea: (dentro del método startApp(), en este caso todo el código sera escrito dentro de este método.)

Display pantalla = Display.getDisplay(this);

5 - Nos tirara un error eso porque no importamos las librerías así que para no tener que agregar cada librería una por una agregamos la siguiente:

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

6 - Ahora creamos primero nuestra Alerta:

Alert alerta = new Alert("Mi Alerta", "Mensaje de la Alerta", null, AlertType.CONFIRMATION)

Así de sencillo creamos una Alerta, Descripción de los parámetros que recibe la clase Alert:

a) Titulo de la alerta (String)
b) Mensaje de la Alerta (String)
c) Una Imagen, por el momento no trabajaremos con imágenes mas adelante les explicare la Clase Image (Image)
d) Tipo de la Alerta:

AlertType.CONFIRMATION : "Cuando se realizo una operación."
AlertType.ALARM : "Cuando se le avisa al usuario sobre un evento"
AlertType.ERROR : "Se ha producido un error"
AlertType.INFO : "Avisos mostrando información"
AlertType.WARNING : "Aviso para una acción peligrosa, Ejemplo: Esta por borrar todos los Contactos"

Estos son los únicos tipos de alertas que se pueden definir.

7 - Ahora ponemos la Alerta en la pantalla:

pantalla.setCurrent(alerta);

Así de sencillo podemos mostrar Objetos por pantalla, siempre y cuando esos objetos hallan heredado de la Clase Displayable.

8 - Ahora crearemos nuestro Cuadro de Textos (TextBox):

TextBox texto = new TextBox("Nombre", "", 32, TextField.ANY);

Parámetros de TextBox:

a) Titulo del TextBox (String)
b) Valor por defecto dentro del cuadro de texto, por defecto se deja vacio: "", pero si quieres que el cuadro de texto ya tenga un texto escrito lo ingresas ahi (String)
c) La cantidad máxima de caracteres que permite (int)
d) el Tipo de caracteres que permite:

TextField.ANY : Permite todos los caracteres
TextField.DECIMAL : Solo números decimales
TextField.EMAILADDR : Permite solo direcciones de Email
TextField.NUMERIC : Solo números del 0 al 9
TextField.PHONENUMBER : Permite los caracteres para escribir números de teléfono
TextField.URL : Solo direcciones web
TextField.PASSWORD : Oculta los caracteres con asteriscos

Estos tipos se pueden combinar por ejemplo:

TextBox texto = new TextBox("Nombre", "", 32, TextField.NUMERIC | TextField.PASSWORD);

Solo deberán concatenar los Tipos con " | ";

9 - Reemplazamos la alerta por el TextBox:

pantalla.setCurrent(texto);

Esto nos quedara algo asi:

10 - Nos queda ahora crear Listas:

List lista = new List("Mi Lista", List.IMPLICIT);

Parámetros de las Listas:

a) Titulo de la lista (String)
b) Tipo de Lista:

List.IMPLICIT : Listas tipo Menú
List.EXCLUSIVE : Listas que solo se puede elegir una Opción (El equivalente a botones de Radio)
List.MULTIPLE : Listas que permite seleccionar múltiples opciones (Equivalente a CheckBoxs)

Para agregar items a nuestra lista debemos hacerlo a través del método Append:

lista.append("Opcion 1", null);

El primer parámetro recibe el Nombre del Item, y el segundo recibe una Imagen como no trabajamos se deja en Null.
Entonces nuestro codigo quedara:

List lista = new List("Mi Lista", List.MULTIPLE);
lista.append("Opcion 1", null);
lista.append("Opcion 2", null);
lista.append("Opcion 3", null);
lista.append("Opcion 4", null);
lista.append("Opcion 5", null);

Esto se vera así:

Listas Implícitas:

Listas Exclusivas:

Listas Múltiples:

Esto ha sido todo por hoy, seguiré trayéndote tutoriales para Java Me...

Saludos
Maty.

GastosMax - Mi Primera Aplicacion Jave ME

2010-06-05T12:03:00.000-07:00

Buenas hoy les presentare mi primera aplicación hecha en Java ME, que es soportada para la mayoría de los celulares del mercado.

GastosMax es una simple aplicación con la que puedes llevar un simple detalle de todos tus gastos.

Tendras un listado de todos tus gastos y el total de todo lo que llevas gastando.

Descargar GastosMax v1.0.0

Aceptamos cualquier sugerencia y opiniones para mejorar la aplicación ;).

Imágenes:

Hola Mundo con Java ME

2010-06-01T12:00:00.000-07:00

Buenas... Hoy un pequeño tutorial para comenzar con NetBeans y observar como crear nuestra primer aplicación con JAVA ME.

1 - Abrimos NetBeans

2 - Vamos a Archivo -> Proyecto Nuevo (Ctrl + Mayus + N)

3 - Creamos un Proyecto de Tipo: Java ME -> Mobile Application y hacemos clic en Siguiente.

4 - Aqui definimos el Nombre de nuestro Proyecto y la ubicacion. Proyect Name (Nombre del Proyecto).

Y dejamos solo la casilla seleccionada de Set as Main Project.

* Set as Main Project: El proyecto se fija como Principal
* Create Hello MIDlet: Seleccionando esta casilla nos creara automáticamente un Hola Mundo, pero esta clase tendrá muchos componentes que por el momento no es necesario que lo sepan, además de tener mucho código y ya asustarlos de una xD.

Hacemos clic en Siguiente.

5 - En este paso podremos elegir el Emulador con que probaremos nuestra aplicación y las configuraciones de la Aplicacion. Es recomendable seleccionar CLDC-1.1 y MIDP-2.0 ya que son los estándares que soportan la mayoría de los celulares del mercado.

Y aqui ya hacemos clic en Terminar.

6 - Hacemos clic en Source Packages con el botón derecho: Nuevo -> MIDlet

7 - Aqui configuramos nuestro MIDlet:

* MIDlet Name: Nombre de nuestra Aplicacion
* MIDlet Class Name: Nombre de la Clase de nuestra aplicación, atención no puede tener espacios.
* MIDlet Icon: Icono de nuestra aplicacion, por el momento lo dejamos en blanco.

y hacemos clic en Terminar.

8 - Ya tenemos nuestra Clase creada. Nuestra clase extiende (es hija) de MIDlet, toda aplicación en Java ME debe heredar de MIDlet.

Se encontraran con 3 Métodos/Funciones ya predefinidas, estos metodos son necesarios para el fundamiento de la aplicación:

* startApp() : La aplicacion iniciara desde este metodo.
* pauseApp() : Cuando la aplicación es temporalmente detenida, por ejemplo por la recepcion de una llamada. Se llama a este método
* destroyApp() : Cuando la aplicacion se cierra.

9 - Escribimos la siguiente linea:

Display pantalla = Display.getDisplay(this);

NetBeans nos marcara un error en esta linea, si hacemos clic en la lamparita nos dira las posibles soluciones al problema. Y hacemos clic en Añadir "import" a javax.microedition.lcdui.Display;

Así nos agrega las clases necesarias para poder usar la clase Display.

Display: Es una clase que representa la pantalla del celular. En nuestra linea reservamos un lugar en la memoria (Display pantalla;) y asignamos a ese espacio el objeto pantalla existente.

Con nuestro objeto pantalla podremos especificar que mostrar por pantalla.

10 - El objeto pantalla para poder mostrar algo contiene un metodo:

pantalla.setCurrent(Displayable objeto);

Que recibe como parámetro un objeto de tipo "Displayable", que sera el objeto a mostrar en pantalla.

Asi que primero debemos crear un objeto para poder mostrar en pantalla:

Alert alerta = new Alert(
                "Hola Mundo", 
                "Este es mi primer mensaje", 
                null, 
                AlertType.CONFIRMATION);

Aqui creamos un Alerta para mostrar un mensaje, la Clase Alert recibe como parametros:

* Titulo : String
* Mensaje : String
* Imagen : Imagen|null
* Tipo de Alerta : AlertType

Al escribir esta linea de código, NetBeans nos tirara error en la linea eso es porque hay que importar las librerías necesarias, hacen de nuevo clic en la lamparita y solucionan ese problema.

11 - Ahora solo nos queda mostrar esa alerta en la pantalla, eso lo haremos con:

pantalla.setCurrent(alerta);

Ya tenemos nuestro primer Hola Mundo.

El codigo deberia quedar:

12 - Ejecutamos nuestra aplicación para probar si todo ha salido bien:

* Haciendo clic con F6
* Llendo a Ejecutar -> Ejecutar Main Project
* Haciendo clic en el Boton:

13 - Se nos abrirá el Emulador, hacemos clic en Launch e iniciara nuestra aplicacion:

Espero que les halla resultado facil e util para comenzar con Java ME.

Saludos...
Maty

MOTODEV SDK for Java ME v3.0 (Emulador)

2010-05-26T19:31:00.000-07:00

Para poder probar su aplicación en los diferentes celulares, tendrás que descargar el emulador de cada empresa para verificar si la aplicación funciona en cada celular. Hoy les mostrare como hacer para descargar el Emulador de Java ME de Motorola:

1 - Ingresamos a la Web de Desarrolladores para Motorola (http://developer.motorola.com/)

2 - Pasamos el Mouse sobre "Platforms" y haces clic en Java ME:

3 - Ahora te dirigis a SDKs:

4 - Haces clic en el ultimo enlace: MOTODEV SDK for Java ME

5 - Clic en Download

6 - Por ultimo elegin la version para su Sistema Operativo y lo instalan.

Bueno eso es todo por hoy, proximamente un tutorial para agregar los emuladores a Netbeans y como usarlos...

Saludos...
Maty

Bienvenidos a Java ME

2010-05-26T15:30:00.001-07:00

Este será mi blog donde les valla dejando tutoriales para programar en Java Micro Edition (Java ME).

Para empezar a programar en Java ME, les recomendare dos IDEs: Eclipse (http://www.eclipse.org/) y Netbeans (http://netbeans.org/). Para los ejemplos yo usare Netbeans que me parece que es más fácil de usar para los que recién comienzan, ya que se encuentra en español.

Saludos

Maty.