Tutorial Android Architecture (Room, LiveData, ViewModel)
Android Architecture merupakan salah satu bagian dari Android Jetpack by Google. Android Architecture sendiri itu terdiri dari:
- Room sebagai SQLite objek mapping library.
- LiveData sebagai objek untuk mengobserve perubahan data di database. Cara kerjanya mirip Subject/RxBus, perbedaannya LiveData ini aware terhadap lifecycle komponen seperti activity, fragment, atau service.
- ViewModel sebagai objek yang akan selalu ada sampai komponen seperti activity di destroy. Berguna untuk menyimpan data sementara agar tidak hilang.
Android Architecture dibangun memang untuk saling terintegrasi satu sama lainnya sehingga memudahkan kita untuk membangun aplikasi. Berbeda dengan sebelum ada Andriod Architecture, kita harus melakukan riset terlebih dahulu untuk mencari sebuah library, mendesain projek kita dengan library yang kita temukan itu, dsb.
Pada tutorial ini saya akan membuat sebuah aplikasi sederhana untuk menyimpan Catatan kemudian ditampilkan dalam bentuk List. Komponent fragment 1 akan berperan sebagai komponent yang menginput sebuah teks kemudian teks tersebut di observe pada fragment 2. Strukturnya seperti gambar berikut:
Tujuan dari tutorial ini adalah untuk memberikan contoh dari penggunaan Android Architecture (Room, LiveData, ViewModel), jadi skenario yang terjadi sangat mungkin dapat dibuat menjadi lebih sederhana.
Kalau kamu ingin langsung melihat projek jadinya, saya sudah memberikan link repo di bagian akhir tutorial ini.
Implementasi Room
Terdapat 3 komponen untuk mengimplementasikan Room di android:
- Database, sebagai objek untuk mendefinisikan Database kita seperti nama DB, Versi DB, Tabel nya apa aja berdasar Entity yang kita buat.
- Entity, sebagai objek untuk mendefinisikan struktur Tabel kita.
- DAO (Data Access Object) sebagai objek untuk melakukan query ke database kita.
Menambahkan Library Room:
// Android Room
implementation 'android.arch.persistence.room:runtime:1.1.1'
kapt 'android.arch.persistence.room:compiler:1.1.1'Membuat database:
import android.arch.persistence.room.Database
import android.arch.persistence.room.RoomDatabase@Database(
version = 1,
entities = [
NoteDb::class
],
exportSchema = false
)
abstract class Database : RoomDatabase() {
abstract fun noteDao(): NoteDao
}
Pada kode diatas kita membuat sebuah database hanya dengan meng extends RoomDatabase() dan mendeklarasikan Table NoteDb::class dengan annotation @Database .
Membuat tabel:
import android.arch.persistence.room.Entity
import android.arch.persistence.room.PrimaryKey
import com.wisnu.try778.Constant@Entity(
tableName = Constant.Table.NOTE
)
class NoteDb(@PrimaryKey val id: String,
val content: String)
Kode diatas adalah isi table kita yaitu table NoteDb yang ditandai dengan annotation @Entity parameter kita secara otomatis akan menjadi nama kolom di table dan minimal harus mempunyai sebuah @PrimaryKey .
Membuat sebuah DAO:
import android.arch.lifecycle.LiveData
import android.arch.persistence.room.Dao
import android.arch.persistence.room.Insert
import android.arch.persistence.room.Query
import com.wisnu.try778.Constant@Dao
interface NoteDao {
@Query("SELECT * FROM ${Constant.Table.NOTE}")
fun loadAllNotesLiveData(): LiveData<List<NoteDb>>
@Insert
fun insertNote(note: NoteDb)
@Query("DELETE FROM ${Constant.Table.NOTE} WHERE id=:noteId")
fun deleteNote(noteId: String)
}
Untuk mengakses database kita perlu membuat interface yang kita berikan annotation @Dao , secara default untuk mengakses method diatas kita diharuskan mengaksesnya melalui background thread, apabila kita mengaksesnya melalui main thread maka apps kita akan crash. Akan tetapi kita dapat mengignore nya dengan memanggil method allowMainThreadQueries() pada saat membuat objek database kita.
Terakhir kita membuat instance DB kita seperti di bawah ini:
Room
.databaseBuilder(
CONTEXT,
Database::class.java,
Constant.Table.DB_NAME
)
.fallbackToDestructiveMigration()
.build()Implementasi LiveData dan ViewModel
Pada implementasi NotaDao kita membuat fungsi loadAllNotesLiveData() yang mengembalikan objek list Note berjenis LiveData. Tujuannya supaya ketika ada perubahan data pada NoteDb kita dapat langsung mendapatkan perubahan datanya.
Menambahkan library LiveData dan ViewModel:
implementation 'android.arch.lifecycle:extensions:1.1.1'
implementation 'android.arch.lifecycle:reactivestreams:1.1.1'Membuat ViewModel:
import android.arch.lifecycle.LiveData
import android.arch.lifecycle.ViewModel
import com.wisnu.try778.database.NoteDao
import com.wisnu.try778.map
import com.wisnu.try778.model.Noteclass NoteViewModel(private val noteDao: NoteDao) : ViewModel() {
private lateinit var notesResult: LiveData<List<Note>>
init {
subscribeNoteResult()
}
fun saveNote(content: String) {
noteDao.saveNote(content)
}
fun deleteNote(note: Note) {
noteDao.deleteNote(note)
}
fun listenNotesResult(): LiveData<List<Note>> {
return notesResult
}
private fun subscribeNoteResult() {
notesResult = noteDao.loadNotesLiveData().map { data ->
data.reversed().map { Note(it.id, it.content) }
}
}
}
Implementasi LiveData kita di Activity atau Fragment:
private val noteViewModel by viewModel<NoteViewModel>()noteViewModel.listenNotesResult().observe(this, Observer {
listNote -> // update UI
})
Dengan kode diatas apabila terjadi perubahan data pada table NoteDb maka kode diatas akan secara otomatis me return data terbaru dariNoteDb .
Keuntungannya dengan membuat mekanisme seperti ini adalah data yang ditampilkan di UI merupakan data yang valid karena sama dengan data kita yang ada pada database, konsep ini dinamakan single source of truth.
Cukup simple bukan? kode kita terlihat jadi lebih sedikit.
Demo
Full source code dapat dilihat pada link dibawah ini, projek ini cocok buat kamu yang ingin belajar:
- Room
- LiveData
- ViewModel
- Kotlin language
- Koin untuk dependency injection
- RecyclerView menggunakan DiffUtil
- RxJava untuk threading
Sumber:
https://developer.android.com/jetpack/docs/guide
https://developer.android.com/training/data-storage/room/defining-data
https://developer.android.com/training/data-storage/room/accessing-data
