Getting Started with Room

Getting Started with Room

in

Overview

Android provides a set of libraries to help to design highly maintainable and robust code. They have provided helper classes for better data caching and handling of UI component states.

Room

The Room is a robust SQL object mapping library. It provides a layer of Abstraction over the Android’s SQLite Database. Allowing us to fluently access the power of SQLite database.

There are 3 major components in Room:

  1. **Database: **Contains the database holder and serves as the main access point for the app’s persisted relational data.
  2. **Entity: **Represents a table within the database.
  3. DAO: Contains the methods used for accessing the database.

The app uses the Room database to get the data access objects, or DAOs, associated with that database. The app then uses each DAO to get entities from the database and save any changes to those entities back to the database. Finally, the app uses an entity to get and set values that correspond to table columns within the database.

Boiler Plate Code

In this tutorial we will be making a very basic Todo Application, that will perform CRUD operations using the Room Database.

device-2017-11-12-032322

The boilerplate code can create, update and delete a todo/memo. However, the data won’t persist as soon as the app is closed.

Our main screen is a having a recyclerview to list all of our todos. The model of the todo is saved in the model package which is as below:

public class Todo {
  private long _id;

  private String todoTitle;

  private String todoText;

  private long timeStamp;

  public long get_id() {
      return _id;
  }

  public void set_id(long _id) {
      this._id = _id;
  }

  public String getTodoTitle() {
      return todoTitle;
  }

  public void setTodoTitle(String todoTitle) {
      this.todoTitle = todoTitle;
  }

  public String getTodoText() {
      return todoText;
  }

  public void setTodoText(String todoText) {
      this.todoText = todoText;
  }

  public long getTimeStamp() {
      return timeStamp;
  }

  public void setTimeStamp(long timeStamp) {
      this.timeStamp = timeStamp;
  }
}

We will be using this class as an Entity (Table) for our database. Through annotations, Room makes it much easier to define the properties of the table. Annotations like PrimaryKey, and ColumnInfo are quite understandable by name.

A table is created using @Entity annotation and the ‘tableName’ attributes are used to provide a table name. We define the primary key of the table using @PrimaryKey annotation and columns of the table using @ColumnInfo annotation and their respective names with a name attribute.

Our model class after adding annotations will look as below:

@Entity(tableName = "todo")
public class Todo {
  @PrimaryKey
  private long _id;

  @ColumnInfo(name = "title")
  private String todoTitle;

  @ColumnInfo(name = "text")
  private String todoText;

  @ColumnInfo(name = "time")
  private long timeStamp;

  public long get_id() {
      return _id;
  }

  public void set_id(long _id) {
      this._id = _id;
  }

  public String getTodoTitle() {
      return todoTitle;
  }

  public void setTodoTitle(String todoTitle) {
      this.todoTitle = todoTitle;
  }

  public String getTodoText() {
      return todoText;
  }

  public void setTodoText(String todoText) {
      this.todoText = todoText;
  }

  public long getTimeStamp() {
      return timeStamp;
  }

  public void setTimeStamp(long timeStamp) {
      this.timeStamp = timeStamp;
  }
}

Next, We will be making our interface for performing CRUD operations.

The dao interface has to be annotated with @Dao annotation. We use @Query annotation for executing a query and @Insert, @Update, and @Delete for insertion, deletion, and updating respectively.

The dao interface will finally look as below:

@Dao
public interface AppDao {
    @Query("Select * from " + AppConstants.DB_NAME + " order by time desc")
    List<Todo> getAllTodos();

    @Query("Select * from " + AppConstants.DB_NAME + " where _id = :id order by time desc")
    Todo getTodo(String id);
@Insert
    void insertTodo(Todo todo);

    @Update
    void updateTodo(Todo todo);

    @Delete
    void deleteTodo(Todo todo);
}

Attribute values can also be passed via interface method arguments and are used in queries with the ‘:’ sign. As we can see in the case of ‘getTodo’.

And at last, we will create an abstract Database Class that will extend RoomDatabase class. Database class is created through @Database annotation, it is mandatory to specify entities and version of the database. In our Database class, we will add access methods for each Dao class.

The AppDatabase class is as below:

@Database(entities = {Todo.class}, version = 1) extends RoomDatabase {
    public abstract AppDao appDao();
}

We will also be using a Singleton class to get the reference to our AppDao interface. Which is as below:

public class AppDBHandler {
    private AppDao appdao;
    private static AppDBHandler ourInstance;

    public static AppDBHandler getInstance(Context context) {
        if(ourInstance == null) {
            ourInstance = new AppDBHandler(context);
        }
        return ourInstance;
    }

    private AppDBHandler(Context context) {
        AppDatabase db = Room.databaseBuilder(context, AppDatabase.class, AppConstants.DB_NAME).build();
        appdao = db.appDao();
    }

    public AppDao getAppDao() {
        return appdao;
    }
}

At last, we are all done with setting up the database boilerplate for the project. Now the only thing left to do is add database operations to our project using our Dao interface.

The Room directly maps the database model to our Java Bean.

In our MainActivity.class, we will add the following lines to retrieve the list of all todos. Just below setting the adapter to our recyclerview.

MainActivity.java
...
...
recyclerView.setAdapter(todoListAdapter);
final AppDao dao = AppDBHandler.getInstance(getApplicationContext()).getAppDao();
Thread T1 = new Thread(new Runnable() {
    @Override
    public void run() {
        todos.addAll(dao.getAllTodos());
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                todoListAdapter.notifyItemRangeInserted(0, todos.size());
            }
        });
    }
});
T1.start();

Note: All the database calls in Room are synchronous and run on same thread to which they are called. If the call is a made on UI thread, then it will throw a IllegalStateException.

MainActivity.java
...
...
case 1: {
    final AppDao dao = AppDBHandler.getInstance(getApplicationContext()).getAppDao();
    Thread T1 = new Thread(new Runnable() {
        @Override
        public void run() {
            dao.deleteTodo(todos.get(position));
            todos.remove(position);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Snackbar.make(parentLayout, "Todo Deleted", Snackbar.LENGTH_SHORT).show();
                    todoListAdapter.notifyItemRemoved(position);
                }
            });
        }
    });
    T1.start();
    break;
}

We are using a single Dialog for creating and editing new todos. In our logic, we are using a private Todo class reference null value which signifies whether the action is an update or a create action. We will modify our existing logic as below:

CreateTodoDialog.java
    ...
    ...
    @Override
    public void onClick(View view) {
        ...
        ...
        if(this.todo == null) {
            todo = new Todo();
            todo.set_id(System.currentTimeMillis());
            todo.setTimeStamp(System.currentTimeMillis());
            todo.setTodoTitle(edtTitle.getText().toString());
            todo.setTodoText(edtText.getText().toString());
            final AppDao dao = AppDBHandler.getInstance(getContext()).getAppDao();
            Thread T1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    dao.insertTodo(todo);
                    dataCallbackListener.onDataReceived(todo);
                }
            });
            T1.start();
        } else {
            todo.setTimeStamp(System.currentTimeMillis());
            todo.setTodoTitle(edtTitle.getText().toString());
            todo.setTodoText(edtText.getText().toString());
            final AppDao dao = AppDBHandler.getInstance(getContext()).getAppDao();
            Thread T1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    dao.updateTodo(todo);
                    dataCallbackListener.onDataReceived(todo);
                }
            });
            T1.start();
        }

And that’s it, the Room itself will use the provided pojo for performing insert and update operations.

Remarks

I believe that it will be very helpful in creating applications that require data caching and have well structure models for reusability. Especially, e-commerce applications in which we can model our product details and can easily use them in carts and product info sections (Eg. quantity, favorites) where we can prevent unnecessary API calls.