Android SQLite architecture for a task list

Question

I'm writing a simple Android app with a database and am trying to make the right architecture for accessing a database.

MainActivity.java

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void onSubmitClick(View view) {
        EditText editTextTitle = (EditText) findViewById(R.id.task_title);
        EditText editTextDescription = (EditText) findViewById(R.id.task_description);

        TaskHelper taskHelper = new TaskHelper(getApplicationContext());
        long taskId = taskHelper.insertTask(
                new Task(editTextTitle.getText().toString(), editTextDescription.getText().toString())
        );

        if (taskId > 0) {
            Toast.makeText(getApplicationContext(), "Task added.", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(getApplicationContext(), "Something went wrong.", Toast.LENGTH_SHORT).show();
        }
    }
}

TaskHelper.java

public class TaskHelper {

    private DatabaseHelper databaseHelper;
    private SQLiteDatabase sqLiteDatabase;

    public TaskHelper(Context context) {
        this.databaseHelper = new DatabaseHelper(context);
        this.sqLiteDatabase = databaseHelper.getWritableDatabase();
    }

    public long insertTask(Task task) {
        ContentValues contentValues = new ContentValues();
        contentValues.put(DatabaseContract.TaskTable.COLUMN_NAME_TITLE, task.getTaskTitle());
        contentValues.put(DatabaseContract.TaskTable.COLUMN_NAME_DESCRIPTION, task.getTaskDescription());

        return this.sqLiteDatabase.insert(
                DatabaseContract.TaskTable.TABLE_NAME,
                null,
                contentValues);
    }
}

DatabaseHelper.java

public class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "Notes.db";
    private static final int DATABASE_VERSION = 1;

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

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(DatabaseContract.TaskTable.CREATE_DATABASE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL(DatabaseContract.TaskTable.DELETE_DATABASE);
    }
}

DatabaseContract.java

public final class DatabaseContract {

    // To prevent someone from accidentally instantiating the contract class,
    // give it an empty constructor.
    private DatabaseContract() {}

    // Inner class that defines table schema
    public static abstract class TaskTable implements BaseColumns {

        public static final String TABLE_NAME = "task";
        public static final String COLUMN_NAME_TASK_ID = "_id";
        public static final String COLUMN_NAME_TITLE = "title";
        public static final String COLUMN_NAME_DESCRIPTION = "description";

        public static final String CREATE_DATABASE =
                "CREATE TABLE " + TABLE_NAME + " ("
                + TaskTable.COLUMN_NAME_TASK_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
                + TaskTable.COLUMN_NAME_TITLE + " TEXT,"
                + TaskTable.COLUMN_NAME_DESCRIPTION + " TEXT);";

        public static final String DELETE_DATABASE =
                "DROP TABLE IF EXIST " + TaskTable.TABLE_NAME;
    }

}

Task.java

public class Task {

    private int taskId;
    private String taskTitle;
    private String taskDescription;

    public Task(String title, String description) {
        this.taskTitle = title;
        this.taskDescription = description;
    }

    public Task(int id, String title, String description) {
        this.taskId = id;
        this.taskTitle = title;
        this.taskDescription = description;
    }

    public int getTaskId() {
        return taskId;
    }

    public String getTaskTitle() {
        return taskTitle;
    }

    public String getTaskDescription() {
        return taskDescription;
    }
}

My vision is to have helper classes for every table in the database. With that approach I want to reduce code in activity methods and separate UI from logic. Primary, I'm looking for architecture improvements but any other is also welcome.

Answer 1

I don't have any comments on the architecture, but here are 2 suggestions:

1. To keep database access thread-safe, I would suggest you make your DatabaseHelper class a singleton and only access the SQLiteDatabase object through that (using getReadableDatabase() and getWritableDatabase()), as outlined here: https://codereview.stackexchange.com/a/36230

2. No database operations should be performed on the main thread. When I need to perform a database operation initiated by a user operation, such as onSubmitClick, I call a method in my DatabaseHelper class which executes an AsyncTask which performs the actual DB operations, and then calls a callback method when it's finished. For example:

   public void fetchModels(DatabaseQueryListener listener) {
       new FetchModelsTask(listener).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
   }
   
   class FetchModelsTask extends AsyncTask<Void, Void, Cursor> {
   
       private DatabaseQueryListener listener;
   
       public FetchModelsTask(DatabaseQueryListener listener) {
           this.listener = listener;
       }
   
       @Override
       protected Cursor doInBackground(Void... params) {
           return query(getReadableDatabase().rawQuery(...);
       }
   
       @Override
       protected void onPostExecute(Cursor cursor) {
           if(listener != null) {
               listener.onQueryExecuted(cursor);
               cursor.close();
           }
       }
   }