OPERACIONES CON REGISTROS

COMUNICACION

Record Stores
Las propiedades de estos almacenes de registros son:
1. Cada Record Store está compuesto por cero o más registros.
2. Un nombre de Record Store es sensible a mayúsculas y minúsculas y está
formado por un máximo de 32 caracteres UNICODE.
3. Dentro de una suite no pueden coexistir dos Record Stores con el mismo
nombre.
4. Si una suite de MIDlets es borrada del dispositivo MID, todos los Record
Stores pertenecientes a esa suite se borrarán.
5. Es posible que un MIDlet acceda a un Record Store creado por otra suite,
siempre que ésta de permiso para ello.
Un Record Store tal como su nombre indica es un almacén de registros. Estos
registros son la unidad básica de información que utiliza la clase RecordStore para
almacenar datos.
Cada uno de estos registros está formado por dos unidades:
• Un número identificador de registro (Record ID) que es un valor entero que
realiza la función de clave primaria en la base de datos.
• Un array de bytes que es utilizado para almacenar la información deseada.
En la Figura 6.3 se ilustra la estructura de un Record Store:
Record Store
Record ID Datos
1 byte [] arrayDatos
2 byte [] arrayDatos
 

Además de un nombre, cada Record Store también posee otros dos atributos:
• Número de versión: Es un valor entero que se actualiza conforme vayamos
insertando, modificando o borrando registros en el Record Store. Podemos
consultar este valor invocando al método RecordStore.getVersion().
• Marca temporal: Es un entero de tipo long que representa el número de
milisegundos desde el 1 de enero de 1970 hasta el momento de realizar la
última modificación en el Record Store. Este valor lo podemos obtener
invocando al método RecordStore.getLastModified().
Así, la estructura de un Record Store se aproxima más a la Figura 6.4.
Nombre: Record Store 1
Version: 1.0
TimeStamp: 2909884894049
Registros:
137
Capítulo 6: Record Management System
Record ID Datos
1 byte [] arrayDatos
2 byte [] arrayDatos
 

6.3. Operaciones con Record Stores
Una vez vista la teoría, pasemos a la práctica. Ya sabemos qué es un Record
Store y como está formado. En este punto veremos la clase
javax.microedition.rms.RecordStore y todas las operaciones que nos permitan
realizar sus métodos.
6.3.1. Creación de un Record Store
La clase RecordStore no dispone de ningún constructor, pero posee el método
estático:
static RecordStore openRecordStore(String name, boolean
createIfNeccesary)
Este método nos abre el Record Store con el nombre pasado como parámetro o
nos crea uno si no existe cuando el parámetro createIfNeccesary es true. Además,
existen otrasdos versiones alternativas de este método:
• static RecordStore openRecordStore(String name, boolean
createIfNeccesary, int autorización, boolean writable)
• static RecordStore openRecordStore(String name, String
vendorName, String suiteName)
El primero de ellos usa los siguientes parámetros:
• autorización:
o AUTHMODE_PRIVATE: Sólo permite el acceso al Record Store a la
MIDlet suite que lo creó.
o AUTHMODE_ANY: Permite el acceso a cualquier MIDlet del
dispositivo. Este modo hay que usarlo con mucho cuidado ya que
podría provocar problemas de privacidad y seguridad.
• writable: Indicamos si el Record Store puede ser modificado por cualquier
MIDlet que pueda acceder a él.
Estos parámetros sólo tienen efecto si estamos creando un Record Store. Si éste ya
estaba creado, estos parámetros se ignorarán.
El segundo método lo usaremos para abrir un Record Store que está asociado a
alguna MIDlet suite especificada por los parámetros vendorName y suiteName. El
acceso vendrá limitado por el tipo de autorización del Record Store cuando fue creado
(véase método anterior).
138
Cuándo terminemos de usar el Record Store, hay que cerrar la comunicación con
él. Esto lo haremos mediante el método:
public void closeRecordStore() throws RecordStoreNotFoundException,
RecordStoreException
Para cerrar correctamente la comunicación con un Record Store, es necesario
invocar este método tantas veces como llamadas se haya realizado al método
openRecordStore().
En la Tabla 6.1 podemos ver algunos métodos que nos proporcionan operaciones
generales con los Record Stores.
Métodos Descripción
String getName() Devuelve el nombre del Record Store.
int getVersion() Devuelve la versión del Record Store.
long getLastModified() Devuelve la marca temporal.
int getNumRecords() Devuelve el número de registros.
int getSize() Devuelve el número de bytes ocupado por el
Record Store.
int getSizeAvailable() Devuelve el tamaño disponible para añadir
registros.
String[] listRecordStores() Devuelve una lista con los nombres de los
Record Stores que existen en la MIDlet suite.
void deleteRecordStore(String name) Elimina del dispositivo al Record Store
especificado por el parámetro ‘name’.
RecordEnumeration
enumerateRecords(RecordFilter filter,
RecordComparator comparator, boolean
actualizado)
Nos devuelve un objeto RecordEnumeration
(vease punto 6.4 Operaciones avanzadas con
Record Stores).
void addRecordListener( RecordListener
listener)
Añade un ‘listener’ para detectar cambios en
el Record Store.
void removeRecordListener
(RecordListener listener)
Elimina un ‘listener’.
Tabla 6.1 Métodos generales de la clase RecordStore
6.3.2. Manipulación de registros
Una vez creado o abierta la comunicación con el Record Store, podemos leer,
escribir, modificar o borrar registros a nuestro gusto. Para ello, usaremos los métodos de
la clase RecordStore que se ven en la Tabla 6.2.
Método Descripción
int addRecord(byte[] datos, int offset, int
numBytes)
Añade un registro al Record Store
void deleteRecord(int id) Borra el registro ‘id’ del Record Store
Int getNextRecordId() Devuelve el siguiente ‘id’ del registro que
se vaya a insertar
139
 

byte[] getRecord(int id) Devuelve el registro con identificador ‘id’
int getRecord(int id, byte[] buffer, int offset) Devuelve el registro con identificador ‘id’
en ‘buffer’ a partir de ‘offset’
Int getRecordSize(int id) Devuelve el tamaño del registro ‘id’
void setRecord(int id, byte[] datonuevo, int
offset, int tamaño)
Sustituye el registro ‘id’ con el valor de
‘datonuevo’
Tabla 6.2 Métodos para el manejo de registros
Las operaciones que más vamos a realizar a la hora de trabajar con registros
serán, sin duda, las de lectura y escritura. Para empezar, veremos un ejemplo donde
cada registro almacenará un tipo básico, en este caso cadenas de caracteres que
representarán una entrada en una agenda. Iremos guardando en los registros el nombre
de las personas incluidas en la agenda. Este ejemplo nos dará una visión global de los
pasos que debemos realizar para comunicarnos en el RMS. Crearemos un Record Store
en el que guardaremos un par de registros que posteriormente recuperaremos y
mostraremos por pantalla.
import javax.microedition.midlet.* ;
import javax.microedition.rms.* ;
public class Agenda extends MIDlet {
private RecordStore rs;
public Agenda(){
abrirRecordStore();
escribirDatos();
leerRegistros();
cerrarRecordStore();
destruirRecordStore();
}
public void startApp() {
//No realizamos ninguna acción ya que no usamos ningún GUI
//Podríamos crear un formulario para introducir datos en el Record //Store
destroyApp(true);
notifyDestroyed();
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void abrirRecordStore(){
try{
rs = RecordStore.openRecordStore(“Agenda”,true);
}
catch (RecordStoreException e){
140
Java a Tope: Java Micro Edition
System.out.println(“Error al abrir el Record Store”);
}
}
public void escribirDatos(){
escribirRegistro(“Antonio”);
escribirRegistro(“Manolo”);
}
public void escribirRegistro(String entrada){
byte[] registro;
registro = entrada.getBytes();
try{
rs.addRecord(registro,0,registro.length);
}
catch (RecordStoreException e){
System.out.println(“Error al insertar registro”);
}
}
public void leerRegistros(){
byte[] registro = new byte[75];
int longitud;
try{
for (int i=1;i<=rs.getNumRecords();i++){
longitud = rs.getRecordSize(i);
registro = rs.getRecord(i);
System.out.println(“Registro “+i+”: “+ new String(registro,0,longitud));
}
}
catch (RecordStoreException e){
System.out.println(“Error al leer los registros”);
}
registro = null;
}
public void cerrarRecordStore(){
try{
rs.closeRecordStore();
}
catch (RecordStoreException e){
System.out.println(“Error al cerrar el Record Store”);
}
}
public void destruirRecordStore(){
try{
RecordStore.deleteRecordStore(“Agenda”);
}
catch (RecordStoreException e){
System.out.println(“Error al eliminar el Record Store”);
141
Capítulo 6: Record Management System
}
}
}
Este ejemplo no es muy útil en el sentido práctico. De nada nos sirve guardar
sólo el nombre de alguien si no guardamos también alguna información de interés
como, por ejemplo, su número de teléfono. Llegados a este punto habría que hacerse
una pregunta: ¿es posible guardar en el mismo registro el nombre y teléfono de cada
persona? La respuesta es sí, es posible guardar en el mismo registro el nombre, teléfono
e incluso dirección o cualquier otro dato de interés, pero no del modo que hemos hecho
anteriormente, ya que para ello hay que recurrir al concepto de stream. Siguiendo el
ejemplo que nos ocupa, lo que mejor podemos hacer es construir una segunda versión
de nuestra agenda donde se guarde en cada registro el nombre y teléfono de cada
persona. Aquí se verá como se realizan las operaciones de lectura y escritura a través de
streams de bytes.
import java.io.*;
import javax.microedition.midlet.* ;
import javax.microedition.rms.* ;
public class Agenda2 extends MIDlet {
private RecordStore rs;
public Agenda2(){
abrirRecordStore();
escribirDatos();
leerRegistros();
cerrarRecordStore();
destruirRecordStore();
}
public void startApp() {
//No realizamos ninguna acción ya que no usamos ningún GUI
//Podríamos crear un formulario para introducir datos en el Record //Store
destroyApp(true);
notifyDestroyed();
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void abrirRecordStore(){
try{
rs = RecordStore.openRecordStore(“Agenda”,true);
}
catch (RecordStoreException e){
System.out.println(“Error al abrir el Record Store”);
142
Java a Tope: Java Micro Edition
}
}
public void escribirDatos(){
escribirRegistro(“Antonio”,555987654);
escribirRegistro(“Manolo”,555123456);
}
public void escribirRegistro(String entrada, long tel){
byte[] registro;
ByteArrayOutputStream baos;
DataOutputStream dos;
try{
baos = new ByteArrayOutputStream();
dos = new DataOutputStream(baos);
dos.writeUTF(entrada);
dos.writeLong(tel);
dos.flush();
registro = baos.toByteArray();
rs.addRecord(registro,0,registro.length);
baos.close();
dos.close();
}
catch (Exception e){
System.out.println(“Error al insertar registro”);
}
}
public void leerRegistros(){
ByteArrayInputStream bais;
DataInputStream dis;
byte[] registro = new byte[75];
try{
bais = new ByteArrayInputStream(registro);
dis = new DataInputStream(bais);
for (int i=1;i<=rs.getNumRecords();i++){
rs.getRecord(i,registro,0);
System.out.println(“Registro “+i);
System.out.println(“Nombre: “+dis.readUTF()+” Telefono:
“+dis.readLong());
bais.reset();
}
bais.close();
dis.close();
}
catch (Exception e){
System.out.println(“Error al leer los registros”);
}
registro = null;
}
143
Capítulo 6: Record Management System
public void cerrarRecordStore(){
try{
rs.closeRecordStore();
}
catch (RecordStoreException e){
System.out.println(“Error al cerrar el Record Store”);
}
}
public void destruirRecordStore(){
try{
RecordStore.deleteRecordStore(“Agenda”);
}
catch (RecordStoreException e){
System.out.println(“Error al eliminar el Record Store”);
}
}
}
En este ejemplo hemos utilizado streams para leer y escribir registros en el
Record Store. Con ello hemos conseguido almacenar información de distinto tipo en el
mismo registro. La estructura del programa es la misma que antes, pero cambiando el
contenido de los métodos encargados de escribir y leer registros: escribirDatos(),
escribirRegistro(String nombre, long telefono) y leerRegistros(). En estos dos
últimos métodos es dónde usamos los streams para leer y escribir datos del Record
Store. También hemos cambiado la forma de manejar las excepciones ya que
capturamos una excepción genérica de tipo Exception para simplificar el programa en
vez de una RecordStoreException. Esto es así porque al usar streams se puede lanzar
una excepción de tipo IOException que también ha de ser capturada. En la práctica
deberíamos usar un par de bloques catch que capturaran ambos tipos de excepciones
por separado y así informar al usuario de una forma más clara que tipo de error ha
ocurrido.
6.4. Operaciones avanzadas con Record Stores
La clase RecordStore nos proporciona algunas interfaces que nos facilitan el
trabajo a la hora de manipular registros. Básicamente, vamos a ver como estas interfaces
nos ayudan a la hora de navegar por los registros de un Record Store, realizar búsquedas
en ellos y ordenaciones.
6.4.1. Navegación a través de un Record Store
En los ejemplos anteriores hemos usado un simple bucle para movernos entre los
distintos registros de nuestro Record Store:
144
for (int i=1;i<=rs.getNumRecords();i++){
longitud = rs.getRecordSize(i);
registro = rs.getRecord(i);
System.out.println(“Registro “+i+”: “+ new
String(registro,0,longitud));
}
Sin embargo, la clase RecordStore nos proporciona la interfaz
RecordEnumeration que nos facilita esta tarea. Esta interfaz posee los métodos que
aparecen en la Tabla 6.3.
Método Descripción
int numRecords() Devuelve el número de registros
Byte[] nextRecord() Devuelve el siguiente registro
int nextRecordId() Devuelve el siguiente ‘id’ a devolver
Byte[] previousRecord() Devuelve el registro anterior
int previousRecordId() Devuelve el ‘id’ del registro anterior
boolean hasNextElement() Devuelve true si existen más registros en
adelante
boolean hasPreviousElement() Devuelve true si existen más registros
anteriores
void keepUpdated() Provoca que los indices se actualicen cuándo
se produzca algún cambio en el Record Store
boolean isKeptUpdated() Devuelve true si los indices se actualizan
al producirse algún cambio en el Record
Store
void rebuild() Actualiza los índices del
RecordEnumeration
void reset() Actualiza los índices a su estado inicial
void destroy() Libera todos los recursos ocupados
Tabla 6.3 Métodos de RecordEnumeration
Haciendo uso de esta interfaz podemos sustituir el bucle anterior por algo como
lo siguiente:
RecordEnumeration re = rs.enumerateRecords(null,null,false);
while (re.hasNextElement()){
registro = re.nextRecord();
//Realizo las operaciones que quiera
...
}
Como vemos, la navegación por los registros usando RecordEnumeration es
mucho más intuitiva y nos permite realizar acciones como movernos hacia delante o
hacia atrás de una manera muy sencilla.
145
 

Vamos a fijarnos en los parámetros que le pasamos al método
enumerateRecords(). Como podemos ver en la tabla 6.1, hemos de pasarle como
primer parámetro una referencia a un RecordFilter y como segundo, otra a un
RecordComparator. Nosotros hemos sustituido ambas referencias por null con lo que
conseguiremos un objeto RecordEnumeration con la misma estructura de registros
que el Record Store original. El tercer parámetro indica si queremos que los índices se
actualicen en el caso de que se produzca alguna acción en el Record Store por cualquier
otro MIDlet mientras trabajamos con él.
6.4.2. Búsqueda de registros
Para realizar una búsqueda eficiente de registros en un Record Store vamos a
utilizar la interfaz RecordFilter. Esta interfaz se encarga de devolver al
RecordEnumeration únicamente los registros que coincidan con un determinado
patrón de búsqueda.
Para usar esta interfaz hemos de implementar necesariamente el método:
public boolean matches(byte [] candidato)
que se encarga de comparar el registro candidato pasado como parámetro con el valor
que queremos buscar y devolvemos true en caso de que coincidan.
En el siguiente ejemplo vamos a crear un RecordFilter y así podremos ver su
funcionamiento
public class Filtro implements RecordFilter{
private String cadenaabuscar = null;
public Filtro(String cadena){
this.cadenaabuscar = cadena.toLowerCase();
}
public boolean matches(byte[] candidato){
boolean resultado = false;
String cadenacandidata;
ByteArrayInputStream bais;
DataInputStream dis;
try{
bais = new ByteArrayInputStream(candidato);
dis = new DataInputStream(bais);
cadenacandidata = dis.readUTF().toLowerCase();
}
catch (Exception e){
return false;
}
if ((cadenacandidata != null) && (cadenacandidata.indexOf(cadenaabuscar)
!= -1))
return true;
else
return false;
146
Java a Tope: Java Micro Edition
}
}
Si usamos este RecordFilter a la hora de invocar a enumerateRecords():
//Creo un objeto de tipo RecordFilter
r
Filtro buscar = new Filtro(“Antonio”);
//Obtengo el RecordEnumeration usando el filtro ante ior
RecordEnumeration re = rs.enumerateRecords(buscar,null,false);
//Si encuentro algún registro dado el patrón de búsqueda
if (re.numRecords() > 0)
System.out.println(“Patron ‘Antonio’ encontrado”);
el resultado será que el RecordEnumeration devuelto sólo contendrá los registros en
los que se haya encontrado el patrón de búsqueda.
6.4.3. Ordenación de registros
La ordenación de registros se realiza a través del interfaz RecordComparator.
Esta interfaz funciona básicamente igual que el RecordFilter. Existe un método public
int compare(byte[] reg1, byte[] reg2) que ha de ser implementado obligatoriamente.
Este método es el encargado de realizar la comparación entre los campos que deseemos
de los registros y el entero que nos devuelve nos indica si reg1 va antes o después que
reg2. El valor devuelto por este método puede ser:
• EQUIVALENT: Los registros pasados al método compare son equivalentes.
• FOLLOWS: El primer registro sigue al segundo.
• PRECEDES: El primer registro precede al segundo.
Al igual que hicimos con el RecordFilter vamos a crear una clase que
implemente la interfaz RecordComparator y veamos cómo se realiza la comparación
entre los registros:
public class Compara implements RecordComparator{
public boolean compare(byte[] reg1, byte[] reg2){
ByteArrayInputStream bais;
DataInputStream dis;
String cad1, cad2;
try{
bais = new ByteArrayInputStream(reg1);
dis = new DataInputStream(bais);
cad1 = dis.readUTF();
bais = new ByteArrayInputStream(reg2);
dis = new DataInputStream(bais);
cad2 = dis.readUTF();
int resultado = cad1.compareTo(cad2);
if (resultado == 0)
return RecordComparator.EQUIVALENT;
else if (result < 0)
return RecordComparator.PRECEDES;
147
Capítulo 6: Record Management System
else
return RecordComparator.FOLLOWS;
}
catch (Exception e){
return RecordComparator.EQUIVALENT;
}
}
}
Esta clase puede usarse a la hora de crear el RecordEnumeration para recorrer
los elementos de manera ordenada:
//Creo un objeto de tipo RecordComparator
Compara comp = new Compara();
//Obtengo el RecordEnumeration usando el objeto anterior, y
// con los registros ordenados
RecordEnumeration re = rs.enumerateRecords(null,comp,false);
6.5. Manejo de eventos en los Record Stores
Existe además otra interfaz que nos permite capturar eventos que se produzcan a
la hora de realizar alguna acción en un Record Store. La interfaz RecordListener es la
encargada de recoger estas acciones. Esta interfaz funciona como cualquier otro
listener. Cuándo ocurre algún evento, un método es llamado para notificarnos este
cambio. Los tres métodos de la Tabla 6.4 se encargan de esta tarea.
Método Descripción
void recordAdded(RecordStore rs, int id) Invocado cuándo un registro es añadido
void recordChanged(RecordStore rs, int id) Invocado cuándo un registro es
modificado
void recordDeleted(RecordStore rs, int id) Invocado cuándo un registro es borrado
Tabla 6.4 Métodos de la interfaz RecordListener
La implementación de estos métodos es vacía por lo que debe ser proporcionada
por nosotros. En el siguiente ejemplo vamos a crear una clase que implemente esta
interfaz. Los métodos anteriores lo único que harán será informar por pantalla que se ha
producido algún cambio en el Record Store.
public class PruebaListener implements RecordListener{
public void recordAdded(RecordStore rs, int id){
try{ String nombre = rs.getName();
System.out.println(“Registro ”+id+” añadido al Record Store: “+nombre);
}
catch (Exception e){
System.err.println(e);
}
}
148
Java a Tope: Java Micro Edition
public void recordDeleted(RecordStore rs, int id){
try{ String nombre = rs.getName();
System.out.println(“Registro “+id+” borrado del Record Store: “+ nombre);
}
catch (Exception e){
System.err.println(e);
}
}
public void recordChanged(RecordStore rs, int id){
try{String nombre = rs.getName();
System.out.println(“Registro “+id+” modificado del Record Store: “+nombre);
}
catch (Exception e){
System.err.println(e);
}
}
}
Añadir este RecordListener a un Record Store es muy sencillo. Sólo tenemos que
incluir el siguiente código en el MIDlet:
RecordStore rs = openRecordStore(“Almacen1”,true);
rs.addRecordListener( new PruebaListener());
Ya hemos visto todos los elementos que nos proporciona el paquete
javax.microedition.rms. A partir de ahora ya podemos almacenar cualquier tipo de
información en nuestro dispositivo MID de manera persistente. Lo siguiente que
podríamos hacer es dotar de una interfaz de usuario a los ejemplos que hemos visto en
este capítulo para dotar de funcionalidad a la agenda que hemos creado.
6.6. Ejemplo práctico
En este punto vamos a dotar a nuestra aplicación PingPong de capacidad para
almacenar las mejores puntuaciones en el MID. El código de esta aplicación ya lo
conocemos excepto por la clase Resultado que es la que posee los métodos necesarios
para almacenar la información en los Record Stores. Aquí podemos ver el código de
esta clase:
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.*;
import java.io.*;
public class Resultado extends List implements CommandListener{
private PingPong midlet;
private Command aceptar;
private RecordStore rs;
149
Capítulo 6: Record Management System
public Resultado(PingPong m){
super("Records",List.IMPLICIT);
initPuntuacion("Clasificacion1");
initPuntuacion("Clasificacion2");
initPuntuacion("Clasificacion3");
midlet = m;
aceptar = new Command("Aceptar",Command.OK,1);
this.addCommand(aceptar);
this.setCommandListener(this);
}
public void commandAction(Command c, Displayable d){
midlet.setMenu();
}
public void verResultado(){
this.setTitle("Records Nivel "+midlet.getNivel());
try{
for (int i=this.size();i>0;i--){
this.delete(i-1);
}
this.append("Puntuacion Jugador",null);
rs = RecordStore.openRecordStore("Clasificacion"+midlet.getNivel(),true);
for (int i=1;i<=rs.getNumRecords();i++){
byte[] registro = rs.getRecord(i);
ByteArrayInputStream bais = new ByteArrayInputStream(registro);
DataInputStream dis = new DataInputStream(bais);
String nombre = dis.readUTF();
long puntuacion = dis.readLong();
this.append(" "+puntuacion+" "+nombre,null);
bais.close();
dis.close();
registro = null;
}
rs.closeRecordStore();
}
catch (Exception e){
System.out.println("Excepción detectada");
}
}
public void insertarRegistro(String nombre, long punt){
try{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
dos.writeUTF(nombre);
dos.writeLong(punt);
dos.flush();
byte[] nreg = baos.toByteArray();
baos.close();
150
Java a Tope: Java Micro Edition
dos.close();
rs = RecordStore.openRecordStore("Clasificacion"+midlet.getNivel(),true);
byte[] reg3 = rs.getRecord(3);
if (getPuntuacion(reg3) < punt){
byte[] reg2 = rs.getRecord(2);
byte[] reg1 = rs.getRecord(1);
if (getPuntuacion(reg2) < punt){
if (getPuntuacion(reg1) < punt){
rs.setRecord(1,nreg,0,nreg.length);
rs.setRecord(2,reg1,0,reg1.length);
rs.setRecord(3,reg2,0,reg2.length);
}
else{
rs.setRecord(2,nreg,0,nreg.length);
rs.setRecord(3,reg2,0,reg2.length);
}
}
else{
rs.setRecord(3,nreg,0,nreg.length);
}
}
rs.closeRecordStore();
}
catch (Exception e){
System.out.println(e);
}
}
private long getPuntuacion(byte[] registro){
try{
ByteArrayInputStream bais = new ByteArrayInputStream(registro);
DataInputStream dis = new DataInputStream(bais);
String nombre = dis.readUTF();
long puntuacion = dis.readLong();
bais.close();
dis.close();
return puntuacion;
}
catch (Exception e){
System.out.println(e);
return -1;
}
}
private void initPuntuacion(String nombre){
try{
rs = RecordStore.openRecordStore(nombre,true);
if (rs.getNumRecords() == 0){
for (int i=0;i<3;i++){
byte[] registro;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
151
Capítulo 6: Record Management System
DataOutputStream dos = new DataOutputStream(baos);
dos.writeUTF("AAA");
dos.writeLong(0);
dos.flush();
registro = baos.toByteArray();
rs.addRecord(registro,0,registro.length);
baos.close();
dos.close();
registro = null;
}
}
rs.closeRecordStore();
}
catch (Exception e){
System.out.println(e);
}
}
public boolean esRecord(long punt){
try{
rs = RecordStore.openRecordStore("Clasificacion"+midlet.getNivel(),true);
byte[] reg = rs.getRecord(3);
long p3 = getPuntuacion(reg);
rs.closeRecordStore();
reg = null;
return ((p3 >= punt)?false:true);
}
catch (Exception e){
System.out.println(e);
return false;
}
}
}
Esta clase es la encargada de almacenar los registros con las mejores
puntuaciones. Dispone de los siguientes métodos:
• verResultado(): Nos muestra los records almacenados en el Record Store.
• insertarRegistro(String n, long p): Nos inserta en el Record Store un nuevo
record en el caso de que sea así en la posición correcta.
• getPuntuacion(byte[] registro): Nos devuelve la puntuación almacenada en
un registro dado.
• initPuntuacion(String nombre): Nos inicializa las puntuaciones en el caso de
que sea la primera ejecución del MIDlet y no existan datos en el Record Store.
• esRecord(long puntuacion): Nos devuelve true o false dependiendo de si la
puntuación pasada como parámetro sea un record nuevo o no.

COMUNICACION