Thursday, November 27, 2008

BAJEMOS A ECHAR UN VISTAZO


INTERFACES DE BAJO NIVEL

Bueno, en las entregas anteriores hablamos de las interfaces de alto nivel; comentábamos que estas interfaces son de las más fáciles de implementar pues su presentación gráfica queda a cargo del dispositivo en que se ejecute la aplicación.
Esto nos permite ahorrar tiempo y esfuerzo, aunque en ocasiones será necesario tomar el control de la presentación, por ejemplo: Si lo que estamos desarrollando es un videojuego.

REGLA No. 1:
Antes de comenzar, es conveniente que establecer una regla : "Todas las pantallas que vayamos a crear usando las APIs de bajo nivel heredan de la clase Canvas".

Por esta razón, lo primero de todo es conocer a fondo esta clase y luego iremos profundizando en cada uno de los elementos que la componen.
La clase Canvas es la superclase de todas las pantallas que usan las APIs de bajo nivel, al igual que Screen lo era para las pantallas que usaban las APIs de alto nivel.

CONVIVENCIA PACIFICA:
Sin embargo, en la relación de APIs de alto y bajo nivel, no hay nada escrito, ésto es : "No existe ningún impedimento que nos permita usar en el mismo MIDlet pantallas tanto derivadas de Canvas como de Screen"

La clase Canvas permite manejar eventos de bajo nivel y dibujar cualquier cosa por pantalla. Es por ésa razón que se usa como base para la realización de juegos.

Esta clase posee un método abstracto paint() que debemos implementar de manera obligatoria (Por nuestra propia voluntad) y es la encargada de dibujar en la pantalla del dispositivo.


Veamos un ejemplo para irnos familiarizando:


BajoNivel.java


import java.io.IOException;
import javax.microedition.lcdui.*;
public class BajoNivel extends Canvas implements CommandListener {
private PBajoNivel midlet;
private Command salir;
private Image imgFondo, imgTriste;
public BajoNivel(PBajoNivel mid) {
try {
imgFondo = Image.createImage("/fondo.PNG");
imgTriste = Image.createImage("/triste.PNG");
} catch (IOException e) {
e.printStackTrace();
}
salir = new Command("Salir", Command.EXIT,1);
this.midlet = mid;
this.addCommand(salir);
this.setCommandListener(this);
}
public void paint(Graphics g) {
g.setColor(255,255,255);
g.fillRect(0,0,getWidth(),getHeight());
g.setColor(0,0,0);
g.drawImage(imgFondo, 0, 0, 0);
g.drawImage(imgTriste, 40, 40, 0);
}
public void commandAction(Command c, Displayable d){
if (c == salir){
midlet.salir();
}
}
}



Esta rutina es la que nos mostrará en el dispositivo la pantalla, nótese que estamos utilizando dos imágenes fondo.PNG y triste.PNG, estos archivos los colocamos en el directorio de RES en nuestro proyecto.


Ahora veamos el código del MIDlet que lo mandará llamar.


PBajoNivel.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class PBajoNivel extends MIDlet {
private BajoNivel panCanvas;
private Display pantalla;
public PBajoNivel() throws Exception{
pantalla = Display.getDisplay(this);
panCanvas = new BajoNivel(this);
}
public void startApp() {
pantalla.setCurrent(panCanvas);
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void salir(){
destroyApp(false);
notifyDestroyed();
}
}


Como se observa, PBajoNivel.java se limita a declarar un objeto pancanvas heredado de la clase BajoNivel.


Veamos dos ejemplos de ejecutar ésta aplicación en dos modelos distintos de cellular, a fin de que el lector pueda constatar la diferencia de despliegue entre uno y el otro.












Sunday, November 23, 2008

EL RESTO DE LAS INTERFACES

En las útimas dos entregas, hemos visto el uso de dos componentes para el uso de menús, vimos la clase LIST y CHOICEGROUP; vimos que básicamente la diferencia entre ambas es que la clase LIST no está subordinada a la clase FORM; ésto es, que no es necesario crear primero un objeto tipo FORM para luego agregar el objeto LIST.



private Display display;

private List miLista;

...

display = Display.getDisplay(this);

miLista = new List("Opciones", List.IMPLICIT);
miLista.append("Altas", null);
miLista.append("Bajas", null);
miLista.append("Consultas", null);
miLista.append("Modificaciones", null);
miLista.append("Impresion", null);
...


display.setCurrent(miLista);



Mientras que un objeto CHOICEGROUP debe estar unido a un objeto FORM.



private Display miDisplay;
private Form miForma;
private ChoiceGroup miGrupo;


...

miDisplay = Display.getDisplay(this);
miForma = new Form("MENU PRINCIPAL");


...

miGrupo = new ChoiceGroup("Opciones: ", ChoiceGroup.EXCLUSIVE);
miGrupo.append("Altas", null);
miGrupo.append("Bajas", null);
miGrupo.append("Consultas", null);
miGrupo.append("Modificaciones", null);
miGrupo.append("Impresion", null);


...

miForma.append(miGrupo);

...
display.setCurrent(miLista);




Pero además de estas clases contamos con muchas otras más como...


Class Ticker

Util para mostrar mensajes en forma de una marquesina deslizándote lado a lado de la pantalla del usuario.


Class DateField

Util para manejar fechas, ya sea para despliegue o para solicitar al usuario que proporcione una fecha en específico.



Class ImageItem

Util para trabajar con archivos de imágenes en nuestra aplicación. Ya lo veremos más adelante pero con esta herramienta podremos agregarle un atractivo visual que lo haga más amigable y agradable para el usuario.


Class TextField

Util para manejar texto; que puede ser de despliegue solamente o bien, para pedir al usuario que teclee datos. Como pueden password, números, nombres, etc.



Hay que recordar que las clases gráficas de alto nivel, tienen la facilidad de que se adaptan al tipo de despliegue con que cuenta el dispositivo en el cual estamos trabajando.

En otras palabras, nosotros llamamos las clases y creamos los objetos en nuestra aplicación, pero la presentación visual queda bajo el control del hardware.



Veamos ahora, el uso de las clases que acabamos de mencionar, en un ejemplo.


import java.io.IOException;
import java.util.Date;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.DateField;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.ImageItem;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.lcdui.TextField;
import javax.microedition.lcdui.Ticker;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;



public class MIDOtros extends MIDlet implements CommandListener, ItemStateListener {
private Ticker miMarquesina;
private DateField miFecha;
private ImageItem miImagen;
private TextField miHumor;
private Image imgSerio, imgFeliz, imgTriste;
private Command Salir;
private Display miDisplay;
private Form miForma;


public MIDOtros() {
try {
imgSerio = Image.createImage("/serio.PNG");
imgFeliz = Image.createImage("/feliz.PNG");
imgTriste = Image.createImage("/triste.PNG");
} catch (IOException e) {
e.printStackTrace();
}


Date wHoy = new Date();
miDisplay = Display.getDisplay(this);
miFecha = new DateField("Dia de hoy",DateField.DATE);
miFecha.setDate(wHoy);
miHumor = new TextField("% de Animo", "50", 2, TextField.NUMERIC);
miMarquesina = new Ticker("Ejemplo de Graficos de Alto Nivel. Tutorial para el Desarrollo de aplicaciones en móviles, País México. Noviembre del 2008");
miForma = new Form("Otros Items");
Salir = new Command("Salir", Command.EXIT, 0);
miImagen = new ImageItem(null, imgSerio, 0, null);
miForma.setTicker(miMarquesina);
miForma.append(miFecha);
miForma.append(miImagen);
miForma.append(miHumor);
miForma.addCommand(Salir);
miForma.setCommandListener(this);
miForma.setItemStateListener(this);
}


protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}


protected void pauseApp() {
}


protected void startApp() throws MIDletStateChangeException {
this.miDisplay.setCurrent(this.miForma);
}


public void commandAction(Command arg0, Displayable arg1) {
if (arg0 == Salir){
try {
destroyApp(false);
} catch (MIDletStateChangeException e) {
e.printStackTrace();
}
notifyDestroyed();
}
}


public void itemStateChanged(Item arg0) {
if (arg0 == miHumor){
int wValor = Integer.parseInt(miHumor.getString());
if (wValor <> 70) {
miImagen.setImage(imgFeliz);
} else {
miImagen.setImage(imgSerio);
}
}
}
}
}




Como se observa, en esta aplicación manejamos archivos de imagen :


imgSerio = Image.createImage("/serio.PNG");
imgFeliz = Image.createImage("/feliz.PNG");
imgTriste = Image.createImage("/triste.PNG");




Que son archivos tipo PNG, este tipo nos permite manejar imágenes con una buena y razonable resolución y almacenarlos en poco espacio.
Bien, una vez compilado nuestro código; podemos ejecutarlo y verlo en acción.

Sunday, November 16, 2008

LAS OPCIONES DEL USUARIO

En el post anterior hablamos de la clase LIST en J2ME, pero contamos además con otra clase, CHOICEGROUP.

clase ChoiceGroup

public class ChoiceGroup extends Item implements Choice

Un componente ChoiceGroup es un grupo de elementos que podemos seleccionar. Es prácticamente lo mismo que el componente List, pero dentro de un formulario.

Para construir un objeto ChoiceGroup realizaremos una llamada a su constructor con los siguientes parámetros:

ChoiceGroup(String etiqueta, int tipo)
ChoiceGroup(String etiq, int tipo, String[] elementos, Image[] imagenes)
Y ahora veamos un ejemplo de cómo se utiliza esta clase dentro de una aplicación.

MIDChoiceGroup.java

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;


public class MIDChoiceGroup extends MIDlet implements CommandListener, ItemStateListener {
private Display miDisplay;
private Form miForma;
private ChoiceGroup miGrupo;
private Command Salir;

public MIDChoiceGroup() {
// TODO Auto-generated constructor stub
miDisplay = Display.getDisplay(this);
miForma = new Form("MENU PRINCIPAL");
Salir = new Command("Salir", Command.EXIT, 0);

miGrupo = new ChoiceGroup("Opciones: ", ChoiceGroup.EXCLUSIVE);
miGrupo.append("Altas", null);
miGrupo.append("Bajas", null);
miGrupo.append("Consultas", null);
miGrupo.append("Modificaciones", null);
miGrupo.append("Impresion", null);

miForma.append(miGrupo);
miForma.addCommand(Salir);
miForma.setItemStateListener(this);
miForma.setCommandListener(this);
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
// TODO Auto-generated method stub

}

protected void pauseApp() {
// TODO Auto-generated method stub

}

protected void startApp() throws MIDletStateChangeException {
// TODO Auto-generated method stub
miDisplay.setCurrent(miForma);
}
public void commandAction(Command c, Displayable s) {
// TODO Auto-generated method stub
if (c == Salir){
try {
this.destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

public void MuestraMensaje(){
Alert miAlerta = new Alert("Opcion", miGrupo.getString(miGrupo.getSelectedIndex()), null, null);
miDisplay.setCurrent(miAlerta, miForma);
}

public void itemStateChanged(Item i){
if (i == miGrupo){
this.MuestraMensaje();
}
}
}

Monday, November 10, 2008

EMPECEMOS POR LA PANTALLA

OPCIONES PARA EL USUARIO
Parte importante de toda interface de usuario, es que se pueda elegir la acción que se desea realizar. Ya sea por menús contextuales o barras en la parte superior o inferior de la pantalla; pero el usuario debe poder seleccionar la acción a realizar de entre un rango definido de tareas.
En el caso de J2ME se pueden utilizar las clases LIST y CHOICEGROUP; veamos una por una y un ejemplo para su uso correcto.
  • CLASE List

    public class List extends Screen implements Choice

    La clase List nos va a permitir construir pantallas que poseen una lista de opciones. Esto nos será muy útil para crear menús de manera independiente.
    La clase List implementa la interfaz Choice, para poder interactuar con las distintas opciones que se muestre en una lista (List).

Otra parte importante de toda interface gráfica, es la comunicación Aplicación-Usuario; en otras palabras, que la aplicación pueda comunicarse con el usuario en caso de ocurrir algún error, dar una advertencia o informar de algun suceso.

en J2ME se usa mucho la class Alert para encargarse de ésto.

  • CLASE Alert

    public class Alert extends Screen

    El objeto Alert representa una pantalla de aviso. Normalmente se usa cuando queremos avisar al usuario de una situación especial como, por ejemplo, un error.
    Un Alert está formado por un título, texto e imágenes si queremos. Vamos a ver como crear una pantalla de alerta. Para ello contamos con dos constructores:

    Alert(String titulo)
    Alert(String titulo, String textoalerta, Image imagen, AlertType tipo)

    Además podemos definir el tiempo que queremos que el aviso permanezca en pantalla, diferenciando de esta manera dos tipos de Alert:

    1. Modal: La pantalla de aviso permanece un tiempo indeterminado hasta que es cancelada por el usuario. Esto lo conseguimos invocando al método Alert.setTimeOut(Alert.FOREVER).

    2. No Modal: La pantalla de aviso permanece un tiempo definido por nosotros. Para ello indicaremos el tiempo en el método setTimeOut(tiempo). Una vez finalizado el tiempo, la pantalla de aviso se eliminará de pantalla y aparecerá el objeto Displayable que nosotros definamos.

    Podemos elegir el tipo de alerta que vamos a mostrar y cada tipo de alerta tiene asociado un sonido. Los tipos que podemos definir aparecen a continuación:

    ALARM Aviso de una petición previa
    CONFIRMATION Indica la aceptación de una acción
    ERROR Indica que ha ocurrido un error
    INFO Indica algún tipo de información
    WARNING Indica que puede ocurrir algún problema

Ahora veamos un ejemplo en acción:

MIDListas.java

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.List;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;


public class MIDListas extends MIDlet implements CommandListener {
private Command salir, acepta;
private Display display;
private List miLista;
private Alert miAlerta;

public MIDListas() {

display = Display.getDisplay(this);

salir = new Command("Salir", Command.EXIT, 2);
acepta = new Command("Aceptar", Command.OK, 1);

miLista = new List("Opciones", List.IMPLICIT);
miLista.append("Altas", null);
miLista.append("Bajas", null);
miLista.append("Consultas", null);
miLista.append("Modificaciones", null);
miLista.append("Impresion", null);
miLista.addCommand(salir);

miLista.addCommand(salir);
miLista.addCommand(acepta);
miLista.setCommandListener(this);
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
// TODO Auto-generated method stub
}

protected void pauseApp() {
// TODO Auto-generated method stub
}

protected void startApp() throws MIDletStateChangeException {
// TODO Auto-generated method stub
// Establecemos el "Display" actual a nuestra pantalla
display.setCurrent(miLista);
}

public void commandAction(Command c, Displayable s) {
// TODO Auto-generated method stub
if (c == this.miLista.SELECT_COMMAND){ // Si selecciono
this.MuestraMensaje();
}
if (c == salir){
try {
this.destroyApp(false);
notifyDestroyed();
} catch (MIDletStateChangeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if (c == acepta){
this.MuestraMensaje();
}
}

public void MuestraMensaje(){
miAlerta = new Alert("Opcion", miLista.getString(miLista.getSelectedIndex()), null, null);
display.setCurrent(miAlerta, miLista);
}
}

Friday, November 7, 2008

INTERFAZ DE USUARIO

Interfaces Gráficas de Usuario de Alto Nivel



En esta entrega hablaremos de la interface gráfica de alto nivel, esta interfaz usa componentes tales como botones, cajas de texto, formularios, etc. Estos elementos son implementados por cada dispositivo y la finalidad de usar las APIs de alto nivel es su portabilidad. Al usar estos elementos, perdemos el control del aspecto de nuestra aplicación ya que la estética de estos componentes depende exclusivamente del dispositivo donde se ejecute. En cambio, usando estas APIs de alto nivel ganaremos un alto grado de portabilidad de la misma aplicación entre distintos dispositivos. Fundamentalmente, se usan estas APIs cuando queremos construir aplicaciones de negocios.

Wednesday, November 5, 2008

CREACION Y ADMINISTRACION DE PROYECTOS


PONIENDO A TRABAJAR EL WIRELESS TOOLKIT



Todo proyecto comienza con un paso, y éste sería darle un click al ícono del Wireless Toolkit que se mira en la imagen.


Cuando se crea un proyecto, el Wireless Toolkit se encarga de crear un árbol de directorios en los que podremos almacenar nuestro código, los recursos que necesitemos en la aplicación y los archivos de instalación, entre otros.



Ya sea con la opción File-> New Project, o con el icono de New Project que aparece en pantalla; se puede crear un proyecto.







Para la creación del nuevo proyecto, deberemos proporcionar dos cosas:

  1. Nombre del Proyecto

  2. Nombre de la clase MIDlet

Por ejemplo, podemos dar como nombre del proyecto: Mi Primera Aplicación para J2ME, y como nombre de la clase MIDlet: MiPrimerMidlet.java y presionemos el botón Create Project.

Para ser nuestra primera práctica y antes de que entremos de lleno a conocer los perfiles (MIDP) y las configuraciones (CLDC), seleccionemos la siguiente opción que se muestra en la pantalla y presionemos después el botón OK.

Como mencionaba anteriormente, al momento de seleccionar un nuevo proyecto, el Wireless Toolkit crea una estructura de directorios en los que almacenaremos todo lo necesario para desarrollar la aplicación.


Y en ésta imagen lo podemos apreciar, Wireless Toolkit ha creado para nuesta aplicación la estructura de directorios en D:\Documents and Settings\wz2qch\j2mewtk\2.5.2\apps\Mi Primera Aplicacion para J2ME.

Mencionemos los distintos subdirectorios que nos ha creado:

bin .- En este directorio tendremos los archivos de instalación de la aplicación; que serían un archivo *.jar, otro *.jad y uno llamado MANIFEST.MF
lib .- Si además de las class y librerías que nos proporciona J2ME, utilizamos alguna otra; es en este lugar donde podemos almacenarlas para ser llamadas por nuestra aplicación.

res .- Es el lugar en donde podemos almacernar nuestros recursos; que pueden archivos de imágenes, documentos, etc; necesarios para nuestra aplicación.
src .- Y por último pero no por eso menos importante, es este directorio en donde almacenaremos nuestro código fuente, nuestros archivos *.java que darán funcionalidad a lo que desarrollemos.

Cuando yá se empieza a trabajar y se compilan los proyectos; se crean otros directorios adicionales como el classes, el tmpclasses y el tmplib.

Pongamos en el directorio src el código que creamos anteriormente y que llamamos MiPrimerMidlet.java.

Para compilarlo, bastará con presionar el botón BUILD en el menú principal de Wireless Toolkit y si no hay errores de compilación, podremos ejecutarlo en el emulador presionando el botón RUN.
Como se observa en la imagen, se desplegará nuestra aplicación gracias al emulador por default. Es posible cambiar este emulador por otro, para tener una representación mas fidedigna de cómo se vería en un modelo distinto de móvil.
Esto se hace seleccionando el emulador que deseemos, en la caja de combo DEVICE, y podemos seleccionar entre:
  1. DefaultPhoneColor
  2. DefaultGrayPhone
  3. MediaControlSkin
  4. QwertyDevice

Tuesday, November 4, 2008

LA CLASE MIDlet: LA MADRE DE TODOS

Todo desarrollo en J2ME tiene una base, esta base es la clase MIDlet.



Echemosle un vistazo a la documentación de SUN MicroSystems...



"javax.microedition.midlet Class MIDlet
java.lang.Object ---------> javax.microedition.midlet.MIDlet


public abstract class MIDlet extends Object


A MIDlet is a MID Profile application. The application must extend this class to allow the application management software to control the MIDlet and to be able to retrieve properties from the application descriptor and notify and request state changes. The methods of this class allow the application management software to create, start, pause, and destroy a MIDlet. A MIDlet is a set of classes designed to be run and controlled by the application management software via this interface. The states allow the application management software to manage the activities of multiple MIDlets within a runtime environment. It can select which MIDlets are active at a given time by starting and pausing them individually. The application management software maintains the state of the MIDlet and invokes methods on the MIDlet to notify the MIDlet of change states. The MIDlet implements these methods to update its internal activities and resource usage as directed by the application management software. The MIDlet can initiate some state changes itself and notifies the application management software of those state changes by invoking the appropriate methods.
Note: The methods on this interface signal state changes. The state change is not considered complete until the state change method has returned. It is intended that these methods return quickly."



Para todos aquellos que no mastican muy bien el inglés, no se preocupen; lo más importante lo veremos por medio de ejemplos.



La clase MIDlet cuenta con tres métodos protegidos, ésto significa, no pueden faltar, y son los siguientes:

  1. startApp()

  2. pauseApp()

  3. destroyApp(boolean unconditional)
El método startApp() es el dá inicio a todo, es como el public avoid main que veíamos en los códigos de J2SE. el pauseApp() en el caso de tener que interrumpir la ejecución de la aplicación, por ejemplo: Si recibimos una llamada o entra un mensaje a nuestro dispositivo móvil.


El método destroyApp() sería el encargado de dar por terminada la aplicación, desactivándolo y procediendo a su destrucción como proceso activo en memoria.

Para que lo podamos entender mejor, vamos a ver un ejemplo:


MiPrimerMidlet.java

import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.StringItem;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class MiPrimerMidlet extends MIDlet {
Display Despliegue;
Form Pantalla;
StringItem txtBox;

public MiPrimerMidlet() {
Despliegue = Display.getDisplay(this);
Pantalla = new Form("Primer Midlet");
StringItem txtBox = new StringItem("MI PRIMER MIDLET !!!", null);
Pantalla.append(txtBox);
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}

protected void pauseApp() {
}

protected void startApp() throws MIDletStateChangeException {
Despliegue.setCurrent(Pantalla);
}
}

Analicemos éste código, notemos primero que nada que entre las librerías que estamos importando, hay dos que hacen referencia directa a la clase MIDlet


import javax.microedition.midlet.MIDlet;

import javax.microedition.midlet.MIDletStateChangeException;

La primera línea nos permite heredar la clase MIDlet, la segunda nos permite manejar los cambios de estado, esto es: el startApp, pauseApp y el destroyApp que hemos estado mencionando.


Siguiendo con el análisis vemos como nuestra aplicación hereda a la clase MIDlet

public class MiPrimerMidlet extends MIDlet {


Y adicional a ésto manejos tres elementos más: Un Display, una Form y un StringItem.



La clase Display nos dá el poder de controlar la pantalla del dispositivo, la Form nos permite desplegar algo en la pantalla y agregar allí nuestros controles, en este caso: Un letrero que diga MI PRIMER MIDLET !!!



La clase Display toma control de la pantalla del dispositivo con el método getDisplay en la línea

Despliegue = Display.getDisplay(this);

Además de éste método, tiene otros igual de útiles como :

  1. 1.- getBestImageHeight(int imageType)
  2. 2.- getBestImageWidth(int imageType)
  3. 3.- setCurrent(Alert alert, Displayable nextDisplayable)
  4. 4.- setCurrent(Displayable nextDisplayable)

La clase Form nos permite desplegar algo en la pantalla y agregar allí los componentes que deseamos.

Como se puede observar en el ejemplo, declaramos un objeto StringItem (txtBox), le asignamos un letrero que dice MI PRIMER MIDLET !!! y a continuación lo agregamos al objeto Form (Pantalla).

Despliegue = Display.getDisplay(this);

Pantalla = new Form("Primer Midlet");

StringItem txtBox = new StringItem("MI PRIMER MIDLET !!!", null);

Pantalla.append(txtBox);

Y finalmente, asignamos este objeto Form (txtBox) con todo y componente al objeto Despliegue para poder visualizarlo.

Despliegue.setCurrent(Pantalla);

En la siguiente entrega, veremos cómo se compila, cómo se ejecuta y cómo se crean los archivos instalables de J2ME, hoy por hoy hemos terminado.

Y LLEGAMOS AL J2ME

La edición Java 2 Micro Edition fue presentada en 1999 por Sun Microsystems con el propósito de habilitar aplicaciones Java para pequeños dispositivos.
En esta presentación, se mostró una primera versión de una nueva Java Virtual Machine (JVM) para dispositivos Palm.

Como se muestra en el gráfico, J2ME es la versión del lenguaje Java que está orientada al desarrollo de aplicaciones para dispositivos pequeños con capacidades restringidas tanto en pantalla gráfica, como de procesamiento y memoria (teléfonos móviles, PDA`s, Handhelds, Pagers, etc).

Es la respuesta de Java a las necesidades de los usuarios de telefonía móvil que cada vez demandan más servicios y prestaciones por parte tanto de los terminales como de las compañías.

La tecnología del J2ME depende del asentamiento en el mercado de otras, como GPRS, íntimamente asociada a J2ME y que no ha estado a nuestro alcance hasta hace poco.

J2ME es la tecnología del futuro para la industria de los dispositivos móviles. Actualmente las compañías telefónicas y los fabricantes de móviles están implantando los protocolos y dispositivos necesarios para soportarla.





RELACION DE APIS en JAVA

Como se observa en el gráfico, en la actualidad J2SE es un subconjunto de J2EE, y el J2ME está contenido dentro de éstas dos, pero sin embargo debido a la limitaciones de los dispositivos a los que está dirigido, conserva una parte independiente llamada javax.microedition, que son clases e interfaces genéricas para la configuración CLDC.


COMPONENTES DEL J2ME

a) Máquina virtual.
La Máquina Virtual de la configuración CLDC se denomina KVM.

Características principales:
• Pequeña, con una carga de memoria entre los 40Kb y los 80 Kb, dependiendo de la plataforma y las opciones de compilación.
• Alta portabilidad.
• Modulable.
• Lo más completa y rápida posible y sin sacrificar características para las que
fue diseñada.

b) Configuración.

Configuración de dispositivos limitados con conexión, CLDC (Connected Limited Device Configuration).
La CLDC está orientada a dispositivos dotados de conexión y con limitaciones
en cuanto a capacidad gráfica, cómputo y memoria. Un ejemplo de éstos dispositivos
son: teléfonos móviles, buscapersonas (pagers), PDAs, organizadores personales, etc.

CLDC está orientado a dispositivos con ciertas restricciones. Algunas de éstas restricciones vienen dadas por el uso de la KVM, necesaria al trabajar con la CLDC debido a su pequeño tamaño.


Los dispositivos que usan CLDC deben cumplir los siguientes requisitos:
Disponer entre 160 Kb y 512 Kb de memoria total disponible. Como mínimo se debe disponer de 128 Kb de memoria no volátil para la Máquina Virtual Java y las bibliotecas CLDC, y 32 Kb de memoria volátil para la Máquina Virtual en tiempo de ejecución.
Procesador de 16 o 32 bits con al menos 25 Mhz de velocidad.
Ofrecer bajo consumo, debido a que éstos dispositivos trabajan con suministro de energía limitado, normalmente baterías.
Tener conexión a algún tipo de red, normalmente sin cable, con conexión intermitente y ancho de banda limitado (unos 9600 bps).

La CLDC aporta las siguientes funcionalidades a los dispositivos:

  • Un subconjunto del lenguaje Java y todas las restricciones de su Máquina Virtual (KVM).

  • Un subconjunto de las bibliotecas Java del núcleo.

  • Soporte para E/S básica.

  • Soporte para acceso a redes.

  • Seguridad.

CLASES EN J2ME

  • java.io Clases y paquetes estándar de E/S.

  • java.lang Clases e interfaces de la Máquina Virtual.

  • java.util Clases, interfaces y utilidades estándar.

  • javax.microedition Clases e interfaces de conexión genérica CLDC

c) Perfiles.

El perfil es el que define las APIs que controlan el ciclo de vida de la aplicación, interfaz de usuario, etc. Más concretamente, un perfil es un conjunto de APIs orientado a un ámbito de aplicación determinado. Los perfiles identifican un grupo de dispositivos por la funcionalidad que proporcionan (electrodomésticos, teléfonos móviles, etc.) y el tipo de aplicaciones que se ejecutarán en ellos. Las librerías de la interfaz gráfica son un componente muy importante en la definición de un perfil. Aquí nos podemos encontrar grandes diferencias entre interfaces, desde el menú textual de los teléfonos móviles hasta los táctiles de los PDAs.

El perfil establece unas APIs que definen las características de un dispositivo, mientras que la configuración hace lo propio con una familia de ellos.

Esto hace que a la hora de construir una aplicación se cuente tanto con las APIs del perfil como de la configuración. Tenemos que tener en cuenta que un perfil siempre se construye sobre una configuración determinada. De este modo, podemos pensar en un perfil como un conjunto de APIs que dotan a una configuración de funcionalidad específica.

Ya hemos visto los conceptos necesarios para entender cómo es un entorno de ejecución en Java Micro Edition.

Para empezar a desarrollar nuestras aplicaciones, es necesario contar con el Sun Java Wireless Toolkit 2.5.2 for CLDC (http://java.sun.com/javame/downloads/index.jsp) o bien, si queremos estar a la vanguardia, podemos descargar el Java Platform Micro Edition Software Development Kit 3.0 Early Access en esa misma liga.

Adicionalmente, yo instalo el Sony Ericsson SDK 2.5.0.3 for the Java™ ME Platform (https://developer.sonyericsson.com/site/global/docstools/java/p_java.jsp)

Con estas herramientas instaladas podemos conquistar el mundo !

Nota Importante: La secuencia correcta de instalación sería

  1. El JDK de J2SE
  2. El Sun Java Wireless Toolkit 2.5.2 for CLDC (o el Development Kit 3.0 Early Access)
  3. Sony Ericsson SDK 2.5.0.3 for the Java ME Platform

EN JAVA TODO ES UN OBJETO




Bueno, ahora que ya tenemos casi todas las herramientas que necesitamos para el desarrollo de aplicaciones para móviles, veamos un poco más de teoría para asegurarnos de que vamos a empezar con el pie derecho.

Lo primero que tenemos que conocer, son los OBJETOS.

¿QUE SON LOS OBJETOS ?

Como se puede ver en la imagen anterior, para poder fabricar los objetos Reloj y Lámpara, se necesita la información pregrabada llamada clases.

Las clases son las que almacenan las propiedades y métodos que contendrá un objeto.

Un objeto cambiará sus propiedades o las propiedades de otros objetos por medio de los métodos.
Los métodos que sólo pueden ejecutarse cuando el objeto existe, son los denominados dinámicos, y los métodos que pertenecen a la clase son denominados estáticos, porque pueden ser llamados sin necesidad de la existencia de un objeto.

En el ejemplo tenemos dos objetos, Reloj y Lámpara los cuales tienen métodos Cuerda e Interruptor, que son los que cambiaran el estado de las propiedades Hora e Ilumina. La clase reloj, podría tener un método estático llamado poner_en_hora, para ajustar todos los relojes fabricados.
Un programa en ejecución inicia en un método estático ya que no existen inicialmente objetos en nuestra aplicación, este método se llama main el cuál se define como:

public static void main(String[] args){
.....
}
Donde args es un vector o arreglo unidimensional que contendrá los argumentos que hayan sido pasados al comando java después de las órdenes y el nombre de la clase principal que alojará este método. El entorno de ejecución o la JVM fabricará objetos de sistema que podrán ser utilizados llamando a métodos estáticos de clases pertenecientes a la biblioteca de java.

Veamos un sencillo ejemplo, imaginemos que tenemos que crear un objeto llamado ALUMNO, todo objeto alumno debe tener las siguientes propiedades : NOMBRE, EDAD y GRADO.

Como métodos, podría tener PonNombre, PonEdad, PonGrado y DatosCompletos.

Escribamos entonces la definición de la clase para el objeto ALUMNO.

Alumno.java

public class Alumno {
String wNombre;
int wEdad;
String wGrado;

public Alumno() {
this.wNombre = "Desconocido";
this.wEdad = 0;
this.wGrado = "Desconocido";
}

public void PonNombre(String wNombre) {
this.wNombre = wNombre;
}

public void PonEdad(int wEdad) {
this.wEdad = wEdad;
}

public void PonGrado(String wGrado){
this.wGrado = wGrado;
}

public void DatosCompletos(String wNombre, int wEdad, String wGrado){
this.wNombre = wNombre;
this.wEdad = wEdad;
this.wGrado = wGrado;
}
}

Ahora que ya tenemos la definición de la clase Alumno, escribamos el código que utilice esta clase y fabrique objetos alumno.

Primero.java

public class Primero {

public Primero(){
}

public static void main(String[] args) {
Alumno miObjeto = new Alumno();

System.out.println("Primera parte....");
System.out.println("Nombre = " + miObjeto.wNombre); System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
System.out.println("Tipo = " + miObjeto.getClass().toString());
System.out.println("\n");

miObjeto.wNombre = "Epigmenio Corrales";
miObjeto.wEdad = 45;
miObjeto.wPuesto = "Grado Doctorado";
System.out.println("Segunda parte....");
System.out.println("Nombre = " + miObjeto.wNombre);
System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
System.out.println("\n");

miObjeto.DatosCompletos("Casildo Ortega Del Monte", 23, "Segundo Grado Maestría");
System.out.println("Tercera parte....");
System.out.println("Nombre = " + miObjeto.wNombre);
System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
}
}

Si ejecutamos este sencillo código que hemos ejecutado, obtendremos un resultado en pantalla como el que sigue:

Primera parte....
Nombre = Desconocido
Edad = 0
Grado = Desconocido
Tipo = class Alumno

Segunda parte....
Nombre = Epigmenio Corrales
Edad = 45
Grado = Grado Doctorado

Tercera parte....
Nombre = Casildo Ortega Del Monte
Edad = 23
Grado = Segundo Grado Maestría

Muy bien, después de este breve y pequeño recordatorio de Java, la definición de Clases y la creación de Objetos; estamos listos para abordar de lleno el tema del J2ME.

Monday, November 3, 2008

PONGAMOS A TRABAJAR AL FRAMEWORK

Creación de un proyecto en Eclipse




Desde el menú Window -> Open perspective -> Java




Empezamos con el wizard de creación de un proyecto desde el menú File -> New -> Project o bien pulsando sobre el botón que se ve en la imagen.




En la primera pantalla del wizard ponemos un nombre al proyecto y decidimos donde se guardará, por defecto se crea una carpeta con el nombre del proyecto dentro de eclipse_home en el directorio workspace.


Pulsamos "Next" para ir a la pantalla de configuración del classpath, del directorio donde se guardarán las clases generadas, si el proyecto que estamos creando depende de algún otro, etc.

























Una vez que se ha configurado el proyecto pulsamos "Finish" para terminarlo de crear.

ADOPTEMOS UN FRAMEWORK

Ahora que hemos instalado la herramienta de J2SE, podemos escribir nuestro código en cualesquier editor de texto, guardando nuestro trabajo en un archivo con la terminación .java y desde la línea de comandos compilarlo utilizando la sentencia :

c:\MiDirectorio\javac MiPrograma.java

Este proceso puede resultar abrumador, sobre todo porque el compilador de J2SE es muy estricto en cuanto a la sintaxis y el error provocado por la presencia de una tilde (´) o un punto y coma (;) mal colocado puede romper los nervios aún del programador más experimentado.

Por fortuna, contamos con algunos IDE´s o Frameworks que pueden auxiliarnos en esta tarea, uno de ellos yá lo mencionamos antes, es el NetBeans.

Por ahora veremos el Eclipse y posteriormente en otro post regresaremos al NetBeans.


Instalación de Eclipse

Los requerimientos necesarios es tener instalado el JDK 1.3 o superior y preferiblemente tener 256 MB de memoria y si es más pues mejor.

Lo primero que tenemos que hacer es bajarnos el software correspondiente de http://www.eclipse.org/
De todas formas recomiendo este sitio para la descarga del software http://gul.uc3m.es/eclipse/downloads/
Eclipse puede funcionar en Windows, Linux, Solaris, etc..

Descomprimimos el fichero eclipse-SDK-3.0-win32.zip que nos acabamos de bajar en el directorio c:\eclipse al que llamaremos de ahora en adelante : eclipse_home.

Nosotros hemos optado por trabajar con la última versión de eclipse 3.0.

Para arrancar la plataforma eclipse basta con ejecutar eclipse.exe que se encuentra dentro eclipse_home.


Y listo, tenemos instalado nuestro framework que nos ahorrará muchos dolores de cabeza al momento de querer compilar nuestro código.


En la próxima emisión veremos cómo se trabaja con él.

EMPECEMOS INSTALANDO JAVA

El lenguaje de programación Java en la actualidad


Desde 1995, Sun Microsystems ha controlado las especificaciones, el desarrollo y evolución del lenguaje a través del Java Community Process, si bien otros han desarrollado también implementaciones alternativas de estas tecnologías de Sun, algunas incluso bajo licencias de software libre.
Entre noviembre de 2006 y mayo de 2007, Sun Microsystems liberó la mayor parte de sus tecnologías Java bajo la licencia GNU GPL, de acuerdo con las especificaciones del Java Community Process, de tal forma que prácticamente todo el Java de Sun es ahora software libre (aunque la biblioteca de clases de Sun que se requiere para ejecutar los programas Java todavía no es software libre).
Bien, ahora que yá estamos mas enfocados en la historia de la herramienta que nos ocupa; averiguemos qué necesitamos y cómo lo conseguimos.
Instalación del SDK de Java (SDK = Software Development Kit)

En la página de Sun podemos encontrar varios tipos de descarga:
  1. JRE .- Si sólo queremos ejecutar aplicaciones Java, necesitaremos instalar JRE (Java Runtime Enviroment). Este es un entorno de ejecución que sirve para poder ejecutar programas java compilados.
  2. JDK .- Por el contrario, si lo que queremos es crear, compilar y ejecutar nuestras aplicaciones, necesitaremos el SDK (Sun Development Kit). SDK es el entorno de desarrollo que incluye varias herramientas además del compilador de java y el debugger.
  3. También podemos descargarnos el SDK+NetBeans si queremos un entorno visual para desarrollar nuestras aplicaciones. Netbeans es especialmente útil para diseñar interfaces gráficas para usuarios.

Puedes descargar estas aplicaciones en la página de Sun.(http://developers.sun.com/downloads/)

Las descargas estan agrupadas por Java EE (Enterprise Edition: Desarrollo de aplicaciones web) , Java ME (Micro Edition: Desarrollo para dispositivos móviles y PDA's) y Java SE (Standard Edition: Nos iremos por ésta si queremos crear aplicaciones en nuestro equipo de escritorio y posteriormente pasarlas a nuestro equipo móvil).

Configurar Java

Una vez instalada la versión SDK (Java SE), deberemos configurar las variables de entorno para poder ejecutar aplicaciones JAVA desde cualquier ruta de tu sistema.

Windows 2000/XP:

  1. Pulsaremos el botón derecho del ratón sobre MI PC, y seleccionaremos propiedades.
  2. En la pestaña de Opciones Avanzadas, hay un botón que te permite configurar las "Variables de Entorno". Haz click en este botón y modifica la variable "Path" del sistema, de modo que también contenga la ruta del ejecutable Java.
  3. Por ejemplo: si has instalado Java en c:\Java y la variable del sistema tiene el valor C:\WINDOWS\SYSTEM32, le cambiaremos el valor para que se lea: C:\WINDOWS\SYSTEM32;C:\Java\bin .
  4. Ahora, desde la linea de comandos podrás compilar (Ej: javac Miprograma.java) y ejecutar (Ej: java Miprograma) tus aplicaciones Java desde cualquier carpeta del sistema.

Configurar la variable CLASSPATH

Además de configurar la variable de entorno PATH, también deberás decirle a Java dónde encontrar los archivos de clases compiladas al ejecutar tus aplicaciones. Para ello deberemos modificar la variable CLASSPATH para que almenos incluya el directorio actual (.)

Ej: Desde la linea de comandos escribiremos: SET CLASSPATH=%CLASSPATH%;.

Ésta variable también puede contener otros directorios que contengan clases compiladas.

BIENVENIDO A DESARROLLO MOVIL

Sean bienvenidos a este blog dedicado al desarrollo de aplicaciones para dispositivos móviles, éste es un sitio está dirigido a todos aquellos que estén interesados en el área, que inician o se encuentran yá dentro del ámbito.

Actualmente existen bastantes herramientas para realizar estas aplicaciones, empezaremos por una de las más populares: J2ME de la empresa Sun MicroSystems.

En lo personal, me aburren las explicaciones largas y tediosas, pero todo viaje tiene su comienzo y éste, siempre hay que ver un poco de teoría para saber dónde vamos a pisar y si el camino valdrá o nó la pena.

Comencemos entonces....

LENGUAJE DE PROGRAMACION JAVA

Historia :

Influído por los lenguajes C y C++; Java nació a inicios de la década de los 90´s para tratar de poner remedio al problema de la programacion de microcomponentes en la industria de la fabricacion de electrodomésticos (Refrigeradores, hornos de microndas, lavadoras, etc.).


Problemas en la programación de microcomponentes:

Cuando un fabricante desea iniciar con la produccion de un modelo determinado, realiza primero un prototipo en el cual cada uno de sus componentes es cargado con la configuracion de fabrica.




Y posteriormente cada equipo en la linea de produccion es ensamblado con los clones de los microcomponentes del prototipo.

Si el fabricante decide realizar un cambio de diseño y esto incluye una nueva version del microcomponente o un cambio de proveedor; entonces se vé en la necesidad de tener que realizar una version nueva del software que sea compatible con este modelo.

James Gosling propuso entonces resolver el problema con una herramienta que tuviera las siguientes características:

1) Programación de bajo nivel, como el lenguaje C.
2) Ejecutable sin importar la plataforma. (Write Once, Run Anywhere)
3) Entorno de ejecución ligero y gratuito.

El proyecto se llamó Green Project en sus inicios, y la herramienta creada por el equipo de Gosling ofrecía lo siguiente:

1) Un manejo de objetos más simple que el lenguaje C.
2) Eliminación de la manipulación directa de punteros o memoria.
3) Compilación del código en bytecodes, que es interpretado a código nativo por la máquina virtual para ser ejecutado.

La base de todo, era la Máquina Virtual que se encontraba en los componentes y se encargaba de recibir el código compilado en archivos bytecodes.

Esta Máquina Virtual se encargaba de traducir el archivo a código nativo y ejecutarlo en el microcomponente, adicional a ésto, resolvía el problema de administrar los recursos mediante el garbagge collector (Recolector de basura) que constantemente revisa y libera memoria.

En 1994 se introduce al campo de la Internet con el navegador Netscape, aunque su presentación oficial fué un año después.