PDF de programación - INTRODUCCIÓN A J2ME (Java 2 MicroEdition)

INTRODUCCIÓN A J2ME



(Java 2 MicroEdition)



Manuel J. Prieto
([email protected])

Noviembre 2002

Cualquier

comentario,

sugerencia

o

errata,

puede

ser

remitida

a

[email protected]. Todas ellas serán bienvenidas y sin duda ayudarán a mejorar

este documento y los posteriores. Cualquier otra cuestión o tema, puede ser

también remitida a [email protected].



J2ME – Manuel J. Prieto (Nov 2002)



1 PRESENTACIÓN DE J2ME .................................................................. 5

1.1 Nuevos Conceptos..................................................................................... 5
1.1.1 Configuración........................................................................................... 5
1.1.2 Perfiles........................................................................................................ 6

1.2 Primer MIDlet .............................................................................................. 7
1.2.1 Descripción del MIDlet ......................................................................... 7
1.2.2 Compilación.............................................................................................. 9

2 LAS APIS DE CLDC Y DE MIDP ...................................................... 11

2.1 El API de CLDC........................................................................................... 11
2.1.1 El paquete java.lang........................................................................... 12
2.1.2 El paquete java.util ............................................................................. 12
2.1.3 El paquete java.io................................................................................ 13

2.2 El GCF (Generic Connection Framework) de CLDC.............. 13

2.3 El API de MIDP .......................................................................................... 14
2.3.1
Las clases heredadas de J2SE ........................................................ 14
2.3.2 Clases e interfaces propios de MIDP ............................................ 14
2.3.3 El paquete javax.microedition.midlet .......................................... 15
2.3.4 El paquete javax.microedition.lcdui.............................................. 15
2.3.5 El paquete javax.microedition.io ................................................... 16
2.3.6 El paquete javax.microedition.rms ............................................... 16

2.4 Ejemplo de uso de APIs de MIDP y J2SE................................... 17

3 MIDLETS GRÁFICOS.......................................................................... 20

3.1 La clase Graphics ..................................................................................... 20

3.2 Primitivas gráficas .................................................................................. 20

3.3 Escribiendo texto..................................................................................... 21

3.4 Dibujando imágenes .............................................................................. 23

3.5 Ejemplo de uso de los métodos gráficos ................................... 24

4 COMPONENTES DE INTERFAZ DE USUARIO............................. 28

4.1 Screens y Forms ....................................................................................... 29

4.2 La clase Alert.............................................................................................. 31



J2ME – Manuel J. Prieto (Nov 2002)

4.3 La clase List................................................................................................. 32

4.4 La clase TextBox ...................................................................................... 33

4.5 La clase Ticker........................................................................................... 34

4.6 La clase StringItem ................................................................................ 35

4.7 La clase ImageItem ............................................................................... 36

4.8 La clase TextField .................................................................................... 38

4.9 La clase DateField.................................................................................... 39

4.10 La clase ChoiceGroup ........................................................................ 39

4.11 La clase Gauge....................................................................................... 40

5 GESTIÓN DE COMANDOS................................................................. 42

6 CONEXIÓN A REDES.......................................................................... 44

6.1 Entrada/Salida desde el MIDlet...................................................... 46

6.2 La clase InputStream ............................................................................ 47

6.3 La clase OutputStream......................................................................... 48

6.4 Ejemplo de conexión.............................................................................. 48

7 PERSISTENCIA DE DATOS (RMS)................................................. 53

7.1 El paquete RMS ......................................................................................... 53

7.2 La clase RecordStore ............................................................................. 53

7.3 Las interfaces de RMS........................................................................... 54

7.4 Abriendo un almacén de registros ................................................ 54

7.5 Añadiendo nuevos registros ............................................................. 54

7.6 Recuperando registros ......................................................................... 54

7.7 Borrando registros.................................................................................. 55

7.8 Enumeración de registros................................................................... 55

7.9 Cerrando un almacén de datos........................................................ 56



J2ME – Manuel J. Prieto (Nov 2002)

8 OPTIMIZACIÓN DE CÓDIGO........................................................... 57

8.1 Optimización para la mantenibilidad........................................... 57

8.2 Optimización del tamaño .................................................................... 57

8.3 Optimización de velocidad ................................................................. 57

8.4 Eliminación de Evaluaciones innecesarias ............................... 57

8.5 Eliminar subexpresiones comunes................................................ 58

8.6 Aprovechar las variables locales.................................................... 58

8.7 Expandir los bucles................................................................................. 58



J2ME – Manuel J. Prieto (Nov 2002)

1 PRESENTACIÓN DE J2ME
J2ME es el acrónimo de Java 2 Micro Edition. J2ME es la versión de
Java orientada a los dispositivos móviles. Debido a que los
dispositivos móviles tienen una potencia de cálculo baja e interfaces
de usuario pobres, es necesaria una versión específica de Java
destinada a estos dispositivos, ya que el resto de versiones de Java,
J2SE o J2EE, no encajan dentro de este esquema. J2ME es por tanto,
una versión “reducida” de J2SE.


1.1 Nuevos Conceptos

Configuración

1.1.1
La configuración es un mínimo grupo de APIs (Application Program
Interface), útiles para desarrollar las aplicaciones destinadas a un
amplio rango de dispositivos. La configuración estándar para los
dispositivos inalámbricos es conocida como CLDC (Connected Limited
Device Configuration). El CLDC proporciona un nivel mínimo de
funcionalidades para desarrollar aplicaciones para un determinado
conjunto de dispositivos inalámbricos. Se puede decir que CLDC es el
conjunto de clases esenciales para construir aplicaciones. Hoy por
hoy, sólo tenemos una configuración, pero es de esperar que en el
futuro aparezcan distintas configuraciones orientadas a determinados
grupos de dispositivos.
Los requisitos mínimos de hardware que contempla CLDC son:

o 160KB de memoria disponible para Java
o Procesador de 16 bits
o Consumo bajo de batería
o Conexión a red

Los dispositivos que claramente encajan dentro de este grupo, son
los teléfono móviles, los PDA (Personal Digital Assintant), los “Pocket
PC”...
En cuanto a los requisitos de memoria, según CLDC, los 160KB se
utilizan de la siguiente forma:
o 128KB de memoria no volátil para la máquina virtual Java y
o 32KB de memoria volátil, para sistema de ejecución (Java

para las librerías del API de CLDC

Runtime System).

En cuanto a las limitaciones impuestas por CLDC, tenemos por
ejemplo las operaciones en coma flotante. CLDC no proporciona
soporte para matemática en coma flotante. Otra limitación es la
eliminación del método Object.finalize. Este método es invocado
cuando un objeto es eliminado de la memoria, para optimizar los
recursos. También se limita el manejo de las excepciones. Es
complicado definir una serie de clases de error estándar, que se
ajuste a todos los dispositivos contemplados dentro de CLDC. La
solución es soportar un grupo limitado de clases de error y permitir



J2ME – Manuel J. Prieto (Nov 2002)

que el API específico de cada dispositivo defina su propio conjunto de
errores y excepciones.
La seguridad dentro de CLDC es sencilla, sigue el famoso modelo
sandbox. Las líneas básicas del modelo de seguridad sandbox en