J2me: memorizzare file

[boysna]

Ciao a tutti.
Come da titolo l'argomento della mia discussione è J2ME.

In particolar modo mi sto chiedendo come memorizzare dei file. Si può usare un RecordStore per fare questo?

Ciao.

[PGI-Bis]

Sì, puoi usare un RecordStore. Però ha delle limiti quantitativi non elevati - qualche kilobyte se non ricordo male.

Se il dispositivo supporta il JSR 75, solitamente perchè dispone di schede di memoria, allora potresti usare gli strumenti offerti dal package javax.microedition.io.file.

Alternativamente potresti usare un web server per conservare i file. Una sorta di filesystem remoto. Qui tuttavia entra in gioco il costo della connessione internet e non è detto che l'utente sia felice di pagarla. Dipende da quanto è utile l'applicazione.

[boysna]

Sì, puoi usare un RecordStore. Però ha delle limiti quantitativi non elevati - qualche kilobyte se non ricordo male.

Se il dispositivo supporta il JSR 75, solitamente perchè dispone di schede di memoria, allora potresti usare gli strumenti offerti dal package javax.microedition.io.file.

Alternativamente potresti usare un web server per conservare i file. Una sorta di filesystem remoto. Qui tuttavia entra in gioco il costo della connessione internet e non è detto che l'utente sia felice di pagarla. Dipende da quanto è utile l'applicazione.

Per ora posso tralasciare questo problema dela capacità.
Come faccio a memorizzarlo in un recordstore per esempio?

[PGI-Bis]

Non è complicato.

Puoi partire dalla definizione di un FileSystem minimo e astratto, sul genere:

public interface FileSystem {

/** Carica il file */
byte[] load(String fileName) throws FileSystemException;

/** Salva un file */
void save(String fileName, byte[] data) throws FileSystemException ;

/** True se il file in argomento esiste */
boolean exists(String fileName) throws FileSystemException ;
}

Da qui alla versione su RecordStore è questione di qualche linea di codice derivante da un rapido esame del package rms. Una versione semplice potrebbe essere questa.

Ogni file è un Record. Ogni record è costituito di due segmenti. Il primo segmento è quello del nome, il secondo è quello dei dati. Basandoti su questa convenzione puoi creare un RecordFilter in grado di estrarre dal RecordStore i dati corrispondenti ad un certo nome, se esistono.

Il RecordFilter che verifica la corrispondenza tra i byte di un nome ed i byte di un Record può essere:

import javax.microedition.rms.*;

/** Filtro per record che si basa sulla corrispondenza di
un nome, conservato nei primi byte del record */
public class NamedRecordFilter implements RecordFilter {
private byte[] name;

/** Imposta i dati della corrispondenza */
public void setName(byte[] b) {
name = b;
}

/** True se i primi byte di candidate corrispondano
esattamente a tutti i byte usati per il nome */
public boolean matches(byte[] candidate) {
if(name == null) return false;
if(candidate.length < name.length) return false;
for(int i = 0; i < name.length; i++) {
if(name[i] != candidate[i]) return false;
}
return true;
}
}

Con questo due di bastoni, possiamo far coppia con:

import java.io.*;
import javax.microedition.rms.*;

public class RecordStoreFileSystem implements FileSystem {
private final NamedRecordFilter FILTER = new NamedRecordFilter();
private final String ROOT;

/** Crea un FileSystem sul RecordStore identificato dal
nome in argomento */
public RecordStoreFileSystem(String root) {
ROOT = root;
}

/**@InheritDoc */
public byte[] load(String fileName) throws FileSystemException {
byte[] fileData = null;
RecordStore rs = null;
try {
//Converte il nome in nome + #, per la ricerca
byte[] nameData = createFileName(fileName);

//Apre il record store
rs = RecordStore.openRecordStore(ROOT, true);

//imposta il filtro
FILTER.setName(nameData);

/*applica il filtro, ottenendo un enumeratore sui record
selezionati dal filtro*/
RecordEnumeration re = rs.enumerateRecords(FILTER, null, false);

/*Se c'è più di un record sputa un'eccezione.*/
if(re.numRecords() > 1) {
throw new FileSystemException("RecordStoreFS, load(String), error: 2 files found");
} else if(re.numRecords() == 1) {
/* Se c'è una corrispondenza, carica il record, estrai il segmento
dati e lo conserva per la restituzione finale */
fileData = unpackFileData(nameData, re.nextRecord());
}

//Libera le risorse occupate dall'enumeratore
re.destroy();
} catch(Exception ex) {
throw new FileSystemException(ex.getMessage());
} finally {
dispose(rs);
}
return fileData;
}

public void save(String fileName, byte[] fileData) throws FileSystemException {
RecordStore rs = null;
try {
//Trasforma il nome del file in nome + #
byte[] nameData = createFileName(fileName);

//Impacchetta i dati (nome# + dati)
byte[] filePack = createFilePack(nameData, fileData);

//Apre il RecordStore ROOT
rs = RecordStore.openRecordStore(ROOT, true);

//Verifica l'esistenza del file, filtrando il RecordStore
FILTER.setName(nameData);
RecordEnumeration re = rs.enumerateRecords(FILTER, null, false);

//Se c'è già un Record che inizia con nome#
if(re.numRecords() > 0) {
//lo sovrascrive
int recordId = re.nextRecordId();
rs.setRecord(recordId, filePack, 0, filePack.length);
} else {
//altrimenti ne crea uno nuovo
rs.addRecord(filePack, 0, filePack.length);
}
re.destroy();
} catch(Exception ex) {
throw new FileSystemException(ex.getMessage());
} finally {
dispose(rs);
}
}

/** @InheritDoc */
public boolean exists(String fileName) throws FileSystemException {
boolean answer = false;
RecordStore rs = null;
try {
//Apre il record store di nome ROOT
rs = RecordStore.openRecordStore(ROOT, true);

//Imposta il filtro per cercare qualcosa che inizi per "fileName"+#
FILTER.setName(createFileName(fileName));

//Filtra i Record del RecordStore
RecordEnumeration re = rs.enumerateRecords(FILTER, null, false);

//Se esiste una corrispondenza restituisce true
answer = re.numRecords() > 0;
re.destroy();
return answer;
} catch(RecordStoreException ex) {
throw new FileSystemException(ex.getMessage());
} finally {
dispose(rs);
}
}

/* Estra da filePack il segmento che contiene i dati del file. */
private byte[] unpackFileData(byte[] name, byte[] filePack) {
byte[] data = new byte[filePack.length - name.length];
for(int i = name.length; i < filePack.length; i++) {
data[i - name.length] = filePack[i];
}
return data;
}

/* Chiude il RecordStore in argomento */
private void dispose(RecordStore rs) throws FileSystemException {
if(rs != null) {
try {
rs.closeRecordStore();
} catch(RecordStoreException ex) {
throw new FileSystemException(ex.getMessage());
}
}
}

/* Crea un pacchetto di byte di dimensioni name.length +
data.length, diviso in due segmenti ideali. Il primo
segmento contiene i byte di name, il secondo i byte di data */
private byte[] createFilePack(byte[] name, byte[] data) {
byte[] pack = new byte[name.length + data.length];
for(int i = 0; i < name.length; i++) {
pack[i] = name[i];
}
for(int i = 0; i < data.length; i++) {
pack[i + name.length] = data[i];
}
return pack;
}

/* Crea un pacchetto di byte utf-8 che rappresenta la sezione
nome nell'array di byte di un Record. Al nome è aggiunto il
carattere # per evitare un falso positivo nel caso in cui
il nome di un file corrisponda alla parte iniziale di un nome
di file più lungo. Il carattere # non è valido per la costruzione
del nome di un file. */
private byte[] createFileName(String fileName) {
try {
return (fileName + "#").getBytes("utf-8");
} catch(UnsupportedEncodingException ex) {
throw new Error("UTF-8 Unsupported");
}
}
}

L'uso è limitato da quanto esposto nell'interfaccia FileSystem. In lettura avremo:

FileSystem fs = new RecordStoreFileSystem("myfs");
String fileName = "pippo.txt";
try {
byte[] data = fs.load(fileName);
} catch(FileSystemException ex) {
...
}

e in scrittura:

FileSystem fs = new RecordStoreFileSystem("myfs");
String fileName = "pippo.txt";
byte[] data = "Hello world!".getBytes();
try {
fs.save(fileName, data);
} catch(FileSystemException ex) {
...
}

Le varianti si sprecano. La ricerca sequenziale di una corrispondenza tra pacchetti di byte ed un nome non è molto efficiente. Puoi usare record nel RecordStore per mantenere una lista di coppie (nome, id) e fare una ricerca su quella per scovare il file corrispondente al nome. Se poi i file sono destinati ad essere un bel po' anzichè una lista di coppie dovresti pensare ad una tabella... Son tutti problemi da file system.