Home » Android » android – how should I open and close my database properly

android – how should I open and close my database properly

Posted by: admin June 15, 2020 Leave a comment


I have an app which stores some data in a SQLite DB.Also I’m doing a lot of query an requery in my app.I have about 15 activities in it.And almoust all use the DB to query for data.
But what I’m doing is opening my DB in every activity and close it in onDestroy{…} of every activity.

The problem is that onDestroy{…} may never get called and sometimes my app stays on for a long time and I switch from an activity to another opening for to many times my DB.

And sometimes I get errors like-database too many times opened and never closed.

I would try to close my DB exactly after I get my data from it and close it…moving to my next activity and re-opening and so on…..
But the problem is that in some activities I come back from other activities….closing my DB and coming back to that activity would produce a big Force Close.

What I wanna do is open my DB at the beginning of my app and close it at the end of it, but I’m facing 2 problems:

Should I make my SQLiteOpenHelper class a singleton?…get an instance of it..open it in my first activity and then in my following activities just get an instance of my DB which is already opened/???

2.Where is the end of my app????How should I know where is the end of my app and where to close my DB.


public class DBAdapter extends SQLiteOpenHelper {

    public DBAdapter(Context context) {
        super(context, DATABASE_NAME, null, 1);
        this.myContext = context;


    public void openDataBase() throws SQLException {

        String myPath = DATABASE_PATH + DATABASE_NAME;
        db = SQLiteDatabase.openDatabase(myPath, null,



That is a piece of code from my class that manages my DB.To make this singleton I should use a constructor likw this:

private DBAdapter()

//nothing in here


But this is undefined for SQLiteOpenHelper

This is how I did it according with zirael advice:

package com.Server_1;

import android.app.Application;

public class MyApplication extends Application{

private static DBAdapter db;

public void onCreate()

    db=new DBAdapter(getApplicationContext());

public static DBAdapter getDatabaseAdapter()
    return db;


In every activity I where I need DB connection I do this:

MyApplication myApplication = (MyApplication) this.getApplication();

DBAdapter db= myApplication.getDatabaseAdapter();

And finally my manifest looks like:

<application  android:icon="@drawable/icon"  
How to&Answers:

In my app I open connection to database in myApplication class (your custom class that extends Application – it should be named the same as your application in androidManifest).


<application android:label="@string/app_name" 
    android:name="com.mypackage.MyApplication " android:debuggable="true">

MyApplication .java

public class MyApplication extends Application {

    private DatabaseAdapter dbAdapter;

    public void onCreate() {
        dbAdapter = new DatabaseAdapter(getApplicationContext());

And in each class that need db connection I simply use:

MyApplication myApplication = (MyApplication) this.getApplication();
DatabaseAdapter dbAdapter= myApplication.getDatabaseAdapter();

MyApplication is run automatically on every application start. This way I keep only one connection to DB so it’s closed when app is being removed from memory without any problem.


When you retrieve your dbAdapter from you MyApplication class, do it in a lazy fashion, creating it only when needed. In my implementation, I also open it at this time.

public static DbAdapter getDbAdapter() {
    if (dbAdapter == null) {
        dbAdapter = new DbAdapter();
    return dbAdapter;

It is a good idea to use getReadableDatabase() or getWriteableDatabase() in the open method of your database adapter.

Also, I think it works better to retrieve your adapter in onStart() and close it in onStop() of the activities where it is being used, rather than using onCreate() and onDestroy().

protected void onStop() {

And in the MyApp class…

public static void closeDatabase() {


If you are not managing your database in line with Google’s recommendations, why not – there’s usually a good reason why things are the way they are…

In any case, you can use getReadableDatabase() and getWriteableDatabase() – these functions will open the database if necessary, but just return the existing database object if it is already open, thus preventing you from opening the database multiple times.


Something you might try is use a singleton that each activity would attach to in its onResume() callback, and detach from in its onPause() callback. When the detach count reaches zero, set a timer which would get canceled in the attach method. If the timer expires, close the database.


There is a good answer from another question Best place to close database connection

“According to this post by a Google engineer, there’s nothing wrong with leaving the database connection open:

Android made a deliberate design decision that is can seem surprising,
to just give up on the whole idea of applications cleanly exiting and
instead let the kernel clean up their resources. After all, the kernel
needs to be able to do this anyway. Given that design, keeping
anything open for the entire duration of a process’s life and never
closing it is simply not a leak. It will be cleaned up when the
process is cleaned up.

So, for simplicity, I would extend the Application class to provide a single well-defined entry point for your code, and open the database connection in its onCreate(). Store the DB connection as a field in your Application, and provide an accessor method to make the connection available to rest of your code.

Then, don’t worry about closing it.”