En iyi uygulamaları izleme

Compose'da sık karşılaşılan sorunlarla karşılaşabilirsiniz. Bu hatalar, yeterince iyi çalışan ancak kullanıcı arayüzü performansınıza zarar verebilecek kodlar oluşturmanıza neden olabilir. Compose'da uygulamanızı optimize etmek için en iyi uygulamaları takip edin. R8 ve temel profillerle oluşturulduğunda Compose kaydırma ve başlatma performansını gösteren deneysel karşılaştırma verileri için Hero karşılaştırmaları bölümüne bakın.

Maliyetli hesaplamaları en aza indirmek için remember kullanın

Bir animasyonun her karesi için çalıştırılabilen composable işlevler çok sık çalıştırılabilir. Bu nedenle, composable'ınızın gövdesinde mümkün olduğunca az hesaplama yapmanız gerekir.

Önemli bir teknik, hesaplama sonuçlarını remember ile depolamaktır. Böylece hesaplama bir kez çalıştırılır ve sonuçları gerektiğinde alabilirsiniz.

Örneğin, aşağıdaki kodda sıralı bir ad listesi gösteriliyor ancak sıralama işlemi çok maliyetli bir şekilde yapılıyor:

@Composable
fun ContactList(
    contacts: List<Contact>,
    comparator: Comparator<Contact>,
    modifier: Modifier = Modifier
) {
    LazyColumn(modifier) {
        // DON’T DO THIS
        items(contacts.sortedWith(comparator)) { contact ->
            // ...
        }
    }
}

ContactsList her yeniden oluşturulduğunda, liste değişmemiş olsa bile tüm kişi listesi baştan sıralanır. Kullanıcı listeyi kaydırırsa yeni bir satır göründüğünde Composable yeniden oluşturulur.

Bu sorunu çözmek için listeyi LazyColumn dışında sıralayın ve sıralanan listeyi remember ile depolayın:

@Composable
fun ContactList(
    contacts: List<Contact>,
    comparator: Comparator<Contact>,
    modifier: Modifier = Modifier
) {
    val sortedContacts = remember(contacts, comparator) {
        contacts.sortedWith(comparator)
    }

    LazyColumn(modifier) {
        items(sortedContacts) {
            // ...
        }
    }
}

Artık liste, ContactList ilk kez oluşturulduğunda bir kez sıralanır. Kişiler veya karşılaştırıcı değişirse sıralanan liste yeniden oluşturulur. Aksi takdirde, composable, önbelleğe alınmış sıralı listeyi kullanmaya devam edebilir.

remember hesaplama bloğunda referans verilen tüm girişleri her zaman anahtar olarak iletin. Böylece, bu girişler değiştiğinde önbelleğe alınan değer güncellenir. remember, anahtarlarını ve önbelleğe alınmış sonucunu yuva tablosunda sakladığından ve her yeniden oluşturma geçişinde Object.equals() kullanarak anahtarları karşılaştırdığından, remember'i yalnızca maliyetli hesaplamaları veya ağır nesne ayırmalarını (tarih biçimlendiriciler, gölgelendiriciler veya liste sıralama gibi) önbelleğe alırken ya da nesne kimliğinin korunması gerektiğinde kullanın.

Büyük bir koleksiyonu veya pahalı bir equals() uygulamasına sahip bir nesneyi, ucuz bir hesaplama için remember anahtarı olarak iletirken dikkatli olun. Anahtarı karşılaştırmak, hesaplamayı doğrudan çalıştırmaktan daha maliyetli olabilir:

@Composable
fun ContactHeader(contacts: List<Contact>) {
    // Avoid: Comparing the `contacts` list with .equals() on recomposition
    // is more expensive than reading contacts.size or contacts.firstOrNull() directly.
    val firstContactName = remember(contacts) {
        contacts.firstOrNull()?.name.orEmpty()
    }
    Text(firstContactName)
}

Yavaş düzen anahtarlarını ve içerik türlerini kullanma

Yavaş düzenler, öğeleri verimli bir şekilde yeniden kullanır ve yalnızca gerektiğinde yeniden oluşturur veya yeniden oluşturur. Ancak geç yüklenen düzenleri yeniden oluşturma ve alan yeniden kullanımı için optimize edebilirsiniz.

Bir kullanıcı işleminin, listedeki bir öğenin taşınmasına neden olduğunu varsayalım. Örneğin, notları değiştirilme zamanına göre sıralanmış bir liste halinde gösterdiğinizi ve en son değiştirilen notun en üstte yer aldığını varsayalım.

@Composable
fun NotesList(notes: List<Note>) {
    LazyColumn {
        items(
            items = notes
        ) { note ->
            NoteRow(note)
        }
    }
}

Ancak bu kodla ilgili bir sorun var. Alt notun değiştirildiğini varsayalım. Bu not artık en son değiştirilen not olduğundan listenin en üstüne taşınır ve diğer tüm notlar bir sıra aşağı kayar.

Yardımınız olmadan Compose, değişmeyen öğelerin listede yalnızca taşındığını fark etmez. Bunun yerine Compose, eski "2. öğe"nin silindiğini ve 3. öğe, 4. öğe ve diğer tüm öğeler için yeni bir öğe oluşturulduğunu düşünür. Sonuç olarak Compose, listedeki her öğeyi yeniden oluşturur. Oysa yalnızca bir öğe değişmiştir.

Bu sorunu çözmek için öğe anahtarları sağlamanız gerekir. Her öğe için sabit bir anahtar sağlamak, Compose'un gereksiz yeniden oluşturma işlemlerini önlemesini sağlar. Bu durumda Compose, şu anda 3. sırada olan öğenin daha önce 2. sırada olan öğeyle aynı olduğunu belirleyebilir. Bu öğenin verilerinden hiçbiri değişmediğinden Compose'un öğeyi yeniden oluşturması gerekmez.

@Composable
fun NotesList(notes: List<Note>) {
    LazyColumn {
        items(
            items = notes,
            key = { note ->
                // Return a stable, unique key for the note
                note.id
            }
        ) { note ->
            NoteRow(note)
        }
    }
}

Yavaş düzenlerle (LazyColumn, LazyRow, LazyGrid) çalışırken aşağıdaki yönergeleri de göz önünde bulundurun:

  • Pakete kaydedilebilir, benzersiz anahtarlar kullanın: Anahtarlar benzersiz, belirleyici ve Android Bundle içine kaydedilebilir olmalıdır. Çünkü geç yüklenen düzenler dahili olarak rememberSaveable kullanır. Int, Long veya String gibi temel türleri tercih edin ve anahtar olarak liste dizinlerini ya da hashCode() değerini kullanmayın.
  • Heterojen listeler için her zaman contentType belirtin: contentType = { it.type } öğesini items veya itemsIndexed öğesine iletin. Böylece Compose, kaydırma sırasında yalnızca aynı görsel yapıyı paylaşan öğeler arasındaki oluşturma alanlarını yeniden kullanır.
  • indexOf yerine itemsIndexed kullanın: items bloğunda list.indexOf(item) çağrısı yapmaktan kaçının. Bu, düzeni O(N²) taramasına dönüştürür. Bunun yerine itemsIndexed kullanın.
  • Paylaşılan durumu ve CompositionLocal okumalarını yukarı taşıyın: Paylaşılan Flow örneklerini toplayın ve CompositionLocal değerlerini (ör. LocalContext.current veya LocalDensity.current) bir kez lazy düzenin üzerindeki üst composable'da okuyun ve çözümlenen değerleri öğe composable'larına iletin.
  • Küçük, sınırlı listeler için Row veya Column kullanın: Küçük statik veya sınırlı koleksiyonlar (ör. 1 ila 10 öğe) için forEach ile standart bir Row veya Column kullanmak, geç sanallaştırma ve önceden getirme ek yükünü önler.
  • Farklı boyutlardaki öğeler için cacheWindow ayarı yapın: Varsayılan önceden getirme, ileriye dönük pencereyi görüntü alanının %10 ila %50'si arasında sabitler. Görüntü alanının %50'sinden büyük öğeler içeren düzenlerde (ör. tam kanamalı kartlar veya medya gönderileri), kaydırma sırasında geç oluşturmayı önlemek için geç düzende daha büyük bir aheadFraction yapılandırın. Küçük öğeler için varsayılan pencere, birden fazla öğeyi otomatik olarak önceden getirir. Daha fazla bilgi için LazyLayoutCacheWindow ile kaydırma performansını iyileştirme başlıklı makaleyi inceleyin.

Yeniden oluşturma işlemlerini sınırlamak için computedStateOf veya derivedStateOf kullanın

Oluşturmalarınızda durum kullanmanın bir riski, durum hızla değişirse kullanıcı arayüzünüzün ihtiyacınız olandan daha fazla yeniden oluşturulabilmesidir. Örneğin, kaydırılabilir bir liste gösterdiğinizi varsayalım. Listenin durumunu inceleyerek listede görünen ilk öğenin hangisi olduğunu öğrenirsiniz:

val listState = rememberLazyListState()

LazyColumn(state = listState) {
    // ...
}

val showButton = listState.firstVisibleItemIndex > 0

AnimatedVisibility(visible = showButton) {
    ScrollToTopButton()
}

Buradaki sorun, kullanıcı listeyi kaydırdığında listState değerinin, kullanıcı parmağını sürükledikçe sürekli değişmesidir. Yani liste sürekli olarak yeniden oluşturuluyor. Ancak aslında bu kadar sık yeniden oluşturmanız gerekmez. Yeni bir öğe en üstte görünür hale gelene kadar yeniden oluşturmanız gerekmez. Bu da çok fazla ekstra hesaplama yapılmasına neden olur ve kullanıcı arayüzünüzün performansını düşürür.

Çözüm, türetilmiş durum (veya Compose Runtime 1.13 ve sonraki sürümlerde computedStateOf) kullanmaktır. Türetilmiş durum, Compose'a hangi durum değişikliklerinin yeniden oluşturmayı tetiklemesi gerektiğini bildirmenizi sağlar. Bu durumda, ilk görünür öğenin ne zaman değiştiğini önemsediğinizi belirtin. Bu durum değeri değiştiğinde kullanıcı arayüzünün yeniden oluşturulması gerekir. Ancak kullanıcı, yeni bir öğeyi en üste getirecek kadar kaydırma yapmadıysa yeniden oluşturulması gerekmez.

val listState = rememberLazyListState()

LazyColumn(state = listState) {
    // ...
}

val showButton by remember {
    derivedStateOf {
        listState.firstVisibleItemIndex > 0
    }
}

AnimatedVisibility(visible = showButton) {
    ScrollToTopButton()
}

Compose sürümünüze ve hesaplama maliyetinize göre uygun durum türetme yaklaşımını seçin:

  • remember { computedStateOf { ... } } (Compose Runtime 1.13 ve sonraki sürümler): Sonucu önbelleğe almadan her okuma işleminde hesaplamasını yeniden değerlendirir ve yalnızca hesaplanan çıkış değiştiğinde oluşturmayı geçersiz kılar. Önbellek kayıt tutma ve geçersiz kılma geri yazma ek yükünü önlediğinden, temel koşul kontrolleri ve hızlı değişen durumlardan (kaydırma ofsetleri gibi) kaynaklanan basit türetmeler için remember { computedStateOf { listState.firstVisibleItemIndex > 0 } } tercih edin.
  • remember { derivedStateOf { ... } }: Birden fazla okuma işleminde hesaplama sonucunu önbelleğe alır. 1.13'ten önceki Compose sürümlerinde veya hesaplamanın kendisi hesaplama açısından pahalı olduğunda ve bir oluşturma aşamasında birden çok kez okunduğunda derivedStateOf kullanın. derivedStateOf içinde okunan anlık görüntü durumu değerlerini (ör. listState.firstVisibleItemIndex) remember anahtarı olarak iletmeyin. Bu işlem, her durum değişikliğinde DerivedState öğesini yeniden oluşturur ve atlamayı engeller.
  • Basit Kotlin alıcıları (get()) ve doğrudan özellik okumaları: Geçersiz kılma azaltmanın gerekli olmadığı önemsiz boole ifadeleri için basit bir özel alıcı tercih edin ve koleksiyonu derivedStateOf içine sarmak yerine doğrudan .size okuyun. Eşzamanlı durum türetmeleri için produceState ile snapshotFlow kullanmaktan kaçının. Bu, gereksiz eş yordam dağıtım ek yüküne neden olur.

Okuma işlemlerini mümkün olduğunca erteleme

Bir performans sorunu tespit edildiğinde durum okumalarını ertelemek faydalı olabilir. Durum okumalarını ertelemek, Compose'un yeniden oluşturma sırasında mümkün olan en az kodu yeniden çalıştırmasını sağlar. Örneğin, kullanıcı arayüzünüzde, composable ağacında yukarı taşınmış bir durum varsa ve bu durumu bir alt composable'da okuyorsanız durum okuma işlemini bir lambda işlevine sarmalayabilirsiniz. Böylece okuma işlemi yalnızca gerçekten gerektiğinde yapılır. Referans için Jetsnack örnek uygulamasındaki uygulamaya bakın. Jetsnack, ayrıntı ekranında daralan araç çubuğu benzeri bir efekt uygular. Bu tekniğin neden işe yaradığını anlamak için Jetpack Compose: Yeniden Oluşturma İşleminde Hata Ayıklama başlıklı blog yayınını inceleyin.

Bu efekti elde etmek için Title composable'ının, Modifier kullanarak kendisini dengelemek amacıyla kaydırma ofsetine ihtiyacı vardır. Optimizasyon yapılmadan önceki Jetsnack kodunun basitleştirilmiş bir versiyonunu inceleyelim:

@Composable
fun SnackDetail() {
    // ...

    Box(Modifier.fillMaxSize()) { // Recomposition Scope Start
        val scroll = rememberScrollState(0)
        // ...
        Title(snack, scroll.value)
        // ...
    } // Recomposition Scope End
}

@Composable
private fun Title(snack: Snack, scroll: Int) {
    // ...
    val offset = with(LocalDensity.current) { scroll.toDp() }

    Column(
        modifier = Modifier
            .offset(y = offset)
    ) {
        // ...
    }
}

Kaydırma durumu değiştiğinde Compose, en yakın üst yeniden oluşturma kapsamını geçersiz kılar. Bu durumda en yakın kapsam, SnackDetail bileşenidir. Box satır içi bir işlev olduğundan yeniden oluşturma kapsamı değildir. Bu nedenle Compose, SnackDetail ve SnackDetail içindeki tüm composable'ları yeniden oluşturur. Kodunuzu yalnızca kullandığınız durumu okuyacak şekilde değiştirirseniz yeniden oluşturulması gereken öğelerin sayısını azaltabilirsiniz.

@Composable
fun SnackDetail() {
    // ...

    Box(Modifier.fillMaxSize()) { // Recomposition Scope Start
        val scroll = rememberScrollState(0)
        // ...
        Title(snack) { scroll.value }
        // ...
    } // Recomposition Scope End
}

@Composable
private fun Title(snack: Snack, scrollProvider: () -> Int) {
    // ...
    val offset = with(LocalDensity.current) { scrollProvider().toDp() }
    Column(
        modifier = Modifier
            .offset(y = offset)
    ) {
        // ...
    }
}

Kaydırma parametresi artık bir lambda. Yani Title, yukarı çekilen duruma referans vermeye devam edebilir ancak değer yalnızca gerçekten ihtiyaç duyulan Title içinde okunur. Sonuç olarak, kaydırma değeri değiştiğinde en yakın yeniden oluşturma kapsamı artık Title composable'dır. Compose'un artık Box öğesinin tamamını yeniden oluşturması gerekmez.

Bu iyi bir gelişme ancak daha iyisini yapabilirsiniz. Yalnızca bir Composable'ı yeniden düzenlemek veya yeniden çizmek için yeniden oluşturma işlemine neden oluyorsanız şüphelenmeniz gerekir. Bu durumda, yalnızca Title composable'ının ofsetini değiştirirsiniz. Bu işlem, düzen aşamasında yapılabilir.

@Composable
private fun Title(snack: Snack, scrollProvider: () -> Int) {
    // ...
    Column(
        modifier = Modifier
            .offset { IntOffset(x = 0, y = scrollProvider()) }
    ) {
        // ...
    }
}

Daha önce kod, ofseti parametre olarak alan Modifier.offset(x: Dp, y: Dp) yöntemini kullanıyordu. Değiştiricinin lambda sürümüne geçerek işlevin, düzen aşamasında kaydırma durumunu okumasını sağlayabilirsiniz. Sonuç olarak, kaydırma durumu değiştiğinde Compose, oluşturma aşamasını tamamen atlayıp doğrudan düzen aşamasına geçebilir. Sık değişen State değişkenlerini değiştiricilere aktarırken mümkün olduğunca değiştiricilerin lambda sürümlerini kullanmanız gerekir.

Bu yaklaşımın başka bir örneğini inceleyelim. Bu kod henüz optimize edilmedi:

// Here, assume animateColorBetween() is a function that swaps between
// two colors
val color by animateColorBetween(Color.Cyan, Color.Magenta)

Box(
    Modifier
        .fillMaxSize()
        .background(color)
)

Burada, kutunun arka plan rengi iki renk arasında hızla değişiyor. Bu nedenle bu durum çok sık değişir. Ardından composable, arka plan değiştiricide bu durumu okur. Renk her karede değiştiği için kutunun her karede yeniden oluşturulması gerekir.

Bunu iyileştirmek için lambda tabanlı bir değiştirici (bu örnekte drawBehind) kullanın. Yani renk durumu yalnızca çizim aşamasında okunur. Sonuç olarak, Compose, oluşturma ve düzen aşamalarını tamamen atlayabilir. Renk değiştiğinde Compose doğrudan çizim aşamasına geçer.

val color by animateColorBetween(Color.Cyan, Color.Magenta)
Box(
    Modifier
        .fillMaxSize()
        .drawBehind {
            drawRect(color)
        }
)

Geriye doğru yazmaktan kaçının

Compose'un temel varsayımı, hiçbir zaman önceden okunmuş bir duruma yazmayacağınızdır. Bu işlem, geriye doğru yazma olarak adlandırılır ve her karede sonsuz bir şekilde yeniden oluşturmaya neden olabilir.

Aşağıdaki composable'da bu tür bir hata örneği gösterilmektedir.

@Composable
fun BadComposable() {
    var count by remember { mutableIntStateOf(0) }

    // Causes recomposition on click
    Button(onClick = { count++ }, Modifier.wrapContentSize()) {
        Text("Recompose")
    }

    Text("$count")
    count++ // Backwards write, writing to state after it has been read</b>
}

Bu kod, bir önceki satırda okuduktan sonra composable'ın sonundaki sayıyı günceller. Bu kodu çalıştırırsanız düğmeyi tıkladıktan sonra (bu işlem yeniden oluşturmaya neden olur) Compose bu composable'ı yeniden oluştururken, güncel olmayan bir durum okuma işlemi görür ve başka bir yeniden oluşturma işlemi planlar. Bu nedenle, sayaç sonsuz bir döngüde hızla artar.

Oluşturma'da hiçbir zaman duruma yazmayarak geriye doğru yazma işlemlerini tamamen önleyebilirsiniz. Mümkünse her zaman bir etkinliğe yanıt olarak ve önceki onClick örneğinde olduğu gibi bir lambda içinde duruma yazın.

Geriye doğru yazma, yeniden oluşturma döngüleri ve aşama koordinasyonu hakkında ayrıntılı bir kılavuz için Compose'da geriye doğru yazma başlıklı makaleyi inceleyin.

Ek kaynaklar