Consumindo APIs em Android com Retrofit e Butter Knife

Esses dias eu estava lendo umas postagens no excelente grupo de programadores Android do Facebook e me deparei com um comentário de um dev que reclamava que os tutoriais na Internet geralmente ensinavam do jeito mais difícil, sem usar bibliotecas que facilitam o trabalho do desenvolvedor e que são muito utilizadas pelas empresas no dia-a-dia dos projetos. Dentre as bibliotecas citadas por ele que deveriam ser ensinadas estavam Retrofit e ButterKnife.

Sinceramente, eu não usava nenhuma das duas até então. Retrofit já estava no meu radar há algum tempo, mas não havia tido a necessidade de usá-la, pois sua utilidade é ser um HTTP Client fortemente tipado para Java e Android, permitindo abstrair APIs em código Java muito facilmente.

Já o ButterKnife eu nunca tinha ouvido falar, mas realmente parece muito útil pois ele permite fazer o binding automático dos componentes visuais em variáveis Java locais, para uso na sua lógica de aplicação. Imagino que deva ter algumas limitações, mas resolvi testar mesmo assim.

O resultado desses estudos originaram este tutorial, onde vou criar um app que consome uma API REST escrita em Node.js e hospedada na Umbler, para fornecer um cadastro de clientes para o usuário.

Veremos neste tutorial completo:

  1. Preparando a API
  2. Criando o app
  3. Usando ButterKnife
  4. Usando Retrofit (em breve)
  5. Fazendo tudo funcionar (em breve)
  6. Indo além! (em breve)

Vamos lá!

Atenção: se este é o primeiro app Android que programa em sua vida, procure fazer este tutorial primeiro.

#1 – Preparando a API

Usarei neste tutorial uma API Node.js que fornece um CRUD sobre uma base de clientes em um MySQL. Se você quiser fazer a API do zero e aproveitar para aprender um pouco de Node.js, esse post aqui ensina tudo que você precisa saber.

Mesmo que não queira aprender a programar Node.js, sugiro acessar o respectivo post, seguir as instruções para criação do banco, baixar o zip do projeto e testar usando o POSTMAN, assim como eu ensino no tutorial (não esqueça de entrar no index.js e editar os dados da conexão MySQL para apontar para o seu banco).

Basicamente usaremos neste tutorial os endpoints abaixo, que você deve testar e se certificar que está funcionando antes de avançar para a próxima etapa:

  • GET /clientes – lista todos os clientes;
  • GET /clientes/{id} – retorna apenas um cliente;
  • POST /clientes – salva um novo cliente (dados no body);
  • PATCH /clientes/{id} – atualizar um cliente existente (dados no body);
  • DELETE /clientes/{id} – exclui um cliente;

O app em si não será muito elaborado, pois o foco é o uso das bibliotecas Retrofit e ButterKnife, mas sim, usaremos todos os endpoints supracitados.

Atencão: não aponte para nenhuma URL que apareça em meus exemplos ou códigos-fonte, pois são bancos e sites de exemplo que geralmente não ficam no ar por muito tempo. Crie a sua infra de teste na sua hospedagem de site, para usar os SEUS endpoints.

Após se certificar de que sua API está funcionando localmente, sugiro hospedá-la em um provedor de hospedagem. Na verdade eu sempre crio os bancos de dados em provedores de hospedagem também, pois não gosto de ter vários servidores de banco instalados em minha máquina consumindo recursos. Particularmente para hospedar Node.js e MySQL eu recomendo a Umbler, pois inclusive bancos MySQL pequenos são de graça e o deploy pode ser feito via Git, como mostro nesse vídeo.

Com a API 100%, vamos em frente!

#2 – Criando o APP

Como faremos uma prova de conceito, esse app não será nem um pouco elaborado. Na parte final deste tutorial darei algumas ideias de como deixá-lo profissional, mas por ora, vamos fazer um app de uma tela só.

Nesta tela poderemos fazer a pesquisa de cliente por id, o cadastro, a atualização e a exclusão de clientes. Para ver se tudo está sendo persistido no banco de dados, usaremos o endpoint “GET /clientes” no navegador mesmo, para que sejam listados todos os clientes e possamos ver se está tudo funcionando como deveria.

Crie um novo projeto no Android Studio (mas pode ser Eclipse ou NetBeans também, com pequenas variações nos passos que vou mostrar) usando o template de Activity Basic, aquele que vem com um botão flutuante no canto inferior direito. Usarei aqui o ConstraintLayout, que já expliquei como funciona em outro post e o nome da minha activity principal é MainActivity.

O Android Studio gera dois arquivos de layout para essa Activity, um chamado activity_main.xml que serve como “arcabouço” ou “esqueleto” para o layout, e o content_main.xml que serve como “miolo” ou  “área interna” do layout. Isso permite uma organização maior do layout bem como reuso de código. Focaremos aqui na construção da interface usando o content_main.xml, que por padrão vem um Hello World que deve ser apagado.

Arraste para esse formulário um campo de edição de texto (id:txtId) com dois botões à sua direita (id:btnBuscar e id:btnExcluir). Logo abaixo, coloque um campo de edição de texto para o nome do cliente (id:txtNome) e outro mais abaixo para o CPF do cliente (id:txtCPF). No final do formulário, coloque um botão de salvar (id:btnSalvar). Crie as constraints necessárias (ou use o recurso Infer Constraints) para que sua tela se pareça com a minha abaixo:

Tela do app
Tela do app

Caso tenha dificuldade, use e/ou consulte os fontes abaixo, do content_main.xml:

Alguns pontos que merecem atenção nesse layout são:

  • os campos de edição de texto possuem “hints”, o que remove a necessidade de usar TextViews para rótulos de campos;
  • os campos de edição de texto possuem inputType, para agilizar a digitação dos valores já exibindo o teclado virtual correto para cada um;

Já na activity_main.xml, fiz duas alterações bem pequenas: troquei o ícone do floating button e troquei o id dele (de fab para btnNovo). O código XML apenas desse componente que foi alterado está abaixo:

Na sequência vamos fazer esta tela funcionar, mesmo que de maneira incompleta usando ButterKnife!

#3 – Usando ButterKnife

Agora que temos a nossa tela pronta, é hora de programarmos ela. Usaremos a biblioteca open-source ButterKnife para nos auxiliar com tarefas repetitivas e muito chatas que são os bindings dos widgets dos layouts XML em variáveis Java locais.

Caso ainda não tenha entendido o ganho que isso traz, imagina que a seguinte linha de código:

é substituída por:

Visualmente pode não parecer grande coisa, mas esta declaração é feita no topo da classe da Activity, o que permite que esse componente seja usado em toda a classe. Além disso, essa biblioteca é extremamente performática pois não usa Reflection, mas sim um transpilador das anotações para código Java nativo de binding que não serve apenas para binding de campos mas também de cores, strings, imagens, etc.

Mas antes de sairmos aproveitando tudo o que a biblioteca tem a oferecer, precisamos adicionar a sua dependência ao nosso projeto, modificando nosso arquivo build.gradle (do Module:app) para adicionar as seguintes linhas dentro da seção dependencies:

Essas linhas adicionam uma nova dependência ao projeto bem como um processador de annotations (aquelas palavras precedidas por @ que fica sobre os métodos e variáveis).

Com essa dependência adicionada, vá na sua MainActivity.java e adicione as seguintes variáveis no escopo da sua classe, fora do onCreate:

O tipo EditText irá exigir a adição de imports na sua classe, bem como a annotation @BindView, apenas use o recurso ALT+ENTER e siga em frente.

No onCreate desta Activity, logo abaixo o setContentView, você deve inicializar o ButterKnife para que ele faça as conversões corretas de código (aproveite para jogar fora o código velho do FloatingActionButton):

E é aqui que a magia acontece. Com muito menos repetição de código, os meus componentes estarão carregados nas variáveis locais que defini no trecho de código anterior à esse, permitindo o seu uso sem qualquer receio nos métodos de onClick dos botões, os quais faremos na sequência, também usando ButterKnife pra fazer o binding do método ao componente apropriado (quem já fez isso com Listeners vai ver muito valor aqui).

Primeiro, vamos programar o btnNovoOnClick (o floating button) para apenas limpar todos os campos do formulário, incluindo o id, sinalizando um novo cadastro (apenas coloque esse método no escopo da classe MainActivity.java):

Note a annotation @OnClick acima do método, que informa qual o id do componente que queremos mapear o click. Você pode inclusive colocar diversos ids para o mesmo método tratar, pode omitir o parâmetro View no método (como eu fiz) ou mesmo substituir o view pelo tipo correto do componente (pra evitar castings no código, embora eles ainda ocorram no código compilado).

Na sequência, vamos programar o btnBuscarOnClick: ele deve pegar o id que foi digitado pelo usuário e usar esse id como filtro para trazer os dados do usuário e preencher o formulário. Aqui não iremos na API ainda, então faremos uma falsa busca por enquanto:

Quase finalizando, vamos programar, também de maneira fake, o click do nosso botão de excluir. A ideia aqui é que o usuário digite o id e clique em excluir, o app pede uma confirmação e avisa se conseguiu excluir ou não:

E por fim, o click do botão de salvar. Esse botão também é um pouquinho mais “esperto” que os outros, pois ele deve diferenciar o cadastro de um novo cliente de uma edição de um cliente já existente. Isso é feito analisando o campo id, que deve estar vazio ou com um número inferior a 1.

Se você mandar este app executar agora e fazer alguns testes, verá os comportamentos esperados uma vez que ainda não estamos consumindo a API, o que faremos na próxima parte deste tutorial usando Retrofit!

E aí, gostou da primeira parte? A parte 2 você confere neste link!

Enquanto isso, dá uma olhada no meu livro de Android clicando no banner abaixo pra aprender a criar outros tantos apps incríveis!

Criando apps para empresas com Android

O que achou desse artigo?
[Total: 1 Média: 5]