aprendiendo-lenguaje-java.com

Nuestro primer MIDlet

2009-04-12T13:26:00.000-07:00

En este capítulo vamos a construir y ejecutar nuestro primer MIDlet. Existen diferentes herramientas válidas para construir programas bajo el standard J2ME, como el propio "Sun One Studio" de Sun Microsystems o "Jbuilder" de Borland. Nosotros vamos a valernos del "J2ME Wireless Toolkit 2.0" que proporciona Sun. Este entorno es el más sencillo de utilizar, y aunque no nos ofrece una gran potencia a la hora de desarrollar aplicaciones, no nos distraerá con grandes complejidades del principal objetivo que es aprender a hacer aplicaciones (juegos) en J2ME.

Para instalar J2ME Wireless Toolkit, primero hemos de instalar el entorno de programación de J2SE (JDK). Puedes descargar la última versión de JDK desde la URL http://java.sun.com/j2se/downloads.html. Una vez descargado e instalado, estaremos en condiciones de descargar e instalar J2ME desde la URL http://java.sun.com/j2me/download.html. El entorno de desarrollo que nos provee el Wireless Toolkit se llama KToolBar.

Compilando el primer MIDlet.- Vamos a construir paso a paso nuestro primer MIDlet usando esta herramienta. Tras la instalación del wireless toolkit, tendremos un nuevo submenú en el menú inicio con un aspecto similar a éste:

Selecciona la aplicación KToolBar e inicializa el entorno. Verás aparecer la ventana del entorno.

Vamos a crear un nuevo proyecto, así que pulsamos el botón New Project. Nos solicitará un nombre para el proyecto y otro para la clase principal de la aplicación.

Tanto el proyecto como la clase principal se llamarán HelloWorld, así que introducimos este nombre en ambos cuadros de texto y pulsamos el botón Create Project. En este momento KToolBar crea la estructura de directorios necesaria para albergar el proyecto.

Cada una de las carpetas creadas tiene una misión concreta. Por ahora nos bastará saber que nuestros archivos fuente irán emplazados en el directorio src, y los recursos necesarios como gráficos, sonidos, etc... se alojarán en el directorio res.

A diferencia de otros entornos de programación, KToolBar no cuenta con un editor integrado para editar los programas, por lo tanto vamos a utilizar uno externo. Puedes utilizar el bloc de notas de Windows o tu editor favorito. Personalmente utilizo Crimson Editor (http://www.crimsoneditor.com/), que tiene soporte para Java.

Utilizando tu editor favorito introduce el programa siguiente:

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

public class HelloWorld extends MIDlet implements CommandListener {
private Command exitCommand;
private Display display;
private Form screen;

public HelloWorld() {
// Obtenemos el objeto Display del midlet.
display = Display.getDisplay(this);

// Creamos el comando Salir.
exitCommand = new Command("Salir", Command.EXIT,2);

// Creamos la pantalla principal (un formulario)
screen = new Form("HelloWorld");

// Creamos y añadimos la cadena de texto a la pantalla
StringItem saludo = new StringItem("","Hola Mundo...");
screen.append(saludo);

// Añadimos el comando Salir e indicamos que clase lo manejará
screen.addCommand(exitCommand);
screen.setCommandListener(this);
}

public void startApp() throws MIDletStateChangeException {
// Seleccionamos la pantalla a mostrar
display.setCurrent(screen);
}

public void pauseApp() {
}

public void destroyApp(boolean incondicional) {
}

public void commandAction(Command c, Displayable s) {
// Salir
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}

No es necesario que trates de comprender el programa ahora. Entraremos en más detalles un poco más adelante. Por ahora simplemente lo vamos a almacenar en el directorio src que ha creado KToolBar con el nombre HelloWorld.java. Es importante que el nombre sea exactamente éste incluidas mayúsculas y minúsculas. Esto es así, ya que el nombre de la clase principal tiene que ser idéntico al nombre del archivo que lo contiene. Una vez hecho esto, volvemos al entorno KTooBar y pulsamos el botón Build. Si todo va bien, aparecerá el texto Build Complete. Ya tenemos nuestro programa compilado y podemos ejecutarlo en el emulador. En el desplegable Device puedes seleccionar el emulador que quieres utilizar. El DefaultColorPhone tiene soporte de color, así que te resultará más atractivo. Pulsa el botón Run. Verás aparecer un emulador con forma de teléfono móvil. En la pantalla del móvil aparece un menú con un sólo programa llamado HelloWorld. Pulsa select para ejecutarlo.

Deberías ver como aparece la frase Hola Mundo... en la pantalla.

Ahora que hemos comprobado que el programa funciona en el emulador, estamos listos para empaquetar el programa y dejarlo listo para descargar a un dispositivo real. En KToolBar despliega el menú project, y selecciona create package del submenú package. KToolBar nos informa de que ha creado los archivos HelloWorld.jar y HelloWorld.jad dentro del directorio bin. Estos son los archivos que habremos de transferir al teléfono móvil.

Conclusión y bibliografía de J2ME

2009-04-11T12:40:00.000-07:00

De unos años a la fecha las instituciones de educación tecnológica en México, particularmente las relacionadas con la computación y el desarrollo de software, han centrado sus esfuerzos en un solo fin para la programación: aplicaciones de bases de datos, principalmente para computadoras de escritorio con conexión a una red o, en los mejores casos, para servidores de grandes compañías. Esta situación se debe, principalmente, a lo difícil o casi imposible que se ha vuelto el competir con los gigantes del software (Microsoft, Sun, Borland, etc.) en aplicaciones de interés general, como pueden ser: procesadores de texto, juegos, anti virus, hojas de cálculo, reproductores multimedia, entornos de programación y un largo etcétera; todo el mercado de estos productos de consumo masivo se considera, en la mayoría de las ocasiones, fuera del alcance de un estudiante de nivel licenciatura, algunas veces de posgrado, y que decir de uno de preparatoria, por muy brillantes que estos sean.

Si bien es cierto que para un ser humano solitario, y hasta cierto grado principiante, es imposible competir contra un grupo enorme de profesionales que llevan años dedicándose al desarrollo de los mismos módulos para un mismo paquete, también lo es que ese ser humano puede llegar a formar parte de uno de esos mitificados grupos y, por qué no, puede incluso ser el fundador de uno de ellos.

A lo largo de este documento se han podido ver las enormes capacidades de desarrollo que los llamados "pequeños dispositivos inalámbricos" presentan, desde la mas sencilla página web, hasta una completa aplicación con fines científicos, de manejo de bases de datos o de acceso a la red empresarial.

Lo anterior sugiere que, siendo el campo de la programación de equipos pequeños e inalámbricos, un campo hasta cierto punto virgen en muchas regiones del mundo, se puede orientar a los alumnos a la creación, no ya de sistemas de inventarios para un supermercado[1], sino de aplicaciones que, por ser de uso general -y aunque su precio de venta sea mucho menor- resuelvan más necesidades de más personas alrededor del mundo.

Actualmente, en los teléfonos celulares, se pueden utilizar aplicaciones como calculadoras simples, sencillísimos editores de texto para el envío de mensajes, juegos que cada vez tienen mayor complejidad, entre otras. No hay todavía una calculadora científica, un editor de texto con corrección de ortografía (aunque sea por medio de la red) o un paquete de oficina compatible con los de las PC.

Se ha elegido, para este proyecto de investigación, demostrar los conocimientos adquiridos con una aplicación de hoja de cálculo debido a la representatividad de este tipo de paquetes, es decir, ¿Qué tipo de software puede ser más general?. En una hoja de cálculo se puede ingresar texto, datos numéricos, realizar operaciones, hacer programas sencillos (y en ocasiones no tan sencillos) en las mejores hojas.

Con lo anterior se pretende enviar un mensaje a cada lector que, habiendo pasado por las páginas anteriores, haya conservado el interés en este reporte y esté ahora leyendo estas líneas.

"Tenemos ante nuestros ojos un campo por labrar, un campo donde quién va pasando por un tramo se apodera de él. Es un campo enorme y, hasta ahora, son pocos los que lo ocupan y relativamente poco el espacio que han abarcado. Podemos dejar que suceda lo que sucedió con las computadoras de escritorio y quedarnos sólo con el espacio donde estamos parados (y probablemente ni eso), o podemos comenzar a ganar terreno. Quizá nunca tengamos más del espacio suficiente para construir nuestra choza, pero es mejor que poder apenas levantar las manos para cubrirnos de la lluvia".

8.BIBLIOGRAFÍA

1.Deitel, H.M. Deitel, P.J. "Cómo programar en Java", Prentice Hall. México. 1998.

2.Froute, Agustín, "Tutorial de Java". froufe@arrakis.es. España. Julio de 1996.

3.Lopez Camacho, Vicente, "Linux, guía de instalación y administración", McGraw-Hill, España, 2001.

4.Java.sun.com

5.www.motocoder.com

6.www.motorola.com

7.www.nokia.com

8.www.sonyericsson.com

9.www.wapforum.com

10.www.wmlclub.com

DESARROLLO DE UNA APLICACIÓN

2009-04-10T12:37:00.000-07:00

6.1.Descripción del proyecto

El proyecto en el que se ha pretendido aplicar los conocimientos adquiridos mediante esta investigación consiste en una pequeña hoja de cálculo con la que se puedan realizar las operaciones aritméticas básicas (igualación, suma, resta, multiplicación y división) y combinaciones sencillas de estas (potencia, promedio, por ejemplo), además de comparaciones entre varios elementos (determinar el valor mayor o menor de una lista).

También se busca que la aplicación tenga la capacidad de almacenar los datos de la hoja de cálculo de manera persistente en el equipo, así como de abrir documentos (hojas) guardados con anterioridad y borrar las hojas, que ya han sido guardadas previamente, para liberar el limitado espacio de almacenamiento del dispositivo.

6.2. Herramientas a utilizar

Para la realización de la hoja de cálculo (llamada hojaC, nombre perteneciente a la clase principal), se ha utilizado una computadora de las siguientes características:

-Procesador AMD Duron a 1.3 Ghz.

-160 MB de memoria RAM.

-Disco duro de 8.4 Gb.

-Sistema operativo: Mandrake Linux 8.2.

Se inició la escritura del código de hojaC, como se comentó en el capítulo 4, utilizando un editor de texto llamado Gedit y Java Wireless Toolkit para la compilación. Aunque esto resultaba sumamente tediosos, por lo que se optó por utilizar el Entorno Integrado de Desarrollo (IDE) Sun ONE Studio, en una versión de evaluación especial para la plataforma micro de Java.

6.3. Desarrollo

La aplicación está compuesta por cinco clases principales, de las cuales la llamada hojaC es la que se ejecuta al iniciar y la que inicia el resto de las clases. A continuación se describen las funciones con que cada clase debe cumplir.

-hojaC: Es la clase MIDlet, es decir, la que se ejecuta. esta clase sólo utiliza una forma (Form) sobre la que se instancian una clase Tabla y una clase TextField, de estas, TextField se encarga de mostrar en la parte inferior de la pantalla el valor de la celda actual, Tabla se explica enseguida.

-Tabla [1]: Esta es la clase que realiza la mayor parte del trabajo, ya que es la encargada de dibujar la hoja y sus valores, almacenar dichos valores temporalmente, realizar las llamadas a otras clases y la actualización del campo de texto (TextField). Esta clase implementa la interfaz CustomItem, la que permite la utilización de elementos propios de la clase Canvas (eventos de teclas, dibujo de líneas, rellenado de rectángulos, cambio de colores, etc.) y de los formularios o formas (TextField, por ejemplo).

-Texto: Hereda o extiende a la clase TextBox, su única función consiste en capturar los valores de las celdas y enviarlos al arreglo donde los guarda Tabla.

-funcion: Esta clase contiene los métodos necesarios para la resolución de las fórmulas que se introducen a la hoja de cálculo. Un objeto instanciado en esta clase se construye cada vez que la hoja se actualiza, esto es, cada que se presiona una tecla

-Archivo: La clase Archivo es la encargada de todas las operaciones que se realizan con archivos. En ella se encuentran los métodos destinados a pedir el nombre o mostrar la lista de los archivos, así como guardarlos, borrarlos o abrirlos, según lo solicite el usuario.

Ahora se explicará cada clase mostrando aquellos fragmentos de código que se consideren importantes para tal explicación.

6.3.1.Clase hojaC

La clase hojaC, como el resto de las clases de esta aplicación, forma parte del paquete hoja. Debido a que será la clase que habrá de albergar a las demás, debe heredar el paquete midlet, lcdui será para poder utilizar la clase Form. Además la clase, para poder se ejecutada, necesita extender la clase MIDlet.

package hoja;

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

public class hojaC extends MIDlet implements CommandListener {

Esta clase incluirá los comandos Salir, Guardar, Abrir, Borrar y Nuevo. También se declaran las clases disp, forma1, tabla, txt1 y una variable lógica prim que servirá para identificar cuando sea la primer vez que se ejecuta la clase, esto sirve para no redefinir los comandos y los valores de algunas variables.

private final static Command Salir = new Command("Salir", Command.EXIT, 1);

private final static Command Guardar = new Command("Guardar", Command.SCREEN, 3);

private final static Command Abrir = new Command("Abrir", Command.SCREEN, 3);

private final static Command Borrar = new Command("Borrar", Command.SCREEN, 3);

private final static Command Nuevo = new Command("Nuevo", Command.SCREEN, 3);

private Display disp;

private Form forma1;

private Tabla tabla;

public TextField txt1;

private boolean prim;

En el constructor de la clase sólo se instancian las clases forma1, tabla, txt1 y se le asigna a prim el valor inicial de verdadero.

public hojaC(){

forma1=new Form("Mini-hoja de cálculo");

tabla=new Tabla(null, Display.getDisplay(this),this);

txt1=new TextField("=", null, 64, 0);

prim=true;

}

En el método startApp() se agregan los comandos, la tabla y el campo de texto a forma1 y se define esta como objeto a mostrar.

public void startApp() {

if (prim){

disp=Display.getDisplay(this);

forma1.append(tabla);

forma1.append(txt1);

forma1.addCommand(Salir);

forma1.addCommand(Guardar);

forma1.addCommand(Abrir);

forma1.addCommand(Borrar);

forma1.addCommand(Nuevo);

forma1.setCommandListener(this);

prim=false;

disp.setCurrent(forma1);

}else{

disp.setCurrent(forma1);

}

public void pauseApp() { }

public void destroyApp(boolean unconditional) { }

La función settexto es utilizada por la clase Tabla para actualizar el contenido de txt1 cada vez que en la tabla se cambia de celda.

protected void settexto(String texto){

txt1.setString(texto);

}

Finalmente, en el método commandAction se define que se hará en caso de cada opción del menú.

public void commandAction(Command c, Displayable d){

if (c==Salir){

destroyApp(false);

notifyDestroyed();

}

if(c==Abrir){

Archivo ar=new Archivo('A',tabla.getDatos(),disp,forma1);

forma1.setCommandListener(this);

}

if(c==Guardar){

Archivo ar=new Archivo('G',tabla.getDatos(),disp,forma1);

forma1.setCommandListener(this);

}

if(c==Borrar){

Archivo ar=new Archivo('B',tabla.getDatos(),disp,forma1);

forma1.setCommandListener(this);

}

if(c==Nuevo){ tabla.limpiar(); }

}

6.3.2.Clase Tabla

Esta clase importará el paquete javax.microedition.lcdui y la clase funcion de el paquete hoja. Además agrega un comando al menú que había creado hojaC, el comando cmdAny (que mostrará el texto "Valor"). Se hereda la capacidad de manejo de herramientas de Canvas en la misma pantalla que elementos de Form.

package hoja;

import javax.microedition.lcdui.*;

import hoja.funcion;

public class Tabla extends CustomItem implements ItemCommandListener {

private final static Command cmdAny = new Command("Valor", Command.SCREEN,1);

private Display display;

//Ancho de la columna que muestra el número de fila o renglón

private static int num=18;

//Filas y columnas en pantalla

private int rows = 6;

private int cols = 3;

//Filas y columnas reales de la tabla (filas y columnas del arreglo)

private int rrows = 5;

private int rcols = 3;

//Tamaño de una celda

private int dx = 51;

private int dy = 19;

//Celda seleccionada

private int currentX = 0;

private int currentY = -1;

//Arreglo donde se almacenarán los datos

private String[][] data = new String[rrows][rcols];

//Indicador de la pantalla vertical y horizontal donde se encuentra[2].

private int pantallaV=1;

private int pantallaH=1;

//Se necesita utilizar una clase hojaC para la actualización de txt1.

private hojaC hoja1;

En el constructor de Tabla se crea una clase CustomItem (super) con title como parámetro, se asigna valor a d y se definen el comando.

public Tabla(String title, Display d,hojaC hoja) {

super(title);

display = d;

addCommand(cmdAny);

setDefaultCommand(cmdAny);

setItemCommandListener(this);

hoja1=hoja;

}

El método paint es el encargado de dibujar el estado actual de la tabla, originalmente integra a la clase Canvas, y CustomItem lo hereda de esta. Lo primero que se hace es dibujar las líneas y los títulos de columna y renglón.

protected void paint(Graphics g, int w, int h) {

for (int i = 0; i <= rows; i++) {

if (i>0&&i

int ClipX = g.getClipX();

int ClipY = g.getClipY();

int ClipWidth = g.getClipWidth();

int ClipHeight = g.getClipHeight();

g.setClip(1, (i*dy), num - 1, dy - 1);

g.drawString(String.valueOf(i), num-2, ((i + 1) * dy)+1,

Graphics.BOTTOM | Graphics.RIGHT);

g.setClip(ClipX, ClipY, ClipWidth, ClipHeight);

}

if (i==0)

g.drawLine(0,0, cols * dx+num, i * dy);

g.drawLine(0, i * dy, cols * dx+num, i * dy);

}

for (int i = 0; i <= cols; i++) {

if (i>0){

int x;

x=((i * dx)+((i-1)*dx))/2;

int ClipX = g.getClipX();

int ClipY = g.getClipY();

int ClipWidth = g.getClipWidth();

int ClipHeight = g.getClipHeight();

g.setClip(((i-1)*dx)+num, 1, dx - 1, dy - 1);

g.drawString(letrade(i), x+num,dy,

Graphics.BOTTOM | Graphics.HCENTER);

g.setClip(ClipX, ClipY, ClipWidth, ClipHeight);

}else

g.drawLine(0,0, 0, rows * dy);

g.drawLine((i * dx)+num, 0, (i * dx)+num, rows * dy);

}

Después se dibuja un rectángulo de color diferente al resto para indicar la celda seleccionada.

int oldColor = g.getColor();

g.setColor(0x00D0D0D0);

g.fillRect((currentX * dx) + 1+num, ((currentY+1) * dy)+1, dx - 1, dy - 1);

g.setColor(oldColor);

Finalmente se busca en el arreglo data todas aquellas celdas que contengan algún valor y se dibuja su contenido en la posición adecuada.

for (int i = 1; i <>

for (int j = 0; j <>

if (data[i-1][j] != null) {

int oldClipX = g.getClipX();

int oldClipY = g.getClipY();

int oldClipWidth = g.getClipWidth();

int oldClipHeight = g.getClipHeight();

funcion func=new funcion(data);

g.setClip((j * dx) + num, i * dy+1, dx - 1, dy - 1);

g.drawString(func.Valor(data[i-1][j]), (j * dx) + num+1,

((i + 1) * dy) - 2, Graphics.BOTTOM | Graphics.LEFT);

g.setClip(oldClipX, oldClipY, oldClipWidth, oldClipHeight);

}

El método traverse está definido como integrante de CustomItem, esta clase utiliza los eventos de teclas de la clase Canvas para lograr el desplazamiento por las celdas de la tabla.

protected boolean traverse(int dir, int viewportWidth, int viewportHeight,

int[] visRect_inout) {

switch (dir) {

case Canvas.DOWN:

if (currentY < (rrows - 1)) {

currentY++;

repaint(currentX * dx, currentY * dy, dx, dy);

repaint(currentX * dx, currentY+1 * dy, dx, dy);

} else {

pantallaV++;

}

break;

case Canvas.UP:

if (currentY > 0) {

currentY--;

repaint(currentX * dx, (currentY + 2) * dy, dx, dy);

repaint(currentX * dx, (currentY+1) * dy, dx, dy);

} else {

pantallaV--;

return false;

}

break;

case Canvas.LEFT:

if (currentX > 0) {

currentX--;

repaint((currentX + 1) * dx, currentY * dy, dx, dy);

repaint(currentX * dx, currentY * dy, dx, dy);

}else{

pantallaH--;

}

break;

case Canvas.RIGHT:

if (currentX < (rcols - 1)) {

currentX++;

repaint((currentX - 1) * dx, currentY * dy, dx, dy);

repaint(currentX * dx, currentY * dy, dx, dy);

}else{

pantallaH++;

}

visRect_inout[0] = currentX;

visRect_inout[1] = currentY;

visRect_inout[2] = dx;

visRect_inout[3] = dy;

//Se actualiza el contenido de txt1, de la clase hoja.

hoja1.settexto(data[currentY][currentX]);

return true;

}

Se utiliza setText para almacenar en el arreglo data una cadena de caracteres que corresponde al valor de la celda actual.

public void setText(String text) {

if (text.compareTo("")==0){

text=null;

}

data[currentY][currentX] = text;

currentY--;

repaint(currentY * dx, currentX * dy, dx, dy);

}

Cuando en el menú se selecciona la opción "Nuevo", la clase hojaC llama al método limpiar, el cual recorre toda la tabla eliminando cualquier valor que ésta tenga y actualizando la celda.

public void limpiar() {

for(int y=0;y

for(int x=0;x

data[y][x] = null;

repaint(y * dx, x * dy, dx, dy);

}

Las funciones getdato, getText y getDatos se emplean para obtener el valor de la celda actual, de una celda determinada y de toda la tabla, respectivamente.

protected String getdato(){

return data[currentY][currentX];

}

protected String getText(int x, int y){

return data[y][x];

}

protected String[][] getDatos(){

return data;

}

Al seleccionar la opción "Valor" del menú se asigna a modo el valor para admitir cualquier carácter y se crea una instancia de Texto, mostrándola en pantalla.

public void commandAction(Command c, Item i) {

if (c==cmdAny){

modo=TextField.ANY;

Texto txt1 = new Texto(data[currentY][currentX], this, display, modo);

display.setCurrent(txt1);

}

Por efecto de claridad y espacio, se han omitido algunos fragmentos del código de la clase Tabla que se han considerado innecesarios en la explicación del funcionamiento de la clase, aunque eso no significa que no sean vitales para la operación real de la misma.

6.3.3.Clase Texto

La clase Texto extiende a la clase TextBox, motivo por el cual debe importar javax.microedition.midlet.MIDlet, aunque no sea una clase ejecutable por sí sola. Se utiliza una clase Tabla, una clase Display para mostrar el TextBox, los comandos CMD_OK y CMD_CANCEL para insertar el texto en la tabla o cancelar la modificación y una variable String que habrá de almacenar el texto ingresado.

package hoja;

import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;

public class Texto extends TextBox implements CommandListener {

private final static Command CMD_OK = new Command("OK", Command.OK,1);

private final static Command CMD_CANCEL = new Command("Cancelar",

Command.CANCEL,1);

private Tabla parent;

private Display display;

private String text;

El constructor toma como parámetros una cadena de texto, una clase Tabla que es la que lo llama, una clase Display donde se ha de mostrar ca caja de texto y una variable entera modo, esta variable entera está pensada para la posible utilización de varios formatos de cadenas de texto (numérico, carácter, correo electrónico, etc.). Los valores de los parámetros tomados se asignan a los objetos con el mismo nombre declarados en esta clase.

public Texto(String text, Tabla parent, Display display, int modo) {

super("Ingrese valor", text, 64, modo);

this.parent = parent;

this.display = display;

this.text=text;

addCommand(CMD_OK);

addCommand(CMD_CANCEL);

setCommandListener(this);

}

El método commandAction utiliza el método setText de la clase Tabla (parent en este caso) y regresa display a dicha clase si se selecciona el comando CMD_OK, de los contrario no utiliza setText.

public void commandAction(Command c, Displayable d) {

if (c == CMD_OK) {

parent.setText(getString());

display.setCurrentItem(parent);

} else

if (c == CMD_CANCEL) {

display.setCurrentItem(parent);

}

6.3.4.Clase funcion

Al igual que las hojas de cálculo para computadoras de escritorio, ésta permite la utilización de fórmulas para realizar operaciones, ya sea con valores constantes o con valores introducidos dentro de las celadas de la hoja. El formato para la utilización de fórmulas en hojaC es el siguiente:

operación(operando1, operando2, ... , operando n)

Donde los operandos pueden ser números enteros, celdas de la hoja (A1, B3, C4, por ejemplo) u otras funciones y operación se sustituye con el símbolo correspondiente a la operación que se desee realizar, tales símbolos se muestran en la tabla 6.1.

Tabla 6.1. Símbolos utilizados en las funciones de la hoja de cálculo.

*Símbolo*	*Función*	*Sintaxis*	*Ejemplo*
+	Suma.	+(op1, op2, ... , opn)	+(A1,2,8,B4)
-	Resta (A-B).	-(op1, op2)	-(356,*(A1,3))
*	Multiplicación.	*(op1, op2, ... , opn)	*(4,5,2,1,3)
/	División (A/B).	/(op1, op2)	/(25,5)
<	Mínimo.		<(32,1,0,A2)
>	Máximo.	>op1, op2, ... , opn)	>(C3,A2,B1,5)
%	Tanto por ciento (A * B%).	%(op1, op2)	%(100,25)
:	Promedio.	:(op1, op2, ... , opn)	:(10,9,8,7,6)
@	Potencia.	@(base, potencia)	@(9,2)
=	Igualación.	=(Valor)	=(B2)

A continuación se explica el código fuente de esta clase:

Se utilizará una variable data, la cual es una arreglo de String (igual al data de la clase Tabla), para tener acceso a todos los valores de la hoja, debido a que una función puede hacer referencia al valor de cualquier celda.

private static String data[][];

int lev=0;

public funcion(String[][] data1){

data=data1;

}

La función getDato toma como parámetro el nombre de una celda (A1, B2, etc.), lo transforma a coordenadas en la tabla ([1][2], por ejemplo) para después obtener el valor contenido en esa localidad, ese valor es el que esta función devuelve como cadena de caracteres.

private String getDato(String celda){

int x,y;

String a;

char b;

try{

a=celda.substring(1);

y=Integer.parseInt(a);

b=celda.charAt(0);

x=Character.digit(b,Character.MAX_RADIX)-9;

}catch (Exception e){

return "Error";

}

if ((x<1)||(y<1)||(x>24)||(y>65))

return "Error";

a=data[y-1][x-1];

if (a==null||a.compareTo("")==0)

return "0";

return data[y-1][x-1];

}

Los valores de las celdas que empleará una operación (suma, resta. división etc.) se almacenan en un objeto de la clase Vector, lo más similar en Java a los arreglos dinámicos de C++, de manera que primero se deben introducir todos los datos al vector y después se procesan según lo solicite la fórmula.

En la suma se convierten a enteros todos los términos del vector y se suman los resultados de tal conversión. Si alguno de los términos no se puede convertir (no es la representación de un entero) la función devuelve la constante -32767 que se ha designado como error.

private int suma(Vector datos){

int result=0,R=0;

for(int x=0;x

try{

R=Integer.parseInt(datos.elementAt(x).toString());

}catch (Exception e){

return -32767;

}

result+=R;

}

return result;

}

La resta se puede realizar únicamente entre dos elementos enteros, si el vector tiene más elementos o si alguno de ellos no se ha podido convertir a entero, se devuelve la constante de error (-32767), de lo contrario la resta se realiza y se devolverá el resultado.

private int resta(Vector datos){

int result,r=0,R=0;

int s=datos.size();

if(s==2){

try{

R=Integer.parseInt(datos.elementAt(0).toString());

r=Integer.parseInt(datos.elementAt(1).toString());

}catch (Exception e){

return -32767;

}

result=R-r;

}else{

result=-32767;

}

return result;

}

El proceso de la igualación es muy sencillo, sólo se verifica que en el vector exista un único elemento y se regresa ese valor, o -32767 de no ser así.

private String igual(Vector datos){

if(datos.size()==1){

return datos.elementAt(0).toString();

}else{

return "Error";

}

El proceso de multiplicación es igual al de la suma, se convierten los elementos a entero y se procesan (multiplican, en este caso) acumulativamente.

private int multi(Vector datos){

int result=1,R=0;

for(int x=0;x

try{

R=Integer.parseInt(datos.elementAt(x).toString());

}catch (Exception e){

return -32767;

}

result*=R;

}

return result;

}

Así como la suma y la multiplicación siguen el mismo procedimiento, la resta y la división también lo hacen, con las obvias diferencias en la operación medular.

private int divi(Vector datos){

int result,r=0,R=0;

if(datos.size()==2){

try{

R=Integer.parseInt(datos.elementAt(0).toString());

r=Integer.parseInt(datos.elementAt(1).toString());

}catch (Exception e){

return -32767;

}

result=R/r;

}else{

result=-32767;

}

return result;

}

Para calcular máximos y mínimos se utiliza la misma función, incluyendo el parámetro de entrada mm, el cual habrá de tomar un valor de 'm' si se trata de un mínimo o 'M' si lo que hay que calcular es el máximo. Al igual que el resto de las operaciones, el máximo y el mínimo también devuelven la constante de error si los datos del vector no se pueden convertir a enteros.

private int maxmin(Vector datos, char mm){

int M=-32767,x,B;

try{

M=Integer.parseInt(datos.elementAt(0).toString());

}catch(Exception e){

return -32767;

}

for (x=1;x

try{

B=Integer.parseInt(datos.elementAt(x).toString());

}catch(Exception e){

return -32767;

}

if(mm=='M')

if(M

M=B;

}

if(mm=='m')

if(M>B){

M=B;

}

return M;

}

El cálculo del tanto por ciento también utiliza sólo dos valores, el primero es el valor base y el segundo el tanto por ciento a calcular.

private int pciento(Vector datos){

int result,r=0,R=0;

if(datos.size()==2){

try{

R=Integer.parseInt(datos.elementAt(0).toString());

r=Integer.parseInt(datos.elementAt(1).toString());

}catch (Exception e){

return -32767;

}

result=R/100 * r;

}else{

result=-32767;

}

return result;

}

Debido a lo similares que son las funciones en su procedimiento, las siguientes sólo se especificarán en nombre, ya que sería una redundancia innecesaria el explicar los procesos ya explicados.

Promedio.

private int prom(Vector datos){

int result=0,R=0;

for(int x=0;x

try{

R=Integer.parseInt(datos.elementAt(x).toString());

}catch (Exception e){

return -32767;

}

result+=R;

}

result=result/datos.size();

return result;

}

Potencia.

private int pot(Vector datos){

int result,r=0,R=0;

if(datos.size()==2){

try{

R=Integer.parseInt(datos.elementAt(0).toString());

r=Integer.parseInt(datos.elementAt(1).toString());

}catch (Exception e){

return -32767;

}

result=1;

for (int x=0;x

result*=R;

}

}else{

result=-32767;

}

return result;

}

La función recurrente Valor es la que realiza la mayor parte del trabajo, toma el valor de la ceda tal y como se ha introducido, lo analiza para verificar si se trata de una constante o de una fórmula. En este último caso, separa sus términos, ordena la obtención del valor final (constante) de los datos y finalmente selecciona la operación a realizar.

public String Valor(String dato){

char c;

Vector A=new Vector();

String cad;

lev++;

Para evitar referencias circulares, no puede haber más de nueve niveles de anidación en las fórmulas.

if (lev>9){

dato=null;

return "Error";

}

cad=dato;

//separar términos

c=cad.charAt(0);//se toma el primer carácter (donde está el símbolo)

if(c=='+'||c=='-'||c=='*'||c=='/'||c=='<'||c=='>'||c=='%'||c==':'||

PROGRAMACIÓN MIDP

2009-04-09T12:28:00.000-07:00

PROGRAMACIÓN MIDP
En el presente capítulo se tratarán las características básicas de la programación de aplicaciones MIDP, NO se trata de un tutorial de programación, únicamente se revisarán los aspectos generales que hacen a la programación MIDP diferente de el resto de las aplicaciones Java. En el siguiente capítulo se desarrollará una aplicación y se explicará el funcionamiento de cada instrucción o bloque de instrucciones.

Pero primero se deben conocer los pasos a seguir en el proceso de desarrollo para facilitar su comprensión y dar una idea previa de lo que se deberá hacer.

5.1.Herramientas necesarias

A continuación se proporciona una lista con las herramientas necesarias para programar MIDlets.

-Plataforma de desarrollo Java (J2SDK, por ejemplo) disponible en java.sun.com.

-Editor de textos (block de notas, edit, vi, emacs, etc.).

-Compilador CLDC (1.0, 1.1) y al menos un perfil (MIDP, PDAP), ambos disponibles en java.sun.com.

Hay algunos paquetes de desarrollo Java que incluyen los dos últimos requisitos, además de proveer de otras herramientas que pueden facilitar la programación.

-Java Wireless Toolkit: Este paquete se puede descargar del sitio Java de Sun Microsystems, provee de un compilador (incluye CLDC y MIDP) y organizador de proyectos. Se crea en este programa un proyecto y automáticamente se generan las carpetas donde se han de guardar los códigos fuente, las clases, imágenes y otros accesorios que la aplicación utilice. Disponible para Windows y Linux. En la figura 5.1 se muestra la barra de herramientas de JWT (Java Wireless Toolkit).

Figura 5.1. Java Wireless Toolkit.

-Nokia Developer Suite for J2ME: En la sección de desarrolladores de Nokia (www.nokia.com) se puede descargar este entorno de desarrollo, incluye todo lo que se necesita para la programación de MIDlets (a excepción del SDK). Se puede instalar en plataformas Windows 2000, XP y Linux.

Este paquete puede resultar poco conveniente para computadoras poco actuales, ya que entre sus requerimientos se mencionan 256 MB de memoria RAM y procesador de 300 Mhz.

-Motorola SDK for J2ME. Sólo existe para Windows, es otro kit de desarrollo completo al que sólo hay que agregar el SDK de Java.

-Code Warrior. Quizá uno de los mejores entornos integrados de desarrollo (IDE) para la edición micro de la plataforma Java. Se puede descargar gratis después de suscribirse en el sitio de programadores de Motorola, aunque en versión de evaluación por treinta días.

-Sun ONE Studio: Otro entorno completo, bastante útil, incluye editor de texto, compilador, preverificador y simuladores para probar las aplicaciones. En el sitio oficial de Sun se puede descargar una evaluación de 60 días o comprar la versión completa.

En el presente documento se utilizará el Wireless Toolkit de Java, debido a que es más pequeño (en espacio de disco) y, por lo tanto, más fácil de obtener con una conexión telefónica a Internet, además de que está disponible para Linux que será la plataforma empleada para la programación.

5.2. Ciclo de desarrollo de una aplicación MIDP

Las aplicaciones MIDP (MIDlets) siguen un proceso desde que son ideadas hasta que están instaladas y ejecutándose en los dispositivos. Dicho proceso es el siguiente:

-Escritura.

-Compilación y preverificación.

-Prueba y corrección.

-Empaquetado.

-Prueba del paquete.

5.2.1. Escritura de la aplicación

Hay algunas reglas para el desarrollo de MIDlets, además de las establecidas por el lenguaje, que deben ser consideradas:

-Toda MIDlet debe importar los paquetes javax.microedition.midlet.* y javax.microedition.lcdui.*.

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

-javax.microedition.midlet.*. Define que se utilizará MIDP.

-javax.microedition.lcdui.*. Proporciona las apis de interfaz de usuario.

-Cada MIDlet debe extender la clase MIDlet.

public class FirstMIDlet extends MIDlet {

-Una MIDlet no debe tener ningún método public static void main(), contrario a lo que sucede en las aplicaciones Java de escritorio.

Constructor de la clase

public FirstMIDlet() { }

Inicia la MIDlet, en lugar de main().

public void startApp() { }

5.2.2. Compilar y preverificar

Cuando se utiliza Java Wireless Toolkit, o algún otro entorno de desarrollo, el proceso de compilación y preverificación es sumamente sencillo:

Una vez escrito el código de las clases que compongan la aplicación se ejecuta JWT y se abre la aplicación a compilar. En JWT se puede también depurar el código, probar y empaquetar la aplicación, etc.

Para compilar la MIDlet, una vez abierta, hay que seleccionar la opción "Build", esto creará el archivo de clase o bien indicará los errores que se tengan. El compilado con JWT incluye la preverificación.

También se puede compilar y preverificar el código fuente desde la linea de comando del sistema operativo. Teniendo correctamente instalado el SDK de Java y CLDC se utiliza:

javac -d .| bootclasspath [ruta] [archivo.java]

para crear el archivo de clase en el mismo directorio (-d .\) que el de código y para preverificar el resultado de la compilación se utiliza el comando:

preverify -classpath [ruta_clases]

este comando preverifica todos los archivos de clases en el directorio ruta_clases y guarda el resultado en un subdirectorio, dentro de esa ruta, llamado "output", para preverificar una sola clase hay que especificar su nombre.

5.2.3. Probando la MIDlet

Si no se utiliza JWT la aplicación puede ser probada, desde linea de comandos, con la siguiente instrucción:

midp [nombre_MIDlet]

Aunque si su aplicación consta de varias MIDlets o archivos de clase y requiere dejar que el usuario escoja cuales ejecutar, entonces es necesario empaquetar la aplicación.

Utilizando JWT este trabajo se simplifica bastante, sólo se abre un proyecto y, si ya está compilado y preverificado, se selecciona "Run" o "Ejecutar" para ver el resultado en un emulador (Fig. 5.2).

Figura 5.2. Una de las vistas del emulador de JWT

5.2.4. Empaquetado

Si una aplicación consta de múltiples clases, una archivo .jar es usado para agruparlas, así es más fácil de distribuir y desplegar. esto se puede hacer desde linea de comandos de la siguiente manera:

jar cf [archivo.jar] [clases]

El siguiente paso es crear el archivo descriptor de la aplicación (archivo .jad), el cual provee información sobre el contenido del archivo .jar. Un ejemplo de archivo descriptor de aplicación es el siguiente:

MIDlet-Name: MID1

MIDlet-Version:1.0.0

MIDlet-Vendor:Sun Microsystems, Inc.

MIDlet-Description: Primera MIDlet

MIDlet-Info-URL: http://java.sun.com/j2me.

MIDlet-Jar-URL: MID1.jar

MIDlet-Jar-Size: 1063

MicroEdition-Profile: MIDP-2.0

MicroEdition-Configuration: CLDC-1.0

MIDlet-1: MID,icono.png, MIDlet1

MIDlet-2: MID1,MIDlet2

Las primeras lineas resultarán, seguramente, más que obvias así que se explicará únicamente el último elemento (MIDlet-1), este contiene los datos de la primera MIDlet integrante del paquete (hay que recordar que un paquete se puede componer de muchas MIDlets) y consta de tres partes: nombre de la aplicación, ícono (opcional) y clase. El nombre aparecerá en la pantalla del dispositivo, acompañado del ícono (si existe), para que pueda ser seleccionado y la clase es el archivo compilado que se ejecuta al seleccionar un nombre.

5.2.5. Probar la aplicación empaquetada

Una vez que se ha empaquetado la aplicación, se puede probar para asegurar su funcionamiento agregando la opción -descriptor al comando midp.

midp -descriptor MID1.jad

Utilizando en kit de Java es el mismo proceso que probar la aplicación sin empaquetar, ya que al realizar el paquete se genera automáticamente el archivo descriptor.

5.3. Mapeo de teclas

Se le llama mapeo de teclas a la distribución que tienen las funciones del dispositivo (navegación, comandos, selección, etc.) sobre las teclas exteriores, es decir, la función desplazarse hacia la derecha, puede estar colocada en la tecla con el número 6 de un teléfono y esa misma función puede operar sobre la tecla "é" de otro dispositivo.

Cuando el programador requiere de aplicaciones altamente portables debe darle a este aspecto una gran importancia, no se puede permitir que un comando o función de su MIDlet quede inhabilitada a causa de un descuido de ese tipo.

5.4. Manejo de eventos

Cuando no se utilizan cajas de texto, listas o formularios en una pantalla, se puede tomar el control de las acciones a realizar cuando se presione, libere o mantenga presionada cierta tecla del dispositivo. A la presión (rápida o detenida) y liberación de teclas se les conoce como eventos, aunque no son el único tipo de eventos, también pueden serlo el cierre repentino y deliberado de la aplicación, la llegada de un mensaje o una llamada telefónica, el encendido del teléfono, en fin, un evento es toda acción llevada a cabo por un agente exterior a la MIDlet y que influya sobre su operación.

Un evento es, por tanto, una acción sobre la MIDlet, tomada por el usuario en tiempo de ejecución.

5.4.1.Llamadas

Se conoce como Llamada (Callback en inglés) a las invocaciones a métodos definidos por el programador que son ejecutados por la aplicación en respuesta a eventos.

Además de J2ME, los conceptos de llamadas y eventos son utilizados en muchos entornos de programación, principalmente aquellos con desarrollo de interfaces gráficas (Visual Basic, Delphi, Visual J, etc.).

En lenguajes como C++, las llamadas se implementan mediante apuntadores, una función desvía su apuntador a otra al ocurrir un evento. Como Java no utiliza apuntadores, las llamadas se implementan mediante interfaces, las interfaces son clases que únicamente tienen métodos únicamente definidos, las acciones a tomar en cada método dependen del programador, es decir, una interfaz es como el esqueleto de una clase que debe ser llenado por el programador.

En MIDP hay cuatro clases de llamadas de interfaces de usuario.

-Comandos abstractos que son parte de la API de alto nivel.

-Eventos de bajo nivel que representan presión y liberación de teclas.

-Llamadas al método paint() de una clase Canvas.

-Llamadas al método Run de objetos ejecutables (de la interfaz Runnable) solicitados por una llamada al método CallSerially de la clase Dispaly.

5.4.2.Navegación en pantalla

Un aplicación MIDP, a excepción de las demasiado sencillas, siempre utilizará más de una pantalla, por lo que resulta necesaria una herramienta que permita a los usuarios desplazarse de una pantalla a otra según lo requiera la propia MIDlet.

El paquete javax.microedition.lcdui proporciona la clase Command, la cual captura la información de un evento. Un comando creado con la clase Command solamente contiene información sobre él mismo, no de la acción que realiza cuando está activado, la acción está definida en un objeto de la interfaz CommandListener asociado con la pantalla. A continuación se muestra como declarar un comando:

Command miComando=new Command("Mio", Command.SCREEN,2);

Los tres parámetros que el constructor de la clase Command debe incluir son los siguientes:

-Etiqueta: Una cadena de caracteres usada para la presentación visual del comando.

-Tipo: Especifica su intención, es decir, la acción que realizará el comando. Algunos tipos pueden ser:

-Command.SCREEN.

-Command.EXIT.

-Command.BACK.

-Command.ITEM

-Prioridad: Describe la importancia del comando con respecto a otros en pantalla. Una prioridad de 1 indica al comando más importante.

Cuando una MIDlet se ejecuta, el dispositivo escoge el lugar de un comando basándose en su tipo (abajo y a la izquierda para salir, por ejemplo) y coloca los comandos similares con base en su valor de prioridad. Considérese una aplicación con los siguientes comandos:

Command Salir=new Command("Exit", Command.EXIT,1);

Command miCom=new Command("Mio1", Command.SCREEN,2);

Command miCom2=new Command("Mio2", Command.SCREEN,2);

En este ejemplo, el manejador de la aplicación coloca el comando Exit en la pantalla y crea un menú para mantener Info y Buy. Presionando la tecla correspondiente al menú, el usuario, es llevado a otra pantalla donde puede seleccionar alguna de las dos opciones. (Fig. 5.3)

La clase Command provee de tres métodos para conocer tipo, etiqueta y prioridad del comando.

-int getCommandType().

-String getLabel().

-int getPriority().

Figura 5.3. Ejemplo de la clase Command.

5.4.3. Eventos de alto nivel

El manejo de eventos en la api de alto nivel se basa en un modelo de escucha o escuchante (listener, en inglés). Los objetos Screen y Canvas pueden tener "escuchantes" para comandos. Para que un objeto pueda ser un escuchante, debe implementar la interfaz CommandListener.

Los comandos se agregan a un objeto con el método addCommand y se registra un escuchante con el método CommandListener. Ambos métodos pertenecen a la clase Displayable y son heredados por Screen y Canvas.

5.4.3.1.La interfaz CommandListener

Esta interfaz es para MIDlets que necesitan recibir eventos de alto nivel. Esta interfaz tiene un método que todo escuchante debe implementar, el método CommanAction.

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

El parámetro c es un objeto Command que identifica al comando que fue agregado al d (objeto Displayable) con el método addCommand. El parámetro d es el objeto visible (Form, Canvas, Screen) donde el evento ocurre. Dentro de las llaves ({ }) se introduce el código que se habrá de ejecutar al ocurrir un evento.

public void commandAction(Command c, Displayable s) {

if (c == CmdSalir) {

destroyApp(false);

notifyDestroyed();

}

En el trozo de código mostrado arriba se emplea una decisión if para identificar qué comando es el que ha sido activado, si se trata del comando CmdSalir se destruye la aplicación, es decir, se cierra y se notifica su destrucción.

5.4.3.2.La interfaz ItemStateListener

Las aplicaciones usan esta interfaz para recibir eventos que indican cambios en el estado interno de los elementos en una pantalla, formulario. Esto pasa cuando el usuario hace cualquiera de las siguientes cosas.

-Ajustar el valor de una barra de avance interactiva.

-Ingresar o modificar el valor de un TextField.

-Ingresar una nueva fecha u hora en una DateField.

-Cambiar los valores seleccionados en un ChoiceGroup.

Esta interfaz tiene un único método que un escuchante debe implementar.

public void itemStateChanged(Item i){ }

Para registrar un escuchante de esta interfaz se utiliza el método setItemStateListener.

ItemStateListener listener = new ItemStateListener();

Form.setItemStateListener(listener);

public void itemStateChanged(Item item) {

}

5.4.4.Eventos de bajo nivel

Si se usa la clase Canvas para tener acceso a eventos de entrada o para dibujar gráficos en la pantalla, es necesario manejar los eventos de bajo nivel. Aplicaciones como los juegos, pueden ser realizadas utilizando la clase Canvas, gracias a que esta posee métodos para controlar eventos de teclas y los llamados "eventos de juego". Los eventos de teclas se registran como códigos específicos que están directamente relacionados a las teclas del aparato. Los eventos de juego producen un código relacionado con la acción asignada a una tecla del dispositivo.

5.4.4.1.Eventos de teclas

Como ya se mencionó, los eventos de teclas están relacionados directamente con las teclas del dispositivo. Los eventos de teclas definidos en la clase Canvas son:

-KEY_NUM0.

-KEY_NUM1.

-KEY_NUM2.

-KEY_NUM3.

-KEY_NUM4.

-KEY_NUM5.

-KEY_NUM6.

-KEY_NUM7.

-KEY_NUM8.

-KEY_NUM9.

-KEY_STAR.

-KEY_POUND.

Los números del 0 al 9, el asterisco "*" y la almohadilla "#" son las teclas genéricas en todos los dispositivos, quizá existan otros eventos en diferentes dispositivos, pero por motivos de portabilidad, se recomienda solamente usar estos.

5.4.4.2.Eventos de juego

Debido a que en los equipos actuales varía mucho la distribución de las teclas, si se requiere una localización específica de estas, flechas de dirección, por ejemplo; es necesario utilizar los eventos de juego, estos eventos son los siguientes:

-DOWN.

-LEFT.

-RIGHT.

-UP.

-FIRE.

-GAME_A.

-GAME_B.

-GAME_C.

-GAME_D.

Anteriormente se explicó que cada aparato mapea sus teclas de forma diferente al resto. Con los eventos de juego se puede lograr que la aplicación reaccione a la presión de una tecla que indique movimiento hacia arriba en el dispositivo anfitrión, independientemente del código de esta tecla.

5.4.5.Métodos de manejo de eventos

Para el manejo de eventos de bajo nivel, J2ME provee al programador de los siguientes métodos:

-protected void keyPressed (int keyCode).

-protected void keyReleased (int keyCode)

-protected void keyRepeated (int keyCode)

-protected void pointerPressed (int x, int y)

-protected void pointerDragged (int x, int y)

-protected void pointerReleased (int x, int y)

-protected void showNotify ()

-protected void hideNotify ()

-protected abstract void paint (Graphics g)

-commandAction(). De la interfaz CommandListener.

Cabe aclarar que los eventos de apuntador (pointer) no son aplicables a todos los dispositivos, sólo para aquellos que cuenten con un indicador de ese tipo (apuntador de ratón, por ejemplo), se puede comprobar si el equipo lo soporta utilizado los métodos hasPointerEvents y hasPointerMotionEvents. Otro método que podría no estar disponible en algún dispositivo es keyRepeated, se puede comprobar su operabilidad con el método hasRepeatEvents.

5.5. Principales componentes

Son muchos y muy variados los componentes que incluyen las apis de MIDP y CLDC, además cada programador puede crear componentes propios tomando como base los ya existentes.

Por lo anterior, se explicarán sólo aquellos que son considerados cómo básicos para la realización de aplicaciones en general.

En la tabla 5.1 se muestra cada uno de los componentes y una breve descripción de estos.

Tabla 5.1. Clases del paquete lcdui.

Clase

Descripción

Alert

Pantalla que muestra un mensaje al usuario y espera un cierto periodo de tiempo antes de pasar a la siguiente pantalla.

AlertType

Indica la naturaleza de las alertas (exclamación, error, etc.).

Canvas

Es la base para la escritura de aplicaciones que utilicen eventos de bajo nivel y para dibujar objetos gráficos en la pantalla.

ChoiceGroup

Un grupo de elementos seleccionables, colocados dentro de una forma (Form).

Command

Una estructura que encapsula la información semántica de una acción (p. ej. "Salir").

DateField

Componente modificable para presentar en pantalla la información de hora y fecha.

Display

Representa el manejador de pantalla y dispositivos de entrada (teclas) del sistema.

Displayable

Característica de un objeto que tiene la capacidad de ser mostrado en la pantalla.

Font

Representa las propiedades de la fuente (letra).

Form

Una pantalla que contiene una mezcla arbitraria de elementos (imágenes, cajas de texto, etc.)

Gauge

Una barra que puede ser utilizada como indicador de avance en un proceso.

Graphics

Provee la capacidad de presentar gráficos 2D simples.

Image

Muestra una imagen.

ImageItem

Proporciona el control de trazado (colocación) de una imagen en una forma o alerta

Item

Superclase para elementos que van a ser adheridos a una forma o alerta.

List

Muestra una lista de opciones.

Screen

La superclase de todas las clases de interfaz de usuario de alto nivel.

StringItem

Un elemento que puede contener una cadena de caracteres.

TextBox

Pantalla que permite al usuario insertar y modificar texto.

TextField

Un componente de texto modificable que puede ser colocado en una forma.

Ticker

Un texto que cruza continuamente la pantalla, puede ser agregado en todos los tipos de pantalla a excepción de canvas.

En los siguientes apartados se verá como utilizar algunas de las clases listadas en la tabla anterior, esto mediante la explicación de programas sencillos que, aunque pudiesen carecer de utilidad, ilustran de forma clara la forma de implementar una clase determinada.

5.5.1.¡Hola mundo!

Se iniciará esta serie de programas de ejemplo con el clásico código fuente de una aplicación que lo único que hace es mostrar un mensaje en la pantalla, en este caso el mensaje es "¡Hola mundo!".

El código fuente es el siguiente:

import javax.microedition.lcdui.*;

import javax.microedition.midlet.*;

Se comienza por importar los paquetes que son obligatorios para cualquier MIDlet. Esto puede variar dependiendo de la finalidad de la clase a crear, pero para una clase que será la principal de su paquete, es forzoso el importar las clases del paquete javax.microedition.midlet y lcdui se requiere para las operaciones de entrada y salida de información.

public class Holamundo extends MIDlet implements CommandListener {

Se inicia el código de la clase, la cual extiende (o hereda) la clase MIDlet, necesaria, como ya se dijo, para la creación de clases ejecutables, además se implementa la interfaz CommandListener, esta interfaz define una estructura de clase en la que se deben declarar unos objetos llamados comandos, los cuales responderán a alguna acción del usuario.

private Form Forma1;

Se ha instanciado un objeto de la clase Form, que, como ya se vio, pertenece al paquete lcdui. Un objeto Form define una pantalla donde se agregarán objetos de entrada y salida de datos por teclado y pantalla, respectivamente.

public Holamundo() {

Forma1 = new Form("¡Hola mundo!");

Forma1.append(new StringItem(null, "¡Hola mundo!"));

Forma1.addCommand(new Command("Salir", Command.EXIT, 1));

Forma1.setCommandListener(this);

}

En la sección de arriba se describe el constructor de la clase, el cual debe llevar el mismo nombre que la clase, sin especificar tipo y de acceso público. En un constructor de clase se establecen los valores que han de tomar las variables, se crean las instancias de las clases, en fin, se define como habrá de presentarse, al arrancar, la aplicación al usuario. Al iniciar el constructor se instancia un objeto Form con título "¡Hola mundo!" y de nombre Forma1, enseguida, a esa misma forma se le agrega un elemento SringItem sin etiqueta (título o descripción) y con un contenido igual a "¡Hola mundo!", se agrega también, un comando, los comandos son las opciones que, en un teléfono celular, aparecen en la parte inferior de la pantalla y que el usuario puede seleccionar presionando las teclas que se encuentran debajo del texto; ese comando tiene por texto o etiqueta la palabra "Salir", es del tipo EXIT y de prioridad 0. En un comando, la prioridad indica la importancia de ese comando con respecto a otros en la pantalla, dicha prioridad puede ir de 1 a 10, siendo 1 el valor de prioridad más alto.

public void startApp() {

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

}

El método startApp es el que se ejecuta después del constructor, en el se encuentran las instrucciones que serán ejecutadas por la aplicación (es como el procedimiento main de las aplicaciones en C o Java). En el ejemplo, se utiliza un objeto Display que se encarga del control de la pantalla, un método getDisplay(this), el cual arroja como resultado la pantalla del dispositivo (como salida de datos para la MIDlet this, la actual) y otro método setCurrent(Forma1), que indica que lo que se ha de mostrar en la pantalla será lo contenido en Forma1.

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

public void commandAction(Command c, Displayable s) {

notifyDestroyed();

}

}

Las funciones pauseApp y destroyApp, también son obligatorias de cualquier clase MIDP (sea la principal del proyecto o no), en pauseApp se pueden definir las acciones a tomar cuando la aplicación sea pausada por el usuario, por la misma aplicación o por otra; destroyApp indica lo que se realizará antes de cerrar la aplicación. El método commandAction define lo que se hará con los comandos de la MIDlet, como en el ejemplo sólo se tiene un comando basta con notificar la destrucción de la aplicación,
5.5.2.TextBox
La clase TextBox, genera objetos de pantalla completa, como Form,la diferencia es que TextBox únicamente permite la introducción de texto y el manejo de comandos. A continuación se presenta un ejemplo sencillo:

import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

public class TextBoxDemo extends MIDlet

implements CommandListener {

private Command CmdSalir;

private Display display;

private TextBox t = null;

De esta primera parte sólo hay que resaltar la creación de un objeto TextBox de nombre t y valor nulo.

public TextBoxDemo() {

display = Display.getDisplay(this);

CmdSalir = new Command("Salir", Command.EXIT, 2);

t = new TextBox("Hola", "Esto es una prueba", 256, 0);

t.addCommand(CmdSalir);

t.setCommandListener(this);

}

En el constructor de la MIDlet se observa la designación del contenido de la pantalla (esta MIDlet), la creación de un comando de salida de prioridad 2, la instanciación de t con título "Hola", texto inicial "Esto es una prueba", longitud máxima de texto de 256 caracteres y tipo 0, los tipos son valores constantes que la clase TextBox interpreta para permitir la entrada de algunos caracteres e impedir la de otros, en el ejemplo el tipo 0 es la constante Textfield.ANY, que indica que se puede introducir cualquier carácter (también existen Textfield.NUMERIC, TextField.DECIMAL y TextField.PHONENUMBER, entre otras). Después de creado el objeto t, se le agrega el comando CmdSalir.

public void startApp() {

display.setCurrent(t);

}

En el método startApp se indica que el elemento en pantalla será t.

public void pauseApp() {

}

public void destroyApp(boolean unconditional) {

}

public void commandAction(Command c, Displayable s) {

if (c == CmdSalir) {

destroyApp(false);

notifyDestroyed();

}

}

}

Cuando una MIDlet tiene más de un comando (aunque no es el caso de esta) se puede realizar una decisión con el parámetro c para definir las acciones a tomar en cada comando.
5.5.3.TextField
El elemento Textfield trabaja sobre una forma (Form), por lo que ésta debe ser declarada e instanciada antes de utilizar el Textfield.

private Form mainForm;

mainForm = new Form("Text Field");

private TextField txt1;

txt1=newTextField("Cualquier carácter", "", 15, TextField.ANY)

Una vez instanciada la forma, se utiliza el método append para crear en ella los campos de texto que consideremos necesarios:

mainForm.append(txt1);

mainForm.append(new TextField("E-Mail", "", 15, TextField.EMAILADDR));

mainForm.append(new TextField("Entero", "", 15, TextField.NUMERIC));

mainForm.append(new TextField("Decimal", "10.5", 15, TextField.DECIMAL));

mainForm.append(new TextField("Teléfono", "", 15, TextField.PHONENUMBER));

mainForm.append(new TextField("Password", "", 15, TextField.PASSWORD));

mainForm.append(new TextField("URL", "", 15, TextField.URL));

Como se puede observar, el constructor de la clase Textfield lleva cuatro parámetros, el primero de ellos indica la etiqueta que habrá de llevar el campo de texto, en el segundo se debe especificar el valor inicial, el siguiente es la longitud (en caracteres) que habrá de tolerar el campo y el último indica el filtro a utilizar para dicho campo, es decir, que caracteres admitirá.

Quizá el lector observe que, el utilizar la palabra clave new dentro de los paréntesis del método append podría limitar el control que se tenga sobre los objetos de la forma, por lo tanto es recomendable declarar e instanciar antes los objetos y sólo nombrarlos en append, como se hizo con txt1.

Hay varios filtros además de los mostrados en el ejemplo, se recomienda al lector interesado revisar la especificación de la clase Textfield.
5.5.4.Datefield
Hasta ahora no se ha descrito, en las clases TextField y TextBox, un método relativamente fácil para introducir una fecha, los signos "/" en un teléfono son un poco difíciles de localizar, sin contar con que los números son la última o una de las últimas opciones en el orden de las teclas de la mayoría de los equipos, estos problemas no lo son tanto si se utiliza la clase DateField. Enseguida se explica cómo.

public class DateFieldDemo extends MIDlet implements CommandListener{

private final static Command CmdSalir = new Command("Salir", Command.EXIT,1);

private boolean primera;

private Form mainForm;

public DateFieldDemo() {

Primera = true;

Forma = new Form("Ejemplo de fecha");

}

En esta clase de nombre DateFieldDemo, se utilizan por primera vez los cambios de pantalla, implícitos en la clase DateField, es por esto que se crea una variable lógica Primera que servirá para no instanciar los objetos dos veces (al iniciar la MIDlet y al volver del cambio de pantalla).

protected void startApp() {

if(Primera) {

Forma.append(new DateField("Fecha", DateField.DATE));

Forma.append(new DateField("Hora", DateField.TIME));

Forma.append(new DateField("Fecha y hora",

DateField.DATE_TIME));

Forma.addCommand(CmdSalir);

Forma.setCommandListener(this);

Primera = false;

}

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

}

Además de los ya conocido, en startApp se agregan a la forma tres campos de fecha, el primero pedirá, según la forma que tenga dispositivo de hacerlo, la fecha; el segundo pedirá la hora y el tercero ambos datos.

protected void destroyApp(boolean unconditional) { }

protected void pauseApp() { }

public void commandAction(Command c, Displayable d) {

if (c == CmdSalir) {

destroyApp(false);

notifyDestroyed();

}

}

}
5.5.5.StringItem
Cuando lo que se desea no es pedir al usuario un dato, sino mostrarle información, seguramente no es recomendable utilizar clases cuyo contenido pueda ser alterado. Para esto se utiliza la clase StringItem.

public class StringItemDemo extends MIDlet implements CommandListener,

ItemCommandListener {

private Display display;

private Form mainForm;

private final static Command IR = new Command("Ir", Command.ITEM, 1);

private final static Command PRES = new Command("Pres",

Command.ITEM, 1);

private final static Command Salir = new Command("Salir",

Command.EXIT, 1);

En esta primera parte del código de la clase, se puede ver que se ha implementado una nueva interfaz, ItemCommmandListener, la cual se utiliza para agregar comandos, no sólo a los objetos de pantalla completa (como TextBox o Form), sino a los agrupados en estos objetos. Ahora podemos utilizar los comandos de tipo ITEM.

protected void startApp() {

display = Display.getDisplay(this);

mainForm = new Form("String Item Demo");

mainForm.append("Esto es sólo una etiqueta");

StringItem item = new StringItem("Etiqueta de String Item: ",

"Texto de String Item");

mainForm.append(item);

item = new StringItem("Etiqueta: ", "texto");

mainForm.append(item);

item = new StringItem("Hipervínculo ", "Ir a", Item.HYPERLINK);

item.setDefaultCommand(IR);

item.setItemCommandListener(this);

mainForm.append(item);

item = new StringItem("Botón ", "Presionar", Item.BUTTON);

item.setDefaultCommand(PRES);

item.setItemCommandListener(this);

mainForm.append(item);

mainForm.addCommand(Salir);

mainForm.setCommandListener(this);

display.setCurrent(mainForm);

}

En startApp sólo se muestran las posibilidades que se tienen para escribir un texto que el usuario no pueda modificar y que además pueda ejecutar alguna acción. Desde simplemente escribir "Esto es sólo una etiqueta" hasta un botón que, al ser presionado, puede realizar una tarea. En el ejemplo, se distinguen dos tipos de constructores de StringItem, el primero, que tiene como parámetros dos cadenas de texto (etiqueta o título y contenido) y el segundo, que además permite la definición de un tipo de texto (hipervínculo o botón).

public void commandAction(Command c, Item item) {

if (c == IR) {

String text = "Ir a la URL...";

Alert a = new Alert("URL", text, null, AlertType.INFO);

display.setCurrent(a);

} else if (c == PRES) {

String text = "Do an action...";

Alert a = new Alert("Action", text, null, AlertType.INFO);

display.setCurrent(a);

}

}

public void commandAction(Command c, Displayable d) {

destroyApp(false);

notifyDestroyed();

}

Tal vez llame la atención el hecho de tener dos funciones con el mismo nombre (CommandAction), pero hay que observar los parámetros que toman al activarse, ambas capturan un evento en el teclado, pero la primera captura los eventos ocasionados en el componente de la forma que esté seleccionado, mientras el otro se ocupa de los eventos generales y funcionan solamente sobre los eventos

protected void destroyApp(boolean unconditional) { }

protected void pauseApp() { }

}
5.5.6.ChoiceGroup
Los grupos de selección o ChoiceGroup, por su nombre en inglés, son listados de elementos en los que se puede seleccionar uno o varios de ellos y permiten realizar operaciones (principalmente comparaciones lógicas) con dicha selección.

import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;

public class Choice1 extends MIDlet implements CommandListener {

private final static Command CMD_Salir = new Command("Salir",

Command.EXIT,1);

private Display display;

private boolean primera;

private Form Forma;

public ChoiceGroupDemo() {

primera = true;

}

Hasta este punto todo se ve como en los ejemplos anteriores, se importan las clases, se define la clase con extensiones e implementaciones, se crea un comando que se utilizará para salir de la MIDlet, se declaran los objetos y variables a utilizar y se determina lo que ha de hacer el constructor.

protected void startApp() {

if(primera) {

display = Display.getDisplay(this);

Forma = new Form("Choice Group");

Forma.append("Choice Group");

Image[] ArrImg = null;

try {

Image Imag = Image.createImage("/midp/uidemo/icono.png");

ArrImg = new Image[] { Imag, Imag, Imag, Imag };

} catch (java.io.IOException err) {

}

String[] arrString = {

"Opcion A", "Opcion B", "Opcion C", "Opcion D"

};

ChoiceGroup[] grupos = {

new ChoiceGroup("Exclusivo", ChoiceGroup.EXCLUSIVE,

arrString,ArrImg),

new ChoiceGroup("Multiple", ChoiceGroup.MULTIPLE,

arrString,ArrImg),

new ChoiceGroup("Pop-Up", ChoiceGroup.POPUP,

arrString,ArrImg)

};

for (int iter = 0; iter <>

Forma.append(grupos[iter]);

}

Forma.addCommand(CMD_Salir);

Forma.setCommandListener(this);

primera = false;

}

display.setCurrent(Forma);

}

startApp crea tres grupos de selección, exclusivo, múltiple y pup-up. Todos estos grupos contienen cuatro opciones (A, B, C y D) y cuatro iconos, correspondientes, cada uno, a una opción, contenidos en arrString y arrImg, respectivamente.

El grupo exclusivo es aquel que permite que uno y sólo uno de sus elementos esté seleccionado. El grupo múltiple permite la selección de uno o varios elementos. El modo pop-up permite escoger una sola opción, pero, a diferencia del exclusivo, las muestra en un menú desplegable.

public void commandAction(Command c, Displayable d) {

if (c == CMD_Salir) {

destroyApp(false);

notifyDestroyed();

}

}

protected void destroyApp(boolean unconditional) {

}

protected void pauseApp() {

}

}
5.5.7.List
Una lista de elementos, a diferencia de lenguajes como HTML WML, en J2ME es una lista de la que se puede seleccionar un elemento, es decir, es como un grupo de selección (ChoiceGroup). A continuación se muestra un código de ejemplo para la utilización de listas:

public class Lista extends MIDlet implements CommandListener {

private final static Command SALIR = new Command("Salir",

Command.EXIT, 1);

private final static Command ATRAS = new Command("Atrás",

Command.BACK, 1);

private Display display;

private List Lista1;

private List ListaEx;

private List ListaIm;

private List ListaMul;

private boolean primera;

En esta primera parte del código únicamente se han declarado las variables y los objetos que se utilizarán, notese que entre esos objetos se encuentran cuatro listas u objetos List.

public Lista() {

display = Display.getDisplay(this);

String[] Opciones = {"Opción A", "Opción B", "Opción C", "Opción D"

};

Image[] imagenes = null;

ListaEx = new List("Exclusiva", Choice.EXCLUSIVE, Opciones,

imagenes);

ListaEx.addCommand(ATRAS);

ListaEx.addCommand(SALIR);

ListaEx.setCommandListener(this);

ListaIm = new List("Implícita", Choice.IMPLICIT, Opciones,

imagenes);

ListaIm.addCommand(ATRAS);

ListaIm.addCommand(SALIR);

ListaIm.setCommandListener(this);

ListaMul = new List("Múltiple", Choice.MULTIPLE, Opciones,

imagenes);

ListaMul.addCommand(ATRAS);

ListaMul.addCommand(SALIR);

ListaMul.setCommandListener(this);

primera = true;

}

El constructor de la clase principal crea un arreglo Opciones que contiene los elementos de la lista, otro arreglo imagenes de valor nulo que definirá las imágenes a utilizar como iconos a mostrar al lado de los elementos; finalmente se instancian las listas según el tipo al que pertenecerán y se les agrega un comando ATRAS y otro SALIR.

¿Qué es J2ME?

2009-04-08T12:19:00.000-07:00

¿QUÉ ES J2ME?
J2ME (Java 2 Micro Edition) es la plataforma basada en el lenguaje Java que Sun Microsystems ha creado para la programación de dispositivos inalámbricos pequeños como teléfonos celulares, paginadores y PDA. La figura 4.1 muestra como está compuesta la plataforma J2ME.

Figura 4.1. Componentes de J2ME
4.1.Perfiles, configuraciones y máquinas virtuales
La edición micro de Java se compone, además del lenguaje, de una máquina virtual, configuraciones, perfiles y paquetes adicionales (Fig. 4.1).

La máquina virtual es la base de la plataforma, es el interprete del lenguaje y sobre la cual se han de ejecutar las aplicaciones, también sobre esta máquina virtual corren las configuraciones (CDC y CLDC), las cuales incorporan apis básicas para la creación de aplicaciones y sirven de soporte a los perfiles. Los perfiles incluyen la mayor parte de las clases y apis que se van a utilizar en la programación, como pueden ser instrucciones de entrada y salida o de inicio y terminación de la aplicación.

Los paquetes adicionales son aquellos que la especificación de la tecnología inalámbrica Java (JSR185) no establece como obligatorios para incorporar en los dispositivos. Ejemplos de esto pueden ser las apis de mensajes inalámbricos (WMAPI) y de multimedia (WMAPI).

4.2. MIDP 2.0

Hasta este momento es el único perfil aplicado a los dispositivos en el mercado, aunque se están investigando algunos otros, como el especializado en PDA.

MIDP 2.0 incorpora apis de interfaz de usuario, de ciclo de vida del programa, almacenamiento persistente, juegos, trabajo en red y multimedia. Según la especificación de la tecnología inalámbrica de Java todo dispositivo que soporte MIDP 2.0 debe incluir mínimamente las siguientes características:

-Debe permitir archivos Java (JAR) de más de 64 KB. y archivos descriptores de aplicaciones (JAD) mayores a 5 KB.

-Se debe permitir a cada MIDlet la utilización de 30 KB de almacenamiento persistente y se recomienda que las MIDlets incluyan información acerca de el almacenamiento mínimo con el que trabajan correctamente.

-El espacio de memoria libre para una aplicación ejecutándose (Heap o del montón) debe ser por lo menos de 256 KB.

-Soporte para pantallas de 125 x 125 pixeles, con una profundidad de color de 12 bits.

-Se deben incluir la capacidad de que el dispositivo reaccione a eventos de tiempo (una alarma a determinada hora, los llamados ticklers o despertadores).

-Mecanismos para tomar un número telefónico del directorio del equipo.

-Soporte para imágenes en formato JPEG y PNG.

-Acceso a contenidos multimedia por el protocolo HTTP 1.1.

4.3. CLDC 1.1

Además de la Configuración para Dispositivos Conectados (CDC), CLDC (Connected Limited Device Configuration) es la única opción en configuraciones en la tecnología inalámbrica Java, aunque esta última está dedicada a la clase de aparatos que nos ocupan.

CLDC es la base para que los perfiles (como MIDP o PDAP) funcionen, proveyendo las apis básicas y la máquina virtual (KVM). CLDC está diseñada para equipos microprocesadores RISC o CISC de 16 a 32 bits y con una memoria mínima de 160 KB para la pila de la tecnología Java.

La JSR185 pide como requisitos mínimos para todo equipo que implemente CLDC 1.0 o 1.1

-Soporte mínimo para diez hilos relacionados con aplicaciones (MIDlets).

-Usar zonas de tiempo personalizables, con referencia en el formato de zonas de tiempo GMT (GMT \7:00, por ejemplo).

-Soporte para propiedades de carácter y conversiones mayúsculas-minúsculas en los bloques suplementales Unicode para Basic Latin y Latin-1 (nuestros caracteres).

4.4. KVM

Como ya se explicó anteriormente la máquina virtual es la base de la plataforma Java.

En el caso de la plataforma J2ME, debido a las capacidades limitadas de almacenamiento, memoria, procesamiento y pantalla de los dispositivos; no se puede integrar una máquina virtual Java (JVM) del las dimensiones de J2SE o J2EE. Por esto se ha creado una nueva máquina virtual: KVM (Kilobyte Virtual Machine)

KVM es una máquina virtual Java compacta y portable específicamente diseñada para ser la base de desarrollo en dispositivos pequeños y de recursos limitados. Actualmente CLDC trabaja sobre KVM. Además KVM está diseñada para mantener los aspectos centrales del lenguaje Java ejecutándose en unos cuantos kilobytes de memoria (de ahí su nombre).

Aunque KVM deriva de la máquina virtual J2SE (JVM), algunas características de esta última han sido eliminadas para soportar CLDC, debido a que resultan demasiado costosas de implementar o su presencia supone problemas de seguridad, resultando una KVM con las siguientes limitantes:

-Soporte de punto flotante.- KVM no soporta números de punto flotante, esto debido a que la mayoría de los dispositivos en los que se implementa no lo soportan tampoco.

-Finalización.- Las apis CLDC no incluyen el método object.finalize, así que no se pueden hacer operaciones de limpieza final antes de que el recolector de basura tome los objetos.

-Manejo de errores.- CLDC sólo define tres clases error: java.lang.Error, java.lang.OutOfMemoryError y java.lang.VirtualMachineError. Todo tipo de errores que no sean en tiempo de ejecución se manejan de modo dependiente del dispositivo, esto incluye la finalización de una aplicación o reinicio del dispositivo.

-Interfaz Nativa Java (JNI).-No se implementa JNI (posibilidad de incluir código en C dentro de clases Java), primeramente por motivos de seguridad, aunque también es considerado excesivo dadas las limitantes de memoria del dispositivo al que se dirige.

-Cargadores de clases definidas por el usuario.- KVM debe tener un cargador de clases que no pueda ser manipulado o remplazado por el usuario, principalmente por razones de seguridad.

-No hay soporte para la API reflection. La API reflection es más bien usada para aplicaciones de bajo nivel (depuradores, constructores GUI, etc). La falta de esta API impide también la serialización de objetos.

-Grupos de hilos o hilos "demonio".- Aunque CLDC soporta programación multihilo, no soporta grupos de hilos o hilos "demonio". Si requiere usar operaciones para grupos de hilos use objetos de colección para almacenar los objetos hilo a nivel de aplicación.

-Referencias débiles.- Ninguna aplicación construida con CLDC puede requerir referencias débiles.

4.4.1.Verificador de clases

En la máquina virtual de J2SE, el verificador de clases es el responsable de rechazar archivos de clase no válidos. Una máquina virtual que soporte CLDC (ahora KVM) también debe ser capaz de rechazar estos archivos. Sin embargo, el proceso de verificación de clases es tardado y costoso y, por lo tanto, no recomendable para equipos con recursos limitados.

Los diseñadores de KVM decidieron mover la mayor parte del trabajo de verificación de clases fuera del dispositivo, es decir, hacia la computadora de escritorio donde las clases son compiladas o el servidor de donde se descargan. A este proceso de verificación se le llama preverificación. Los dispositivos son únicamente responsables de ejecutar algunas pruebas en la clase preverificada para asegurarse de que aún es válida.

4.5. Apis en J2ME-CLDC

Las apis para CLDC tienen el objetivo de proveer un conjunto de bibliotecas mínimo y útil para el desarrollo de aplicaciones y definición de perfiles para una gran variedad de aparatos.

Las apis CLDC se pueden dividir en dos categorías:

-Clases derivadas de apis J2SE. Estas se localizan en los paquetes java.lang, java.io y java.util y se derivan de apis del Java Developement Kit (JDK) 1.3. En las tablas 4.1 y 4.2 se muestra una lista detallada de las clases incluidas.

-Clases específicas para CLDC. Se localizan en el paquete javax.microedition y sus subpaquetes y se explican con detalle abajo en la tabla 4.4.

4.5.1.Clases heredadas (derivadas)

CLDC hereda algunas clases de sistema, entrada y salida (E/S) y utilidades de la plataforma J2SE, las tablas 4.1 y 4.2 muestran los paquetes y sus clases que se heredaron de la edición estándar.

Tabla 4.1. Clases de NO excepción heredadas de J2SE

Paquete

Clases

java.lang

Boolean, Byte, Character, Class, Integer, Long, Math, Object, Runnable, Runtime, Short, String, StringBuffer, System, Thread, Throwable

java.io

ByteArrayInputStream, ByteArrayOutputStream, DataInput, DataOutput, DataInputStream, DataOutputStream, InputStream, OutputStream, InputStreamReader, OutputStreamWriter, PrintStream, Reader, Writer

java.util

Calendar, Date, Enumeration, Hashtable, Random, Stack, TimeZone, Vector

Tabla 4.2. Clases de excepción heredadas de J2SE

Paquete

Clases

java.lang

ArithmeticException, ArrayIndexOutOfBoundException, ArrayStoreException, ClassCastException, ClassNotFoundException, Error, Exception, IllegalAccessException, IllegalArgumentException, IllegalMonitorStateException, IllegalThreadStateException, IndexOutOfBoundException, InstantiationException, InterruptedException, OutOfMemoryError, NegativeArraySizeException, NumberFormatException, NullPointerException, RuntimeException, SecurityException, StringIndexOutOfBoundException, VirtualMachineError

java.io

EOFException, IOException, InterruptedException, UnsupportedEncodingException, UTFDataFormatException

java.util

EmptyStackException, NoSuchElementException

4.5.1.1.Soporte de propiedades

En CLDC no hay implementación para la clase java.util.Properties, sin embargo las propiedades mostradas en la tabla 4.3 están disponibles y se pueden obtener llamando al método System.getProperty(clave), donde clave puede ser cualquiera de las siguientes:

Tabla 4.3. Claves de las propiedades CLDC.

Clave

Explicación

Valor predeterminado

microedition.platform

La plataforma o dispositivo huésped.

null

microedition.encoding

Codificación predeterminada de caracteres.

ISO8859_1

microedition.configurations

Configuración y versión J2ME actual.

CLDC-1.0

microedition.profiles

Nombre de los perfiles soportados.

null

4.5.2.Clases específicas de CLDC

Las siguientes clases (Tabla 4.4) son específicas de CLDC y están contenidas en el paquete javax.microedition.io:

Tabla 4.4. Clases específicas de CLDC.

Paquete

Clases

javax.microedition.io

Connection, ConnectionNotFoundException, Connector, ContentConnector, Datagram, DatagramConnection, InputConnection, OutputConnection, StreamConnection, StreamConnectionNotifier

4.5.2.1.Clases específicas de MIDP

Además de las clases específicas de MIDP contenidas en javax.microedition.rms, javax.microedition.midlet y javax.microedition.lcdui; están disponibles las siguientes clases, interfaces y clases de excepción:

-IllegalStateException. Clase en el paquete java.lang.

-Timer y TimerTask. Clases en el paquete java.util.
HttpConnection. Interfaz para acceso a una red por el protocolo HTTP contenida en el paquete javax.microedition.io.

El lenguaje de programación Java

2009-04-07T12:18:00.000-07:00
3. EL LENGUAJE DE PROGRAMACIÓN JAVA
Debido a que el presente documento centra su atención en la programación de dispositivos móviles, solamente se dará un descripción general del funcionamiento y características del lenguaje Java, ya que después se profundizará en su variante J2ME.

Cuando se programa en Java, se coloca todo el código en métodos, de la misma forma que se escriben funciones en lenguajes como C. En el presente capítulo se describen algunas de las principales características del lenguaje de programación Java.

3.1. Acerca de la máquina virtual

Como ya se ha mencionado, Java es un lenguaje interpretado, esto es que los programas no se compilan a archivos ejecutables, sino a archivos que habrán de ser interpretados por otros que si lo sean. Los archivos compilados de Java se llaman archivos de códigos de bytes o bytecodes.

Cuando se hace un programa en Java, el o los archivos que contengan el código fuente deben ser nombrados con extensión ".java" y al momento de ser compilados se creará un archivo de bytecodes con extensión ".class" del mismo nombre que el archivo fuente. Este archivo será la aplicación y, por lo tanto el que se habrá de ejecutar.

El trabajo de la máquina virtual es interpretar estos códigos de bytes según el sistema operativo en que se esté trabajando. He aquí el secreto de la portabilidad de Java: existe una máquina virtual para cada sistema operativo y los bytecodes se verifican cada vez que han de ser ejecutados, es decir, no corren directamente sobre el sistema operativo, sino que la maquina virtual los ejecuta convirtiendo los bytecodes a instrucciones propias de la plataforma anfitrión.

3.2.Características básicas del lenguaje

3.2.1. Comentarios

Los comentarios se introducen en los programas como ayuda para quienes habrán de leerlos, ya sea los propios programadores o aquellos quienes les han de dar mantenimiento. Un comentario no se ejecuta ni compila junto con el resto del programa, es únicamente para información. En Java hay tres tipos de comentarios:

A) // comentarios para una sola línea.

Todo el texto de una línea que se encuentre después de "//" será omitido por el compilador.

B) /* comentarios de una o

más líneas*/

Se omitirá en la compilación y ejecución todo el texto contenido a partir de la apertura del comentario "/*" y hasta su cierre "*/".

C) /** comentario de documentación,

de una o más líneas*/

Los comentarios de documentación, colocados inmediatamente antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta javadoc. Dichos comentarios sirven como descripción del elemento declarado permitiendo generar una documentación de nuestras clases escrita al mismo tiempo que se genera el código.

En este tipo de comentario para documentación, se permite la introducción de algunos tokens o palabras clave, que harán que la información que les sigue aparezca de forma diferente al resto en la documentación.

3.2.2. Identificadores

Los identificadores se utilizan para nombrar variables, funciones, clases y objetos; cualquier cosa que el programador necesite identificar o usar.

En Java, un identificador debe comenzar con una letra, un subrayado (_) o un símbolo de dólar ($). Los siguientes caracteres pueden ser letras o dígitos. Se distinguen las mayúsculas de las minúsculas (case sensitive) y no hay longitud máxima en el identificador.

Serían identificadores válidos:

identificador

nombre_usuario

Nombre_Usuario

_variable_del_sistema

$transaccion

Y su uso sería, por ejemplo:

int contador_principal;

char _lista_de_archivos;

float $cantidad_en_Ptas;

3.2.3. Palabras clave

Las palabras claves en un lenguaje de programación son aquellas que tienen alguna función especifica para dicho lenguaje, por ejemplo una palabra que indique la impresión de una cadena de texto en pantalla.

Las siguientes son las palabras clave que están definidas en Java y que no se pueden utilizar como identificadores:

abstract continue for new switch

boolean default goto null synchronized

break do if package this

byte double implements private threadsafe

byvalue else import protected throw

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

const float native super while

Seguramente no serán estas las únicas palabras que no podrán ser utilizadas como identificadores, debido a que existen también las palabras utilizadas por las clases que utilicemos (extendamos) en nuestros programas y las palabras reservadas de Java.

3.2.4. Palabras Reservadas

Además de las anteriores, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora no tienen un cometido específico. Esas palabras son:

cast future generic inner

operator outer rest var

3.2.5. Literales y tipos de datos

Java utiliza cinco tipos de datos básicos:

A) Enteros. Números sin punto decimal.

byte 8 bits complemento a dos

short 16 bits complemento a dos

int 32 bits complemento a dos

long 64 bits complemento a dos

Por ejemplo: 21, 077, 0xDC00

B) Reales en coma flotante. Números con punto decimal.

float 32 bits IEEE 754

double 64 bits IEEE 754

Por ejemplo: 3.14, 2e12, 3.1E12

C) Lógicos o booleanos. almacenan sólo valores de falso o verdadero.

true (verdadero).

false (falso).

D) Caracteres. Únicamente almacenan un carácter, una letra, símbolo o número (no se toma en cuenta su valor matemático).

Por ejemplo: "a", \t, \u???? [????] es un número unicode.

E) Cadenas. Son una agrupación de caracteres.

Por ejemplo: "Esto es una cadena literal"

3.2.5.1.Arreglos

Son asociaciones de varios datos del mismo tipo, por ejemplo un arreglo de cinco datos enteros o una lista de diez nombres, también son llamados arrays.

En Java se pueden declarar arreglos de cualquier tipo:

char s[];

int iArray[];

Incluso se pueden construir arreglos de arreglos:

int tabla[][] = new int[4][5];

Los límites de los arreglos se comprueban en tiempo de ejecución para evitar desbordamientos y la corrupción de memoria, es decir, se verifica que no se intenten ocupar más espacios de los especificados en la declaración del arreglo.

En Java un arreglo es realmente un objeto, porque tiene definido el operador "[ ]". Tiene una función miembro: length. Se puede utilizar este método para conocer su longitud.

int a[][] = new int[10][3];

a.length; /* 10 */

a[0].length; /* 3 */

Para crear un arreglo en Java hay dos métodos básicos. Crearlo vacío:

int lista[] = new int[50];

o se puede crear el arreglo con sus valores iniciales:

String nombres[] = {

"Juan","Pepe","Pedro","María"

};

Esto que es equivalente a:

String nombres[];

nombres = new String[4];

nombres[0] = new String( "Juan" );

nombres[1] = new String( "Pepe" );

nombres[2] = new String( "Pedro" );

nombres[3] = new String( "María" );

No se pueden crear arreglos estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

Tampoco se puede llenar un array sin declarar el tamaño con el operador new:

int lista[];

for( int i=0; i <>

lista[i] = i;

Es decir, todos los arrays en Java son estáticos, esto mejora la seguridad en el manejo de memoria. Para convertir un arreglo en el equivalente a los arreglos dinámicos de C++, se usa la clase vector, que permite operaciones de inserción, borrado, etc.

3.2.6. Operadores

Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la siguiente tabla aparecen los operadores que se utilizan en Java, por orden de precedencia:

. [] () ++ -- !

~ instanceof * / % +

- << >> >>> < >

<= >= == != & ^

| && || ? : = op=

*= /= %= += -=

Los operadores numéricos se comportan como esperamos:

int + int = int

Los operadores relacionales devuelven un valor booleano.

Para las cadenas, se pueden utilizar los operadores relacionales para comparaciones además de + y += para la concatenación:

String nombre = "nombre" + "Apellido";

El operador = siempre hace copias de objetos, marcando los antiguos para borrarlos, y ya se encargará el garbage collector de devolver al sistema la memoria ocupada por el objeto eliminado.

3.2.7. Separadores

Los separadores en Java definen la forma y función del código. Agrupan bloques de código e identificadores, definen la prioridad en operaciones. Los separadores admitidos en Java son los siguientes:

-() - paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para definir precedencia en expresiones.

-{} - llaves. Para contener los valores de matrices iniciadas automáticamente. También se utiliza para definir un bloque de código, para clases, métodos y ámbitos locales.

-[] - corchetes. Para declarar tipos matriz. También se utiliza cuando se referencian valores de matriz.

-; - punto y coma. Separa sentencias.

-, - coma. Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar sentencias dentro de una sentencia for.

-. - punto. Para separar nombres de paquete de subpaquetes y clases. También se utiliza para separar una variable o método de una variable de referencia.

3.2.8. Control de flujo

Las instrucciones de control de flujo son aquellas que, basándose en criterios dados por el programador, alteran el flujo natural (lineal) del programa.

En Java tenemos casi las mismas instrucciones de control de flujo (selección, decisión, salto y repetición) que en C.

3.2.8.1.Estructuras de decisión y selección

Son fragmentos de código que se ejecutan solamente si una condición contenida en ellos se cumple, como se muestra en los siguientes ejemplos:

A) if/else:

if( condición_Boolean ) {

Instrucciones_si_se_cumple_la_condición_Boolean;

}

else {

Instrucciones_si:no_se_cumple;

}

B) switch:

switch( expr1 ) {

case expr2:

instrucciones_si_expr1_=_expr2;

break;

case expr3:

instrucciones_si_expr1_=_expr3;

break;

default:

instrucciones_si_expr1_<>_expr2_y_a_expr3;

break;

}

3.2.8.2.Ciclos de repetición

Estas estructuras repiten su ejecución tantas veces como se haya indicado o bien cuando se cumpla una determinada condición.

A) for

for( expr1 inicio; expr2 test; expr3 incremento ) {

sentencias;

}

También se soporta el operador coma (,) en los ciclos for

for( a=0,b=0; a <>

B) while

while( Boolean ) {

sentencias;

}

C) do/while

do {

sentencias;

}while( Boolean );

3.2.8.3.Excepciones

Algunas veces los programas producen algún error en tiempo de ejecución y quisiéramos tener la capacidad de decirle qué hacer cuando esto suceda, principalmente para evitar que el programa se colapse cada vez que el error se presenta. para esto nos sirven las excepciones de Java.

A) try-catch-throw

try {

sentencias;

} catch( Exception ) {

sentencias;

}

Java implementa excepciones para facilitar la construcción de código robusto. Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción, que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones predefinidas.

3.2.8.4.Control general del flujo

Rompen el flujo natural del programa incondicionalmente, ya sea para terminar un módulo o todo el programa o simplemente para pasar a otro lugar del código.

break [etiqueta]

continue [etiqueta]

return expr;

etiqueta: sentencia;

Por ejemplo, en caso de que nos encontremos con ciclos anidados, se permite el uso de etiquetas para poder salirse de ellos, por ejemplo:

uno: for( ) {

dos: for( ) {

continue; /* seguiría en el ciclo interno, pero omitiría las instrucciones siguientes*/

continue uno; // seguiría en el ciclo uno principal

break uno; // se saldría del ciclo principal

}

}

En el código de una función siempre hay que ser consecuentes con la declaración que se haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero, es imprescindible que se coloque un return final para salir de esa función, independientemente de que haya otros en medio del código que también provoquen la salida de la función. En caso de no hacerlo se generará un a advertencia (Warning), y el código Java no se puede compilar con "Warnings".

int func() {

if( a == 0 )

return 1;

return 0; // es imprescindible porque se retorna un entero

}

3.2.9. Clases

Las clases son la parte fundamental de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. por lo tanto, el conocimiento de las clases es fundamental para poder entender los programas Java.

Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto, todos los métodos se definen dentro del bloque de la clase. Java no soporta funciones o variables globales, todo debe pertenecer a una clase. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una clase.

Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos. En C la unidad fundamental son los archivos con código fuente, en Java son las clases. De hecho son pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave import (equivalente al #include) puede colocarse al principio de un archivo, fuera del bloque de la clase. Sin embargo, el compilador reemplazará esa sentencia con el contenido del archivo que se indique, que consistirá, como es de suponer, en más clases.

3.2.9.1.Tipos de clases

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que se han visto, pero hay más modificadores. Los tipos de clases que se pueden definir son:

-abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.

-final.

Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.

-public.

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.

-synchronizable.

Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos hilos (threads) de programación; el sistema se encarga de colocar las banderas (flags) necesarias para evitarlo. Este mecanismo hace que desde hilos diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobrescriban.

-protected.

Una clase definida como protected puede ser utilizadas desde cualquier clase del mismo paquete, sin posibilidad, a diferencia de las clases public, de ser accedidas desde otros paquetes, aun importandolas.

3.2.9.2.Paquetes de clases

Al crear una clase se puede incluir en un paquete que se compilará como tal, es decir, la aplicación no funcionará si falta alguna de las clases integrantes del paquete.

La agrupación en paquetes es bastante útil para motivos de organización y portabilidad, ya que nos obliga a tener todas las clases relacionadas a un proyecto en la misma carpeta o directorio. Para incluir una clase en un paquete se hace de la siguiente forma:

package Clases; //esta línea indica que esta clase forma parte del paquete //clases

public MiClase {

int i; ....

3.2.10. Variables y métodos de instancia

Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos primitivos como int, char, etc. Los métodos son funciones.

Por ejemplo, en el siguiente segmento de código podemos observarlo:

public MiClase {

int i;

public MiClase() {

i = 10;

}

public void Suma_a_i( int j ) {

i = i + j;

}

}

La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor de la clase y Suma_a_i( int j ).

3.2.10.1.Ámbito de una variable

Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las variables de Java sólo son válidas desde el punto donde están declaradas hasta el final de la sentencia compuesta que la engloba. Se pueden anidar estas sentencias compuestas, y cada una puede contener su propio conjunto de declaraciones de variables locales. Sin embargo, no se puede declarar una variable con el mismo nombre que una de ámbito exterior.

El siguiente ejemplo intenta declarar dos variables separadas con el mismo nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos diferentes. En Java, esto es ilegal.

Class ambito {

int i = 1; // ámbito exterior

{ // crea un nuevo ámbito

int i = 2; // error de compilación

}

}

3.2.10.2.Métodos y Constructores

Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases. El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea) un objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase:

MiClase mc;

mc = new MiClase();

La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia) i con el nombre del objeto:

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc:

mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

3.2.10.3.Finalizadores

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger automáticamente todos los objetos que se salen del alcance. No obstante proporciona un método que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector) llamará:

// Cierra el canal cuando este objeto es reciclado

protected void finalize() {

close();

}

3.3. Programación multihilo (multithread)

Se le llama programación multihilo o multithreaded (en inglés) al método de programación donde el flujo del programa se diseña como caminos o hilos independientes que pueden ejecutarse al mismo tiempo,

Lo anterior significa que con Java se pueden realizar aplicaciones que realicen varias tareas a la vez y que se puede controlar cada una de estas tareas independientemente del resto.

La programación multihilo en Java se logra realizando una agrupación en hilos como si de procedimientos se tratase, aunque se usa la clase thread.

En el siguiente ejemplo veremos como crear un hilo en lenguaje Java y como ordenar su ejecución:

//La clase principal

public class MiClase{

//código de la clase

//Se deben instanciar las clases hilo.

Hilo1 H1;

Hilo2 H2;

H1 = new Hilo1 ("1");

H2 = new Hilo2 ();

//Llamadas a los hilos

H1.start

H2.start

}

//Hilos

class Hilo1 extends Thread { //Extiende (hereda) la clase Thread

//Constructor de la clase Hilo1

public Hilo1(String nom){ //este constructor utiliza un nombre de hilo

}

pulic void run(){

//run contiene el código que se ejecutará

}

}

class Hilo2 extends Thread {

public Hilo2(){ /*Variante del constructor que no pide nombre de hilo (define los nombres de hilo como Thread1, Thread2... Treadn.*/

}

pulic void run(){

}

}

"Un programa inicia la ejecución de un hilo invocando el método start de ese hilo, a su vez start, invoca el método run. Una vez que start echa a andar el hilo, regresa de inmediato el control a su invocador. De ahí en adelante el invocador se ejecutará en paralelo con el hilo iniciado. El método start lanza una excepción de estado de hilo ilegal (IllegalThreadStateException) si el hilo que está tratando de iniciar ya se está ejecutando."[1]

Desafortunadamente nuestro espacio para la explicación del lenguaje Java es reducido puesto que no es ese nuestro tema principal, aunque se incluye por considerarse necesario, y no podemos dedicarle lo merecido al interesante tema de la programación multihilo. Recomendamos al lector el libro citado al pie de esta página, dedica un capítulo (que tal vez resulte también insuficiente pero es mejor que dos cuartillas) completo a este tema.

Diseño de páginas web para dispositivos pequeños

2009-04-06T12:14:00.000-07:00

2. DISEÑO DE PÁGINAS WEB PARA DISPOSITIVOS PEQUEÑOS
Como todos los interesados en el diseño y programación web saben, las páginas web se hacen con los llamados lenguajes de aumento de texto, dependiendo del tipo de página se utiliza un lenguaje determinado, aunque todos tienen características similares.

2.1.Lenguajes de aumento o ganancia (markup) de texto

Los lenguajes de aumento de texto, como HTML (Hipertext Markup Language), DHTML (Dynamic HTML), XML (eXtensible Markup Language) y WML (Wireless Markup Language), son lenguajes que, basándose en la utilización de etiquetas (tags), dan al texto simple características especiales, que pueden ir desde mostrarlo con tamaño, alineación o tipo distinto de fuente hasta la creación de enlaces a otros documentos o aplicaciones o bien la generación de formularios gráficos para introducir datos a una base de datos, auxiliándose de otros lenguajes.

2.2.Lenguaje WML

Debido a que el tema que ocupa a este documento es la programación de dispositivos inalámbricos, este capítulo se dedicará a la explicación del lenguaje de diseño web dedicado a ellos, WML.

WML es un lenguaje basado en XML y creado especialmente para el diseño de páginas web para equipos con capacidades de procesamiento, memoria e interfaz limitadas, es decir, para las llamadas PDA, teléfonos celulares y paginadores (pagers).

2.2.1.Cartas y Barajas

Todo el código WML se organiza dentro de una colección de cartas y barajas. Las cartas especifican una o más unidades de interacción con el usuario, por ejemplo un menú de opciones, una pantalla de texto o un campo de entrada de texto. Lógicamente, un usuario navega a través de una serie de cartas de WML, revisando el contenido de cada una de ellas, introduciendo la información requerida, realizando elecciones y moviéndose a otra carta. Las cartas están agrupadas dentro de barajas. Una baraja es la unidad más pequeña WML que un servidor puede enviar al terminal del usuario.
2.2.2.Etiquetas
Al igual que HTML, WML basa su codificación en etiquetas, éstas definen el formato y otras propiedades que tendrá el texto o los objetos que se encuentren dentro de ellas.

Las etiquetas WML se señalan escribiéndose dentro de los signos <>, por ejemplo <etiqueta>, aunque la mayoría de las etiquetas cuentan con apertura y cierre, este último se hace agregando un "/" antes del nombre de la etiqueta y después del signo "<", ejemplo: cierre_de_etiqueta>.

Todo texto u objeto ubicado entre una apertura y un cierre de etiqueta se verá afectado por ella, por ejemplo,
Texto, hará que "Texto" aparezca en el centro de la pantalla, así como cualquier imagen u objeto que se encuentre dentro de los límites de la etiqueta .

2.2.3.Etiquetas básicas

2.2.3.1.Obligatorias del documento

-. Con esta etiqueta se debe iniciar cualquier documento WML, indica al navegador que se abrirá un archivo codificado en XML, hay que recordar que es la base de WML.

-http://www.wapforum.org/DTD/WML_1.1.xml">. Se especifica el tipo de XML que se abrirá, WML en este caso y además se indica al navegador la URL que seguirá para la descodificación del lenguaje.

-... . Se escribe después de los dos anteriores, determina el cuerpo principal del documento, cumple la misma función que la etiqueta en ese lenguaje.

-.... Recordemos que una página WML se divide en cartas, esta etiqueta marca los límites de una carta llamada "cartauno". Una página WML puede tener tantas cartas como sean necesarias.

2.2.3.2.De formato de texto

-
...
. Limita un párrafo, en WML todo texto debe estar incluido en un párrafo.

-
. Salto de linea, como en HTML.

-a la cartados. Enlace de hipertexto a una carta llamada cartados, en lugar de "#cartados" puede ir cualquier URL válida.

- . Pone el texto contenido en negritas.

- . Todo texto dentro de esta etiqueta se mostrará en itálicas.

- . Similar a la itálica.

- . Otra opción para letra negrita.

- . Texto subrayado.

- . Letra grande, se debe recordar que se está ante dispositivos con limitantes gráficas, así que no se puede ser muy exigente con los tamaños de letra.

- . Letra pequeña

2.2.3.3.Caracteres especiales

Al igual que en HTML, hay algunos caracteres utilizados por el lenguaje que presentan ciertas dificultades a la hora de mostrarlos en pantalla (", $ #, etc.). En caso de que sea necesario hacerlo se proporciona una lista, en la tabla 2.1, de códigos por los que se deben sustituir los caracteres para que aparezcan sin ningún problema.

Tabla 2.1. Códigos de caracteres especiales.

Signo

Código

Signo

Código

<

< %3c

>

>%3e

'

'

"

"

&

&%26

$

$$%24

[

%5b

]

%5d

/

%2f

\

%55c

?

%3f

;

%3b

:

%3a

^

%5e

@

%40

|

%7c

=

%3d

+

%2b

}

%7d

{

%7b

,

%2c

espacio

%20

#

%23

`

%27

2.2.3.4.Tildes y eñes

En WML se deben sustituir las letras acentuadas y eñes por los siguientes caracteres:

á á Á ` é é

É É í i Í Í

ó ó Ó Ó ú ú

Ú Ú ñ ñ Ñ Ñ

2.2.4.Variables

Una de las grandes diferencias entre el WML y el HTML es que WML permite la definición variables en las cartas, asignarles valores y presentarlos en la pantalla, incluso utilizar las variables en expresiones. Con esto se puede conservar información en el paso de una carta a otra y así dividir el contenido en varios pasos (cosa bastante útil para pantallas tan pequeñas).

Las variables son cadenas de texto case-sensitive (distingue mayúsculas y minúsculas) a la que se le asigna un valor (secuencia de caracteres) o ningún valor.

El nombre de la variable puede empezar por el guión bajo: "_" o una letra, seguida de una o más letras, números o el guión bajo. Ejemplos de nombres de variables válidos: NOMBRE_Usuario, _mivar1, X700II

2.2.4.1.Crear variables y asignarles valores

. Juan es el valor de la variable mivar1. Con setvar se crea la variable y a la vez se le asigna un valor.

Input. Con input se puede crear (declarar) la variable, asignarla un valor y también devolverle el valor original. Input se utiliza para la entrada de datos y esos datos (valores) se asignarán a una variable. Se presenta como un cuadro de texto.

Select. Con select se puede crear (declarar) la variable, asignarle un valor y también devolverle el valor original. Select permite seleccionar al usuario uno o más valores entre una lista de opciones que se asignarán a una variable.

Postfield. Con postfield se puede crear (declarar) la variable, asignarle un valor y también devolverle el valor original.

2.2.4.2.Hacer referencia a variables

Es posible incluir el valor de una variable dentro de un documento WML, tanto para que aparezca en la pantalla como para que se envíe a un programa. Hay tres formas de hacer esto:

1.$nombrevariable. Se utiliza cuando no hay ambigüedad con el nombre de la variable dentro del contexto.

2.$(nombrevariable). Cuando puede existir ambigüedad con el nombre de la variable dentro del contexto.

3.$(nombrevariable:conversión). Cuando se introduce el valor de una variable dentro de una baraja, se puede definir el formato (escape, unescape o no escape) así:

1.$(var:e), $(var:E), $(var:escape): cualquiera de los tres traduce al formato escape[1].

2.$(var:u), $(var:U), $(var:unesc): cualquiera de los tres traduce del formato escape a texto US-ASCII.

3.$(var:n), $(var:N), $(var:noesc): cualquiera de los tres hace que el valor de la variable no se traduzca al formato escape.

WML siempre aplica el formato escape cuando se trata de atributos que trabajan con URLs. Por eso muchas veces se puede asumir que el WML convertirá al formato escape cuando lo tiene que hacer. De todas formas, conviene incluirlo si tenemos mínimas dudas de lo que ocurrirá.

2.2.4.3.Las variables y las tareas , , y

- . No hace nada. Se utiliza para desactivar eventos en el nivel de la baraja.

-. Prev vuelve al anterior URL. Si dentro de prev hay un elemento setvar, como en el ejemplo, se procesa antes de que se ejecute el prev.

-. Refresh refresca los contenidos visibles del navegador. Si refresh contiene un setvar, como en el ejemplo, se procesa el setvar y después se procede al refresh.

-. Go lleva a otra URL u otra carta. Si dentro de Go hay un elemento setvar, se procesa primero éste y después se ejecuta la tarea "Go".

href= "http://www.WMLclub.com/cgi-bin/programa.pl ?x=$(mivar1)&y=$(mivar2)" method="post">

2.2.5.Creación de tablas

El manejo de tablas en WML es similar al de HTML, se define el elemento
y se indican las columnas ("columns"), después se especifican, dentro de cada columna, las filas y los datos que han de llevar.
Aunque el tag de

está recogido en las especificaciones del WML 1.1, existen algunos móviles que no lo implementan, como es el caso del Nokia 7110, en su lugar los datos son mostrados en una tabla de una columna. A continuación vemos un ejemplo de código para creación de tablas:

fila 1, columna 1

fila 1, columna 2

fila 1, columna 3

fila 2, columna 1

fila 2, columna 2

fila 2, columna 3

2.2.6.Manejo de imágenes

En los dispositivos móviles se permite la visualización de imágenes, pero éstas deben estar en formato WBMP, en lugar de las utilizadas en HTML que pueden ser gif, jpg o bmp; aunque algunos de los más modernos equipos ya cuentan con soporte para jpg.

Una imagen WBMP puede ser creada por el diseñador en un programa especial, o bien convertida de otro formato en el mismo programa. Uno de estos programas puede ser Image Magic o bien el incluido en el kit de desarrollo WAP de Nokia.

La forma de incluir una imagen en una página WML es la siguiente:

2.3.Scripts en WML (WMLS)

WMLS son las siglas de Wireless Markup Language Script y es un lenguaje de programación que junto con el WML nos permite el diseño de las páginas que se visualizan en los terminales móviles.

El navegador, además de poseer un intérprete para WML, también tiene uno para los scripts. Además del propio lenguaje en sí, este intérprete implementa un conjunto de librerías que permiten a nuestros programas acceder a ciertos servicios del terminal.

El código WMLS debe incluirse en un archivo distinto al WML asociado.

2.3.1.Utilización de WMLScript

Al utilizar WMLS se pretende cubrir los huecos de funcionalidad que deja WML, es decir, se trata hacer con las páginas cosas que resultarían imposibles con el simple WML. Entre las utilidades del WMLScript están las siguientes:

-Validación de los datos de entrada por parte del usuario.

-Manejar mediante código funciones propias del terminal, como realizar llamadas desde el teléfono, enviar mensajes, agregar número de teléfono a la libreta de direcciones y acceder a la tarjeta SIM.

-Realizar alertas, mensajes de error, confirmaciones, etc.

2.3.1.1.Identificadores

Se utilizan identificadores para nombrar las variables, las funciones y los pragmas (información para la unidad de compilación). Estos identificadores tienen las mismas reglas de definición que los nombres de variables en WML, además no pueden ser iguales a una palabra reservada.

2.3.1.2.Comentarios

Los comentarios en el WMLS, son como en el C o en el C++ (una sola línea, empieza por // y más de una línea empieza por /* y termina por */):

//comentario

/*Comentarios de más

de una línea */

2.3.1.3.Caracteres especiales

Al estar basado en WML, el manejo de caracteres especiales se realiza de la misma forma.

NOTA: Los WMLscripts se pueden escribir en cualquier editor de texto normal y corriente. No pueden ser ejecutados sin que sean llamados desde una carta WML.

2.3.2.Primeros pasos

A continuación se muestra un sencillo WMLS que convierte pesos a dólares (suponiendo el tipo de cambio a 11.05 pesos por dólar).

Primero es necesario hacer el WML que recogerá la cifra que se desee pasar a dólares.

"http://www.wapforum.org/DTD/WML_1.1.xml">

Conversor de pesos a dólares

Resultado: $(resultado)

En esta carta se ha creado una variable que se llama cantidad y lleva la cifra a convertir en dólares. Además se incluye una variable, que no tiene nada, llamada resultado. En esta variable se almacenará el resultado en el WMLs siguiente:

extern function calcular(cantidad) {

var dolar = (cantidad/11.05);

var dolarString = String.toString(dolar);

dolarString = String.format("%.2f", dolarString);

WMLBrowser.setVar("resultado", dolarString);

WMLBrowser.refresh();

}

Primero se declara la función, en este caso llamada calcular. La función es extern, esto significa que puede ser llamada desde fuera del archivo WMLS. Esta función recibirá como parámetro la variable cantidad. Al igual que C++ y Java, la función comienza con { y termina con }.

Se declara una variable llamada dólar y se le asigna un valor, en este caso, lo que haya introducido el usuario dividido entre 11.05 (el supuesto valor actual de la moneda estadounidense).

Como el resultado puede tener una cantidad enorme de cifras decimales, primero se convierte a una cadena de texto, con String.toString. El resultado irá dentro de la variable dolarString, después con "%.2f" se indica que el formato será un float (de punto flotante o decimal) con dos cifras después del punto.

Se crea una variable de nombre resultado y cuyo valor es el contenido de dolarString y además se envía a la carta desde la cual fue llamada esta función.

Actualiza el navegador (browser) para que en la pantalla aparezcan los cambios (ahora la variable "resultado" tiene un valor y tiene que aparecer en pantalla)

2.3.2.1.Variables en WMLScript

Las variables deben ser declaradas antes de poder utilizarlas en una expresión. Esta es la forma de declarar una variable:

var NombreVariable;

El nombre de la variable puede llevar caracteres alfabéticos, números y el guión bajo ("_"), pero nunca puede empezar con un número.

En la declaración de una variable puede asignársele un valor inicial. Hay dos formas de hacerlo, con igual resultado:

var a; a = 1;

O esta otra forma:

var a = 1;

También se pueden declarar varias variables a la vez, separadas por comas en la misma instrucción var.

El valor de las variables en el WMLScript sólo duran lo que dura la función en la que son declaradas. Por eso sólo se puede acceder a su valor dentro de la función donde han sido declaradas.

Las variables pueden contener cualquier tipo de datos:

-Boolean (true o false).Ejemplo: var respuesta = true;

-Integer (número entero positivo o negativo, sólo desde -2147483648 hasta el 2147483647). Ejemplo: var num = 7890;

-Float (número decimal, el mínimo es: +-1.17549435E-38 y el máximo es: +-3.402823476E+38).Ejemplo: var num = 6.78;

-String (caracteres alfabéticos, se puede utilizar comillas dobles o simples).Ejemplo: var nombre = "Juan";

-Invalid (para distinguirlo de los otros tipos de datos o para saber por ejemplo cuándo el resultado de una operación se sale de los máximos o los mínimos, un float menor a +-1.17549435E-38, por ejemplo).

Ejemplo: var ex = invalid;

Hay una forma de crear variables globales, esto es, variables que se almacenan en el contexto del navegador y que pueden ser accesadas tanto por las cartas WML, como por las funciones del WMLScript. Estas variables hay que crearlas con la función setVar de la librería WMLBrowser, así:

WMLBrowser.setVar ("nombreVariable", valor);

La variable siempre tiene que tener un valor inicial:

WMLBrowser.setVar ("nombre", 0);

2.3.3.Librerías

WMLScript cuenta con seis librerías, éstas incluyen gran variedad de funciones con las que podemos trabajar, dichas librerías son: lang, float, string, URL, dialogue y WMLbrowser.

2.3.3.1.Lang

Todas las funciones se utilizan como i se hiciera en un entorno orientado a objetos: lang.abs(-9), por ejemplo. Todos los nombres de funciones comienzan con minúscula.

1.Funciones aritméticas:

-abs (número). Calcula y devuelve el valor absoluto.

-max (número1, número2), min (número1, número2). Regresan el mayor y el menor, respectivamente, entre dos números comparados.

2.Funciones de tipos de datos:

-isFloat (valor). Devuelve true si valor puede ser convertido en número con decimales, false si no puede ser convertido e invalid si el sistema no soporta decimales.

-isInt (valor). Es true si el valor puede ser convertido a entero. False si ni puede ser. Invalid si excede los limites antes mencionados.

-parseFloat (cadena de texto). Devuelve un número con decimales, sacado de la cadena de texto. Analiza la cadena de texto y termina en el primer carácter que no sea parte de un número con decimales. Devuelve "invalid" cuando hay un error en el análisis -no encuentra un número con decimales- o el dispositivo WAP no acepta números con decimales.

-parseInt (cadena de texto). Devuelve el número entero, sacado de la cadena de texto. El análisis de la cadena de texto se detiene en el primer carácter que no sea parte de un número con decimales. Devuelve "invalid" cuando hay un error en el análisis -no encuentra un número con decimales-.

3.Funciones de entorno.

Con estas funciones puedes conocer las capacidades del dispositivo WAP en el que se ejecuta el WMLscript.

-CharacterSet(). Devuelve un número entero que es el valor asignado por el IANA (Internet Assigned Numbers Authority) identificando el set de caracteres que soporta el intérprete del WMLScript.

-Float(). Devuelve true si el dispositivo soporta los números con decimales; false, en caso contrario.

-MaxInt(). Devuelve el número entero máximo que acepta el dispositivo (actualmente es 2.147.483.647).

-minInt(). Devuelve el número entero mínimo que acepta el dispositivo (actualmente es -2.147.483.648)

4.Funciones de control de flujo.

Te permite terminar la ejecución del script y devolver el control al lugar desde donde fue llamado (por ejemplo, otra función del mismo WMLscript).

-abort (cadena de texto). Termina "inesperadamente" la interpretación del bytecode del WMLscript y devuelve una cadena de texto describiendo el error. A esta cadena de texto no se puede acceder desde un documento WML.

-exit (valor). Termina "normalmente" la interpretación del bytecode del script y devuelve un valor a la función desde la que fue llamado. A esta cadena de texto no se puede acceder desde un documento WML.

5.Funciones de números aleatorios.

-random(número entero). Devuelve un entero positivo aleatorio entre 0 y el número indicado.

-seed (número entero). Inicia en generador de números aleatorios en el número indicado.

2.3.3.2.Float

1.Funciones de entorno:

-maxFloat(). Devuelve el número positivo decimal máximo. Actualmente es 3.40282347E+38, para todos los dispositivos que disponen de números decimales. Si el dispositivo no los soporta, el resultado será "invalid".

-MinFloat(). Devuelve el número positivo decimal mínimo. Actualmente es 1.17549435E-38 para todos los dispositivos que disponen de números decimales. Si el dispositivo no los soporta, devolverá "invalid".

2.Funciones aritméticas.

-ceil(número). Devuelve el entero menor más próximo a número. Si el número ya es entero, devuelve el mismo número dado.

-floor(número). Es lo contrario de ceil. Devuelve el entero más próximo a número, pero que no sea mayor que él.

-int(número). De un número dado devuelve la parte entera.

-pow (número1, número2). Devuelve el número1 elevado a la potencia número2. Si número1 es negativo, número2 debe ser un número entero. Si número1 es cero y número2 es menor que cero, pow devuelve "invalid".

-round(número). Devuelve el número entero más cercano al número dado. Si dos enteros están igualmente cerca del número, round devuelve el mayor de ellos.

-sqrt(número). Devuelve la raíz cuadrada del número. Si el resultado es menor que cero sqrt devuelve "invalid".

2.3.3.3.String

1.Funciones básicas.

-charAt (cadenadetexto, número). Devuelve el carácter en la posición número de cadenadetexto.

-compare (cadenadetexto1, cadenadetexto2). Compara dos cadenas de texto.

-lenght (cadenadetexto). Regresa la cantidad de caracteres que tiene una cadena.

-isEmpty (cadenadetexto). Devuelve true si la cadena está vacía, false si no lo está.

2.Funciones de subcadena (Substring).

-subString(cadena,Inicio,Longitud). Extrae una subcadena de determinada longitud de caracteres, comenzando en la posición Inicio.

-find (cadena, subcadena). Determina si una subcadena pertenece a una cadena, devuelve True si existe.

-replace (cadena, cadena1, cadena2). Reemplaza en cadena todas las apariciones de cadena1 por cadena2.

3.Funciones de elementos.

-elementAt (cadena, numElemento, separador).

-elements (cadena, separador).

-insertAt (cadena, cadena2, número, separador).

-removeAt (cadena, número, separador).

-replaceAt (cadena, elemento, número, separador).

4.Funciones de conversión:

-format (formatString, valor). Da un formato especifico a un determinado valor.

-toString (valor). Devuelve el valor expresado como cadena de caracteres. Por ejemplo:

a=String.toString(3.5); //a="3.5"

2.3.3.4.URL

La librería URL tiene funciones para manipular y verificar URLs relativos y absolutos. La sintaxis de un URL (definido en detalle en [Request For Comments (RFC) 2396]) es:

://<:port>/;?#

Ejemplo:

http://www.WMLclub.com:80/docs/faqs/index.htm;3;2?id=juan#nombre

Para las funciones que devuelven una cadena que contiene un componente de un URL, los delimitadores de adelante y de atrás no están incluidos en el resultado devuelto. La única excepción es en la ruta (donde se incluyen las diagonales (/)). Hay tres tipos de funciones de la librería URL:

1.Funciones para manejar URLs

Permiten validar, recuperar, crear y convertir a formato escape las URLs:

-escapeString(cadenadetexto).

-getBase().

-GetReferer().

-isValid(url).

-resolve(baseString,incluidoString).

-unescapeString(cadenadetexto).

2.Funciones para extraer componentes.

Se utilizan para recuperar componentes individuales de URLs relativos y absolutos. Estas funciones primero comprueban que el URL es válido, utilizando isValid(), antes de extraer los componentes. Si isValid es "false", estas funciones devolverán "invalid".

-getFragment(cadenadetexto).

-getHost(cadenadetexto).

-getPort(cadenadetexto).

-getParameters(cadenadetexto).

-getPath(cadenadetexto).

-getScheme(cadenadetexto).

-getQuery(cadenadetexto).

3.Funciones para extraer contenido.

Sólo hay una función para extraer contenido de un URL y es la que permite asignar el contenido de un archivo de texto a una variable WMLScript.

loadString(URLString,contentTypeString)

2.3.3.5.Dialogue

Los diálogos son mensajes en pantalla que esperan una respuesta del usuario. La forma en la que aparece en pantalla dependerá de cada micronavegador. Esta librería sólo tiene tres funciones:

-prompt(cadena,cadenaPorDefecto). El texto que sale en pantalla es "cadena" y espera una respuesta por parte del usuario (un input). El valor por defecto del input es cadenaPorDefecto. Devuelve la cadena que el usuario ha introducido.

-confirm(cadena,cadenaOK,cadenaCancelar). El texto que sale en pantalla es "cadena" y despliega dos opciones a elegir ("cadenaOK" y "cadenaCancelar") y espera una respuesta del usuario. La función confirm devuelve "true" si el usuario ha seleccionado OK y "false" si ha seleccionado Cancel.

-alert(cadena). Presenta una cadena de texto y espera la confirmación del usuario. Devuelve una cadena vacía.

2.3.3.6.WMLbrowser

Las funciones de esta librería permiten acceder a las variables de contexto del micronavegador del dispositivo. También permiten ejecutar una tarea cuando el intérprete WMLscript termina su ejecución.

Todas estas funciones devuelven invalid si el micronavegador no soporta WML o si el intérprete de WMLscript no puede ser invocado desde el micronavegador.

1.Funciones de variables.

Permiten leer y escribir variables en el contexto del micronavegador.

- getVar(nombre). Devuelve la cadena que contiene la variable nombre, devolverá una cadena vacía si la variable no existe, "invalid" si nombre no es un nombre de variable apropiado. Ejemplo:

var a = "Hola";

var b = WMLBrowser.getVar(a); // b = "Hola"

- setVar(nombre, valor). Inicia la variable nombre con el contenido de valor, si la operación se realiza con éxito devuelve "True", de lo contrario "False" e "Invalid" si nombre no es un nombre de variable válido. Por ejemplo:

var a = WMLBrowser.setVar(color,azul); // a = true

2.Funciones de tareas.

-go(cadenaURL). Carga el URL dado. Esto sucede cuando el script devuelve el control al navegador. Ej.:

var carta="http://www.WMLclub.com/demos/a.WML#carta2";

WMLBrowser.go(carta);

-prev(). Carga la carta vista anteriormente. Al igual que go(), su efecto se da sólo cuando el WMLscript devuelve el control al micronavegador. Ej.:

WMLBrowser.prev();

-refresh(). Actualiza la carta visualizada. Ej.:

WMLBrowser.refresh();

-newContext(). Vacía el contexto del navegador y devuelve una cadena vacía. Ej.:

WMLBrowser.newContext();

3.Funciones de consulta.

-GetCurrentCard(). Devuelve la carta actual (la que llamó al script) junto con la ruta más corta con respecto a la ubicación del archivo .WMLs. Ej.:

Si www.server.com/a.WML llama a www.server.com/pro.WMLs:

var a = getCurrentCard(); // a = "a.WML"

O si www.serv0.com/a.WML llama a www.serv1.com/test/test.WMLs:
var a = getCurrentCard(); // a = "http://www.serv0.com/a.WML"
[1]Formato adoptado por Internet Society para identificar los caracteres utilizados en las URL, donde se escribe el "%" y el número de carácter, %20 para el espacio, por ejemplo.

Desarrollo de aplicaciones para dispositivos inalámbricos (J2ME)

2009-04-05T12:08:00.002-07:00

Durante los últimos años hemos experimentado, más que en ninguna otra época de la humanidad, un sorprendente avance en la tecnología; tanto en la de las grandes organizaciones: comerciales, militares y educativas, como en la que usamos diariamente.

Indudablemente algunos de los más grandes avances se han dado en el área de las comunicaciones: televisión, radio, satélites, teléfonos celulares; y en la electrónica y computación: computadoras con capacidades que antes eran inimaginadas, dispositivos de tamaños minimizados sorprendentemente, sin sacrificar por esto gran poder de procesamiento.

Hasta hace pocos años estas dos ramas de la tecnología se desarrollaban independiente una de la otra, pero con el surgimiento de Internet, revolucionando la forma de comunicarse, los teléfonos celulares o móviles fueron creciendo en cuanto a capacidad, de forma que han llegado a convertirse -algunos modelos- en computadoras de bolsillo, con las limitantes de poder que sus características suponen, obviamente.

Quién habría de imaginarse hace treinta años que un teléfono podría trasladarse de un lugar a otro, no requerir de cable y tener mayor funcionalidad que las supercomputadoras de aquella época o que no sería necesario sino un bolsillo de 8 x 13 cm para cargar una computadora completa, seguramente nadie. Las nuevas tecnologías utilizadas por los fabricantes de estos aparatos tienden a reducir el tamaño sin sacrificar funcionalidad e incluso aumentarla.

Dentro de las nuevas tecnologías que incorporan los pequeños dispositivos portátiles -PDA (Portable Digital Assistant), teléfonos celulares, etc.- se encuentran primordialmente el acceso a Internet, con todas las ventajas de movilidad e información que proporcionan ambas tecnologías (telefonía móvil e Internet), por un lado y la capacidad para el usuario de crear sus propias aplicaciones o descargarlas de Internet e instalarlas en su equipo.

En cuanto al acceso y navegación en Internet, se utiliza un protocolo llamado WAP (Wireless Application Protocol) que es el encargado de la comunicación y la interpretación de los contenidos; también se utiliza, para la creación de las páginas que se verán en estos dispositivos, el lenguaje WML (Wireless Markup Language), el cual es similar al HTML de las computadoras de escritorio, aunque diseñado especialmente para las características de los dispositivos portátiles. En este documento se tratarán brevemente los fundamentos del diseño de páginas WML.

Por el lado de desarrollo de aplicaciones se tienen lenguajes como C++ y Java en versiones especiales para los equipos en cuestión, el presente reporte de investigación se centrará en el lenguaje Java, ya que ocupa una abrumadora mayoría en el mercado y está demostrando ser la mejor opción disponible para todos los programadores interesados en el tema, ademas de las características de seguridad y estabilidad inherentes a cualquier producto Java.

1.1.Un vistazo a las comunicaciones inalámbricas

Este amplísimo campo abarca desde las señales de radio y televisión hasta teléfonos celulares y comunicación por satélite. Conceptualmente, puede ser dividido en dos tipos:

-LAN (Local Area Network): Operan regularmente en distancias cortas -unos cuantos metros. Pueden ser desde el control de la alarma de un auto, un juguete de radio control o una red BlueTooth.

-WAN (Wide Area Network): Sobrepasan por mucho las distancias de los dispositivos LAN, aunque basan su funcionamiento en una red terrestre excelentemente elaborada: Una red de antenas de radio cuidadosamente colocadas, los aparatos pueden funcionar mientras se encuentren en el rango de al menos una de las antenas. Como los teléfonos celulares y los receptores de radio.

1.2.Introducción a la plataforma Java

Java fue creado por Sun Microsystems en un intento por desarrollar un lenguaje que facilitara la programación de aparatos electrodomésticos conectados a la red de una casa inteligente. Después de un tiempo de desarrollo, la directiva del proyecto vio que las capacidades del lenguaje iban mucho mas allá de una red casera y decidieron enfocarlo hacia las aplicaciones basadas en Internet o con cierto nivel de desempeño requerido en el trabajo de red, además de satisfacer a las empresas que demandaban un lenguaje que se pudiese implementar en todas sus máquinas, sin importar el sistema operativo sobre el que trabajaran.

Aunque el lenguaje Java es sintácticamente similar a C++, difiere enormemente en su fundamento:

-Java es un lenguaje puramente orientado a objetos, interpretado, esto significa que los programas realizados con Java no son ejecutables por si solos, existe otro programa que los interpreta cada vez que son requeridos. Esto puede causar disminución en la velocidad de ejecución de las aplicaciones, pero, aunque aun no se alcanza la rapidez de ejecución de los programas hechos en C++ o Visual BASIC, se ha mejorado enormemente con respecto a las primeras versiones del lenguaje, lo que significa que tal vez en un futuro cercano la rapidez deje de ser un impedimento para usar Java.

-C++ utiliza, como característica principal, apuntadores a memoria y delega a los programadores, simples seres humanos, la tarea de localizarla, controlarla y liberarla. Mientras tanto, Java utiliza objetos de tipo seguro, no permite la asignación de memoria dinámica y gracias a su recolector de basura (garbage collector) la memoria sin usar se recicla automáticamente.

La base de la plataforma Java es una máquina virtual, la cual puede ser implementada en los más populares sistemas operativos y en gran variedad de hardware. Por lo que se puede tener aplicaciones binarias Java operando consistentemente a través de diferentes implementaciones.

Las APIs (Application Programming Interface) Java son el conjunto de clases y objetos que permiten, mediante la utilización del lenguaje Java, la interacción entre el programador y la computadora y entre esta y el usuario final.

Juntos, el lenguaje de programación Java, la máquina virtual y las apis, forman la plataforma Java (Fig. 1.1) , la cual, en su versión 2, se puede encontrar en tres ediciones:

-Java 2 Standard Edition (J2SE). Diseñada para computadoras de escritorio, puede trabajar en sistemas operativos como: Windows, Linux, MacOS, Solaris, OS x.

-Java 2 Enterprise Edition (J2EE). Plataforma para aplicaciones multiusuario o empresariales. Se basa en J2SE y agrega apis para trabajo en el servidor.

-Java 2 Micro Edition (J2ME). Conjunto de tecnologías y especificaciones desarrolladas para dispositivos pequeños como los teléfonos celulares y PDA (palm, agendas electrónicas). Utiliza derivados de componentes J2SE, como son una máquina virtual más pequeña y un conjunto de apis menos potentes.

Figura 1.1. La plataforma Java
1.2.1.Introducción a J2ME
A diferencia de J2SE, la micro edición de Java no es sólo una pieza de software ni una simple especificación, J2ME es una plataforma, una colección de tecnologías y especificaciones diseñadas para diferentes partes del mercado de los dispositivos pequeños.

J2ME se divide en configuraciones, perfiles y paquetes opcionales. Las configuraciones son especificaciones que detallan una máquina virtual y un conjunto base de apis que pueden ser usadas en cierta clase de dispositivos. La maquina virtual puede ser completa, como la describe la especificación o algún derivado de ella.

Un perfil trabaja sobre una configuración pero agrega apis específicas para hacer un entorno completo de construcción de aplicaciones. Usualmente incluyen apis para el ciclo de vida de las aplicaciones, interfaz de usuario y almacenamiento persistente.

Un paquete opcional provee una funcionalidad que puede no estar relacionada con alguna configuración o perfil, por ejemplo la API Bluetooh (JSR182).

Actualmente J2ME tiene disponibles dos configuraciones:

-Connected Limited Device Configuration (CLDC). Para dispositivos pequeños con conexiones de red intermitentes, como teléfonos celulares y PDA.

-Connected Device Configuration (CDC). Diseñada para aparatos más grandes (en términos de memoria y poder de procesamiento) con conexiones de red robustas.

MIDP (Mobile Information Device Profile) es el perfil con mayor desarrollo en la plataforma Java, aunque se está investigando el PDA Profile. MIDP incluye apis de interfaz de usuario, de ciclo de vida de aplicaciones y algunas de almacenamiento persistente.

Los dispositivos implementan una "pila" de software completa, la cual consiste usualmente en una configuración, un perfil y apis opcionales.

Figura 1.2. Pila de software para JSR185

JSR185, Java Technnology for Wireless Industyry (JWTI), es la especificación vigente para el desarrollo de aplicaciones inalámbricas en Java, con esta especificación se intenta dejar de lado algunos problemas de compatibilidad entre dispositivos que las anteriores especificaciones dejaron pendientes, así que JSR185 exige que todos los fabricantes que deseen adoptar esta especificación deben incluir en sus dispositivos CLDC 1.0 o 1.1, MIDP 2.0 y WMA (Wireless Messaging API), dejando opcional MMAPI (MultiMedia API), de esta forma el desarrollador puede saber que esperar de una clase de dispositivos y con esto crear aplicaciones altamente portables. En la figura 1.2 se presenta gráficamente esta pila de software.

1.3.Tecnología WAP y WML

1.3.1.WAP (Wireless Application Protocol)

Este protocolo pretende ofrecer a los usuarios de equipos con recursos de memoria, resolución de pantalla y capacidad de procesamiento limitados las mismas funcionalidades que se ofrecen de Internet a través de computadoras personales, pero con las ventajas y limitantes propias de estos dispositivos.

1.3.2.WML (Wireless Markup Language)

WML es un lenguaje de aumento o ganancia (markup) de texto basado en el lenguaje de aumento extensible (XML, Extensible Markup Language) y fue desarrollado para especificar contenidos e interfaces de usuario para terminales de banda estrecha tales como teléfonos móviles e intérpretes de páginas. WML est` diseñado para trabajar con dispositivos inalámbricos pequeños que poseen cuatro características:

-Pantalla pequeña de baja resolución. Al nacimiento de este lenguaje, la resolución de los teléfonos celulares se limitaba a unas cuantas lineas de texto y de 8 a 12 columnas de caracteres, debido al rápido aumento en ese ramo, las nuevas versiones del lenguaje se pueden implementar en equipos con resoluciones de hasta 256 x 256 pixeles..

-Los aparatos de entrada tienen una capacidad limitada o están diseñados para un propósito determinado. Un teléfono móvil tiene comúnmente teclas numéricas y un reducido número de teclas adicionales con funciones especificas. Algunos dispositivos más sofisticados pueden poseer teclas programables de software, pero no un ratón ni otros dispositivos de selección.

-Los recursos computacionales están limitados por una CPU de baja potencia, una memoria reducida y una potencia restringida.

-La red ofrece un reducido ancho de banda y una alta latencia. No son infrecuentes los aparatos con conexiones de red de 300 bit/s a 10 Kb/s y latencia "round-trip" de entre 5 y 10 segundos.

Las características del lenguaje WML pueden agruparse en cuatro áreas principales:

-Ofrece un soporte de texto e imagen y tiene una amplia variedad de formatos y comandos.

-Las cartas (fragmentos de página o pantallas) WML se agrupan en barajas. Una baraja WML es similar a una página HTML identificada por una URL (Universal Resource Location, localización universal de recursos) y es la unidad básica de transmisión de contenidos.

-Ofrece soporte para gestión de navegación entre cartas y barajas, e incluye comandos para su manejo. Estos pueden usarse para navegar o ejecutar scripts, WML también provee de conexiones de anclaje similares a las usadas en el HTML versión 4.

-Se pueden establecer parámetros para todas las barajas de WML usando un modelo establecido. Se pueden usar variables en lugar de cadenas y sustituirse en el tiempo de ejecución. Esta forma de establecer parámetros permite que los recursos de la red sean usados de forma eficiente.

Toda la información de WML se transmite en formato codificado por la red inalámbrica.

Programación Cliente-Servidor

2008-11-16T17:27:00.000-08:00

Java es un nuevo lenguaje de programación, como tantos otros. Así que uno se pregunta el por qué del revuelo que se ha formado con su aparición. La respuesta no es inmediatamente obvia si se observa el asunto desde el punto de vista de la programación tradicional, porque aunque resuelve algunos de los problemas típicos de este tipo de programación, lo que verdaderamente es importante es que también resuelve los problemas que se generan en Internet, en la Telaraña Mundial, en el World-Wide-Web, en la Web.
Internet puede resultar algo misterioso al principio, sobre todo porque se utiliza un vocabulario propio, que hasta que no se domina, uno anda un poco despistado. Pero, en esencia, Internet es un sistema Cliente-Servidor gigante. La idea primaria de un sistema cliente-servidor es que debe haber un sitio donde se centraliza la información, que se desea distribuir bajo demanda a un conjunto de personas o máquinas.

La clave de este concepto radica en que si se produce un cambio en la información del sistema central, inmediatamente es propagada a los receptores de la información, a la parte cliente. Luego, el concepto básico es muy simple; el problema se presenta cuando hay solamente un servidor que tiene colgados a muchos clientes, en que el rendimiento general del sistema decrece de forma exponencial al aumento del número de clientes.

El funcionamiento de la Web sigue este mismo principio. Inicialmente, se solicita una información a un servidor y éste envía de vuelta un fichero que será interpretado por el navegador (el cliente) que lo formateará para visualizarlo en la máquina cliente. El navegador fue el primer paso adelante en la expansión de Internet, ya que permitía visualizar un mismo fichero en plataformas diferentes sin hacerle cambio alguno; pero su finalidad principal es la visualización de ficheros, no la interactividad con el usuario, ni la posibilidad de ejecutar programas en la parte del usuario, en la parte cliente del sistema.

Para proporcionar un poco de interactividad, se dotó al lenguaje HTML de ciertos mecanismos básicos de entrada de datos, como botones, cajas de selección, campos de texto, y algunos otros; pero la carga que incorporaban al sistema caía del todo dentro del lado del servidor, con lo cual, si había muchos clientes colgando, el colapso del servidor era casi seguro. Así que surgieron algunas alternativas a los CGI, para que se pudiese descargar al servidor de tanto trabajo y que el cliente realizase también operaciones.

Plug-ins

Esto son piezas de código que se incorporan al navegador y le indican que "a partir de ahora dispones de una nueva característica". Hay carasterísticas que se añaden a los navegadores a través de plug-ins que son muy rápidas y eficientes, pero el problema es que escribir un plug-in no es una tarea trivial ni tampoco es algo que haya que hacer en el proceso de construcción de un Site. Luego los pulg-ins son herramientas válidas para programadores muy expertos que permiten incorporar características nuevas al navegador sin necesidad de que el vendedor conceda su permiso.

Scripts

Un lenguaje script permite embeber código fuente para la programación del lado cliente, directamente en la página HTML, y el plug-in que interpreta ese lenguaje se activará automáticamente cuando se cargue en el navegador. Estos lenguajes tienden a ser muy simples y sencillos, además se cargan muy rápidamente porque van incluidos en la página que envía el servidor. La pega es que el código del programador está expuesto a la vista de cualquiera, aunque tampoco se pueden hacer demasiadas filigranas con un lenguaje script.

Estos lenguajes se utilizan fundamentalmente para hacer más atractivos los interfaces gráficos de las páginas, porque disponen de elementos gráficos y pueden llegar a resolver el 80% de los problemas que se plantean en la programación de la parte cliente del sistema cliente-servidor; y, además, son lenguajes mucho más sencillos de aprender e implementar soluciones con ellos que recurrir a Java o ActiveX. Siempre que los problemas del caigan dentro de ese 80% que son capaces de resolver los lenguajes script, y el programador se encuentre cómodo con este tipo de lenguajes, serían la elección prioritaria, antes de adentrarse en las profundidades que representa siempre el estudio de un nuevo lenguaje de programación.

El lenguaje script más utilizado es JavaScript, que no tiene nada que ver con Java, me imagino que se llamará así para aprovechar el tirón de popularidad de Java, pero también se pueden realizar scripts en la parte cliente con Visual Basic o con Tcl/Tk.

Java

¿Y qué pasa con el 20% de los problemas que no pueden resolver los lenguajes script? La respuesta más común, si se hiciese una encuesta, sería Java, y no solamente porque sea un poderoso lenguaje de programación enfocado a la seguridad, multi-plataforma e internacional, sino porque Java está siendo continuamente extendido para proporcionarle nuevas características y librerías que resuelven elegantemente problemas que son muy difíciles en la programación tradicional como el acceso a bases de datos, el uso de multihilo, la programación de redes y la programación distribuida, y además porque Java, a través de los applets, permite la programación de la parte cliente.

Un applet es un miniprograma que corre solamente bajo un navegador y es descargado automáticamente como parte de una página Web, al igual que cualquier gráfico, y cuando se activa, ejecuta un programa. Este es el interés, proporciona una forma a través de la cual se puede distribuir software al cliente desde el servidor, en el momento en que el cliente necesite ese software, y no antes, con lo cual siempre tendrá el cliente la última versión de ese software, se actualice cuando se actualice. Además, tal como está diseñado Java, el programador necesita crear su programa una sola vez, y ya estará listo para ser ejecutado en todas las plataformas que dispongan de un navegador con soporte Java.

Con Java se podrá realizar tanto trabajo como sea posible en el cliente antes y después de hacer peticiones al servidor. Por ejemplo, se puede evitar el enviar una petición a través de Internet mientras el usuario no haya introducido los parámetros correctos de esa petición, que estará chequeando el cliente, sin necesidad de tener que consultar continuamente al servidor; con ello se gana en velocidad de respuesta ante el usuario, una reducción general en el tráfico de red y una gran descarga de trabajo para el servidor.

Una de las ventajas de los applets sobre los scripts es que están en forma compilada, con lo cual el código fuente no es visible; aunque se puede descompilar sin demasiadas complicaciones, pero vamos, no está del todo accesible. Además, un applet puede comprimir varios módulos, utilizando ficheros JAR, evitando múltiples conexiones con el servidor, ya que en una sola se descargan todos los componentes necesarios.

Y, finalmente, está la curva de aprendizaje, porque a pesar de lo que el lector haya podido escuchar o leer por ahí, Java no es un lenguaje trivial. Si el lector domina Visual Basic, por ejemplo, el que realice sus trabajos en VBscript le resultará más fácil y rápido y resolverá sus problemas de programación cliente-servidor sin embarcarse en la dura empresa de aprender Java.

ActiveX

La competencia directa de Java es ActiveX, de Microsoft, aunque su enfoque sea bastante diferente. ActiveX es originalmente una solución orientada a entornos Windows, aunque parece ser que ahora está siendo desarrollado para ser multiplataforma. Lo que hace ActiveX es decir "si tu programa se conecta a este entorno, se podrá descargar en una página Web y correr bajo un navegador que soporte controles ActiveX". Microsoft Internet Explorer soporta ActiveX directamente y Netscape lo soporta a través de plug-in. Por lo tanto, ActiveX no está constreñido a un solo lenguaje de programación, sino que se pueden desarrollar componentes ActiveX en el lenguaje que domine el programador, ya sea C++, Visual Basic o el Delphi de Borland.

Scriptlets

Microsoft ha subido una vez más la apuesta en su batalla contra Java con el lanzamiento de los scriplets, que son similares en naturaleza a los componentes JavaBeans, y aparecen como una campaña de vaporware por parte de Microsoft. Su aparente meta es posicionar esta tecnología como un potencial rival multiplatafroma de Java, que, según dice Microsoft, no cumple su compromiso de ser tan manejable como propugna su publicidad. Los scriptlets, a diferencia de Java, sólo se pueden utilizar sobre un navegador Web. Si bien es cierto que a los applets les ocurre lo mismo, Java deja abierta la posibilidad de crear aplicaciones, dependientes de una máquina virtual Java, pero no de un navegador; y en cuanto la máquina virtual Java se encuentra incluida en el propio sistema operativo, el usuario no advierte dependencia alguna. La verdad es que los scriptlets no aportan nada nuevo a las posibilidades de las herramientas actuales, sino que son otra forma de hacer lo mismo.

La descarga y ejecución automática de programas a través de Internet, en principio, suena como el sueño de cualquier creador de virus. Los componentes ActiveX son especialmente sensibles a este ataque, ya que se puede hacer lo que se quiera, sin control alguno, con lo cual, el usuario puede bajarse un componente ActiveX que haga estragos en su máquina. Esto no es nuevo, sino que es un problema largamente conocido desde los tiempos de las BBS, pero que aquí se ve amplificado por la velocidad de Internet.

Cuando se pide una página Web, se reciben ficheros gráficos, el código de la página (con o sin scripts), código Java precompilado y componentes ActiveX. De estos, algunos son casi inofensivos, como los ficheros gráficos y el código HTML de la página, porque es muy poco lo que se puede manipular sobre ellos. Java está diseñado para ejecutar los applets en una caja cerrada (sand box), envuelta en una capa de seguridad que impide cualquier acceso a disco o a memoria que se encuentre fuera de esa caja cerrada. Así que, la parte más propensa a introducir elementos no deseados en la máquina cliente son los componentes ActiveX.

Actualmente se está intentando paliar esta desagradable posibilidad a través de las firmas digitales, que permiten reconocer al autor. Esta idea parte de que los autores de virus normalmente son anónimos, y si se eliminan estos componentes anónimos, siempre se podrá forzar al programador a que sea responsable de sus acciones. Puede se una buena idea, porque permitirá a los programas ser más funcionales, aunque si un programa tiene un bug inadvertido que pueda resultar destructivo, todavía podrá causar problemas.

Con respecto a Java, hay diversas opiniones respecto a la draconiana restricción a que un applet no pueda escribir en el disco local del cliente; porque, que pasa si el usuario quiere crear una base de datos local, o quiere guardar cualquier tipo de información para cuando se encuentre desconectado de Internet. La asunción inicial de que todo el mundo estaría conectado es impracticable, aunque si se redujesen los precios del teléfono, pudiese llegar a ser el estado normal de muchos usuarios; así que la solución debe llegar por otra vía. Los applets firmados, que utilizan una clave pública para comprobar que el applet viene del lugar correcto y no ha sido manipulado puede ser una de esas soluciones. Desde Java 1.1 se dispone de un entorno para implementar firmas digitales, por lo que si fuese necesario se podría hacer que un applet se saliese de su caja cerrada.

Mas de Java

2008-11-16T17:24:00.000-08:00

El uso principal que se hace de Internet e incluso de las redes internas (corporativas) es correo electrónico (e-mail), aunque actualmente hay un auge sorprendente de la navegación web. Los documentos web pueden contener variedad de texto, gráficos de todas clases y proporcionar enlaces hipertexto hacia cualquier lugar de la red. Los navegadores utilizan documentos escritos en lenguaje HTML. La combinación actual de navegadores HTML/WWW están limitados pues a texto y gráficos. Si se quiere reproducir un sonido o ejecutar un programa de demostración, primero hemos de bajarnos (download) el fichero en cuestión y luego utilizar un programa en nuestro ordenador capaz de entender el formato de ese fichero, o bien cargar un módulo (plug-in) en nuestro navegador para que pueda interpretar el fichero que hemos bajado.

Hasta ahora, la única forma de realizar una página web con contenido interactivo, era mediante la interfaz CGI (Common Gateway Interface), que permite pasar parámetros entre formularios definidos en lenguaje HTML y programas escritos en Perl o en C. Esta interfaz resulta muy incómoda de programar y es pobre en sus posibilidades.

El lenguaje Java y los navegadores con soporte Java, proporcionan una forma diferente de hacer que ese navegador sea capaz de ejecutar programas. Con Java se puede reproducir sonido directamente desde el navegador, se pueden visitar home pages con animaciones, se puede enseñar al navegador a manejar nuevos formatos de ficheros, e incluso, cuando se pueda transmitir video por las líneas telefónicas, nuestro navegador estará preparado para mostrar esas imágenes.

Utilizando Java, se pueden eliminar los inconvenientes de la interfaz CGI y también se pueden añadir aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo, a juegos o aplicaciones especializadas para la televenta. Es posible implementar publicidad interactiva y periódicos personalizados. Por ejemplo, alguien podría escribir un programa Java que implementara una simulación química interactiva -una cadena de adn-. Utilizando un navegador con soporte Java, un usuario podría recibir fácilmente esa simulación e interaccionar con ella, en lugar de conseguir simplemente un dibujo estático y algo de texto. Lo recibido cobra vida. Además, con Java podemos estar seguros de que el código que hace funcionar el experimento químico no contiene ningún trozo de código malicioso que dañe al sistema. El código que intente actuar destructivamente o que contenga errores, no podrá traspasar los muros defensivos colocados por las características de seguridad y robustez de Java.

Además, Java proporciona una nueva forma de acceder a las aplicaciones. El software viaja transparentemente a través de la red. No hay necesidad de instalar las aplicaciones, ellas mismas vienen cuando se necesitan. Por ejemplo, la mayoría de los navegadores del Web pueden procesar un reducido número de formatos gráficos (típicamente GIF y JPEG). Si se encuentran con otro tipo de formato, el navegador estándar no tiene capacidad para procesarlo, tendría que ser actualizado para poder aprovechar las ventajas del nuevo formato. Sin embargo, un navegador con soporte Java puede enlazar con el servidor que contiene el algoritmo que procesa ese nuevo formato y mostrar la imagen. Por lo tanto, si alguien inventa un nuevo algoritmo de compresión para imágenes, el inventor sólo necesita estar seguro de que hay una copia en código Java de ese algoritmo instalada en el servidor que contiene las imágenes que quiere publicar. Es decir, los navegadores con soporte Java se actualizan a sí mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o algoritmo.

En esta filosofía es en la que se basan los NC (Network Computer), que serán ordenadores sin disco y con mucha memoria. Sus programas residen en un servidor que se los envía cuando los solicita. Es quizá un guiño al pasado y una versión futurista de lo que ha sido un Terminal-X en otros tiempos, salvando las diferencias, evidentemente (no sea que alguien me tilde de irreverente con las nuevas tecnologías).

Portabilidad de Java

2008-11-16T17:00:00.001-08:00

Java es una palabra que actualmente está en boca de todos y ha creado una auténtica revolución. Nosotros nos enfocaremos al lenguaje Java, y la verdad es que no es para tanto el armar ese revuelo. Verdad es que Java es una gran idea, pero, no escandalosamente genial. Quizá todo se haya visto magnificado por Internet, pero Java se anuncia como un lenguaje completo de propósito general y, bueno, hay ciertas porciones del mismo que no están definidas o son discutibles, y algunas características son ciertamente oscuras. A lo largo del Tutorial iremos presentando todas esas cosas.

La creación de este Tutorial ha partido de la necesidad de aprendizaje del lenguaje Java para implantarlo en aplicaciones críticas. Se necesitaba una evaluación del lenguaje para comprobar si podría emplearse en el desarrollo de pequeñas aplicaciones (no necesariamente con Internet por medio, aunque también). Esto ha hecho que hayamos investigado en muchas fuentes, principalmente de Sun Microsystems, y obtenido las conclusiones a que queríamos llegar. Que resumiendo vienen a indicarnos que, tal como se encuentra definido Java actualmente y con las herramientas que hay, si no hay interés en Internet, lo mejor es olvidarse de Java. Aunque pronto pueda que esta afirmación sea falsa, dado el empeño que todo el mundo está poniendo en llevar a Java a buen puerto, pero la decisión del grupo que hemos formado fue descartar Java (momentáneamente).

En toda esta historia nos hemos dado cuenta de que falta literatura en castellano; como siempre, vamos a remolque. Por ello ha sido el desarrollar este Tutorial de Java, que esperamos (espero) humildemente, sea de provecho para alguien. Eso sería ya una gran satisfacción para mí. Quizá yo no sea la persona más indicada para estar escribiendo esto, porque todavía soy y siempre me consideraré un principiante en Java, pero sí que puedo transmitir los pocos conocimientos que he adquirido, y eso es lo que haré.

Todas las sugerencias que alguien pueda ofrecer, serán bienvenidas. Prometo contestar a todo el mundo, si no me sobrepasa el correo. Y me gustaría que pudiésemos ir haciendo crecer este Tutorial de Java entre mucha más gente. No obstante, la experiencia de muchos años de BBS me dice que hay mucho escuchador y poco participador, por lo que el Tutorial esta casi planteado en un noventa por ciento. Aunque, repito, todas las colaboraciones serán bienvenidas y si van con el estilo, incluidas en el Tutorial de Java que arranca aquí.

Y una recomendación final, antes de que alguien se decida a publicar un applet nada más terminar de leerse éste u otro Tutorial sobre Java. Hay que ser críticos con nuestro trabajo. Debemos valorar mucho nuestra estima y, por ende, el código que escribimos bajo nuestro nombre. Actualmente hay muchos applets que se pueden visualizar y, desgraciadamente, bastantes de ellos son de muy baja calidad, escritos por programadores que están dando sus primeros balbuceos en Java. Más que applets son crapplets (crap es una forma coloquial de mierda), algunos de ellos incluso se quedan colgados o no tienen un rendimiento mínimo aceptable. Debemos renunciar a una excesiva rapidez de desarrollo en beneficio de un código fiable y bien diseñado. Y parafraseando palabras de Alex Newman, director ejecutivo de Sun User Group/Java: "Hay un montón de buenos programadores que no se dedican a ir por ahí vendiendo código. Lo que hacen es buscar trabajo. Saber programar en Java será algo positivo para incluir en el currículum".

No obstante, y para que todos tengamos una idea general de lo que es Java, haremos una serie de aclaraciones o indicaciones, para que alguien que no esté muy decidido a aprender Java, pueda tener elementos de juicio y de comparación para tomar esa decisión. Por ello, haremos una introducción más extensa de lo que sería habitual en un Tutorial, lo que también me permitirá verter ciertas opiniones que en otro sitio no tendrían cabida.

Esta es la segunda versión del Tutorial de Java corregida, ampliada y readaptada para acomodarse a las nuevas características introducidas a Java por Sun desde la versión 1.1 del Java Development Kit (JDK) y adaptándose en todo lo posible a la versión 1.2. He revisado todo el código fuente, he añadido algunos ejemplos más en las partes en las que más consultas he tenido y también, en respuesta a demanda, he incorporado algunas secciones, que aunque no son tan básicas como pretendo yo con el Tutorial, sí parece que resultan muy interesantes a la mayoría de los lectores de la versión anterior del Tutorial (que todavía se puede encontrar en la dirección http://www.fie.us.es/info/internet/JAVA/).

ESTA NO ES UNA TRADUCCION DEL "JAVA TUTORIAL" DE SUN Microsystems, POR LO QUE LOS TEMAS QUE SE TRATAN SON LOS QUE A MI ME PARECEN MAS INTERESANTES. TAMPOCO ME UNE NINGUN TIPO DE RELACION CON SUN NI CON NINGUNA DE SUS FILIALES.

Quien vaya a desarrollar applets para su publicación en Internet y pretenda que llegue a la mayoría de navegantes que aterricen en su página, ha de saber que si desarrolla con el JDK 1.1.X, y más con el JDK 1.2, sus applets no podrán verse con una versión inferior a la 4.0 de los navegadores más extendidos, Netscape y Microsoft Explorer. E incluso estos navegadores no tienen soporte total del JDK 1.1.X, a fecha de hoy.

El JDK 1.1 fue un tremendo paso adelante en la evolución de Java y en el JDK 1.2 se han incorporado a la Plataforma Java muchas de las APIs que estaban en versiones individuales. El rendimiento y estabilidad de Java son mucho más sólidos, y los JavaBeans van a representar un modelo a seguir por muchas empresas. También el movimiento 100% Pure Java asegurará que los applets que hoy se están desarrollando, funcionarán en cualquier entorno del mañana, y no todo el mundo puede precisar algo semejante. Creo que nunca una tecnología nueva ha sido adoptada por tanta gente en tan poco tiempo.

Las críticas que se hacen a Java de que no está completamente definido y de que sus capacidades dejan bastante que desear, deben hacer reflexionar a quienes las predican, porque es menester recordar que el rendimiento es un camino no una meta, siempre estamos en condiciones de mejorar algo, sea lo que sea. Y tal como se está moviendo el mercado entorno a Java, pronto veremos que Java entra de verdad en el mundo de los negocios y su estabilidad se verá infinitamente más robustecida.

Conocimientos Previos

En el planteamiento inicial se supone que tú, que estás leyendo esto, tienes experiencia en algún lenguaje de programación, como puede ser C o un lenguaje similar, también que sabes utilizar un navegador de WWW como Netscape o Internet Explorer, también que eres capaz de desarrollar páginas WWW con HTML y comprendes la programación orientada a objetos. Intentaré que estos conocimientos sean suficientes para poder seguir el Tutorial. Haré referencias a C++ para la mejor comprensión de lo que hace diferente a Java, porque muchos de los lectores del anterior Tutorial tenían conocimientos de C++, y la mayoría de las consultas que se me hacen van en esa orientación.

El entorno de desarrollo habitual entre la gente que trabajamos con el JDK (los pobres sin poder para comprarse herramientas comerciales) consiste en tener abiertas sobre el escritorio de la pantalla, ya sea en Solaris, Windows '95/NT o Linux, varias ventanas, que usamos para lo siguiente:

En una de ellas tenemos abierto HotJava, apuntando al fichero packages.html de la documentación del API de Java, para poder tener al momento la información sobre los parámetros de llamada, valores de retorno y la información de cada una de las funciones que estemos utilizando.
Los que estén desarrollando sobre Windows '95 o NT, podrán disponer de la documentación del API también desde el sistema de ayuda de Windows si han descargado esta documentación en formato Winhelp desde Dippy.
En otra tendremos abierto un navegador con soporte Java, normalmente será Netscape, en una versión superior a la 4.0.3, para que tenga soporte al JDK 1.1.X en los applets que desarrollemos, o Microsoft Explorer, en versión 4.0 o superior. Aunque, lo mejor sin duda es utilizar, por ahora, el appletviewer para la verificación del correcto funcionamiento de los applets, antes de pelearnos con problemas que pueden originarse en el soporte a medias del JDK 1.1.X por parte de los navegadores comerciales.
Tendremos abierta otra ventana con un editor, donde iremos escribiendo el código de nuestro applet o aplicación Java. En Windows '95 son muy utilizados el editor Jpad y Diva. Aunque en estos momentos, quien tiene potencia suficiente en su ordenador, está programando Java desde el Java Workshop de Sun.
Y una ventana más donde tendremos acceso al prompt del sistema para poder invocar al compilador y a las demás herramientas del JDK.
Los que tengan algo de dinero podrán estar utilizando alguno de los entornos shareware que ya hay disponibles como RadJa, Kawa o JavaMaker.
Los que disponen de poder adquisitivo abundante habrán empezado con el Symantec Café de Symantec, ahora estarán trabajando con Borland Latte, o estarán entusiasmados con el Visual J++ de Microsoft. Y los enamorados de OS2, que en su versión 4.0 ya incluía una Máquina Virtual Java (JVM) en su kernel, se lo pasarán en grande con el IBM VisualAge for Java.
También somos afortunados los que podemos disfrutar de las ventajas que ofrece Linux, que con ser el sistema operativo más económico, resulta ser uno de los más potentes. Y esto también es válido cuando se trata de Java, porque el porting realizado del JDK es muy bueno.

Objetivos

Entre los objetivos que me he marcado están los que expongo a continuación. Estos objetivos esperan que tú, que estás leyendo esto, cuando llegues al final del Tutorial, saques el máximo aprovechamiento de lo que yo sé y seas capaz de:
Crear páginas HTML que llamen a applets Java
Crear contextos gráficos en Java
Utilizar los componentes del interfaz gráfico que proporciona Java
Crear aplicaciones autónomas en Java
Crear aplicaciones multi-threaded
Utilizar las librerías de E/S para manipular ficheros de texto y datos
Crear servidores y clientes TCP/IP que se comuniquen vía socket

Intentaré cumplir lo que acabo de prometer, aunque también pido paciencia, ya que Java en este momento es un lenguaje con una tremenda vitalidad, que todavía estoy yo aprendiendo. Y por otro lado, no es nada sencillo el hacerse entender, por lo que tengo que dar varias vueltas a cada una de las frases que escribo para cerciorarme de que tú, lector, comprendes exactamente lo que yo te quiero transmitir.

Eso sí, tampoco esperes que te proporcione ungüentos milagrosos, que por arte de magia traspasen el conocimiento. El estudio de Java, y sus applets, no será sino el examen de una particular forma de ver las cosas, con un poco de estructuración en la presentación y un cierto trasfondo de Internet; el resto es, como siempre, tarea del programador. Es decir, uno puede aprender a construir un applet, o dejar que alguna de las herramientas lo construyan automáticamente, igual que puede enseñarse a codificar un diálogo en un entorno gráfico, pero... la inteligencia de esa pieza siempre dependerá de la habilidad y experiencia del programador respecto del lenguaje usado y de sus recursos. En fin, un buen applet será únicamente resultado del trabajo de un buen programador Java.

Para concluir esta presentación, aquí está un enlace a páginas que mantienen relación con el Tutorial, bien en forma de enlaces o mirrors, y en donde puedes encontrar información que cumplimente todo lo que en este Tutorial se cuenta.

Cambiar los colores del Nimrod Look&Feel

2008-11-06T17:13:00.000-08:00

El creador de Nimrod Look&Feel ha dado la posibilidad de cambiar los colores y la opacidad de este Look&Feel. Esto se realiza a través de un editor que incorpora el fichero .jar del propio "skin".

Cuando el fichero nimrodlf.jar (el mismo que usted importa al proyecto para obtener el Look&Feel) es ejecutado haciendo doble click sobre el mismo o escribiendo en la línea de comandos:

java -jar nimrodlf.jar

...se puede observar el editor que trae consigo este Look&Feel y que le permite, entre otras cosas cambiar los colores del Look&Feel y la opacidad.

Aquí se pueden modificar, probar y guardar en un fichero llamado NimRODThemeFile.theme (este nombre se puede cambiar, por supuesto) las características antes mencionadas(color y opacidad). Esto se logra haciendo clicks en los recuadros "Selection", "Background", "Menu Opacity" e "Internal Frame Opacity" y escogiendo los colores y opacidad que usted desee.

Después de haber escogido los colores y la opacidad deseada se pulsa el botón "Save" y se guarda esta configuración en un fichero .theme con el nombre por defecto NimRODThemeFile.

Este fichero se coloca luego dentro de la carpeta de tabajo(../src) y cuando se compila la aplicación, habiendo importado previamente el .jar del Nimrod Look&Feel este detecta automáticamente el fichero .theme con la configuración requerida y....se puede observar al ejecutar acto seguido la aplicación como cambia el aspecto de este Look&Feel.

Aquí les dejo un video de como se lleva acabo todo el proceso...

Maximizar jFrame

2008-11-03T10:56:00.001-08:00

Si queremos que al iniciar una aplicación Java nuestra ventana principal se encuentre maximizada no importa la resolución de pantalla con la cual se esté trabajando lo único que tenemos que hacer es escribir en el constructor de nuestro jFrame principal la siguiente línea de código:

this.setExtendedState(this.MAXIMIZED_BOTH);

De forma tal que nuestro constructor nos quedaría más o menos así:

public MyFrame(){
this.setExtendedState(this.MAXIMIZED_BOTH);
initComponents();
...
...
}

A la línea:
this.setExtendedState(this.MAXIMIZED_BOTH);

se le pueden pasar otros parámetros:

this.MAXIMIZED_HORIZ //Maximiza la aplicación horizontalmente

this.MAXIMIZED_VERT //Maximiza la aplicación verticalmente

Java en los Browser

2008-10-29T20:26:00.001-07:00

JAVA EN LOS BROWSERS:------El primer lugar y el más frecuente, donde encontramos al lenguaje Java, es en los exploradores o navegadores de Internet. Veamos cómo llega hasta ahí.

La World Wide Web:------Llamada así por sus siglas WWW, es la aplicación que ha popularizado a Internet, y ha sido la causante de la explosión de la red de redes.

Hablando sencillamente, la WWW basa su existencia en dos aplicaciones: los servidores de Web y los clientes. Los primeros son programas dedicados, instalados en las máquinas nodos de la red, que atienden a todos los pedidos de los clientes. Estos solicitan archivos, recursos de la Web , en general, archivos HTML y gráficos. Los archivos HTML son archivos de texto, que contienen una descripción de lo que vemos como página en nuestro browser. La sigla HTML significa Hypertext Markup Languaje (lenguaje de marcación de hipertexto), y es el lenguaje que describe las páginas Web.

En esas páginas se colocan textos, gráficos y otros recursos. Es trabajo del cliente, nuestro browser, interpretar esa página, mostrarla en pantalla, y reclamar todo lo que se necesite para armarla, como los gráficos y archivos de sonido que la pueden acompañar.

Java en la Web:------Los programas Java son, al fin, otro recurso más, como pueden serlo una página HTML o un archivo gráfico. Al igual que estos últimos viajan desde el servidor a la máquina cliente, y se ejecutan en ésta.

Verá, cuando arme alguna applet, que existe una construcción, la marca HTML , que especifica un determinado lugar en una página Web, para que el browser posicione y ejecute una aplicación Java. Los archivos Java que viajan son de un tipo: se trata de archivos con extensión .class y contienen las instrucciones Java ya compiladas, no viajan en código fuente. Una applet se compone, como mínimo, de un archivo .class, pero puede requerir más archivos .class (con más código para ejecutar), que el browser recupera, o archivos gráficos, de sonido u otros, que la propia applet se encarga de recuperar.

Máquinas Virtuales:------Se ha mencionado que el lenguaje Java se compila, no pensando en una plataforma o procesador en particular, sino produciendo código (que se denomina bytecodes), destinado a ser interpretado por la llamada máquina virtual Java. Esta máquina no es una única, sino que hay una por cada plataforma y, en realidad, cada browser que implementa Java tiene la suya. Así, el Microsoft Explorer usará su máquina en Windows, mientras que el Netscape Navigator usará la suya, que variará de Windows a UNIX.

Pero todas tienen la misma funcionalidad (o debería esperarse eso). Tanto el usuario como los programadores no deberíamos preocuparnos por las distintas implementaciones. Sin embargo, se escuchan quejas de los desarrolladores, originadas en la pequeñas diferencias que se encuentran tanto entre una implementación y otra, como en el aspecto de la interface gráfica.

Además de la máquina virtual, cada browser instala una serie de clases, ya listas para usar, que Java espera tener disponibles en cualquier plataforma. Esas clases tienen una funcionalidad definida, que no debería sufrir modificaciones.

Netscape y Microsoft:------La empresa Netscape, creadora del Netscape Navigator, soporta Java desde la versión 2 de su browser. Microsoft no se ha quedado atrás y soporta Java desde la versión 2.0 de su browser. Microsoft no se ha quedado atrás (pues no le convenía, dado la mayoría de las páginas contiene - aunque sea - un poquito de Java) y soporta Java desde la versión 3.0 de su Internet Explorer. Ambos browsers instalan y usan su propia máquina virtual Java. No hay diferencias apreciables en las prestaciones de estos dos browsers, respecto de Java.

Hay que hacer algunas aclaraciones: en general, los browsers, de cualquier origen, soportan Java en ambientes que permiten la multitarea y los llamados múltiples hilos de ejecución (multihttrading).

Seguridad:------Debido a la naturaleza de Internet, traer programas desde un lugar lejano y no controlado a nuestra computadora, para ejecutarlo, puede ser riesgoso.

Con respecto a las applets Java debemos quedarnos tranquilos: Sun y los constructores de browsers han implementado una política de seguridad, que impide a una applet, por ejemplo, leer o escribir en nuestro disco, o interferir con otras aplicaciones en ejecución. Es tan grande la seguridad que, como programadores, nos puede llegar a molestar: en una applet nunca podremos grabar un archivo local, con datos transitorios o de configuración.

Nuevos browsers:
Entre Netscape (en múltiples plataformas) y Microsoft (en plataformas Windows) acaparan el mercado de los browsers.

Java sin browsers:

Pero no todo es Internet en Java. Este es un lenguaje de uso general, que sólo incidentalmente cobró popularidad en Internet. Podemos desarrollar aplicaciones Java que se ejecuten en nuestra máquina, sin necesidad de estar conectados a la red, y sin el auxilio de browsers. Mientras los programas Java para Internet y páginas HTML se llaman applets, los que pueden ejecutarse fuera de la red se llaman genéricamente aplicaciones.

Metro: Pila de webservices de Sun

2008-10-28T16:44:00.000-07:00
Metro es la actualización del antiguo JWSDP (Java Web Services Developer Pack), y digo actualización porque la mayor parte del código se hereda de JWSDP (dicho por uno de sus desarrolladores, si el código es bueno y funciona bien, para que cambiarlo? ).
Esta incluido en Glassfish (Servidor de aplicaciones de Sun) a partir de su versión 2.
Metro realmente es un paquete de diferentes tecnologías, entre las que se encuentran JAX-WS, JAXB, y WSIT (implementación de webservices, implementación de XML-Bindings y Webservices intercomunication tecnology, que permite comunicar sin problemas webservices java y .net 3).
Según los desarrolladores de Metro,
Veamos que necesitamos para usarlo y un pequeño ejemplo.
AVISO: Este tutorial presupone el conocimiento por parte del lector de muchos de los términos e ideas que aquí se exponen, por tanto exige niveles de conocimiento altos en las tecnologías subyacentes. Los ejemplos se muestran como fragmentos que el lector debe completar.
Instalación
La instalación es muy sencilla. Hay que descargarse el jar (https://metro.dev.java.net/1.1/) y ejecutarlo (java -jar metro-installer.jar o doble clic sobre el archivo si estas en windows).
Lo que nos va a instalar es una serie de herramientas y los ficheros necesarios para su funcionamiento. Estas herramientas, al igual que en axis, son las que nos van a permitir la generación automática de código para poder crear nuestros webservices.
Tendremos por tanto 2 posibilidades de crear un webservice.

A partir de un fichero WSDL (WebServices Description Language).

útil cuando ya tenemos este tipo de fichero, o queremos reimplementar la funcionalidad de un webservice ya publicado en internet (y que nos da igual que este en .net, java o cualquier otra tecnología).

No es recomendable este método para generar un webservice desde 0, puesto que es trabajo de crear el fichero .wsdl puede llegar a ser muy tedioso.
En la versión usada, Metro 1.1, WSDL 2.0 no está soportado.

A partir de una clase java.

Perfecto para crear un webservice desde 0, o publicar ciertos métodos de una aplicación java que tenemos ya desarrollada.

No recomendable cuando tengamos el fichero wsdl (El webservice generado puede no ser totalmente compatible con el del wsdl que teníamos).

Veamos detalladamente cada uno de los pasos.

Crear un WebService

Para todos los ejemplos vamos a usar el webservice público definido en 'http://wscc.info/index.php?show=32031_SWE&&page_anchor=http://wscc.info/p32031/p32031_swe.php', y que devuelve información de geolocalización de una ip dada. Además el webservice está realizado en .net, y así comprobaremos si WSIT funciona.

Desde un fichero WSDL

Para generar el webservice desde este tipo de ficheros vamos a usar la herramienta que trae Metro, wsimport, y que nos va a crear todas las clases necesarias para poder poner en funcionamiento el webservice. Un ejemplo de uso del comandos sería:

wsimport.sh -s src/main/java -p com.autentia.service -Xnocompile http://ws.ip2location.com/ip2locationwebservice.asmx?wsdl

Donde:

-s: ruta donde se van a generar los fuentes.

-p : paquete en el que se generará el código.

-Xnocompile : indica a la herramienta que no compile el código generado.

y nos generará las siguientes clases:
IP2Location.java: Java bean de tipo de dato complejo.

Ip2LocationWebService.java: Proxy del webservice.

IP2LOCATION.java: Java bean de tipo de dato complejo.

Ip2LocationWebServiceSoap.java: Interfaz del servicio.

IP2LocationResponse.java: Java bean de la respuesta del servicio.

ObjectFactory.java: Factoría de objetos usados internamente por el servicio.

package-info.java: Archivo para javadoc.
Como lo que vamos a hacer es reescribir el servicio web (hacer un webservice compatible con el wsdl usado pero realizado en java), no nos quedaría nada más que crear la clase skeleton del webservice (la que implementa la lógica de negocio del webservice).
Creamos una nueva clase java que tendrá la siguiente estructura (en este ejemplo la llamaremos IP2LocationSkel.java):

@WebService(endpointInterface="com.autentia.service.Ip2LocationWebServiceSoap") public class IP2LocationSkel implements Ip2LocationWebServiceSoap { ... }

Donde veis lo simple que es: creamos la clase y hacemos que implemente la interfaz generada anteriormente (no es obligatorio, pero si muy recomendable para saber cómo es el método a implementar en tiempo de compilación).

Lo que si es obligatorio es la anotación de la clase (y lo que le da potencia y sencillez a Metro): @WebService. La propiedad endpointInterface indica la clase (nombre cualificado) de la interfaz del webservice (y es por esto por lo que no es obligatorio implemetar la interfaz anterior).

Y ya está! Ya tendríamos nuestro webservice creado, en pocos pasos y de manera muy sencilla!

Desde java

Vamos a hacer ahora la operación inversa. Queremos realizar un webservice desde 0, no tenemos el fichero WSDL o ya tenemos una clase java de la que queremos hacer públicos alguno de sus métodos a través de webservice.

No tedríamos más que generar una clase java, que debe cumplir los siguientes requisitos:

La clase se debe anotar con @javax.jws.WebService.

Todos los métodos que se desean exponer como operación del webservice se pueden anotar con @javax.jws.WebMethod (si todos los métodos de la clase son operaciones del servicio web se puede omitir dicha anotación).

Todos los métodos que se desean exponer como operación del webservice pueden lanzar java.rmi.RemoteException, aparte de todas las excepciones específicas del servicio.

Todos los parámetros de los métodos del servicio y tipos de retorno deben ser compatibles con â€œJAXB 2.0 Java to XML Schema mapping definition".

Los parámetros de los métodos del servicio y tipos de retorno no pueden implementar directa o indirectamente la interfaz java.rmi.Remote.

Veamos una sección de la clase (una clase que implementa una pequeña calculadora):
@WebService public class AddNumbersImpl { @WebMethod public int addNumbers(int number1, int number2) throws AddNumbersException { ... } }

Fijaos en las anotaciones: hemos anotado la clase con @WebService, y el método addNumbers con @WebMethod (el único que expondremos como método del servicio web).
El siguiente paso: generar las clases de apoyo necesarias para poner en marcha el webservice, y para ello usaremos otra herramienta que nos provee Metro, y que se llama wsgen
wsgen.sh -cp -keep com.autentia.service.AddNumbersImpl
Donde:

-cp : indica el classpath a utilizar, es decir, la ruta o rutas de .jar o carpetas que contienen los .class necesarios para la compilación.

-keep : indica que no se borren los ficheros .java generados.

com.autentia.service.AddNumbersImpl: para el ejemplo, es la clase que implementa el webservice (denominado SEI: service endpoint implementation).

Que nos generará las siguientes clases:
AddNumbersExceptionBean.java : java bean para la excepción que puede lanzar el webservice.

AddNumbers.java : Skeleton del webservice.

AddNumbersResponse.java : clase de tratamiento de la respuesta SOAP.

Ya tenemos nuestro webservice! (sencillito, eh?)

Creando una aplicación web con nuestro webservice (war)
Una vez creado nuestro webservice veamos qué recursos y configuraciones debemos incluir para que el webservice funcione como una aplicación web y la podamos publicar (yo he usado tomcat y funciona sin problemas).
Ante todo debemos meter en la carpeta WEB-INF/lib de nuestro war los .jar (webservice*.jar) que vienen en la instalación de Metro.
Dentro de WEB-INF deben ir localizados web.xml y sun-jaxws.xml
El fichero de descripción de la aplicación web, web.xml, debe contener el siguiente fragmento (se define el servlet y filtros necesarios para que funcione Metro):
web.xml:
... <listener> <listener-class> com.sun.xml.ws.transport.http.servlet.WSServletContextListener </listener-class> </listener> <servlet> <description>JAX-WS endpoint - fromjava</description> <display-name>metro ws engine servlet</display-name> <servlet-name>metroServlet</servlet-name> <servlet-class> com.sun.xml.ws.transport.http.servlet.WSServlet </servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>metroServlet</servlet-name> <url-pattern>/ws/*</url-pattern> </servlet-mapping> ...

El fichero de descripción del webservice para Metro:

sun-jaxws.xml:

<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">

<endpoint name="addnumbers-example" implementation="com.autentia.service.AddNumbersImpl" url-pattern="/ws/addnumbers"/> </endpoints>

Ojo! El url-mapping del servlet de webservice de metro y de la definición del webservice deben ser compatibles:

Una vez empaquetado el código convenientemente podemos instalar la aplicación en Tomcat, y acceder a http://localhost:8080/<war-name>/ws/addnumbers:

podemos ver el wsdl generado al pulsar sobre el link que nos propone la página.

Generar el cliente

Bien, ya he creado mi web service, ya lo he publicado... y ahora cómo lo uso? O cómo me conecto a un webservice externo?. Veamos cómo crear entonces un cliente apra webservice, y lamaera es muy sencilla, y es 99% igual que la forma en que generábamos un servicio web a partir de un wsdl.

Ejecutando el comando (la URI del wsdl tomaremos la del webservice del ejemplo comentado al inicio):

wsimport.sh -s src/main/java -p com.autentia.service -Xnocompile http://ws.ip2location.com/ip2locationwebservice.asmx?wsdl

con el que ya vimos anteriormente qué clases se generaban automáticamente.

La diferencia entre crear un webservice a aprtir de un WSDL y un cliente es la clase que tenemos que crear. Ahora codificaremos una clase como sigue, que será la que se conecte y haga la llamda al webservice:

public class IP2LocationStub implements Ip2LocationWebServiceSoap { public IP2LOCATION ip2Location(String ip, String license) { // Create Service Ip2LocationWebService service = new Ip2LocationWebService(); // create proxy Ip2LocationWebServiceSoap proxy = service.getIp2LocationWebServiceSoap(); // invoke return proxy.ip2Location(ip, license); } }

Donde, como al crear el webservice, no es obligatorio que la clase implemente la interfaz Ip2LocationWebServiceSoap, pero si es muy recomendable.

Si llamáis al webservice del ejemplo necesitáis una clave de uso, con lo que la llamada volverá con los datos vacíos y con un mensaje de error, pero eso implica que el ejemplo funciona!!!

Conclusión

Ya habéis visto lo sencillo que es crear un servicio web y un cliente de webservice con Metro (y hemos probado además que WSIT funciona!).

En mi humilde opinión el desarrollo a base de anotaciones agiliza y simplifica mucho la tarea de generar web services, además nos permite reutilizar clases que ya teníamos.

En cuanto al rendimiento, existe en http://weblogs.java.net/blog/kohsuke/archive/2007/02/jaxws_ri_21_ben.html una comparativa de Metro vs Axis2, donde se muestra que para el envío de ciertos tipos de datos, Metro puede llegar a ser el doble de rápido que axis2 (por tanto más eficiente), aunque claro, la comparativa está realizada por uno de los propios desarrolladores de Metro... A final vuestra experiencia será la que diga la última palabra.

No os perdáis los próximos tutoriales sobre metro donde veremos cómo automatizar las tareas que realizábamos 'a mano' mediante maven2, y otro que nos enseñará a usar RESTFull con Metro.

Validación de documentos XML

2008-10-23T18:35:00.000-07:00

Veamos cómo se valida un documento XML.

import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.DefaultHandler;

public class Validate {

public Validate(String filename) {
StringBuffer buff = new StringBuffer();

try {
File f = new File(".", filename);
StringBuffer errorBuff = new StringBuffer();
InputSource input = new InputSource(new FileInputStream(f));

// Set systemID so parser can find the dtd with a relative URL in the source document.
input.setSystemId(f.toString());
SAXParserFactory spfact = SAXParserFactory.newInstance();

spfact.setValidating(true);
spfact.setNamespaceAware(true);

SAXParser parser = spfact.newSAXParser();
XMLReader reader = parser.getXMLReader();

//Instantiate inner-class error and lexical handler.
Handler handler = new Handler(filename, errorBuff);
reader.setProperty("http://xml.org/sax/properties/lexical-handler ", handler);
parser.parse(input, handler);

if (handler.containsDTD && !handler.errorOrWarning) { // valid
buff.append("VALID " + filename +"\n");
}
else if (handler.containsDTD) { // not valid
buff.append ("NOT VALID " + filename + "\n");
buff.append(errorBuff.toString());
}
else buff.append("NO DOCTYPE DECLARATION " + filename + "\n");
}
catch (Exception e) {
buff.append("NOT WELL-FORMED " + filename + ". " + e.getMessage() + "\n");
}

System.out.print(buff.toString());
}

class Handler extends DefaultHandler implements LexicalHandler {
boolean errorOrWarning;
boolean containsDTD;
String sourceFile;
StringBuffer errorBuff;

Handler(String sourceFile, StringBuffer errorBuff) {
super();
this.sourceFile = sourceFile;
this.errorBuff = errorBuff;
errorOrWarning = false;
containsDTD = false;
}

public void error(SAXParseException exc) {
errorBuff.append(sourceFile + " Error: " + exc.getMessage()+ "\n");
errorOrWarning = true;
}

public void warning(SAXParseException exc) {
errorBuff.append(sourceFile + " Warning:" + exc.getMessage()+ "\n");
errorOrWarning = true;
}

public void startDTD (String name, String publicId, String systemId) throws SAXException {
containsDTD = true;
}

public void endDTD () throws SAXException {}
public void startEntity (String name) throws SAXException {}
public void endEntity (String name) throws SAXException {}
public void startCDATA () throws SAXException {}
public void endCDATA () throws SAXException {}
public void comment (char ch[], int start, int length) throws SAXException {}
}

public static void main(String[] args) {
Validate v = new Validate("birds.xml");
}
}

Glosario de Java

2008-10-11T17:33:00.000-07:00

abstract: Abstracto.Aplicable a clases o métodos.

array: Variable que posee varias posiciones para almacenar un valor en cada posición. Las posiciones son accedidas mediante un índice numérico.

break: Palabra clave que finaliza la ejecución de un bucle o de una instrucción switch.

bucles: Tipo de estructura iterativa, que permite repetir un conjunto de instrucciones un número variable de veces.

clase: Estructura que define como son los objetos, indicando sus atributos y sus acciones.

clase base: Clase de la cuál se hereda para construir otra clase, denominada derivada.

CLASSPATH: Variable de entorno que permite a la máquina virtual java saber donde localizar sus clases.

constructor: Función especial empleada para inicializar a los objetos, cada clase posee sus propios constructores.

derivada: Clase que hereda de una clase base.

Excepcion: Objeto empleado para representar una situación de excepción (error) dentro de una aplicación java.
herencia: Característica que permite que una clase posea las características de otra, sin tener que reescribir el código.

herencia sencilla y múltiple: Dos tipos de herencia, con una sóla clase base, o con varias.

instancia: Un objeto creado a partir de una clase.

instanciación: Proceso de creación de un objeto a partir de una clase.

interfaz: Define un tipo de datos, pero sólo indica el prototipo de sus métodos, nunca la implementación.

JDK: Java Development Kit, es el conjunto de herramientas proporcionadas por sun, que permite compilar y ejecutar código java.

jerarquía de herencia: Árbol construido mediante las relaciones de herencia en las clases java.

máquina virtual: Es la encargada de ejecutar el código java.

multiplataforma: Posibilidad de existir en varias plataformas (sistemas operativos)

package: Paquete. Carpeta creada para contener clases java, y así poder organizarlas.

PATH: Variable de entorno, empleada por los sistemas operativos para saber donde localizar sus programas ejecutables.

Sobrescritura: Poseer el mismo método, pero con código distinto, en una clase base y en una clase que deriva de ella.

transformación de datos: Cómo cambiar el tipo de una información, por ejemplo cambiar el literal "23" al valor numérico 23.

try/catch/finally: Instrucciones empleadas para gestionar los posibles errores que se puedan provocar en un programa java.

Prácticas con excepciones

2008-10-11T17:32:00.000-07:00

Crear el fichero Try1.java

Agregar el siguiente código:

public class Try1

{

public static void main(String arg[])

{

int [] array = new int[20];

array[-3] = 24;

}

}

Como podremos comprobar al ejecutar se generará el siguiente error:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException

at Try1.main(Try1.java:6)

Que indica que se ha generado una excepción del tipo java.lang.ArrayIndexOutOfBoundsException en la función Try1.main, dentro del fichero Try1.java y en la línea 6 del código. Esta excepción en particular, se lanza cuando intentamos acceder a una posición de un array y no existe dicha posición.

Vamos a gestionar esta interrupción mediante un bloque try/catch, el fichero crear es Try2.java, con el siguiente código:

public class Try2

{

public static void main(String arg[])

{

int [] array = new int[20];

try

{

array[-3] = 24;

}

catch(ArrayIndexOutOfBoundsException excepcion)

{

System.out.println(" Error de índice en un array");

}

}

}

Intentemos provocar también un error de tipo división por cero y pongamos un catch específico para dicho error (fichero Try3.java):

public class Try3

{

public static void main(String arg[])

{

int [] array = new int[20];

try

{

// array[-3] = 24;

int b = 0;

int a = 23/b;

}

catch(ArrayIndexOutOfBoundsException excepcion)

{

System.out.println(" Error de índice en un array");

}

catch(ArithmeticException excepcion)

{

System.out.println(" Error de índice en un array");

}

}

}

Podemos comprobar que se ejecuta el catch correspondiente al tipo de error generado. La línea que lanza el error de índice la hemos comentado para que no lo genere y podamos generar el error de división por cero.

Los tipos de error que se generan, son todos ellos clases, que heredan de la clase java.lang.Exception, que a su vez hereda de java.lang.Throwable, por lo tanto podríamos crear nuestros propios errores personalizados. Al igual que podríamos tener un solo catch que capture todos los errores, independientemente del tipo del error.

Excepciones

2008-10-11T17:31:00.001-07:00

Excepcion es, o sencillamente problemas. En la programación siempre se producen errores, más o menos graves, pero que hay que gestionar y tratar correctamente. Por ello en java disponemos de un mecanismo consistente en el uso de bloques try/catch/finally . La técnica básica consiste en colocar las instrucciones que podrían provocar problemas dentro de un bloque try, y colocar a continuación uno o más bloques catch, de tal forma que si se provoca un error de un determinado tipo, lo que haremos será saltar al bloque catch capaz de gestionar ese tipo de error específico. El bloque catch contendrá el codigo necesario para gestionar ese tipo específico de error. Suponiendo que no se hubiesen provocado errores en el bloque try, nunca se ejecutarían los bloques catch.

Veamos ahora la estructura del bloque try/catch/finally:

try

{

//Código que puede provocar errores

}

catch(Tipo1 var1)

{

//Gestión del error var1, de tipo Tipo1

}

[ ...

catch(TipoN varN)

{

//Gestión del error varN, de tipo TipoN

} ]

[

finally

{

//Código de finally

}

]

Como podemos ver es obligatorio que exista la zona try, o zona de pruebas, donde pondremos las instrucciones problemáticas. Después vienen una o más zonas catch, cada una especializada en un tipo de error o excepción. Por último está la zona finally, encargada de tener un código que se ejecutará siempre, independientemente de si se produjeron o no errores.

Se puede apreciar que cada catch se parece a una función en la cuál sólo recibimos un objeto de un determinado tipo, precisamente el tipo del error. Es decir sólo se llamará al catch cuyo argumento sea coincidente en tipo con el tipo del error generado.

Práctica con interfaces

2008-10-11T17:30:00.000-07:00

Vamos a definir el interfaz Cantante, un interfaz muy simple que sólo posee un método: cantar.

Crear el fichero Cantante.java

Agregar el siguiente código:

public interface Cantante

{

public void cantar();

}

Cojamos la clase Persona y hagamos que implemente el interfaz Cantante:

public class Persona implements Cantante

Además agreguemos el código para el método que define el interfaz cantante:

public void cantar()

{

System.out.println("La laa la raa laaa!");

}

Construyamos ahora una clase con función main (ArranqueInterfaz.java)para ejecutar:

public class ArranqueInterfaz

{

public static void main(String arg[])

{

Persona p = new Persona();

hacerCantar(p);

}

public static void hacerCantar(Cantante c)

{

c.cantar();

}

}

Interfaces III

2008-10-11T17:29:00.002-07:00

Podemos ver que construimos un objeto (p) de tipo persona y se lo pasamos a la función hacerCantar. Esta función espera recibir un objeto Cantante, y una persona lo es, por tanto la recibe y llama al método cantar del objeto recibido.

Probemos a intentar pasar a la función hacerCantar en lugar del objeto Persona (p) un objeto String (texto), resultado: error de compilación.

Contruyamos ahora la clase Canario (Canario.java), pensando que también sabe cantar:

public class Canario implements Cantante

{

private int peso;

/* Aqui vendrían el resto de atributos y funciones propias de un canario */

public void cantar()

{

System.out.println("Pio Pio Pio");

}

}

Y ahora agreguemos en la clase ArranqueInterfaz el siguiente código, para crear un objeto canario y pasarselo a la función hacerCantar:

Canario c = new Canario();

hacerCantar(c);

Tras ejecutar comprobaremos que podemos pasar tanto una Persona como un Canario a la función hacerCantar, de tal manera que dentro de dicha función sólo accedamos a las funciones del interfaz y no habrá problemas. Por ejemplo, si pusiéramos:

c.SetNombre("Luis")

dentro de la función hacerPersona, podría funcionar si pasásemos un objeto Persona, pero no si pasamos uno de tipo Canario.

Interfaces II

2008-10-11T17:29:00.001-07:00

Donde modif.visibilidad puede ser public o bien sin especificar, es decir visibilidad pública (desde cualquier clase se puede emplear el interfaz) o de paquete (sólo se puede emplear desde clases del mismo paquete).

nombreInterfaz por convenio, sigue las mismas reglas de nomenclatura que las clases, y en muchos casos acaba en able (que podíamos traducir como: 'ser capaz de').

La claúsula opcional extends, se emplea para conseguir que un interfaz herede las funciones de otro/s interfaces, simplemente listaInterfaces es una lista separada por coma de interfaces de los que se desea heredar.

En muchas ocasiones un interfaz es empleado para definir un comportamiento, que posteriormente será implementado por diversas clases, que podrán no tener nada que ver entre ellas, pero que todas se comportarán igual de cara al interfaz. Es decir, todas tendrán las funciones indicadas por el interfaz.

Cuando varios objetos de distintas clases pueden responder al mismo mensaje (función), aún realizando cosas distintas se denomina polimorfismo.

Interfaces I

2008-10-11T17:28:00.001-07:00

Un interfaz es una lista de acciones que puede llevar a cabo un determinado objeto. Sorpresa, ¿eso no eran los métodos que se definen en una clase? Casi, en una clase además de aparecer los métodos aparecía el código para dichos métodos, en cambio en un interfaz sólo existe el prototipo de una función, no su código.

Veámoslo con un ejemplo: Pensemos en un interfaz en el que en su lista de métodos aparecen los métodos despegar, aterrizar, servirComida y volar. Todos pensamos en un avión, ¿verdad? El motivo es sencillamente que avión es el concepto que engloba las acciones que hemos detallado antes, a pesar que existan muchos objetos avión diferentes entre sí, por ejemplo Boeing 747, Boeing 737, MacDonell-Douglas.

Lo realmente interesante es que todos ellos, a pesar de pertenecer a clases distintas, poseen el interfaz avión, es decir poseen los métodos detallados en la lista del interfaz avión.

Esto significa también que a cualquier avión le podemos pedir que vuele, sin importarnos a que clase real pertenezca el avión, evidentemente cada clase especificará como volará el avión (porque proporciona el código de la función volar).

En java un interfaz define la lista de métodos, pero para que una clase posea un interfaz hay que indicar explícitamente que lo implementa mediante la claúsula implements. Pero veamos primero la estructura de un interfaz:

[modif.visibilidad] interface nombreInterfaz [extends listaInterfaces]

{

prototipo método1;

.....

prototipo método1;

}

Introducción a la transformación entre tipos de datos (II)

2008-10-11T17:27:00.002-07:00

En ocasiones nos interesará transformar un tipo, por ejemplo entero, a otro tipo entero de menos precisión, es decir, transformar de long a int, para ello habrá que emplear el operador de moldeo:

(tipo)

para forzar la conversión de un tipo a otro:

long b =-234;

int a = (int)b;

Funcionará mientras que el valor almacenado en el long esté dentro del rango permitido al tipo int, si no, se truncará el valor. Lo mismo se puede indicar para los tipos float y double.

También se puede emplear el operador de moldeo para objetos. Veamos un ejemplo:

Coche c = new Coche();

Vector v = new Vector();

v.add(c);

Object o = v.get(0);

Coche recuperado = (Coche) o;

En este ejemplo creamos un objeto de la clase Coche, y un objeto de la clase Vector. Un Vector en java se emplea como un array dinámico.

En este caso agregamos al vector el coche mediante la función add. Para recuperar el objeto que está en la posición 0 usamos la función get, esta función devuelve un Object, cuando pensamos que debería devolver un objeto Coche. En realidad lo que devuelve es una referencia de la clase base Object, que apunta al objeto de la posición 0, es decir nuestro objeto coche. Pero necesitamos que nuestro objeto sea apuntado por una referencia de tipo Coche para poder llamar a las funciones de la clase Coche. Por ello hacemos una conversión de referencias en la última línea.

Introducción a la transformación entre tipos de datos (I)

2008-10-11T17:27:00.001-07:00

En java será necesario transformar entre tipos de datos básicos, generalmente entre String hacia cualquier otro tipo tipo básico, o viceversa. Si es necesario transformar un tipo básico hacia String, la forma más rápida consiste en concatenar el valor a un objeto String, por ejemplo:

"" + 34

Con ello conseguiremos que se cree el literal "34".

Si en cambio queremos transformar el literal "2345" a un valor int para poder operar con el será necesario emplear:

int valor = Integer.parseInt("2345");

Integer es una clase empleada para representar al tipo básico int, y para transformar de String a int, pero puede lanzar excepciones, es por ello que siempre hay que usarla con try/catch:

int valor;

try{

valor = Integer.parseInt( "2345");

}catch(Exception e){ e.printStackTrace();}

System.out.println(valor*10);

*Clase*	*Descripción*
Alert	Pantalla que muestra un mensaje al usuario y espera un cierto periodo de tiempo antes de pasar a la siguiente pantalla.
AlertType	Indica la naturaleza de las alertas (exclamación, error, etc.).
Canvas	Es la base para la escritura de aplicaciones que utilicen eventos de bajo nivel y para dibujar objetos gráficos en la pantalla.
ChoiceGroup	Un grupo de elementos seleccionables, colocados dentro de una forma (Form).
Command	Una estructura que encapsula la información semántica de una acción (p. ej. "Salir").
DateField	Componente modificable para presentar en pantalla la información de hora y fecha.
Display	Representa el manejador de pantalla y dispositivos de entrada (teclas) del sistema.
Displayable	Característica de un objeto que tiene la capacidad de ser mostrado en la pantalla.
Font	Representa las propiedades de la fuente (letra).
Form	Una pantalla que contiene una mezcla arbitraria de elementos (imágenes, cajas de texto, etc.)
Gauge	Una barra que puede ser utilizada como indicador de avance en un proceso.
Graphics	Provee la capacidad de presentar gráficos 2D simples.
Image	Muestra una imagen.
ImageItem	Proporciona el control de trazado (colocación) de una imagen en una forma o alerta
Item	Superclase para elementos que van a ser adheridos a una forma o alerta.
List	Muestra una lista de opciones.
Screen	La superclase de todas las clases de interfaz de usuario de alto nivel.
StringItem	Un elemento que puede contener una cadena de caracteres.
TextBox	Pantalla que permite al usuario insertar y modificar texto.
TextField	Un componente de texto modificable que puede ser colocado en una forma.
Ticker	Un texto que cruza continuamente la pantalla, puede ser agregado en todos los tipos de pantalla a excepción de canvas.

*Paquete*	*Clases*
java.lang	Boolean, Byte, Character, Class, Integer, Long, Math, Object, Runnable, Runtime, Short, String, StringBuffer, System, Thread, Throwable
java.io	ByteArrayInputStream, ByteArrayOutputStream, DataInput, DataOutput, DataInputStream, DataOutputStream, InputStream, OutputStream, InputStreamReader, OutputStreamWriter, PrintStream, Reader, Writer
java.util	Calendar, Date, Enumeration, Hashtable, Random, Stack, TimeZone, Vector

*Clave*	*Explicación*	*Valor predeterminado*
microedition.platform	La plataforma o dispositivo huésped.	null
microedition.encoding	Codificación predeterminada de caracteres.	ISO8859_1
microedition.configurations	Configuración y versión J2ME actual.	CLDC-1.0
microedition.profiles	Nombre de los perfiles soportados.	null

*Paquete*	*Clases*
javax.microedition.io	Connection, ConnectionNotFoundException, Connector, ContentConnector, Datagram, DatagramConnection, InputConnection, OutputConnection, StreamConnection, StreamConnectionNotifier

*Signo*	*Código*	*Signo*	*Código*
<	< %3c	>	>%3e
'	'	"	"
&	&%26	$	$$%24
[	%5b	]	%5d
/	%2f	\	%55c
?	%3f	;	%3b
:	%3a	^	%5e
@	%40	\|	%7c
=	%3d	+	%2b
}	%7d	{	%7b
,	%2c	espacio	%20
#	%23	`	%27

fila 1, columna 1	fila 1, columna 2	fila 1, columna 3
fila 2, columna 1	fila 2, columna 2	fila 2, columna 3