What experience do you have in developing native…

I have experience working with various approaches:

HttpURLConnection: A basic class providing direct access to HTTP. Requires manual handling of streams, JSON/XML parsing, thread pool management. Suitable for simple requests or deep understanding of network operations.
Apache HttpClient: A popular library before Android 6.0 (API 23). Offered a more convenient API compared to HttpURLConnection, but had support issues in newer Android versions.

Volley: A library from Google designed for fast network operations. Simplifies requests, caching, image handling. Used for medium complexity applications.

// Example of using Volley
val queue = Volley.newRequestQueue(context)
val url = "https://api.example.com/data"
val stringRequest = StringRequest(Request.Method.GET, url,
    Response.Listener<String> { response ->
        // Handle successful response
    },
    Response.ErrorListener { error ->
        // Handle error
    })
queue.add(stringRequest)

Retrofit: A type-safe HTTP client from Square built on OkHttp. Significantly simplifies REST API interactions through a declarative approach and customization options (converters, interceptors). The preferred choice for most modern applications.

interface ApiService {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") userId: Int): User
}

// Creating Retrofit client
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val apiService = retrofit.create(ApiService::class.java)

// Making a request with coroutines
GlobalScope.launch {
    try {
        val user = apiService.getUser(1)
        // Handle data
    } catch (e: Exception) {
        // Handle error
    }
}

OkHttp: A powerful and efficient HTTP client. Forms the basis of Retrofit and other libraries. Excellent for low-level request management, HTTP/2 support, caching, interceptors.
Working with Multipart requests: Sending files and data in a single request.
Error handling: Implemented mechanisms for intercepting and handling API errors (e.g., HTTP status codes, custom server errors).
Response caching: Applied caching strategies to improve performance (e.g., HTTP-level or app-level caching).
Timeouts and retries: Configured timeout parameters and implemented retry logic for transient network issues.
Security: Worked with HTTPS, certificate validation.

Comparison of popular libraries:

Library	Foundation	Type safety	Complexity	Usage
HttpURLConnection	Java/Android API	No	High	Low-level access
Volley	Custom	No	Medium	Simple/medium applications
Retrofit	OkHttp	Yes	Low	REST API, modern applications
OkHttp	Custom	Partial	Medium	Low-level management

I prefer to use Retrofit because of its convenience, type safety, and integration with coroutines, which greatly simplifies asynchronous programming. At the same time, I understand and can use OkHttp for more fine-grained control or when Retrofit is not sufficient.

What experience do you have in developing native solutions for implementing network requests on the Android platform?