The document provides a comprehensive overview of the Android Jetpack Room Persistence Library, detailing its advantages such as abstraction over SQLite, compile-time checking for SQL statements, and easier testing and migration. It outlines the components involved, such as entities, DAOs, and Room database setup, alongside code examples for implementation. Additionally, it offers various resources for further learning and migration strategies from SQLite to Room.

1. Android Jetpack
Room Persistence Library
Huỳnh Quang Thảo
Trusting Social
Google Developer Expert on Android

2. When start new android app …
- Database:
- Native SQLite
- ORM wrapper on SQLite: DBFlow
- Different database engines: Realm.

3. When start new android app …
- Running a jobs:
- AlarmManager + Broadcast Receiver
- Firebase JobDispatcher
- JobScheduler
- GCMNetworkManager
-

4. When start new android app …
- Control data Slow and update latest data on UI.

5. When start new android app …
- Control data Slow and update latest data on UI.
- Loading data:
- Loading data from network.
- Loading data from on-device database.
- Loading data from multiple sources.

8. Android Architecture Components

9. ViewModel

10. Live Data

11. World before Room
-SQL boiler code
-Migration
-Testing

12. Solutions
GreenDAO
Realm
DBFlow

13. Why Room
-provides an abstraction layer over SQLite.

14. Why Room
-provides an abstraction layer over SQLite.
-Provide compile-time checking for SQL Statement.

15. Why Room
-provides an abstraction layer over SQLite.
-Provide compile-time checking for SQL Statement.
-Detect query database on main thread.

16. Why Room
-provides an abstraction layer over SQLite.
-Provide compile-time checking for SQL Statement.
-Detect query database on main thread.
-Easier for testing and migration.

17. Room Components

18. Entity
public class Word {
private String mWord;
public Word(String word) {this.mWord = word;}
public String getWord(){return this.mWord;}
}

19. Entity
@Entity(tableName = "word_table")
public class Word {
@PrimaryKey
@NonNull
@ColumnInfo(name = "word")
private String mWord;
public Word(String word) {this.mWord = word;}
public String getWord(){return this.mWord;}
}

20. Entity
-Support database constraints. (unique key, primary keys …)

21. Entity
-Support database constraints. (unique key, primary keys …)
-Support deSine relationship between model.

22. Entity
-Support database constraints. (unique key, primary keys …)
-Support deSine relationship between model.
-Can ignore derived Sields.

23. Entity
-Support database constraints. (unique key, primary keys …)
-Support deSine relationship between model.
-Can ignore derived Sields.
-Support database views.

24. DAO
@Dao
public interface WordDao {
@Insert
void insert(Word word);
@Query("DELETE FROM word_table")
void deleteAll();
@Query("SELECT * from word_table ORDER BY word ASC")
LiveData<List<Word>> getAllWords();
}

25. DAO
-Use annotation for simple actions such as insert/delete/update
@Dao
public interface WordDao {
@Insert
void insert(Word word);
}

26. DAO
-Write custom query.
@Dao
public interface WordDao {
@Query("DELETE FROM word_table")
void deleteAll();
@Query("SELECT * from word_table ORDER BY word ASC")
LiveData<List<Word>> getAllWords();
}

27. DAO
-Check query at compile time.

28. DAO
-Check query at compile time.

29. DAO
-Return LiveData data.
@Dao
public interface WordDao {
@Query("SELECT * from word_table ORDER BY word ASC")
LiveData<List<Word>> getAllWords();
}

30. Room Database
-Abstraction over SQLiteHelper.
@Database(entities = {Word.class}, version = 1)
public abstract class WordRoomDatabase extends RoomDatabase {
public abstract WordDao wordDao();
private static volatile WordRoomDatabase INSTANCE;
static WordRoomDatabase getDatabase(final Context context) {
if (INSTANCE == null) {
synchronized (WordRoomDatabase.class) {
if (INSTANCE == null) {
// Create database here
INSTANCE =
Room.databaseBuilder(context.getApplicationContext(),
WordRoomDatabase.class, "word_database")
.addCallback(sRoomDatabaseCallback)
.build();
}
}
}
return INSTANCE;
}
}

31. Room Database

32. Sample application
Codelab:
https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#0
Code demo:
https://github.com/googlecodelabs/android-room-with-a-view

34. WorkSlow

35. 7 steps to to Room
https://medium.com/androiddevelopers/7-steps-to-room-27a5fe5f99b2

36. Step 1: Add dependencies
dependencies {
// Room components
implementation "android.arch.persistence.room:runtime:$rootProject.roomVersion"
annotationProcessor "android.arch.persistence.room:compiler:$rootProject.roomVersion"
androidTestImplementation "android.arch.persistence.room:testing:$rootProject.roomVersion"
// Lifecycle components
implementation "android.arch.lifecycle:extensions:$rootProject.archLifecycleVersion"
annotationProcessor "android.arch.lifecycle:compiler:$rootProject.archLifecycleVersion"
}
build.gradle (module app)

37. Step 2: Update model to entity
@Entity(tableName = "word_table")
public class Word {
@PrimaryKey
@NonNull
@ColumnInfo(name = "word")
private String mWord;
public Word(String word) {this.mWord = word;}
public String getWord(){return this.mWord;}
}

38. Step 3: Create DAO
@Dao
public interface WordDao {
@Insert
void insert(Word word);
}

39. Step 3: Create DAO
@Dao
public interface WordDao {
@Insert
void insert(Word word);
@Query("DELETE FROM word_table")
void deleteAll();
@Query("SELECT * from word_table ORDER BY word ASC")
LiveData<List<Word>> getAllWords();
}

40. Step 4: Create Database
@Database(entities = {Word.class}, version = 1)
public abstract class WordRoomDatabase extends RoomDatabase {
}

41. Step 4: Create Database
@Database(entities = {Word.class}, version = 1)
public abstract class WordRoomDatabase extends RoomDatabase {
public abstract WordDao wordDao();
}

42. Step 4: Create Database
@Database(entities = {Word.class}, version = 1)
public abstract class WordRoomDatabase extends RoomDatabase {
public abstract WordDao wordDao();
private static volatile WordRoomDatabase INSTANCE;
static WordRoomDatabase getDatabase(final Context context) {
if (INSTANCE == null) {
synchronized (WordRoomDatabase.class) {
if (INSTANCE == null) {
// Create database here
INSTANCE =
Room.databaseBuilder(context.getApplicationContext(),
WordRoomDatabase.class, "word_database")
.addCallback(sRoomDatabaseCallback)
.build();
}
}
}
return INSTANCE;
}
}

43. Step 5: Update Repository
public class WordRepository {
private WordDao mWordDao;
private LiveData<List<Word>> mAllWords;
}

44. Step 5: Update Repository
public class WordRepository {
private WordDao mWordDao;
private LiveData<List<Word>> mAllWords;
public WordRepository(Application application) {
WordRoomDatabase db = WordRoomDatabase.getDatabase(application);
mWordDao = db.wordDao();
mAllWords = mWordDao.getAllWords();
}
public LiveData<List<Word>> getAllWords() {
return mAllWords;
}
public void insert(Word word) {
new insertAsyncTask(mWordDao).execute(word);
}
}

45. Step 6: Testing DAO
@RunWith(AndroidJUnit4.class)
public class WordDaoTest {
private WordDao mWordDao;
private WordRoomDatabase mDb;
@Before
public void createDb() {
Context context = InstrumentationRegistry.getTargetContext();
mDb = Room.inMemoryDatabaseBuilder(context, WordRoomDatabase.class)
// Allowing main thread queries, just for testing.
.allowMainThreadQueries()
.build();
mWordDao = mDb.wordDao();
}
@After
public void closeDb() {
mDb.close();
}
}

46. Step 6: Testing DAO
@RunWith(AndroidJUnit4.class)
public class WordDaoTest {
private WordDao mWordDao;
private WordRoomDatabase mDb;
@Before
public void createDb() {
Context context = InstrumentationRegistry.getTargetContext();
mDb = Room.inMemoryDatabaseBuilder(context, WordRoomDatabase.class)
// Allowing main thread queries, just for testing.
.allowMainThreadQueries()
.build();
mWordDao = mDb.wordDao();
}
@After
public void closeDb() {
mDb.close();
}
@Test
public void insertAndGetWord() throws Exception {
Word word = new Word("word");
mWordDao.insert(word);
List<Word> allWords = LiveDataTestUtil.getValue
(mWordDao.getAlphabetizedWords());
assertEquals(allWords.get(0).getWord(), word.getWord());
}
}

47. Step 7: Clean up
- Remove unused classes replaced by Room. (i.e: any class extends SQLiteHelper)
- More complex project:
- https://medium.com/androiddevelopers/incrementally-migrate-from-sqlite-to-room-66c2f655b377

48. Learning References
Android architecture components
- https://developer.android.com/jetpack/docs/guide

49. Learning References
Android architecture components
- https://developer.android.com/jetpack/docs/guide
Android LifeCycle components
- https://www.youtube.com/watch?v=5qlIPTDE274
- https://developer.android.com/topic/libraries/architecture/lifecycle

50. Learning References
Android architecture components
- https://developer.android.com/jetpack/docs/guide
Android LifeCycle components
- https://www.youtube.com/watch?v=5qlIPTDE274
- https://developer.android.com/topic/libraries/architecture/lifecycle
Android LiveData
- https://www.youtube.com/watch?v=OMcDk2_4LSk
- https://developer.android.com/topic/libraries/architecture/livedata

51. Learning References
Android architecture components
- https://developer.android.com/jetpack/docs/guide
Android LifeCycle components
- https://www.youtube.com/watch?v=5qlIPTDE274
- https://developer.android.com/topic/libraries/architecture/lifecycle
Android LiveData
- https://www.youtube.com/watch?v=OMcDk2_4LSk
- https://developer.android.com/topic/libraries/architecture/livedata
Room Persistence libraries
- https://developer.android.com/topic/libraries/architecture/room
- https://www.youtube.com/watch?v=SKWh4ckvFPM

52. Learning References
Android architecture components
- https://developer.android.com/jetpack/docs/guide
Android LifeCycle components
- https://www.youtube.com/watch?v=5qlIPTDE274
- https://developer.android.com/topic/libraries/architecture/lifecycle
Android LiveData
- https://www.youtube.com/watch?v=OMcDk2_4LSk
- https://developer.android.com/topic/libraries/architecture/livedata
Room Persistence libraries
- https://developer.android.com/topic/libraries/architecture/room
- https://www.youtube.com/watch?v=SKWh4ckvFPM
Paging
- https://developer.android.com/topic/libraries/architecture/paging/

53. Codelab
- https://codelabs.developers.google.com/codelabs/android-lifecycles/#1
- https://codelabs.developers.google.com/codelabs/android-persistence/#0
- https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#0
- https://codelabs.developers.google.com/codelabs/android-paging/#0

54. Q&A