20 ofte stillede Android-interviewspørgsmål. Android-udvikling er et efterspurgt felt med fokus på Kotlin-baserede mobilapps, Android SDK og Jetpack samt lifecycle-, performance-, netværks-, storage-, test- og releaseopgaver. Spørgsmålene dækker flere niveauer, og du kan øve dig i at svare mundtligt i vores interviewtræner.
1Hvordan vælger du mellem lazy og lateinit til en Kotlin-egenskab, hvis værdi mangler ved konstruktion?
val by lazy beregner værdien ved første adgang og genbruger resultatet. Det udskyder dyr konstruktion, men venter ikke på en ekstern asynkron tildeling. lateinit var tillader udtrykkelig senere og gentagen tildeling, fx ved injektion eller et livscykluskald. Det kræver en understøttet ikke-null referencetype, kan ikke bruges til primitive typer og giver UninitializedPropertyAccessException ved for tidlig læsning. Ved lazy vurderer jeg trådsikkerhedstilstand og den tråd, som skal beregne værdien. Til et Fragment-view, der destrueres og genskabes, bruger jeg en holder, hvis reference kan ryddes eller nulstilles.
2Hvad er de fire primære Android-applikationskomponenter, og hvad er livscyklus- og trådmodellen for deres standard-callbacks?
De fire primære Android-applikationskomponenter er Activity, Service, BroadcastReceiver og ContentProvider. En Activity leverer en brugergrænseflade til interaktioner på skærmen. En Service udfører baggrundsbehandling uden en dedikeret UI. En BroadcastReceiver lytter efter og reagerer på systemomspændende eller app-interne broadcast-beskeder. En ContentProvider administrerer og udstiller strukturerede data til andre applikationer eller interne moduler. Som standard afvikles de primære livscyklus-callbacks for Activity (f.eks. onCreate, onStart, onResume), Service (f.eks. onCreate, onStartCommand, onBind) og BroadcastReceiver (onReceive) synkront på applikationens hovedtråd (UI-tråden). ContentProvider-metoder (såsom onCreate) initialiseres også på hovedtråden, men query/insert-handlinger, der kaldes på tværs af processer, kører på tråde fra en Binder-trådpulje. Da standard-callbacks kører på hovedtråden, vil tunge, blokerende operationer som netværkskald eller omfattende disk-I/O til databaser blokere UI-løkken og udløse en Application Not Responding (ANR)-fejl.
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
}
}
3Hvad er de primære ansvarsområder for en ViewModel sammenlignet med UI-controllere (User Interface) som Activities og Fragments i Androids MVVM-arkitektur (Model-View-ViewModel), og hvorfor frarådes det at videregive en Context til en ViewModel?
I Androids MVVM-arkitektur er en ViewModel ansvarlig for at opbevare og administrere UI-relateret tilstand, orkestrere præsentationslogik og overleve konfigurationsændringer (såsom skærmrotationer). Til sammenligning er UI-controllere (Activities og Fragments) ansvarlige for at gengive UI-elementer på skærmen, observere tilstandsændringer, håndtere direkte brugerinteraktioner (klik, swipes) samt håndtere Android-livscyklusbegivenheder. Det frarådes kraftigt at videregive en Activity-`Context` eller en reference til et View til en ViewModel, fordi ViewModels generelt overlever UI-controlleres livscyklus på tværs af konfigurationsændringer. Når en Activity destrueres og genoprettes under rotation, vil en ViewModel, der holder på dens Context, forhindre den gamle Activity i at blive fjernet af garbage collectoren, hvilket forårsager en hukommelseslækage. Hvis en Android-`Context` er strengt nødvendig til operationer på systemniveau, bør der i stedet anvendes en Context med applikations-scope (for eksempel via `AndroidViewModel` eller ved at injicere ApplicationContext).
// 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))
}
}
}
4Hvordan adskiller normale og farlige tilladelser i Android sig fra hinanden, og hvad sker der, når en app anmoder om en farlig tilladelse ved kørselstid (runtime)?
Normale tilladelser udgør en minimal risiko for brugerens privatliv eller enhedens drift og tildeles automatisk af systemet ved installation af appen, hvis de er deklareret i `AndroidManifest.xml` (såsom `ACCESS_NETWORK_STATE`). Farlige tilladelser (også kaldet runtime-tilladelser) styrer adgangen til private brugerdata eller begrænsede enhedsfunktioner, såsom kamera, mikrofon, lokation og kontakter. Når en app anmoder om en farlig tilladelse under kørslen, viser Android-systemet en systemdialogboks, der beder brugeren om at tillade eller afvise adgangen. Hvis brugeren giver tilladelse, udfører appen den ønskede funktion. Hvis brugeren afviser tilladelsen, modtager appen et afvisnings-callback og skal håndtere det elegant ved at deaktivere eller begrænse den afhængige funktion uden at gå ned, samt eventuelt vise en forklarende brugergrænseflade (UI rationale).
5Hvad er forskellen mellem debug- og release-builds i Android, og hvordan kombineres build types og product flavors til build variants?
I Android-udvikling konfigurerer build types pakke- og runtime-egenskaber til forskellige udviklingsstadier. Debug-builds aktiverer debugging-flag (`isDebuggable = true`), anvender et standard debug-keystore og deaktiverer typisk kodeminificering og -krympning (R8/ProGuard) for at sikre hurtige build-iterationer. Release-builds deaktiverer debugging-flag, aktiverer optimeringer og tilsløring (obfuscation) og kræver en sikker release-signeringsnøgle til distribution. Product flavors repræsenterer forskellige versioner eller målgrupper af appen, som deler den samme kernekodebase, såsom forskellige miljøer (staging vs. produktion) eller produktudgaver (gratis vs. betalt). I Gradle dannes build variants ved det kartesiske produkt af product flavors og build types (Build Variant = Product Flavor × Build Type). For eksempel vil en kombination af flavors som `staging` og `production` med build types som `debug` og `release` give fire build variants: `stagingDebug`, `stagingRelease`, `productionDebug` og `productionRelease`.
6Hvad er en coroutine i Kotlin, og hvordan adskiller suspendering sig fra at blokere en tråd under runtime i Android?
En coroutine i Kotlin er en letvægtsabstraktion til samtidighed, der gør det muligt at skrive asynkron, ikke-blokerende kode på en sekventiel måde. Flere coroutines kan køre samtidigt på en enkelt tråd eller på tværs af trådpuljer uden den tunge hukommelses- og kontekstskift-overhead, som operativsystemtråde har. Den væsentlige forskel mellem suspendering og blokering er trådudnyttelse: - Blokering (f.eks. Thread.sleep() eller synkron disk-/netværks-I/O) standser den underliggende tråd og gør den utilgængelig for andet arbejde. På Androids hovedtråd fastfryser blokering brugergrænsefladen og udløser ANR-fejl (Application Not Responding). - Suspendering (via suspend-funktioner såsom delay()) pauser coroutinen uden at standse den underliggende tråd. Coroutinen gemmer sin udførelsestilstand i en Continuation og frigiver tråden tilbage til kørselsmiljøet, så den kan udføre andet arbejde (såsom at håndtere UI-interaktioner). Når den asynkrone operation er færdig, genoptages coroutinen.
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"
}
7Hvad er forskellen i Jetpack Compose mellem tilstand bevaret med remember versus rememberSaveable, og hvordan driver mutableStateOf UI-opdateringer (User Interface) på tværs af rekompositioner?
I Jetpack Compose gemmer `remember` et objekt i hukommelsen på tværs af rekompositioner, så længe den pågældende composable forbliver i kompositionstræet. Tilstand, der udelukkende fastholdes med `remember`, går dog tabt ved konfigurationsændringer (såsom skærmrotationer) og systeminitieret proceslukning (process death). Til sammenligning bevarer `rememberSaveable` tilstand på tværs af konfigurationsændringer og proceslukning ved automatisk at gemme og gendanne værdier via Androids Saved Instance State bundle (eller gennem brugerdefinerede `Saver`-implementeringer for ikke-understøttede datatyper). `mutableStateOf` indkapsler en værdi i et observerbart `MutableState`-objekt understøttet af Composes Snapshot-tilstandssystem. Når en composable læser værdien af en `MutableState` under kompositionen, registrerer Compose denne læsehandling. Når værdien senere ændres, markerer Compose automatisk alle composables, der læste værdien, som ugyldige og planlægger dem til rekomposition, hvilket sikrer, at brugerfladen forbliver synkroniseret med den opdaterede tilstand.
@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")
}
}
}
8Hvordan hjælper Kotlins null-sikkerhed (null safety) med at forhindre nedbrud i Android-apps, og hvornår bør man bruge en type, der kan være null, frem for en ikke-null type?
Kotlins null-sikkerhed hjælper med at forhindre mange Android-nedbrud ved at gøre null-egenskaben til en del af typesystemet. En værdi erklæret som `String` behandles som ikke-null, så kompileren tillader direkte adgang såsom `name.length`. En værdi erklæret som `String?` kan være null, og Kotlin tvinger dig derfor til at håndtere det tilfælde før brug, hvilket reducerer utilsigtede `NullPointerException`-fejl fra valgfrie Intent-extras, API-svar, Bundle-argumenter eller Java-/platform-API'er. Brug en ikke-null type, når værdien er påkrævet for, at objektet eller funktionen er gyldig. Brug en type, der kan være null, når fravær er en reel, forventet tilstand, såsom en valgfri URL til et profilbillede eller et manglende felt fra serveren. Værdier, der kan være null, håndteres normalt med sikre kald såsom `user?.name`, Elvis-operatoren såsom `user?.name ?: "Guest"` eller eksplicitte null-tjek. `!!`-operatoren fravælger sikkerheden og kaster en undtagelse, hvis værdien er null, så den bør anvendes sjældent og kun, når udvikleren reelt kan bevise, at værdien ikke kan være null.
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
9Hvad er den mekaniske forskel på at videregive en Activity Context versus en Application Context til objekter med lang levetid, og hvordan fører det forkerte valg til en hukommelseslækage?
En Activity Context er bundet direkte til livscyklussen for en specifik skærm og dens UI-hierarki, hvorimod en Application Context er bundet til hele app-processens livscyklus. Når en Activity afsluttes eller genoprettes (f.eks. ved en konfigurationsændring såsom skærmrotation), slutter dens livscyklus, og dens hukommelse bør frigives af Garbage Collector (GC). Hvis du sender en Activity Context til et objekt med lang levetid – såsom en singleton, et statisk felt eller en langvarig baggrundstråd – fastholder dette langlivede objekt en stærk reference til din Activity. Da objekter med lang levetid fungerer som GC-rødder eller kan nås fra GC-rødder, kan garbage collectoren ikke frigive den destruerede Activity. Dette fastholder ikke kun selve Activity-instansen, men også hele dens tilknyttede View-hierarki, drawables og ressourcer, hvilket skaber en betydelig hukommelseslækage. Til sammenligning er det sikkert at videregive applicationContext til komponenter med lang levetid, da dens livscyklus forventes at matche processens levetid.
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 }
}
}
}
}
10Hvad er forskellen på en upload-nøgle (upload key) og en app-signeringsnøgle (app signing key) ved brug af Google Play App Signing?
I Google Play App Signing tjener upload-nøglen og app-signeringsnøglen to forskellige sikkerhedsmæssige formål. Upload-nøglen opbevares af udvikleren til at signere build-artefaktet (AAB), før det uploades til Google Play Console, hvilket bekræfter udviklerens identitet over for Google. App-signeringsnøglen gemmes sikkert i Googles cloud-infrastruktur og bruges af Google Play til at signere de genererede APK'er, der rent faktisk leveres og installeres på slutbrugernes enheder, hvilket etablerer appens permanente kryptografiske identitet på Android. En væsentlig driftsmæssig fordel er nøglegenoprettelse: Hvis en udvikler mister eller kompromitterer sin upload-nøgle, kan Google Play-support nulstille upload-nøglen efter verifikation af udviklerens identitet uden at afbryde appens opdateringssti. I den ældre model, hvor udviklere selv lå inde med app-signeringsnøglen, betød tab af nøglen, at appen aldrig kunne opdateres igen.
11Hvordan ville du tilføje redigering og sletning i en eksisterende Android-app til noter og kontrollere, at ændringerne gemmes varigt?
Jeg bruger appens eksisterende repository og stabile id’er, opdaterer det permanente lager og gør resultaterne observerbare for brugerfladen. Jeg bevarer ugemte ændringer, hvor det er relevant, og tester genskabelse af processen, annullering af sletning og fejl i repositoryet.
12Hvordan modtager en Android-view normalt præsentationsændringer i MVP og MVVM?
I MVP modtager præsentatoren handlinger, koordinerer logik og kalder en view-grænseflade, fx showLoading eller showItems. Den holder en reference og skal styre til- og frakobling. I MVVM udstiller ViewModel tilstand via StateFlow eller LiveData. Viewet observerer i takt med livscyklussen, tegner tilstanden og sender handlinger tilbage. ViewModel bør ikke holde en Activity eller et Fragments view i live. Begge mønstre kan bruge reaktive teknikker. Forskellen mellem kommandoer og observeret tilstand har betydning for test og ansvar for livscyklussen.
13Hvordan adskiller kold, lun og varm Android-opstart sig, og hvordan sammenligner du en optimering på tværs af dem?
Ved kold start findes processen ikke, så proces og applikation initialiseres, og en Activity oprettes. Ved lun start genbruges procestilstand, men en Activity eller skærm skal muligvis gendannes. Ved varm start kommer en eksisterende Activity i forgrunden. Jeg måler hver for sig, da optimering af Application især kan hjælpe den kolde start. Med gentagelige benchmarks og systemspor måler jeg første visning og fuldt brugbart indhold separat. Enhed, OS, build, data, kompilering, baselineprofil samt proces- og Activity-tilstand holdes ens. Jeg sammenligner fordelinger og ser efter arbejde skubbet efter første billede og forringelser i andre startmåder.
14Hvordan vil du designe et forløb til kørselstilladelser (runtime permissions), der håndterer den første anmodning, rationale-UI (User Interface), afvisning, 'spørg ikke igen' og en fallback til indstillinger uden at presse brugeren?
Et ikke-påtrængende, brugervenligt forløb til runtime-tilladelser følger principperne om trinvis fremvisning (progressive disclosure), klar begrundelse og kontrolleret degradering på tværs af alle afvisningstilstande:
1. **Kontekstbaseret anmodning (første gang)**: Anmod kun om tilladelser på det tidspunkt, hvor der reelt er brug for dem, når brugeren interagerer med en funktion (f.eks. ved at trykke på 'Scan kode' for at få kameratilladelse), frem for på forhånd ved app-opstart.
2. **Rationale-UI**: Når `shouldShowRequestPermissionRationale()` returnerer `true`, vises en klar forklaring i appen (såsom et bottom sheet eller en dialogboks), der forklarer, hvorfor tilladelsen er nødvendig, og hvilken fordel den giver, før systemets dialogboks udløses.
3. **Kontrolleret degradering ved afvisning**: Hvis brugeren afviser anmodningen, respekteres valget uden at blokere for urelaterede funktioner. Tilbyd en alternativ arbejdsgang, hvor det er muligt (f.eks. manuel tekstindtastning, hvis kameraadgang afvises).
4. **Permanent afvisning ('Spørg ikke igen') og fallback til indstillinger**: Hvis tilladelsen afvises, og `shouldShowRequestPermissionRationale()` returnerer `false` (brugeren har valgt 'Spørg ikke igen' eller afvist gentagne gange), informeres brugeren om, hvorfor funktionen er utilgængelig, og der tilbydes en valgfri knap, der sender vedkommende til appens indstillinger via `Settings.ACTION_APPLICATION_DETAILS_SETTINGS`. Sørg for, at brugeren let kan annullere eller navigere tilbage uden at blive låst fast.
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()
}
}
15Hvordan vil du designe en Android CI/CD-pipeline (Continuous Integration/Continuous Delivery) fra validering af pull requests til oprettelse af signerede release candidates, intern test, upload til Play-spor og udrulningspromovering?
En produktionsklar Android CI/CD-pipeline starter ved valideringstrinnet for pull requests med hurtige automatiserede tjek: statisk analyse (ktlint, detekt, Android Lint), enhedstests og kompilering af et debug-build. Ved merge til main- eller release-branchen udløses release-pipelinen for at generere en signeret Release Candidate (RC) Android App Bundle (`.aab`) ved hjælp af CI-administrerede release-keystore-legitimationsoplysninger, Proguard/R8-krympning og automatiseret versionsopdatering. Den signerede AAB og dens tilhørende deobfuskerings-mappingfiler uploades til Google Plays interne testspor (eller Firebase App Distribution) ved hjælp af værktøjer som Gradle Play Publisher (GPP) eller Fastlane, hvor automatiserede smoke-tests eller instrumenteringstests køres. Når intern QA og interessenter godkender buildet, promoveres nøjagtig samme binære artefakt videre (Internt -> Lukket Alpha/Beta -> Produktionsudrulning) uden at genkompilere fra kildekoden. Til sidst sikrer trinvise udrulninger (f.eks. 5 % -> 20 % -> 100 %) kombineret med automatiseret overvågning af crash-rater og vitale målinger en sikker udrulning.
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
16Hvorfor ødelægger det coroutine-annullering at fange generiske Exception eller Throwable uden at kaste CancellationException videre, og hvordan diagnosticerer man annulleringsproblemer?
Kotlin Coroutines er baseret på kooperativ annullering, der er implementeret via CancellationException. Når en coroutines Job annulleres, kaster suspenderende kald (såsom delay eller yield) en CancellationException for at afvikle kaldstakken og afslutte coroutinen. Når kode fanger en generisk Exception eller Throwable uden at kaste CancellationException videre, sluges annulleringssignalet. Coroutinen formår ikke at afbryde og fortsætter sin kørsel, hvilket skaber en 'zombie-coroutine', som spilder CPU/hukommelse, lækker ressourcer og kan udløse ugyldige tilstandsovergange eller nedbrud mod destruerede UI-komponenter. Sådan diagnosticeres annulleringsproblemer: 1. Verificer korrekt undtagelseshåndtering ved at sikre, at CancellationException eksplicit kastes videre, eller at der kun fanges domænespecifikke undtagelser i stedet for generiske Throwable/Exception. 2. Inspicer coroutine-tilstande i debug-builds ved hjælp af Kotlin Coroutines Debugger (-Dkotlinx.coroutines.debug) eller Android Studio Coroutines Inspector for at identificere kørende coroutines, der burde være afsluttet. 3. Log coroutine-livscyklustilstande (f.eks. job.isActive, job.isCancelled), eller benyt struktureret logning i completions-handlere for annullering (job.invokeOnCompletion).
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)
}
17Hvordan fungerer state hoisting og UDF (Unidirectional Data Flow) i Jetpack Compose, og hvordan beslutter du, om tilstand hører til i en leaf-composable, en overordnet composable eller en ViewModel?
State hoisting er et mønster i Jetpack Compose, hvor tilstand flyttes op i kompositionshierarkiet for at gøre en composable tilstandsløs og omdanne den til en ren UI-komponent. Det muliggør UDF (Unidirectional Data Flow), hvor tilstand flyder nedad (fra overordnet komponent/ViewModel til underordnede composables som argumenter), og hændelser flyder opad (fra underordnede composables til overordnet komponent/ViewModel som callbacks). Beslutningen om, hvor tilstand hører hjemme, følger disse retningslinjer: 1. Leaf Composable (Lokal UI-tilstand): Hvis tilstanden udelukkende er midlertidig, visuel og ikke behøves af overordnede eller sideløbende komponenter (f.eks. om en intern fold ud/ind-animation kører, eller en lokal ripple-effekt), holdes den lokal i leaf-composablen ved hjælp af `remember`. 2. Overordnet Composable (Hoisted UI-tilstand): Hvis sideløbende composables har brug for at dele eller reagere på tilstanden, eller hvis den overordnede komponent styrer komponentens synlighed/validering, løftes tilstanden op til den nærmeste fælles overordnede composable. Leaf-komponenten bliver tilstandsløs (modtager `value` og `onValueChange`). 3. ViewModel (Skærm- / forretningstilstand): Hvis tilstanden repræsenterer forretningsdata, overlever konfigurationsændringer, styrer navigation eller kræver interaktion med domæne-/repository-lagene, hører den hjemme i en ViewModel eksponeret som observerbar tilstand (f.eks. `StateFlow`). ViewModel håndterer forretningslogik og opdaterer UI-tilstanden derefter.
18Hvordan ville du designe Android-klienten til en Gmail-lignende tjeneste fra åbning af indbakken til læsning af en mail?
En observerbar lokal database forsyner den sideinddelte indbakke. Et repository koordinerer autentificeret synkronisering og lagring. ViewModel udstiller indlæsning, indhold, tom tilstand og fejl. Jeg navigerer med stabilt ID og viser gemt indhold, mens det manglende hentes. Læst/ulæst kan ændres optimistisk og registreres i en outbox med gentagelse og konfliktregler. Inkrementelle synkroniseringstokens og baggrundsarbejde undgår at hente alt igen. Konto, mappe og valg gendannes uden at sende hele beskedtekster som navigationsargumenter. Vedhæftninger hentes efter behov med grænser og annullering. Jeg begrænser scripts, farlige links og eksternt indhold i fremmed HTML. Jeg tester offlinebrug, udløbet godkendelse, procesdød og gentagne synkroniseringshændelser.
19Hvordan påvirker strømstyringsfunktioner på systemniveau såsom Doze Mode, App Standby Buckets og OEM-opgavedræbere (Original Equipment Manufacturer) baggrundsplanlægning, og hvordan ville du designe en robust synkroniseringsmotor ved hjælp af WorkManager?
Batterioptimeringer på systemniveau begrænser baggrundskørsel markant. Doze Mode begrænser CPU, netværksadgang og baggrundsjobs i perioder med inaktivitet og tillader kun afvikling under periodiske vedligeholdelsesvinduer. App Standby Buckets drosler dynamisk hyppigheden af baggrundsjobs og netværksadgang baseret på, hvor nyligt appen har været brugt (fra Active ned til Restricted eller Never). Desuden dræber aggressive, tilpassede OEM-strømstyringsværktøjer (såsom MIUI eller OneUI) ofte baggrundsprocesser, ignorerer standardalarmer og fjerner tilladelser til automatisk start uanset standard AOSP-adfærd (Android Open Source Project). For at bygge en robust synkroniseringsmotor er WorkManager standardfundamentet, fordi det abstraherer JobScheduler, AlarmManager og BroadcastReceivers, samtidig med at det integrerer direkte med operativsystemets begrænsninger. WorkManager gør det muligt at deklarere strenge forudsætninger for kørsel (såsom NetworkType.CONNECTED, requiresBatteryNotLow(true)) og udskyder automatisk kørslen til Doze-vedligeholdelsesvinduer, eller indtil forbindelsen er genoprettet. For at modstå uventet procesafslutning, forbigående netværksudfald og OEM-nedlukninger skal synkroniseringsmotoren overholde to grundlæggende principper: eksponentiel backoff og fuldstændig idempotens. WorkManager bør konfigureres med BackoffPolicy.EXPONENTIAL for at undgå thundering herd-problemer på backendservere ved genetablering efter Doze. Derudover skal workers behandle synkroniseringshandlinger som atomare og idempotente — ved hjælp af deterministiske transaktions-ID'er, lokale tilstandsflag og dedupliceringsnøgler på serversiden — så hvis en worker pludseligt afsluttes midtvejs og sættes i kø igen, vil et nyt forsøg hverken duplikere data eller ødelægge lokale databaser.
20Hvordan designer du en skalerbar Android-arkitektur til flere teams ved hjælp af 'API-Implementation'-moduladskillelsesmønstret for at optimere Gradle-byggetider og håndhæve stringente kontraktgrænser?
I en enterprise-Android-kodebase med flere teams opdeler API-Implementation-mønstret (API-Impl) hvert funktions- eller domænemodul i to separate Gradle-underprojekter: et letvægts `:feature:api`-modul, der indeholder offentlige grænseflader, modeller og navigationskontrakter, og et `:feature:impl`-modul, der indeholder intern forretningslogik, UI og repository-implementationer. Forbrugende moduler afhænger udelukkende af `:feature:api` ved hjælp af `implementation project(':feature:api')`, mens rodmodulet `:app` eller dedikerede sammensætningsrødder forbinder konkrete implementationer via Dependency Injection (f.eks. Dagger/Hilt). Dette mønster optimerer Gradle-byggeydelsen markant gennem ABI-stabilitet (Application Binary Interface) og isolering af kompilerings-classpathen. Når udviklere ændrer implementationsdetaljer i `:feature:impl`, forbliver det offentlige ABI for `:feature:api` uændret. Som følge heraf springer Gradle genkompilering over for alle nedstrømsmoduler, der kun afhænger af `:feature:api`, hvilket maksimerer effektiviteten af Gradle Remote Build Cache og konfigurationscachen. Fra et organisatorisk og styringsmæssigt perspektiv etablerer dette mønster klare ejerskabsskillelinjer på tværs af teams ved hjælp af værktøjer som CODEOWNERS. Teams kan trygt videreudvikle deres interne implementationsdetaljer uden at eksponere private klasser, hvilket forhindrer uønsket tæt kobling og cirkulære afhængigheder på tværs af store teams.