Nova versão do livro que ensina a criar aplicativos com Corona SDK

Se você não sabe o que é Corona SDK, leia este post!

Comprem o livro neste link para que o tradutor ganhe sua comissão! O site de compras é o PagSeguro do UOL e tenho 100% de qualificações positivas.

Foi em 2012 que conheci Corona SDK e que começou minha paixão pelo desenvolvimento amador de games mobile como hobby. Nesse mesmo ano conheci o livro Beginning Mobile App Development with Corona e decidi que ia ajudar o autor, o Dr. Brian Burton, a fazer a versão nacional chamada Criando Aplicações Móveis com Corona, sendo o primeiro livro em Português sobre o assunto, e até hoje um dos únicos materiais em nosso idioma. Cinco anos e centenas de compradores depois…

corona-sdk

Corona, mais forte do que nunca!

Quando conheci o Corona em uma revista da Info, era um framework indie de desenvolvimento mobile que suportava Android e iOS com programação em Lua. Tinha alguns milhares de desenvolvedores ao redor do mundo e era desenvolvido por uma empresa chamada Ansca Mobile, fundada por dois ex-engenheiros da Adobe, do time de games do Flash.

Hoje, a empresa se chama Corona Labs e seu framework é utilizado por mais de 200 mil desenvolvedores ativos ao redor do mundo, com uma imensa comunidade online, muito material e exemplos disponíveis e diversos aplicativos em seu portfólio. Com atualizações praticamente mensais, Corona é gratuito para todos desenvolvedores, e seduz a cada dia novos estúdios digitais e programadores freelancer que encontram no seu poder e simplicidade a amálgama perfeita para desenvolver aplicativos, games e livros interativos para Android, iOS, Mac OSX, Windows, Amazon Fire, Apple TV, Fire TV e Android TV.

Some a isso um tempo livre que entrou em minha agenda e a vontade de voltar a programar jogos e temos a combinação perfeita para lançar uma nova versão do livro que já faz cinco anos que foi lançado em Português, e cuja última atualização tinha sido em 2014.

corona-sdk2

O que há de novo no livro?

Corona evoluiu muito desde o seu lançamento, e o livro não apenas vem para corrigir erros antigos mas para expandir as possibilidades com o framework com muitas correções em códigos que deixaram de funcionar, um novo apêndice traduzido sobre a linguagem Lua, indicações diferentes de ferramentas e muitas páginas adicionais, sem mudar em nada o preço final! Veja as principais novidades da nova versão do livro:

  • nova biblioteca Graphics 2.0;
  • integração com Apple Game Center e Google Play;
  • suporte à JSON;
  • monetização com anúncios;
  • novas ferramentas para look & feel nativo;
  • mockups;
  • nova biblioteca Widgets 2.0;
  • Eventos do sistema e Ferramentas (acelerômetro, giroscópio, GPS, mapas e notificações)
  • Gráficos Avançados com filtros, geradores, efeitos compostos e LiquidFun

São quase 500 páginas de dicas, tutoriais, exemplos de games e apps completos e muito mais! Sério, tudo que você precisa saber sobre como criar games e apps com Corona SDK está neste livro.

Confira nesta resenha tudo o que há no livro!

Mas e quem comprou a versão antiga?

Obviamente não esquecemos dos antigos compradores e todos podem baixar a nova versão do livro gratuitamente. Para isto, basta acessar o link abaixo do site do autor e informar o e-mail que usaram para compra do livro. Pronto! Você receberá por e-mail uma cópia novíssima e atualizada do livro para aproveitar ainda mais o nosso framework mobile favorito!

Get Book Updates Here

 

Comprem o livro neste link para que o tradutor ganhe sua comissão! O site de compras é o PagSeguro do UOL e tenho 100% de qualificações positivas.

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