onupgrade - sqliteopenhelper android studio

La conexión de SQLite se filtró aunque todo cerró

Question

Encontré muchas cosas como close the connection y close the cursor , pero hago todas estas cosas. Todavía la conexión SQLite se filtra y recibo una advertencia como esta:

A SQLiteConnection object for database was leaked!

Tengo un administrador de base de datos esto, al que llamo en mis actividades con el siguiente código:

DatabaseManager dbm = new DatabaseManager(this);

El código de mi clase de administrador de base de datos sigue ahora:

public class DatabaseManager {

    private static final int DATABASE_VERSION = 9;
    private static final String DATABASE_NAME = "MyApp";
    private Context context = null;
    private DatabaseHelper dbHelper = null;
    private SQLiteDatabase db = null;


    public static class DatabaseHelper extends SQLiteOpenHelper {

         public DatabaseHelper(Context context) {
             super(context, DATABASE_NAME, null, DATABASE_VERSION);
         }

         @Override
         public void onCreate(SQLiteDatabase db) {

                   //create database tables
         }

         @Override
         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
                      //destroy and recreate them
         }

     }

     public DatabaseManager(Context ctx) {
         this.context = ctx;
     }

    private DatabaseManager open() throws SQLException {
        dbHelper = new DatabaseHelper(context);
        db = dbHelper.getWritableDatabase();

        if (!db.isReadOnly()) {
            db.execSQL("PRAGMA foreign_keys = ON;");
        }

        return this;
    }

    private void close() {
        dbHelper.close();
    }
}

Cuando llamo a un método de base de datos, hago lo siguiente:

public Object getData() {

    open();

            //... database operations take place ...

    close();

    return data;
}

Pero como dije, todavía tengo esta conexión de SQLite filtrada de advertencia.

¿Qué estoy haciendo mal?

Answer 1

La fuente en negrita en la cita corresponde a esta parte en su código:

private DatabaseManager open() throws SQLException {
    dbHelper = new DatabaseHelper(context);
    db = dbHelper.getWritableDatabase();

desde: http://www.androiddesignpatterns.com/2012/05/correctly-managing-your-sqlite-database.html

Método n. ° 1: utilice una fábrica abstracta para crear instancias del SQLiteOpenHelper

Declare su ayudante de base de datos como una variable de instancia estática y use el patrón Abstract Factory para garantizar la propiedad singleton. El código de muestra a continuación le dará una buena idea de cómo diseñar correctamente la clase DatabaseHelper.

El método estático de fábrica getInstance garantiza que solo un DatabaseHelper existirá en un momento dado. Si el objeto mInstance no se ha inicializado, se creará uno. Si ya se ha creado uno, simplemente se devolverá.

No debe inicializar su objeto auxiliar utilizando el new DatabaseHelper(context) .
En su lugar, siempre use DatabaseHelper.getInstance(context) , ya que garantiza que solo existirá un helper de base de datos en todo el ciclo de vida de la aplicación.

public static class DatabaseHelper extends SQLiteOpenHelper { 

  private static DatabaseHelper mInstance = null;

  private static final String DATABASE_NAME = "database_name";
  private static final String DATABASE_TABLE = "table_name";
  private static final int DATABASE_VERSION = 1;

  public static DatabaseHelper getInstance(Context ctx) {

    // Use the application context, which will ensure that you 
    // don''t accidentally leak an Activity''s context.
    // See this article for more information: http://bit.ly/6LRzfx
    if (mInstance == null) {
      mInstance = new DatabaseHelper(ctx.getApplicationContext());
    }
    return mInstance;
  }

  /**
   * Constructor should be private to prevent direct instantiation.
   * make call to static factory method "getInstance()" instead.
   */
  private DatabaseHelper(Context ctx) {
    super(ctx, DATABASE_NAME, null, DATABASE_VERSION);
  }
}

Answer 2

private void method() {
        Cursor cursor = query();
        if (flag == false) {  // WRONG: return before close()
            return;
        }
        cursor.close();
   }

La buena práctica debería ser así:

    private void method() {
        Cursor cursor = null;
        try {
            cursor = query();
        } finally {
            if (cursor != null)
                cursor.close();  // RIGHT: ensure resource is always recovered
        }
    }