Android AsyncTask y SQLite DB instancia

Question

Tengo un problema y no estoy seguro de cómo abordarlo. Una actividad en mi aplicación tiene múltiples AsyncTask que tienen acceso al número SQLiteOpenHelper. Inicializo y abrí el ayudante en onCreate() y lo estoy cerrando en onStop(). También compruebo si se ha inicializado en onResume().

Desde que publiqué mi aplicación, recibí varios errores con la excepción de nulo en doInBackground donde trato de acceder al asistente de DB. Sé que esto sucede porque el DB está cerrado (onStop()) justo antes de llamar al doInBackground, es suficiente.

Mi pregunta es, ¿dónde debo cerrar la conexión DB? ¿Es correcto usar una instancia única del ayudante DB en la Actividad y acceder a ella desde múltiples hilos (AsyncTasks)? ¿O debería usar una instancia auxiliar DB separada para cada AsyncTask?

Este es un esqueleto simplificada de mi actividad:

public class MyActivity extends Activity{ 
    private DbHelper mDbHelper; 
    private ArrayList<ExampleObject> objects; 

    @Override 
    public void onStop(){ 
     super.onStop(); 
     if(mDbHelper != null){ 
      mDbHelper.close(); 
      mDbHelper = null; 
     } 
    } 

    @Override 
    public void onResume(){ 
     super.onResume(); 
     if(mDbHelper == null){ 
      mDbHelper = new DbHelper(this); 
      mDbHelper.open(); 
     } 
    } 

    @Override 
    public void onCreate(Bundle icicle) { 
     super.onCreate(icicle); 
     DbHelper mDbHelper = new DbHelper(this); 
     mDbHelper.open(); 
    } 

    private class DoSomething extends AsyncTask<String, Void, Void> { 

     @Override 
     protected Void doInBackground(String... arg0) { 
      objects = mDbHelper.getMyExampleObjects(); 
      return null; 
     } 

     @Override 
     protected void onPostExecute(final Void unused){ 
      //update UI with my objects 
     } 
    } 

    private class DoSomethingElse extends AsyncTask<String, Void, Void> { 

     @Override 
     protected Void doInBackground(String... arg0) { 
      objects = mDbHelper.getSortedObjects(); 
      return null; 
     } 

     @Override 
     protected void onPostExecute(final Void unused){ 
      //update UI with my objects 
     } 
    } 
} 

Answer 1

Mencionó que cancela la AsyncTask antes de cerrar la base de datos. Pero debe tener en cuenta que cancelar la AsyncTask simplemente indica que la tarea debe cancelarse y usted necesita verificar isCancelled() en doInBackground() y hacer lo necesario para detener las operaciones de DB.

Antes de cerrar la base de datos, debe verificar getStatus() para asegurarse de que la tarea AsyncTask se haya detenido.

Answer 2

Es bueno utilizar una sola DB Helper. El problema es que cuando el usuario abandona el Activity, el DB está cerrado, pero el AsyncTask aún se puede ejecutar. Por lo tanto, debe verificar que el DB no sea nulo cuando intente acceder a él, y si es null, esto puede significar que su Activity se destruyó y cancel esa tarea.

Answer 3

No necesita administrar la conexión db para cada actividad. Puede hacerlo en una instancia de android.app.Application y acceder a db utilizando esta instancia. Algo como esto:

public class MyApplication extends Application { 

    // Synchronized because it's possible to get a race condition here 
    // if db is accessed from different threads. This synchronization can be optimized 
    // thought I wander if it's necessary 
    public synchronized static SQLiteDatabase db() { 
     if(self().mDbOpenHelper == null) { 
      self().mDbOpenHelper = new MyDbOpenHelper(); 
     } 
     return self().mDbOpenHelper.getWritableDatabase(); 
    } 

    public static Context context() { 
     return self(); 
    } 

    @Override 
    public void onCreate() { 
     super.onCreate(); 
     mSelf = this; 
    } 

    private static MyApplication self() { 
     if (self == null) throw new IllegalStateException(); 
     return mSelf; 
    } 

    private MyDbOpenHelper mDbOpenHelper; 

    private static MyApplication mSelf; 
} 

De esta manera usted puede estar seguro de que DB es siempre accesible.

Y sí, tener una instancia de Db helper es una buena práctica. La sincronización de subprocesos está hecha para usted de manera predeterminada.