Съдържание на курса
Урок 02 — Екрани, които се променят
От Dorian Chávez · съосновател и Chief Executive Officer на Hábil ·
Преди да четете, седем думи. По един ред за всяка; останалите от поредицата идват в урока, където се използват.
- Състояние: данна, която екранът помни и която може да се променя. Срещнахте я в урок 01; тук тя е темата.
- Рекомпозиция: когато Compose изпълнява отново вашите функции, за да обнови екрана, защото някоя данна се е променила.
- Събитие: нещо, което се случва и за което приложението научава, като докосване на бутон.
- Издигане на състоянието: изваждане на състоянието от един екран и пазенето му във функцията, която го вика.
- Интерфейс: списък с това, което може да се поиска от нещо, без да се казва как то го изпълнява.
- Имплементация: клас, който наистина изпълнява онова, което интерфейсът иска. Може да има няколко.
- Тестов дубльор: имплементация, направена само за тестовете, която отговаря онова, от което тестът има нужда.
Какво отнасяте: приложение с три екрана —приветствие, вход и начален екран— което минава от единия към другия, и умение да кажете защо екранът се е променил всеки път: коя стойност се е променила, кой я е променил и кой я е прочел.
Новата идея на този урок : състоянието. Когато се промени стойност на състояние, която екранът е прочел, Compose планира рекомпозиция, за да обнови каквото е нужно, и екранът се чертае отново. Преминаването от един екран към друг е точно това: стойност, която се променя. Освен това упражнявате една спомагателна практика, която също се проверява: отделянето на решението дали някой влиза в договор (интерфейс), с имплементация само за тестовете (стъпка 3).
Бележка за текстовете на приложението. Проектът на курса носи екранните си текстове на испански, а файловете в
lecciones/ не са преведени: автоматичните проверки на курса (verifica) търсят именно тези текстове. Затова в
блоковете с код, в изходите от терминала и в скиците на екрана текстовете остават така, както ги има проектът, а в
прозата урокът ги дава на български и първия път слага оригинала в скоби: екраните „Влезте във вашия акаунт“ („Entra
a tu cuenta“), „Здравейте, Ана“ („Hola, Ana“) и „Тук ще виждате поръчките си“ („Aquí verás tus órdenes“), бутонът
„Продължете“ („Continuar“) и съобщението „Все още не можете да влезете“ („Todavía no se puede entrar“). Тези от урок 01
са същите: „Магазинът“ („La tienda“), „Вход“ („Entrar“) и „Здравейте!“ („¡Hola!“).
Сцената
Трите екрана работят. Преди да затворите, преглеждате файла, за да го оставите чист, и една дума ви пречи: remember.
Редът се чете същото и без нея. Изтривате я.
Компилира се. Отваряте приложението: приветствието изглежда същото. Докосвате „Вход“.
Нищо не се случва. Няма съобщение за грешка. Приветствието си стои. Докосвате отново. Нищо.
Тази промяна съществува и е измерена: тя е „Счупете едно нарочно“ от стъпка 4. Само с тази изтрита дума симулираните тестове на урока минават от 7 от 7 в зелено на 1 от 7, с 6 в червено и нито един с грешка (18 ноември 2026 г.). Нищо не гръмна. Екранът спря да се променя, а кодът не казва защо.
Отговорът е в един въпрос: когато докоснете бутон, къде остава запазено онова, което се е случило? Първо предвиждате какво прави една стойност на състояние, после изграждате с нея маршрута, а накрая сами я чупите, за да го обясните.
Преди да започнете
Какво ви трябва: завършеният урок 01 —тук Column, Text и Button не се обясняват
отново— и средата от урок 00: зададен ANDROID_HOME и емулатор или вашият телефон.
Началният проект. От корена на хранилището на поредицата:
git pull
cd lecciones/02-pantallas-que-cambian/inicio
Там работите. До него е solucion/: накрая ви служи да сравните решенията си и да разберете всяка разлика. Вашите
предвиждания и обяснения отиват в respuestas/02.md, в корена на хранилището (mkdir -p respuestas, ако не
съществува).
Какво проектът вече носи (скеле). Тук то не се оценява:
| Какво носи | Къде | Защо |
|---|---|---|
| Приветствието от урок 01 | Bienvenida.kt |
Тръгвате от онова, което вече сте написали |
| Тестовете | app/src/test/…/RecorridoTest.kt и ArranqueTest.kt |
Те са тези, които изпълнява verifica. Не ги променяйте |
Памет, gradlew, Android 36 за тестовете и Java 25 |
Както в урок 01 | Обяснено в урок 01 |
Навигацията също е скеле. В Android има библиотека за придвижване между екрани, Navigation. Тук тя не се
използва: маршрутът се сглобява със стойност на състояние и един when, които ви давам вече написани в стъпка 2.
Скицата. Три екрана, по един наведнъж:
┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ La tienda │ │ Entra a tu cuenta │ │ Hola, Ana │
│ Tus órdenes, en tu │ ─▶ │ [ Continuar ] │ ─▶ │ Aquí verás tus │
│ bolsillo │ │ Todavía no se puede │ │ órdenes │
│ [ Entrar ] │ │ entrar (si no pasó) │ │ │
└──────────────────────┘ └──────────────────────┘ └──────────────────────┘
приветствие (bienvenida) вход (entrada) начало (inicio)
(В скицата „si no pasó“ означава „ако не е минало“.)
От входа към началния екран се минава с докосване на „Продължете“, само ако някой реши, че можете да минете. Кой решава, е стъпка 3.
Стъпка 1 · Предвидете какво прави една стойност на състояние
Тази стъпка е ваша, без Claude Code. Отворете app/src/main/java/mx/habil/ejemplo/tienda/Bienvenida.kt. Това е екранът
от урок 01, с тези три части:
var saludando by remember { mutableStateOf(false) } // състоянието
…
Button(onClick = { saludando = true }) { // събитието го променя
Text("Entrar")
}
if (saludando) { // екранът го чете
Text("¡Hola!")
}
Първо предвидете. Сменете saludando = true с saludando = !saludando (! обръща: от false на true и
обратно). Напишете в respuestas/02.md, преди да изпълните каквото и да е: какво се вижда след първото докосване,
след второто и след третото?
Сега го проверете. С отворен емулатор или с включен телефон:
./gradlew installDebug # компилира и инсталира; не отваря приложението
Отворете приложението, докоснете три пъти и сравнете. Ако предвиждането ви не е излязло вярно, не го изтривайте: запишете отдолу кой ред би ви дал отговора.
Какво се случи, по ред. Това е веригата на целия урок:
- Докосвате бутона: това е събитието.
onClickпроменя стойността. Нищо не чертае.- Compose следи тази стойност, защото тя е родена от
mutableStateOf. Когато се промени, планира рекомпозиция: да изпълни отново онова, което я е прочело и има нужда от обновяване. - В този пример вашата функция се изпълнява пак.
rememberѝ връща запазената стойност, не нова. ifчете сегашната стойност и описанието на екрана излиза различно.
Не пишете код, като предполагате колко пъти или в какъв ред ще се изпълни една функция @Composable: според
документацията Compose може да прескача онези, които не са се променили, и да изпълнява други много пъти.
Никой не „добавя“, нито „маха“ поздрава: функцията описва екрана за стойността от този момент.
Преди да продължите, върнете на ръка реда на бутона на Button(onClick = { saludando = true }). Така запазвате
всяка друга промяна, която може да сте направили. За да се уверите, че файлът е останал какъвто е бил, тази команда не
бива да показва нищо (само гледа, не променя файла ви):
git diff -- app/src/main/java/mx/habil/ejemplo/tienda/Bienvenida.kt
Доказва се с: вашето написано предвиждане, сравнено с изпълнението (цел 2.1).
Стъпка 2 · На ръка: една стойност решава кой екран се вижда
Също без Claude Code. Ще напишете два екрана и функцията, която избира кой от тях се чертае.
Първо предвидете. Ако „на кой екран съм“ е стойност на състояние, в коя функция трябва да живее: в Bienvenida,
в екрана за вход или в трета, която вика двете? Напишете коя и защо.
1. Приветствието спира да пази състояние и подава сигнал. В Bienvenida.kt изтрийте реда със saludando, блока
if (saludando) { … } и четирите import от androidx.compose.runtime, които не са Composable. Променете два реда:
fun Bienvenida(alEntrar: () -> Unit) {
…
Button(onClick = alEntrar) {
alEntrar: () -> Unit е параметър, чиято стойност е функция: не получава нищо (()) и не връща данна (Unit).
Екранът я изпълнява при докосване на бутона и не знае какво се случва после.
2. Екранът за вход. Създайте PantallaEntrada.kt в същата папка. Започва с package mx.habil.ejemplo.tienda и със същите import като Bienvenida.kt:
@Composable
fun PantallaEntrada(rechazada: Boolean, alContinuar: () -> Unit) {
Column(
modifier = Modifier.fillMaxSize().padding(24.dp),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text("Entra a tu cuenta", style = MaterialTheme.typography.headlineLarge)
Button(onClick = alContinuar) {
Text("Continuar")
}
if (rechazada) {
Text("Todavía no se puede entrar")
}
}
}
Не пази нищо и той: получава една данна (rechazada) и подава сигнал за докосване (alContinuar).
3. Функцията, която пази състоянието. Създайте Tienda.kt:
package mx.habil.ejemplo.tienda
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
enum class Pantalla { BIENVENIDA, ENTRADA, INICIO }
@Composable
fun Tienda() {
var pantalla by remember { mutableStateOf(Pantalla.BIENVENIDA) }
when (pantalla) {
Pantalla.BIENVENIDA -> Bienvenida(alEntrar = { pantalla = Pantalla.ENTRADA })
Pantalla.ENTRADA -> PantallaEntrada(rechazada = false, alContinuar = { })
Pantalla.INICIO -> Text("Aquí va el inicio")
}
}
enum class Pantalla { … }е затворен списък: еднаPantallaможе да бъде само едно от тези три.when (pantalla) { … }изпълнява клона за тази стойност. Ако ви липсва един от трите, не се компилира.alEntrar = { pantalla = Pantalla.ENTRADA }е функцията, която подавате на приветствието. То подава сигнал; тук се променя състоянието.
4. Приложението да стартира в Tienda. В MainActivity.kt редът със setContent става
setContent { Tienda() }.
Проверете го в приложението. ./gradlew installDebug, отворете го и докоснете „Вход“: трябва да остане екранът
„Влезте във вашия акаунт“ („Entra a tu cuenta“), а приветствието вече не бива да се вижда. „Продължете“ още не прави
нищо.
С готовото решение, в емулатора от изпитването (Pixel 9, Android 37, 18 ноември 2026 г.) се видя това: приветствието
с „La tienda“, „Tus órdenes, en tu bolsillo“ и „Entrar“; при докосване на „Entrar“ — „Entra a tu cuenta“ и
„Continuar“; а при докосване на „Continuar“ — съобщението „Todavía no se puede entrar“. Началният екран не се
появява в инсталираното приложение: до него стигат само тестовете.
Какво току-що направихте. Състоянието не остана в никой екран: вие го издигнахте до функцията, която ги вика. Това е издигане на състоянието и документацията на Android го препоръчва: състоянието живее в най-близкия общ предшественик на онези, които го четат, и на онези, които го променят; надолу пътуват данни, нагоре пътуват събития.
verifica още не може да изпълни тестовете. От корена на хранилището:
./lecciones/02-pantallas-que-cambian/verifica
Това червено е очакваното само когато завършите стъпка 2, и то само защото още липсват Entrada, EntradaFalsa и
параметърът entrada на Tienda. Вървите добре, ако между редовете виждате тези (измерено на 18 ноември 2026 г.;
тези на Gradle се повтарят по няколко пъти):
❌ No encontré «interface Entrada» en src/main: sin ella las pruebas no compilan (paso 3)
✅ Texto: en src/main hay un «fun Tienda(»
❌ No encontré «class EntradaFalsa» en src/test: la escribes tú en EntradaFalsa.kt (paso 3)
ℹ️ Estado guiado del paso 2: arriba faltan piezas del paso 3, y mientras falten las pruebas no compilan.
❌ Las pruebas no llegaron a correr. Esto dijo Gradle:
e: RecorridoTest.kt:45:38 No parameter with name 'entrada' found.
e: RecorridoTest.kt:45:48 Unresolved reference 'EntradaFalsa'.
Resultado: 0 pruebas corridas.
(Това е изходът на verifica, точно както го отпечатва скриптът, на испански. На български казва: „Не намерих
«interface Entrada» в src/main: без него тестовете не се компилират (стъпка 3)“; „Текст: в src/main има «fun
Tienda(»“; „Не намерих «class EntradaFalsa» в src/test: вие я пишете в EntradaFalsa.kt (стъпка 3)“; „Воден режим на
стъпка 2: по-горе липсват части от стъпка 3 и докато липсват, тестовете не се компилират“; „Тестовете не стигнаха да
се изпълнят. Това каза Gradle“; и „Резултат: 0 изпълнени теста“.)
Ако редовете на Gradle споменават друг файл —Tienda.kt, Bienvenida.kt, PantallaEntrada.kt—, или ако вече сте
започнали стъпка 3, това не е това червено: това е грешка, която трябва да поправите, преди да продължите. Например,
с написано recuerda вместо remember, Gradle каза e: Tienda.kt:14:21 Unresolved reference 'recuerda'. (измерено на
18 ноември 2026 г.). А тъй като тестовете още не се изпълняват, тази стъпка се проверява в инсталираното приложение.
Доказва се с: в инсталираното приложение „Вход“ ви води до екрана за вход (първата половина на цел 2.2).
Стъпка 3 · С Claude Code: кой решава дали влизате
Липсва началният екран и липсва да се реши кой може да стигне до него. Днес няма доставчик (Google идва в урок 04) и въпреки това тестовете трябва да минат през трите екрана.
Затова това решение не се пише вътре в никой екран. Декларира се отделно, като интерфейс: „от това може да се поиска да влезе и то отговаря с името на онзи, който е влязъл, или с нищо“. И се пишат две имплементации:
| Имплементация | Къде живее | Какво отговаря | Кой я използва |
|---|---|---|---|
EntradaSinProveedor |
app/src/main (приложението) |
Винаги „не“: null |
Инсталираното приложение |
EntradaFalsa |
app/src/test (тестовете) |
Винаги „да“, с името, което ѝ зададете | Само тестовете |
EntradaFalsa е тестов дубльор. За да не пусне истинското приложение никого без доставчик, спазваме това
правило: приложението не носи никакъв начин за влизане без доставчик. Според документацията на Android дубльор,
който живее в тестовия код, не пътува с приложението.
Тук влиза инструментът и винаги влиза по един и същи начин: предвиждате → искате → четете какво е генерирал →
изпълнявате verifica → обяснявате със свои думи.
- Предвидете. Напишете в
respuestas/02.md: от файловетеBienvenida.kt,PantallaEntrada.kt,Tienda.ktиMainActivity.ktкои ще се променят и кои не? - Поискайте от Claude Code, стоейки в
inicio/: „СъздайEntrada.ktс интерфейсEntrada, който имаfun entrar(): String?, и класEntradaSinProveedor, който връщаnull. СъздайInicio.ktс композируема функцияInicio(nombre: String), която показва "Hola, ", последвано от името, и отдолу "Aquí verás tus órdenes". НаправиTiendaда получаваentrada: Entrada: при докосване на "Continuar" викаentrada.entrar(); ако върне име, минава към началния екран с това име; ако върнеnull, остава и слагаrechazadaнаtrue. ВMainActivityизползвайEntradaSinProveedor(). Вapp/src/test, доRecorridoTest.kt, създайEntradaFalsa.kt: получава име, винаги го връща и отчита въвvecesколко пъти са я помолили да влезе. Не променяйRecorridoTest.kt, нито двата екрана, които вече съществуват.“ - Прочетете цялата промяна, преди да я приемете. Тялото на функциите може да варира. Онова, което тестовете
викат по име, е част от договора на този урок и трябва да остане такова, каквото е:
Entradaсfun entrar(): String?,EntradaSinProveedor(),Tienda(entrada = …),EntradaFalsa(nombre)с брояча сиvecesи текстовете на екраните. С други имена вашият дизайн може да е също толкова добър, но тези тестове няма да се компилират. Трябва да носи тези четири части:
// Entrada.kt — договорът и имплементацията на приложението
interface Entrada {
fun entrar(): String? // името на онзи, който е влязъл, или null, ако не е могъл
}
class EntradaSinProveedor : Entrada {
override fun entrar(): String? = null
}
// EntradaFalsa.kt — в app/src/test, не в app/src/main
class EntradaFalsa(private val nombre: String) : Entrada {
var veces = 0
override fun entrar(): String? {
veces++
return nombre
}
}
// Tienda.kt — получава входа и пази три стойности на състояние
@Composable
fun Tienda(entrada: Entrada) {
var pantalla by remember { mutableStateOf(Pantalla.BIENVENIDA) }
var nombre by remember { mutableStateOf<String?>(null) }
var rechazada by remember { mutableStateOf(false) }
when (pantalla) {
Pantalla.BIENVENIDA -> Bienvenida(alEntrar = { pantalla = Pantalla.ENTRADA })
Pantalla.ENTRADA -> PantallaEntrada(
rechazada = rechazada,
alContinuar = {
val quien = entrada.entrar()
if (quien != null) {
nombre = quien
pantalla = Pantalla.INICIO
} else {
rechazada = true
}
}
)
Pantalla.INICIO -> Inicio(nombre = nombre ?: "")
}
}
// MainActivity.kt — единственото място в приложението, което назовава имплементация
setContent { Tienda(entrada = EntradaSinProveedor()) }
Четири неща, които да проверите при четенето:
: Entradaслед името на класа казва „този клас изпълнява този интерфейс“, аoverrideотбелязва функцията, която го изпълнява. Безoverrideне се компилира.entrada.entrar()е вътре вalContinuar, тоест вътре в събитието. Оставено свободно в тялото наTienda, то би се изпълнявало всеки път, когато функцията се чертае, а Compose може да я изпълнява много пъти.Tiendaне казва кой вход ѝ се е паднал. Познава само интерфейса.- В
Inicio.ktще видите"Hola, $nombre": знакът$вмъква стойността на променливата в текста.
- Изпълнете
verifica. Сега тестовете наистина се изпълняват: седем отметки „Simulado“ в зелено —шест от маршрута и една от стартирането— и редътResultado: 7 de 7 pruebas en verde (0 en rojo, 0 con error, 0 saltadas)(резултат: 7 от 7 теста в зелено, 0 в червено, 0 с грешка, 0 пропуснати). Остава една отметка в червено, тази наrespuestas/02.md: тя се попълва в стъпка 4. - Обяснете, в три реда от
respuestas/02.md: какво се случва между докосването на „Продължете“ и появата на „Здравейте, Ана“, като назовете стойностите на състояние, които се променят.
Покажете, че смяната на входа не засяга екраните. Тестовете вече използваха EntradaFalsa("Ana"),
EntradaFalsa("Luis") и EntradaSinProveedor() със същите три екрана. Сега го показвате вие. Стоейки в inicio/,
изпълнете това и поставете изхода в respuestas/02.md:
grep -rlE "EntradaSinProveedor|EntradaFalsa" app/src | sort
В solucion/ изходът са четири файла (измерено на 18 ноември 2026 г.): Entrada.kt и MainActivity.kt в
src/main, и EntradaFalsa.kt и RecorridoTest.kt в src/test. Нито един екран не се появява. Напишете отдолу кои
файлове бихте пипнали, за да въведете друг начин за влизане, и кои не.
Какво доказва всяка отметка и какво не.
- „Simulado“, шестте от маршрута: начертаха
Tiendaв паметта с входа, който тестът е избрал, докоснаха бутоните и потърсиха текстовете. Доказват кой екран остава след всяко докосване, с две имплементации. - „Simulado“, тази от стартирането: отвори
MainActivity, класа, който Android отваря при докосване на иконата, и докосна „Entrar“ и „Continuar“. Доказва, че по този път приложението не пуска никого. - „Texto“: само потърси думи във вашите файлове, без да брои коментарите. Не доказва, че кодът прави онова, което тези думи подсказват.
Никоя не доказва, че не съществува друг начин за влизане без доставчик: втори вход с друго име в src/main,
използван от друго място, минава в зелено. Това го проверявате вие: прочетете MainActivity.kt и се уверете, че вика
Tienda(entrada = EntradaSinProveedor()) и че в src/main няма друг клас, който да изпълнява Entrada. Не
доказват и как изглеждат екраните, какво прави бутонът „назад“, нито нещо за Google.
В инсталираното приложение стигате до екрана за вход, а „Продължете“ трябва да отговори „Все още не можете да
влезете“ („Todavía no se puede entrar“): приложението използва EntradaSinProveedor. До началния екран стигат само
тестовете.
Ако някой ред още не ви е ясен, преди да продължите опитайте да го обясните със свои думи. Ако пак не излиза, върнете се към този фрагмент или поискайте пояснение.
Доказва се с: симулираният verifica минава през трите екрана (цел 2.2) и го прави с две имплементации на
Entrada, плюс вашия изход от grep и вашето четене на MainActivity.kt (цел 2.4).
Стъпка 4 · Без ИИ: счупете едно нарочно
Това е упражнение 2.3 и се прави без Claude Code. Със седемте теста в зелено ще предизвикате сцената от началото.
1. Предвидете. В Tienda.kt редът на състоянието ще остане така, без remember:
var pantalla by mutableStateOf(Pantalla.BIENVENIDA)
Напишете в respuestas/02.md: компилира ли се?, какво се вижда, когато отворите приложението?, какво се случва, когато
докоснете „Вход“?
2. Счупете го и измерете. Направете промяната и изпълнете verifica. Това даде на 18 ноември 2026 г.:
✅ Simulado: la app empieza en la bienvenida, con «La tienda» y el botón «Entrar», y sin nada de las otras dos
❌ Al tocar el botón «Entrar» no aparece la pantalla de entrada con «Entra a tu cuenta» y un botón «Continuar» …
❌ conLaEntradaFalsaLlegaAlInicio quedó en rojo, pero depende de la marca anterior …
(y cuatro más iguales)
Resultado: 1 de 7 pruebas en verde (6 en rojo, 0 con error, 0 saltadas), leído de …
(Испанският е изходът на verifica, както се отпечатва. На български: „Симулирано: приложението започва от
приветствието, с «La tienda» и бутона «Entrar», и без нищо от другите два екрана“; „При докосване на бутона «Entrar» не
се появява екранът за вход с «Entra a tu cuenta» и бутон «Continuar» …“; „… остана в червено, но зависи от
предишната отметка …“; „(и още четири същите)“; „Резултат: 1 от 7 теста в зелено (6 в червено, 0 с грешка, 0
пропуснати), прочетено от …“.)
Копирайте в respuestas/02.md червения ред, който започва с „Al tocar el botón «Entrar» no aparece la pantalla de
entrada“. После инсталирайте приложението и го вижте сами.
3. Обяснете защо, със свои думи, преди да прочетете следващото.
Какво казва документацията на Android: remember пази стойност в паметта на екрана и при всяка рекомпозиция връща
същата стойност. Без remember редът се изпълнява отново изцяло. Веригата, изведена от тази документация
(verifica измерва резултата, не всяка стъпка), е такава:
- Докосвате „Вход“. Събитието променя стойността на
ENTRADA. - Compose научава, защото стойността все още се ражда от
mutableStateOf, и изпълняваTiendaотново. Tiendaтръгва отгоре и първият ред създава нова стойност, наBIENVENIDA.whenчете тази нова стойност. Приветствието се чертае пак.
Стойността наистина се промени. Загубено беше мястото, където се пазеше.
4. Друг начин да го счупите. Оставете реда като обикновена променлива: var pantalla = Pantalla.BIENVENIDA.
verifica дава същото 1 от 7 (измерено на 18 ноември 2026 г.), но по друга причина: според документацията Compose
научава само за промените в стойности, които може да наблюдава. Стойността се променя и никой не чертае отново.
5. Поправете го. Върнете реда на var pantalla by remember { mutableStateOf(Pantalla.BIENVENIDA) } и изпълнете
verifica: седем от седем, а сега и отметката на respuestas/02.md.
verifica само проверява, че сте поставили червения ред: не знае дали сте го счупили, нито оценява обяснението ви.
Упражнение 2.3 е завършено, когато можете да отметнете четирите:
- Предвиждането ви от точка 1 е написано, с това, което сте видели отдолу.
- Поставихте червения ред и „Resultado“, който ви е дал.
- Обяснихте, стъпка по стъпка, защо екранът спира да се обновява без
remember. - Казахте с какво втората форма на счупване е сходна и с какво не.
Едно ограничение. Според документацията на Android remember не запазва стойността при промяна на
конфигурацията, като завъртане на телефона; за това съществува rememberSaveable. Този урок нито го използва, нито го
проверява.
В емулатора от изпитването (18 ноември 2026 г.), при завъртане на телефона, докато сте на „Entra a tu cuenta“,
приложението се върна към приветствието: състоянието се загуби, както казва документацията. А „назад“, от всеки от
двата екрана, затвори приложението и върна началния екран на телефона: маршрутът на този урок не обработва „назад“.
Доказва се с: „Счупете едно нарочно“ (цел 2.3).
Вашите упражнения
2.1, стъпка 2 и 2.3 се правят без ИИ.
| # | Правите | Готово е, когато |
|---|---|---|
| 2.1 | Предвиждате какво прави състоянието от стъпка 1 и го изпълнявате | Имате предвиждането си и това, което сте видели |
| 2.2 | Изграждате приветствие → вход → начален екран | verifica дава 7 от 7 и в инсталираното приложение видяхте „Todavía no se puede entrar“ |
| 2.3 | Чупите състоянието и обяснявате защо екранът спира да се обновява | Доказателството ви са четирите квадратчета от стъпка 4, написани от вас. verifica само потвърждава, че проектът е оправен (7 от 7) и че сте поставили червеното |
| 2.4 | Отделяте решението за влизане в Entrada и показвате, че смяната му не засяга екраните |
Тестовете с двете имплементации и този от стартирането са в зелено, поставихте изхода си от grep и прочетохте, че src/main не носи друг вход |
Време: отделете около три часа, с „Счупете едно нарочно“. Това е приблизителна оценка: ще я поправим според времето, което отнеме на първата група.
Не ви ли тръгва?
Съобщенията на английски са тези, които компилаторът на поредицата (Kotlin 2.4.21) даде на 18 ноември 2026 г.
| Виждате | Вероятна причина | Какво правите |
|---|---|---|
No value passed for parameter 'alEntrar' |
Някой вика Bienvenida() без функцията |
Подайте ѝ я: Bienvenida(alEntrar = { … }) |
'when' expression must be exhaustive. Add the 'INICIO' branch or an 'else' branch. |
На when му липсва един от трите екрана |
Добавете клона, който съобщението назовава |
'entrar' hides member of supertype 'Entrada' and needs an 'override' modifier. |
Класът изпълнява интерфейса, без да го казва | Напишете override fun entrar() |
Smart cast to 'String' is impossible, because 'nombre' is a delegated property. |
Попитахте if (nombre != null) върху състояние и го използвахте като String |
Първо запазете резултата във val, като val quien = entrada.entrar() |
| ❌ „EntradaFalsa aparece en src/main“ (EntradaFalsa се появява в src/main) | Входът, който пуска хора, е останал вътре в приложението | Преместете го в app/src/test/java/mx/habil/ejemplo/tienda/ |
| ❌ при „solo al tocar Continuar“ (само при докосване на Continuar) | entrada.entrar() е останало извън събитието |
Отива вътре в alContinuar = { … } |
RecorridoTest.kt или ArranqueTest.kt са се променили |
Някой (вие или Claude Code) е пипнал тестовете | Вижте какво се е променило с git diff, който съобщението дава, и го отменете на ръка. Възстановяването на файла с git отхвърля всичко, което има: правете го само след като прегледате този diff. После повторете заявката, като поискате да не ги пипа |
На Linux Mint 22.3 (x86_64) verifica на този урок излезе в зелено върху решението: 7 от 7 (18 ноември 2026 г.).
В заключение
Отговорете, без да четете отново:
- Докосвате „Вход“ и екранът се променя. Какво се е случило по средата, по ред?
- Какво прави
rememberи какво се вижда в приложението, ако го махнете? - Седемте ви симулирани теста са в зелено. Кажете едно нещо, което това доказва, и едно, което не доказва.
- Защо
EntradaFalsaживее вsrc/test, а не вsrc/main?
Какво следва: в урок 03 приложението опознава Firebase, а в урок 04 влизате с Google.
Сравнете отговорите си
Стъпка 1. След първото докосване се вижда „Здравейте!“ („¡Hola!“), след второто изчезва, а след третото се връща (измерено на 18 ноември 2026 г. със симулиран тест).
Стъпка 2. В трета функция, която вика двете, Tienda. Ако стойността живееше в Bienvenida, екранът за вход не
би могъл да я прочете, а когато приветствието спре да се чертае, стойността би се изгубила заедно с него.
Стъпка 3. Променят се Tienda.kt и MainActivity.kt; Bienvenida.kt и PantallaEntrada.kt не: те само
получаваха данни и подаваха сигнали за докосвания. Между докосването и „Здравейте, Ана“: alContinuar вика
entrada.entrar(), което връща "Ana"; запазва се в nombre и pantalla става INICIO; Compose изпълнява Tienda
отново и when избира Inicio. За да въведете друг начин за влизане, с онова, което има в този урок, пишете нова
имплементация и променяте реда в MainActivity.kt, който я избира; екраните и Tienda.kt не се пипат. Как изглежда
с истинския Google, се вижда в урок 04.
Стъпка 4. Да, компилира се, а симулираните тестове намират приветствието при отварянето; при докосване на
„Вход“ екранът не се променя. Втората форма е сходна в броя (1 от 7), но не и в причината: без remember Compose
чертае отново със стойност, току-що създадена; с обикновена променлива никога не научава.
В заключение:
- Събитието промени стойност на състояние; Compose изпълни отново функцията, която я е прочела;
whenизбра друг екран. - Пази стойността между една рекомпозиция и следващата. Без него приложението остава на приветствието.
- Доказва кой екран остава след всяко докосване, с вход, който пуска, и с такъв, който не пуска, и че приложението,
отворено от
MainActivity, не пуска никого. Не доказва как изглеждат, какво прави бутонът „назад“, че няма друг начин за влизане по друг път, нито че Google работи. - Защото пуска всекиго. В
src/testя използват само тестовете и не пътува в инсталираното приложение.
Източници на урока
Отворени на 18 ноември 2026 г.
- Android Developers. State and Jetpack Compose. https://developer.android.com/develop/ui/compose/state
- Android Developers. Thinking in Compose (рекомпозиция; ефектите отиват в събитията). https://developer.android.com/develop/ui/compose/mental-model
- Android Developers. Lifecycle of composables (какво задейства рекомпозиция). https://developer.android.com/develop/ui/compose/lifecycle
- Android Developers. Where to hoist state (най-близкият общ предшественик). https://developer.android.com/develop/ui/compose/state-hoisting
- Android Developers. Navigation (библиотеката, която този урок не използва). https://developer.android.com/guide/navigation
- Android Developers. Use test doubles in Android (какво е дубльор; казва, че този, който живее в тестовия код, не пътува с приложението). https://developer.android.com/training/testing/fundamentals/test-doubles
- Android Developers. Android build structure (разлика между
src/mainиsrc/test). https://developer.android.com/build/android-build-structure - Android Developers. Build local unit tests и Test in Android Studio. https://developer.android.com/training/testing/local-tests · https://developer.android.com/studio/test/test-in-android-studio
- Android Developers. Test your Compose layout. https://developer.android.com/develop/ui/compose/testing
- Android Developers. SemanticsMatcher и Role (роля на бутон в тестовете). https://developer.android.com/reference/kotlin/androidx/compose/ui/test/SemanticsMatcher · https://developer.android.com/reference/kotlin/androidx/compose/ui/semantics/Role
- Kotlin. Interfaces. https://kotlinlang.org/docs/interfaces.html
- Kotlin. Enum classes. https://kotlinlang.org/docs/enum-classes.html
- Kotlin. Conditions and loops (
when). https://kotlinlang.org/docs/control-flow.html - Kotlin. Higher-order functions and lambdas (функционални типове като
() -> Unit) и Functions (Unit). https://kotlinlang.org/docs/lambdas.html · https://kotlinlang.org/docs/functions.html - Kotlin. Strings (шаблони с
$). https://kotlinlang.org/docs/strings.html - Собствено измерване: Mac с Apple silicon, 18 ноември 2026 г. (
verificaвърхуinicio/иsolucion/; двата начина за счупване на състоянието; предвиждането от стъпка 1; междинното състояние на стъпка 2, със и без правописна грешка; съобщения на компилатора).
Външен преглед (18 ноември 2026 г.): С ПРОМЕНИ, 3 с висок приоритет, 4 със среден и 2 с нисък; приложен.
Предпочитате имейл? Пишете ни на hola@habil.mx