LifecycleOwner — bu nədir, Jetpack interfeysi və hadisələrə abunəlik

LifecycleOwner nədir?

LifecycleOwner — androidx.lifecycle paketindən olan interfeysdir ki, tək metodu — Lifecycle obyektini qaytaran getLifecycle() metodunu ehtiva edir. Bu obyekt komponentin cari vəziyyətini (CREATED, STARTED, RESUMED, DESTROYED) izləyir və dəyişdikdə bütün abunə olunmuş müşahidəçiləri xəbərdar edir. LifecycleOwner Architecture Components-in bir hissəsidir və lifecycle-runtime kitabxanasına daxildir.

İnterfeysin əsas vəzifəsi — həyat dövrünə girişi standartlaşdırmaqdır. Jetpack-in yaranmasından əvvəl tərtibatçılar onStart-da əl ilə abunəlik və onStop-da abunəlikdən çıxma istifadə edirdilər, bu da kodun təkrarlanmasına və səhvlərə səbəb olurdu. LifecycleOwner bu problemi bütün Android komponentləri üçün vahid mexanizm təqdim edərək həll edir. Həyat dövrü metodlarının açıq şəkildə çağırılması əvəzinə, tərtibatçı Lifecycle-a bir dəfə abunə olur və bildirişlər avtomatik gəlir.

İnterfeys Kotlin-də bir abstrakt metodu olan funksional interfeys kimi bəyan edilmişdir:

interface LifecycleOwner {
    val lifecycle: Lifecycle
}

İnterfeysin funksional xarakteri sayəsində onu delegat və ya lambda vasitəsilə realizə etmək asandır. Bu, xüsusilə Custom Views və hostun həyat dövrü dəyişikliklərinə reaksiya verməli olan ViewModel sinifləri yaratmaq üçün əlverişlidir. getLifecycle()-dən alınan Lifecycle obyekti abunəlikləri idarə etmək üçün addObserver və removeObserver metodlarını təqdim edir.

LifecycleOwner necə işləyir

LifecycleOwner iki əsas siniflə birlikdə işləyir: Lifecycle və LifecycleObserver. Lifecycle komponentin cari vəziyyətini State enum (INITIALIZED, CREATED, STARTED, RESUMED, DESTROYED) şəklində saxlayır və onlar arasında keçidləri izləyir. Vəziyyət dəyişdikdə, Lifecycle bütün qeydiyyatdan keçmiş müşahidəçiləri xəbərdar edir, müvafiq annotasiya olunmuş metodları çağırır. Bu mexanizm "lifecycle-aware" adlanır — kod yalnız komponent müvafiq vəziyyətdə olduqda icra olunur.

Hadisələrin ötürülmə mexanizmi Observer naxışına əsaslanır. LifecycleOwner Observable rolunu oynayır, LifecycleObserver realizasiyası isə Observer rolunu oynayır. Activity və ya Fragment öz vəziyyətini dəyişdikdə (onCreate → onStart → onResume → onPause → onStop → onDestroy) AndroidX sisteminə avtomatik əlavə olunan daxili ReportFragment mexanizmi vasitəsilə Lifecycle-ı xəbərdar edir. Tərtibatçı Lifecycle metodlarını əl ilə çağırmalı deyil — hər şey avtomatik baş verir.

Vacib detal: Lifecycle ON_STOP və ON_DESTROY hadisələrinin prosesin qəza ilə başa çatması halında belə çatdırılacağına zəmanət verir. Bu, LifecycleOwner-ı kritik resursları azad etmək üçün etibarlı alət edir. Adi vəziyyətin saxlanması üçün ViewModel-də SavedStateHandle istifadə etmək tövsiyə olunur, lakin LifecycleOwner əsas təhlükəsizlik səviyyəsini təmin edir.

LifecycleObserver və DefaultLifecycleObserver

LifecycleOwner hadisələrinə abunə olmağın iki yolu var: klassik anotasiyalı LifecycleObserver və müasir açıq metodlu DefaultLifecycleObserver. İkinci yanaşma Google tərəfindən 2022-ci ildən tövsiyə olunur, çünki daha yaxşı tip təhlükəsizliyi təmin edir və anotasiya yanaşmasında istifadə olunan refleksiyadan qaçır. DefaultLifecycleObserver Java 8+ və ya Kotlin tələb edir və yeni layihələr üçün üstünlük verilir.

DefaultLifecycleObserver vasitəsilə abunəlik nümunəsi:

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // GPS izləmənin işə salınması yalnız komponent aktiv olduqda
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        // Fon rejiminə keçid zamanı təhlükəsiz dayandırma
        stopLocationUpdates()
    }
}

// Qoşulma:
lifecycleOwner.lifecycle.addObserver(MyObserver())

DefaultLifecycleObserver-ın hər bir metodu parametr olaraq LifecycleOwner qəbul edir. Bu, müşahidəçiyə icra olunan komponentin kontekstinə ayrıca ötürmədən daxil olmağa imkan verir. Bu yanaşma kodu daha modul və test edilə bilən edir — Observer Activity və ya Fragment-in konkret realizasiyasından asılı deyil, LifecycleOwner abstraksiyası ilə işləyir.

LifecycleObserver anotasiya yanaşması

@OnLifecycleEvent anotasiyası ilə köhnə üsul hələ də legacy layihələrdə rast gəlinir, lakin yeni kod üçün tövsiyə edilmir. Anotasiyaların işlənməsi üçün zəruri olan refleksiya əlavə yük yaradır və kompilasiya mərhələsində aşkar edilməyən səhvlərə səbəb ola bilər. Google rəsmi olaraq DefaultLifecycleObserver-a keçidi tövsiyə edir.

// Köhnəlmiş yanaşma — yeni layihələr üçün tövsiyə edilmir
class MyLegacyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        startLocationUpdates()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        stopLocationUpdates()
    }
}

Anotasiya yanaşmasının əhəmiyyətli çatışmazlığı var: Observer-in həyat müddətinə nəzarətin olmaması. Əgər tərtibatçı LifecycleOwner məhv olduqda Observer-i abunəlikdən çıxarmağı unudarsa, Observer obyekti zibil toplayıcı işə düşənə qədər yaddaşda qalır. DefaultLifecycleObserver bu problemi həll edir — Observer Lifecycle-a bağlıdır və DESTROYED vəziyyətinə keçid zamanı avtomatik abunəlikdən çıxarılır.

Activity və Fragment-də LifecycleOwner

AppCompat 1.1.0 və AndroidX Fragment 1.2.0-dən başlayaraq, AppCompatActivity və ya Fragment-dən törəyən bütün Activity və Fragment avtomatik olaraq LifecycleOwner-dır. Bu o deməkdir ki, getLifecycle() metodu onlarda defolt olaraq mövcuddur və həyat dövrü hadisələrinə abunəlik əlavə konfiqurasiya olmadan işləyir. Tərtibatçı yalnız Activity və ya Fragment-in istənilən yerindən lifecycle.addObserver() çağırmalıdır.

Activity-də LifecycleOwner inteqrasiyası nümunəsinə baxaq:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(LocationObserver(this))
    }
}

Bu nümunədə lifecycle — AndroidX Activity sayəsində mövcud olan extension property-dir. LocationObserver Observer-i Activity-nin başlaması (ON_START) və dayanması (ON_STOP) barədə avtomatik bildirişlər alacaq. Ekran fırlananda Observer ON_DESTROY və daha sonra ON_CREATE barədə xəbərdar edilir ki, bu da əlavə kod olmadan konfiqurasiya dəyişikliklərini düzgün idarə etməyə imkan verir.

Fragment-də LifecycleOwner

Fragment interfeys vasitəsilə LifecycleOwner-ı realizə edir və onun Lifecycle-i Fragment-in həyat dövrünə bağlıdır, valideyn Activity-yə deyil. Bu vacibdir: Fragment-in Lifecycle-i Fragment tranzaksiyadan silindikdə DESTROYED vəziyyətinə keçir, Activity isə RESUMED vəziyyətində qala bilər. Bu fərq Observer-ə hər bir komponentin həyat dövrünü ayrıca abunə etməyə imkan verir.

class MyFragment : Fragment() {
    private val uiStateObserver = UiStateObserver()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        lifecycle.addObserver(uiStateObserver)
    }
}

Fragment-də LifecycleOwner istifadəsinin mühüm üstünlüyü — Fragment DESTROYED vəziyyətinə keçdikdə avtomatik abunəlikdən çıxmadır. Bu, xüsusilə Fragment-lərin dinamik yaradıldığı və məhv edildiyi ViewPager üçün aktualdır. Bu ssenaridə əl ilə abunəlik idarəsi son dərəcə mürəkkəb və səhvlərə açıq olardı.

Xüsusi LifecycleOwner yaratmaq

LifecycleOwner interfeysi həyat dövrü olan istənilən sinifdə realizə edilə bilər. Bu, Custom Views, Service və hətta bəzi arxitektura həllərində ViewModel üçün faydalıdır. Google Lifecycle-in vəziyyətini idarə edən və hadisələr yaradan köməkçi LifecycleRegistry sinfini təqdim edir. Tərtibatçı komponentin vəziyyəti dəyişdikdə LifecycleRegistry-nin müvafiq metodlarını əl ilə çağırmalıdır.

Custom View-də LifecycleOwner realizasiyası nümunəsi:

class MyCustomView(
    context: Context,
    attrs: AttributeSet?
) : FrameLayout(context, attrs), LifecycleOwner {

    private val lifecycleRegistry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry

    fun onStart() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED)
    }

    fun onStop() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED)
    }
}

Bu nümunədə LifecycleRegistry vəziyyət anbarı rolunu oynayır. onStart/onStop metodları valideyn komponent (məsələn, Activity) tərəfindən Custom View görünən və ya gizlənən zaman çağırılmalıdır. LifecycleRegistry vəziyyətlər arasında keçid üçün lazımi hadisələri avtomatik hesablayır və bütün abunə olunmuş Observer-ləri xəbərdar edir.

Xüsusi LifecycleOwner realizasiyası zamanı qaydaya riayət etmək vacibdir: LifecycleRegistry-nin vəziyyəti həyat dövrünün müvafiq metodunda, bütün digər əməliyyatlardan sonra ən sonda yenilənməlidir. Bu, Observer-lərin komponent yeni vəziyyətə tam hazır olduqda bildiriş almasını təmin edir. LifecycleRegistry.createUnsafe alternativ olaraq istifadə edilə bilər, lakin ipliklərlə diqqət tələb edir.

Jetpack komponentlərində LifecycleOwner

LifecycleOwner bir neçə əsas Android Jetpack komponenti üçün təməldir. LiveData aktiv vəziyyəti müəyyən etmək və komponent məhv olduqda avtomatik abunəlikdən çıxmaq üçün LifecycleOwner-dan istifadə edir. ViewModel birbaşa LifecycleOwner-ı realizə etmir, lakin SavedStateHandle vasitəsilə Lifecycle ala bilər. Navigation Component NavBackStackEntry-də abunəlikləri idarə etmək üçün LifecycleOwner-dan istifadə edir. Bu əlaqəni başa düşmək tətbiq arxitekturasını möhkəm təməl üzərində qurmağa kömək edir.

LiveData-nın LifecycleOwner ilə qarşılıqlı əlaqəsi:

class ExampleActivity : AppCompatActivity() {
    private val viewModel: ExampleViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        viewModel.userData.observe(this) { data ->
            // this — LifecycleOwner (Activity)
            // Kod yalnız Activity RESUMED vəziyyətində olduqda icra olunur
            updateUI(data)
        }
    }
}

LiveData observe() metodunda LifecycleOwner tələb edir, çünki bu, UI yeniləmələrinin yalnız aktiv vəziyyətdə baş verəcəyinə zəmanət verir. Activity fondadırsa, LiveData son dəyəri saxlayır, lakin Observer-i xəbərdar etmir. RESUMED vəziyyətinə qayıtdıqda, Observer şəbəkəyə və ya verilənlər bazasına əlavə sorğular olmadan aktual dəyəri alır.

DataBinding də observable sahələri Activity və ya Fragment-in həyat dövrünə bağlamaq üçün LifecycleOwner-dan istifadə edir. Bu, ViewModel + DataBinding birləşməsində yaddaş sızmalarının qarşısını almağa imkan verir — bütün abunəliklər LifecycleOwner məhv olduqda avtomatik təmizlənir. Bu yanaşma kodu deklarativ və təhlükəsiz edir.

İstifadə üzrə tövsiyələr

LifecycleOwner-dan düzgün istifadə bir neçə əsas qaydaya riayət etməyi tələb edir. Birinci və ən vacib: Observer-i həmişə onCreate/onViewCreated-da abunə edin, daha gec yox. Bu, Observer-in Lifecycle-ın ilkin vəziyyətini (onCreate-dən sonra CREATED) almasını və hadisələri qaçırmamasını təmin edir. İkinci qayda: bütün yeni layihələr üçün anotasiya yanaşması əvəzinə DefaultLifecycleObserver istifadə edin.

• LifecycleOwner referansını statik sahələrdə və ya sinqletonlarda saxlamayın — bu, bütün Activity-nin sızmasına səbəb olur
• Vəziyyətə həssas əməliyyatları icra etməzdən əvvəl getCurrentState() vasitəsilə Lifecycle vəziyyətini yoxlayın
• Observer-ləri lambda daxilində yaratmayın — hər bir rekompozisiya yeni obyekt yaradacaq və köhnə Observer-lər avtomatik abunəlikdən çıxmayacaq
• Korutinlər üçün repeatOnLifecycle istifadə edin — blok müəyyən edilmiş vəziyyətə daxil olduqda işə düşür və vəziyyətdən çıxdıqda ləğv edilir
• Fon iplikdən LifecycleRegistry-də setCurrentState çağırmayın — bu, həyat dövrünün tək iplikli zəmanətlərini pozur

Korutinlər və LifecycleOwner ilə işin müasir yanaşması — repeatOnLifecycle genişlənməsi:

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.flow.collect { value ->
            updateUI(value)
        }
    }
}

Bu naxış collect-in Flow-da yalnız STARTED və ya RESUMED vəziyyətində aktiv olmasına zəmanət verir. STOPPED vəziyyətinə keçdikdə kolleksiya avtomatik ləğv edilir, STARTED vəziyyətinə qayıtdıqda isə yenidən başladılır. repeatOnLifecycle Fragment-də Flow-dan əl ilə abunəlikdən çıxmanı əvəz edir və UI komponentlərində asinxron məlumat axınları ilə işləmək üçün Google tərəfindən tövsiyə olunan yanaşmadır.

Digər vacib tövsiyə: LifecycleObserver-dan həyat dövrü ilə əlaqəli olmayan məntiq üçün çox istifadə etməyin. Əgər komponent müəyyən vəziyyətdə hərəkət yerinə yetirməlidirsə, lakin məhv olduqda abunəlikdən çıxma tələb etmirsə, onStart/onStop-da metodların açıq şəkildə çağırılmasından istifadə etmək daha yaxşıdır. LifecycleObserver uzunömürlü komponentlər (LocationListener, SensorManager) üçün əsaslandırılmışdır, burada əl ilə abunəlik idarəsi mürəkkəb və səhvlərə açıqdır.