Android-Interviewvorbereitung

Android-Interviewfragen

20 häufig gestellte Android-Interviewfragen. Android-Entwicklung ist ein gefragtes Feld für mobile Apps auf Kotlin-Basis, Android SDK und Jetpack sowie Lifecycle-, Performance-, Netzwerk-, Storage-, Test- und Release-Aufgaben. Die Fragen decken verschiedene Niveaus ab, und du kannst mündliche Antworten in unserem Interview-Trainer üben.

Android-KI-Interview startenKeine Kreditkarte erforderlich. 1 kostenlose Sitzung verfügbar.
Technisches Interview-Training auf EnglischEin Modus, in dem Nicht-Muttersprachler technische Interviews üben können.

Fragen für Einsteiger

1Wann verwenden Sie lazy oder lateinit für eine Kotlin-Eigenschaft, die bei der Konstruktion noch keinen Wert hat?

val by lazy berechnet beim ersten Zugriff einen Wert und behält ihn. Das verschiebt teure Arbeit, wartet aber nicht auf eine spätere asynchrone Zuweisung. lateinit var erlaubt die spätere explizite Initialisierung, etwa durch Injection oder einen Lebenszyklus-Callback, und erneute Zuweisungen. Der Referenztyp muss unterstützt und nicht nullable sein, primitive Typen scheiden aus. Vorzeitiges Lesen wirft UninitializedPropertyAccessException. Bei lazy beachte ich den Thread-Sicherheitsmodus und den ausführenden Thread. Für eine zerstörte und neu erstellte Fragment-View verwende ich einen löschbaren oder zurücksetzbaren Halter und gebe die Referenz rechtzeitig frei.

Diese Frage mit einem KI-Coach beantworten

2Welche vier grundlegenden Komponenten hat eine Android-Anwendung, und welches Lebenszyklus- und Threading-Modell gilt standardmäßig für ihre Callbacks?

Die vier grundlegenden Android-Anwendungskomponenten sind Activity, Service, BroadcastReceiver und ContentProvider. Eine Activity stellt eine Benutzeroberfläche für Interaktionen auf einem Bildschirm bereit. Ein Service führt Hintergrundverarbeitung ohne eigene Benutzeroberfläche aus. Ein BroadcastReceiver empfängt systemweite oder appinterne Broadcast-Nachrichten und reagiert darauf. Ein ContentProvider verwaltet strukturierte Daten und stellt sie anderen Anwendungen oder internen Modulen zur Verfügung. Standardmäßig werden die wesentlichen Lebenszyklus-Callbacks von Activity (etwa onCreate, onStart und onResume), Service (etwa onCreate, onStartCommand und onBind) und BroadcastReceiver (onReceive) synchron auf dem Hauptthread der Anwendung ausgeführt, also dem Thread der Benutzeroberfläche. Auch die Initialisierung eines ContentProviders über Methoden wie onCreate erfolgt auf dem Hauptthread; prozessübergreifend aufgerufene query- und insert-Operationen laufen dagegen auf Threads aus dem Binder-Threadpool. Da die Standard-Callbacks auf dem Hauptthread laufen, blockieren aufwendige, blockierende Operationen darin — etwa Netzwerkanfragen oder umfangreiche Datenbankzugriffe auf den Datenträger — die Ereignisschleife der Oberfläche und führen zu einem ANR-Fehler (die Anwendung reagiert nicht).

class DataSyncService : Service() {
    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // onStartCommand runs on the Main Thread; heavy work must be offloaded
        serviceScope.launch {
            performDiskAndNetworkSync()
            stopSelf(startId)
        }
        return START_NOT_STICKY
    }

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onDestroy() {
        super.onDestroy()
        serviceScope.cancel()
    }

    private fun performDiskAndNetworkSync() {
        // Blocking I/O safely executed on Dispatchers.IO
    }
}
Diese Frage mit einem KI-Coach beantworten

3Welche Hauptaufgaben hat ein ViewModel in der Android-Architektur MVVM im Vergleich zu Oberflächen-Controllern wie Activities und Fragments, und warum wird davon abgeraten, einem ViewModel einen Context zu übergeben?

In der MVVM-Architektur (Trennung von Datenmodell, Ansicht und Ansichtsmodell) hält und verwaltet das ViewModel den für die Benutzeroberfläche relevanten Zustand, koordiniert die Präsentationslogik und übersteht Konfigurationsänderungen wie Bildschirmdrehungen. Oberflächen-Controller, also Activities und Fragments, sind dagegen dafür verantwortlich, Oberflächenelemente anzuzeigen, Zustandsänderungen zu beobachten, unmittelbare Benutzereingaben wie Klicks und Gesten zu behandeln und Android-Lebenszyklusereignisse zu verwalten. Von der Übergabe eines Activity Contexts oder einer View-Referenz an ein ViewModel wird dringend abgeraten, weil ViewModels bei Konfigurationsänderungen gewöhnlich länger leben als die jeweiligen Oberflächen-Controller. Wird eine Activity bei einer Drehung zerstört und neu erstellt, verhindert ein ViewModel, das ihren Context hält, die Freigabe der alten Activity durch die Garbage Collection. Dadurch entsteht ein Speicherleck. Ist ein Android Context für systemnahe Vorgänge zwingend erforderlich, sollte stattdessen ein Context mit Anwendungsgültigkeit verwendet werden, etwa über `AndroidViewModel` oder durch Übergabe des ApplicationContext als Abhängigkeit.

// Bad: Storing Activity context or View reference causes leaks
class LeakyViewModel(private val activityContext: Context) : ViewModel() {
    fun showToast() { Toast.makeText(activityContext, "Hello", Toast.LENGTH_SHORT).show() }
}

// Good: ViewModel manages state; Activity observes and handles context-specific tasks
class SafeViewModel(private val repository: UserRepository) : ViewModel() {
    private val _uiState = MutableStateFlow<UserUiState>(UserUiState.Loading)
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
    
    fun loadUser(id: String) {
        viewModelScope.launch {
            _uiState.value = UserUiState.Success(repository.getUser(id))
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

4Wie unterscheiden sich normale und gefährliche Android-Berechtigungen, und was geschieht, wenn eine App eine gefährliche Berechtigung zur Laufzeit anfordert?

Normale Berechtigungen stellen nur ein geringes Risiko für die Privatsphäre des Benutzers oder den Gerätebetrieb dar. Sind sie in AndroidManifest.xml deklariert, erteilt das System sie bei der Installation automatisch, beispielsweise ACCESS_NETWORK_STATE. Gefährliche Berechtigungen, auch Laufzeitberechtigungen genannt, regeln den Zugriff auf private Benutzerdaten oder eingeschränkte Gerätefunktionen wie Kamera, Mikrofon, Standort und Kontakte. Fordert eine App eine gefährliche Berechtigung zur Laufzeit an, zeigt Android einen Systemdialog an, in dem der Benutzer den Zugriff erlauben oder ablehnen kann. Bei Zustimmung führt die App die angeforderte Funktion aus. Bei Ablehnung erhält sie einen entsprechenden Callback und muss damit kontrolliert umgehen: Sie deaktiviert die abhängige Funktion oder bietet sie eingeschränkt an, ohne abzustürzen. Gegebenenfalls erläutert sie dem Benutzer in der Oberfläche, weshalb die Berechtigung benötigt wird.

val requestPermissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission()
) { isGranted: Boolean ->
    if (isGranted) {
        accessCameraFeature()
    } else {
        showPermissionDeniedExplanation()
    }
}

fun checkAndRequestPermission() {
    when {
        ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED -> {
            accessCameraFeature()
        }
        shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
            showRationaleDialog { requestPermissionLauncher.launch(Manifest.permission.CAMERA) }
        }
        else -> {
            requestPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

5Was unterscheidet Debug- und Release-Builds unter Android, und wie entstehen aus Build Types und Product Flavors die Build-Varianten?

In der Android-Entwicklung konfigurieren Build Types die Paketierung und Laufzeiteigenschaften für unterschiedliche Entwicklungsphasen. Debug-Builds aktivieren Debugging-Einstellungen (`isDebuggable = true`), verwenden einen standardmäßigen Debug-Keystore und deaktivieren üblicherweise Codeverkleinerung und das Entfernen ungenutzten Codes durch R8/ProGuard, damit sich Builds schnell wiederholen lassen. Release-Builds deaktivieren Debugging, aktivieren Optimierungen und Codeverschleierung und benötigen für die Verteilung einen sicher verwalteten Release-Signierschlüssel. Product Flavors bilden unterschiedliche Versionen oder Zielausprägungen einer App auf derselben zentralen Codebasis ab, etwa Staging und Produktion oder kostenlose und kostenpflichtige Editionen. In Gradle entstehen Build-Varianten als kartesisches Produkt aus Product Flavors und Build Types: Build-Variante = Product Flavor × Build Type. Kombiniert man beispielsweise die Flavors `staging` und `production` mit den Build Types `debug` und `release`, ergeben sich vier Varianten: `stagingDebug`, `stagingRelease`, `productionDebug` und `productionRelease`.

android {
    flavorDimensions += "environment"
    productFlavors {
        create("staging") {
            dimension = "environment"
            applicationIdSuffix = ".staging"
        }
        create("production") {
            dimension = "environment"
        }
    }
    buildTypes {
        getByName("debug") {
            isDebuggable = true
        }
        getByName("release") {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

6Was ist eine Coroutine in Kotlin, und wie unterscheidet sich das Suspendieren zur Android-Laufzeit vom Blockieren eines Threads?

Eine Coroutine in Kotlin ist eine leichtgewichtige Abstraktion für nebenläufige Abläufe, mit der asynchroner, nicht blockierender Code in sequenzieller Form geschrieben werden kann. Mehrere Coroutinen können nebenläufig auf einem einzigen Thread oder über Threadpools laufen, ohne den hohen Speicher- und Kontextwechselaufwand von Betriebssystem-Threads. Der wesentliche Unterschied zwischen Suspendieren und Blockieren liegt in der Nutzung des Threads: Blockieren, etwa durch Thread.sleep() oder synchrone Datenträger- beziehungsweise Netzwerkzugriffe, hält den zugrunde liegenden Thread an und macht ihn für andere Arbeit unbrauchbar. Auf dem Android-Hauptthread friert dadurch die Oberfläche ein, und es können ANR-Fehler (die Anwendung reagiert nicht) entstehen. Suspendieren, beispielsweise über suspend-Funktionen wie delay(), pausiert dagegen die Coroutine, ohne den zugrunde liegenden Thread anzuhalten. Die Coroutine hält ihren Ausführungszustand in einer Continuation fest und gibt den Thread an die Laufzeitumgebung zurück, damit er andere Aufgaben bearbeiten kann, etwa Benutzerinteraktionen. Sobald die asynchrone Operation abgeschlossen ist, wird die Coroutine fortgesetzt.

suspend fun fetchUserData(): String {
    delay(1000) // Suspends execution and yields the thread
    return "User Data"
}

fun fetchUserDataBlocking(): String {
    Thread.sleep(1000) // Blocks and locks the underlying thread
    return "User Data"
}
Diese Frage mit einem KI-Coach beantworten

7Was unterscheidet in Jetpack Compose den mit remember erhaltenen Zustand vom Zustand mit rememberSaveable, und wie löst mutableStateOf Oberflächenaktualisierungen über Rekompositionen hinweg aus?

In Jetpack Compose hält `remember` ein Objekt über Rekompositionen hinweg im Arbeitsspeicher, solange die Composable-Funktion im Kompositionsbaum verbleibt. Zustand, der ausschließlich mit `remember` gehalten wird, geht jedoch bei Konfigurationsänderungen wie Bildschirmdrehungen und bei einer vom System veranlassten Prozessbeendigung verloren. `rememberSaveable` erhält den Zustand dagegen auch über Konfigurationsänderungen und Prozessbeendigungen hinweg. Dazu sichert und restauriert es Werte automatisch über das Android-Bundle für gespeicherten Instanzzustand; für nicht unterstützte Datentypen können eigene `Saver`-Implementierungen verwendet werden. `mutableStateOf` verpackt einen Wert in ein beobachtbares `MutableState`-Objekt, das auf dem Snapshot-Zustandssystem von Compose basiert. Liest eine Composable-Funktion während der Komposition den Wert eines `MutableState`, registriert Compose diesen Lesezugriff. Ändert sich der Wert später, markiert Compose automatisch alle Composable-Funktionen, die ihn gelesen haben, als ungültig und plant ihre Rekomposition. Dadurch bleibt die Benutzeroberfläche mit dem aktualisierten Zustand synchron.

@Composable
fun CounterExample() {
    // Resets to 0 on screen rotation
    var localCount by remember { mutableStateOf(0) }

    // Persists across screen rotation and process death
    var persistentCount by rememberSaveable { mutableStateOf(0) }

    Column {
        Button(onClick = { localCount++; persistentCount++ }) {
            Text("Local: $localCount | Saved: $persistentCount")
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

8Wie hilft Kotlins Null-Sicherheit dabei, Abstürze in Android-Apps zu verhindern, und wann würdest du einen nullable beziehungsweise einen nicht-nullbaren Typ verwenden?

Kotlins Null-Sicherheit verhindert viele Android-Abstürze, indem sie die Möglichkeit eines Null-Werts im Typsystem ausdrückt. Ein als `String` deklarierter Wert gilt als nicht null; daher erlaubt der Compiler direkte Zugriffe wie `name.length`. Ein als `String?` deklarierter Wert kann dagegen null sein. Kotlin verlangt deshalb, diesen Fall vor der Verwendung zu behandeln. Das verringert versehentliche `NullPointerException`s durch optionale Intent-Extras, Antworten von Programmierschnittstellen, Bundle-Argumente oder Java- und Plattformschnittstellen. Verwende einen nicht-nullbaren Typ, wenn der Wert erforderlich ist, damit das Objekt oder die Funktion gültig ist. Ein nullable Typ ist passend, wenn das Fehlen des Werts ein erwarteter Zustand ist, beispielsweise bei einer optionalen Profilbildadresse oder einem fehlenden Serverfeld. Nullable Werte werden üblicherweise mit sicheren Aufrufen wie `user?.name`, dem Elvis-Operator wie `user?.name ?: "Guest"` oder ausdrücklichen Null-Prüfungen behandelt. Der Operator `!!` umgeht die Sicherheitsprüfung und wirft eine Ausnahme, wenn der Wert null ist. Er sollte daher selten und nur dann verwendet werden, wenn sich tatsächlich nachweisen lässt, dass der Wert nicht null sein kann.

val displayName: String? = intent.getStringExtra("display_name")

val greeting = "Hello, ${displayName ?: "Guest"}"
val lengthText = displayName?.length?.toString() ?: "No name provided"

// Risky: crashes if displayName is null
val riskyLength = displayName!!.length
Diese Frage mit einem KI-Coach beantworten

9Welcher technische Unterschied besteht darin, langlebigen Objekten einen Activity Context statt eines Application Contexts zu übergeben, und wie führt die falsche Wahl zu einem Speicherleck?

Ein Activity Context ist unmittelbar an den Lebenszyklus eines bestimmten Bildschirms und seiner Oberflächenhierarchie gebunden. Ein Application Context gehört dagegen zum Lebenszyklus des gesamten App-Prozesses. Wird eine Activity beendet oder neu erstellt, etwa bei einer Bildschirmdrehung als Konfigurationsänderung, endet ihr Lebenszyklus, und ihr Speicher soll durch die GC (automatische Speicherbereinigung) freigegeben werden. Wird einem langlebigen Objekt wie einem Singleton, einem statischen Feld oder einem lange laufenden Hintergrundthread ein Activity Context übergeben, hält dieses Objekt eine starke Referenz auf die Activity. Da langlebige Objekte selbst Wurzeln der Speicherbereinigung sind oder von solchen Wurzeln aus erreichbar bleiben, kann die zerstörte Activity nicht freigegeben werden. Dadurch bleiben nicht nur die Activity-Instanz, sondern auch ihre gesamte angehängte View-Hierarchie, Drawables und Ressourcen erhalten. Das verursacht ein erhebliches Speicherleck. Die Übergabe von applicationContext ist für langlebige Komponenten dagegen sicher, weil seine Lebensdauer der erwarteten Lebensdauer des Prozesses entspricht.

class LocationRepository private constructor(private val context: Context) {
    companion object {
        @Volatile
        private var INSTANCE: LocationRepository? = null

        fun getInstance(context: Context): LocationRepository {
            return INSTANCE ?: synchronized(this) {
                // SAFE: Using context.applicationContext prevents retaining an Activity reference
                INSTANCE ?: LocationRepository(context.applicationContext).also { INSTANCE = it }
            }
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

10Was unterscheidet einen Upload-Schlüssel von einem App-Signierschlüssel bei Google Play App Signing?

Bei Google Play App Signing erfüllen Upload-Schlüssel und App-Signierschlüssel zwei unterschiedliche Sicherheitsaufgaben. Den Upload-Schlüssel verwahrt der Entwickler. Er signiert damit das Build-Artefakt, ein AAB (Android-App-Bundle), vor dem Hochladen in die Google Play Console und weist gegenüber Google seine Identität nach. Der App-Signierschlüssel wird sicher in Googles Cloud-Infrastruktur gespeichert. Google Play verwendet ihn, um die erzeugten APK-Installationspakete zu signieren, die tatsächlich an Endgeräte ausgeliefert und dort installiert werden. Damit bildet er die dauerhafte kryptografische Identität der App unter Android. Ein wesentlicher betrieblicher Vorteil ist die Wiederherstellung des Zugangs: Geht der Upload-Schlüssel verloren oder wird er kompromittiert, kann der Google-Play-Support ihn nach Prüfung der Entwickleridentität zurücksetzen, ohne den Update-Pfad der App zu unterbrechen. Beim älteren Modell, in dem Entwickler den eigentlichen App-Signierschlüssel selbst verwahrten, bedeutete dessen Verlust, dass die App nicht mehr aktualisiert werden konnte.

android {
    signingConfigs {
        create("release") {
            storeFile file("my-upload-key.jks")
            storePassword System.getenv("KEYSTORE_PASSWORD")
            keyAlias "upload-alias"
            keyPassword System.getenv("KEY_PASSWORD")
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.getByName("release")
            minifyEnabled true
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

Fragen für Fortgeschrittene

11Wie würden Sie Bearbeiten und Löschen in einer bestehenden Android-Notiz-App implementieren und die Persistenz prüfen?

Nutzen Sie das vorhandene Repository und stabile IDs, aktualisieren Sie den dauerhaften Speicher und stellen Sie beobachtbare Ergebnisse für die Oberfläche bereit. Bewahren Sie ungespeicherte Änderungen bei Bedarf auf und testen Sie Prozessneustart, Abbruch eines Löschvorgangs und Repository-Fehler.

Diese Frage mit einem KI-Coach beantworten

12Wie erhält eine Android-View in MVP und MVVM typischerweise Änderungen der Darstellung?

In MVP nimmt der Presenter Aktionen entgegen, koordiniert die Logik und ruft Methoden der View-Schnittstelle wie showLoading oder showItems auf. Er hält eine Referenz auf diese Schnittstelle und muss sie beim An- und Abkoppeln verwalten. In MVVM veröffentlicht das ViewModel beobachtbaren Zustand über StateFlow oder LiveData. Die View beobachtet ihn gemäß ihrem Lebenszyklus, zeichnet ihn und meldet Aktionen zurück. Das ViewModel hält keine Referenz auf Activity oder Fragment-View. Beide Muster können reaktiv umgesetzt werden. Der praktische Unterschied zwischen Anweisungen und beobachtetem Zustand prägt Tests und Zuständigkeit für den Lebenszyklus.

Diese Frage mit einem KI-Coach beantworten

13Wie unterscheiden sich kalte, warme und heiße Android-Starts, und wie messen Sie eine Optimierung in diesen Fällen?

Beim Kaltstart fehlen Prozess und Anwendungszustand, und die Activity wird neu erstellt. Beim Warmstart ist Prozesszustand vorhanden, die Activity oder ihr Bildschirminhalt muss gegebenenfalls wiederhergestellt werden. Beim Heißstart kehrt eine bestehende Activity in den Vordergrund zurück. Ich trenne die Fälle, da etwa schnellere Application-Initialisierung vor allem kalt hilft. Wiederholbare Benchmarks und System-Traces messen Zeit bis zur ersten Anzeige sowie bis zum vollständig nutzbaren Inhalt. Gerät, Betriebssystem, Build, Daten, Kompilierung, Baseline-Profil sowie Startzustand von Prozess und Activity halte ich konstant. Ich vergleiche Verteilungen, prüfe auf hinter den ersten Frame verschobene Arbeit und auf Rückschritte in anderen Startmodi.

Diese Frage mit einem KI-Coach beantworten

14Wie gestalten Sie Laufzeitberechtigungen mit Erstfrage, Begründung, Ablehnung, „Nicht mehr fragen“ und Einstellungen ohne Nutzerdruck?

Fragen Sie erst bei tatsächlichem Bedarf, etwa beim Tippen auf Codescan, nicht pauschal beim Start. Liefert shouldShowRequestPermissionRationale() den Wert true, erklären Sie in der App, beispielsweise in einem Bottom Sheet oder Dialog, warum die Berechtigung benötigt wird und welchen Nutzen sie bietet, bevor Sie den Systemdialog öffnen. Respektieren Sie Ablehnung, lassen Sie unabhängige Funktionen frei und bieten Sie etwa manuelle Eingabe statt Kamera. Der Wert false allein beweist keine dauerhafte Ablehnung: Es tritt auch vor der ersten Frage auf. Erfassen Sie, ob bereits eine Anfrage gestellt wurde, und berücksichtigen Sie deren Ergebnis und berücksichtigen Sie Plattform- oder Richtlinienbeschränkungen. Ist kein weiterer Dialog verfügbar, erklären Sie die fehlende Funktion und bieten Sie eine optionale Schaltfläche an, die über Settings.ACTION_APPLICATION_DETAILS_SETTINGS zu den App-Einstellungen führt. Nutzer müssen abbrechen oder zurückkehren können, ohne eingeschlossen zu werden.

fun onScanButtonClicked() {
    when {
        ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED -> {
            openScanner()
        }
        activity.shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
            showRationaleDialog(onConfirm = { cameraPermissionLauncher.launch(Manifest.permission.CAMERA) })
        }
        else -> {
            cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }
}

fun handlePermissionResult(isGranted: Boolean) {
    if (isGranted) {
        openScanner()
    } else if (!activity.shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
        showSettingsRedirectDialog()
    } else {
        showManualEntryFallback()
    }
}
Diese Frage mit einem KI-Coach beantworten

15Wie würdest du eine Android-Pipeline für CI/CD, also kontinuierliche Integration und Bereitstellung, von der Pull-Request-Prüfung über signierte Release-Kandidaten und interne Tests bis zum Upload in Play-Tracks und zur schrittweisen Veröffentlichung gestalten?

Eine Android-CI/CD-Pipeline für den Produktivbetrieb beginnt bei Pull Requests mit schnellen automatisierten Prüfungen: statischer Analyse durch ktlint, detekt und Android Lint, Unit-Tests und dem Kompilieren eines Debug-Builds. Nach dem Zusammenführen in den Haupt- oder Release-Branch startet die Release-Pipeline. Sie erzeugt einen signierten Release-Kandidaten (RC) als Android App Bundle (.aab) unter Verwendung der von der CI verwalteten Keystore-Zugangsdaten, Codeverkleinerung durch ProGuard/R8 und automatischer Versionsanhebung. Das signierte AAB und die Mapping-Dateien zur Rückauflösung verschleierter Namen werden mit Werkzeugen wie Gradle Play Publisher (GPP) oder Fastlane in den internen Test-Track von Google Play oder zu Firebase App Distribution hochgeladen. Dort werden automatisierte Smoke- oder Instrumentierungstests ausgeführt. Nach der Freigabe durch die interne Qualitätssicherung und die Verantwortlichen wird exakt dasselbe Binärartefakt in die folgenden Stufen übernommen: interner Test, geschlossener Alpha-/Beta-Test, Produktions-Rollout. Ein erneuter Build aus dem Quellcode erfolgt dabei nicht. Abschließend ermöglichen gestaffelte Rollouts, etwa 5 %, 20 % und 100 %, zusammen mit automatisierter Überwachung der Absturzrate und Android Vitals eine sichere Veröffentlichung.

lane :promote_internal_to_beta do
  upload_to_play_store(
    track: 'internal',
    track_promote_to: 'beta',
    skip_upload_aab: true, # Promotes existing binary without rebuilding
    skip_upload_metadata: false,
    skip_upload_changelogs: false
  )
end
Diese Frage mit einem KI-Coach beantworten

16Warum stört das pauschale Abfangen von Exception oder Throwable den Coroutine-Abbruch, wenn CancellationException nicht erneut geworfen wird, und wie diagnostizierst du solche Abbruchprobleme?

Kotlin-Coroutines verwenden kooperativen Abbruch über CancellationException. Wird der Job einer Coroutine abgebrochen, werfen suspendierende Aufrufe wie delay oder yield eine CancellationException, um den Aufrufstapel abzuwickeln und die Coroutine zu beenden. Fängt der Code pauschal Exception oder Throwable ab, ohne CancellationException erneut zu werfen, wird das Abbruchsignal verschluckt. Die Coroutine beendet sich nicht und läuft weiter. Eine solche „Zombie-Coroutine“ verbraucht unnötig CPU-Zeit und Speicher, kann Ressourcen offenhalten und ungültige Zustandsübergänge oder Abstürze beim Zugriff auf bereits zerstörte UI-Komponenten verursachen. Zur Diagnose: 1. Ausnahmebehandlung prüfen und sicherstellen, dass CancellationException ausdrücklich erneut geworfen wird oder nur fachlich relevante Ausnahmen statt pauschal Throwable beziehungsweise Exception abgefangen werden. 2. Coroutine-Zustände in Debug-Builds mit dem Kotlin Coroutines Debugger (-Dkotlinx.coroutines.debug) oder dem Android Studio Coroutines Inspector untersuchen, um noch laufende Coroutines zu finden, die bereits beendet sein sollten. 3. Lebenszykluszustände wie job.isActive und job.isCancelled protokollieren oder strukturiertes Logging in Abschluss-Callbacks wie job.invokeOnCompletion verwenden.

import kotlinx.coroutines.CancellationException

// ANTI-PATTERN: Swallows cancellation, creating a zombie coroutine
try {
    doSuspendingWork()
} catch (e: Exception) {
    logError(e)
}

// CORRECT: Preserves cancellation propagation
try {
    doSuspendingWork()
} catch (e: Exception) {
    if (e is CancellationException) throw e
    logError(e)
}
Diese Frage mit einem KI-Coach beantworten

17Wie funktionieren State Hoisting und unidirektionaler Datenfluss (UDF) in Jetpack Compose, und wie entscheidest du, ob Zustand in ein untergeordnetes Composable, ein übergeordnetes Composable oder ein ViewModel gehört?

Beim State Hoisting wird Zustand in der Kompositionshierarchie nach oben verlagert, damit ein Composable zustandslos und zu einer reinen UI-Komponente wird. Das ermöglicht unidirektionalen Datenfluss (UDF): Zustand fließt als Parameter vom übergeordneten Composable oder ViewModel nach unten zu den untergeordneten Composables; Ereignisse fließen als Callbacks in die Gegenrichtung. Für die Platzierung gelten folgende Leitlinien. 1. Untergeordnetes Composable am Ende der Hierarchie, lokaler UI-Zustand: Ist der Zustand kurzlebig, rein visuell und wird weder von übergeordneten noch von benachbarten Komponenten benötigt, bleibt er mit remember lokal. Beispiele sind eine interne Ein-/Ausklappanimation oder ein lokaler Welleneffekt bei Berührung. 2. Übergeordnetes Composable, nach oben verlagerter UI-Zustand: Müssen Geschwister-Composables den Zustand teilen oder darauf reagieren, oder steuert das übergeordnete Element Sichtbarkeit beziehungsweise Validierung, wird der Zustand zum nächsten gemeinsamen übergeordneten Composable verlagert. Das untergeordnete Composable wird zustandslos und erhält value sowie onValueChange. 3. ViewModel, Bildschirm- beziehungsweise fachlicher Zustand: Repräsentiert der Zustand Geschäftsdaten, soll er Konfigurationsänderungen überstehen, steuert er die Navigation oder benötigt er Zugriffe auf Domänen- oder Repository-Schichten, gehört er in ein ViewModel und wird als beobachtbarer Zustand bereitgestellt, etwa über StateFlow. Das ViewModel verarbeitet die Geschäftslogik und aktualisiert den UI-Zustand entsprechend.

// Stateless Leaf Composable
@Composable
fun SearchBar(query: String, onQueryChange: (String) -> Unit) {
    TextField(value = query, onValueChange = onQueryChange)
}

// Stateful Screen / ViewModel Owner
@Composable
fun SearchScreen(viewModel: SearchViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    SearchBar(
        query = uiState.query,
        onQueryChange = { newQuery -> viewModel.onQueryChanged(newQuery) }
    )
}
Diese Frage mit einem KI-Coach beantworten

Fragen für Erfahrene

18Wie entwerfen Sie den Android-Client einer Gmail-ähnlichen Anwendung vom Öffnen des Posteingangs bis zum Lesen einer Nachricht?

Eine beobachtbare lokale Datenbank speist den seitenweisen Posteingang. Ein Repository synchronisiert authentifiziert mit dem Server. Das ViewModel liefert Lade-, Inhalts-, Leer- und Fehlerzustände. Die Detailansicht erhält eine stabile ID, zeigt gespeicherten Inhalt und lädt Fehlendes nach. Gelesen-Markierungen aktualisiere ich optimistisch und speichere Änderungen mit Wiederholungs- und Konfliktregeln in einer Outbox. Inkrementelle Synchronisation mit Token und Hintergrundarbeit spart Downloads. Konto, Ordner und Auswahl lassen sich wiederherstellen, ohne Nachrichtentexte als Navigationsargumente zu übergeben. Anhänge lade ich bei Bedarf mit Grenzen und Abbruch. Bei fremdem HTML beschränke ich Skripte, unsichere Links und externe Inhalte. Ich teste Offlinebetrieb, abgelaufene Anmeldung, Prozessende und doppelte Synchronisationsereignisse.

Diese Frage mit einem KI-Coach beantworten

19Wie beeinflussen Doze, Standby-Buckets und herstellerspezifische Prozessbeendigung Hintergrundplanung, und wie bauen Sie eine robuste Synchronisierung mit WorkManager?

Doze beschränkt bei Inaktivität Prozessornutzung (CPU), Netzwerkzugriff und Hintergrundaufgaben und verschiebt viel gewöhnliche Arbeit in Wartungsfenster mit dokumentierten Ausnahmen. App-Standby-Buckets drosseln die Häufigkeit von Hintergrundjobs und den Netzwerkzugriff dynamisch danach, wie kürzlich die App genutzt wurde; die Einstufungen reichen von Active bis Restricted oder Never. Aggressive Energiesparmechanismen der Gerätehersteller (OEMs) wie MIUI oder OneUI können Prozesse beenden, Alarme ignorieren und Autostart einschränken, abweichend vom Verhalten des offenen Android-Basisprojekts (AOSP). WorkManager plant persistent im Rahmen der Plattform, umgeht aber weder Doze, Quoten, Force-stop noch Anbietergrenzen. Bedingungen wie NetworkType.CONNECTED und requiresBatteryNotLow verschieben Arbeit bis zu zulässiger Ausführung und Konnektivität. Gegen Prozessende und Netzfehler verwenden Sie geeignete Wiederholungen, häufig exponentielles Backoff, unter Berücksichtigung zufälliger Wartezeitstreuung und serverseitiger Ratenlimits; exponentielle Abstände allein verhindern keine synchronen Wellen. Worker benötigen atomare lokale Checkpoints und idempotente Fernoperationen, nicht die Annahme einer atomaren Transaktion über Gerät und Server. Deterministische Transaktions-IDs, lokale Zustandsflags und Serverdeduplizierung erlauben Wiederanlauf ohne doppelte Daten oder lokale Korruption.

val syncConstraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .build()

val syncWorkRequest = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(syncConstraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        WorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .addTag("data_sync_tag")
    .build()

WorkManager.getInstance(context).enqueueUniqueWork(
    "unique_data_sync",
    ExistingWorkPolicy.KEEP,
    syncWorkRequest
)
Diese Frage mit einem KI-Coach beantworten

20Wie gestalten Sie eine skalierbare Mehrteamarchitektur mit API-/Implementierungsmodulen für schnelle Gradlebuilds und strikte Grenzen?

Das Muster trennt pro Funktion oder Domäne zwei Gradle-Unterprojekte: ein leichtgewichtiges `:feature:api` mit öffentlichen Schnittstellen, Modellen und Navigationsverträgen sowie `:feature:impl` mit interner Geschäftslogik, Benutzeroberfläche und Repository-Implementierungen. Abhängige Module verwenden ausschließlich `:feature:api`, etwa mit `implementation project(':feature:api')`. Das Wurzelmodul `:app` oder andere zentrale Zusammenbaupunkte verbinden die konkreten Implementierungen durch Bereitstellung der Abhängigkeiten, beispielsweise mit Dagger oder Hilt. Stabile öffentliche Schnittstellen und kleinere Klassenpfade für die Kompilierung können erneute Kompilierungen verringern. Dieser Vorteil muss gegen zusätzlichen Modul- und Verknüpfungsaufwand gemessen werden. Ändern sich nur interne Details in `:feature:impl`, bleibt die öffentliche binäre Schnittstelle (ABI) von `:feature:api` unverändert. Abhängige Module mit unveränderten Kompilierungseingaben können dann ohne erneute Kompilierung auskommen. Betroffene Arbeiten an Implementierungsmodulen und der App-Paketierung bleiben erforderlich. Annotationsverarbeitung, erzeugter Code oder nach außen gelangte ABI-Typen können die Menge ungültig gewordener Ergebnisse vergrößern. Der Build Cache verwendet Aufgabenergebnisse wieder; der Configuration Cache verwendet den bereits konfigurierten Aufgabengraphen wieder. Das sind unterschiedliche Mechanismen. Organisatorisch schaffen etwa CODEOWNERS klare Teamzuständigkeiten. Zusammen mit Abhängigkeitsprüfungen können Teams interne Implementierungen weiterentwickeln, ohne private Klassen offenzulegen und versehentliche Kopplung zu erhöhen. Ohne Kontrolle des Abhängigkeitsgraphen können allerdings auch Schnittstellenmodule Zyklen bilden.

// :feature:checkout:api/src/main/java/com/example/checkout/api/CheckoutApi.kt
package com.example.checkout.api

interface CheckoutLauncher {
    fun launchCheckoutFlow(cartId: String)
}

// :feature:checkout:impl/src/main/java/com/example/checkout/impl/CheckoutLauncherImpl.kt
package com.example.checkout.impl

import com.example.checkout.api.CheckoutLauncher
import javax.inject.Inject

internal class CheckoutLauncherImpl @Inject constructor(
    private val paymentGateway: PaymentGateway
) : CheckoutLauncher {
    override fun launchCheckoutFlow(cartId: String) {
        // Concrete checkout implementation
    }
}

// :feature:checkout:impl/src/main/java/com/example/checkout/impl/di/CheckoutModule.kt
package com.example.checkout.impl.di

import com.example.checkout.api.CheckoutLauncher
import com.example.checkout.impl.CheckoutLauncherImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent

@Module
@InstallIn(SingletonComponent::class)
internal abstract class CheckoutBindingModule {
    @Binds
    abstract fun bindCheckoutLauncher(impl: CheckoutLauncherImpl): CheckoutLauncher
}
Diese Frage mit einem KI-Coach beantworten

Übe Interviews auf deinem Smartphone: Android-Entwickler

Antworte laut und erhalte KI-Feedback in der Android-App.

EngineerSpeak bei Google Play herunterladen
Zum Download scannen