Kako upravljaš mrežom u Androidu?

Question

Accepted Answer

Android aplikacije često komuniciraju s **API-jima** preko mreže. Standardni pristup koristi biblioteke kao što su **Retrofit** (REST klijent) i **OkHttp**, s coroutine-ima za asinkronost i JSON parsing — čisto i ispravno rukovanje mrežnim pozivima izvan glavne niti.

## Retrofit — standardni REST klijent

```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 pretvara REST API u čist Kotlin interface; s coroutine-ima, pozivi su asinkroni i izgledaju sekvencijalno; converter-i rukovode JSON↔object parsing-om.

## Ključni koncepti i najbolje prakse

```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
```

## Zašto je važno

Razumijevanje mrežnog rada u Androidu je esencijalno jer **većina aplikacija komunicira s backend-ima** — slanje i primanje podataka preko mreže je gotovo univerzalna potreba, pa je to mora-znati praktično znanje.

Aplikacije stalno rade API pozive (učitavanje podataka, slanje obrazaca, autentifikacija), a Android ima standardan, zreo pristup. **Retrofit** (standardni REST klijent) je centralan: pretvara REST API u čist Kotlin **interface**, a kombiniran s **coroutine-ima** (što čini pozive asinkroni i sekvencijalno izgledajućima) i **converter-ima** (rukovođenje JSON-u-u-objekt parsing-om), pruža čist, produktivan način za mrežne pozive — razumijevanje toga je esencijalno za moderni Android networking.

Razumijevanje **ključnih koncepata i najboljih praksi** je važno: pokretanje mrežnih poziva **izvan glavne niti** (putem coroutine-ima i Dispatchers.IO, nikad blokiranje UI-a — fundamentalni zahtjev, jer blokiranje uzrokuje ANR), korištenje **OkHttp** značajki (interceptor-i za auth header-e i logging, timeout-i, caching), **JSON parsing** u data klase (putem Gson, Moshi ili kotlinx.serialization), **rukovanje greškama** s elegancijom (mrežni kvarovi, non-2xx odgovori, timeout-i — pružanje UI povratne informacije, jer mrežni pozivi često padaju), korištenje **repository pattern-a** (apstrakcija mrežnog rada iza čistog, testabilnog interface-a), prikazivanje **loading/error/success state-a**, i deklariranje **internet permission-a**.

To odražava robusno, dobro-arhitekturo mrežnu komunikaciju umjesto krhkih ad-hoc poziva.

Budući da većina Android aplikacija komunicira s API-jima (gotovo univerzalna potreba) i činiti to dobro (Retrofit + coroutine-i, izvan glavne niti, s pravilnim JSON parsing-om, rukovanje greškama i arhitekturom) je esencijalno za funkcionalne, robusne aplikacije, i budući da razumijevanje standardnih alata i praksi je neophodno za ovu temeljnu mogućnost, razumijevanje mrežnog rada u Androidu je esencijalno, često primijenjeno praktično znanje — temeljna vještina potrebna u gotovo svakoj stvarnoj Android aplikaciji koja komunicira s backend-om, ključna za izgradnju aplikacija koje pouzdano dohvaćaju i prikazuju stvarne podatke.