SQLite android: java.lang.IllegalStateException: The database 'database' is not open [RESOLVIDO]

Olá como viram no titulo o SQL fica dando esse erro. O app nao da crash e carrega as
informaçoes normalmente mais no terminal eu fico vendo esse erro. Abaixo esta o CRUD.


CREATE: cria as tabelas se elas nao existirem

package CRUD;

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

 public class Create extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Create instancia = null;

public static Create getInstancia(Context context) {
    if (instancia == null) {
        instancia = new Create(context);
    }
    return instancia;
}

private Create(Context context) {
    //toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
    super(context, NOME_BASE, null, VERSAO_BASE);
}

@Override
public void onCreate(SQLiteDatabase db) {

}

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

}

/**
 * Cria a tabela de debitos fixos
 */
public void createDebitoFixoTable() {
    SQLiteDatabase db = getWritableDatabase();
    String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + DEBITOFIXO_TABLE + "("
            + "ID TEXT,"
            + "VALOR TEXT,"
            + "DATA TEXT,"
            + "OBSERVACAO TEXT,"
            + "QUITADO INTEGER,"
            + "FIXO INTEGER,"
            + "FOLHA TEXT,"
            + "CATEGORIA TEXT,"
            + "N_ID TEXT"
            + ")";
    db.execSQL(SQLCreateTabelaFdebito);
    db.close();
}

/**
 * Cria a tabela de debitos fixos
 */
public void createDebitosTable() {
    SQLiteDatabase db = getWritableDatabase();
    String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + DEBITOS_TABLE + "("
            + "ID TEXT,"
            + "VALOR TEXT,"
            + "DATA TEXT,"
            + "OBSERVACAO TEXT,"
            + "QUITADO INTEGER,"
            + "FIXO INTEGER,"
            + "FOLHA TEXT,"
            + "CATEGORIA TEXT,"
            + "N_ID TEXT"
            + ")";
    db.execSQL(SQLCreateTabelaFdebito);
    db.close();
    System.out.println("Create.createDebitosTable");
}

public void createFolhasTabela() {
    SQLiteDatabase db = getWritableDatabase();
    String SQLCreateTabelaFdebito = "CREATE TABLE IF NOT EXISTS " + FOLHAS_TABLE + "("
            + "NOME_FOLHA TEXT,"
            + "MES_FOLHA TEXT,"
            + "RENDA_FOLHA TEXT"
            + ")";
    db.execSQL(SQLCreateTabelaFdebito);
    db.close();
}

/**
 * Cria a tabela de FOLHAS
 */
public void createCOnfTable() {
    SQLiteDatabase db = getWritableDatabase();
    String sqlCreateTabelaLivro = "CREATE TABLE IF NOT EXISTS " + CONFIGURAÇAO_TABLE + "("
            + "ID INTEGER,"
            + "CONFVAL TEXT"
            + ")";
    db.execSQL(sqlCreateTabelaLivro);
    db.close();

}
}


DB_Names: contem as constatantes do database

package CRUD;

 /**
 * Created by Gilian Marques on 11/11/2016.
 */

public class DB_Names {

private static DB_Names instancia = null;

public static DB_Names getInstancia() {
    if (instancia == null) {
        instancia = new DB_Names();
    }
    return instancia;
}


public static final String NOME_BASE = "DRDB";
public static final int VERSAO_BASE = 1;
public static final int CONF_ID = 1;
public static final String FOLHAS_TABLE = "FOLHAS";
public static final String DEBITOFIXO_TABLE = "DEBITOS_FIXOS";
public static final String DEBITOS_TABLE = "DEBITOS";
public static final String CONFIGURAÇAO_TABLE = "CONFIGURACOES";

}


DELETE : apaga os dados das tabelas

package CRUD;

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

import objetos.debito;
objetos.folha;

public class Delete extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE= DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;    private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;

private static final String DEBITOFIXO_TABLE= DB_Names.DEBITOFIXO_TABLE;
private static Delete instancia = null;

public static Delete getInstancia(Context context) {
    if (instancia == null) {
        instancia = new Delete(context);
    }
    return instancia;
}

private Delete(Context context) {
    //toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
    super(context, NOME_BASE, null, VERSAO_BASE);
}

@Override
public void onCreate(SQLiteDatabase db) {

}

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

}

/**
 * remove o debito fixo que bate com a id recebida
 *
 * @param nome o nome do debito que deve ser removido
 * @return TRUE se tudo ocorreu bem, isso n quer dizer que o debito foi removido pois pode ser que o debito
 * recebido n exista na tabela e isso nao gera um erro. FALSE se houver algum erro.
 */
public boolean removeDebitoFixo(String nome) {
    SQLiteDatabase db = getWritableDatabase();
    try {
        db.delete(DEBITOFIXO_TABLE, "ID = '" + nome + "'", null);
        System.out.println("Create.removeDebitoFixo  ddbHelper   debito fixo removido " + nome);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("Create.removeDebitoFixo  ddbHelper   debito fixo NAO removido " + nome);

        return false;
    } finally {
        db.close();
    }
}

/**
 * remove o debito  que bate com a id recebida
 *
 * @param nome o nome do debito que deve ser removido
 * @return TRUE se tudo ocorreu bem. FALSE se houver algum erro.
 */
public boolean removeDebito(String nome, folha f) {
    SQLiteDatabase db = getWritableDatabase();
    try {
        db.delete(DEBITOS_TABLE, "ID = '" + nome + "'", null);
        System.out.println("Create.removeDebito  ddbHelper   debito removido " + nome + " da folha " + f.getIdentificaçao());
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("Create.removeDebito   ddbHelper   debito NAO removido " + nome + " da folha " + f.getIdentificaçao());
        return false;
    } finally {
        db.close();
    }
}

/**
 * remove a folha do banco de dados: Remove a tabela correspondente a folha
 * depois apaga o nome da folha da tabela de nomes
 *
 * @param nomeFolha o nome que sera usado para localizar a tabela e o registro na
 *                  tabela de nomes
 * @return TRUE se tudo ocorreu bem FALSE se houve algum erro
 */
public boolean RemoveFolha(String nomeFolha) {
    System.out.println("Create.RemoveFolha");
    SQLiteDatabase db = getWritableDatabase();
    try {
        //removendo tabela
        String sqlDropTabelaLivros = "DROP TABLE " + nomeFolha.replace(" ", "_");
        db.execSQL(sqlDropTabelaLivros);
        //removendo nome  da tala de folhas
        try {
            db.delete(FOLHAS_TABLE, "NOME_FOLHA = '" + nomeFolha + "'", null);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            db.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
    System.out.println("Create.RemoveFolha  folha removida " + nomeFolha);
    return true;
}


}

READ : obtem os dados do DB

package CRUD;

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

import java.util.ArrayList;

import main.splashScreen;
import objetos.debito;
import objetos.folha;

public class Read extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Read instancia = null;

public static Read getInstancia(Context context) {
    if (instancia == null) {
        instancia = new Read(context);
    }
    return instancia;
}

private Read(Context context) {
    super(splashScreen.context, NOME_BASE, null, VERSAO_BASE);
}

@Override
public void onCreate(SQLiteDatabase db) {

}

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

}

/**
 * obtem a configuraçao atual do app
 *
 * @return NULL se nao houver configuraçao caso haja, retorna UMA STRING com as configuraçoes
 * checa atraves da checagem da primeira configuraçao, se for
 * invalida retorna null se for valida retorna a configuraçao (STRING)
 */
public String getConfiguraçao() {
    System.out.println("Read.getConfiguraçao");
    SQLiteDatabase db = getReadableDatabase();
    String SQLgetAllDebios = "SELECT * FROM " + CONFIGURAÇAO_TABLE;
    String configuraçoes = null;
    Cursor c = db.rawQuery(SQLgetAllDebios, null);
    if (c.moveToFirst()) {
        configuraçoes = c.getString(1);
    }
    db.close();
    if (configuraçoes.equals("")) {
        return null;
    }
    return configuraçoes;
}

/**
 * retorna uym arrayList com  todas as folhas (OBJETO) cadastradas no banco de dados
 * OS NOMES RETORNADOS SAO DAS FOLHAS E NAO DAS TABELAS
 *
 * @return null se o tamanho do array for menor ou igual  a 0
 */
public ArrayList<folha> getTodasFolhas() {
    System.out.println("Read.getTodasFolhas");
    ArrayList<folha> array = new ArrayList<>();
    SQLiteDatabase db = getReadableDatabase();
    String sqlSelectTodosLivros = "SELECT * FROM " + FOLHAS_TABLE + "";
    Cursor c = db.rawQuery(sqlSelectTodosLivros, null);

    if (c.moveToFirst()) {
        do {
            folha f = new folha();
            f.setIdentificaçao(c.getString(0));
            f.setMes(c.getString(1));
            f.setRenda(c.getString(2));
            array.add(f);
        } while (c.moveToNext());
    }
    db.close();

    if (array.size() <= 0) {
        return null;

    } else {
        return array;
    }
}

/**
 * @param nome a id da folha que sera obtida
 * @return a folha que bate com oo nome recebido ou NULL se nao houver essa folha ou em caso de erro
 */
public folha getFolha(String nome) {
    System.out.println("Read.getFolha");
    ArrayList<folha> array = new ArrayList<>();
    SQLiteDatabase db = getReadableDatabase();
    String sqlSelectTodosLivros = "SELECT * FROM " + FOLHAS_TABLE + "";
    Cursor c = db.rawQuery(sqlSelectTodosLivros, null);

    if (c.moveToFirst()) {
        do {
            if (c.getString(0).equals(nome)) {
                folha f = new folha();
                f.setIdentificaçao(c.getString(0));
                f.setMes(c.getString(1));
                f.setRenda(c.getString(2));
                db.close();
                return f;
            }
        }
        while (c.moveToNext());
    }
    return null;
}



/**
 * poe os debitos da folha recebida num ArrayList e a retorna
 *
 * @param f
 * @return
 */
public void getDebitos(folha f) {
    SQLiteDatabase db = getReadableDatabase();
    ArrayList<debito> DBDeb = new ArrayList<>();
    ArrayList<debito> DBDeb2 = new ArrayList<>();
    String SQLgetAllDebios = "SELECT * FROM " + DEBITOS_TABLE;
    Cursor c = db.rawQuery(SQLgetAllDebios, null);
    int i = 0;
    if (c.moveToFirst()) {
        do {
            if (c.getString(6).equals(f.getIdentificaçao())) {
                debito d = new debito();
                d.setIdentificaçao(c.getString(0));
                d.setValor(c.getString(1));
                d.setDataDePagamento(c.getString(2));
                d.setObservaçao(c.getString(3));
                d.setQuitado(Boolean.parseBoolean(c.getString(4)));
                d.setFixo(Boolean.parseBoolean(c.getString(5)));
                d.setFolha((c.getString(6)));  // 0 ?
                d.setCategoria(c.getString(7));
                d.setId(c.getString(7));
                DBDeb2.add(d);
                i++;
            }
        } while (c.moveToNext());
    }
    for (int j = DBDeb2.size()-1; j >= 0; j--) {
        DBDeb.add(DBDeb2.get(j));
    }


    System.out.println("Read.getDebitos " + i + " debitos inseridos em  " + f.getIdentificaçao());
    db.close();
    f.setDebitos(DBDeb);
}

/**
 * Obtem os debitos fixos registrados no banco de dados
 *
 * @return todos os debitos fixos em um ArrayList
 */
public ArrayList<debito> getAllDebitosFixos() {
    System.out.println("Read.getAllDebitosFixos");
    ArrayList<debito> listDebitos = new ArrayList<>();
    SQLiteDatabase db = getReadableDatabase();
    String SQLgetAllDebios = "SELECT * FROM " + DEBITOFIXO_TABLE;
    Cursor c = db.rawQuery(SQLgetAllDebios, null);
    if (c.moveToFirst()) {
        do {
            //checo se a id esta vazia, se n estiver entao prossigo
            if (c.getString(1) != null) {
                debito d = new debito();
                d.setIdentificaçao(c.getString(0));
                d.setValor(c.getString(1));
                d.setDataDePagamento(c.getString(2));
                d.setObservaçao(c.getString(3));
                d.setQuitado(Boolean.parseBoolean(c.getString(4)));
                d.setFixo(Boolean.parseBoolean(c.getString(5)));
                d.setFolha((c.getString(6)));  // 0 ?
                d.setCategoria(c.getString(7));
                d.setId(c.getString(7));
                listDebitos.add(d);
            }
        } while (c.moveToNext());
    }

    db.close();
    return listDebitos;
 }

}

UPDATE : inseri novos dados e atualiza os dados ja existentes

package CRUD;

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

import main.splashScreen;
import objetos.debito;
import objetos.folha;

public class Update extends SQLiteOpenHelper {
private static final String NOME_BASE = DB_Names.NOME_BASE;
private static final int VERSAO_BASE = DB_Names.VERSAO_BASE;
private static final int CONF_ID = DB_Names.CONF_ID;
private static final String DEBITOS_TABLE = DB_Names.DEBITOS_TABLE;

private static final String FOLHAS_TABLE = DB_Names.FOLHAS_TABLE;
private static final String DEBITOFIXO_TABLE = DB_Names.DEBITOFIXO_TABLE;
private static final String CONFIGURAÇAO_TABLE = DB_Names.CONFIGURAÇAO_TABLE;
private static Update instancia = null;

public static Update getInstancia(Context context) {
    if (instancia == null) {
        instancia = new Update(splashScreen.context);
    }
    return instancia;
}

private Update(Context context) {
    //toda vez que essa classe é instanciada ela checa se as tabelas exitem e as cria se necessario
    super(context, NOME_BASE, null, VERSAO_BASE);
}

@Override
public void onCreate(SQLiteDatabase db) {

}

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

}


/**
 * Escreve no banco de dados as configuraçoes contidas em C
 *
 * @param c a configuraçao atual que sera salva
 */
public boolean setConfiguraçoes(String c) {
    System.out.println("Create.setConfiguraçoes");
    SQLiteDatabase db = getWritableDatabase();
    String where = "ID" + "='" + CONF_ID + "'";

    ContentValues cv = new ContentValues();
    cv.put("ID", CONF_ID);
    cv.put("CONFVAL", c);

    try {
        db.update(CONFIGURAÇAO_TABLE, cv, where, null);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}

/**
 * seta a configuraçao do app pela primeira vez
 * a diferença desse metodo é que ele n substitui a configuraçao salva,
 * ele adiciona uma linha de configuraçao
 * <p>
 * DEVE SER CHAMADO APENAS QUANDO UMA NOVA CONFIGURAÇAO
 * FOR CRIADA, OQUE SÓ DEVE ACONTECER QUANDO O APP FOR ABERTO PELA PRIMEIRA VEZ.
 *
 * @param c a configuraçao a ser salva
 */
public void setPrimeiraConf(String c) {
    System.out.println("Create.setPrimeiraConf");
    SQLiteDatabase db = getWritableDatabase();
    ContentValues cv = new ContentValues();
    cv.put("ID", CONF_ID);
    cv.put("CONFVAL", c);
    db.insert(CONFIGURAÇAO_TABLE, null, cv);
    db.close();
}

public boolean addFolha(folha f) {
    SQLiteDatabase db = getWritableDatabase();
    try {
        ContentValues cv = new ContentValues();
        cv.put("NOME_FOLHA", f.getIdentificaçao());
        cv.put("MES_FOLHA", f.getMes());
        cv.put("RENDA_FOLHA", f.getRenda());
        db.insert(FOLHAS_TABLE, null, cv);
        db.close();
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * adiciona debitos    no banco passado como parametro
 *
 * @param d
 * @param
 */
public void addDebito(debito d) {
    SQLiteDatabase db = getWritableDatabase();
    ContentValues cv = new ContentValues();
    cv.put("ID", d.getIdentificaçao());
    cv.put("VALOR", d.getValor());
    cv.put("DATA", d.getDataDePagamento());
    cv.put("OBSERVACAO", d.getObservaçao());
    cv.put("QUITADO", d.isQuitado());
    cv.put("FIXO", false);
    cv.put("FOLHA", d.getFolha());
    cv.put("CATEGORIA", d.getCategoria());
    cv.put("N_ID", d.getId());
    db.insert(DEBITOS_TABLE, null, cv);
    System.out.println("Update.addDebito  adiconando debito " + d.getIdentificaçao());
    db.close();
    return;
}

/**
 * adiciona o debitoFixo no banco de debitos fixos
 *
 * @param d O debito que sera adicionado
 * @return TRUE se tudo deu certo, FALSE se houve algum erro.
 */
public boolean addDebitoFixo(debito d) {
    SQLiteDatabase db = getWritableDatabase();

    ContentValues cv = new ContentValues();
    cv.put("ID", d.getIdentificaçao());
    cv.put("VALOR", d.getValor());
    cv.put("DATA", d.getDataDePagamento());
    cv.put("OBSERVACAO", d.getObservaçao());
    cv.put("QUITADO", d.isQuitado());
    cv.put("FIXO", d.isFixo());
    cv.put("FOLHA", d.getFolha());
    cv.put("CATEGORIA", d.getCategoria());
    cv.put("N_ID", d.getId());

    try {
        db.insert(DEBITOFIXO_TABLE, null, cv);
        System.out.println("Create.addDebitoFixo adicionando debito fixo " + d.getIdentificaçao());
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}

/**
 * recebe o debito editado a id ( que servira pra saber qual debito no banco de dados sera
 * atualizada.
 *
 * @param DebID A id original do debito
 * @param d     o novo debito que ira substituir o debito igual a id recebida
 */
public boolean updateDebito(String DebID, debito d) {
    SQLiteDatabase db = getWritableDatabase();
    String where = "N_ID" + "='" + DebID + "'";
    ContentValues cv = new ContentValues();
    cv.put("ID", d.getIdentificaçao());
    cv.put("VALOR", d.getValor());
    cv.put("DATA", d.getDataDePagamento());
    cv.put("OBSERVACAO", d.getObservaçao());
    cv.put("QUITADO", d.isQuitado());
    cv.put("FIXO", d.isFixo());
    cv.put("FOLHA", d.getFolha());
    cv.put("CATEGORIA", d.getCategoria());
    cv.put("N_ID", d.getId());
    try {
        db.update(DEBITOS_TABLE, cv, where, null);
        System.out.println("Create.updateDebito  debito atualizado de " + DebID + " para " + d.getIdentificaçao());
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}

/**
 * quando a folhe é edita esse metodo é chamado para editar a
 * propriedade folha de cada debito para que nao se percam
 *
 * @param oldNomeFolha  o nome antigo da folha que sera subistituido
 * @param novoNomeFolha o nome  da folha que sera usado para atualizar os debitos
 */
public boolean updateDebitoFolha(String oldNomeFolha, String novoNomeFolha) {
    SQLiteDatabase db = getWritableDatabase();
    String where = "FOLHA" + "='" + oldNomeFolha + "'";
    ContentValues cv = new ContentValues();
    cv.put("FOLHA", novoNomeFolha);
    try {
        db.update(DEBITOS_TABLE, cv, where, null);
        System.out.println("Update.updateDebitoFolha");
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}

/**
 * altera o  registro da folha no banco de dados
 *
 * @param f        folha que contem os novos registros
 * @param oldFolha id da antiga folha
 */
public boolean updateFolha(folha f, String oldFolha) {
    SQLiteDatabase db = getWritableDatabase();
    String where = "NOME_FOLHA" + "='" + oldFolha + "'";
    ContentValues cv = new ContentValues();
    cv.put("NOME_FOLHA", f.getIdentificaçao());
    cv.put("MES_FOLHA", f.getMes());
    cv.put("RENDA_FOLHA", f.getRenda());

    try {
        db.update(DEBITOS_TABLE, cv, where, null);
        System.out.println("Create.updateDebito  debito atualizado de " + oldFolha + " para " + f.getIdentificaçao());
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}

/**
 * recebe o debito editado o a id (nome) que servira pra saber qual debito no banco de dados sera
 * atualizado.
 *
 * @param oldNome o nome original do debito (o nome do debito antes dele ser editado)
 * @param d       o novo debito que ira substituir o debito igual a id recebida
 */
public boolean editDebitoFixo(String oldNome, debito d) {
    SQLiteDatabase db = getWritableDatabase();
    String where = "ID" + "='" + oldNome + "'";
    ContentValues cv = new ContentValues();
    cv.put("ID", d.getIdentificaçao());
    cv.put("VALOR", d.getValor());
    cv.put("DATA", d.getDataDePagamento());
    cv.put("OBSERVACAO", d.getObservaçao());
    cv.put("QUITADO", d.isQuitado());
    cv.put("FIXO", d.isFixo());
    cv.put("FOLHA", d.getFolha());
    cv.put("CATEGORIA", d.getCategoria());
    cv.put("N_ID", d.getId());
    try {
        db.update(DEBITOFIXO_TABLE, cv, where, null);
        System.out.println("Create.editDebitoFIXO  debito fixo atualizado de " + oldNome + " para " + d.getIdentificaçao());
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    } finally {
        db.close();
    }
}


}

É isso, preciso saber o porque desse erro e como corrigi-lo, Obg.


AQUI ESTA O REGISTRO DO ANDROID STUDIO


I/System.out: Create.createDebitosTable
I/System.out: Read.getConfiguraçao
I/System.out: Read.getTodasFolhas
I/System.out: Read.getFolha
I/System.out: %%% nome da folha que esta sendo salva como de boot F3°
I/System.out: Create.setConfiguraçoes
I/System.out: Read.getDebitos 1 debitos inseridos em F3

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database
’/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)
E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)
I/System.out: Read.getDebitos 1 debitos inseridos em F3
I/System.out: Read.getAllDebitosFixos
I/System.out: Read.getDebitos 1 debitos inseridos em F3
I/System.out: debitosAdapter.updatemList atualizando mList
I/System.out: Read.getDebitos 1 debitos inseridos em F3

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)
E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)

E/System: Uncaught exception thrown by finalizer
E/System: java.lang.IllegalStateException: The database ‘/data/user/0/com.gilianmarques.dev.debitreminder/databases/DRDB’ is not open.
at android.database.sqlite.SQLiteDatabase.throwIfNotOpenLocked(SQLiteDatabase.java:2169)
at android.database.sqlite.SQLiteDatabase.createSession(SQLiteDatabase.java:365)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:84)
at android.database.sqlite.SQLiteDatabase$1.initialValue(SQLiteDatabase.java:83)
at java.lang.ThreadLocal$Values.getAfterMiss(ThreadLocal.java:430)
at java.lang.ThreadLocal.get(ThreadLocal.java:65)
at android.database.sqlite.SQLiteDatabase.getThreadSession(SQLiteDatabase.java:359)
at android.database.sqlite.SQLiteProgram.getSession(SQLiteProgram.java:101)
at android.database.sqlite.SQLiteQuery.setLastStmt(SQLiteQuery.java:96)
at android.database.sqlite.SQLiteQuery.close(SQLiteQuery.java:111)
at android.database.sqlite.SQLiteCursor.close(SQLiteCursor.java:300)
at android.database.sqlite.SQLiteCursor.finalize(SQLiteCursor.java:366)
at java.lang.Daemons$FinalizerDaemon.doFinalize(Daemons.java:202)
at java.lang.Daemons$FinalizerDaemon.run(Daemons.java:185)
at java.lang.Thread.run(Thread.java:818)

Após alguns estudos resolvi meu problema: Deve-se abrir o banco antes de usar e fecha-lo assim que acabar e para as operaçoes de leitura onde se obtem getWritableDatabase(); deve-se sempre fechar o cursor com cursor.close();

aqui esta o codigo:

public String getConfiguraçao() {
    openDB();  // vejo se é necessario abrir o DB
    System.out.println("Read.getConfiguraçao");
    String SQLgetAllDebios = "SELECT * FROM " + CONFIGURAÇAO_TABLE;
    String configuraçoes = null;
    Cursor c = db.rawQuery(SQLgetAllDebios, null);
    if (c.moveToFirst()) {
        configuraçoes = c.getString(1);
    }
    c.close();  // fecho o cursor pra evitar um SQLiteConnection leaked
    closeDB();  // fecho o DB
    return configuraçoes;
}

 private void openDB() {
    if (!db.isOpen()) {
        System.out.println("DB foi  berto");
        db = mContext.openOrCreateDatabase("caminho para o seu DB", SQLiteDatabase.OPEN_READWRITE, null);
    } else {
        System.out.println("DB ja estava aberto");
    }
}

private void closeDB() {
    db.close();
}