Android: mi ez, rendszerarchitektúra és fejlesztés Kotlinban

Mi az Android?

Android egy Linux kernel alapú mobil operációs rendszer, amelyet a Google 2007 óta fejleszt. A forráskód nyílt az Apache 2.0 licenc alatt az Android Open Source Project (AOSP) részeként. Minden gyártó módosíthatja a rendszert és telepítheti saját eszközeire.

A StatCounter (2026) szerint az Android a globális mobil OS piac körülbelül 72%-át birtokolja. A legnagyobb gyártók: Samsung, Xiaomi, Oppo, Vivo, Google Pixel. A fragmentáció a platform kulcsproblémája: több ezer modell különböző OS verziókkal egyidejűleg használatos.

Az Android architektúrája az engedélyek (permissions) elvén épül: minden alkalmazás külön Linux UID alatt fut, és csak a saját adataihoz fér hozzá. A rendszererőforrásokhoz (kamera, mikrofon, névjegyek) való hozzáférést az Android 6-tól (API 23) kezdve futásidőben az Android Engedélyeken keresztül kell kérni.

Android verziók története

Android 1.0 2008-ban jelent meg a HTC Dreamen. Kulcsfontosságú mérföldkövek: Android 4.0 Ice Cream Sandwich (egységes UI telefonokhoz és táblagépekhez), Android 5.0 Lollipop (Material Design), Android 6.0 (futásidőbeli engedélyek), Android 10 (sötét téma, gesztusok), Android 12 (Material You). 2023-tól a Google áttért az éves nagy kiadásokra desszertnevek nélkül.

Android architektúra: négy kulcsréteg

Az Android architektúra négy fő rétegből áll, amelyek elkülönítik a hardvert a felhasználói alkalmazásoktól. Minden réteg a szigorúan meghatározott interfészeken keresztül használja az alatta lévő réteg szolgáltatásait.

Linux kernel és HAL

Az alsó réteg egy módosított Linux kernel (LTS, 6.x verzió Android 15-ben). Ez kezeli a memóriát, folyamatokat, hálózati vermet és illesztőprogramokat. A Hardware Abstraction Layer (HAL) egységes API-t biztosít a hardverrel való interakcióhoz: kamera, Bluetooth, Wi-Fi, érzékelők. A gyártók HAL modulokat implementálnak anélkül, hogy befolyásolnák a felső rétegeket.

Android Runtime (ART)

ART végrehajtja az alkalmazások DEX bájtkódját. Az Android 5.0-tól kezdve az ART felváltotta a Dalvikot, és a Ahead-of-Time (AOT) fordítást használja a teljesítmény javítására. Minden alkalmazás saját folyamattal rendelkezik, külön ART példánnyal. A szemétgyűjtés (GC) minimális szünetekkel működik — egy tipikus GC szünet 2–4 ms.

Application Framework

A Framework az a réteg, amellyel a fejlesztő közvetlenül dolgozik. Tartalmazza az Activity Managert (képernyő verem), Content Providers-t (adat-hozzáférés), Resource Manager-t (lokalizáció, erőforrások), Notification Manager-t, Location Manager-t. Minden rendszerszolgáltatás a Binder IPC-n — az Android folyamatok közötti kommunikációs mechanizmusán — keresztül hívható meg.

// Példa a Binderrel való munkára AIDL interfészen keresztül
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Szolgáltatás implementációja
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
}

Rendszeralkalmazások

A felső réteg szabványos rendszeralkalmazásokból áll: Telefon, Névjegyek, Kamera, Beállítások, Böngésző. Ezek nem rendelkeznek magasabb jogosultságokkal, mint a felhasználói alkalmazások, de harmadik féltől származó alkalmazásokkal helyettesíthetők. Android 15-ben a rendszeralkalmazások a Google Play System Updates-en keresztül frissülnek, függetlenül a gyártó OTA frissítéseitől.

Kotlin — az Android fejlesztés elsődleges nyelve

Kotlin egy statikusan tipizált programozási nyelv a JetBrainstől, amely a JVM-en fut. A Google 2017-ben a Google I/O-n jelentette be a Kotlint az Android hivatalos nyelveként. A Kotlin teljes mértékben kompatibilis a Javával, de kiküszöböli annak hiányosságait: null biztonság, adatosztályok, kiterjesztő függvények és korutinok.

Null biztonság és típusok

A Kotlin fő jellemzője a NullPointerException elleni beépített védelem. A típusok nullable (String?) és non-null (String) típusokra oszlanak. A fordító ellenőrzi a nullable hozzáférést fordítási időben. A safe call (?.) és Elvis operátor (?:) leegyszerűsíti az opcionális értékekkel való munkát beágyazott ellenőrzések nélkül.

// Példa Kotlin kódra korutinokkal és Flow-val
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)
    }
}

A példa bemutatja a korutinokat (suspend függvény) aszinkron hálózati és adatbázis-eléréshez, a Flow-t az adatváltozások reaktív megfigyeléséhez és a Result-ot a biztonságos hibakezeléshez. A korutinok szálterhelés nélkül helyettesítik a callback-eket és az RxJava-t.

Kotlin korutinok és Flow

A Kotlin korutinok könnyűsúlyú szálak, amelyek egy megosztott szálkészleten futnak. Dispatchers.IO hálózathoz és lemezhez, Dispatchers.Main UI-hoz, Dispatchers.Default CPU-intenzív feladatokhoz. A viewModelScope és lifecycleScope automatikusan törli a korutinokat, amikor a komponens megsemmisül.

// ViewModel korutinokkal és StateFlow-val
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 és fejlesztői eszközök

Android Studio az IntelliJ IDEA alapú hivatalos IDE, amelyet a Google fejlesztett. Tartalmaz kódszerkesztőt, Layout Inspector-t, eszköz-emulátort, APK Analyzer-t, Profiler-t (CPU, Memória, Hálózat, Energia) és Firebase integrációt. Az Android Studio 2024 (Ladybug) támogatja a Kotlin 2.0-t többplatformos KMP móddal.

Android emulátor

Az Android emulátor KVM-et (Linux) vagy Hyper-V-t (Windows) használ hardveres gyorsításhoz. Támogatja a GPS, érzékelők, kamera, hívások és SMS szimulációját. A Google Pixel 9 Pro az ajánlott konfiguráció teszteléshez API 35-tel és 8 GB emulátor RAM-mal.

Android Profiler és hibakeresés

A Profiler valós időben jeleníti meg a CPU terhelést, memóriaallokációt, hálózati kéréseket és energiafogyasztást. A Memory Profiler lehetővé teszi a heap dump-ot és a szivárgások elemzését a referenciafa segítségével. A Network Inspector rögzíti az összes HTTP/HTTPS kérést a törzzsel és fejlécekkel. Mélyebb elemzéshez az Android Studio Canary használatos.

Android alkalmazás komponensei

Egy Android alkalmazás négy típusú komponensből áll, mindegyik saját belépési ponttal és életciklussal. A komponensek az AndroidManifest.xml fájlban kerülnek regisztrálásra.

Activity és Intent

Activity a felhasználói felület alapkomponense. Minden képernyő egy külön Activity vagy egy Fragment egy Activity-n belül. A képernyők közötti navigáció Intent-en keresztül történik — egy objektum, amely egy műveletet (ACTION_VIEW, ACTION_SEND) és adatokat (URI) tartalmaz. A Jetpack Navigation Graph-ban a navigáció XML-ben van leírva.

Service és WorkManager

Service háttérfeladatokat hajt végre, de az Android 8-tól kezdve a háttérszolgáltatások korlátozottak. A WorkManager az ajánlott könyvtár a késleltetett és garantált háttérfeladatokhoz, láncok, korlátozások (pl. csak töltés közben) és összeomlás utáni újraindítás támogatásával.

Jetpack Compose vs XML Layouts

A választás a Jetpack Compose és a hagyományos XML elrendezések között a fő architekturális döntés egy Android projekt indításakor. Az XML elrendezések (RecyclerView, ConstraintLayout, FrameLayout) 2008 óta a szabványok. A Jetpack Compose 2021-ben került bevezetésre deklaratív alternatívaként.

A Google a Jetpack Compose-t ajánlja minden új projekthez. Az XML elrendezések az örökölt projektek támogatásához és azokban az esetekben maradnak relevánsak, ahol maximális View testreszabásra (Canvas, SurfaceView) van szükség. A Compose kód átlagosan 40%-kal rövidebb, mint a megfelelő XML + ViewBinding.

// Jetpack Compose — felhasználói profil képernyő
@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 = "Felhasználó avatárja",
            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("Profil szerkesztése")
        }
    }
}

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

A ProfileScreen függvény @Composable-ként van deklarálva — deklaratívan írja le az UI-t View példányok létrehozása nélkül. A Compose automatikusan frissíti a képernyőt, amikor a user változik. A @Preview közvetlenül az IDE-ben mutatja az eredményt anélkül, hogy buildelni kellene és az emulátoron futtatni.

Activity és Fragment életciklus

Minden Activity az Androidban hat életciklus-állapoton megy keresztül: onCreate, onStart, onResume, onPause, onStop, onDestroy. A Fragment hozzáadja az onAttach, onCreateView, onViewCreated elemeket. Az életciklus megértése kritikus fontosságú a memóriakezelés és a szivárgások megelőzése szempontjából.

Az Activity fő állapotai

onCreate — egyszer hívódik meg az Activity létrehozásakor. Itt történik az inicializálás: setContentView, adapter beállítás, LiveData feliratkozás. onResume — az Activity az előtérben van és kapcsolatba lép a felhasználóval. onPause — az Activity elveszti a fókuszt (párbeszédpanel, másik Activity). onStop — az Activity nem látható. onDestroy — az Activity megsemmisül.

// Activity életciklus kezeléssel LifecycleScope-on keresztül
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", "")
    }
}

A repeatOnLifecycle használata biztosítja, hogy az adatgyűjtés szüneteljen, amikor az Activity háttérbe kerül, és folytatódjon, amikor visszatér az előtérbe. Ez megakadályozza a szivárgásokat és a felesleges hálózati kéréseket. Az onSaveInstanceState elmenti az ideiglenes állapotot a képernyő elforgatásakor.

Google Play: közzététel és követelmények

Google Play a hivatalos Android alkalmazásbolt. A fejlesztői fiók regisztrációja egyszeri 25 USD költséggel jár. Minden alkalmazás automatikus Google Play Integrity ellenőrzésen megy keresztül rosszindulatú kód, irányelvek megsértése és nem megfelelő engedélyhasználat szempontjából.

Közzétételi követelmények

A Google megköveteli az alkalmazás aláírását Android App Bundle (AAB) vagy APK formátumban. Az AAB az ajánlott formátum, amely lehetővé teszi optimalizált APK-k generálását minden eszközkonfigurációhoz. Az alkalmazást egy kulccsal (keystore) kell aláírni érvényes tanúsítvánnyal. A Google Play App Signing opcionális kulcstitkosítás a Google oldalán.

Adatvédelmi irányelvek

Minden személyes adatokhoz hozzáférést kérő alkalmazásnak Adatvédelmi irányelveket kell biztosítania. 2024-től a Google megköveteli a Data Safety nyilatkozatot — egy űrlapot, amely meghatározza az összegyűjtött adatok típusát és a feldolgozás céljait. Az Android 14+ célozó alkalmazásoknak a Declarations API-t kell használniuk az engedélyek deklarálásához.