How do you handle networking in Android?

Question

Accepted Answer

Android apps frequently communicate with **APIs** over the network. The standard approach uses libraries like **Retrofit** (REST client) and **OkHttp**, with coroutines for async, and JSON parsing — handling network calls cleanly and correctly off the main thread.

## Retrofit — the standard REST client

```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 turns a REST API into a clean Kotlin interface; with coroutines, calls are async and sequential-looking; converters handle JSON↔object parsing.

## Key concepts and 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
```

## Why it matters

Understanding networking in Android is essential because **most apps communicate with backends** — fetching and sending data over the network is a near-universal need, so it's must-know practical knowledge.

Apps constantly make API calls (loading data, submitting forms, authentication), and Android has a standard, mature approach. **Retrofit** (the standard REST client) is central: it turns a REST API into a clean Kotlin **interface**, and combined with **coroutines** (making calls async and sequential-looking) and **converters** (handling JSON-to-object parsing), it provides a clean, productive way to make network calls — understanding it is essential for modern Android networking.

Understanding the **key concepts and best practices** is important: running network calls **off the main thread** (via coroutines and Dispatchers.IO, never blocking the UI — a fundamental requirement, since blocking causes ANR), using **OkHttp** features (interceptors for auth headers and logging, timeouts, caching), **JSON parsing** into data classes (via Gson, Moshi, or kotlinx.serialization), **handling errors** gracefully (network failures, non-2xx responses, timeouts — providing UI feedback, since network calls commonly fail), using the **repository pattern** (abstracting networking behind a clean, testable interface), showing **loading/error/success states**, and declaring the **internet permission**.

These reflect building robust, well-architected networking rather than fragile ad-hoc calls.

Since most Android apps communicate with APIs (a near-universal need) and doing it well (Retrofit + coroutines, off the main thread, with proper JSON parsing, error handling, and architecture) is essential for functional, robust apps, and since understanding the standard tools and practices is necessary for this core capability, understanding networking in Android is essential, frequently-applied practical knowledge — a fundamental skill needed in virtually every real Android app that communicates with a backend, central to building apps that reliably fetch and display real data.