Android Architecture Component da Kotlin ve LiveData

Bilginin en güzel yanı paylaşınca güzel oluyor olması. Bugün Android Architecture Components başlığı altındaki Kotlinde LiveData’dan bahsetmek istiyorum.

LiveData observable bir classtır. Diğerlerinden farklı olarak Android Life Cycles ile birlikte çalışır fragment ve activitylerde android geliştiricilere büyük fayda sağlamakta.

LiveData Observer class tarafından lifecycle da aktif durumlarda clientdan data bilgisi sağlar. STARTED veya RESUME aktif olarak kabul edilir.

Observer

Observer class veya component (fragment,activity vs) tarafından kullanılan bir arayüzdür. Class lardaki değişikliklerden haberdar olmak için Observer arayüz kullanır.

Bu observer arayüzün onChange(T t)methodu vardır. LiveData’da olan basit bir geri dönüş değeri.Buradaki T her türlü değeri alabilir.

Peki bu LiveData’nın daha ne avantajları var?

• Arayüzdeki bütün dataların eşleşmesini sağlar.
• Memory Leak olmamaktadır.
• Crashe düşen ve kapanan activity durumu ortadan kalkıyor.
• Manuel LifeCycle yok.
• Sürekli güncel veriler

LiveData ve MutableLiveData Arasındaki farklar nelerdir?

• MutableLiveData değiştirilebilirken LiveData değiştirilemez.
• MutableLiveData, LiveData yı genişletir ve setValue() ve postValue() gibi methodlar sağlar.
• setValue() & postValue() gibi yöntemler public olmadığından, değiştirmek istemediğinizde LiveData yı kullanın.

Peki setValue() ve postValue() arasındaki farklar nelerdir?

setValue() => Aktif observer yapı varsa value onlara gönderilecektir. Bu yol MainThread ile çağırılmalıdır.

postValue() => Gönderilen value düzenlenmesi için MainThread e gönderilir. MainThread den kaç kere çağırırsanız çağırın son değer gelir.

Yani?

setValue() ile MainThread den çağırılmalıdır. Fakat arka planda MainThread de bir value ayarlamamız gerekiyorsa postValue() kullanılmalıdır.

Canlı verilerle çalışmadan önce üzerinde çalışacağımız durumu iyice anlayalım.

• Belirli bir veri türü için LiveData örneği oluşturulur. Bu olay genelde ViewModel class ı içerisinde gerçekleştirilir.
• LiveData nesnesinde tutulan veriler değiştiğinde bunları kontrol eden onChanged() yöntemini tanımlayan observer nesnesi oluşturun. Genelde activity veya fragment da yani UI bileşenlerine observer nesnesi oluşturulur.
• Observe() methodunu kullanarak observer nesnesini LiveData nesnesine ekleyin. Observe() yöntemi bir LifecycleOwner nesnesi alır. Bu nesneler birbirleri arasındaki değişikliklerden haberdar olur. Genelde activity veya fragment da yani UI bileşenlerine observer nesnesi eklenir.

DeepNot:

ObserveForever(Observer) yöntemini kullanarak ilişkili LifeCycleOwner objesi olmadan bir observer a kaydedebilirisiniz. Bu durumda observer ın her zaman aktif olması kabul edilir ve her değişiklikten haberdar olur. RemoteObserver(Observer) yöntemi çağırarak bu observe leri kaldırabilirsiniz.

LiveData da depolanan nesneleri güncellediğinde ekli olan LifeCycleOwner aktif durumda olduğu sürece tüm observe leri tetikler.

LiveData UI bileşenlerin güncellemelerine izin verir. LiveData nesneleri tarafından tutulan veriler değiştiğinde tüm veriler otomatik güncellenmiş olur.

Çok konuştuk biraz da kod gösterelim

Öncelikle gradle dosyasına çalışmamız gereken kütüphaneleri ekleyelim.

def lifecycle_version = "2.2.0"
    // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // Annotation processor
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"

En üstteki Kapt eklentisini eklemeyi unutmayalım.

apply plugin: ‘kotlin-kapt’

Yapacağımız uygulamada kütüphaneleri projemize eklemiş olduk. Temel yapıda livedata yı ekleyelim

class BasicViewModel : ViewModel() {

    private lateinit var timer: CountDownTimer
    private val _seconds = MutableLiveData<Int>()
    private val finished = MutableLiveData<Boolean>()

    var _finished : LiveData<Boolean> = finished

    fun seconds() : LiveData<Int>
    {
         return _seconds
    }

    fun startTimer()
    {
         timer = object : CountDownTimer(10000,1000)
         {
             override fun onFinish() {
                 finished.value = true
             }

             override fun onTick(millisUntilFinished: Long) {
                 val timeLeft = millisUntilFinished/1000
                 _seconds.value = timeLeft.toInt()
             }

         }.start()
    }

    fun stopTimer()
    {
         timer.cancel()
    }
}

class LiveDataBasicActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_live_data_basic)

        val viewModel = ViewModelProvider(this).get(BasicViewModel::class.java)

        viewModel.seconds().observe(this, Observer {
            txtCounter.text = it.toString()
        })

        viewModel._finished.observe(this, Observer {
            if (it)
                Toast.makeText(this, "Finished !!", Toast.LENGTH_SHORT).show()
        })

        btStart.setOnClickListener{
            viewModel.startTimer()
        }
        btStop.setOnClickListener{
            viewModel.stopTimer()
            txtCounter.text = getString(R.string.value)
        }

    }
}

Yukarıda 10 saniyeden başlayan CountDownTimer’ı kullandığım BasicViewModel sınıfımız var ve her onTick te değerini _second MutableLiveData nesnesine eşitliyor ve daha sonra LiveData türünü saniye türünü döndürüyorum.

Bana zaman ayırdığınız için teşekkür ederim. Bol kodlu günler... :)