Rispondi 
 
Valutazione discussione:
  • 0 voti - 0 media
  • 1
  • 2
  • 3
  • 4
  • 5
Programmazione Android, lezione 9: uso di un database sqlite
Autore Messaggio
Bay's Chef Offline
Administrator
*******

Messaggi: 73
Registrato: Jun 2012
Reputazione: 0
Messaggio: #1
Programmazione Android, lezione 9: uso di un database sqlite
Come anticipato nella lezione precedente, al crescere della complessità dell'applicazione crescerà, probabilmente, la necessità di salvare dei dati per poterli in seguito manipolare. Uno degli strumenti più versatili per compiere questo genere di operazione è un database e Android integra nativamente la possibilità di creare e manipolare database SQLite.

SQLite è un database relazionale molto semplice e veloce.

Gli strumenti per interagire con SQLite sono forniti dai package:

- android.database
- android.database.sqlite

Il primo package fornisce una serie di classi per gestire dati provenienti da database in generale, come ad esempio i cursori, mentre il secondo package contiene classi più specifiche per compiere tutte le operazioni necessarie ad interagire col database, come la sua creazione, l'apertura e chiusura, l'iterrogazione.

La creazione di un database è possibile usare il metodo:
    PROGRAMMAZIONE ANDROID
public static SQLiteDatabase openDatabase(String path, SQLiteDatabase.CursorFactory factory, int flags);



L'esecuzione di questo metodo creerà un database al percorso:

/data/data/<application package name>/databases/<path>.db

In cui path è il primo argomento di openDatabase().

Il secondo argomento, factory, rappresenta il tipo di implementazione di Cursor che si desidera usare. Spesso, per questo parametro, si utilizza il valore null per indicare che si intende utilizzare l'implementazione di default.

L'ultimo argomento, le flags, permettono di specificare le modalità di accesso al database e possono assumere i valori:

CREATE_IF_NECESSARY, che permette di creare il DB prima di aprirlo
OPEN_READONLY, che apre il DB in sola lettura,
OPEN_READWRITE, che apre il DB in lettura e scrittura,
NO_LOCALIZED_COLLATORS, specifica che le funzioni di ricerca non devono venire influenzate da Locale, cioè dalla localizzazione.

Per gestire efficientemente un database avremo bisogno di una classe in grado di gestire la sua apertura, chiusura, modifica ed interrogazione. Per semplificare il discorso, propongo un esempio di classe per gestire un database di coordinate GPS. Questo database permette di memorizzare la data, un nome (ad esempio di cosa c'è a quella posizione), delle note e le coordinate (latitudine/longitudine):

    PROGRAMMAZIONE ANDROID
public class GPSdb{
 
	public static final String MYDATABASE_NAME = "GpsPosition";
	public static final String MYDATABASE_TABLE = "posizioni";
	public static final int MYDATABASE_VERSION = 1;
	public static final String KEY_ID = "_id";
	public static final String KEY_NOME = "nome";
	public static final String KEY_NOTE = "note";
	public static final String KEY_LAT = "lat";
	public static final String KEY_LON = "lon";
	public static final String KEY_DATA = "data";
 
	private static final String SCRIPT_CREATE_DATABASE =
	"create table " + MYDATABASE_TABLE + " ("
	+ KEY_ID + " integer primary key autoincrement, " 
	+ KEY_DATA + " string,"
	+ KEY_NOME + " string not null,"
	+ KEY_NOTE + " string,"
	+ KEY_LAT + " real not null,"
	+ KEY_LON + " real not null);";
 
	private SQLiteHelper sqLiteHelper;
	private SQLiteDatabase sqLiteDatabase;	
	private Context context;
 
	public GPSdb(Context c){
		context = c;
	}
 
	public GPSdb openToRead() throws android.database.SQLException {
		sqLiteHelper = new SQLiteHelper(context, MYDATABASE_NAME, null, MYDATABASE_VERSION);
		sqLiteDatabase = sqLiteHelper.getReadableDatabase();
		return this;
	}
 
	public GPSdb openToWrite() throws android.database.SQLException {
		sqLiteHelper = new SQLiteHelper(context, MYDATABASE_NAME, null, MYDATABASE_VERSION);
		sqLiteDatabase = sqLiteHelper.getWritableDatabase();
		return this;
	}
 
	public void close(){
		sqLiteHelper.close();
	}
 
	public long insert(String data, String nome, String note, double lat, double lon){
 
		ContentValues contentValues = new ContentValues();
		contentValues.put(KEY_DATA, data	);
		contentValues.put(KEY_NOME, nome);
		contentValues.put(KEY_NOTE, note);
		contentValues.put(KEY_LAT, lat);
		contentValues.put(KEY_LON, lon);
		return sqLiteDatabase.insert(MYDATABASE_TABLE, null, contentValues);
 
	}
 
	public int deleteAll(){
		return sqLiteDatabase.delete(MYDATABASE_TABLE, null, null);
	}
 
	public Cursor queueAll(){
 
		String[] columns = new String[]{KEY_ID, KEY_DATA, KEY_NOME, KEY_NOTE, KEY_LAT, KEY_LON};
		Cursor cursor = sqLiteDatabase.query(MYDATABASE_TABLE, columns, null, null, null, null, null);
 
		return cursor;
 
	}
 
	public class SQLiteHelper extends SQLiteOpenHelper {
 
		public SQLiteHelper(Context context, String name,CursorFactory factory, int version) {
 
			super(context, name, factory, version);
 
		}				
 
		@Override
		public void onCreate(SQLiteDatabase db) {db.execSQL(SCRIPT_CREATE_DATABASE);}
 
		@Override
		public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {}
 
	}
 
}



Il codice non è commentato, ma si comprende abbastanza bene quali siano le sue funzioni: al suo interno viene creata una stringa che descrive il database, che verrà usata alla creazione, dal metodo onCreate() di SQLiteHelper. Questo creerà il database che potrà poi essere manipolato coi metodi: openToRead, openToWrite, close, insert, deleteAll e queueAll.

Per inserire una nuova posizione, si potrà ad esempio operare così:
    PROGRAMMAZIONE ANDROID
// nei field
double latD, lonD;
String NOME, NOTE;
 
// nel location listener
latD=location.getLatitude();
lonD=location.getLongitude();
 
/*
* ...tanto altro codice... :-p
*/
 
public void SaveLoc(){
		Calendar c=Calendar.getInstance();
	    	String giorno=Integer.toString(c.get(Calendar.DAY_OF_MONTH));
	    	String mese=Integer.toString(c.get(Calendar.MONTH));
	    	String anno=Integer.toString(c.get(Calendar.YEAR));
	    	String ora=Integer.toString(c.get(Calendar.HOUR_OF_DAY));
	    	String min=Integer.toString(c.get(Calendar.MINUTE));
	    	String data=giorno+"/"+mese+"/"+anno+"-"+ora+":"+min;
 
		GPSpos = new GPSdb(this);
		GPSpos.openToWrite();
		GPSpos.insert(data, NOME, NOTE, latD, lonD);
		GPSpos.close();
 
		finish();
 
}



Mentre la lettura dei dati potrà essere effettuata così:
    PROGRAMMAZIONE ANDROID
//nei field
ArrayList<String> PosList = new ArrayList<String>();
ArrayList<Double> LatList = new ArrayList<Double>();
ArrayList<Double> LonList = new ArrayList<Double>();
 
/*
* ...tanto altro codice... :-p
*/
 
//dove serve
GPSpos = new GPSdb(getBaseContext());
GPSpos.openToRead();
Cursor cur = GPSpos.queueAll();
 
        if (cur.getCount()>0){
 
        	while (cur.moveToNext()){
 
        		String chk=cur.getString(1)+", "+cur.getString(2);
        		if (cur.getString(3)!=null && cur.getString(3).length()>0) chk+=", "+cur.getString(3);
                        //le due linee sopra non sono importanti, generano solo un'etichetta di testo... 
        		PosList.add(chk);
        		LatList.add(cur.getDouble(4));
        		LonList.add(cur.getDouble(5));
 
        	}
 
        } else LabelTextView.setText("cursore vuoto");



Ora, non starò li a descrivere a menadito tutto il codice, vale la pena notare solamente che, una volta creata una classe di gestione del database sufficientemente ed opportunamente strutturata, sarà poi semplice interagire col database per le varie operazioni di lettura e scrittura.
(Questo messaggio è stato modificato l'ultima volta il: 04-16-2013 01:35 PM da Bay's Chef.)
04-11-2013 07:36 PM
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta

Tags
Rispondi 


Vai al forum:


Utente(i) che stanno guardando questa discussione: 1 Ospite(i)

Contattaci | Android Bay | Torna all'inizio della pagina | Torna al contenuto | Mobile Version | RSS Syndication
Iscriviti subito a BannerPromotion.it