Hvordan håndterer du networking i Android?

Question

Accepted Answer

Android-apps kommunikerer hyppigt med **APIs** over netværket. Standard-tilgangen bruger biblioteker som **Retrofit** (REST-klient) og **OkHttp**, med coroutines til async, og JSON-parsing — håndtering af netværkskald rent og korrekt uden for hovedtråden.

## Retrofit — standard REST-klienten

```kotlin
// define the API as an interface; Retrofit implements it
interface ApiService {
  @GET("users/{id}")
  suspend fun getUser(@Path("id") id: Int): User    // suspend → coroutine async

@POST("users")
  suspend fun createUser(@Body user: User): User
}

// build Retrofit and use it
val api = Retrofit.Builder()
  .baseUrl("https://api.example.com/")
  .addConverterFactory(GsonConverterFactory.create())   // JSON parsing
  .build()
  .create(ApiService::class.java)

// call it from a coroutine (off the main thread)
viewModelScope.launch {
  val user = api.getUser(42)      // async, clean, returns a parsed User object
}
```

Retrofit omdanner en REST API til en ren Kotlin-interface; med coroutines er kaldene async og ser sekventielle ud; converters håndterer JSON↔objekt-parsing.

## Nøglebegreber og best practices

```text
✓ Run network calls OFF the main thread (coroutines + Dispatchers.IO) — never block UI
✓ OkHttp (under Retrofit) → interceptors (auth headers, logging), timeouts, caching
✓ JSON parsing → Gson / Moshi / kotlinx.serialization (response ↔ data classes)
✓ HANDLE ERRORS — network failures, non-2xx responses, timeouts → graceful UI feedback
✓ Repository pattern → abstract networking behind a clean interface (testable, organized)
✓ Show loading/error/success STATES (with ViewModel + observable state)
✓ INTERNET permission in the manifest
```

## Hvorfor det betyder noget

At forstå networking i Android er afgørende, fordi **de fleste apps kommunikerer med backends** — hentning og afsendelse af data over netværket er et næsten universelt behov, så det er vigtig praktisk viden.

Apps foretager konstant API-kald (indlæsning af data, indsendelse af formularer, godkendelse), og Android har en standard, moden tilgang. **Retrofit** (standard REST-klient) er central: den omdanner en REST API til en ren Kotlin-**interface**, og kombineret med **coroutines** (der gør kaldene async og sekventielt-udseende) og **converters** (der håndterer JSON-til-objekt-parsing), giver den en ren, produktiv måde at foretage netværkskald på — forståelse heraf er vigtig for moderne Android-networking.

Forståelse af **nøglebegreber og best practices** er vigtig: kørsel af netværkskald **uden for hovedtråden** (via coroutines og Dispatchers.IO, aldrig blokering af UI — et grundlæggende krav, da blokering forårsager ANR), brug af **OkHttp**-funktioner (interceptors til auth headers og logging, timeouts, caching), **JSON-parsing** til data classes (via Gson, Moshi eller kotlinx.serialization), **fejlhåndtering** på elegant vis (netværksfejl, non-2xx-svar, timeouts — levering af UI feedback, da netværkskald ofte mislykkes), brug af **repository-mønster** (abstrahering af networking bag en ren, testbar interface), visning af **loading/error/success-tilstande**, og erklæring af **internet-tilladelse**.

Disse afspejler opbygning af robust, velarkitektureret networking snarere end skrøbelig ad-hoc-kald.

Da de fleste Android-apps kommunikerer med APIs (et næsten universelt behov) og at gøre det godt (Retrofit + coroutines, uden for hovedtråden, med korrekt JSON-parsing, fejlhåndtering og arkitektur) er afgørende for funktionelle, robuste apps, og da forståelse af standard-værktøjerne og praksisserne er nødvendig for denne kernefunktionalitet, er forståelse af networking i Android vigtig, hyppigt anvendt praktisk viden — en grundlæggende færdighed, der er nødvendig i praktisk talt enhver rigtig Android-app, der kommunikerer med en backend, central for at opbygge apps, der pålideligt henter og viser rigtige data.