Como consumir API de CPF em Kotlin para aplicações Android nativas

dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
    implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

<uses-permission android:name="android.permission.INTERNET" />

data class CpfResponse(
    val success: Boolean,
    val data: CpfData?
)

data class CpfData(
    val cpf: String,
    val name: String,
    val nameUpper: String,
    val gender: String,
    val birthDate: String,
    val day: Int,
    val month: Int,
    val year: Int
)

{
    "success": true,
    "data": {
    "cpf": "12345678900",
    "name": "João da Silva",
    "nameUpper": "JOÃO DA SILVA",
    "gender": "M",
    "birthDate": "15/06/1990",
    "day": 15,
    "month": 6,
    "year": 1990
    }
}

import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Path

interface CpfHubService {

    @GET("cpf/{cpf}")
    suspend fun consultarCpf(
    @Path("cpf") cpf: String,
    @Header("x-api-key") apiKey: String,
    @Header("Accept") accept: String = "application/json"
    ): CpfResponse
}

import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit

object CpfHubClient {

    private const val BASE_URL = "https://api.cpfhub.io/"

    private val loggingInterceptor = HttpLoggingInterceptor().apply {
    level = HttpLoggingInterceptor.Level.BODY
    }

    private val httpClient = OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .writeTimeout(10, TimeUnit.SECONDS)
    .addInterceptor(loggingInterceptor)
    .build()

    private val retrofit = Retrofit.Builder()
    .baseUrl(BASE_URL)
    .client(httpClient)
    .addConverterFactory(GsonConverterFactory.create())
    .build()

    val service: CpfHubService = retrofit.create(CpfHubService::class.java)
}

class CpfRepository {

    private val service = CpfHubClient.service

    suspend fun consultar(cpf: String, apiKey: String): Result<CpfData> {
    return try {
    val response = service.consultarCpf(cpf, apiKey)
    if (response.success && response.data != null) {
    Result.success(response.data)
    } else {
    Result.failure(Exception("CPF não encontrado ou inválido."))
    }
    } catch (e: Exception) {
    Result.failure(e)
    }
    }
}

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class CpfViewModel : ViewModel() {

    private val repository = CpfRepository()

    private val _estado = MutableStateFlow<CpfEstado>(CpfEstado.Idle)
    val estado: StateFlow<CpfEstado> = _estado

    fun consultarCpf(cpf: String) {
    val cpfLimpo = cpf.replace(Regex("\\D"), "")
    if (cpfLimpo.length != 11) {
    _estado.value = CpfEstado.Erro("CPF deve ter 11 dígitos.")
    return
    }

    _estado.value = CpfEstado.Carregando

    viewModelScope.launch {
    val resultado = repository.consultar(cpfLimpo, "SUA_CHAVE_DE_API")
    resultado.fold(
    onSuccess = { dados ->
    _estado.value = CpfEstado.Sucesso(dados)
    },
    onFailure = { erro ->
    _estado.value = CpfEstado.Erro(
    erro.message ?: "Erro desconhecido."
    )
    }
    )
    }
    }
}

sealed class CpfEstado {
    object Idle : CpfEstado()
    object Carregando : CpfEstado()
    data class Sucesso(val dados: CpfData) : CpfEstado()
    data class Erro(val mensagem: String) : CpfEstado()
}

import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {

    private val viewModel: CpfViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    lifecycleScope.launch {
    viewModel.estado.collectLatest { estado ->
    when (estado) {
    is CpfEstado.Idle -> { /* Estado inicial */ }
    is CpfEstado.Carregando -> {
    // Mostrar indicador de carregamento
    }
    is CpfEstado.Sucesso -> {
    val dados = estado.dados
    // Exibir nome, data de nascimento, gênero
    }
    is CpfEstado.Erro -> {
    // Exibir mensagem de erro
    }
    }
    }
    }

    // Ao clicar no botão de consulta
    // viewModel.consultarCpf(editTextCpf.text.toString())
    }
}