Към съдържанието
Съдържание на курса

Урок 01 — Първият ми екран работи

От · съосновател и Chief Executive Officer на Hábil ·

Преди да четете, седем думи. По един ред за всяка; останалите от поредицата идват в урока, в който се използват.

  • Kotlin: езикът, на който пишете приложението. Файловете му завършват на .kt.
  • Compose (Jetpack Compose): библиотеката на Android за изграждане на екрани чрез писане на функции на Kotlin.
  • Composable функция: функция, маркирана с @Composable, която описва част от екрана.
  • Скица: рисунката как трябва да изглежда екранът. С нея сравнявате.
  • Модификатор: това, което казва на един елемент колко място заема и колко отстъп оставя.
  • Състояние: данна, която екранът помни и която може да се променя, например „бутонът вече е натиснат“.
  • Симулиран тест: тест, който изчертава вашия екран в паметта на компютъра ви, без емулатор, и търси в него онова, което трябва да е там.

Какво отнасяте: приветствения екран на магазина —име, мото и бутон— написан от вас, и умението да четете екран на Compose ред по ред и да казвате какво променя всеки ред на екрана.

Новата идея на този урок (единствената, която се оценява): в Compose екранът е функция, която описва онова, което се вижда. Няма отделен файл с оформление: четете функцията и знаете какво ще се появи.

Бележка за текстовете на приложението. Проектът на курса носи екранните си текстове на испански, а файловете в lecciones/ не са преведени: автоматичните проверки на курса (verifica) търсят тъкмо тези текстове. Затова в блоковете с код, в изходите на терминала и в скиците на екрана текстовете остават така, както са в проекта, а в прозата урокът ги цитира на български и първия път дава оригинала в скоби: името „Магазинът“ (в проекта: „La tienda“), мотото „Вашите поръчки, в джоба ви“ („Tus órdenes, en tu bolsillo“), бутонът „Вход“ („Entrar“) и поздравът „Здравейте!“ („¡Hola!“).


Сцената

Искате от Claude Code приветствения екран. След малко имате кратък файл на Kotlin. Компилира се. Тестовете минават в зелено. Инсталирате го, натискате „Вход“ и се появява поздравът. Затваряте компютъра.

На следващия ден някой отваря приложението до скицата и ви пита: „защо поздравът излиза над бутона, когато тук е под него?“. Отваряте файла. Виждате remember, mutableStateOf, Modifier, един if по средата на екрана. Не знаете кой от тези редове мести поздрава.

Този код съществува: това е листингът от упражнение 1.3, а неговите тестове излизат 4 от 4 в зелено, макар поздравът да е на грешното място (измерено на 18 ноември 2026 г.). Зеленото казва, че поздравът се появява. Не казва къде.

Затова уроците вървят в този ред: четете един екран, пишете един на ръка, искате промяна от Claude Code и накрая обяснявате —без помощ— какво прави всеки блок от онова, което е генерирал.


Преди да започнете

Какво ви трябва:

Върши работа Не върши работа
Предишен урок 00 завършен: зададен ANDROID_HOME и емулатор или вашият телефон Да го прескочите: без SDK проектът не се компилира
Знания Да програмирате на някакъв език и да сте правили интерфейс Не се предполагат Kotlin и Compose

Началният проект. От корена на хранилището на поредицата:

git pull
cd lecciones/01-mi-primera-pantalla/inicio

Там работите. До него е solucion/, с решения екран: той е за сравнение накрая, не за преписване.

Какво вече носи проектът (скелето). Не го пишете вие и тук не се оценява, но си струва да знаете защо е там:

Какво носи Къде Защо
org.gradle.jvmargs=-Xmx4g gradle.properties Дава 4 GB памет на Gradle, инструмента, който компилира. Без нея компилирането с Firebase (урок 03) се провали с „Java heap space“ (измерено на 13 ноември 2026 г.)
gradlew вече генериран коренът на проекта Скриптът, който сваля и пуска точната версия на Gradle. Генерирането му с gradle wrapper вътре в проект с AGP 9.4 се провали (измерено на 13 ноември). Не го генерирайте наново
sdk=36 app/src/test/resources/robolectric.properties Симулираните тестове използват копие на Android 36. Без да е зададено, взимаха Android 37 и нито един не се изпълни (измерено на 13 ноември)
jvmToolchain(25) app/build.gradle.kts При опита от 13 ноември Robolectric, докато зареждаше своя Android 36, не стартира с Java 17 и поиска Java 21 или по-нова. Затова проектът фиксира 25

Скицата. Ето какво трябва да се вижда накрая:

┌────────────────────────────────┐
│                                │
│           La tienda            │  ← име, с едър шрифт
│  Tus órdenes, en tu bolsillo   │  ← мото
│          [ Entrar ]            │  ← бутон
│            ¡Hola!              │  ← появява се само след като натиснете «Entrar»
│                                │
└────────────────────────────────┘
  Всичко центрирано, по средата на екрана, с 24 dp отстъп.

dp е единицата на Android за размери: приблизително един пиксел на екран със средна плътност, нагласена така, че да изглежда със същия размер и на по-плътни екрани.


Стъпка 1 · Прочетете един екран, преди да го пуснете

Отворете app/src/main/java/mx/habil/ejemplo/tienda/Bienvenida.kt. Ето как идва:

@Composable
fun Bienvenida() {
    Column(
        modifier = Modifier.fillMaxSize().padding(24.dp),
        verticalArrangement = Arrangement.Center
    ) {
        Text("Aquí va tu pantalla")
        Text("Lección 01")
    }
}

Първо предвидете. В корена на хранилището създайте папката за отговори, ако още я няма (mkdir -p respuestas), и в нея файла respuestas/01.md. Там отиват вашите предвиждания и обяснения. Преди да пуснете каквото и да е, напишете три реда: колко текста ще се виждат?, един до друг или един под друг?, залепени вляво или центрирани?

За да предвидите, четете функцията отвън навътре:

  • @Composable маркира функцията като такава, която описва екран.
  • fun Bienvenida() е функция на Kotlin. Не връща нищо: описва онова, което трябва да се вижда.
  • Column( … ) { … } подрежда онова, което носи вътре, във вертикална последователност: един под друг.
  • Text("…") показва текст. Всяко извикване е един елемент.
  • Modifier.fillMaxSize().padding(24.dp) казва, че колоната заема цялото пространство, което ѝ е дадено, и оставя 24 dp отстъп.
  • verticalArrangement = Arrangement.Center поставя съдържанието по средата на височината. За хоризонталното никой не е казал нищо, а в Column то започва по подразбиране от Alignment.Start: страната, откъдето започва текстът.

Сега го пуснете. С отворен емулатор или с включен телефон:

./gradlew installDebug      # компилира и инсталира; не отваря приложението

Отворете го от списъка с приложения и сравнете с вашите три реда. Ако някое предвиждане е излязло грешно, не го изтривайте: напишете отдолу кой ред от кода би ви дал отговора. В емулатора от опита (Pixel 9, Android 37, 18 ноември 2026 г.) се видяха два текста, „Тук е вашият екран“ („Aquí va tu pantalla“) и под него „Урок 01“ („Lección 01“), по средата на височината и залепени вляво.

Второ предвиждане. Ами ако махнете Column и оставите двата Text сами? Според документацията на Android Compose ги слага един върху друг. Опитайте, запишете какво виждате и върнете Column.

Кой извиква Bienvenida()? MainActivity.kt, в същата папка: редът ѝ setContent { Bienvenida() } казва коя функция чертае екрана. Него не го променяте.

Доказва се с: вашето написано предвиждане, сравнено с изпълнението (цел 1.1).


Стъпка 2 · Kotlin: онова, което вече познавате, с друго име

Достатъчно е да разпознаете три неща, които вече ползвате на друг език.

В Kotlin Какво е Къде го виждате
val nombre = "La tienda" Променлива, на която се присвоява стойност веднъж и вече не се променя val pantalla = … в BienvenidaTest.kt
var saludando = false Променлива, която може да се променя Пишете я в стъпка 4
fun doble(n: Int): Int { return n * 2 } Функция: име, параметри с техния тип и тип на върнатата стойност fun Bienvenida()
fun doble(n: Int) = n * 2 Същата, в кратък вид: тялото е израз, а типът на върнатата стойност се извежда
Bundle? Тип, който може да е null. Без ? не може savedInstanceState: Bundle? в MainActivity.kt

Три подробности, които наистина се различават от други езици:

  • Типът стои след името: n: Int. При променлива почти никога не го пишете: в val x = 5 Kotlin заключава, че е Int.
  • Null стойностите се декларират. Променлива String не може да съхранява null. Ако може да липсва, типът е String?, и тогава lema.length е грешка при компилиране; lema?.length връща null, ако lema е null; а lema?.length ?: 0 връща 0 в този случай.
  • Скобите накрая са функция, която подавате на друга. В Column( … ) { … } онова, което е между къдравите скоби, е функция без име (ламбда). Ако последният параметър на една функция е друга функция, Kotlin позволява да я напишете извън кръглите скоби. Затова Compose изглежда като вложени блокове.

Доказва се с: преговора 1.4, в „Вашите упражнения“.


Стъпка 3 · Напишете приветствието, на ръка

Тази стъпка е ваша, без Claude Code: това са около десет реда.

Първо предвидете. Колко извиквания на composable функции ще са ви нужни вътре в Column и коя от тях ще носи друга вътре в себе си?

В Bienvenida.kt:

  1. Добавете три реда към блока с import. Един import казва на Kotlin от коя библиотека идва всяко име:
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.ui.Alignment
  1. Центрирайте хоризонталното. Сложете запетая след Arrangement.Center и отдолу параметъра, който липсваше:
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
  1. Сменете двата текста с трите елемента от скицата:
        Text("La tienda", style = MaterialTheme.typography.headlineLarge)
        Text("Tus órdenes, en tu bolsillo")
        Button(onClick = { }) {
            Text("Entrar")
        }

style = MaterialTheme.typography.headlineLarge дава на името един от размерите на шрифта на Material, набора от визуални компоненти на Android. Button носи две неща: onClick, функцията, която се извиква, когато някой го натисне —засега празна—, и между къдравите скоби онова, което се вижда вътре в бутона, а то е още един Text.

Пуснете verifica. От корена на хранилището:

./lecciones/01-mi-primera-pantalla/verifica

Не променя вашия код: пуска симулираните тестове (./gradlew testDebugUnitTest) и ви превежда резултата. Първия път има нужда от мрежа и отнема време, защото сваля библиотеката за тестове (Robolectric) и копие на Android: при опита от 13 ноември беше 1 минута и 21 секунди на Mac; следващите, секунди.

Вървите добре, ако виждате три зелени отметки и една червена:

✅ Simulado: la pantalla muestra el nombre «La tienda»
✅ Simulado: la pantalla muestra el lema «Tus órdenes, en tu bolsillo»
✅ Simulado: hay un elemento «Entrar» con acción de toque y rol de botón
❌ Al tocar el botón «Entrar» no aparece «¡Hola!» (o ya estaba desde antes): ese cambio lo pides en el paso 4
Resultado: 3 de 4 pruebas en verde (1 en rojo, 0 con error, 0 saltadas), leído de …

(Това е изходът на verifica, точно както го отпечатва скриптът, на испански. На български казва: екранът показва името; екранът показва мотото; има елемент „Вход“ с действие при докосване и роля на бутон; и, в червено, „при натискане на бутона „Вход“ не се появява „Здравейте!“ (или вече е било там): тази промяна я искате в стъпка 4“; и резултатът, 3 от 4 теста в зелено.)

Това червено е очакваното: бутонът още не прави нищо. В червено излиза и отметката за respuestas/01.md, която още не сте попълнили.

Какво доказва всяка отметка и какво не. „Simulado“ (симулиран) значи, че тестът е изчертал вашата функция в паметта и е намерил този текст, и че „Вход“ може да се докосне и е обявен за бутон (Text, на който добавяте само докосване, не минава). Не доказва размера на шрифта, отстъпа, центрирането нито реда: това го виждате вие, с ./gradlew installDebug и скицата до себе си.

Доказва се с: симулираният verifica намира трите елемента и вие сте сравнили инсталираното приложение със скицата (цел 1.2).


Стъпка 4 · С Claude Code: нека бутонът поздравява

Тук влиза инструментът и влиза винаги по един и същ начин: предвиждате → искате от него → четете какво е генерирал → пускате verifica → обяснявате със свои думи.

  1. Предвидете. Напишете в respuestas/01.md: за да се появи „Здравейте!“ само след натискане на бутона, какво трябва да помни екранът? Кой от редовете, които вече сте написали, ще се промени?
  2. Поискайте от Claude Code, застанали в inicio/: „В Bienvenida.kt направи така, че при натискане на "Entrar" да се появява текстът "¡Hola!" под бутона. Преди натискането не трябва да се вижда. Не променяй нищо друго и не пипай тестовете.“
  3. Прочетете цялата промяна, преди да я приемете. Не е нужно да е идентична с тази, но трябва да носи тези три части:
    var saludando by remember { mutableStateOf(false) }      // 1. състоянието
    …
        Button(onClick = { saludando = true }) {             // 2. събитието
            Text("Entrar")
        }
        if (saludando) {                                     // 3. екранът чете състоянието
            Text("¡Hola!")
        }
  1. Пуснете verifica. Сега четирите теста трябва да излязат в зелено.
  2. Обяснете, в два реда от respuestas/01.md, какво става между натискането на бутона и появата на поздрава.

Днес не проектирате състояние от нулата: само проследявате промяната, която предлага Claude Code. Кое състояние си струва да се пази и как да се съхрани е централната идея на урок 02. За да го проследите, трябва да знаете какво прави всяка част:

  • mutableStateOf(false) създава стойност, която Compose наблюдава. Когато се промени, Compose насрочва обновяването на частта от екрана, която я е прочела. Това се нарича прекомпозиция.
  • remember { … } пази тази стойност, докато този екран е жив. Това не е запис на диска: ако Android създаде екрана наново, тя се връща на false.
  • by позволява да използвате saludando като обикновена променлива. Иска два import: androidx.compose.runtime.getValue и androidx.compose.runtime.setValue.
  • onClick = { saludando = true } е събитието: променя само състоянието. Не чертае нищо.
  • if (saludando) { Text("¡Hola!") } е обикновен Kotlin вътре в екрана: ако състоянието е true, този текст съществува; ако не, не съществува.

Идеята на урока, цялата: натискате → състоянието се променя → Compose обновява онова, което е прочело това състояние, а тук това е if → описанието на екрана вече включва поздрава. Никой не „добавя“ текста. И Compose може да изпълни наново само необходимото: не пишете код, предполагайки, че цялата функция ще се изпълни.

Ако някой ред още не ви е ясен, спрете тук: поискайте от Claude Code да го обясни, проверете го с малка промяна и с verifica, и продължете, когато можете да го кажете със свои думи.


Стъпка 5 · Без ИИ: обяснете пет блока и поправете един

Това е упражнение 1.3 и се прави без Claude Code, върху вашия собствен Bienvenida.kt. Ако вашият вече отговаря на скицата, за поправката използвайте този листинг, който е един възможен отговор на същата заявка:

19  @Composable
20  fun Bienvenida() {
21      var saludando by remember { mutableStateOf(false) }
22
23      Column(
24          modifier = Modifier.fillMaxSize().padding(24.dp),
25          verticalArrangement = Arrangement.Center,
26          horizontalAlignment = Alignment.CenterHorizontally
27      ) {
28          Text("La tienda", style = MaterialTheme.typography.headlineLarge)
29          Text("Tus órdenes, en tu bolsillo")
30          if (saludando) {
31              Text("¡Hola!")
32          }
33          Button(onClick = { saludando = true }) {
34              Text("Entrar")
35          }
36      }
37  }

С този листинг verifica дава 4 от 4 в зелено (измерено на 18 ноември 2026 г.). И въпреки това не отговаря на скицата.

Правите две неща, писмено, в respuestas/01.md:

  1. Обяснете пет блока, по един от всеки вид: състояние, текст, модификатор, събитие и функция. За всеки напишете реда му във формата Bienvenida.kt:21 и какво се променя на екрана, ако го махнете или го промените. „Пази булева стойност“ не е видим ефект; „без този ред поздравът никога не се появява“ е.
  2. Поправете блока, който не отговаря на скицата. Кажете кой е и защо тестовете не го засичат, поправете го, пуснете verifica и инсталирайте приложението отново.

verifica само проверява, че сте записали поне пет препратки във формата Bienvenida.kt:N; не оценява вашите обяснения нито поправката. А 4 от 4 потвърждава поведение, не как изглежда. Упражнение 1.3 е завършено, когато можете да отметнете и четирите:

  • Налице са петте вида: състояние, текст, модификатор, събитие и функция.
  • Всеки казва ефект, който се вижда на екрана.
  • Обяснихте защо поздравът излизаше отгоре и защо тестовете не го засякоха.
  • След преместването 4 от 4 остава в зелено и в инсталираното приложение видяхте „¡Hola!“ под „Entrar“. Запишете това наблюдение до поправката.

Доказва се с: упражнение 1.3 (цел 1.3).


Вашите упражнения

1.2 и 1.3 се правят без ИИ.

# Правите Готово е, когато
1.1 Предвиждате какво чертае функцията от стъпка 1 и я пускате Имате вашите три реда и онова, което видяхте
1.2 Пишете име, мото и бутон по скицата verifica отбелязва в зелено трите елемента и сте сравнили инсталираното приложение със скицата: групата центрирана и името с едър шрифт
1.3 Обяснявате пет блока и поправяте онзи, който не отговаря на скицата Отметнахте четирите квадратчета от стъпка 5: 4 от 4 остава в зелено и видяхте поздрава под бутона в инсталираното приложение
1.4 Отговаряте на преговора по Kotlin Четири от пет верни, всеки със своето защо

Преговор 1.4. Отговорете, без да пускате кода. verifica не оценява вашите предвиждания нито този преговор: сравнете ги сами със „Сравнете отговорите си“ и запазете онова, което сте написали.

  1. val nombre = "La tienda" и на следващия ред nombre = "Otra". Компилира ли се?
  2. var saludando = false. Никой не е написал типа. Кой е той и кой го е решил?
  3. fun doble(n: Int) = n * 2. Какво връща doble(4) и от какъв тип е?
  4. В MainActivity.kt пише savedInstanceState: Bundle?. Какво ви подсказва този ??
  5. val lema: String? = null. Какво става с lema.length, с lema?.length и с lema?.length ?: 0?

Време: отделете около два часа, с компилирането и вашите предвиждания. Това е оценка: ще я нагласим според времето, което отнеме на първата група.


Не ви ли тръгва?

Съобщенията на английски са тези, които компилаторът на поредицата (Kotlin 2.4.21) даде на 18 ноември 2026 г.

Виждате Вероятна причина Какво правите
Unresolved reference 'Button' Липсва import за това име или е написан грешно Добавете import от стъпка 3 и проверете главните букви
'val' cannot be reassigned Декларирахте състоянието с val и после го променяте Трябва да е var saludando by remember { … }
Property delegate must have a 'getValue(…)' method Използвахте by без двата му import Добавете getValue и setValue (стъпка 4)
„Las pruebas no llegaron a correr“ (тестовете не стигнаха до изпълнение) Кодът не се компилира Прочетете реда, който започва с e:: носи файл, ред и колона
❌ при бутона, с видимо „Entrar“ Това е Text, самостоятелен или с clickable: не е обявен за бутон Трябва да е Button с Text вътре
❌ при поздрава, макар да се вижда „¡Hola!“ Поздравът е винаги там, а не само след натискане Отива вътре в if (saludando)
BienvenidaTest.kt се е променил Някой (вие или Claude Code) е пипнал тестовете Възстановете го с командата, която дава съобщението, и повторете заявката, като поискате да не ги пипа

На Linux Mint 22.3 (x86_64) verifica на този урок излезе в зелено върху решението: 4 от 4, за 64 секунди, включително първото компилиране (18 ноември 2026 г.). Ако вашият SDK не носи build-tools, Gradle ги сваля сам първия път.


В заключение

Отговорете, без да четете отново:

  1. Какво е екранът в Compose, в едно изречение?
  2. Натискате „Entrar“ и се появява „¡Hola!“. Какво се случи по средата, по ред?
  3. Вашите четири симулирани теста са в зелено. Кажете едно нещо, което това доказва, и едно, което не доказва.

Какво следва: в урок 02 приложението има повече от един екран и преминава от единия към другия.


Сравнете отговорите си

Стъпка 1. Два текста, един под друг (Column), по средата на височината (Arrangement.Center) и от лявата страна (никой не е посочил хоризонталното подравняване).

Стъпка 3. Четири извиквания: Text, Text, Button и, вътре в бутона, още един Text.

Упражнение 1.3, върху листинга от стъпка 5:

Блок Ред Видим ефект
Състояние Bienvenida.kt:21 Без него поздравът не може да се появи след докосването
Текст Bienvenida.kt:28 Това е името; без style би се видяло със същия размер като мотото
Модификатор Bienvenida.kt:24 Без fillMaxSize() колоната заема само онова, което мери съдържанието ѝ: няма вече място, в което да се центрира
Събитие Bienvenida.kt:33 С onClick = { } бутонът може да се докосне, но нищо не се случва
Функция Bienvenida.kt:20 Това е целият екран; MainActivity я извиква

Блокът, който не отговаря на скицата, е този на редове 30 до 32: той е преди бутона, така че поздравът излиза над „Entrar“, а скицата го иска отдолу. Поправя се, като преместите тези три реда след ред 35. Тестовете не го засичат, защото проверяват текстът да съществува и да се вижда, не на коя позиция е.

Преговор 1.4:

  1. Не. val не може да се присвоява повторно; компилаторът казва 'val' cannot be reassigned.
  2. Boolean. Kotlin го е заключил от стойността false.
  3. Връща 8, от тип Int: тялото е израз, а типът на върнатата стойност се извежда.
  4. Че този параметър може да пристигне като null, а Kotlin не ви позволява да го ползвате, без да вземете предвид този случай.
  5. lema.length не се компилира; lema?.length дава null; lema?.length ?: 0 дава 0.

В заключение:

  1. Функция, маркирана с @Composable, която описва онова, което се вижда.
  2. onClick промени състоянието на true; Compose изпълни функцията наново; if вече включва текста.
  3. Доказва, че трите елемента и поздравът съществуват и че бутонът отговаря. Не доказва как изглеждат нито в какъв ред са.

Източници на урока

Отворени на 18 ноември 2026 г.

Външен преглед (18 ноември 2026 г.): С ПРОМЕНИ, 3 с висок приоритет, 5 със среден и 2 с нисък; приложен.

Да обсъдим вашия проект

Предпочитате имейл? Пишете ни на hola@habil.mx