Android: co to je, architektura systému a vývoj v Kotlinu

Co je Android?

Android je mobilní operační systém založený na jádru Linux, vyvíjený Googlem od roku 2007. Zdrojový kód je otevřený pod licencí Apache 2.0 v rámci projektu Android Open Source Project (AOSP). Každý výrobce může systém upravit a nainstalovat na svá zařízení.

Podle StatCounter (2026) Android drží přibližně 72% celosvětového trhu mobilních OS. Největšími výrobci jsou Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentace je klíčovým problémem platformy: tisíce modelů s různými verzemi OS se používají současně.

Architektura Androidu je postavena na principu oprávnění (permissions): každá aplikace běží pod samostatným Linux UID a má přístup pouze ke svým datům. Přístup k systémovým zdrojům (kamera, mikrofon, kontakty) je vyžadován prostřednictvím Android Permissions za běhu, počínaje Android 6 (API 23).

Historie verzí Android

Android 1.0 byl vydán v roce 2008 na HTC Dream. Klíčové milníky: Android 4.0 Ice Cream Sandwich (jednotné UI pro telefony a tablety), Android 5.0 Lollipop (Material Design), Android 6.0 (oprávnění za běhu), Android 10 (tmavé téma, gesta), Android 12 (Material You). Od roku 2023 Google přešel na každoroční hlavní vydání bez názvů dezertů.

Architektura Android: čtyři klíčové vrstvy

Architektura Android se skládá ze čtyř hlavních vrstev, které izolují hardware od uživatelských aplikací. Každá vrstva využívá služby vrstvy pod ní prostřednictvím přísně definovaných rozhraní.

Jádro Linux a HAL

Nejnižší vrstva je modifikované jádro Linux (LTS, verze 6.x v Android 15). Spravuje paměť, procesy, síťový zásobník a ovladače. Hardware Abstraction Layer (HAL) poskytuje jednotné API pro interakci s hardwarem: kamera, Bluetooth, Wi-Fi, senzory. Výrobci implementují moduly HAL, aniž by ovlivňovali horní vrstvy.

Android Runtime (ART)

ART spouští DEX bajtkód aplikací. Počínaje Android 5.0, ART nahradil Dalvik a používá Ahead-of-Time (AOT) kompilaci pro zlepšení výkonu. Každá aplikace má svůj vlastní proces se samostatnou instancí ART. Garbage collection (GC) pracuje s minimálními pauzami — typická pauza GC je 2–4 ms.

Application Framework

Framework je vrstva, se kterou vývojář přímo pracuje. Zahrnuje Activity Manager (zásobník obrazovek), Content Providers (přístup k datům), Resource Manager (lokalizace, zdroje), Notification Manager, Location Manager. Všechny systémové služby jsou volány přes Binder IPC — mechanismus meziprocesové komunikace Android.

// Příklad práce s Binder přes AIDL rozhraní
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementace služby
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

Systémové aplikace

Nejvyšší vrstva tvoří standardní systémové aplikace: Telefon, Kontakty, Kamera, Nastavení, Prohlížeč. Nemají vyšší oprávnění než uživatelské aplikace, ale mohou být nahrazeny aplikacemi třetích stran. V Android 15 jsou systémové aplikace aktualizovány prostřednictvím Google Play System Updates nezávisle na OTA aktualizacích výrobce.

Kotlin — primární jazyk vývoje Android

Kotlin je staticky typovaný programovací jazyk od JetBrains běžící na JVM. Google oznámil Kotlin jako oficiální jazyk Android v roce 2017 na Google I/O. Kotlin je plně kompatibilní s Javou, ale odstraňuje její nedostatky: nulovou bezpečnost, datové třídy, rozšiřující funkce a korutiny.

Nulová bezpečnost a typy

Hlavní vlastností Kotlin je vestavěná ochrana proti NullPointerException. Typy jsou rozděleny na nullable (String?) a non-null (String). Kompilátor kontroluje nullable přístup v době kompilace. Operátor safe call (?.) a operátor Elvis (?:) zjednodušují práci s volitelnými hodnotami bez vnořených kontrol.

// Příklad kódu Kotlin s korutinami a Flow
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

Příklad ukazuje korutiny (funkce suspend) pro asynchronní přístup k síti a databázi, Flow pro reaktivní pozorování změn dat a Result pro bezpečné zpracování chyb. Korutiny nahrazují callbacky a RxJava bez režie vláken.

Kotlin korutiny a Flow

Kotlin korutiny jsou lehká vlákna běžící na sdíleném fondu vláken. Dispatchers.IO pro síť a disk, Dispatchers.Main pro UI, Dispatchers.Default pro úkoly náročné na CPU. viewModelScope a lifecycleScope automaticky ruší korutiny při zničení komponenty.

// ViewModel s korutinami a StateFlow
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio a vývojové nástroje

Android Studio je oficiální IDE založené na IntelliJ IDEA, vyvinuté Googlem. Zahrnuje editor kódu, Layout Inspector, emulátor zařízení, APK Analyzer, Profiler (CPU, Paměť, Síť, Energie) a integraci Firebase. Android Studio 2024 (Ladybug) podporuje Kotlin 2.0 s multiplatformním režimem KMP.

Android emulátor

Android emulátor používá KVM (Linux) nebo Hyper-V (Windows) pro hardwarovou akceleraci. Podporuje simulaci GPS, senzorů, kamery, hovorů a SMS. Google Pixel 9 Pro je doporučená konfigurace pro testování s API 35 a 8 GB RAM emulátoru.

Android Profiler a ladění

Profiler v reálném čase zobrazuje zatížení CPU, alokaci paměti, síťové požadavky a spotřebu energie. Memory Profiler umožňuje výpis haldy a analýzu úniků pomocí referenčního stromu. Network Inspector zaznamenává všechny HTTP/HTTPS požadavky s tělem a hlavičkami. Pro hloubkovou analýzu se používá Android Studio Canary.

Komponenty Android aplikace

Android aplikace se skládá ze čtyř typů komponent, každá s vlastním vstupním bodem a životním cyklem. Komponenty se registrují v souboru AndroidManifest.xml.

Activity a Intent

Activity je základní komponentou uživatelského rozhraní. Každá obrazovka je samostatná Activity nebo Fragment uvnitř Activity. Navigace mezi obrazovkami probíhá přes Intent — objekt obsahující akci (ACTION_VIEW, ACTION_SEND) a data (URI). V Jetpack Navigation Graph je navigace popsána v XML.

Service a WorkManager

Service provádí úlohy na pozadí, ale od Android 8 jsou služby na pozadí omezeny. WorkManager je doporučená knihovna pro odložené a garantované úlohy na pozadí s podporou řetězců, omezení (např. pouze při nabíjení) a restartu po pádu.

Jetpack Compose vs XML Layouts

Volba mezi Jetpack Compose a tradičními XML rozvrženími je hlavním architektonickým rozhodnutím při zahájení Android projektu. XML rozvržení (RecyclerView, ConstraintLayout, FrameLayout) jsou standardem od roku 2008. Jetpack Compose byl představen v roce 2021 jako deklarativní alternativa.

Google doporučuje Jetpack Compose pro všechny nové projekty. XML rozvržení zůstávají relevantní pro podporu starších projektů a pro případy, kde je vyžadováno maximální přizpůsobení View (Canvas, SurfaceView). Compose kód je v průměru o 40% kratší než ekvivalentní XML + ViewBinding.

// Jetpack Compose — obrazovka profilu uživatele
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Avatár uživatele",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("Upravit profil")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Anna Petrová", "anna@example.com"),
            onEditClick = {}
        )
    }
}

Funkce ProfileScreen je deklarována jako @Composable — deklarativně popisuje UI bez vytváření instancí View. Compose automaticky aktualizuje obrazovku při změně user. @Preview zobrazí výsledek přímo v IDE bez sestavení a spuštění na emulátoru.

Životní cyklus Activity a Fragment

Každá Activity v Androidu prochází šesti stavy životního cyklu: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment přidává onAttach, onCreateView, onViewCreated. Pochopení životního cyklu je klíčové pro správu paměti a prevenci úniků.

Hlavní stavy Activity

onCreate — volá se jednou při vytvoření Activity. Zde probíhá inicializace: setContentView, nastavení adaptérů, odběr LiveData. onResume — Activity je v popředí a interaguje s uživatelem. onPause — Activity ztrácí fokus (dialog, jiná Activity). onStop — Activity není viditelná. onDestroy — Activity je zničena.

// Activity se zpracováním životního cyklu přes LifecycleScope
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

Použití repeatOnLifecycle zajišťuje, že sběr dat se pozastaví, když Activity přejde na pozadí, a obnoví se, když se vrátí do popředí. Tím se zabrání únikům a zbytečným síťovým požadavkům. onSaveInstanceState ukládá dočasný stav při otáčení obrazovky.

Google Play: publikování a požadavky

Google Play je oficiální obchod s aplikacemi pro Android. Registrace vývojářského účtu stojí 25 $ jednorázově. Každá aplikace prochází automatickou kontrolou Google Play Integrity na škodlivý kód, porušení zásad a nesprávné použití oprávnění.

Požadavky na publikování

Google vyžaduje podpis aplikace prostřednictvím Android App Bundle (AAB) nebo APK. AAB je doporučený formát, který umožňuje generovat optimalizované APK pro každou konfiguraci zařízení. Aplikace musí být podepsána klíčem (keystore) s platným certifikátem. Google Play App Signing je volitelné šifrování klíče na straně Google.

Zásady ochrany osobních údajů

Všechny aplikace požadující přístup k osobním údajům musí poskytnout Zásady ochrany osobních údajů. Od roku 2024 Google vyžaduje prohlášení Data Safety — formulář specifikující typy shromažďovaných údajů a účely zpracování. Aplikace cílené na Android 14+ musí používat Declarations API pro deklarování oprávnění.