Android में आप networking को कैसे handle करते हैं?

Question

Accepted Answer

Android apps अक्सर network पर **APIs** से संवाद करती हैं। standard दृष्टिकोण **Retrofit** (REST client) और **OkHttp** जैसी libraries का उपयोग करता है, async के लिए coroutines, और JSON parsing के साथ — network calls को clean और सही ढंग से main thread से बाहर handle करता है।

## Retrofit — 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 एक REST API को एक clean Kotlin interface में बदल देता है; coroutines के साथ, calls async और क्रमिक दिखने वाली होती हैं; converters JSON↔object parsing handle करते हैं।

## मुख्य अवधारणाएँ और सर्वोत्तम अभ्यास

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

## यह क्यों महत्वपूर्ण है

Android में networking को समझना ज़रूरी है क्योंकि **अधिकांश apps backends से संवाद करती हैं** — network पर डेटा fetch करना और भेजना लगभग सार्वभौमिक ज़रूरत है, इसलिए यह अनिवार्य रूप से जानने योग्य व्यावहारिक ज्ञान है।

Apps निरंतर API calls करती हैं (डेटा load करना, forms submit करना, authentication), और Android के पास एक standard, परिपक्व दृष्टिकोण है। **Retrofit** (standard REST client) केंद्रीय है: यह एक REST API को एक clean Kotlin **interface** में बदल देता है, और **coroutines** (calls को async और क्रमिक दिखने वाली बनाना) तथा **converters** (JSON-to-object parsing handle करना) के साथ मिलकर, यह network calls करने का एक clean, productive तरीका प्रदान करता है — इसे समझना आधुनिक Android networking के लिए ज़रूरी है।

**मुख्य अवधारणाओं और सर्वोत्तम अभ्यासों** को समझना महत्वपूर्ण है: network calls को **main thread से बाहर** चलाना (coroutines और Dispatchers.IO के माध्यम से, कभी UI block न करना — एक मौलिक आवश्यकता, क्योंकि blocking से ANR होता है), **OkHttp** features का उपयोग (auth headers और logging के लिए interceptors, timeouts, caching), data classes में **JSON parsing** (Gson, Moshi, या kotlinx.serialization के माध्यम से), errors को gracefully **handle करना** (network failures, non-2xx responses, timeouts — UI feedback प्रदान करना, क्योंकि network calls आमतौर पर विफल होती हैं), **repository pattern** का उपयोग (networking को एक clean, testable interface के पीछे abstract करना), **loading/error/success states** दिखाना, और **internet permission** घोषित करना।

ये नाज़ुक ad-hoc calls के बजाय robust, well-architected networking बनाने को दर्शाते हैं।

चूँकि अधिकांश Android apps APIs से संवाद करती हैं (लगभग सार्वभौमिक ज़रूरत) और इसे अच्छी तरह करना (Retrofit + coroutines, main thread से बाहर, उचित JSON parsing, error handling, और architecture के साथ) functional, robust apps के लिए ज़रूरी है, और चूँकि standard tools और practices को समझना इस core क्षमता के लिए आवश्यक है, इसलिए Android में networking को समझना ज़रूरी, बार-बार लागू होने वाला व्यावहारिक ज्ञान है — लगभग हर वास्तविक Android app में आवश्यक एक मौलिक कौशल जो किसी backend से संवाद करती है, ऐसी apps बनाने के केंद्र में जो वास्तविक डेटा को विश्वसनीय रूप से fetch और display करती हैं।