Room Architecture In Android

• Step 1 - Creating a New Project with Empty Activity.
• Step 2 - Setting up the Library and Manifest.
• Step 3 - Implementation of Telegram Bot in the Android App.

1. Open Android Studio and select "Create new project".
2. Name the project as you wish and select your activity template.
   
3. Click the “Finish” button to create a new project in Android Studio.

1. First, add Google’s maven repository to your project-level build.gradle file.
   1. allprojects {
   2. repositories {
   3. jcenter()
   4. maven { url 'https://maven.google.com' }
   5. }
   6. }

2. Then, add the following dependencies to your app-level build.gradle file.
   1. compile 'android.arch.persistence.room:runtime:1.0.0-alpha1'
   2. annotationProcessor 'android.arch.persistence.room:compiler:1.0.0-alpha1'
   3. compile 'android.arch.lifecycle:extensions:1.0.0-alpha1'

3. Then click “Sync Now” to setup your project.

1. Create a Model class named as ProductModel.
   1. @Entity
   2. public class ProductModel {
   4. @PrimaryKey(autoGenerate = true)
   5. public int itemId;
   6. private String itemName;
   7. private String itemQty;
   8. @TypeConverters(DateConverter.class)
   9. private Date itemAddedDate;
   11. public ProductModel(int itemId, String itemName, String itemQty, Date itemAddedDate) {
   12. this.itemId = itemId;
   13. this.itemName = itemName;
   14. this.itemQty = itemQty;
   15. this.itemAddedDate = itemAddedDate;
   16. }
   18. public void setItemName(String itemName) {
   19. this.itemName = itemName;
   20. }
   22. public void setItemQty(String itemQty) {
   23. this.itemQty = itemQty;
   24. }
   26. public void setItemAddedDate(Date itemAddedDate) {
   27. this.itemAddedDate = itemAddedDate;
   28. }
   30. public String getItemName() {
   31. return itemName;
   32. }
   34. public String getItemQty() {
   35. return itemQty;
   36. }
   38. public Date getItemAddedDate() {
   39. return itemAddedDate;
   40. }
   42. public int getItemId() {
   43. return itemId;
   44. }
   45. }
   Here, @Entity annotation is used to tell the Model Class about Database Table.
   @PrimaryKey annotation is used to set Primary Key for Table and autoGenerate = true is used to set Auto Increment to Primary Key.
   @TypeConverters annotation is used to convert the Date into String and Vice-Versa. The DateConverter is a class created on your own as below.

2. Create a class named DateConverter and Paste the following code.
   1. class DateConverter {
   3. @TypeConverter
   4. public static Date toDate(Long timestamp) {
   5. return timestamp == null ? null : new Date(timestamp);
   6. }
   8. @TypeConverter
   9. public static Long toTimestamp(Date date) {
   10. return date == null ? null : date.getTime();
   11. }
   12. }
   This Converter is used to convert date to string and vice versa. Because we cannot save Date format in SQLite Directly.

3. Create a class and name it as a class and paste the following code. Here, the query for storing and retrieving data from Local DB is performed.
   1. @Dao
   2. @TypeConverters(DateConverter.class)
   3. public interface ProductModelDao {
   5. @Query("select * from ProductModel")
   6. LiveData<List<ProductModel>> getAllProducts();
   8. @Query("select * from ProductModel where itemId = :itemId")
   9. ProductModel getProductById(int itemId);
   11. @Insert(onConflict = REPLACE)
   12. void addProduct(ProductModel ProductModel);
   14. @Update(onConflict = REPLACE)
   15. void updateProduct(ProductModel ProductModel);
   17. @Delete
   18. void deleteProduct(ProductModel ProductModel);
   20. }

@Dao annotation indicates this interface is DAO.

@Query annotation indicates the data are queries to retrieve data from DB.

@Insert, @Update, @Delete annotations are used to insert, update and delete the data stored in the DB respectively.

onConflict indicates to replace the data when conflicts occur while performing the tasks.

4. Create an abstract class and name it as a class and paste the following code.
   1. @Database(entities = {ProductModel.class}, version = 1)
   2. public abstract class AppDataBase extends RoomDatabase {
   3. private static AppDataBase INSTANCE;
   5. public static AppDataBase getDatabase(Context context) {
   6. if (INSTANCE == null) {
   7. INSTANCE = Room.databaseBuilder(context.getApplicationContext(), AppDataBase.class, "product_db")
   8. .build();
   9. }
   10. return INSTANCE;
   11. }
   13. public static void destroyInstance() {
   14. INSTANCE = null;
   15. }
   17. public abstract ProductModelDao itemAndPersonModel();
   18. }

@Database annotation indicates this class is the database of our application. Entities is an array of tables or entities separated by commas. The version is used to denote the version of the database. This class is used to create the database and get an instance of it.

We can create the database using this query.

1. Room.databaseBuilder(context.getApplicationContext(), AppDataBase.class, "product_db")
2. .build();

5. Create Android View Model for retrieving all the data from DB.
   1. public class ProductListViewModel extends AndroidViewModel {
   3. private final LiveData<List<ProductModel>> itemAndPersonList;
   4. private AppDataBase appDatabase;
   6. public ProductListViewModel(Application application) {
   7. super(application);
   8. appDatabase = AppDataBase.getDatabase(this.getApplication());
   9. itemAndPersonList = appDatabase.itemAndPersonModel().getAllProducts();
   10. }
   12. public LiveData<List<ProductModel>> getItemAndPersonList() {
   13. return itemAndPersonList;
   14. }
   16. public void deleteItem(ProductModel borrowModel) {
   17. new deleteAsyncTask(appDatabase).execute(borrowModel);
   18. }
   20. private static class deleteAsyncTask extends AsyncTask<ProductModel, Void, Void> {
   22. private AppDataBase db;
   23. deleteAsyncTask(AppDataBase appDatabase) {
   24. db = appDatabase;
   25. }
   26. @Override
   27. protected Void doInBackground(final ProductModel... params) {
   28. db.itemAndPersonModel().deleteProduct(params[0]);
   29. return null;
   30. }
   31. }
   32. }