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]

Originariamente inviato da 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.

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.