Conexiones con API REST en Android Studio: Volley y Retrofit con Kotlin

La conexión con servicios web y APIs REST es el núcleo de prácticamente cualquier aplicación moderna en Android. Ya sea para autenticar usuarios, sincronizar una base de datos en la nube, consultar pronósticos del tiempo o consumir datos de una tienda online, nuestras apps necesitan comunicarse de forma asíncrona, segura y eficiente con servidores remotos.

¿Cómo funciona una API REST en Android?

Una API REST (Representational State Transfer) expone puntos de acceso o endpoints mediante el protocolo HTTP(S). Cada operación utiliza un verbo estándar:

• GET: Para obtener recursos o listados (ej. /api/productos).
• POST: Para enviar información o crear un nuevo registro (ej. /api/login o /api/usuarios).
• PUT / PATCH: Para actualizar datos existentes.
• DELETE: Para eliminar un recurso.

Normalmente los servicios web devuelven la respuesta en formato JSON, por lo que necesitaremos parsear ese flujo de texto a modelos de datos (objetos o data class en Kotlin). Si quieres repasar cómo procesar JSON, echa un vistazo al vídeo práctico de Walkiria Apps: trabajar con JSON en Android Studio.

Opción 1: Conexión mediante Google Volley

Volley es una biblioteca desarrollada por Google para gestionar peticiones de red en Android. Se encarga automáticamente de encolar las solicitudes, gestionar la caché y ejecutar las respuestas en el hilo principal (UI thread), ideal para proyectos rápidos y ligeros.

Para incluir la dependencia oficial de Volley en tu archivo build.gradle.kts (o build.gradle):

// Dependencia oficial de Google Volley
implementation("com.android.volley:volley:1.2.1")

Ejemplo de una petición POST enviando parámetros con Volley:

val queue = Volley.newRequestQueue(context)
val url = "https://api.tudominio.com/login"

val stringRequest = object : StringRequest(
    Method.POST, url,
    Response.Listener { response ->
        // Manejar la respuesta del servidor (JSON String)
        try {
            val jsonObject = JSONObject(response)
            val success = jsonObject.getBoolean("success")
        } catch (e: JSONException) {
            e.printStackTrace()
        }
    },
    Response.ErrorListener { error ->
        // Manejar error de red o servidor
        error.printStackTrace()
    }
) {
    override fun getParams(): MutableMap<String, String> {
        val params = HashMap<String, String>()
        params["username"] = "usuario"
        params["password"] = "claveSegura"
        return params
    }
}

stringRequest.setShouldCache(false)
queue.add(stringRequest)

Opción 2: El Estándar Moderno con Retrofit y Corrutinas de Kotlin

En el ecosistema profesional de Android, la combinación de Retrofit (de Square) + Kotlin Coroutines es el estándar preferido por su tipado seguro, legibilidad y conversión automática mediante Gson o Moshi:

// Dependencias de Retrofit y conversor Gson
implementation("com.squareup.retrofit2:retrofit:2.11.0")
implementation("com.squareup.retrofit2:converter-gson:2.11.0")

Defines tu interfaz de endpoints de forma declarativa con funciones suspendidas (suspend):

data class UsuarioResponse(val id: Int, val nombre: String, val email: String)

interface ApiService {
    @GET("usuarios/{id}")
    suspend fun getUsuario(@Path("id") id: Int): Response<UsuarioResponse>
}

Y realizas la llamada desde una corrutina (como lifecycleScope.launch en tu Activity o viewModelScope en tu ViewModel) sin bloquear jamás la interfaz gráfica:

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

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

lifecycleScope.launch {
    try {
        val response = api.getUsuario(42)
        if (response.isSuccessful) {
            val user = response.body()
            // Actualizar la interfaz de usuario con los datos
        }
    } catch (e: Exception) {
        // Error de conexión o timeout
    }
}

Vídeo Tutorial Práctico: Conexión Paso a Paso

En mi clase en vídeo de YouTube te muestro paso a paso la arquitectura de comunicación, cómo depurar respuestas y cómo aislar las llamadas de red para tener un código limpio y mantenible: