Tutorial: Utilização do sqlite no Android (Parte I)

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.