Como programar para Android no NetBeans

sdk-netbeans

Atualizado em 30/08/2017!

Tem muita, mas muita gente mesmo, que não gosta do Android Studio.

Não me entenda mal, a ferramenta não é ruim, só é pesada demais para a maioria dos computadores comuns entre os desenvolvedores de software (aqui tem algumas dicas de performance se quiser). Geralmente quem não reclama (tanto) de performance são os felizes usuários de discos SSD, uma vez que o I/O de disco é o principal gargalo dessa IDE.

Como professor de desenvolvimento de apps, muitos alunos me perguntam se não existem alternativas. É claro que existem! Eu comecei desenvolvendo apps Android no Eclipse, uma popular e leve IDE que super recomendo…para quem está familiarizado com ela, pois é meio chatinha de configurar. Outra IDE igualmente popular e com maior aceitação entre o público iniciante é o NetBeans, que ensinarei neste post como configurar para desenvolvimento de aplicativos mobile para a plataforma Android.

Depois de ler, caso queira se aprofundar mais, dê uma olhada no livro de Android que escrevi! Mas se o seu problema é com o Java em si, esse livro resolve!

Ingredientes

Para o tutorial de hoje vamos precisar:

  • conexão com a Internet;
  • muito espaço em disco livre;
  • IDE NetBeans 8.1 completa (tem de ser a 8.1);
  • plugin para programar Android no NetBeans;
  • Android Tools (linha de comando, standalone);

Internet e espaço em disco são essenciais aqui, baixaremos e instalaremos diversas coisas neste tutorial, então certifique-se de ter alguns GB sobrando no HD e uma conexão banda-larga antes de prosseguirmos. Ah, e tempo disponível também, não é algo muito rápido de fazer…

Eu possuo a versão completa do NetBeans 8.2 na minha máquina, embora seja bem provável que não seja necessária essa versão. Na dúvida, recomendo baixar a versão completa no site do fabricante. Um leitor mencionou ter tido problemas com a versão 8.2 e que com a 8.1 funcionou pra ele (inclusive tem essa resposta no StackOverflow), então fique atento a isso.

O plugin eu vou fornecer a URL para ser adicionado ao gerenciador de plugins do NetBeans logo adiante, então não se preocupe.

O Android SDK Tools via linha de comando deve ser baixado do site oficial do Android (procure no final da página, depois dos links do Android Studio). Atenção: mesmo que você já possua o Android Studio instalado na sua máquina, não se recomenda o uso do mesmo repositório de SDKs, então não seja preguiçoso e baixe o que estou mandando! 😛

Modo de Preparo

Baixe e instale o NetBeans (277MB) com o link fornecido antes (versão completa), apenas vá avançando até o final!

Baixe e descompacte o Android SDK Tools (entre 82MB até 132MB, dependendo do sistema operacional) com o outro link que forneci, em uma pasta sem acentos e espaços, para evitar problemas futuros. Que tal C:\android?

Atenção: o Google removeu nas versões mais recentes do SDK o executável android.exe que possuía a interface gráfica para obrigar todo mundo a usar o Android Studio. Sendo assim, temos três alternativas para que você consiga usar no Eclipse:

Após conseguir ter acesso a alguma forma de instalar as dependências, certifique-se de instalar ao menos as versões mais recentes do Android SDK Tools, Android SDK Build-Tools e Android SDK Platform-Tools, além de uma versão do Android SDK. Isso vai consumir algumas centenas de MB e potencialmente mais de 1GB, então vá fazer outra coisa da sua vida enquanto tudo é baixado.

Quando tudo terminar, na sua pasta C:\android vão ter duas pastas novas: platforms e platform-tools.

Agora abra o NetBeans e vá na opção Ferramentas > Plugins (Tools > Plugins), acesse a opção Definições (Settings) e mande adicionar uma nova configuração clicando no botão correspondente. Para essa nova definição, adicione o nome Android e no campo URL informe a seguinte:

http://nbandroid.org/release81/updates/updates.xml

Ainda na mesma janela, vá na opção Plugins Disponíveis (Available Plugins) e marque as duas opções de plugins para Android. A primeira fornece suporte à programação Android no NetBeans e a segunda permite que você abra projetos Android criados no Android Studio. Na dúvida, baixe os 2, são apenas 6MB, é rapidinho.

Reinicie o NetBeans quando ele pedir.

Quando ele reiniciar, vá em Ferramentas > Android SDK Manager. Ele vai dizer que você não configurou o SDK Manager ainda e vai solicitar que você configure, lhe dando um atalho para o local de configuração (janela abaixo).

captura-de-tela-2016-12-18-as-15-58-32

Aqui você apenas deve informar o local onde está instalado o seu Android SDK, que instalamos e configuramos no segundo passo deste tutorial, lembra? Coloque o caminho da pasta onde estão as pastas tools, platforms e platform-tools, Aplique e dê um ok.

Agora o seu NetBeans está configurado para programarmos em Android!

Experimentando

Se você for em Ferramentas > Android SDK Manager, você abre o gerenciador do SDK do Android, onde pode baixar novas versões das plataformas, plugins e bibliotecas de desenvolvimento.

Se você for em Ferramentas > AVD Manager, você abre o gerenciador de máquinas virtuais do Android (Android Virtual Devices), onde pode criar e inicializar máquinas virtuais para fazer os seus testes de apps (é o mesmo emulador usado no Android Studio).

Mas agora vem a parte mais legal: se você for em Arquivo > Novo Projeto você verá uma nova categoria de projetos no NetBeans: Android!!!

captura-de-tela-2016-12-18-as-16-42-27

A tela seguinte, de configuração do projeto, muda um pouco, mas não muito…

captura-de-tela-2016-12-18-as-16-43-38

Nela, você é obrigado a informar um Package Name com ao menos duas partes (no exemplo usei o domínio do meu site, mas você pode inventar qualquer coisa) e também é obrigado a selecionar a TargetPlatform, que no meu caso apenas tenho baixado a versão Android 2.3.3 (no Android SDK Manager, lembra?). Note também que o nome da Activity principal foi deixado como MainActivity, que é a sugestão do próprio NetBeans.

Após finalizar, o NetBeans nos mostra o projeto aberto, que cuja árvore de diretórios é a seguinte:

captura-de-tela-2016-12-18-as-16-46-15

Note como ela lembra a árvore de diretórios dos projetos feitos no Android Studio, com a mesma divisão de um pacote para as classes Java e uma pasta de resources para layouts, valores (além das futuras imagens que deverão ser colocadas aí também!).

Mas e aquele erro ali? Se assim como eu você der alguma “ratiada” e deixou de instalar o Build Tools do Android SDK, você vai ter aquele erro ali que se mandarmos compilar, teremos a mensagem abaixo:

“SDK does not have any Build Tools installed.”

Pra solucionar é simples: abra novamente o Android SDK Manager e marque a opção Android SDK Build-Tools (a mais recente já serve). Espere ele baixar tudo e mande compilar no NetBeans que vai estar resolvido.

Agora vamos testar nosso app de Olá Mundo!

Quando você clicar no botão de Run/Executar/Play-verde do NetBeans, ele vai abrir uma máquina virtual android (AVD) para testarmos nosso app nele!

Prós e contras

Óbvio que nem tudo são flores, apesar de podermos programar em uma IDE bem mais rápida que o Android Studio, temos alguns reveses.

O primeiro, é que perdemos o editor visual de layouts do Android Studio, inexistente no NetBeans. Dá pra usar o DroidDraw, ferramenta externa pra isso, mas não é a mesma coisa.

O segundo revés é que perdemos o acesso rápido e prático às ferramentas de desenvolvedor do Android, como o File Explorer, Android Device Monitor, entre outros. Você vai ter de procurá-los na pasta tools e alguns só serão acessíveis via linha de comando.

E aí, o que achou da ideia de programar apps Android no NetBeans ao invés do Android Studio?

* OBS: curtiu o post? Então 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

Tutorial app de mensagens para Android com backend em Node.js

Ok, já temos Whatsapp, Telegram, Slack e outras incríveis plataformas de mensagens no mercado, mas não é por isso que deixa de ser valioso saber desenvolver uma aplicação que permite a troca de mensagens entre diferentes usuários.

Diversos são os contextos em que você pode ganhar dinheiro com apps de mensagens, como criando chatbots, usando a parte de mensageria como backend de outro tipo de operação, criando mensageiros para atender demandas específicas de empresas e por aí vai.

Sendo assim, o intuito deste post é permitir que você seja capaz de criar uma aplicação cliente de mensagens para a plataforma Android. O message-server obviamente não estará no app Android, mas sim em uma hospedagem ou servidor na nuvem, que será o ponto central para todos os clientes se conectarem.

Para o servidor de mensagens (backend), usaremos Node.js com Socket.io. As mensagens não serão persistidas, mas poderíamos fazê-lo com MongoDB, se assim quiséssemos. Essas tecnologias casam muito bem com conceitos como real-time, comunicação de rede não bloqueante e programação assíncrona baseada em eventos (falei muito disso neste post de Node). Não é ao acaso que foram escolhidas para servir de backend para este tutorial e no vídeo abaixo explico um pouco disso e do porque ainda programo usando o SDK nativo do Android:

Veremos neste tutorial:

  1. Preparando o back-end
  2. Criando o app
  3. Programando a troca de mensagens
  4. Indo além

Vamos lá!

#1 – Preparando o back-end

O seu app irá conversar com um back-end que eu ensinei como criar em um tutorial recente sobre Node.js com Socket.io.

Ao terminar o referido tutorial, você terá uma aplicação web de chat com servidor socket.io e é imprescindível que faça o mesmo antes de começar esse aqui, até para entender como funciona o Socket.io, o seu modelo de eventos, a troca de mensagens, etc.

Se você preferir, no referido post há um formulário para baixar o zip com o projeto pronto. Pode partir disso também, mas certifique-se de instalar as dependências com ‘npm install’, rode o projeto localmente e teste para ver se está tudo funcionando.

Opcionalmente, existem diversas coisas que não foram implementadas no referido tutorial mas que são citadas na última seção, dentre elas persistência de dados e autenticação, dois itens muito importantes para um app de mensagens que posso explorar em continuações deste tutorial.

Em suma, não há muito o que fazer aqui, pois tudo já foi feito no outro post.

Vamos em frente!

#2 – Criando o app

Se esse é o seu primeiro projeto com Android, recomendo começar por este post aqui, muito mais didático.

Crie um novo projeto no Android Studio com o nome de ChatApp e na Activity inicial use uma Empty Activity e deixe com as configurações sugeridas (nome de MainActivity, etc). Em chats mais avançados como clones do Whatsapp, poderíamos usar o template com abas para ter a listagem de contatos em uma, a conversa em outra, etc.

Nossa interface será bem simples: uma lista de mensagens, um campo para escrever uma nova mensagem e um botão de enviar, tal qual o layout abaixo, que pode ser feito de diversas maneiras por ser bem simples, sendo que as que recomendo são com Constraint Layout ou com Relative Layout.

Chat App
Chat App

Usei nesta interface uma ListView, que é um componente rápido e prático de implementar listas simples. Existe outro componente chamado RecyclerView, muito mais poderoso e com mais opções, que eu recomendo dar uma olhada se esse projeto for tomar grandes proporções ou virar importante para você. Para conhecer o RecyclerView. sugiro este outro tutorial aqui.

O código completo do layout pode ser visto abaixo, com atenção aos ids dos componentes e ao onClick do Button, o restante você pode mudar à vontade:

Para que nossa ListView liste as mensagens que adicionaremos mais tarde e para que a caixa de texto possa ser lido depois, adicione as seguintes modificações no método onCreate da sua MainActivity.java:

Neste código eu carrego os componentes de interface em variáveis locais, para que eu possa manipulá-los mais tarde. Também crio um adapter que terá os dados a serem listados na minha ListView. Mais tarde, quando eu quiser atualizar ela, basta adicionar novos elementos no adapter.

Para que o click do botão seja manipulado eu adicionei o nome de um método à propriedade onClick do Button: btnEnviarOnClick. Esse método ainda não existe, vamos criá-lo em nossa MainActivity.java, como abaixo:

Neste código Java eu apenas estou lançando a mensagem digitada diretamente  na ListView (através do adapter), como se fosse uma conversa consigo mesmo. Mais tarde mudaremos este código para enviar ao servidor de mensagens.

Você até pode rodar este app do jeito que está, mas não vai ver nada de incrível, apenas um botão que exibe o texto digitado na listagem.

Chat Fake
Chat Fake

Com isso, o arcabouço do nosso app está pronto para receber a lógica de comunicação com o servidor de mensagens.

#3 – Programando a troca de mensagens

Para usar o cliente do Socket.io em apps Android, devemos adicionar manualmente uma dependência no build.gradle, dentro da coleção “dependencies”.

Isso exigirá que o Gradle seja sincronizado com o repositório e ele vai baixar essa biblioteca cliente que o pessoal do Socket.io deixou pronta para uso com Android.

Como o Socket.io irá se conectar à Internet, precisamos dessa permissão explícita em nosso AndroidManifest.xml:

E para versões de Android 6+, precisaremos também solicitar essa permissão no momento que precisarmos do recurso, para garantir que a teremos. Como ao abrir o aplicativo já estaremos esperando pelas mensagens do servidor, precisamos dessa permissão logo no início do ciclo de vida Activity, no onCreate.

Antes disso, vamos criar dois novos e métodos e alterar o onClick do botão e o onCreate da Activity como segue:

O primeiro método vamos modificar ele para fazer o setup do cliente do Socket.io e ficar aguardando as mensagens. Já o segundo método, vamos alterar para enviar as mensagens para o server do Socket.io. Ambos métodos dependem que exista uma conexão (e permissão para usar) com a Internet.

Primeiro, vamos declarar uma variável cliente do Socket.io no topo da nossa Activity, junto às demais variáveis, como segue:

Quando você declarar esta variável terá de importar a dependência correta. O Android Studio dá 3 opções, a correta é a do meio, conforme mostra a foto abaixo:

Import correto
Import correto

Agora, dentro do método waitMessage, vamos adicionar o seguinte código de inicialização do Socket.io:

O endereço 10.0.2.2 é o localhost da máquina host da VM do Android e a porta 3000 é a default do Node.js. Caso seu message-server esteja hospedado em algum lugar (recomendo subir para a Umbler), coloque aqui a URL ou IP correspondente (de preferência a URLs ao invés de IPs).

Outros pontos importantes deste código incluem o runOnUiThread que delega à thread de UI a atualização da interface, para evitar o erro “CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.” e o uso de smoothScrollToPosition para jogar o scroll sempre para o final da ListView possibilitando ao usuário enxergar as novas mensagens mais facilmente.

Enquanto esse código aí faz a conexão do Socket, precisamos de um código para encerrar essa conexão, que deve ir no onDestroy da Activity, um método que devemos incluir como abaixo:

Agora vem a parte chata de pedir permissão, altera a chamada ao waitMessage no onCreate para que fique dessa maneira, solicitando a permissão de internet:

Primeiro, note que declarei uma constante lá no início do código, essa constante é o código da operação que quero realizar. Quando vou configurar o cliente do Socket.io, eu verifico se tenho a permissão de Internet concedida. Caso já tenha, cai no else e configura. Caso contrário, eu solicito ao sistema que peça essa permissão ao usuário, passando o código da tarefa que quero realizar após a permissão ser concedida.

Mas como saberei se o usuário me deu a permissão?

Aí entra o trecho de código abaixo, que trata a resposta a pedidos de permissão de maneira assíncrona:

Ou seja, caso a permissão tenha sido concedida e o código da ação a ser executada for igual a READ_SOCKET, eu mando executar o waitMessage. Caso contrário mando um aviso default pois o app não irá funcionar.

Isso tudo já é o suficiente para que recebamos mensagens, então abra a aplicação web de chat que criamos no tutorial anterior com “npm start”, abra no navegador na URL localhost:3000/chat e abra o seu app Android no simulador também. Possivelmente na primeira execução ele vai pedir a permissão de Internet e você deve fornecer. Quando você digitar mensagens na aplicação web, elas aparecerão no app automaticamente, como mostra a imagem abaixo:

Recebendo Mensagens
Recebendo Mensagens

Agora, para finalizar, vamos fazer com que as mensagens escritas no app sejam enviadas para o servidor, a fim de atualizar também a aplicação web automaticamente. Atualize os métodos sendMessage e onRequestPermissionsResult como abaixo:

Note que defini uma nova constante com o código 2, para que seja possível distinguir as solicitações de permissão, caso não sejam feitas na ordem normal (leitura primeiro, escrita depois) ou seja revogada nesse meio tempo. Essa constante é usada em um novo ‘case’ no onRequestPermissionsResult, enquanto que a ação de enviar mensagens ao servidor é ridiculamente simples, um mero socket.emit passando o nome do evento (aqui estou usando o mesmo nome de evento do tutorial anterior) já resolve.

Como o meu servidor está fazendo broadcast de tudo que recebe, automaticamente a mensagem do app ecoará de volta atualizando a lista, sem que eu tenha de me preocupar com isso.

O resultado agora é um app de chat se comunicando com um webapp de chat através de Socket.io, como mostra na imagem abaixo, em uma comunicação bi-lateral:

Enviando Mensagens
Enviando Mensagens

E inclusive você pode abrir diversos clientes web e diversos clientes Android que todo mundo consegue conversar com todo mundo sem problema algum, como mostra a imagem abaixo!

Todo mundo conversando
Todo mundo conversando

#4 – Indo além

Note que criar este tipo de aplicação antes de termos tecnologias modernas e consolidadas como Socket.io era realmente difícil. Hoje é possível criar um servidor de chat com 12 linhas Node.js no server (embora o meu esteja maior) e uma Activity no client, como fizemos aqui. E esse conhecimento pode ser extendido para criação de jogos por exemplo, pois o modelo de eventos do Socket.io permite que você comunique o que quiser e no formato que quiser através dele, coisa que aqui apenas mandei mensagens de texto simples.

Itens que você pode considerar para ampliar este projeto e torná-lo uma aplicação de mensageria mais profissional:

  • hospedagem do server em um provedor de hospedagem ou servidor na nuvem;
  • autenticação das requisições;
  • uso de HTTPS para comunicação segura;
  • persistência das mensagens no server, sugiro MongoDB, e no client com SQLite;
  • mensagens privadas;
  • suporte a nicknames;
  • busca de mensagens;
  • push notifications quando novas mensagens chegarem (hoje elas chegam mesmo com o app em background, só não avisam o usuário);
  • aviso textual quando o usuário estiver digitando uma mensagem;
  • sinalização de quem está online no chat;

E muito mais!

Espero que tenham gostado deste tutorial, pois foi realmente interessante e divertido fazê-lo!

Eeste post é coberto pelos slides abaixo, frutos de um workshop meu.

Curtiu o post? Então 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

Consumindo APIs em Android com Retrofit e Butter Knife – Parte 2

Esta é a segunda parte do tutorial de como consumir APIs em um app Android usando Retrofit e ButterKnife. Caso tenha caído aqui de pára-quedas, sugiro ler (e programar) a primeira parte do tutorial primeiro, seja clicando no link anterior ou usando o sumário logo abaixo (os itens 1 a 3 são da parte 1 do tutorial).

Apenas recapitulando, estou usando uma API escrita em Node.js com banco MySQL, cujo tutorial e fontes se encontram neste post. Esta API e seu banco estão hospedados na Umbler, que fornece MySQL gratuito para pequenos projetos.

Sobre as bibliotecas-foco desse tutorial, a Retrofit permite abstrair requisições HTTP a APIs usando classes Java de uma maneira muito elegante e produtiva. Enquanto o Butter Knife permite fazer o binding de recursos do seu app (componentes visuais, imagens, cores, strings, eventos, etc) com muito menos código do que normalmente é necessário.

E pra encerrar a introdução, a belíssima tela (#sqn) do nosso app está como abaixo:

Tela do app
Tela do app

Dito isso, veremos neste tutorial completo os seguintes itens (do 1 ao 3 já foram vistos na parte 1):

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

Vamos lá!

#4 – Usando Retrofit

Como mencionado anteriormente, Retrofit é um HTTPClient que agiliza bastante algumas tarefas tediosas de mapear APIs HTTP em objetos Java para tornar as requisições mais type-safe.

Neste tutorial, temos uma API REST de clientes que possui algumas operações elementares que precisamos mapear para métodos e classes Java, o que o Retrofit vai nos permitir fazer muito facilmente. Mas antes de sair usando ele, precisamos adicioná-lo como uma dependência em nosso build.gradle (no Module: app), na seção dependencies (tal qual fizemos com o ButterKnife):

Aqui, eu adicionei o Retrofit e o converter que vai nos permitir serializar e desserializar JSON usando a biblioteca Gson (isso porque minha API trabalha com JSON, isso pode variar no seu caso). Apenas atente que o converter utilizado deve ser da mesma versão do seu Retrofit (2.3.0 no meu caso).

E no arquivo proguard-rules.pro, onde tem as configurações do Proguard, adicione as seguintes linhas (recomendação do dev do projeto Retrofit):

Atenção: se você não sabe o que é o Proguard, ele é um otimizador, minificador, ofuscador e pré-verificador de código Java que roda automaticamente segundo uma série de regras para tornar o APK final o menor possível (no caso do Android) e o mais “seguro” possível, do ponto de vista de ofuscação de código. Mais informações nesta resposta do Quora.

Com isso temos o Retrofit configurado em nosso projeto e pronto para usar. O primeiro passo é adicionar uma classe Java que representa um cliente do seu banco de dados, o que eu fiz abaixo do jeito mais simples possível:

Atenção: foi usada aqui a mesma capitalização (maiúsculas e minúsculas) das colunas da tabela Clientes do meu banco de dados MySQL. Ajuste de acordo com o seu cenário. Caso os nomes não coincidam, a desserialização não acontecerá corretamente mais tarde e os métodos retornarão clientes “vazios”.

Agora, adicione uma interface Java ao nosso projeto, que representará a API localmente. Aqui eu chamei de ClientesService.java:

Para cada endpoint da nossa API (falei sobre isso na parte 1 deste tutorial, lembra?), criamos um método na interface usando annotations para os verbos HTTP e para os parâmetros que devam vir no path e no body da requisição HTTP.

Para quem entende um mínimo de web APIs, o código é auto-explicativo.

Atenção: meu método que retorna cliente por id está retornando uma lista de clientes propositalmente porque na minha API Node+MySQL eu sempre retorno um array JSON em GETs. Outro ponto de atenção são os métodos de insert e update que possuem a annotation @FormUrlEncoded pois minha API Node+MySQL espera chave-valor no body (caso esperasse JSON, eu usaria um @Body Cliente como parâmetro). Métodos com esta annotation devem possuir parâmetros com @Field indicando o nome de cada chave que será enviada no body. Para saber os fields corretos, consulte a documentação da API (no meu caso, consulte o tutorial original).

Agora, para podermos usar esta interface, vamos adicionar uma nova variável e um método de carregamento dessa variável em nossa MainActivity.java:

Esse método de carregamento deve ter sua baseUrl apontada para a sua URL (no meu caso, node.luiztools.com.br). Caso queira apontar para uma webapi rodando localhost, use 10.0.2.2 como URL (e inclua a porta, se necessário). Além disso, esse método usa a biblioteca Gson para converter o body das requisições para JSON, conforme exigido pela minha API (isso pode variar na sua).

E no onCreate da MainActivity, adicione uma chamada à esse método logo no final (aproveitei para adicionar a permissão de uso de rede na thread principal, conforme explico melhor aqui):

Com isso, sempre que precisarmos consumir nosso webservice, basta chamar MainActivity.api.nomeDoMetodo e é isso que temos de fazer agora, substituindo aqueles testes fake por chamadas de verdade à API.

Atenção: como usaremos webapis através da Internet do smartphone, devemos ter permissão para tanto. Adiciona no AndroidManifest.xml as duas linhas logo no início, dentro da tag manifest:

Isso resolve para smartphones com Android anterior ao 6. Para smartphones Marshmallow (6) em diante, você deverá incluir um código de verificação e solicitação de permissão do usuário a cada requisição. Eu incluirei esse código nas chamadas dos métodos abaixo, então não se preocupe.

#5 – Fazendo tudo funcionar

Agora que temos tudo pronto com nosso Retrofit, é hora de usar nosso recém-criado ClientesService através da variável api nos métodos de click dos nosso botões.

Vamos começar com o btnBuscarOnClick, que agora deverá ficar assim:

Note que houve uma imensa alteração aqui. Logo no início eu defino uma constante que define o número 1 para uma ação de busca, isso vai ser útil na sequência. Antes de fazer qualquer coisa no clique deste botão eu verifico se o app tem permissão de usar a Internet, caso contrário, solicita ao usuário que dê a referida permissão, passando o código desta ação de busca (1).

Caso ele tenha a permissão, o código flui naturalmente, usando o método da interface que retorna apenas um cliente por id e usando o cliente retornado para popular os campos.

Para que isto funcione, temos de sobrescrever o método onRequestPermissionsResult que é executado automaticamente após a permissão ter sido concedida ou não pelo usuário:

Aqui é onde usamos o código da ação de busca (1), pois todos os pedidos de permissão vão cair aqui e precisamos saber qual método executar após a permissão ser concedida. Essa permissão será requisitada apenas na primeira ação, nas subsequentes o fluxo cairá no else do código anterior a este e tudo acontecerá naturalmente pois a permissão fica salva.

Sugiro já realizar um teste aqui, para garantir que está funcionando. Acesse a API Node+MySQL no seu navegador e mande listar todos os clientes para pegar o ID de algum deles e usar no app para buscar.

Próximo passo, btnExcluirOnClick!

Aqui as mudanças não foram tão drásticas se você considerar que muita coisa é repetida em relação às permissões e à própria chamada da api em si, que é apenas um método pois o Retrofit faz todo o trabalho pela gente.

Note que defini uma nova constante para ACTION_EXCLUIR, constante essa que devemos incluir no switch/case do onRequestPermissionsResult:

Próximo passo, btnSalvarOnClick!

Neste método, que guarda muitas semelhanças com os anteriores, executamos o método correto da interface conforme for um insert ou update, no mais não há novidade alguma.

Não esqueça de incluir a nova constante ACTION_SALVAR no onRequestPermissionsResult:

Quando for testar o botão de salvar você receberá as mensagens de sucesso ou de fracasso, mas para ter certeza de que realmente funcionou, acesse sua API para ver se o cliente em questão foi alterado ou se apareceu um novo cliente, dependendo do seu caso.

#6 – Indo além!

Opcionalmente existem diversas melhorias que você pode fazer neste app.

Alguns apps usam o banco local (SQLite) para fazer cache dos dados da API que o app consome. Você aprende a usar o banco local neste post. Isso pode ser uma boa ideia dependendo do seu caso, apenas tomando cuidado de ter uma forma de atualizar o seu cache ou mesmo expirá-lo automaticamente.

Não criamos uma tela de listagem de todos os clientes neste tutorial. Isso geralmente é feito e a recomendação atual é usar RecyclerView para isto, um componente moderno e poderoso que permite criar belas e rápidas listagens. Neste post eu ensino como tirar um bom proveito do RecyclerView e com poucas adaptações você consegue usar neste tutorial aqui.

Não adicionei validações no formulário de cadastro/edição de cliente. Isso é super importante para garantir que somente dados íntegros sejam enviados à API. Facilmente você nota que se clicar diretamente em Salvar, sem preencher nenhum campo, mesmo assim um novo cliente vazio é cadastrado com um novo id.

Caso a API possuísse autenticação (a minha é aberta), existem algumas configurações adicionais no Retrofit para que ele envie junto o cabeçalho Authorization. Isso é melhor explicado na seção de Header Manipulation da documentação do Retrofit.

E com isso encerramos este tutorial de como consumir APIs em Android usando Retrofit e ButterKnife.

Espero que tenha gostado e que lhe seja útil!

Curtiu o post? Então 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