Por Mário Baltazar para o Pplware
Tutorial realizado no âmbito do Mestrado em Computação Móvel do Instituto Politécnico da Guarda na Unidade Curricular de Seminário
A plataforma Android foi introduzida no mercado pela Google em 2007 e é composta por um sistema operativo embebido e um conjunto de aplicações que integram com a plataforma. Além das várias inovações implementadas, o Android traz também suporte nativo para o SQLite. O SQLite é uma pequena biblioteca, desenvolvida em linguagem C, que implementa um amplo subconjunto do standard SQL 92, sendo a sua reputação proveniente da combinação do motor de base de dados com a interface dentro de uma única biblioteca. As aplicações que usam SQLite podem ter assim acesso a uma base de dados racional SQL, sem a necessidade de correrem processos RDBMS (relational database management system) em separado e sem grandes overheads. O SQLite foi desenvolvido em 2000 e é actualmente uma base de dados amplamente adoptada em dispositivos móveis, suportando até 2 TB de dados.
Este artigo será dividido em duas partes e hoje vamos começar por ensinar como criar uma pequena aplicação para registo de contactos, sendo esses contactos guardados na base dados sqlite.
Vamos então começar com o desenvolvimento da aplicação, usando para isso a ferramenta de desenvolvimento eclipse.
1 – Criar Projecto
Criação de um novo projecto no Eclipse com o nome: “Contactos”
File > New > Other > Android/Android Project
2 – Criar uma nova classe com nome DbHelper Esta classe será responsável por criar a base de dados no momento em que a aplicação é instalada (método onCreate) e actualizá-la para novas versões(método onUpgrade).
2.1 – A classe DB expande a classe SQLiteOpenHelper, esta fornece os métodos getReadableDatabase() e getWriteableDatabase(), que permitem aceder à base dados SQLiteDatabase quer para ler quer para escrever.
public class DbHelper extends SQLiteOpenHelper { }
2.2 – Adicionar os imports necessários para a classe:
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
2.3 – Adicionar as constantes necessárias:
private static final int DATABASE_VERSION = 1;
public static final String ID = "_id";
public static final String NOME = "nome";
public static final String EMAIL = "email";
public static final String TELEFONE = "telefone";
public static final String FOTO = "foto";
private static final String DATABASE_CREATE = "create table "
+ TABLE_NAME + "( " + ID
+ " integer primary key autoincrement, " + NOME
+ " text not null, " + EMAIL + " text not null, "
+ TELEFONE+" text not null" +
", "+ FOTO +" BLOB);";
2.4 – Fazer @override das classes necessárias:
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(DATABASE_CREATE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(DbHelper.class.getName(), "Upgrading database from version " + oldVersion + "
to " + newVersion + ", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
2.5 – No final a classe terá um aspecto parecido com o seguinte:
public class DbHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "contactos4.db";
public static final String TABLE_NAME = "contactos2";
private static final int DATABASE_VERSION = 1;
public static final String ID = "_id";
public static final String NOME = "nome";
public static final String EMAIL = "email";
public static final String TELEFONE = "telefone";
public static final String FOTO = "foto";
private static final String DATABASE_CREATE = "create table "
+ TABLE_NAME + "( " + ID
+ " integer primary key autoincrement, " + NOME
+ " text not null, " + EMAIL + " text not null, "
+ TELEFONE+" text not null" +
", "+ FOTO +" BLOB);";
public DbHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(DATABASE_CREATE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(DbHelper.class.getName(),
"Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
}
4- Criar nova classe DBAdapter que será a classe base para trabalhar com SQLite. Esta irá permitir abrir, fechar, fazer queries e actualizar a base de dados. 4.1 – Criar nova classe DBAdapter
public class DBAdapter {
}
4.2 – Adicionar os imports necessários para a aplicação:
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
4.3 – Adicionar os Atributos necessários para a classe:
private SQLiteDatabase database;
private DbHelper dbHelper;
private String[] allColumns = { DbHelper.ID, DbHelper.NOME, DbHelper.EMAIL,
DbHelper.TELEFONE, DbHelper.FOTO};
4.4 – Declarar construtor da classe que irá inicializar uma instância da classe DbHelper.
public DBAdapter(Context context) {
dbHelper = new DbHelper(context);
}
Um Context é um handle para o sistema, que fornece serviços como resources, acesso a base de dados e preferências. O contexto da aplicação (application context) é o repositório central para a funcionalidade de todas as aplicações de nível superior no Android. Usa-se este contexto quando queremos aceder a configurações e recursos compartilhados entre as várias janelas (activities) da aplicação.
4.5 – Criar método para criar um novo contacto na base de dados, este irá retornar um objecto Contacto.
public Contacto createContacto(String nome, String email, String telefone, Bitmap foto) {
ContentValues values = new ContentValues();
values.put(DB.NOME, nome);
values.put(DB.EMAIL,email);
values.put(DB.TELEFONE,telefone);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
foto.compress(Bitmap.CompressFormat.PNG, 100, baos);
byte[] photo = baos.toByteArray();
values.put(DB.FOTO, photo);
long insertId = database.insert(DB.TABLE_NAME, null, values);
// To show how to query
Cursor cursor = database.query(DB.TABLE_NAME, allColumns, DB.ID + " = " +
insertId, null,null, null, null);
cursor.moveToFirst();
return cursorToContacto(cursor);
}
Os cursores são “apontadores de dados” da base de dados – ou seja, uma interface que permite o acesso aos dados retornados pela query. O objecto ContentValues permite definir os valores a inserir.
4.6 – Método para eliminar um contacto:
public void EliminaContacto (int idContacto){
database.delete(DbHelper.TABLE_NAME, DbHelper.ID + " = " + idContacto,
null);
}
4.7 – Método para devolver um Contacto passando como parâmetro um cursor.
private Contacto cursorToContacto(Cursor cursor) {
byte[] blob = cursor.getBlob(cursor.getColumnIndex(DB.FOTO));
Bitmap bmp = BitmapFactory.decodeByteArray(blob, 0, blob.length);
Contacto contacto = new
Contacto(cursor.getLong(0),cursor.getString(1),cursor.getString(2),
cursor.getString(3),bmp);
return contacto;
}
4.8 – Método para devolver todos os contactos da tabela:
public Cursor getContactos(){
Cursor cursor = database.rawQuery("select _id, nome,telefone,foto from
contactos2", null);
return cursor;
}
4.9 – Método que devolve o contacto passando como parâmetro o id do contacto pretendido:
public Contacto getContacto (int idContacto){
Cursor cursor = database.query(DB.TABLE_NAME, allColumns, DB.ID + " = " +
idContacto, null,null, null, null);
cursor.moveToFirst();
return cursorToContacto(cursor);
}
Terminamos agora a criação das classes auxiliares para trabalhar com a base de dados, no próximo tutorial iremos criar os layouts e utilizar estas classes para guardar os dados na base de dados.