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.
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 birLiveData
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 olunViewModel
veri getirme sorumluluğudur (örneğin, bir ağdan). Bunun yerineViewModel
ş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
veyaActivity
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 ancakonStop()
ç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ümbeta 2
ve öncesi.
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
- Android Mimari Bileşenleri Temel Örneği
- gösteren bir demo uygulaması olan Sunflower, Mimari Bileşenleri
Codelab'ler
Bloglar
ziyaret edin.Sizin için önerilenler
- Not: JavaScript kapalıyken bağlantı metni gösterilir
- LiveData'ya genel bakış
- Yaşam döngüsüne duyarlı bileşenlerle Kotlin eş yordamlarını kullanma
- ViewModel için Kayıtlı Durum modülü