Yaşam döngüsüne duyarlı bileşenlerle Kotlin eş yordamlarını kullanın

Kotlin eş yordamları, eşzamansız kod yazmanıza olanak tanıyan bir API sağlar. Kotlin eş yordamlarıyla, eş yordamlarınızın ne zaman çalışması gerektiğini yönetmenize yardımcı olan bir CoroutineScope tanımlayabilirsiniz. Her eşzamansız işlem belirli bir kapsamda çalışır.

Yaşam döngüsüne duyarlı bileşenler, uygulamanızdaki mantıksal kapsamlar için birinci sınıf eş yordam desteği sağlar. Bu belgede, eş yordamların yaşam döngüsüne duyarlı bileşenlerle nasıl etkili bir şekilde kullanılacağı açıklanmaktadır.

Bağımlılık ekleme

Bu konuda açıklanan yerleşik eş yordam kapsamları, Lifecycle API'de yer alır. Bu kapsamları kullanırken uygun bağımlılıkları eklediğinizden emin olun.

  • Compose'daki ViewModel yardımcı programları için implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version") kullanın.
  • Compose'daki yaşam döngüsü yardımcı programları için implementation("androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version") kullanın.

Yaşam döngüsüne duyarlı coroutine kapsamları

Compose ve Lifecycle kitaplıkları, uygulamanızda kullanabileceğiniz aşağıdaki yerleşik kapsamları sağlar.

ViewModelScope

Uygulamanızdaki her ViewModel için bir ViewModelScope tanımlanır. Bu kapsamda başlatılan tüm eş yordamlar, ViewModel temizlenirse otomatik olarak iptal edilir. Burada, yalnızca ViewModel etkinse yapılması gereken işleriniz olduğunda eş yordamlar kullanışlıdır. Örneğin, bir düzen için bazı verileri hesaplıyorsanız çalışmayı ViewModel ile sınırlandırmanız gerekir. Böylece ViewModel temizlenirse kaynak tüketimini önlemek için çalışma otomatik olarak iptal edilir.

Aşağıdaki örnekte gösterildiği gibi, ViewModel öğesinin CoroutineScope özelliğine ViewModel öğesinin viewModelScope özelliği üzerinden erişebilirsiniz:

class MyViewModel: ViewModel() {
    init {
        viewModelScope.launch {
            // Coroutine that will be canceled when the ViewModel is cleared.
        }
    }
}

Daha ileri düzey kullanım alanları için varsayılan viewModelScope yerine doğrudan ViewModel'in oluşturucusuna özel bir CoroutineScope iletebilirsiniz. Bu yaklaşım, özellikle aşağıdaki durumlarda daha fazla kontrol ve esneklik sunar:

  • Test etme: TestScope eklemenize olanak tanır. Böylece, birim testlerinde zamanı kontrol etmek ve eş yordam davranışını doğrulamak kolaylaşır.

  • Özel yapılandırma: Kapsamı, ViewModel çalışmaya başlamadan önce belirli bir CoroutineDispatcher (ör. yoğun hesaplama için Dispatchers.Default) veya özel bir CoroutineExceptionHandler ile yapılandırabilirsiniz.

Beste kapsamlı kapsamlar

Animasyonlar, ağ çağrıları veya zamanlayıcılar gibi yan etkiler, composable'ın yaşam döngüsüyle sınırlandırılmalıdır. Bu sayede, bir composable ekranı terk ettiğinde (kompozisyondan çıktığında) çalışan tüm eş yordamlar otomatik olarak iptal edilerek bellek sızıntıları önlenir.

Compose, Composition kapsamını bildirimsel olarak işlemek için LaunchedEffect API'sini sağlar.

LaunchedEffect, askıya alma işlevlerini çalıştırmanıza olanak tanıyan bir CoroutineScope oluşturur. Kapsam, composable'ın beste yaşam döngüsüne bağlıdır, ana makine etkinliğinin yaşam döngüsüne değil.

  • Girme: Composable, kompozisyona girdiğinde coroutine başlar.
  • Çıkış: Composable, kompozisyondan ayrıldığında coroutine iptal edilir.
  • Yeniden başlatma: LaunchedEffect öğesine iletilen herhangi bir anahtar değişirse mevcut coroutine iptal edilir ve yeni bir coroutine başlatılır.

Aşağıdaki örnekte, LaunchedEffect kullanarak nasıl titreşen animasyon oluşturulacağı gösterilmektedir. Coroutine, composable'ın kompozisyondaki varlığına bağlıdır ve yapılandırma değişikliklerine tepki verir:

// Allow the pulse rate to be configured, so it can be sped up if the user is running
// out of time
var pulseRateMs by remember { mutableLongStateOf(3000L) }
val alpha = remember { Animatable(1f) }
LaunchedEffect(pulseRateMs) { // Restart the effect when the pulse rate changes
    while (isActive) {
        delay(pulseRateMs) // Pulse the alpha every pulseRateMs to alert the user
        alpha.animateTo(0f)
        alpha.animateTo(1f)
    }
}
SideEffectsSnippets.kt

LaunchedEffect hakkında daha fazla bilgi için Yan etkiler başlıklı makaleyi inceleyin.

Yaşam döngüsüne duyarlı akış toplama

Jetpack Compose'da akışları güvenli bir şekilde toplamak için collectAsStateWithLifecycle API'sini kullanın. Bu tek işlev, Flow öğesini Compose State nesnesine dönüştürür ve yaşam döngüsü aboneliğini sizin için otomatik olarak yönetir. Varsayılan olarak, yaşam döngüsü STARTED olduğunda toplama işlemi başlar ve yaşam döngüsü STOPPED olduğunda durur. Bu varsayılan davranışı geçersiz kılmak için minActiveState parametresini istediğiniz yaşam döngüsü yöntemiyle (ör. Lifecycle.State.RESUMED) iletin.

Aşağıdaki örnekte, bir composable'da ViewModel'in StateFlow nasıl toplanacağı gösterilmektedir:

@Composable
private fun ConversationScreen(
    conversationViewModel: ConversationViewModel = viewModel()
) {

    val messages by conversationViewModel.messages.collectAsStateWithLifecycle()

    ConversationScreen(
        messages = messages,
        onSendMessage = { message: Message -> conversationViewModel.sendMessage(message) }
    )
}

@Composable
private fun ConversationScreen(
    messages: List<Message>,
    onSendMessage: (Message) -> Unit
) {

    MessagesList(messages, onSendMessage)
    /* ... */
}
StateHoistingSnippets.kt

Birden fazla akışın paralel olarak toplanması

Oluşturma'da birden fazla durum değişkeni bildirerek birden fazla akışı paralel olarak toplayabilirsiniz. collectAsStateWithLifecycle kendi temel kapsamını yönettiği için paralel toplama işlemi otomatik olarak gerçekleştirilir:

@Composable
fun DashboardScreen(viewModel: DashboardViewModel = viewModel()) {
    // Both flows are collected safely in parallel and will emit updates when either changes, the composables will recompose
    val userData by viewModel.userFlow.collectAsStateWithLifecycle()
    val feedData by viewModel.feedFlow.collectAsStateWithLifecycle()

    // ...
}

Akışları kullanarak değerleri eşzamansız olarak hesaplama

Değerleri eşzamansız olarak hesaplamanız gerektiğinde StateFlow ile stateIn operatörünü kullanın.

Aşağıdaki snippet'te Flow öğesine dönüştürülmüş standart bir StateFlow kullanılmaktadır. WhileSubscribed(5000) parametresi, yapılandırma değişikliklerini işlemek için kullanıcı arayüzü kaybolduktan sonra aboneliği beş saniye boyunca etkin tutar.

val uiState: StateFlow<Result> = flow {
    emit(repository.fetchData())
}
.stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5_000),
    initialValue = Result.Loading
)

Toplanan değerleri Compose'a dönüştürmek için collectAsStateWithLifecycle kullanın State. Böylece, veriler her değiştiğinde kullanıcı arayüzünüz reaktif olarak güncellenebilir.

Durum hakkında daha fazla bilgi için Durum ve Jetpack Compose başlıklı makaleyi inceleyin.

Ek kaynaklar

İçeriği görüntüleme

Örnekler