Android Architecture Components, Lifecycle-aware Components

Android Architecture Components, farklı görevler için kütüphaneler içeren bir rehberdir, belirli görevler için bazı kütüphaneler vardır.Örneğin veritabanından bir veri almak isteniliyorsa, bunun için bir kütüphane kullanılır.Android Architecture Components, test edilebilir, bakımı kolay ve daha az koda sahip uygulamalar oluşturmanıza yardımcı olur. Android Architecture Components, Android Jetpack‘in bir parçasıdır.

Android Jetpack

Android Jetpack, Android geliştiricilerinin daha yüksek kaliteli uygulamalar yazabilmesine yardımcı olmak için, bazı component ve araçların bir bütünüdür.Jetpack, Android Support Library ve Architecture Componentleri bir araya getirerek 4 başlık altında toplar.

Resim-1

Bunlar Resim 1 Android Jetpack ‘te görüldüğü gibi Architecture, UI, Behavior, Foundation bileşenleridir.Bu makalede Architecture başlığı altındaki Lifecycles bileşeninden bahsedilecektir.

Lifecycle-aware Components

Lifecycle-aware Components, activity veya fragment gibi diğer bileşenlerin yaşam döngüsünün farkında olan ve bu bileşenin yaşam döngüsü durumundaki değişikliğe yanıt olarak bazı eylemler gerçekleştiren bir bileşendir.

Neden Lifecycle-aware Components ‘e ihtiyaç duyulur?

Örneğin;

• Kullanıcının uygulamayı açar açmaz konumunu izleyen bir uygulamada, uygulama ön planda ise kullanıcının konumunu ekranda göstermeli veya ön planda değilse veritabanında saklamalıdır. Ayrıca, uygulama kapalıyken ise kullanıcının konumunu izlemeyi bırakması gerekir.
• Müzik/Video akışı oynatılan bir uygulamada, başka bir uygulamaya geçildiğinde akışı durdurup arabelleğe almayı tekrar ön plana döndüğünde ise arabelleğe almayı durdurmak ve yeniden başlatmak istenilir.

Android Architecture Components, veri tutarlılığını, Lifecycle‘ı yönetilmesine yardımcı olmayı, uygulamaların modüler olması, memory leak’lerden kaçınılması ve tekrar eden kodlardan kurtulmasına yardımcı olmayı amaçlıyor.

Resim-2

Resim 2 LifeCycle’daki örnekte bir Activity vardır ve bu Activity bir LifeCycle (yaşam döngüsü)’ a sahiptir, bu acitivity LifeCycleOwner olarak adlandırılır. Böylece yaşam döngüsü olan herhangi bir activity’i veya parça LifecycleOwner olarak çağrılabilir.

Lifecycle-aware Components, bu yaşam döngüsü sınıfı tanımlamak için event, state kullanılır. Yani her event bir state ile ilgilidir.

onCreate() event'ı için yaratılacak olan state -> CREATED
onStart() event'ı için yaratılacak olan state -> STARTED
onPause() event'ı için yaratılacak olan state -> PAUSED
onResume () event'ı için yaratılacak olan state -> RESUMED
onDestroy() event'ı için yaratılacak olan state -> DESTROYED
onStop() event'ı için yaratılacak olan state -> STOPPED

LifecycleObserver yaşam döngüsünü gözlemler ve buna göre eylemleri gerçekleştirir.Böylece LifecycleObserver, LifeCycleOwner’ın yaşam döngüsünü gözlemler ve işlemi gerçekleştirir.

Bu şekilde LifeCycleOwner, LifeCycle ve LifecycleObserver ilişkilidir.

Lifecycle-aware Components Demo

Lifecycle-aware bileşenini incelemek için Android Studio’ya gidip Empty Activity şablolunu seçerek Kotlin dili ile yazacağımız LifecycleAwareDemo isimli bir uygulama oluşturalım.

Gradle Scripts altında bulunan build.gradle(Module: app) içerisindeki dependencies kod bloğuna lifecycle bağımlılıklarının eklenmesi gerekir.

def lifecycle_version = "2.2.0"
implementation "android.arch.lifecycle:extensions:$lifecycle_version"
annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"

MainActivityObserver isminde LifeCycleOwner’ın yaşam döngüsünü gözlemleyecek ve eylemleri buna göre gerçekleştirecek bir gözlemci sınıfı yaratılması gerekir.

Oluşturulan bu MainActivityObserver sınıfı LifecycleObserver ‘dan extend edilir.

import androidx.lifecycle.LifecycleObserver

class MainActivityObserver : LifecycleObserver{
}

LifecycleOwner olan MainActivity’i gözlemlemek için bu observer’ın atanması gerekir.

lifecycle.addObserver(MainActivityObserver())

MainActivityObserver sınıfında onCreate, onStart, onResume, onPause, onStop, onDestroy eylemini yürütecek kullanıcı tanımlı işlevler yazılır.

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class MainActivityObserver : LifecycleObserver{

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreateEvent() {
Log.i(TAG, "Observer ON_CREATE")
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStartEvent() {
Log.i(TAG, "Observer ON_START")
}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResumeEvent() {
Log.i(TAG, "ObserverON_RESUME")
}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPauseEvent() {
Log.i(TAG, "Observer ON_PAUSE")
}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStopEvent() {
Log.i(TAG, "Observer ON_STOP")
}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroyEvent() {
Log.i(TAG, "Observer ON_DESTROY")
}

companion object {
private val TAG: String = MainActivityObserver::class.java.simpleName
}
}

Log ifadeleri MainActivity sınıfına da eklenir.

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log

class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

Log.i(TAG, "Owner onCreate")
lifecycle.addObserver(MainActivityObserver())
}

override fun onStart() {
super.onStart()
Log.i(TAG, "Owner onStart")
}

override fun onPause() {
super.onPause()
Log.i(TAG, "Owner onPause")
}

override fun onResume() {
super.onResume()
Log.i(TAG, "Owner onResume")
}

override fun onDestroy() {
super.onDestroy()
Log.i(TAG, "Owner onDestroy")
}

override fun onStop() {
super.onStop()
Log.i(TAG, "Owner onStop")
}

companion object {
private val TAG: String = MainActivity::class.java.simpleName
}
}

Uygulama çalıştırılıp, LogCat penceresine göz atılırsa,

Resim-3

LogCat çıktısında uygulama çalıştırıldığında Owner’ın methodunun önce çalıştırıldığı ardından Observer’ın çalıştığı gözlemlenir.

Resim-4

LogCat çıktısında gördüğümüz gibi uygulamadayken geri tuşuna bastığımızda Observer’ın methodunun önce çalıştırıldığı ardından Owner’ın çalıştığı gözlemlenir.

Özetlenecek olursa,

• LifeCycle’a duyarlı component diğer UI bileşeninin yaşam döngüsü durumundaki değişikliğe yanıt verebilir.
• LifeCycle sınıfı, Fragment ve Activity yaşam döngüsü hakkındaki bilgileri tutmuştur.
• LifeCycle nesnesi, yaşam döngüsü durumunu izlemek için Event ve State kullanır.
• LifeCycleOwner, Lifecycle-aware Component ‘e state sağlar.
• LifeCycleObserver, eylemi yanıtlamak ve gerçekleştirmek için yaşam döngüsü durumunu kaydeder.

Uygulamanın GitHub linkine buradan ulaşabilirsiniz.

Bir sonraki yazıda belirli bir LifeCycle ‘a bağlı nesneler oluşturmak ve almak için kullanılan ViewModel konusuna değinilecektir.

Bu konuyla ilgili sorularınızı  alt kısımda bulunan yorumlar alanını kullanarak sorabilirsiniz.

Referanslar:
www.mshowto.org

TAGs : Lifecycle-aware Components, LifeCycle, LifeCycleOwner, LifeCycleObserver, Android Jetpack, Android Architecture Component, Lifecycle-aware Components nedir