Usando seu próprio banco de dados SQLite em aplicações Android

A maioria dos exemplos e tutoriais de aplicações Android por ai assumem que você quer criar e preencher seu banco de dados em tempo de execução e não usará um banco de dados independente com sua aplicação.

O metódo que será mostrado aqui usa um banco de dados SQLite de sua pasta “assets” e copia em um banco de dados no caminho de sua aplicação, de forma que a API SQLiteDatabase possa abrir e acessar o banco normalmente.

1. Preparando o arquivo de banco de dados SQLIte.

Assumindo que você já tem um banco de dados sqlite criado, precisamos fazer algumas modificações nele. Se você não tiver um gerenciador sqlite instalado, recomendo baixar o programa OpenSource SQLite Database Browser disponível para Win/Mac/Linux.

Abra seu banco de dados e adicione uma nova tabela chamada “android_metadata”, executando a seguinte sentença SQL:

CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US')

Agora insira uma única linha com o texto ‘en_US’ na tabela “android_metadata”:

INSERT INTO "android_metadata" VALUES ('en_US')

Depois , é necessário renomear o campo id primário de suas tabelas para “_id” para que o Android saiba qual a chave primária de suas tabelas. Você pode facilmente fazer essas mudanças no SQLite Database Browser pressionando o botão “edit table”, e depois selecionando a tabela que quer editar e finalmente selecionando o campo que quisr renomear.

Depois de renomear o campo id de todas as tabelas para “_id”, e adicionar a tabela “android_metadata”, seu banco de dados está pronto para ser usado em sua aplicação Android.

Nota: na imagem podemos ver as tabelas “Categories” e “Content” com o campo id renomeado para “_id” e a tabela “android_metadata” adicionada.

2. Copiando, abrindo e acessando seu banco de dados em sua aplicação Android.

Agora, coloque o banco de dados na pasta “asset” de seu projeto e crie uma classe Database Helper baseada na calsse SQLIteOpenHelper do pacote “android.database.sqlite”.

Crie a sua classe DatabaseHelper dessa forma:

public class DataBaseHelper extends SQLiteOpenHelper{
 
    //The Android's default system path of your application database.
    private static String DB_PATH = "/data/data/YOUR_PACKAGE/databases/";
 
    private static String DB_NAME = "myDBName";
 
    private SQLiteDatabase myDataBase;
 
    private final Context myContext;
 
    /**
     * Constructor
     * Takes and keeps a reference of the passed context in order to access to the application assets and resources.
     * @param context
     */
    public DataBaseHelper(Context context) {
 
    	super(context, DB_NAME, null, 1);
        this.myContext = context;
    }
 
  /**
     * Creates a empty database on the system and rewrites it with your own database.
     * */
    public void createDataBase() throws IOException{
 
    	boolean dbExist = checkDataBase();
 
    	if(dbExist){
    		//do nothing - database already exist
    	}else{
 
    		//By calling this method and empty database will be created into the default system path
               //of your application so we are gonna be able to overwrite that database with our database.
        	this.getReadableDatabase();
 
        	try {
 
    			copyDataBase();
 
    		} catch (IOException e) {
 
        		throw new Error("Error copying database");
 
        	}
    	}
 
    }
 
    /**
     * Check if the database already exist to avoid re-copying the file each time you open the application.
     * @return true if it exists, false if it doesn't
     */
    private boolean checkDataBase(){
 
    	SQLiteDatabase checkDB = null;
 
    	try{
    		String myPath = DB_PATH + DB_NAME;
    		checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
 
    	}catch(SQLiteException e){
 
    		//database does't exist yet.
 
    	}
 
    	if(checkDB != null){
 
    		checkDB.close();
 
    	}
 
    	return checkDB != null ? true : false;
    }
 
    /**
     * Copies your database from your local assets-folder to the just created empty database in the
     * system folder, from where it can be accessed and handled.
     * This is done by transfering bytestream.
     * */
    private void copyDataBase() throws IOException{
 
    	//Open your local db as the input stream
    	InputStream myInput = myContext.getAssets().open(DB_NAME);
 
    	// Path to the just created empty db
    	String outFileName = DB_PATH + DB_NAME;
 
    	//Open the empty db as the output stream
    	OutputStream myOutput = new FileOutputStream(outFileName);
 
    	//transfer bytes from the inputfile to the outputfile
    	byte[] buffer = new byte[1024];
    	int length;
    	while ((length = myInput.read(buffer))>0){
    		myOutput.write(buffer, 0, length);
    	}
 
    	//Close the streams
    	myOutput.flush();
    	myOutput.close();
    	myInput.close();
 
    }
 
    public void openDataBase() throws SQLException{
 
    	//Open the database
        String myPath = DB_PATH + DB_NAME;
    	myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
 
    }
 
    @Override
	public synchronized void close() {
 
    	    if(myDataBase != null)
    		    myDataBase.close();
 
    	    super.close();
 
	}
 
	@Override
	public void onCreate(SQLiteDatabase db) {
 
	}
 
	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 
	}
 
        // Add your public helper methods to access and get content from the database.
       // You could return cursors by doing "return myDataBase.query(....)" so it'd be easy
       // to you to create adapters for your views.
 
}

E é isso!

Agora você pode criar uma instância da classe DatabaseHelper e chamar os metódos createDataBase() e openDataBase(). Lembre de mudar o texto “YOUR_PACKAGE” para o namespace de sua aplicação (por exemplo: com.exemplename.myapp) na string DB_PATH.

Traduzido de www.reigndesign.com

  • Haroldo

    cara, eu segui passo a passo seu tutorial, mas o emulador dá force close, vc tem como me arranjar um exemplo curto de criação e inserção de bd, para eu poder dar uma estudada?
    Obrigado
    Haroldo Olivieri

    • Olá Haroldo,
      Eu publiquei um artigo anterior a esse que vem com um link para uma aplicação funcional que usa banco de dados. Dá um olhada nesse código que você irá ter uma noção melhor de como funciona os metódos de acesso a BD no Android (você precisará de noções de uso do subversion para obter o código – eu usei o plugin para o Eclipse).

  • Cah_Vitale

    Kleber, eu segui o tutorial e meu banco foi criado, pelo menos não deu erro, porém quando tento acessar as informações de uma tabela e mostrar em um listview, da erro. Você sabe como faço ou teria exemplo de como acessar minha tabela através da criação do banco dessa maneira? Pois eu estou usando a mesmo classe quando acessava apenas pelo emulador e ia normal.

    • klebermo

      Olá, para sanar sua duvida, recomendo dar um a olhada na classe DataHelper nesse artigo, mas especificamente no metodo SelectAll, que mostra como recuperar dados do banco de dados.

      • Cah_Vitale

        Ok, vou dar uma olhada sim. Ontem fiz um debug do meu código e percebi que o myDataBase está Null, mesmo depois de passar pela linha de código myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY); ele continua nulo.
        Outra coisa, cliquei nesse artigo e deu página não encontrada.

  • Cah_Vitale

    Agora abriu o link…vlw…
    A chamada da classe DataBaseHelper eu posso fazer na minha classe inicial? Pois o nulo está vindo dai…não sei como resolver isso….

    • klebermo

      Não vejo problema com isso. Veja se funciona dessa maneira.

  • Pedro Henrique

    Obrigado, ajudou.

  • Eduardo Giullyanny

    eu tentei criar o meu mas ele não encontra o banco de dados.:

    package ws_forca_vendas.josueh.br.vendassigma.factory;

    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteException;
    import android.database.sqlite.SQLiteOpenHelper;
    import android.os.Environment;
    import android.widget.Toast;

    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.sql.SQLException;

    public class Conexao_ extends SQLiteOpenHelper {

    //Caminho do sistema padrão do Android de seu banco de dados de aplicativo.
    private static String DB_PATH = “/storage/emulated/0/wssigma/”;

    private static String DB_NAME = “dados.db”;

    private SQLiteDatabase myDataBase;

    private final Context myContext;

    /**
    * Constructor
    * Captura e mantém uma referência do contexto passado, a fim de aceder aos bens e recursos de aplicativos.
    *
    * @param context
    */
    public Conexao_(Context context) {

    super(context, DB_NAME, null, 1);
    this.myContext = context;
    }

    /**
    * Cria um banco de dados vazio no sistema e reescreve-lo com o seu próprio banco de dados.
    */
    public void createDataBase() throws IOException {

    boolean dbExist = checkDataBase();

    if (dbExist) {
    Toast.makeText(myContext, “Foi encontrado o banco de dados”,Toast.LENGTH_LONG).show();
    } else {

    // Ao chamar esse método e vazio banco de dados será criado no caminho de sistema padrão
    // da sua aplicação assim que nós estamos indo ser capaz de substituir o banco de dados com nosso banco de dados.
    this.getReadableDatabase();

    try {

    copyDataBase();

    } catch (IOException e) {

    throw new Error(“Error copying database”);

    }
    }

    }

    /**
    * Verifique se o banco de dados já existe para evitar re-copiar o arquivo cada vez que você abrir o aplicativo.
    *
    * @return true se ele existe e falso se isso não acontecer
    */
    private boolean checkDataBase() {

    SQLiteDatabase checkDB = null;

    try {
    String myPath = DB_PATH + DB_NAME;
    checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);

    } catch (SQLiteException e) {

    //banco de dados ainda não existe.

    }

    if (checkDB != null) {

    checkDB.close();

    }

    return checkDB != null ? true : false;
    }

    /**
    * Cópias seu banco de dados de sua pasta-ativos locais para o banco de dados vazio recém-criado na
    * pasta do sistema, de onde podem ser acessados e manipulados.
    * Isto é feito através da transferência de fluxo de bytes.
    */
    private void copyDataBase() throws IOException {

    //Abrir db local como o fluxo de entrada
    InputStream myInput = myContext.getAssets().open(DB_NAME);

    // Caminho para o db vazio recém-criado
    String outFileName = DB_PATH + DB_NAME;

    //Abra o banco de dados vazio como o fluxo de saída
    OutputStream myOutput = new FileOutputStream(outFileName);

    //transferir bytes do arquivo de entrada para o arquivo de saída
    byte[] buffer = new byte[1024];
    int length;
    while ((length = myInput.read(buffer)) > 0) {
    myOutput.write(buffer, 0, length);
    }

    //Fechas as correntes
    myOutput.flush();
    myOutput.close();
    myInput.close();

    }

    public void openDataBase() throws SQLException {

    //Abrir o banco de dados
    String myPath = DB_PATH + DB_NAME;
    myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);

    }

    @Override
    public synchronized void close() {

    if (myDataBase != null)
    myDataBase.close();

    super.close();

    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    // Adicionar os seus métodos de ajuda pública para acessar e obter conteúdo do banco de dados.
    // Você poderia retornar cursores fazendo “voltar myDataBase.query (….)”, de modo que seria fácil
    // Para você para criar adaptadores para os seus pontos de vista.

    }

    package ws_forca_vendas.josueh.br.vendassigma.factory;

    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;

    public class Factory {

    private static SQLiteDatabase conn;
    private static Conexao_ conexao;

    public static SQLiteDatabase getConn(Context context) throws Exception {

    if (conexao == null) {
    conexao = new Conexao_(context);
    }
    conexao.createDataBase();
    conexao.openDataBase();

    conn = conexao.getWritableDatabase();

    return conn;
    }
    }

    eu coloquei um Toast no openDatabase e ele aparece.