Como consumir APIs com Retrofit no Android

Você sabia que há a possibilidade de consumir APIs com Retrofit no Android? É sobre isso que falaremos neste texto, mas antes, é necessário saber que o Retrofit é uma biblioteca desenvolvida pela Square. Além disso, simplifica a comunicação com servidores HTTP e converte automaticamente as respostas em objetos Java.

Neste artigo, vamos nos aprofundar no tema e explorar como configurar e utilizar o Retrofit para consumir APIs em um aplicativo Android.

O que é Retrofit?

O Retrofit é uma biblioteca desenvolvida pela Square para facilitar a comunicação entre aplicativos Android e APIs RESTful. Ele simplifica o processo de realizar requisições HTTP, convertendo automaticamente os dados recebidos em objetos Java, ou seja, isso torna o código mais organizado e fácil de manter. Também oferece suporte a diferentes conversores, como Gson e Moshi, permitindo trabalhar com diferentes formatos de dados.

Diferente de outras abordagens, como HttpURLConnection ou Volley, o Retrofit utiliza interfaces para definir endpoints, fazendo com que as chamadas de API sejam mais intuitivas. Ao mesmo tempo, permite o uso de anotações para especificar detalhes das requisições, como métodos HTTP (GET, POST, PUT, DELETE), parâmetros de URL e cabeçalhos. Isso torna o código mais modular e reutilizável.

Outra grande vantagem por aqui se dá em sua compatibilidade com chamadas síncronas e assíncronas. Enquanto as chamadas síncronas podem ser úteis em algumas situações, a abordagem assíncrona evita bloqueios na UI, garantindo uma experiência mais fluida para o usuário. E não para por aí, já que a ferramenta se integra facilmente com bibliotecas como RxJava e Kotlin Coroutines para um melhor gerenciamento de concorrência.

Então, com sua facilidade de uso, flexibilidade e suporte a recursos avançados, ele se tornou a escolha preferida para desenvolvedores Android que precisam consumir APIs de forma eficiente e escalável. Agora vamos entender como configurá-lo de maneira correta, para não ter problemas dentro de seu projeto.

Configuração em seu projeto Retrofit no Android

Antes de começar a consumir APIs, é necessário adicionar o Retrofit no Android. Portanto, siga os passos abaixo:

1. Adicionar Dependências no build.gradle

No arquivo build.gradle do módulo (geralmente app/build.gradle), adicione as seguintes dependências:

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.google.code.gson:gson:2.8.6'

O Retrofit sozinho lida apenas com requisições HTTP. Para converter os dados JSON em objetos Java, utilizamos o converter-gson, que faz a conversão automática usando a biblioteca Gson.

2. Permissões no Manifest

Se a API estiver na internet, é necessário permitir acesso à internet no AndroidManifest.xml:

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

Criando a interface da API

O Retrofit trabalha com interfaces para definir os endpoints da API. Então, suponha que queremos consumir uma API que retorna uma lista de usuários. Crie uma interface chamada ApiService.java:

import retrofit2.Call;
import retrofit2.http.GET;
import java.util.List;

public interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();
}

Cada método representa uma chamada HTTP. Ou seja, no exemplo acima, o método getUsers() realiza uma requisição GET para o endpoint users.

Criando o cliente Retrofit

Para utilizar o Retrofit, precisamos instanciá-lo e configurar a URL base da API. Desta forma, molde uma classe chamada RetrofitClient.java:

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {
    private static Retrofit retrofit;
    private static final String BASE_URL = "https://jsonplaceholder.typicode.com/";

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

Criando o modelo de Dados

O Retrofit converte automaticamente os dados JSON em objetos Java. Para isso, criamos um modelo de dados correspondente à resposta da API.

Crie uma classe User.java:

public class User {
    private int id;
    private String name;
    private String username;
    private String email;

    // Getters e Setters
    public int getId() { return id; }
    public String getName() { return name; }
    public String getUsername() { return username; }
    public String getEmail() { return email; }
}

Fazendo a requisição na Activity

Agora que temos o Retrofit configurado, podemos fazer a requisição dentro da MainActivity.java:

import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ApiService apiService = RetrofitClient.getRetrofitInstance().create(ApiService.class);
        Call<List<User>> call = apiService.getUsers();

        call.enqueue(new Callback<List<User>>() {
            @Override
            public void onResponse(Call<List<User>> call, Response<List<User>> response) {
                if (response.isSuccessful()) {
                    List<User> users = response.body();
                    for (User user : users) {
                        Log.d("MainActivity", "Usuário: " + user.getName());
                    }
                }
            }

            @Override
            public void onFailure(Call<List<User>> call, Throwable t) {
                Log.e("MainActivity", "Erro: " + t.getMessage());
            }
        });
    }
}

No código acima, utilizamos enqueue() para executar a requisição de forma assíncrona, evitando bloqueios na UI.

Tratamento de erros

É importante lidar com erros corretamente para melhorar a experiência do usuário. Podemos adicionar um tratamento de erros na onFailure() e verificar o código de resposta HTTP:

@Override
public void onResponse(Call<List<User>> call, Response<List<User>> response) {
    if (response.isSuccessful() && response.body() != null) {
        List<User> users = response.body();
        for (User user : users) {
            Log.d("MainActivity", "Usuário: " + user.getName());
        }
    } else {
        Log.e("MainActivity", "Erro na resposta: " + response.code());
    }
}

Enviando dados para a API (POST)

Além de buscar dados, também podemos enviar informações para a API utilizando o método POST.

Adicione o seguinte método na interface ApiService.java:

import retrofit2.http.Body;
import retrofit2.http.POST;

@POST("users")
Call<User> createUser(@Body User user);

Agora, podemos chamar esse método para enviar dados:

User newUser = new User();
newUser.setName("João");
newUser.setUsername("joaosilva");
newUser.setEmail("joao@email.com");

Call<User> call = apiService.createUser(newUser);
call.enqueue(new Callback<User>() {
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful()) {
            Log.d("MainActivity", "Usuário criado: " + response.body().getName());
        }
    }
    @Override
    public void onFailure(Call<User> call, Throwable t) {
        Log.e("MainActivity", "Erro: " + t.getMessage());
    }
});

Benefícios do Retrofit no Android para clientes em geral

Mesmo que os usuários finais não conheçam diretamente essa biblioteca, ela impacta significativamente sua experiência ao utilizar aplicativos móveis. A princípio, a grande vantagem é sua simplicidade e eficiência na integração com APIs, pois os desenvolvedores poderão realizar requisições HTTP de forma estruturada e otimizada, garantindo que os aplicativos enviem dados de maneira confiável.

Ao mesmo tempo, a biblioteca gerencia requisições de rede de forma eficiente, evitando erros comuns como falhas de conexão ou carregamentos intermináveis. Isso significa que, ao abrir um aplicativo para verificar uma notícia, fazer uma compra online ou acessar um serviço de transporte, o usuário pode ter uma resposta ágil e confiável.

Segurança e manutenção dos apps

Outro ponto é a segurança. O Retrofit permite a implementação de práticas seguras, como autenticação de usuários e criptografia de dados, garantindo que informações sensíveis não fiquem expostas a ataques cibernéticos.

A ferramenta contribui também para a manutenção e evolução dos aplicativos, pois facilita a organização e a escalabilidade do código, os desenvolvedores conseguem corrigir problemas e adicionar novas funcionalidades de forma mais ágil. Isso significa que os usuários recebem atualizações frequentes e melhorias contínuas, tornando os aplicativos mais estáveis e com novas funcionalidades ao longo do tempo.

Outro impacto direto para os usuários está na compatibilidade e suporte a diferentes dispositivos. Nestes casos, os aplicativos irão desempenhar um papel uniforme em diferentes modelos de smartphones e versões do Android. Isso evita problemas como falhas em determinados aparelhos ou incompatibilidades ao longo do tempo.

Portanto, mesmo que os usuários não saibam exatamente o que é o Retrofit, eles colhem os benefícios dessa tecnologia diariamente. Desde a rapidez no carregamento das informações até a segurança e estabilidade dos aplicativos, essa ferramenta desempenha um papel fundamental na experiência digital moderna.

Com a crescente demanda por aplicativos cada vez mais rápidos e seguros, ferramentas como o Retrofit se tornam indispensáveis no ecossistema Android. Seu uso não apenas facilita a vida dos programadores, mas também garante que os usuários tenham uma experiência fluida, confiável e otimizada ao interagir com seus aplicativos favoritos.