Android: Was es ist, Systemarchitektur und Entwicklung mit Kotlin

Was ist Android?

Android ist ein mobiles Betriebssystem basierend auf dem Linux-Kernel, das seit 2007 von Google entwickelt wird. Der Quellcode ist unter der Apache 2.0-Lizenz als Teil des Android Open Source Project (AOSP) offen. Jeder Hersteller kann das System modifizieren und auf seinen Geräten installieren.

Laut StatCounter (2026) hält Android etwa 72% des weltweiten Marktes für mobile Betriebssysteme. Die größten Hersteller sind Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentierung ist ein Hauptproblem der Plattform: Tausende Modelle mit verschiedenen OS-Versionen werden gleichzeitig verwendet.

Die Android-Architektur basiert auf dem Berechtigungsprinzip (Permissions): Jede App läuft unter einer separaten Linux-UID und hat nur Zugriff auf ihre eigenen Daten. Der Zugriff auf Systemressourcen (Kamera, Mikrofon, Kontakte) wird ab Android 6 (API 23) zur Laufzeit über Android Permissions angefordert.

Android-Versionsgeschichte

Android 1.0 wurde 2008 auf dem HTC Dream veröffentlicht. Wichtige Meilensteine: Android 4.0 Ice Cream Sandwich (einheitliche UI für Telefone und Tablets), Android 5.0 Lollipop (Material Design), Android 6.0 (Laufzeitberechtigungen), Android 10 (dunkles Design, Gesten), Android 12 (Material You). Seit 2023 ist Google zu jährlichen Hauptversionen ohne Dessertnamen übergegangen.

Android-Architektur: vier Schlüsselschichten

Die Android-Architektur besteht aus vier Hauptschichten, die die Hardware von den Benutzeranwendungen isolieren. Jede Schicht nutzt die Dienste der darunterliegenden Schicht über streng definierte Schnittstellen.

Linux-Kernel und HAL

Die unterste Schicht ist ein modifizierter Linux-Kernel (LTS, Version 6.x in Android 15). Er verwaltet Speicher, Prozesse, Netzwerkstack und Treiber. Die Hardware Abstraction Layer (HAL) bietet eine einheitliche API für die Interaktion mit der Hardware: Kamera, Bluetooth, Wi-Fi, Sensoren. Hersteller implementieren HAL-Module, ohne die oberen Schichten zu beeinflussen.

Android Runtime (ART)

ART führt den DEX-Bytecode von Anwendungen aus. Ab Android 5.0 ersetzte ART Dalvik und verwendet Ahead-of-Time (AOT)-Kompilierung für verbesserte Leistung. Jede App hat ihren eigenen Prozess mit einer separaten ART-Instanz. Die Garbage Collection (GC) arbeitet mit minimalen Pausen — eine typische GC-Pause beträgt 2–4 ms.

Application Framework

Das Framework ist die Schicht, mit der der Entwickler direkt arbeitet. Es umfasst Activity Manager (Bildschirmstapel), Content Providers (Datenzugriff), Resource Manager (Lokalisierung, Ressourcen), Notification Manager, Location Manager. Alle Systemdienste werden über Binder IPC aufgerufen — den Android-Mechanismus für die prozessübergreifende Kommunikation.

// Beispiel für die Arbeit mit Binder über AIDL-Schnittstelle
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Dienstimplementierung
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
}

System-Apps

Die oberste Schicht besteht aus Standard-Systemanwendungen: Telefon, Kontakte, Kamera, Einstellungen, Browser. Sie haben keine höheren Privilegien als Benutzer-Apps, können aber durch Drittanbieter-Apps ersetzt werden. In Android 15 werden System-Apps über Google Play System Updates unabhängig von OTA-Updates des Herstellers aktualisiert.

Kotlin — die primäre Android-Entwicklungssprache

Kotlin ist eine statisch typisierte Programmiersprache von JetBrains, die auf der JVM läuft. Google erklärte Kotlin 2017 auf der Google I/O zur offiziellen Android-Sprache. Kotlin ist vollständig kompatibel mit Java, beseitigt aber dessen Nachteile: Null-Sicherheit, Datenklassen, Erweiterungsfunktionen und Coroutinen.

Null-Sicherheit und Typen

Das Hauptmerkmal von Kotlin ist der eingebaute Schutz vor NullPointerException. Typen werden in nullable (String?) und non-null (String) unterteilt. Der Compiler prüft nullable-Zugriffe zur Compile-Zeit. Der Safe-Call-Operator (?.) und der Elvis-Operator (?:) vereinfachen die Arbeit mit optionalen Werten ohne verschachtelte Prüfungen.

// Beispiel für Kotlin-Code mit Coroutinen und 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)
    }
}

Das Beispiel zeigt Coroutinen (suspend-Funktion) für asynchronen Netzwerk- und Datenbankzugriff, Flow für reaktive Beobachtung von Datenänderungen und Result für sichere Fehlerbehandlung. Coroutinen ersetzen Callbacks und RxJava ohne Thread-Overhead.

Kotlin-Coroutinen und Flow

Kotlin-Coroutinen sind leichtgewichtige Threads, die auf einem gemeinsamen Thread-Pool laufen. Dispatchers.IO für Netzwerk und Festplatte, Dispatchers.Main für die UI, Dispatchers.Default für CPU-intensive Aufgaben. viewModelScope und lifecycleScope brechen Coroutinen automatisch ab, wenn die Komponente zerstört wird.

// ViewModel mit Coroutinen und 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 und Entwicklungswerkzeuge

Android Studio ist die offizielle IDE basierend auf IntelliJ IDEA, entwickelt von Google. Sie umfasst einen Code-Editor, Layout Inspector, Geräteemulator, APK Analyzer, Profiler (CPU, Speicher, Netzwerk, Energie) und Firebase-Integration. Android Studio 2024 (Ladybug) unterstützt Kotlin 2.0 mit plattformübergreifendem KMP-Modus.

Android-Emulator

Der Android-Emulator verwendet KVM (Linux) oder Hyper-V (Windows) für Hardwarebeschleunigung. Er unterstützt die Simulation von GPS, Sensoren, Kamera, Anrufen und SMS. Google Pixel 9 Pro ist die empfohlene Konfiguration für Tests mit API 35 und 8 GB Emulator-RAM.

Android Profiler und Debugging

Der Profiler zeigt in Echtzeit CPU-Auslastung, Speicherzuweisung, Netzwerkanfragen und Energieverbrauch an. Der Memory Profiler ermöglicht Heap-Dumps und Leck-Analyse über den Referenzbaum. Der Network Inspector zeichnet alle HTTP/HTTPS-Anfragen mit Body und Headern auf. Für detaillierte Analysen wird Android Studio Canary verwendet.

Android-App-Komponenten

Eine Android-App besteht aus vier Arten von Komponenten, jede mit eigenem Einstiegspunkt und Lebenszyklus. Die Komponenten werden in der AndroidManifest.xml-Datei registriert.

Activity und Intent

Activity ist die grundlegende Komponente der Benutzeroberfläche. Jeder Bildschirm ist eine separate Activity oder ein Fragment innerhalb einer Activity. Die Navigation zwischen Bildschirmen erfolgt über Intent — ein Objekt, das eine Aktion (ACTION_VIEW, ACTION_SEND) und Daten (URI) enthält. Im Jetpack Navigation Graph wird die Navigation in XML beschrieben.

Service und WorkManager

Service führt Hintergrundaufgaben aus, aber ab Android 8 sind Hintergrunddienste eingeschränkt. WorkManager ist die empfohlene Bibliothek für verzögerte und garantierte Hintergrundaufgaben mit Unterstützung für Ketten, Einschränkungen (z. B. nur beim Laden) und Neustart nach Absturz.

Jetpack Compose vs. XML Layouts

Die Wahl zwischen Jetpack Compose und traditionellen XML-Layouts ist die wichtigste architektonische Entscheidung bei der Gründung eines Android-Projekts. XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) sind seit 2008 der Standard. Jetpack Compose wurde 2021 als deklarative Alternative eingeführt.

Google empfiehlt Jetpack Compose für alle neuen Projekte. XML Layouts bleiben für die Unterstützung von Legacy-Projekten und für Fälle relevant, in denen eine maximale View-Anpassung (Canvas, SurfaceView) erforderlich ist. Compose-Code ist durchschnittlich 40% kürzer als äquivalentes XML + ViewBinding.

// Jetpack Compose — Benutzerprofilbildschirm
@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 = "Benutzeravatar",
            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 bearbeiten")
        }
    }
}

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

Die Funktion ProfileScreen wird als @Composable deklariert — sie beschreibt die UI deklarativ, ohne View-Instanzen zu erstellen. Compose aktualisiert den Bildschirm automatisch, wenn sich user ändert. @Preview zeigt das Ergebnis direkt in der IDE ohne Build- und Emulator-Start.

Lebenszyklus von Activity und Fragment

Jede Activity in Android durchläuft sechs Lebenszyklus-Zustände: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment fügt onAttach, onCreateView, onViewCreated hinzu. Das Verständnis des Lebenszyklus ist entscheidend für die Speicherverwaltung und die Vermeidung von Lecks.

Hauptzustände der Activity

onCreate — wird einmal beim Erstellen der Activity aufgerufen. Hier erfolgt die Initialisierung: setContentView, Adapter-Einrichtung, LiveData-Abonnement. onResume — die Activity ist im Vordergrund und interagiert mit dem Benutzer. onPause — die Activity verliert den Fokus (Dialog, andere Activity). onStop — die Activity ist nicht sichtbar. onDestroy — die Activity wird zerstört.

// Activity mit Lebenszyklusverwaltung über 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", "")
    }
}

Die Verwendung von repeatOnLifecycle stellt sicher, dass die Datenerfassung pausiert, wenn die Activity in den Hintergrund geht, und fortgesetzt wird, wenn sie in den Vordergrund zurückkehrt. Dies verhindert Lecks und unnötige Netzwerkanfragen. onSaveInstanceState speichert den temporären Zustand bei Bildschirmdrehung.

Google Play: Veröffentlichung und Anforderungen

Google Play ist der offizielle Android-App-Store. Die Entwicklerkontoregistrierung kostet einmalig $25. Jede App durchläuft eine automatische Google Play Integrity-Prüfung auf Schadcode, Richtlinienverstöße und falsche Berechtigungsnutzung.

Veröffentlichungsanforderungen

Google verlangt die App-Signierung über Android App Bundle (AAB) oder APK. AAB ist das empfohlene Format, das optimierte APKs für jede Gerätekonfiguration ermöglicht. Die App muss mit einem Schlüssel (keystore) mit einem gültigen Zertifikat signiert sein. Google Play App Signing ist eine optionale Schlüsselverschlüsselung auf Google-Seite.

Datenschutzerklärung

Alle Apps, die Zugriff auf personenbezogene Daten anfordern, müssen eine Datenschutzerklärung bereitstellen. Seit 2024 verlangt Google eine Data Safety-Erklärung — ein Formular, das die Arten der gesammelten Daten und die Verarbeitungszwecke angibt. Apps für Android 14+ müssen die Declarations API zur Deklaration von Berechtigungen verwenden.