mutableStateOf: kuzatiladigan holatni yaratish va Compose reaktivligi

Jetpack Compose-da mutableStateOf nima

mutableStateOf — compose.runtime paketidagi qiymatni saqlaydigan va Compose Runtime-ni o'zgarishlar haqida xabardor qila oladigan MutableState<T> obyektini yaratuvchi funksiyadir. Imzosi: fun <T> mutableStateOf(value: T, policy: SnapshotMutationPolicy<T> = structuralEquality()): MutableState<T>. policy parametri qachon o'zgarish muhim deb hisoblanishini aniqlaydi — strukturaviy tenglikda, referensial tenglikda yoki hech qachon.

MutableState — bitta value xususiyatiga ega interfeys: o'qish uchun getter va yozish uchun setter. Setter chaqirilganda, Compose Runtime o'zgarishni snapshotda qayd etadi va ushbu State o'zgaruvchisini o'qiyotgan barcha Composable funksiyalarni rekompozitsiya talab qiladigan deb belgilaydi. Bu jarayon bitta snapshot sikli doirasida sinxron ravishda sodir bo'ladi, bu kaskadli o'zgarishlarda oraliq holatlarni bartaraf qiladi.

Parameter policy — mutableStateOf ning ikkinchi argumenti, taqqoslashdagi harakatni belgilaydi. structuralEquality() equals() ni tekshiradi — bu standart xatti-harakatdir. referentialEquality() === ni (referensial tenglik) tekshiradi. neverEqual() har bir tayinlashni o'zgarish deb hisoblaydi. Policy tanlovi bir xil qiymat tayinlanganda rekompozitsiya ishga tushadimi yoki yo'qligiga ta'sir qiladi.

mutableStateOf sintaksisi va e'lon qilish usullari

Kuzatiladigan holatni e'lon qilishning eng oddiy usuli — mutableStateOf ni remember bilan ishlatishdir. Remember bo'lmasa, har bir rekompozitsiyada yangi State yaratiladi va barcha oldingi o'zgarishlar yo'qoladi. remember, Composable funksiyasi kompozitsiya tarkibida qolgan ekan, xuddi shu MutableState bir qator rekompozitsiyalardan omon qolishini kafolatlaydi.

@Composable
fun Counter() {
    // Delegatsiyasiz: .value orqali o'qish/yozish
    val count = remember { mutableStateOf(0) }
    Button(onClick = { count.value++ }) {
        Text("Count: ${count.value}")
    }
}

@Composable
fun CounterDelegated() {
    // Delegatsiya bilan: var + by = Property Delegation
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Count: $count")
    }
}

Ikki variant o'rtasidagi farq sintaktikdir. Property Delegation (by) Kotlin konvensiyasidan foydalanadi: kompilyator o'qish va yozish uchun getValue() va setValue() chaqiruvlarini yaratadi. Bu to'g'ridan-to'g'ri count.value ga murojaat qilishga teng, lekin oddiy o'zgaruvchi bilan ishlashga o'xshaydi. Ikkala variant ham funksional jihatdan bir xil: Compose yozuv shaklidan qat'i nazar, getterdagi o'qishni va settedagi yozishni kuzatadi.

Delegatsiya qilingan xususiyatlar va var

Kotlin-ning delegatsiya qilingan xususiyatlar mexanizmi — Compose-ning xususiyati emas, balki tilning o'rnatilgan imkoniyatidir. Har qanday sinf getValue(thisRef, property) va setValue(thisRef, property, value) operatorlarini amalga oshirishi mumkin, shundan so'ng uning namunasi by kalit so'zi bilan ishlatilishi mumkin. MutableState aynan shunday ishlaydi: getValue joriy qiymatni qaytaradi, setValue esa yangi qiymatni tayinlaydi.

Muhim farq: val va var. mutableStateOf ni ham val, ham var ga tayinlash mumkin. Val holatida (val count = mutableStateOf(0)) MutableState obyektining o'zi o'zgarmas, ammo uning value xususiyatini o'zgartirish mumkin. Var holatida (var count by mutableStateOf(0)) delegatsiya primitiv bilan ishlash illyuziyasini yaratadi, lekin aslida setter MutableState-da setValue chaqiradi. Val va var o'rtasidagi tanlov .value ga ochiq va yashirin kirish o'rtasidagi tanlovdir.

State Delegation — kodni soddalashtiradigan, ammo mexanikani o'zgartirmaydigan sintaktik shakardir. Kotlin kompilyatori var x by mutableStateOf(0) ni mutableStateOf.getValue() va mutableStateOf.setValue() ni chaqiradigan getter/setter ga aylantiradi. Yaratilgan baytkodda by bilan val va var o'rtasida farq yo'q — ikkalasi ham bir xil MutableState konteyneri orqali ishlaydi.

    // Compose State uchun maxsus delegatsiya
class ValidatedState<T>(initialValue: T) {
    private val state = mutableStateOf(initialValue)

    operator fun getValue(thisRef: Any?, property: KProperty<*>) = state.value

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        if (value != state.value) {
            state.value = value
        }
    }
}

@Composable
fun Test() {
    var text by remember { ValidatedState("") }
}

Snapshot tizimi: mutableStateOf ichki qanday ishlaydi

Snapshot — parallel o'zgarishlarda State o'qishining mutanosibligini ta'minlaydigan Compose Runtime mexanizmidir. Composable funksiyasi mutableStateOf ni o'qiganda, snapshot joriy qiymatni qayd etadi. Agar kompozitsiya paytida boshqa o'zgarish xuddi shu State ga yozsa, snapshot yozuvni ko'radi, lekin mos kelmaydigan ma'lumotlarni o'qishga ruxsat bermaydi — o'qish har doim snapshot boshlanishidagi dolzarb qiymatni qaytaradi.

mutableStateOf.value = newValue setteri chaqirilganda, Compose Runtime darhol rekompozitsiyani boshlamaydi. Buning o'rniga o'zgarish joriy snapshotda qayd etiladi. Snapshot qo'llanilganda (kadr chegarasida), Compose o'zgartirilgan State lar ro'yxatidan o'tadi va o'qiyotgan komponentlarni Invalid deb belgilaydi. Rekompozitsiya faqat keyingi kadrda ishga tushadi. Bu kaskadli o'zgarishlarda UI ning o'nlab marta qayta chizilmasligini kafolatlaydi.

Global va lokal snapshotlar: standart holatda mutableStateOf avtomatik qo'llaniladigan global snapshotda ishlaydi. Yon ta'sirlarsiz izolyatsiyalangan o'qish uchun Snapshot.takeSnapshot() orqali lokal snapshot yaratish mumkin. Bu State ni o'qish kerak, lekin o'zgarishlarga obuna bo'lish kerak bo'lmagan Modifier ichida ishlatiladi. Bunday yondashuv unumdorlikni optimallashtiradi va kutilmagan rekompozitsiyalarning oldini oladi.

mutableStateOf dan foydalanish misollari

Haqiqiy stsenariyni ko'rib chiqamiz — uch maydonli kirish formasi: email, parol va yuklash holati. Har uch maydon ham mutableStateOf dan foydalanadi, lekin turli policy va turli joylashuv bilan. email delegatsiyadan foydalanadi, parol — to'g'ridan-to'g'ri kirish.

data class LoginState(
    val email: String = "",
    val password: String = "",
    val isLoading: Boolean = false,
    val error: String? = null
)

@Composable
fun LoginForm(onLogin: (String, String) -> Unit) {
    // Forma uchun yagona State, policy = referentialEquality
    var formState by remember {
        mutableStateOf(LoginState(), SnapshotMutationPolicy.referentialEquality())
    }

    val isValid = remember(formState) {
        formState.email.contains("@") && formState.password.length() >= 6
    }

    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = formState.email,
            onValueChange = { formState = formState.copy(email = it) },
            label = { Text("Email") }
        )
        OutlinedTextField(
            value = formState.password,
            onValueChange = { formState = formState.copy(password = it) },
            label = { Text("Parol") },
            visualTransformation = PasswordVisualTransformation()
        )
        Button(
            onClick = { onLogin(formState.email, formState.password) },
            enabled = isValid
        ) {
            Text("Kirish")
        }
    }
}

Ushbu misolda mutableStateOf maxsus LoginState data klassi va referentialEquality policy bilan ishlatilgan. Bu rekompozitsiya faqat copy() orqali yangi LoginState namunasi tayinlanganda ishga tushishini anglatadi. isValid formState asosida hisoblanadi va faqat u o'zgarganda qayta hisoblanadi. Bunday yondashuv rekompozitsiyalar ustida aniq nazorat beradi: forma maydonlarining har biri faqat yangi nusxa yaratish orqali o'zgaradi.