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

Facultad: Ingeniería Escuela: Computación Asignatura: Java.

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).

--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

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.

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.

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.

Estado Pausado

Estado Activo

Estado Destruido

starApp()

pauseApp()

destroyApp()

destroyApp()

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: 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.

import javax.microedition.Midlet.Midlet; public class Nombre extends Midlet { public void starApp() { } public void pauseApp()

{ } public void destroyApp(boolean unconditional) { }

}

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.

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.

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.

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

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

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(); } }

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.

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.

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.

Este es el diagrama de herencia de la clase Displayable. Podemos ver que en su primer nivel, se distingue en dos: Screen y Canvas.

Display Displayable

Screen Canvas

List Alert TextBox Form

Item

ChoiceGroup

DateField Gauge Imageitem Stringitem TextField

Muestra Objetos

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.

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:

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.

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.

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() { }

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:

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

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); } } }

List (titulo, tipo_lista) List (titulo, tipo_lista, arreglo_elemento, arreglo_imagenes)

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.

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);

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) { }

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(); } } } }

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); }

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"); } } } }

IV. REFERENCIA BIBLIOGRAFICA.

• Titulo: Programación para Celulares con JAVA.

Autor: Maximiliano R. Firtman.

Colección: Manuales USERS.

Editorial: MP Ediciones.