En la parte izquierda aparecerá el Asistente para crear el esqueleto del Midlet. Dar clic en Create Skeleton y se creará automáticamente el esqueleto del Midlet. Cuarta Parte: Modificar el código generado: Se modificará el código generado para agregar funcionalidad. Por ejemplo: - Agregar variables - Crear objetos - Implementar métodos - Agregar código - Pruebas QUINTA PARTE: Ejecutar la aplicación: Para ejec

1. Facultad: Ingeniería
Escuela: Computación
Asignatura: Java.
GUIA 9
Comunicación de Dispositivos Móviles NetBeans IDE 6.1
I. OBJETIVOS.
• Dar a conocer al estudiante la evolución de la Telefonía Celular.
• Proporcionar al estudiante los conceptos teóricos sobre la programación de
Dispositivos Móviles utilizando NetBeans IDE 6.1
• Conocer los conceptos básicos del MIDlet.
• Proporcionar ejemplos Sencillos.l
II. INTRODUCCIÓN.
Las tecnologías inalámbricas han tenido mucho auge y desarrollo en estos últimos años.
Una de las que ha tenido un gran desarrollo ha sido la telefonía celular.
Desde sus inicios a finales de los 70 ha revolucionado enormemente las actividades que
realizamos diariamente. Los teléfonos celulares se han convertido en una herramienta
primordial para la gente común y de negocios; las hace sentir más seguras y las hace
más productivas.
A pesar de que la telefonía celular fue concebida estrictamente para la voz, la tecnología
celular de hoy es capaz de brindar otro tipo de servicios, como datos, audio y video con
algunas limitaciones. Sin embargo, la telefonía inalámbrica del mañana hará posible
aplicaciones que requieran un mayor consumo de ancho de banda.
BREVE HISTORIA DE LA TELEFONIA CELULAR
Martin Cooper fue el pionero en esta tecnología, a él se le considera como "el padre de la
telefonía celular" al introducir el primer radioteléfono, en 1973, en Estados Unidos,
mientras trabajaba para Motorola; pero no fue hasta 1979 cuando aparecieron los
primeros sistemas comerciales en Tokio, Japón por la compañía NTT (Nippon Telegraph
and Telephone).
En 1981, los países nórdicos introdujeron un sistema celular similar a AMPS (Advanced
Mobile Phone System). Por otro lado, en Estados Unidos, gracias a que la entidad

2. reguladora de ese país adoptó reglas para la creación de un servicio comercial de
telefonía celular, en 1983 se puso en operación el primer sistema comercial en la ciudad
de Chicago.
Con ese punto de partida, en varios países se diseminó la telefonía celular como una
alternativa a la telefonía convencional inalámbrica. La tecnología tuvo gran aceptación,
por lo que a los pocos años de implantarse se empezó a saturar el servicio. En ese
sentido, hubo la necesidad de desarrollar e implantar otras formas de acceso múltiple al
canal y transformar los sistemas analógicos a digitales, con el objeto de proporcionar
cabida a más usuarios. Para separar una etapa de la otra, la telefonía celular se ha
caracterizado por contar con diferentes generaciones. A continuación, se describe cada
una de ellas.
LAS GENERACIONES DE LA TELEFONIA INALAMBRICA
--Primera generación (1G)
La 1G de la telefonía móvil hizo su aparición en 1979 y se caracterizó por ser analógica y
estrictamente para voz. La calidad de los enlaces era muy baja, tenían baja velocidad
(2400 baudios). En cuanto a la transferencia entre celdas, era muy imprecisa ya que
contaban con una baja capacidad (Basadas en FDMA, Frequency Division Multiple
Access) y, además, la seguridad no existía. La tecnología predominante de esta
generación es AMPS (Advanced Mobile Phone System).
--Segunda generación (2G)
La 2G arribó hasta 1990 y a diferencia de la primera se caracterizó por ser digital.
EL sistema 2G utiliza protocolos de codificación más sofisticados y se emplea en los
sistemas de telefonía celular actuales. Las tecnologías predominantes son: GSM (Global
System por Mobile Communications); IS-136 (conocido también como TIA/EIA136 o
ANSI-136) y CDMA (Code Division Multiple Access) y PDC (Personal Digital
Communications), éste último utilizado en Japón.
Los protocolos empleados en los sistemas 2G soportan velocidades de información más
altas por voz, pero limitados en comunicación de datos. Se pueden ofrecer servicios
auxiliares, como datos, fax y SMS (Short Message Service). La mayoría de los protocolos
de 2G ofrecen diferentes niveles de encripción. En Estados Unidos y otros países se le
conoce a 2G como PCS (Personal Communication Services).

3. --Generación 2.5 G
Muchos de los proveedores de servicios de telecomunicaciones se moverán a las redes
2.5G antes de entrar masivamente a la 3. La tecnología 2.5G es más rápida, y más
económica para actualizar a 3G.
La generación 2.5G ofrece características extendidas, ya que cuenta con más
capacidades adicionales que los sistemas 2G, como: GPRS (General Packet Radio
System), HSCSD (High Speed Circuit Switched), EDGE (Enhanced Data Rates for Global
Evolution), IS-136B e IS-95Bm entre otros. Los carriers europeos y estadounidenses se
moverán a 2.5G en el 2001. Mientras que Japón irá directo de 2G a 3G también en el
2001.
--Tercera generación 3G.
La 3G se caracteriza por contener a la convergencia de voz y datos con acceso
inalámbrico a Internet; en otras palabras, es apta para aplicaciones multimedia y altas
transmisiones de datos.
Los protocolos empleados en los sistemas 3G soportan altas velocidades de información
y están enfocados para aplicaciones más allá de la voz como audio (mp3), video en
movimiento, videoconferencia y acceso rápido a Internet, sólo por nombrar algunos. Se
espera que las redes 3G empiecen a operar en el 2001 en Japón, por NTT; en Europa y
parte de Asia en el 2002, posteriormente en Estados Unidos y otros países.
Asimismo, en un futuro próximo los sistemas 3G alcanzarán velocidades de hasta 384
Kbps, permitiendo una movilidad total a usuarios, viajando a 120 kilómetros por hora en
ambientes exteriores. También alcanzará una velocidad máxima de 2 Mbps, permitiendo
una movilidad limitada a usuarios, caminando a menos de 10 kilómetros por hora en
ambientes estacionarios de corto alcance o en interiores.
PROGRAMACIÓN PARA CELULARES CON JAVA.
Hasta hace unos años, el lenguaje de programación que utilizamos para desarrollar una
aplicación dependía directamente de equipo y sistemas operativos donde sería ejecutado y
era así que utilizábamos una lenguaje y un compilador distinto si nuestra aplicación se
ejecutaba sobre Windows, Macintosh o Linux. Si bien el lenguaje C se podía considerar
uno de los lenguajes más compatibles entre plataformas distintas, siempre era necesario
realizar algunos cambios y compilar nuevamente nuestro código fuente para ser ejecutado
en cada plataforma.
En la década de los 90, la empresa Sun Microsystems, desarrolló un nuevo lenguaje con
una características que lo hacía único: era multiplataforma. Así nació Java: un lenguaje de
programación que permite ejecutar las aplicaciones que desarrollemos en varias

4. plataformas, sistemas operativos y equipos sin necesidad de recopilar o realizar cambios en
el código fuente.
Características
JAVA es un lenguaje totalmente orientado a objetos. Estos significa que toda la
funcionalidad que queramos desarrollar deberá estar enmarcada en clases y objetos.
En la POO (Programación Orientada a Objetos), no trabajamos con funciones,
procedimientos y variables por como las entendemos en programación imperativa. Aquí se
define clases de objetos. Una clase es un conjunto de atributos, variables u otros objetos,
sumando a métodos que se pueden ejecutar sobre él.
Cuando programamos, creamos objetos que son de algunos clase ya declarada de antemano,
por ello podremos acceder a todos sus métodos para comunicarnos con cada objeto.
Máquina Virtual
Las aplicaciones JAVA poseen una particularidad respecto a otros lenguajes: nuestra
aplicación no interactuará directamente con la computadora donde se ejecute ni con el
sistema operativo; interactuará con un sistema llamado Máquina Virtual o JVM (Máquina
Virtual de Java). Dado que JAVA es multiplataforma, es necesario que exista una
aplicación que tenga la tarea de traducir nuestro código a cada plataforma compatible con
Java; esa es la tarea de la JVM.
Cuando compilamos nuestro programa en Java, no obtendremos un programa ejecutable
como con otros lenguajes, sino que obtendremos un código precompilado que podrá ser
ejecutado en cualquier Máquina Virtual Java. De esta forma, es necesario que esta JVM
está instalado en el sistema operativo donde queremos ejecutar nuestra aplicación.
Versiones
Sun ha dividido a Java en tres líneas bien diferenciadas, de acuerdo con el tipo de
aplicaciones y destino. La programación de aplicaciones estándar para equipos de
escritorios se denomina actualmente Java 2 Standard Edition (J2SE), la plataforma para
desarrollo de aplicaciones corporativas, para servidores y sistemas distribuidos se denomina
Java 2 Enterprice Edition (J2EE) y la tercera plataforma se denomina Java 2 Micro Editon
(J2ME).
J2ME.
Podremos darnos cuenta cuán complicada podría ser la vida de un programador para
equipos celulares, teniendo en cuenta la gran diversidad de equipos, marcas, sistemas
operativos, pantallas y teclados que se pueden encontrar en el mercado. Pero existe una
solución a este problema y se llama Java.

5. Sun ha desarrollado una versión de Java llamada J2ME (Java 2 Micro Edition) que, si bien
es lenguaje java 2 nativo, posee ciertas limitaciones en cuanto a las clases disponibles, tipos
de datos y funciones que se pueden utilizar. Estas limitaciones se deben solamente a que los
equipos celulares poseen poco poder de procesamiento y memoria. Más allá de esto, las
características de J2ME son las mismas que Java: Programación Orientada a Objetos,
Herencia, Encapsulamiento y muy importante: portabilidad y compatibilidad entre
plataformas.
J2ME fue pensado para trabajar sobre equipos con ciertas limitaciones: en procesamiento,
pantalla, energía basada en baterías y de alguna forma posee servicios de red para
comunicarse en el exterior.
Una aplicación desarrollada en J2ME podrá ser ejecutada en cualquier equipo celular o
Palm que tenga una Máquina Virtual Java instalada y, en esta categoría, entra la mayoría de
los dispositivos móviles que se ofrecen en el mercado actualmente. De esta forma, nuestras
aplicaciones o juegos podrán ejecutarse de igual forma en cualquier equipo sin realizar
cambios en el código ni tener que recompilar.
MIDP:
Hasta ahora hemos visto que tenemos, en primer lugar a J2ME como base de lenguajes para
trabajar; luego tendremos alguna de las configuraciones de las que vimos.
Aplicación:
MIDP introduce un nuevo concepto de aplicaciones para Java. Así como a las aplicaciones
en Java que se ejecutan en navegadores web se las denomina Applets y a las aplicaciones
en Java que se ejecutan en servidores, Servlets; a las aplicaciones para celulares en MIDP
se les denomina Midlets.
Así, una aplicación para celulares siempre tendrá un objeto de tipo Midlet que será el
encargado de proveernos la funcionalidad necesaria en un equipo móvil.
Cada midlet puede tener en un instante alguno de los siguientes estados.
- Activo: la aplicación se encuentra ejecutándose normalmente.
- Pausado: la aplicación ha sido detenida temporalmente por algún evento, como ser la
recepción de una llamada o todavía no ha pasado a estado Activo al ser creada.
- Destruido: la aplicación se ha cerrado y se ha liberado la memoria ocupada.

6. Estado destroyApp()
Pausado
starApp()
pauseApp() Estado
Destruido
Estado
Activo destroyApp()
Diagrama clásico del ciclo de vida de un Midlet.
Midlet
Como habíamos adelantado varias veces, llamaremos Midlet a una clase de nuestra
aplicación que existe el comportamiento de javax.microediton.Midlet.MIDlet.
Nuestra clase MIDlet tiene tres posibles, estados, estados obligados a implementar los
métodos starApp(), pauseApp)() y destroyApp().
En un Midlet podremos crear formularios, que representan a una serie de objetos que
permitirán mostrar información en pantalla y solicitar ingreso da datos.
Comandos:
Los comandos son equivalentes a los botones de un aplicación de Windows. Es la forma
que tenemos de permitirle al usuario seleccionar una operación a realizar, por ejemplo:
Salir, Comenzar, o cualquier operación que queramos que el usuario seleccione. Los
comandos se implementan de forma distinta según el celular, pero en la mayoría de ellos
los podemos encontrar en la sección inferior de la pantalla relacionados con alguno de los
botones de comandos que se encuentran justo debajo de la pantalla.
Para crear un comando, utilizaremos objetos de tipo Command que podemos adicionar a un
formulario que esté vigente en el momento de ejecución. A cada formulario que tengamos
vigente debemos indicarle quién será su CommandListener.
CommandListener es una clase que se encargará de recibir la ejecución cuando se
seleccione una acción. Allí heremos lo necesario según el comando seleccionado.
La clase que sea la encargada de recibir las acciones de los comandos (CommandListener),
deberá implementar el método commandAction() que veremos que parámetros recibe. Esta
clase receptora puede ser la misma que genera los comandos.

7. Display
En todo Midlet podremos tener una variable que identifique a la pantalla de la aplicación.
Allí podremos definir qué objeto es el que mostraremos en cada momento. Para ello,
debemos definir un objeto de clase Display al cual le apuntaremos la pantalla actual y sobre
la cual podremos mostrar textos, gráficos y otros eventos.
Esqueleto:
El esqueleto de toda clase Midlet es el siguiente:
import javax.microedition.Midlet.Midlet;
public class Nombre extends Midlet
{
public void starApp()
{
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
}
La primera línea indica al compilador qué clases utilizaremos de los paquetes disponibles,
luego definimos el nombre de nuestra clase definiéndola como public class y expresando
que nuestra clase extenderá a Midlet.
III. PROCEDIMIENTO.
PRIMERA PARTE:
Cargar NetBeans 6.0 o superior. En este caso estamos utilizando la última versión de
NetBeans IDE 6.1. Como se muestra en la siguiente figura 1.

8. Figura1. Interface de NetBeans IDE 6.1
SEGUNDA PARTE:
Creación del Proyecto:
Dar clic al icono de New Project o Seleccionar File de la opción de menú y dar clic a New
Project.
Seguidamente aparecerá un Wizard donde el primer paso es:
(Choose Project).
Seleccionar en categoría “Categories” la opción de Mobility. En Proyecto ”Projects”
seleccionaremos MIDP Aplication. Como se visualiza en la siguiente figura y por último
dar clic a Next.

9. Nombre del Proyecto y la Ubicación (Name and Location).
Aquí se colocara el nombre del Proyecto y la Ubicación.
El nombre del Proyecto: se le pondrá Guia7Java.
La ubicación del proyecto: por default o donde al estudiante desee guardarlo.
Por último deshabilitar las opciones de Set as Main Project y Create Hello Midlet.

10. Default Platform Selection.
No cambiar nada y dar Next.
More Configurations Selection
Dar clic a Finish
TERCERA PARTE:
Ya que se á creado el proyecto. Seguiremos con la inserción de una clase Midlet.
Dar clic derecho a la carpeta Source Packages seleccionar la Opción de New y por último
seleccionar Midlet.
Aparecerá una ventana como se muestra en la siguiente figura.
Donde le pondrán nombre a su primer Midlet en este caso se le colocará HolaMundo y al
Package guia9java.

11. Por último dar clic a Finish.
Seguidamente su interface quedara de la siguiente manera como se muestra en la siguiente
figura.

12. Digitar en siguiente Código, como se muestra a continuación.

13. package guiajava7;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/**
* @author: Santiago José Campos Robles
* Ciclo: I-2009
* Materia: Java
*/
public class HolaMundo extends MIDlet implements CommandListener {
private Form formulario;
public void startApp() {
formulario = new Form("Ejemplo 1");
formulario.append("Hola Mundo!");
formulario.addCommand(new Command("Salir",Command.EXIT,1));
formulario.setCommandListener(this);
Display pantalla = Display.getDisplay(this);
pantalla.setCurrent(formulario);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
formulario= null;
}
public void commandAction(Command arg0, Displayable arg1)
{
destroyApp(true);
notifyDestroyed();
}
}

14. EXPLICACIÓN DEL CÓDIGO:
Las primeras dos líneas de nuestro código le indicarán al compilador qué clase
importaremos, ya sea de Java o de J2ME. En este caso estaremos importador todas las
clases que dependan de javax.microedition.midlet (necesarias para todas las clases sean
en Midlet principal) y de javax.microedition.lcdui (necesarias para el manejo de la
interfaz del usuario).
La clase la definimos luego con public class HolaMundo. Todas las clases de nuestra
aplicación para celulares deberán comenzar de forma similar. Recordemos que el nombre
de la clase,”HolaMundo” debe ser exactamente el nombre de nuestro archivo, en este caso
HolaMundo.java
El atributo extends MIDlet indicará que la clase que estamos definiendo tendrá herencia de
la clase MIDlet, que es la encargada, como vinimos comentando, de administrar la
aplicación y de esta forma, nos obligará, por ejemplo a definir el método startApp() que se
ejecutará cuando la aplicación comience. Este atributo no será necesario para clases
accesorias que utilicemos en nuestra aplicación.
El atributo implements CommandListener le indicará al compilador que nuestra clase
implementará la interfaz llamada CommandListener. Esta interfaz definida por J2ME nos
permitirá definir métodos para recibir a través de un método, los comandos seleccionados
por el usuario. De esta forma, cuando creamos un comando y está disponible para que el
usuario lo seleccione, la Java Virtual Machine buscará una clase CommandListener a
quién avisarle que se ha presionado el comando.
Nuestro método principal
Como veníamos comentando el método principal que se ejecutará en nuestra aplicación es
starApp(), debido a que es el método de apertura, nuestro método no retornará ningún
valor a quién lo llame y por eso se le define como void, que implica que nuestra función no
retornará valor alguno.
Definiremos una función de clase Form de nombre formulario. Si bien lo veremos más
adelante, basta con mencionar por ahora que esta clase nos permitirá ubicar otros objetos
(como texto, campos de ingreso de información e imagenes) en la pantalla del teléfono. Al
formulario lo definimos de tipo prívate, lo que significa que no será posible acceder a sus
métodos desde fuera de la clase actual. Ya dentro de la función starApp() vemos que la
primera línea nos permite crear un nuevo Form y asignárselo a nuestra variable. Es muy
importante tener siempre en cuenta que definir una variable de alguna clase no alcanza para
poder utilizarla, necesitaremos crear con new un nuevo objeto de ese tipo y éste asignárselo
a la variable.

15. Luego de crearlo, llamaremos a tres métodos del formulario. El primero, Append, nos
permitirá agregar un texto al mismo, AddCommand nos permitirá incorporar un botón de
comando al formulario y SetCommandListener indicara qué clase será la encargada de
recibir la respuesta de los comandos ( en este caso al indicarle this estaremos informando
que nuestra misma clase HolaMundo será la encargada).
Ya tendríamos nuestro formulario completo, con el texto “Hola Mundo” y un botón para
“Salir”. Sin embargo, el formulario sólo está creado como objeto en memoria, pero éste no
se visualizará en pantalla hasta no le digamos a la pantalla que deberá mostrarlo. Para ello,
debemos definirnos una variable de clase Display, a la que le asignamos
Display.getDisplay(this) que no es más que un objeto puntero a la pantalla del equipo. De
esta forma, en la variable llamada pantalla tendremos acceso a los métodos para administrar
la pantalla. En este caso accedemos al método setCurrent que nos permite definirle qué
objeto será el que queremos representar en la pantalla en ese momento; en nuestro ejemplo:
el formulario creado.
Método de Pausa y Destrucción:
Tendremos que definir nuestro método pauseAdd(), que se ejecutará cuando la aplicación
entre en modo pausa: cuando deja de ejecutarse temporalmente la aplicación por algún
motivo y también se ejecutaran de inmediato cuando se ingresa a la aplicación, antes de
ingresar el método starApp().
El método de destrucción destroyApp() nos da un parámetro lógico que nos indicará si el
cierre de la aplicación es terminante o se puede cancelar (de acuerdo cómo se ha invocado a
este método), por lo que aquí deberemos incluir todo código que queramos ejecutar al
cerrar la aplicación. En este caso, para ayudar a la Máquina Virtual Java en su limpieza de
objetos, definiremos a nuestro formulario como nulo, para que pierda la referencia y pueda
ser eliminado.
Recibir el comando
En nuestro ejemplo, teníamos definido un solo botón comando “Salir” y también teníamos
asignado que la clase CommandListener, quien recibió el resultado de los comandos, era
nuestra propia clase HolaMundo, por lo que no obligaría a definir el método
commandACtion que recibirá por parámetro el comando presionado y el objeto que
contenía al comando (ya lo veremos mejor más adelante.)
Dado que poseemos un solo comando, lo que hacemos es invocar a destroy App para
finalizar la aplicación y el método notifyDestroyed() le avisa al teléfono celular que
queremos finalizar la aplicación. Si hubiéramos tenido más de un botón comando (por
ejemplo, “Entrar” y “Salir”), podríamos haber preguntado que comando era el recibido y
según este parámetro realizar acciones distintas.

16. Interfaz de alto nivel.
En J2ME todas las clases y funciones relacionadas con la interfaz con el usuario
encuentran en el paquete javax.macroedition.lcdui el cual deberemos importar en cada clase
donde queramos hacer uso de ellos. También, como vimos anteriormente, la pantalla del
equipo se podía representar como un objeto instanciado de la clase Display. De esta forma,
para cambiar la información que se está mostrando en pantalla en todo momento,
deberemos invocar al método setCurrent() de nuestro objeto Display indicándole por
parámetro algún objeto Displayable, como el Form que habíamos visto.
La clase Displayable se especializa en dos subclases, llamadas Screen y Canvas. Estas
división también se le conoce como Alto Nivel y Bajo Nivel. La clase canvas por permitirá
trabajar sobre la pantalla directamente a nivel de pixeles, mientras que en la de Alto Nivel
trabajaremos con objetos ya creados, como ser textos, campos de ingreso de texto, listas.,
que serán dibujadas automáticamente por el equipo.
Display Displayable
Muestra Objetos
Screen Canvas
Alert Form List TextBox
Item
ChoiceGrou DateField Gauge Imageitem Stringitem TextField
p
Este es el diagrama de herencia de la clase Displayable. Podemos ver que en su primer nivel, se
distingue en dos: Screen y Canvas.

17. Comandos:
Los botones de comandos pertenecen a la clase Command y trabajan con tres propiedades
para su creación: nombre, tipo y prioridad. Veamos cada una con más detalle.
El nombre del comando será el texto que se visualizará en la pantalla del teléfono celular,
como ser: “Comenzar”, ”Jugar”, ”Salir”, u “Opciones”; el tipo lo veremos a continuación y
la prioridad es un número entero y le permite al teléfono celular ordenar todos los
comandos disponibles de acuerdo con algún criterio. El criterio de ordenamiento de los
comandos disponibles es: a menor número, mayor prioridad, o sea, mejor ubicación en el
listado de opciones.
El tipo de comando relaciona directamente a la acción que estamos definiendo con la
ubicación que ocupará la acción en el teléfono. Como hemos visto, los teléfonos celulares
generalmente poseen uno, dos o tres teclas destinadas a funciones de menú
Los tipos de comandos disponibles son:
TIPO DE COMANDO DESCRIPCIÓN
BACK Referencia una acción que llevaría al usuario a la pantalla anterior.
CANCEL Acción que cancelaria la operación que el usuario llevaba a cabo.
EXIT Botón que permite salir de la aplicación.
HELP El evento dispararía un sistema de ayuda al usuario.
ITEM Acciones que solo se ejecutarían para algún elemento de una lista.
Equivaldría a acciones contextuales a la opción seleccionada.
OK Indica un evento donde el usuario de su confirmación acerca de una
acción que venía realizando.
SCREEN Todos los eventos que no pueden ser categorizados y difícilmente algún
equipo tenga teclas especiales para esta acción, entra aquí.
STOP Solicita la acción de detener lo que se está realizando, por ejemplo, un
cálculo, o una descarga de internet.

18. Cuadro de Texto:
Un cuadro de texto o Textbox permite al usuario ingresar y editar texto. Esta función
resulta muy útil para, por ejemplo, solicitar el nombre, la dirección de email o un número
de teléfono al usuario; valor al cual podremos acceder luego de ser introducido por el
usuario para realizar alguna acción.
TextBox cuadro = new TextBox(“Ingrese su Nombre”,””, 30, TextField.ANY);
Los parámetros para un Textbox son:
METODO DESCRIPCIÓN
Titulo Titulo de la pantalla actual, debería ser la descripción del texto que queremos
solicitar al usuario.
Texto_inicial Nos permite ingresar un texto que ya estará ingresado por defecto.
El usuario podrá borrar o editar sobre el mismo.
Tamaño Especificará un valor numérico con la cantidad máxima de caracteres que
permite ingresar al usuario.
Si ingresamos 0, no permitirá ingresar ningún texto.
Restricciones Especificará, de una lista ya predeterminada las restricciones que le podremos
aplicar al texto ingresado; por ejemplo, solo números o solo caracteres propios
de una dirección de e-mail.
Las restricciones que podemos aplicar a un TextBox son:
RESTRICIONES DESCRIPCION
TextField.ANY Cualquier carácter válido
TextField.NUMERIC Sólo número de 0 al 9
TExtField.PHONENUMBER Sólo número del 0 al 9, #, * (caracteres para un número
telefónico).
TextField.EMAILADDR Carácter válidos de una dirección de e-mail
(juan@miservidor.com)
TextField.URL Caracteres válidos para una dirección web (www.perez.com)
TextField.PASSWORD Reemplazara todos los caracteres ingresados por un asteriscos
para ser utilizados en el ingreso de contraseñas privadas.

19. Ejercicio 2
Insertar MIDlet con el nombre de EjTextBox.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/**
* @author: Santiago José Campos Robles
* Ciclo: I-2009
* Materia: Java
*/
public class EjTextBox extends MIDlet implements CommandListener
{
private TextBox cuadro;
private Command ok, borrar;
private Display pantalla;
public EjTextBox()
{
cuadro = new TextBox("Ingrese su E-
mail","",150,TextField.EMAILADDR);
//Definimos los comandos a utilizar
ok = new Command("Ok", Command.EXIT,1);
borrar = new Command("Borrar",Command.ITEM,2);
//Asignamos comandos al cuadro de texto
cuadro.addCommand(ok);
cuadro.addCommand(borrar);
cuadro.setCommandListener(this);
}
public void startApp()
{
pantalla = Display.getDisplay(this);
pantalla.setCurrent(cuadro);
}
public void pauseApp()
{
}

20. public void destroyApp(boolean unconditional)
{
}
public void commandAction(Command arg0, Displayable arg1)
{
if (arg0 == ok)
{
destroyApp(true);
notifyDestroyed();
}else
{
cuadro.delete(cuadro.getCaretPosition()-1, 1);
}
}
}
Listas
Las listas nos permite que el usuario seleccione alguna opción de una lista prefijada, de tres
formas posibles; en forma exclusiva, en forma múltiple y en forma implícita. El o los
valores seleccionados de una lista deberán ser leídos y administrados a través de comandos
y su correspondiente método CommandListener.
Sintaxis:
List (titulo, tipo_lista)
List (titulo, tipo_lista, arreglo_elemento, arreglo_imagenes)
Listas exclusivas:
Las listas exclusivas son aquellas donde sólo podremos escoger una opción de todas las
disponibles. Al seleccionar una opción, se reemplazará esta selección por cualquier otra que
haya realizado con anterioridad. Realizando una analogía con la programación bajo
sistemas de escritorios, este tipo de objetos es conocido también como Botones de Radio
(Radio Group).
Además de la lista, deberemos crear un comando para que el usuario confirme su elección,
por ejemplo Grabar, Seleccoionar, o Continuar. Adicionamente, podremos crear otro

21. comando para cancelar la operación o volver a la pantalla anterior. Todos estos eventos son
administrados con el CommandListener. Por lo tanto el usuario deberá seleccionar el
elemento y luego pulsar el comando creado.
Para leer el valor que ha sido seleccionado por el usuario podremos utilizar el método
getSelectedIndex() que nos devolverá un valor entero con la posición del elemento
seleccionado (comenzando por cero). Si queremos saber el texto de la opción seleccionada
podremos recurrir a getString enviando como parámetro el valor devuelto por
getSelectedIndex. Asimismo, también podremos definir qué opción estará seleccionada
por defecto utilizando el método setSelectedIndex(posición, true) donde el segundo
parámetro le indica que la posición dada deberá estar seleccionada.
El tipo de lista a definir al construirla será List.EXCLUSIVE.
Listas Múltiples
Las listas múltiples permiten que el usuario pueda seleccionar una o más de las opciones
disponibles dentro de un listado. Esta lista nos permitirá, por ejemplo, que el usuario
seleccione si desea Música, Efectos de Sonido, Dificultad Avanzada, etc. De esta forma,
podrá indicarnos por cada opción si lo desea o no. En la lista exclusiva (y en la implicita)
sólo podríamos seleccionar un solo elemento de la lista. En cambio en este caso, el usuario
podrá activar o desactivar muchas opciones diferentes.
Al igual que la lista exclusiva, la múltiple necesita crear un comando para que el usuario
seleccione. En el caso de listas múltiples no nos alcanzará con el método getSelectedIndex,
ya que en esta lista es posible que haya más de una opción seleccionada. Por ello, se ofrece
el método getSelectedFlags(arreglo_logico) donde le enviamos por parámetros un arreglo
de Boolen y será completado con verdadero o falso por cada elemento que haya en la lista.
En los que encontremos un verdadero sabremos que esa opción fue seleccionada (podremos
recorrer el arreglo con un bucle for de 0 a size()-1). También tendremos un método
setSelectedFlags(arreglo_logico) donde podremos definir qué elementos dela lista estarán
previamente seleccionados completando el arreglo con valores verdaderos.
El tipo de lista múltiple es List.MULTIPLE
Listas implícitas.
Una lista implícita tiene el mismo concepto que una lista exclusiva con la diferencia que la
selección de un elemento de la lista disparará la captura del evento directamente sin
necesidad de recurrir a un comando especial posteriormente.
En la lista exclusiva si el usuario se arrepentía de la selección podía cambiar su elección
mientras no hubiera pulsado el comando Continuar o Guardar. En una lista implícita
apenas seleccione un elemento, se disparará el evento sin necesidad de pulsar otra opción.

22. En este caso, el usuario no tendrá lugar a arrepentirse. Las listas implícitas son especiales
para sistemas de menús de opciones, por ejemplo, el menú principal de nuestra aplicación o
juego, donde podremos indicar cada opción disponible del juego como elementos de una
lista implícita, por ejemplo: Comenzar Juego, Cargar Partido, Opciones, Salir. En estos
casos, resultaría engorroso para el usuario tener que presionar un comando luego de indicar
el comienzo de un juego.
Las listas implícitas no necesitan tener creados y asignados comandos de acción, pero sí
tener asignado una clase CommandListener, ya que cuando el usuario seleccione una
opción, se disparará el evento CommandAction() adecuado.
La forma de saber que opción fue seleccionada es igual que con listas exclusivas, el método
getSelectedIndex. En este caso deberemos utilizar tipo de lista List.IMPLICIT
Ejercicio 3
Insertar MIDlet con el nombre de Ejlistas.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/**
* @author: Santiago José Campos Robles
* Ciclo: I-2009
* Materia: Java
*/
public class Ejlistas extends MIDlet implements CommandListener
{
private List menu;
private List listaexclusiva;
private List listamultiple;
private Display pantalla;
private Command seleccionar, grabar;
private boolean[] opciones;
public Ejlistas()
{
menu = new List("LISTA", List.IMPLICIT);
menu.append("Lista Exclusiva", null);
menu.append("Lista Múltiple", null);
menu.append("Salir", null);
menu.setCommandListener(this);

23. listaexclusiva = new List("Seleccione",List.EXCLUSIVE);
listaexclusiva.append("Efectivo", null);
listaexclusiva.append("Transferencia",null);
listaexclusiva.append("Tarjeta de Crédito",null);
seleccionar = new Command("Seleccionar", Command.OK,1);
listaexclusiva.addCommand(seleccionar);
listaexclusiva.setCommandListener(this);
listamultiple = new List("Opciones",List.MULTIPLE);
listamultiple.append("Sonido",null);
listamultiple.append("Conexion a web", null);
listamultiple.append("Ver Detalles",null);
grabar = new Command("Grabar",Command.OK,1);
listamultiple.addCommand(grabar);
listamultiple.setCommandListener(this);
opciones = new boolean[]{false, false, false};
}
public void startApp()
{
pantalla = Display.getDisplay(this);
pantalla.setCurrent(menu);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}

24. public void commandAction(Command arg0, Displayable arg1)
{
if(arg0 == grabar)
{
listamultiple.getSelectedFlags(opciones);
pantalla.setCurrent(menu);
}else if(arg0 == seleccionar)
{
int opcion = listaexclusiva.getSelectedIndex();
menu.setTitle(listaexclusiva.getString(opcion));
pantalla.setCurrent(menu);
}else
{
switch(menu.getSelectedIndex())
{
case 0:
pantalla.setCurrent(listaexclusiva);
break;
case 1:
listamultiple.setSelectedFlags(opciones);
pantalla.setCurrent(listamultiple);
break;
case 2:
destroyApp(true);
notifyDestroyed();
}
}
}
}

25. Formulario
Ejercicio 4
Insertar MIDlet con el nombre de EjForm.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
/**
* @author: Santiago José Campos Robles
* Ciclo: I-2009
* Materia: Java
*/
public class EjForm extends MIDlet implements
CommandListener,ItemStateListener
{
private Form formulario;
private TextField nombre;
private ChoiceGroup continente;
private TextField estado;
private Command guardar;
private Display pantalla;
public EjForm()
{
formulario = new Form("Ingreso de Datos");
guardar = new Command("Guardar", Command.OK, 1);
nombre = new TextField("Nombre", null, 30, TextField.ANY);
continente = new ChoiceGroup("Continente",Choice.EXCLUSIVE, new
String[]{"Sudamérica","Norteamerica","Centroamerica"}, null);
estado = new TextField("Provincia",null, 30, TextField.ANY);
formulario.append("Ingrese sus datos: ");
formulario.append(nombre);
formulario.append(continente);
formulario.append(estado);
formulario.addCommand(guardar);
formulario.setCommandListener(this);
formulario.setItemStateListener(this);
Ticker aviso = new Ticker("Ingreso de Datos para mi Aplicación");
formulario.setTicker(aviso);
}

26. public void startApp()
{
pantalla = Display.getDisplay(this);
pantalla.setCurrent(formulario);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional) {
}
public void commandAction(Command arg0, Displayable arg1)
{
destroyApp(true);
notifyDestroyed();
}
public void itemStateChanged(Item arg0)
{
if(arg0 == continente)
{
if(continente.getSelectedIndex()==0)
{
estado.setLabel("Provincia");
}else
{
estado.setLabel("Estado");
}
}
}
}

27. IV. REFERENCIA BIBLIOGRAFICA.
• Titulo: Programación para Celulares con JAVA.
Autor: Maximiliano R. Firtman.
Colección: Manuales USERS.
Editorial: MP Ediciones.