Android: wat het is, systeemarchitectuur en ontwikkeling in Kotlin

Wat is Android?

Android is een mobiel besturingssysteem gebaseerd op de Linux-kernel, ontwikkeld door Google sinds 2007. De broncode is open onder de Apache 2.0-licentie als onderdeel van het Android Open Source Project (AOSP). Elke fabrikant kan het systeem aanpassen en op zijn apparaten installeren.

Volgens StatCounter (2026) heeft Android ongeveer 72% van de wereldwijde mobiele OS-markt. De grootste fabrikanten zijn Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentatie is een belangrijk probleem van het platform: duizenden modellen met verschillende OS-versies worden gelijktijdig gebruikt.

De Android-architectuur is gebouwd op het principe van machtigingen (permissions): elke app draait onder een aparte Linux-UID en heeft alleen toegang tot zijn eigen gegevens. Toegang tot systeembronnen (camera, microfoon, contacten) wordt aangevraagd via Android Permissions tijdens runtime, vanaf Android 6 (API 23).

Geschiedenis van Android-versies

Android 1.0 werd uitgebracht in 2008 op de HTC Dream. Belangrijke mijlpalen: Android 4.0 Ice Cream Sandwich (uniforme UI voor telefoons en tablets), Android 5.0 Lollipop (Material Design), Android 6.0 (runtime-machtigingen), Android 10 (donkere modus, gebaren), Android 12 (Material You). Sinds 2023 is Google overgestapt op jaarlijkse grote releases zonder dessertnamen.

Android-architectuur: vier belangrijke lagen

De Android-architectuur bestaat uit vier hoofdlagen die de hardware isoleren van gebruikersapplicaties. Elke laag gebruikt de diensten van de onderliggende laag via strikt gedefinieerde interfaces.

Linux-kernel en HAL

De onderste laag is een gemodificeerde Linux-kernel (LTS, versie 6.x in Android 15). Het beheert geheugen, processen, netwerkstack en stuurprogramma's. De Hardware Abstraction Layer (HAL) biedt een uniforme API voor interactie met hardware: camera, Bluetooth, Wi-Fi, sensoren. Fabrikanten implementeren HAL-modules zonder de bovenste lagen te beïnvloeden.

Android Runtime (ART)

ART voert de DEX-bytecode van applicaties uit. Vanaf Android 5.0 verving ART Dalvik en gebruikt Ahead-of-Time (AOT)-compilatie voor betere prestaties. Elke app heeft zijn eigen proces met een aparte ART-instantie. Garbage collection (GC) werkt met minimale pauzes — een typische GC-pauze is 2–4 ms.

Application Framework

Het Framework is de laag waarmee de ontwikkelaar direct werkt. Het omvat Activity Manager (schermstapel), Content Providers (gegevenstoegang), Resource Manager (lokalisatie, bronnen), Notification Manager, Location Manager. Alle systeemdiensten worden aangeroepen via Binder IPC — het inter-procescommunicatiemechanisme van Android.

// Voorbeeld van werken met Binder via AIDL-interface
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Service-implementatie
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
}

Systeem-apps

De bovenste laag bestaat uit standaard systeemapplicaties: Telefoon, Contacten, Camera, Instellingen, Browser. Ze hebben geen hogere privileges dan gebruikers-apps, maar kunnen worden vervangen door apps van derden. In Android 15 worden systeem-apps bijgewerkt via Google Play System Updates, onafhankelijk van OTA-updates van de fabrikant.

Kotlin — de primaire Android-ontwikkeltaal

Kotlin is een statisch getypeerde programmeertaal van JetBrains die op de JVM draait. Google kondigde Kotlin in 2017 op Google I/O aan als officiële Android-taal. Kotlin is volledig compatibel met Java, maar elimineert de tekortkomingen: null-veiligheid, dataklassen, extensiefuncties en coroutines.

Null-veiligheid en typen

Het belangrijkste kenmerk van Kotlin is ingebouwde bescherming tegen NullPointerException. Typen zijn onderverdeeld in nullable (String?) en non-null (String). De compiler controleert nullable-toegang tijdens het bouwen. De safe call (?.) en Elvis-operator (?:) vereenvoudigen het werken met optionele waarden zonder geneste controles.

// Voorbeeld van Kotlin-code met coroutines en 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)
    }
}

Het voorbeeld toont coroutines (suspend-functie) voor asynchrone netwerk- en databasetoegang, Flow voor reactieve observatie van gegevenswijzigingen en Result voor veilige foutafhandeling. Coroutines vervangen callbacks en RxJava zonder thread-overhead.

Kotlin Coroutines en Flow

Kotlin-coroutines zijn lichtgewicht threads die op een gedeelde threadpool draaien. Dispatchers.IO voor netwerk en schijf, Dispatchers.Main voor UI, Dispatchers.Default voor CPU-intensieve taken. viewModelScope en lifecycleScope annuleren automatisch coroutines wanneer het component wordt vernietigd.

// ViewModel met coroutines en 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 en ontwikkeltools

Android Studio is de officiële IDE gebaseerd op IntelliJ IDEA, ontwikkeld door Google. Het omvat een code-editor, Layout Inspector, apparaatemulator, APK Analyzer, Profiler (CPU, Geheugen, Netwerk, Energie) en Firebase-integratie. Android Studio 2024 (Ladybug) ondersteunt Kotlin 2.0 met multiplatform KMP-modus.

Android-emulator

De Android-emulator gebruikt KVM (Linux) of Hyper-V (Windows) voor hardwareversnelling. Het ondersteunt simulatie van GPS, sensoren, camera, oproepen en SMS. Google Pixel 9 Pro is de aanbevolen configuratie voor testen met API 35 en 8 GB emulator-RAM.

Android Profiler en debuggen

De Profiler toont in realtime CPU-belasting, geheugentoewijzing, netwerkverzoeken en energieverbruik. De Memory Profiler maakt heap-dumps en lekanalyse via de referentieboom mogelijk. Network Inspector registreert alle HTTP/HTTPS-verzoeken met body en headers. Voor diepgaande analyse wordt Android Studio Canary gebruikt.

Android-app-componenten

Een Android-app bestaat uit vier soorten componenten, elk met een eigen toegangspunt en levenscyclus. Componenten worden geregistreerd in het AndroidManifest.xml-bestand.

Activity en Intent

Activity is de basiscomponent van de gebruikersinterface. Elk scherm is een aparte Activity of een Fragment binnen een Activity. Navigatie tussen schermen gebeurt via Intent — een object dat een actie (ACTION_VIEW, ACTION_SEND) en gegevens (URI) bevat. In Jetpack Navigation Graph wordt navigatie beschreven in XML.

Service en WorkManager

Service voert achtergrondtaken uit, maar vanaf Android 8 zijn achtergrondservices beperkt. WorkManager is de aanbevolen bibliotheek voor uitgestelde en gegarandeerde achtergrondtaken met ondersteuning voor ketens, beperkingen (bijv. alleen tijdens het opladen) en herstart na crash.

Jetpack Compose vs XML Layouts

De keuze tussen Jetpack Compose en traditionele XML-lay-outs is de belangrijkste architectonische beslissing bij het starten van een Android-project. XML-lay-outs (RecyclerView, ConstraintLayout, FrameLayout) zijn sinds 2008 de standaard. Jetpack Compose werd in 2021 geïntroduceerd als een declaratief alternatief.

Google beveelt Jetpack Compose aan voor alle nieuwe projecten. XML-lay-outs blijven relevant voor ondersteuning van legacy-projecten en voor gevallen waarin maximale View-aanpassing (Canvas, SurfaceView) nodig is. Compose-code is gemiddeld 40% korter dan gelijkwaardige XML + ViewBinding.

// Jetpack Compose — gebruikersprofielscherm
@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 = "Gebruikersavatar",
            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("Profiel bewerken")
        }
    }
}

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

De functie ProfileScreen wordt gedeclareerd als @Composable — het beschrijft de UI declaratief zonder View-instanties te maken. Compose werkt het scherm automatisch bij wanneer user verandert. @Preview toont het resultaat direct in de IDE zonder te bouwen en op de emulator te draaien.

Levenscyclus van Activity en Fragment

Elke Activity in Android doorloopt zes levenscyclus-toestanden: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment voegt onAttach, onCreateView, onViewCreated toe. Inzicht in de levenscyclus is cruciaal voor geheugenbeheer en het voorkomen van lekken.

Belangrijkste toestanden van Activity

onCreate — eenmaal aangeroepen bij het maken van de Activity. Hier wordt initialisatie uitgevoerd: setContentView, adapter-instelling, LiveData-abonnement. onResume — de Activity is op de voorgrond en heeft interactie met de gebruiker. onPause — de Activity verliest focus (dialoog, andere Activity). onStop — de Activity is niet zichtbaar. onDestroy — de Activity wordt vernietigd.

// Activity met levenscyclusbeheer via 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", "")
    }
}

Het gebruik van repeatOnLifecycle zorgt ervoor dat het verzamelen van gegevens pauzeert wanneer de Activity naar de achtergrond gaat en wordt hervat wanneer deze terugkeert naar de voorgrond. Dit voorkomt lekken en onnodige netwerkverzoeken. onSaveInstanceState slaat tijdelijke toestand op bij schermrotatie.

Google Play: publicatie en vereisten

Google Play is de officiële Android-app-winkel. Ontwikkelaarsaccountregistratie kost eenmalig $25. Elke app ondergaat een automatische Google Play Integrity-controle op kwaadaardige code, beleidsschendingen en onjuist gebruik van machtigingen.

Publicatievereisten

Google vereist app-ondertekening via Android App Bundle (AAB) of APK. AAB is het aanbevolen formaat, waarmee geoptimaliseerde APK's kunnen worden gegenereerd voor elke apparaatconfiguratie. De app moet worden ondertekend met een sleutel (keystore) met een geldig certificaat. Google Play App Signing is optionele sleutelversleuteling aan de kant van Google.

Privacybeleid

Alle apps die toegang tot persoonlijke gegevens aanvragen, moeten een Privacybeleid verstrekken. Sinds 2024 vereist Google een Data Safety-verklaring — een formulier dat de soorten verzamelde gegevens en verwerkingsdoeleinden specificeert. Apps die Android 14+ targeten, moeten de Declarations API gebruiken voor het declareren van machtigingen.