Kotlin Coroutine và android-async-http: Giải Pháp Tối Ưu Cho Mạng Android Hiện Đại

Việc xử lý yêu cầu mạng trong Android thường đối mặt với thách thức như callback hell, rò rỉ bộ nhớ và quản lý luồng phức tạp. Bài viết này trình bày cách kết hợp thư viện mạng truyền thống android-async-http với Kotlin coroutine để xây dựng hệ thống mạng mạnh mẽ và dễ bảo trì. Bạn sẽ học được:

• Ưu điểm và hạn chế của android-async-http
• Cách sử dụng Kotlin coroutine cơ bản
• Phương pháp tích hợp hai công cụ
• Các thực hành tốt nhất cho hệ thống mạng

Khả năng chính của android-async-http

Thư viện android-async-http, ra đời từ năm 2011, vẫn được ưa chuộng nhờ những tính năng nổi bật:

• Xử lý yêu cầu bất đồng bộ tự động trên luồng nền
• Quản lý nhóm luồng hiệu quả với cấu hình tối ưu
• Cơ chế thử lại yêu cầu tự động cho mạng không ổn định
• Hỗ trợ nén GZIP trong quá trình truyền dữ liệu
• Đa dạng handler xử lý phản hồi (JSON, nhị phân, tập tin)

Phiên bản callback truyền thống:

AsyncHttpClient httpClient = new AsyncHttpClient();
httpClient.get("https://api.example.com/data", new AsyncHttpResponseHandler() {
    @Override
    public void onSuccess(int status, Header[] headers, byte[] data) {
        // Xử lý dữ liệu thành công
    }
    
    @Override
    public void onFailure(int status, Header[] headers, byte[] data, Exception exception) {
        // Xử lý lỗi
    }
});

Kotlin Coroutine cơ bản

Kotlin coroutine cung cấp cách viết mã đồng bộ cho tác vụ bất đồng bộ, giải quyết vấn đề callback hell:

• Cấu trúc mã đơn giản hơn
• Quản lý vòng đời tự động
• Cơ chế hủy yêu cầu linh hoạt
• Xử lý ngoại lệ tập trung

Ví dụ cơ bản:

// Khởi động coroutine
lifecycleScope.launch {
    try {
        val user = fetchUserDetails()
        updateUI(user)
    } catch (e: Exception) {
        handleException(e)
    }
}

suspend fun fetchUserDetails(): User = withContext(Dispatchers.IO) {
    // Gọi API mạng
}

Tích hợp hai công cụ

Chuyển đổi API callback thành suspend function qua Continuation:

suspend fun AsyncHttpClient.executeRequest(
    endpoint: String,
    headers: List<Header>? = null
): Result = suspendCancellableCoroutine { cont ->
    val handler = object : AsyncHttpResponseHandler() {
        override fun onSuccess(status: Int, headers: Array<Header>?, body: ByteArray?) {
            if (cont.isActive) {
                body?.let {
                    cont.resume(Result.success(it))
                } ?: cont.resume(Result.failure(IllegalStateException("Body rỗng")))
            }
        }
        
        override fun onFailure(status: Int, headers: Array<Header>?, body: ByteArray?, exception: Throwable) {
            if (cont.isActive) {
                cont.resume(Result.failure(exception))
            }
        }
    }
    
    val activeRequest = get(endpoint, headers?.toTypedArray(), handler)
    cont.invokeOnCancellation { activeRequest.cancel(true) }
}

Ứng dụng thực tế trong Repository:

class NetworkRepository(private val context: Context) {
    private val client = AsyncHttpClient()
    
    init {
        client.setCookieStore(PersistentCookieStore(context))
    }
    
    suspend fun getUserData(id: String): UserData {
        return withContext(Dispatchers.IO) {
            val url = "https://api.example.com/users/$id"
            val result = client.executeRequest(url)
            
            result.fold(
                onSuccess = { body ->
                    JsonParser.parseString(String(body, Charsets.UTF_8))
                        .parseObject(UserData::class.java)
                },
                onFailure = { error ->
                    when (error) {
                        is IOException -> throw NetworkException("Lỗi kết nối", error)
                        else -> throw DataException("Phân tích dữ liệu thất bại", error)
                    }
                }
            )
        }
    }
    
    fun cancelAll() {
        client.cancelAllRequests(true)
    }
}

Trong ViewModel:

class UserViewModel(private val repository: NetworkRepository) : ViewModel() {
    private val _userData = MutableLiveData()
    val userData: LiveData = _userData
    
    fun loadUserData(userId: String) {
        viewModelScope.launch {
            _userData.value = try {
                Result.success(repository.getUserData(userId))
            } catch (e: Exception) {
                Result.failure(e)
            }
        }
    }
    
    override fun onCleared() {
        super.onCleared()
        repository.cancelAll()
    }
}

Thực hành nâng cao

Điều khiển thời gian chờ:

suspend fun fetchDataWithTimeout() {
    withTimeout(10_000) {
        val client = AsyncHttpClient()
        client.setTimeout(8_000)
        val result = client.executeRequest("https://api.example.com/data")
        // Xử lý kết quả
    }
}

Xử lý yêu cầu song song:

suspend fun fetchMultipleData() {
    viewModelScope.launch {
        val deferred1 = async { repository.fetchData("type1") }
        val deferred2 = async { repository.fetchData("type2") }
        val results = awaitAll(deferred1, deferred2)
        processResults(results)
    }
}