Breaking News
Home / Android / Ahmad Rosid – Mengimplementasikan Architecture Component Android dengan Kotlin

Ahmad Rosid – Mengimplementasikan Architecture Component Android dengan Kotlin

Satu lagi yang baru dalam dunia android development yang sedang hangat — hangat nya yaitu Design Pattern Architecture Component yang baru — baru ini dikenalkan oleh google.

Sebelum lebih lanjut untuk mempelajari design pattern Architecture Component ini silahkan lihat dulu sebentar vidio di bawah ini mengenai sedikit penjelasan tentang Architecture Component.

 

 

Didalam Architecture Component ada tiga hal yang perlu kita pahami yaitu :

  1. Lifecycles
  2. LiveData
  3. ViewModel

Untuk kamu yang biasa menggunakan SQLite sebagai local database bisa menggunakan Room dan Paging untuk pengolahan database SQLite secara lebih mudah.

Lifecycles

Sebuah halaman di dalam aplikasi android entah itu Activity atau Fragment atau Dialog memiliki Lifecycles atau siklus kehidupan nya, seperti onStart, onResume, onPause, onDestroy dan yang lainya. Dengan adanya siklus kehidupan ini dapat kita gunakan untuk mengetahui kapan sebuah komponent tersebut sedang aktif kah atau sudah tidak aktif lagi.

Akan tetapi terkadang kita akan mengalami sedikit kesulitan karena untuk mengakses method dari Lifecycles komponent tersebut harus didalam class dari component tersebut sehingga code yang kita tulis menumpuk pada satu class untuk sebuah component yang kita handle, biasanya jika kita ingin memisahkan nya kita menggunakan interface yang mana membuat code yang kita tulis menjadi lebih banyak dan banyak lagi.

Salah satu komponent pada pattern Architecture Component ini adalah Lifecycles yang mana kita bisa mengakses siklus kehidupan dari sebuah activity atau fragment dan yang lainya dengan observable object yang mana tidak lagi perlu kita menggunakan banyak interface.

Berikut ini contoh nya

 

LiveData

Sekarang ini adalam jamanya Observer Pattern di mana — mana setiap object akan di bungkus kedalam object Observable. Salah satunya yaitu LiveDatayang dimana adalah sebuah obserbale holder data class yang intinya live data ini membungkus sebuah object kedalam object observable.

Tidak seperti observable object biasanya LiveData ini adalah sebuah class yang juga Lifecycle Aware yang artinya object ini memiliki response terhadap lifecycle dari Activity, Fragment atau yang lainya. Sehingga dengan begini kita bisa mengurangi kebocoran memory yang di akibatkan oleh object listener dari sebuah observable, yang biasanya mengakibatkan aplikasi kita menjadi lambat dan tidak ada response.

Untuk menggunaan LiveData ini kita perlu mengimplementasikan LifecycleOwner pada activity atau fragment atau komponent lainya yang akan menggunakan object LiveData ini.

 

ViewModel

Selesai dengan urusan Lifecycles dan LiveData maka kita akan di hadapkan dengan salah satu permasalahan umum sebagai seorang developer android, yaitu urusan dengan Thread, yang mana sebagai yang biasa kita hadapi kalau kita melakukan Network Call atau Acces local database dan proses — proses yang lainya itu harus di pisah dengan UI thread.

Nah dengan menggunakan ViewModel ini kita bisa gunakan untuk pengolahan data yang akan kita tampilkan ke user yang mana ViewModel ini juga Lifecycle Aware. Salah satu manfaatnya dari penggunaan ViewModel ini adalah kita tidak perlu lagi melakukan usaha extra jika device mengalami perubahan orientasi screen yang berubah layarnya menjadi horizontal atau vertikal.

Melaui ViewModel ini juga kita bisa gunakan untuk sharing data antar fragment, tanpa harus ribet — ribet menggunakan Event Bus yang seperti biasa kita lakukan. Dan masih banyak lagi keuntungan menggunakan ViewModel ini.

Untuk data yang kita olah di ViewModel ini nantinya akan di bungkus dengan MutableLiveData yang dimana untuk menginstance ViewModel ini kita gunakan ViewModelProvider.

Berikut ini adalah contoh nya

 

Untuk Room dan Paging kita akan bahas pada tulisan berikutnya.

Kotlin Coroutines

Sesuai judul dari artikel ini kita akan coba mengimplementasikan Architecture Component ini dengan menggunakan bahasa pemrogramman kotlin. Tapi sebelum kita lanjut lebih dalam lagi untuk proses implementasi Architecture Component ini kita akan bahas sedikit satu topik yaitu Coroutines.

Coroutines adalah asynchronous programming pada kotlin yang mana kita bisa gunakan untuk blocking thread. Gampangnya kegunaan Coroutines ini adalah berfungsi untuk blocking satu thread hingga proses thread yang lain selesai. Manfaat nya dengan menggunakan Coroutines ini kita akan lebih mudah untuk mengkontrol penggunaan thread yang lebih dari satu, sehingga kita menggurangi pengunaan callback dari sebuah peroses dari thread yang berbeda.

Berikut ini adalah contoh penggunaan dari Kotlin Coroutines.

 

Dependency

Untuk dependecy yang kita gunakan dari latihan untuk mengimplementasikan latihan kita kali ini adalah sebagai berikut.

 

Kesimpulan

Kesimpulan dari pembahan Architecture Component komponent ini adalah dengan Architecture Component ini kita di permudah untuk pengolahan data yang aware dengan siklus hidup sebuah komponent activity, fragment dan yang lainya, dan untuk mengimplementasikan Architecture Component ini kita perlu menggunakan tiga hal yaitu LifecyclesLiveData dan ViewModel.

Dan dengan munggunakan kotlin kita juga bisa gunakan Coroutines untuk mengurusi operasi di beberapa thread dengan lebih mudah dan lebih sedikit dalam penulisan kodenya.

Nah untuk contoh project dari latihan kali ini bisa di buka melalui link dibawah ini.

About gookkis

Cuma tukang ketik di Gookkis.com, semoga tulisan jelek ini bermanfaat.

Baca Juga

Ahmad Rosid – Aplikasi Dompetku Implementasi CRUD database Realm

Yang namanya programming pasti tidak akan jauh — jauh dengan yang namanya pengolahan data, nah salah satunya …

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.