Getting Started with Room

Overview

Android provides a set of libraries to help to design of a highly maintainable and robust code. They have provided with helper classes for better data caching and handling 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.
Architecture Diagram

Boiler Plate Code

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

Todo App
Boilerplate Project Structure

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:

[code language=”java”]

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;
}
}

[/code]
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, 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 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:

[code language=”java”]

@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;
}
}
[/code]
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:

[code language=”java”]
@Dao
public interface AppDao {
@Query(“Select * from ” + AppConstants.DB_NAME + ” order by time desc”)
List 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);
}
[/code]
Attribute values can also be passed via interface method arguments and are used in queries with ‘:’ sign. As we can see in 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 of our each Dao class.

The AppDatabase class is as below:

[code language=”java”]
@Database(entities = {Todo.class}, version = 1) extends RoomDatabase {
public abstract AppDao appDao();
}
[/code]
We will also be using a Singleton class to get the reference to our AppDao interface. Which is as below:

[code language=”java”]
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;
}
}
[/code]
At last, we are all done with setting up database boilerplate for the project. Now the only thing left to do is adding database operations in our project using our Dao interface.

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

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

[code language=”java”]
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();
[/code]

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.

[code language=”java”]
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;
}
[/code]
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 of which signifies whether the action is an update or a create action. We will modify our existing logic as below:

[code language=”java”]
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();
}
[/code]
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 like and can easily use them in carts and product info sections (Eg. quantity, favorites) where we can prevent unnecessary API calls.


Posted

in

by

Recent Post

  • A Comprehensive Guide to Sentiment Analysis Using NLP

    Businesses need to understand public interests, attitudes, behavior, and trigger points in today’s dynamic and competitive market. This enables them to efficiently serve their customers, grab opportunities, grow, and develop resilience in the face of a constantly shifting market. Many businesses find it challenging to process vast amounts of text-based data in order to get […]

  • How AI Is Revolutionizing Banking: Transforming Customer Experiences and Enhancing Financial Security

    Banking is a huge industry with a global Banking market likely to achieve a Net Interest Income of USD 10.34 trillion, with Traditional Banks holding a huge stake of USD 8.30 trillion. According to Statista’s projections suggest an annual growth rate of 4.82% (CAGR 2024-2028), culminating in a market volume of USD12.48 trillion by 2028. […]

  • Mastering Hyperparameter Tuning in Python: Strategies, Techniques, and Tools for Model Optimization

    Understanding various aspects of deep learning and machine learning can often feel like stepping into uncharted territory with no clue where to go. As you start exploring various algorithms and data, you realize that success is based on more than just building a raw model, it’s more about fine-tuning it to perfection. And when we […]

  • What is Transfer Learning? Exploring The Popular Deep Learning Approach

    Have you ever thought about how quickly your smartphone recognizes faces in photos or suggests text as you type? Behind these features, there’s a remarkable technique called Transfer Learning that expands the capabilities of Artificial Intelligence. Now you must be wondering- What is Transfer Learning ? Picture this: Instead of starting from the square from […]

  • LLMOps Essentials: A Practical Guide To Operationalizing Large Language Models

    When you engage with ChatGPT or any other Generative AI tool, you just type and enter your query and Tada!! You get your answer in seconds. Ever wondered how it happens and how it is so quick? Let’s peel back the curtain of the LLMs a bit. What actually happens behind the screen is a […]

  • Building Intelligent AI Models For Enterprise Success: Insider Strategies 

    Just picture a world where machines think and learn like us. It might sound like a scene straight out of a sci-fi movie, right? Well, guess what? We are already living in that world now. Today, data, clever algorithms, and AI models are changing the way businesses operate. AI models are serving as a brilliant […]

Click to Copy