คุณจัดการเรื่อง networking ใน Android อย่างไร?

Question

Accepted Answer

แอป Android มักสื่อสารกับ **API** ผ่านเครือข่ายอยู่เสมอ แนวทางมาตรฐานคือการใช้ไลบรารีอย่าง **Retrofit** (REST client) และ **OkHttp** ร่วมกับ coroutines สำหรับงาน async และการ parse JSON ซึ่งช่วยจัดการ network call ได้อย่างสะอาดและถูกต้องนอก main thread

## Retrofit — 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 ให้กลายเป็น Kotlin interface ที่สะอาด เมื่อใช้ร่วมกับ coroutines การเรียกจะเป็นแบบ async แต่อ่านดูเหมือนเขียนตามลำดับ และ converter จะจัดการการ parse ระหว่าง JSON กับ object

## แนวคิดสำคัญและแนวทางปฏิบัติที่ดี

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

## ทำไมจึงสำคัญ

การเข้าใจ networking ใน Android เป็นสิ่งจำเป็นเพราะ **แอปส่วนใหญ่ต้องสื่อสารกับ backend** การดึงและส่งข้อมูลผ่านเครือข่ายเป็นความต้องการที่แทบจะสากล จึงเป็นความรู้เชิงปฏิบัติที่ต้องรู้

แอปทำการเรียก API อยู่ตลอดเวลา (โหลดข้อมูล ส่งฟอร์ม การยืนยันตัวตน) และ Android มีแนวทางมาตรฐานที่สมบูรณ์ **Retrofit** (REST client มาตรฐาน) เป็นหัวใจสำคัญ มันเปลี่ยน REST API ให้เป็น Kotlin **interface** ที่สะอาด และเมื่อรวมกับ **coroutines** (ทำให้การเรียกเป็น async แต่อ่านดูเหมือนตามลำดับ) และ **converter** (จัดการการ parse จาก JSON เป็น object) ก็ให้วิธีที่สะอาดและมีประสิทธิภาพในการทำ network call การเข้าใจมันจึงเป็นสิ่งจำเป็นสำหรับ networking ใน Android ยุคใหม่

การเข้าใจ **แนวคิดสำคัญและแนวทางปฏิบัติที่ดี** เป็นเรื่องสำคัญ ได้แก่ การทำ network call **นอก main thread** (ผ่าน coroutines และ Dispatchers.IO ไม่บล็อก UI เด็ดขาด ซึ่งเป็นข้อกำหนดพื้นฐาน เพราะการบล็อกทำให้เกิด ANR) การใช้ฟีเจอร์ของ **OkHttp** (interceptor สำหรับ auth header และ logging, timeout, caching) การ **parse JSON** เป็น data class (ผ่าน Gson, Moshi หรือ kotlinx.serialization) การ **จัดการ error** อย่างนุ่มนวล (network ล้มเหลว, response ที่ไม่ใช่ 2xx, timeout โดยให้ feedback กับ UI เพราะ network call มักล้มเหลว) การใช้ **repository pattern** (ซ่อน networking ไว้หลัง interface ที่สะอาดและทดสอบได้) การแสดง **state แบบ loading/error/success** และการประกาศ **internet permission**

สิ่งเหล่านี้สะท้อนการสร้าง networking ที่แข็งแกร่งและออกแบบมาดี แทนการเรียกแบบ ad-hoc ที่เปราะบาง

เนื่องจากแอป Android ส่วนใหญ่สื่อสารกับ API (ความต้องการที่แทบจะสากล) และการทำมันให้ดี (Retrofit + coroutines นอก main thread พร้อมการ parse JSON การจัดการ error และสถาปัตยกรรมที่เหมาะสม) เป็นสิ่งจำเป็นสำหรับแอปที่ทำงานได้และแข็งแกร่ง และเนื่องจากการเข้าใจเครื่องมือและแนวปฏิบัติมาตรฐานเป็นสิ่งจำเป็นต่อความสามารถหลักนี้ การเข้าใจ networking ใน Android จึงเป็นความรู้เชิงปฏิบัติที่จำเป็นและถูกใช้บ่อย เป็นทักษะพื้นฐานที่ต้องมีในแทบทุกแอป Android จริงที่สื่อสารกับ backend และเป็นหัวใจของการสร้างแอปที่ดึงและแสดงข้อมูลจริงได้อย่างเชื่อถือได้