Yaşam Döngüsüne Duyarlı Bileşenlerle Yaşam Döngülerini Yönetme Android Jetpack'in bir parçasıdır.

Yaşam döngüsüne duyarlı bileşenler, etkinlikler ve parçalar gibi başka bir bileşenin yaşam döngüsü durumunu kontrol eder. Bu bileşenler daha iyi düzenlenmiş ve genellikle daha hafif kodlar üretmenize yardımcı olur kolay bir yoludur.

Bağımlı bileşenlerin işlemlerini yaşam döngüsü yöntemlerini kapsar. Ancak bu model ve hataların çoğalmasına yol açabilir. Şunu kullanarak: yaşam döngüsüne duyarlı bileşenlerden sonra bağımlı bileşenlerin kodunu bileşenlerine ayıralım.

androidx.lifecycle paketi yaşam döngüsüne duyarlı geliştirmenizi sağlayan sınıflar ve arayüzler sunar bileşenlerine otomatik olarak ayarlama yapabilen mevcut yaşam döngüsü durumuna göre belirlenen davranışları ifade eder.

Android Çerçevesi'nde tanımlanan uygulama bileşenlerinin çoğunda yaşam döngüleri bulunur. Yaşam döngüleri, işletim sistemi veya işleminizde çalışan çerçeve kodunu da kullanabilirsiniz. Android'in işleyişinin temelini oluştururlar ve uygulamanız da bunlara saygı göstermelidir. Bunu yapmazsanız bellek sızıntıları veya hatta çökebilir.

Ekranda cihazın konumunu gösteren bir etkinliğimiz olduğunu varsayalım. CEVAP yaygın uygulama aşağıdaki gibi olabilir:

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Java

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Bu örnek iyi görünse de gerçek bir uygulamada çok fazla mevcut duruma yanıt olarak kullanıcı arayüzünü ve diğer bileşenleri yöneten çağrılar. kapanış aşamasına geçiş yapacağız. Birden fazla bileşenin yönetilmesi, yaşam döngüsü yöntemlerinde [ör. onStart() ve onStop(), bu da bakımı zorlaştırıyor.

Ayrıca, bileşenin etkinlikten veya parçası durdurulduğundan emin olun. Bu, özellikle de birden fazla reklam öğesi onStart() ürününde yapılan yapılandırma kontrolleri gibi uzun süreli işlemler. Bu, onStop() yönteminin onStart() öncesinde sona erdiği ve bileşenin daha uzun süre canlı tutulduğu bir yarış koşuluna neden olabilir. gerekir.

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

androidx.lifecycle paketi, bu problemleri hızlı ve kolay bir şekilde ele almanıza bir yöntem bulmaktır.

Yaşam döngüsü

Lifecycle bir sınıftır bir bileşenin yaşam döngüsü durumuyla ilgili bilgileri barındıran (ör. etkinliği veya bir parça) oluşturur ve diğer nesnelerin bu durumu gözlemlemesine olanak tanır.

Lifecycle iki ana cihaz kullanır numaralandırmalarını kullanabilirsiniz:

Etkinlik
Çerçeveden dağıtılan yaşam döngüsü etkinlikleri ve Lifecycle sınıfı. Bu etkinlikleri, etkinlikler ve parçalardaki geri çağırma etkinlikleriyle eşlenir.
Eyalet
Google Cloud Platform tarafından izlenen bileşenin Lifecycle nesnesini ifade eder.
Yaşam döngüsü durumlarının şeması
Şekil 1. Android etkinliğini oluşturan durumlar ve etkinlikler yaşam döngüsü
ziyaret edin.

Durumları bir grafiğin düğümleri, olayları ise bu düğümleri devre dışı bırakabilirsiniz.

Bir sınıf, DefaultLifecycleObserver ve onCreate, onStart vb. gibi karşılık gelen yöntemleri geçersiz kılarak. Sonra addObserver() Lifecycle yöntemi sınıfını ve gözlemcinizin bir örneğini aşağıdaki şekilde ileterek örnek:

Kotlin

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

Java

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

Yukarıdaki örnekte, myLifecycleOwner nesnesi LifecycleOwner kullandığınızdan emin olun.

LifecycleOwner

LifecycleOwner bir sınıfının, kalite puanının veya mevcut Lifecycle. Bir tane var yöntemini, getLifecycle() Sınıf tarafından uygulanması gerekir. Bir uygulamanın yaşam döngüsünü yönetmeye çalışıyorsanız bkz. ProcessLifecycleOwner.

Bu arayüz, bir Bireysel abonelikten Lifecycle Fragment ve AppCompatActivity gibi sınıfların yanı sıra yardımcı olabilirsiniz. Herhangi bir özel uygulama sınıfı LifecycleOwner kullanır.

Uygulanan bileşenler DefaultLifecycleObserver etkili bir şekilde çalışan bileşenlerle LifecycleOwner çünkü sahip, gözlemcinin kaydedebileceği yaşam döngüsünü izleyin.

Konum izleme örneğinde, MyLocationListener sınıfını yapabiliriz. DefaultLifecycleObserver'i uygulama ve ardından etkinliğin onCreate() yönteminde Lifecycle. Bu, MyLocationListener sınıfının kendi kendine yeterli olduğunu, diğer bir deyişle mantığın yaşam döngüsü durumundaki değişikliklere tepki verme bunun yerine MyLocationListener içinde bildirildi teşvik edebilirsiniz. Ayrı bileşenlerin kendi mantığını saklaması, daha kolay yönetilmesini sağlar.

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
            // update UI
        });
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
  }
}

Yaygın kullanım alanlarından biri, Lifecycle iyi durumda değil hemen şimdi. Örneğin, geri çağırma işlevi bir kilitlenmeyi tetikler. Bu yüzden, hiçbir zaman bu geri çağırmayı kullanır.

Bu kullanım alanını kolaylaştırmak için Lifecycle sınıfı izin veriyor mevcut durumu sorgulamak için başka nesneler kullanır.

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

Java

class MyLocationListener implements DefaultLifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

Bu uygulama sayesinde LocationListener sınıfımız tamamen elde edebiliyorlar. Başka bir etkinlikten LocationListener kullanmamız gerekirse bunu ilk kullanıma hazırlamamız gerekir. Tüm kurulum ve söküm işlemleri sınıfın kendisi tarafından yönetilir.

Bir kitaplık, Android yaşam döngüsüyle çalışması gereken sınıflar sağlıyorsa yaşam döngüsüne duyarlı bileşenler kullanmanızı öneririz. Kitaplık müşterileriniz şunları yapabilir: Bu bileşenleri şurada manuel yaşam döngüsü yönetimi olmadan, kolayca entegre edebilirsiniz: çok önemli.

Özel bir Yaşam Döngüsü Sahibi uygulama

Destek Kitaplığı 26.1.0 ve sonraki sürümlerde uygulanan Parçalar ve Etkinlikler LifecycleOwner kullanır.

Oluşturmak istediğiniz özel bir sınıfınız varsa LifecycleOwner, siz URL'leri Yaşam Döngüsü Kaydı sınıfını tanımlar ancak etkinlikleri aşağıda gösterildiği gibi bu sınıfa yönlendirmeniz gerekir. kod örneği:

Kotlin

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

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

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

Yaşam döngüsüne duyarlı bileşenler için en iyi uygulamalar

  • Kullanıcı arayüzü denetleyicilerinizi (etkinlikler ve parçalar) mümkün olduğunca sade tutun. Onlar kendi verilerini elde etmeye çalışmamalıdır; bunun yerine bir Bunu yapmak için ViewModel, ve bir LiveData nesnesini ifade eder.
  • Kullanıcı arayüzü denetleyicinizin sorumluluğunda olan veri odaklı kullanıcı arayüzleri yazmaya çalışın. veriler değiştikçe görünümleri güncelleyin veya kullanıcı eylemlerini ViewModel.
  • Veri mantığınızı ViewModel sınıfı. ViewModel yayınlanmalı kullanıcı arayüzü denetleyiciniz ile uygulamanızın geri kalanı arasındaki bağlayıcı işlevi görür. dikkatli olun ViewModel veri getirme sorumluluğudur (örneğin, bir ağdan). Bunun yerine ViewModel şunu aramalıdır: uygun bileşeni kullanıp sonuçları tekrar kullanıcı arayüzü denetleyicisi.
  • Veri Bağlantısı kullanarak ve kullanıcı arayüzü denetleyicisi arasındaki temiz bir arayüze sahip olursunuz. Bu şekilde şunları yapabilirsiniz: görüntülemelerinizi daha açıklayıcı hale getirin ve Google Ads'de kullanmanız için gereken güncelleme kodunu etkinliklerinizi ve parçalarınızı yazın. Bunu Java'da yapmayı tercih ederseniz programlama dili gibi bir kitaplık kullanın. Ortak metin olmaması için Tereyağı Bıçağı ve daha iyi bir soyutlamaya sahip olursunuz.
  • Kullanıcı arayüzünüz karmaşıksa sunucu sınıfını kullanır. Bu zahmetli bir iş olabilir ancak kullanıcı arayüzü bileşenlerinizi daha kolay test edin.
  • Bir View veya Activity referansından kaçının bağlamını ViewModel öğrenebilirsiniz. ViewModel etkinliği sona ererse (yapılandırma değişiklikleri durumunda) ve çöp toplayıcı tarafından düzgün bir şekilde atılmadığından emin olun.
  • Yönetmek için Kotlin eş yordamlarını kullanın ve eşzamansız olarak çalıştırılabilen diğer işlemleri kapsar.

Yaşam döngüsüne duyarlı bileşenler için kullanım alanları

Yaşam döngüsüne duyarlı bileşenler, yaşam döngülerini yönetmenizi çok daha kolay hale getirebilir çeşitli durumlarda. Aşağıda birkaç örnek verilmiştir:

  • Yaklaşık ve ayrıntılı konum güncellemeleri arasında geçiş yapma. Tekliflerinizi otomatikleştirmek ve optimize etmek için ayrıntılı konum güncellemeleri sağlamak için yaşam döngüsüne duyarlı bileşenleri uygulaması görünür olduğunda ve genel güncellemelere geçiş yaparken arka planda çalışır. Yaşam döngüsüne duyarlı bir bileşen olan LiveData kullanıcınız değiştiğinde uygulamanızın kullanıcı arayüzünü otomatik olarak güncellemesine olanak tanır. yerler.
  • Video arabelleğe alma işlemi durduruluyor ve başlatılıyor. Başlamak için yaşam döngüsüne duyarlı bileşenler kullanın video en kısa sürede arabelleğe alınacak, ancak uygulama tam olarak görüntülenene kadar oynatmayı ertele başladı. Arabelleğe alma işlemini sonlandırmak için yaşam döngüsüne duyarlı bileşenleri de kullanabilirsiniz. .
  • Ağ bağlantısını başlatma ve durdurma. Yaşam döngüsüne duyarlı bileşenleri kullanarak bir uygulama etkinken ağ verilerinin canlı güncellenmesini (akışını) etkinleştir ve ayrıca uygulama masaüstünüze girdiğinde otomatik arka plan.
  • Animasyonlu çekilebilir öğeleri duraklatma ve devam ettirme Yaşam döngüsüne duyarlı bileşenleri kullanarak Uygulama arka plandayken animasyonlu çekilebilir öğeleri duraklatma tutma yeri Uygulama ön plana geldikten sonra çekilebilir öğeleri devam ettirebilir.

Durdurma etkinliklerini işleme

Bir Lifecycle, AppCompatActivity üyesine ait olduğunda veya Fragment, Lifecycle durumu şu şekilde değişir: CREATED ve ON_STOP etkinlik, AppCompatActivity veya Fragment adlı kullanıcının onSaveInstanceState() çağrılır.

Fragment veya AppCompatActivity öğesinin durumu şununla kaydedildiğinde: onSaveInstanceState(), kullanıcı arayüzü kadar sabit kabul edilir. ON_START çağrıldı. Durum kaydedildikten sonra kullanıcı arayüzünde değişiklik yapmaya çalışmak, uygulamanızın gezinme durumundaki tutarsızlıklardır. Bu nedenle, FragmentManager Durum kaydedildikten sonra FragmentTransaction. Görüntüleyin Ayrıntılı bilgi için commit().

LiveData gözlemcinin ilişkili Lifecycle ise gözlemcisini çağırmasını engeller en azından şu değil: STARTED. Perde arkasında isAtLeast() birini çağırın.

Maalesef AppCompatActivity adlı kullanıcının onStop() yöntemi sonra çağrılıyor onSaveInstanceState(), Bu, kullanıcı arayüzü durumu değişikliklerine izin verilmeyen ancak Lifecycle henüz CREATED durumu.

Bu sorunu önlemek için beta2 sürümündeki Lifecycle sınıfı ve aşağıyı seçerek durumu şu şekilde işaretleyin: CREATED geçerli izleme kodunu kontrol eden herhangi bir kod, etkinliği durum, sistem tarafından onStop() çağrılana kadar etkinlik dağıtılmasa da gerçek değeri alır.

Maalesef bu çözümün iki önemli sorunu var:

  • API düzeyi 23 ve altında, Android sistemi aslında bir kısmen başka bir etkinlik kapsamında olsa bile etkinlik. Başka kelime, Android sistemi onSaveInstanceState() çağırır ancak onStop() çağırması gerekmez. Bu, potansiyel bir gözlemcinin yaşam döngüsünün hâlâ aktif olduğunu düşündüğü uzun aralık ancak kullanıcı arayüzü durumu değiştirilemez.
  • LiveData sınıfının, Lifecycle sürüm beta 2 ve öncesi.
ziyaret edin. Activity

Ek kaynaklar

Yaşam döngüsüne duyarlı bileşenlerle yaşam döngülerini yönetme hakkında daha fazla bilgi için aşağıdaki ek kaynaklara başvurun.

Örnekler

Codelab'ler

Bloglar

ziyaret edin. ziyaret edin.