Komponen Arsitektur Android adalah kumpulan pustaka yang membantu Anda mendesain aplikasi yang tangguh, dapat diuji, dan dapat dipelihara dengan lebih banyak kekuatan atas pengelolaan siklus hidup dan persistensi data.

Pada artikel ini, kita akan fokus pada subset komponen Arsitektur Android. Kami akan mengembangkan aplikasi catatan, yang pada dasarnya mengambil beberapa masukan dari pengguna (LiveData), simpan ke dalam database lokal (Room) dan tampilkan di layar (ViewModel).

Sebelum kita mulai membangun aplikasi ini, mari kita pahami terlebih dahulu MVVM.

Apa itu MVVM?

Jika Anda terbiasa dengan MVVM, Anda dapat melewati bagian ini sepenuhnya.

MVVM adalah salah satu pola arsitektur yang meningkatkan pemisahan masalah, memungkinkan pemisahan logika antarmuka pengguna dari logika bisnis (atau back-end). Targetnya adalah untuk mencapai prinsip berikut “Menjaga kode UI tetap sederhana dan bebas dari logika aplikasi agar lebih mudah dikelola” .

Ada 3 bagian arsitektur Model-View-ViewModel:

Model adalah lapisan data aplikasi Anda. Ini mengabstraksi sumber data.
Tampilan berisi UI aplikasi Anda. Paling sering diimplementasikan sebagai Aktivitas atau Fragmen. View menginformasikan ViewModel tentang interaksi pengguna dan menampilkan hasil yang diterima dari ViewModel. Tampilan harus ringan dan mengandung logika bisnis nol hingga sangat sedikit.
ViewModel berfungsi sebagai jembatan antara View dan Model Anda. Ia bekerja dengan Model untuk mendapatkan dan menyimpan data. View mengamati dan bereaksi terhadap perubahan data yang diekspos oleh ViewModel.

Berikut adalah arsitektur aplikasi MVVM tingkat tinggi yang khas:

Langkah-langkah implementasi

Kami akan mengikuti langkah-langkah ini untuk mengimplementasikan Komponen Arsitektur Android di aplikasi kami:

Tambahkan Ketergantungan Ruang dan Siklus Hidup
Ruang Pengaturan
Pelajari tentang Data Langsung
Membuat Kelas Repositori/Lapisan Presentasi
Terapkan ViewModel
Tambahkan Adaptor dan RecyclerView
Mengisi Database
Hubungkan UI dan Data
Buat AddNoteActivity

Sekarang kita membahas langkah-langkah ini dalam urutan yang disebutkan.

1. Tambahkan Ketergantungan

Kita perlu menambahkan komponen Room dan Lifecycle . Room pada dasarnya adalah perpustakaan pemetaan objek database yang digunakan untuk mengakses database. Siklus hidup memiliki beberapa set kelas yang bagus seperti ViewModel dan LiveData yang akan kita gunakan untuk mengelola siklus hidup aplikasi kita.
Pertama tambahkan nomor versi, lalu tambahkan pustaka ini ke file build.gradle (Modul: app), di akhir blok dependensi.

dependencies {
    def lifecycle_version = "1.1.1"
    def room_version = "1.1.1"
    --- 
    // Room components
    implementation "android.arch.persistence.room:runtime:$room_version"
    kapt "android.arch.persistence.room:compiler:$room_version"

    // Lifecycle components
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    kapt "android.arch.lifecycle:compiler:$lifecycle_version"
}

2. Ruang Pengaturan

Ada 3 komponen utama dalam Room:

"Kesatuan"
“Dao”
“Basis Data”

Entitas

Entitas hanyalah sebuah POJO yang juga akan menjadi tabel dalam database. Misalnya, Anda dapat membuat kelas POJO dan membubuhi keterangan dengan anotasi “ @Entity” . Anda juga dapat mengidentifikasi bidang mana yang merupakan kunci utama dengan “@PrimaryKey”.

@Entity(tableName = "notes_table")
data class Note(
    var title: String,
    var description: String

) {
    @PrimaryKey(autoGenerate = true)
    var id: Int = 0
}

Di sini, kita memiliki kelas Note, dan nama tabelnya adalah “ notes_table”. Kami telah membuat tiga kolom id, title, description dan juga menjadikan id sebagai kunci utama dengan membubuhi keterangan “@PrimaryKey” dan autoGenerate menjadi true.

Data Access Object (DAO)

Data Access Object (DAO) adalah antarmuka yang dianotasi dengan Dao. Di sinilah operasi database CRUD (buat, baca, perbarui, dan hapus) didefinisikan. Setiap metode dianotasi dengan “ @Insert ”, “ @Delete ”, “ @Query(SELECT * FROM) ”.

@Dao
interface NoteDao {

    @Insert
    fun insert(note: Note)

    @Query("DELETE FROM notes_table")
    fun deleteAllNotes()

    @Query("SELECT * FROM notes_table ")
    fun getAllNotes(): LiveData<List<Note>>
    
}

Di sini, kami memiliki antarmuka NoteDao dan beberapa metode yang akan kami panggil untuk melakukan kueri kami. Untuk memasukkan data, kami memberi anotasi “@Insert” untuk menyisipkan metode. Room tidak memberi kami anotasi yang dapat membantu kami menghapus semuanya sehingga kami memiliki "@Query" untuk melakukan beberapa kueri khusus.

Database
Database buat kelas yang diperluas dari RoomDatabase dan beri anotasi dengan “@Database” . Kelas ini menyatukan Entitas dan DAO. Instance database dapat dibuat saat runtime, dengan memanggil Room.databaseBuilder() (pada perangkat) atau Room.inMemoryDatabaseBuilder() (dalam memori).

@Database(entities = [Note::class], version = 1)
abstract class NoteDatabase : RoomDatabase() {

    abstract fun noteDao(): NoteDao

    private var instance: NoteDatabase? = null

    fun getInstance(context: Context): NoteDatabase? {
        if (instance == null) {
            synchronized(NoteDatabase::class) {
                instance = Room.databaseBuilder(
                    context.applicationContext,
                    NoteDatabase::class.java, "notes_database"
                )
                    .fallbackToDestructiveMigration()
                    .addCallback(roomCallback)
                    .build()
            }
        }
        return instance
    }

}

Di sini, kami memiliki kelas NoteDatabase Room di mana kami harus mendeklarasikan semua entitas dan versi database kami. metode getInstance() akan mengembalikan instance database ruangan. Jika Anda ingin memodifikasi database, lihat Migration.

Live Data Kelas

LiveData berasal dari lifecycle library, untuk mengamati perubahan data. Ini adalah kelas pemegang data yang dapat diamati, dan juga sadar akan siklus hidup yang berarti bahwa ini akan memperbarui komponen yang berada dalam status siklus hidup aktif .

fun getAllNotes() : LiveData<List<Note>>

Di sini, di proyek kami, di mana kami mendapatkan daftar catatan dan kami membungkus daftar dengan LiveData.

4. Membuat Kelas Repositori/Lapisan Presentasi

Ini adalah kelas di mana kami akan memeriksa apakah akan mengambil data dari API atau database lokal, atau Anda dapat mengatakan kami menempatkan logika pengambilan database di kelas ini.

class NoteRepository(application: Application) {

    private var noteDao: NoteDao

    private var allNotes: LiveData<List<Note>>

    init {
        val database: NoteDatabase = NoteDatabase.getInstance(
            application.applicationContext
        )!!
        noteDao = database.noteDao()
        allNotes = noteDao.getAllNotes()
    }

    fun insert(note: Note) {
        val insertNoteAsyncTask = InsertNoteAsyncTask(noteDao).execute(note)
    }

    fun deleteAllNotes() {
        val deleteAllNotesAsyncTask = DeleteAllNotesAsyncTask(
            noteDao
        ).execute()
    }

    fun getAllNotes(): LiveData<List<Note>> {
        return allNotes
    }

    private class InsertNoteAsyncTask(noteDao: NoteDao) : AsyncTask<Note, Unit, Unit>() {
        val noteDao = noteDao

        override fun doInBackground(vararg p0: Note?) {
            noteDao.insert(p0[0]!!)
        }
    }


    private class DeleteAllNotesAsyncTask(val noteDao: NoteDao) : AsyncTask<Unit, Unit, Unit>() {

        override fun doInBackground(vararg p0: Unit?) {
            noteDao.deleteAllNotes()
        }
    }

}

Di sini, kami menambahkan pembungkus untuk insert(), getAllNotes() dan deleteAllNotes(). Room menjalankan operasinya pada utas non-UI/utas latar belakang, jadi kami menggunakan AsyncTask.

5. TampilanModel

Ini juga merupakan bagian dari perpustakaan siklus hidup ; ini akan membantu Anda untuk menyediakan data antara repositori dan UI . Ini bertahan dari data tentang perubahan konfigurasi dan membuat ViewModel yang ada terhubung kembali dengan instance pemilik yang baru.

Mengapa menggunakan ViewModel?

ViewModel sadar akan siklus hidup sehingga akan bertahan dari perubahan konfigurasi. Ini akan hidup lebih lama dari Aktivitas atau Fragmen.
Komunikasi yang lebih mudah antar fragmen, daripada mengandalkan Aktivitas hosting yang meneruskan komunikasi.
Bekerja cukup baik dengan LiveData, pemegang data yang dapat diamati.
Anda dapat menggunakan RxJava alih-alih LiveData.

class NoteViewModel(application: Application) : AndroidViewModel(application) {

    private var repository: NoteRepository =
        NoteRepository(application)
    private var allNotes: LiveData<List<Note>> = repository.getAllNotes()

    fun insert(note: Note) {
        repository.insert(note)
    }

    fun deleteAllNotes() {
        repository.deleteAllNotes()
    }

    fun getAllNotes(): LiveData<List<Note>> {
        return allNotes
    }
}

Di sini, kami menggunakan AndroidViewModel karena kami membutuhkan konteks aplikasi. Kami membuat pembungkus insert(), deleteAllNotes() dan getAllNotes() yang akan menggunakan metode terkait repositori.

6. Tambahkan Adaptor dan RecyclerView

Buat file tata letak (note_item.xml), sertakan dua TextView untuk Judul dan Deskripsi yang dibatasi di dalam Tata Letak Linear yang memiliki orientasi vertikal dan juga sertakan RecyclerView di activity_main.xml. Juga, jangan lupa untuk menambahkan ketergantungan Recyclerview dan CardView di build.gradle. Kita juga perlu menambahkan kelas adaptor yang bertanggung jawab untuk menampilkan data kita di layar.

class NoteAdapter : RecyclerView.Adapter<NoteAdapter.NoteHolder>() {
    private var notes: List<Note> = ArrayList()

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): NoteHolder {
        val itemView = LayoutInflater.from(parent.context)
            .inflate(R.layout.note_item, parent, false)
        return NoteHolder(itemView)
    }

    override fun onBindViewHolder(holder: NoteHolder, position: Int) {
        val currentNote = notes[position]
        holder.textViewTitle.text = currentNote.title
        holder.textViewDescription.text = currentNote.description
    }

    override fun getItemCount(): Int {
        return notes.size
    }

    fun setNotes(notes: List<Note>) {
        this.notes = notes
        notifyDataSetChanged()
    }

    inner class NoteHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        var textViewTitle: TextView = itemView.findViewById(R.id.text_view_title)
        var textViewDescription: TextView = itemView.findViewById(R.id.text_view_description)

    }
}

note_item.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp">

    <LinearLayout
            android:id="@+id/ll"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="6dp"
            android:orientation="vertical">
        <TextView
                android:id="@+id/text_view_title"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:ellipsize="end"
                android:maxLines="1"
                android:text="Title"
                android:textAppearance="@style/TextAppearance.AppCompat.Large"/>

        <TextView
                android:id="@+id/text_view_description"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="Description"/>

    </LinearLayout>
</android.support.v7.widget.CardView>

7. Isi Database

Di sini kami mengisi data saat aplikasi dimulai dan sebelum itu kami juga menghapus data yang ada. Kami membuat PopulateDbAsyncTask yang merupakan penggunaan AsyncTask untuk menghapus dan menyisipkan data.

--- 
private val roomCallback = object : RoomDatabase.Callback() {
            override fun onCreate(db: SupportSQLiteDatabase) {
                super.onCreate(db)
                PopulateDbAsyncTask(instance)
                    .execute()
            }
        }

    }
    class PopulateDbAsyncTask(db: NoteDatabase?) : AsyncTask<Unit, Unit, Unit>() {
        private val noteDao = db?.noteDao()

        override fun doInBackground(vararg p0: Unit?) {
            noteDao?.insert(Note("Title 1", "description 1"))
            noteDao?.insert(Note("Title 2", "description 2"))
            noteDao?.insert(Note("Title 3", "description 3"))
        }
    }

8. Hubungkan UI dan Data

Untuk menampilkan data dari database, kita membutuhkan pengamat yang akan mengamati perubahan data, LiveData di ViewModel. Kami menggunakan ViewModelProvider yang akan membuat ViewModel untuk kami. Kita perlu menghubungkan ViewModel kita dengan ViewModelProvider , dan kemudian dalam metode onChanged, kita selalu mendapatkan data terbaru yang dapat kita tampilkan di layar.

class MainActivity : AppCompatActivity() {
    private val ADD_NOTE_REQUEST = 1
    private lateinit var noteViewModel: NoteViewModel
    private val adapter = NoteAdapter()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val recyclerView = findViewById<RecyclerView>(R.id.recycler_view)
        buttonAddNote.setOnClickListener {
            startActivityForResult(
                Intent(this, AddNoteActivity::class.java),
                ADD_NOTE_REQUEST
            )
        }
        recyclerView.layoutManager = LinearLayoutManager(this)
        recyclerView.setHasFixedSize(true)
        recyclerView.adapter = adapter
        noteViewModel = ViewModelProviders.of(this).get(NoteViewModel::class.java)
        noteViewModel.getAllNotes().observe(this,
            Observer<List<Note>> { t -> adapter.setNotes(t!!) })
    }
    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
        menuInflater.inflate(R.menu.main_menu, menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem?): Boolean {
        return when (item?.itemId) {
            R.id.delete_all_notes -> {
                noteViewModel.deleteAllNotes()
                Toast.makeText(this, "All notes deleted!", Toast.LENGTH_SHORT).show()
                true
            }
            else -> {
                super.onOptionsItemSelected(item)
            }
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        if (requestCode == ADD_NOTE_REQUEST && resultCode == Activity.RESULT_OK) {
            val newNote = Note(
                data!!.getStringExtra(AddNoteActivity.EXTRA_TITLE),
                data.getStringExtra(AddNoteActivity.EXTRA_DESCRIPTION)
            )
            noteViewModel.insert(newNote)

            Toast.makeText(this, "Note saved!", Toast.LENGTH_SHORT).show()
        } else {
            Toast.makeText(this, "Note not saved!", Toast.LENGTH_SHORT).show()
        }

    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".activities.MainActivity">

    <android.support.v7.widget.RecyclerView
            android:id="@+id/recycler_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            tools:listitem="@layout/note_item"
            tools:itemCount="5"/>

    <android.support.design.widget.FloatingActionButton
            android:id="@+id/buttonAddNote"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_add"
            android:layout_marginEnd="16dp"
            android:layout_marginBottom="16dp"
            android:layout_gravity="bottom|right"/>

</android.support.design.widget.CoordinatorLayout>

Di sini, Di MainActivity kami menambahkan tombol luar biasa untuk membuka aktivitas lain di mana kami dapat memasukkan catatan baru, dan kami membuat metode onActivityResult di mana kami mendapatkan data yang telah dimasukkan pengguna di AddNoteActivity.

9. Buat AddNoteActivity

Kami membuat aktivitas di mana pengguna dapat memasukkan data. Oleh karena itu kami membuat AddNoteActivity .Di sini, kami memiliki dua EditText untuk Title , Description , dan Button untuk mengirimkan catatan.

AddNoteActivity.kt

class AddNoteActivity : AppCompatActivity() {
    companion object {
        const val EXTRA_TITLE = "com.anubhav87.mvvmtutorial.EXTRA_TITLE"
        const val EXTRA_DESCRIPTION = "com.anubhav87.mvvmtutorial.EXTRA_DESCRIPTION"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_add_note)
        supportActionBar?.setHomeAsUpIndicator(R.drawable.ic_close)
    }

    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
        menuInflater.inflate(R.menu.add_note_menu, menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem?): Boolean {
        return when (item?.itemId) {
            R.id.save_note -> {
                saveNote()
                true
            }
            else -> super.onOptionsItemSelected(item)
        }
    }

    private fun saveNote() {
        if (edit_text_title.text.toString().trim().isBlank() || edit_text_description.text.toString().trim().isBlank()) {
            Toast.makeText(this, "Can not insert empty note!", Toast.LENGTH_SHORT).show()
            return
        }

        val data = Intent().apply {
            putExtra(EXTRA_TITLE, edit_text_title.text.toString())
            putExtra(EXTRA_DESCRIPTION, edit_text_description.text.toString())
        }

        setResult(Activity.RESULT_OK, data)
        finish()
    }
}

Itu saja untuk itu sekarang. Jalankan aplikasi Anda dan coba terapkan lebih banyak fungsi ke aplikasi.