Android Studio: Tutorial completo do básico ao avançado (10 lições!)

Em 2012 eu comecei a me interessar por Android. Não me orgulho de ter entrado tão atrasado no mercado, uma vez que um colega de faculdade já havia me mostrado a plataforma em 2010, quando estava me formando. Se eu tivesse dado atenção à época, quando qualquer app alcançava um volume grande de downloads, talvez toda minha carreira tivesse sido diferente. Não que eu esteja reclamando do que consegui alcançar nestes 11 anos como desenvolvedor, mas né!

Mas o que eu estava me lembrando agora é que em 2012 era muito difícil programar para Android. Os aparelhos ainda eram poucos, menos ainda os que prestavam.  Android 2.3 era luxo e as ferramentas, terríveis. Usávamos muito Eclipse com os plugins do ADT. Quando um atualizava, quebrava o outro, perdia muito tempo configurando a ferramenta. Logo descobri o MotoDev, um Eclipse modificado pela Motorola que já vinha pronto para programar para Android. Foi a ferramenta que mais utilizei até o lançamento oficial do Android Studio.

Ah, o Android Studio (suspiro)!

Tenho uma relação de amor e ódio com a ferramenta. Ao mesmo tempo em que ela tornou o desenvolvimento nativo para a plataforma muito mais fácil, ela acaba com os recursos da máquina onde você usa ela, principalmente seu espaço e IO de disco. Mas fazer o quê, não há bônus sem ônus.

E é dessa ferramenta que vou falar hoje. Não apenas falar, vou destrinchar tudo que sei sobre ela (e o que não sei vou pesquisar) para lhe entregar o post mais completo que você possa encontrar na Internet sobre o assunto. Um tutorial completo de Android Studio, do básico ao avançado.

Vou falar aqui de (clique para ver algum tópico específico que mais lhe interesse):

  1. Como baixar e instalar a ferramenta?
  2. Como e por que manter atualizado?
  3. Como instalar os pacotes corretos do Android?
  4. Como criar e executar seu primeiro AVD?
  5. Como criar meu primeiro app Android?
  6. Como fazer testes mais avançados?
  7. Como copiar e inserir arquivos no AVD?
  8. Dicas de performance
  9. Como gerar o APK para publicação?
  10. IDEs concorrentes do Android Studio

Tem algum tópico que você gostaria de saber e que eu não cobri aqui? Me manda nos comentários!

#1 – Como baixar e instalar o Android Studio?

O Android Studio é a ferramenta oficial para desenvolvimento Android. Apesar dos seus contras e de existirem alternativas (como listo na dica #12), ele ainda é a melhor opção.

Para baixar, acesse o site oficial da ferramenta neste link. A página detecta seu sistema operacional e lhe fornece a versão mais atualizada da ferramenta. Após baixar, dê um duplo-clique nele para instalar na sua máquina.

Assim que ela terminar de instalar, execute-a para que sejam efetuadas as primeiras atualizações e você possa finalmente utilizá-la.

#2 – Como e por que manter o Android Studio atualizado?

Assim que você instala a ferramenta, a mesma já executa uma atualização de suas dependências. No momento em que escrevo este post ela está versão 2.3.1, mas todo mês sai alguma atualização nova: updates de segurança, de performance, para corrigir bugs, etc. Além disso não é apenas o Android Studio em si que atualiza, mas sempre tem alguma de suas dependências para atualizar. E são muitas:

  • novos SDKs surgem para as novas e antigas versões do Android
  • atualização da ferramenta de compilação (Android Build Tools)
  • novos Add-ons para facilitar a sua vida enquanto desenvolvedor
  • novas versões do Gradle, o gerenciador de build do Android Studio

E essas são apenas algumas!

Para manter o Android Studio atualizado é bem simples, pois a própria ferramenta te avisa quando saem novas atualizações dela própria, bastando aceitar o download e reiniciar a mesma quando solicitado. Ainda assim, você pode mandar verificar atualizações manualmente, usando a opção Android Studio > Check for updates.

É importante manter sua ferramenta atualizada para evitar exploits de segurança que possam ser usados por pessoas maliciosas e até mesmo para que a performance da ferramenta (que não é lá grande coisa) fique um pouco melhor.

#3 – Como baixar os pacotes corretos do Android SDK Manager?

O Android Studio possui integração com o SDK Manager, a ferramenta que gerencia as versões e add-ons de desenvolvimento Android presentes na sua máquina. Você consegue acessar o SDK Manager a partir da splash screen, no meu Configure como abaixo:

Por dentro da ferramenta você também pode acessar o SDK Manager a partir do menu Tools > Android > SDK Manager:

E usando o ícone presente na toolbar (é o Android com a seta de download):

Qualquer uma das opções vai te levar até a seguinte tela do SDK Manager:

Nesta janela temos algumas informações bem importantes que valem ressaltar:

No topo, temos o caminho onde o SDK do Android está instalado na sua máquina. Certifique-se de que este local possui muito espaço em disco disponível, tipo uns 20GB, só pra garantir.

Logo abaixo, temos três abas, sendo a primeira a que mostra as versões de plataforma Android que você possui na sua máquina e que consequentemente conseguirá criar apps. O jeito mais fácil (e que mais ocupa espaço) de instalar esses SDKs é apenas marcando o checkbox correspondente e mandando instalar. Mas há uma maneira mais inteligente, que vou falar mais adiante.

Por ora, certifique-se de que você possui ao menos a versão mais recente instalada, Nougat no meu caso, como pode ver na imagem.

A segunda aba mostra as ferramentas e add-ons das plataformas, como na imagem abaixo:

Aqui não precisamos de muita coisa, mas ao menos você terá de ter sempre a versão mais recente instalada do Android SDK Build-Tools, do Android Emulator, do Android SDK Platform-Tools e do Android SDK Tools. Quando sai alguma atualização desses elementos geralmente a ferramenta avisa, mas não custa nada abrir essa tela de vez em quando para checar por você mesmo.

A terceira aba mostra apenas as URLs dos repositórios de onde as dependências estão sendo baixadas e, a menos que você tenha certeza do que está fazendo, não deve mexer aí.

E por fim, eu mencionei no início desse tópico de que tinha um jeito melhor de baixar as dependências que não apenas marcando o checkbox da versão do Android, não é mesmo?

Pois bem, primeiro, volte à aba inicial do SDK Manager e marque o checkbox inferior-direito que diz “Show package details”. Agora você deveria ver uma árvore de dependências muito mais intrincada, como segue:

Note que abaixo da raiz do Android 7.1.1 que eu tenho instalado no meu note, que apenas três opções estão marcadas: Android SDK Platform 25 (essa é obrigatória), Sources for Android 25 (opcional, para melhorar o debugging) e Google APIs ARM EABI v7a System Image. Neste último que está o segredo para economizar espaço em disco!

Para realizar os testes dos seus apps, como mostrarei adiante, você precisar ter imagens das máquinas virtuais Android baixadas no seu computador. As System Images, que nesse caso eu tenho apenas uma dentre as diversas disponíveis. Uma breve explicação sobre as imagens que aparecem nessa listagem, e que praticamente são as mesmas em todas as versões de Android:

  • Android TV …: é a imagem para testar apps feitos para Smart TVs;
  • Android Wear …: é a imagem para testar apps feitos para wearables (Smart Watches, por exemplo);
  • Google APIs …: é a imagem para testar apps feitos para smartphones e tablets, que usem APIs do Google (Mapas, por exemplo)
  • ARM …: imagens que comecem com esse nome são de smartphones/tablets usando CPU ARM;
  • Intel x86: imagens que comecem com esse nome são de smartphones/tables usando CPU Intel;

Estas são as opções mais frequentes que aparecem para download, e aqui entra mais uma explicação importante:

  • se você possui um computador com processador Intel recente (uns 3 anos pra cá), instale o Add-on Intel Accelerator HAXM que vai melhorar a performance dos testes na sua máquina, bem como baixe somente imagens que possuam arquitetura Intel x86 no nome.
  • agora, se você possui um computador mais antigo ou que não tenha processador Intel, sugiro baixar somente imagens que contenham arquitetura ARM EABI v7 mais fáceis de emular

Mas o mais importante é: você não precisa ter todas essas imagens instaladas em sua máquina. Eu costumo ter apenas uma da versão mais recente do Android e outra da versão 4 (Kitkat, por exemplo), para criar apps com maior suporte na Google Play.

Como assim?

Se você faz um app usando a plataforma 4, por exemplo, todos os smartphones com Android 4+ poderão instalar o seu app. Agora, se você faz um app apenas para Nougat (7), somente quem tem smartphones de ponta, na data em que escrevo este post, é que conseguirá utilizá-lo.

Capicce?!

#4 – Como criar meu primeiro AVD?

Primeiro, você sabe o que é um AVD?

AVD é a sigla para Android Virtual Device, ou Dispositivo Virtual Android. Basicamente um AVD é uma máquina virtual Android que você usa para testar seus apps enquanto desenvolve, para que não precise ter um ou mais dispositivos Android de verdade. É especialmente útil para testar diferentes configurações de smartphone e principalmente dispositivos mais difíceis de termos, como wearables.

Sendo assim, saber como criar um AVD é muito importante para poder prosseguir nos estudos com Android. E o primeiro passo para isso é acessar o AVD Manager, que fica no menu Tools > Android > AVD Manager, por dentro da ferramenta:

Ou ainda, pela toolbar (é o ícone do smartphone com a cabeça do Android no canto direito):

Independente da opção escolhida, o AVD Manager se abrirá, como abaixo:

Neste meu print, já tenho dois AVDs criados, mas isso não importa no momento. Para criar seu primeiro ou décimo, os passos são os mesmos. Primeiro, clique no botão “Create Virtual Device”, no canto inferior esquerdo, isso irá abrir o assistente de criação de AVD:

Na primeira tela, selecione a categoria Phone e depois Nexus One, um modelo de smartphone simples porém suficiente para testarmos nossos apps. Na verdade essa escolha afeta mais a resolução do seu dispositivo do que qualquer outra coisa, então não importa tanto assim neste momento. Avance para a próxima tela no botão inferior direito.

Aqui você escolhe qual versão do Android que seu AVD vai ter, dentre as opções que você já tem baixadas na sua máquina e as demais, que possuem o link para download aqui mesmo, o que facilita bastante o gerenciamento das mesmas. Neste print estou selecionando uma imagem de Nougat que já tenho baixada e que encontra-se na aba “Other images”. Na aba x86 você encontra as imagens de smartphones Intel e na aba Recommended, bem, você tem as recomendas pelo Android Studio, sabe-se lá o que isso signifique…

Avance novamente e verá a seguinte tela.

Aqui você define o nome do seu AVD, revisa a resolução e plataforma do dispositivo, se ele iniciará em posição retrato ou paisagem (que pode ser alterado depois) e se a performance dos gráficos será via software ou via hardware (deixe automático, a menos que for desenvolver algum jogo).

Note que tem um botão ali de “Show Advanced Settings”. Se você clicar nesta opção, poderá personalizar melhor as configurações de hardware do seu aparelho, sendo as mais importantes:

  • Câmera: você decide se o dispositivo vai ter câmera ou não, e se ela usará a webcam do seu notebook ou apenas uma imagem da sua pasta de imagens;
  •  Network: a velocidade da rede do seu celular, podendo simular redes lents e antigas como GPRS, EDGE, etc ou deixar Full para usar a Internet completa do seu computador.
  • Memory & Storage > RAM: define a quantidade de memória RAM o seu dispositivo vai ter. Sugiro 1024MB para a maioria dos AVDs.
  • Memory & Storage > Internal Storage: espaço de armazenamento interno disponível no seu AVD. A menos que vá armazenar muitos arquivos ou um banco de dados muito grande, a sugestão de 800MB é suficiente.
  • Memory & Storage > SD Card: define se você vai ter um SD gerenciado pela ferramenta ou salvo em um arquivo externo que simulará o SD. Em ambos os casos, você deve definir a capacidade do SD virtual em MB.

Caso não tenha certeza do que fazer com cada uma dessas configurações, deixe as mesmas como estão, alterando apenas a RAM para 1024MB. Clicando em Finish finalizará o processo e voltará à tela de gerenciamento dos AVDs, que deve demorar alguns segundos e ficar travada enquanto o AVD está sendo criado.

Note que cada AVD consome um significativo espaço no seu HD (Size on Disk), então não fique criando um monte deles ao mesmo tempo que não vale a pena.

Para editar o AVD, clique no ícone de lápis e o assistente de configuração será aberto novamente. A seta para baixo exibe opções como formatar (Wipe) o AVD e excluí-lo. Obviamente o play verde manda executar o AVD.

A execução pode demorar mais ou menos, dependendo da configuração do seu AVD vs a configuração da sua máquina. Em geral, algo em torno de 1-5 minutos é normal. Sim, a inicialização é bem lenta e consome muitos recursos da máquina. Quem já mexeu com máquinas virtuais antes sabe do que estou falando.

Ao término do processo de inicialização do Android, você terá uma máquina virtual Android para mexer à vontade, sendo o comportamento e aparência equivalentes ao de um Android nativo completo, incluindo funcionalidades como instalar apps e navegar na Internet.

Uma dica: depois que você inicializa seu AVD, não feche ele. Assim, a cada projeto que precisar testar, basta mandar executar no AVD que já está rodando, sem precisar inicializar um novo. Somente encerre o AVD depois que terminar todos seus testes. Também encerre se ele estiver travado ou se demorar mais de 5 minutos para inicializar.

#5 – Como criar meu primeiro app Android?

Eu não vou entrar em detalhes neste passo, uma vez que já fiz isso em diversas outras oportunidades aqui no blog. Sendo assim, leia um dos seguintes materiais antes de prosseguir nesse tutorial:

Com o app criado, use o botão verde de play que fica na toolbar para executá-lo:

O Android Studio vai levar alguns segundos para compilar seu projeto e empacotar usando o Gradle e depois vai lhe perguntar onde deseja testar o mesmo:

Neste exemplo, meu AVD já está inicializado por completo, por isso que aparece na lista de dispositivos conectados. Basta selecionar ele e dar um Ok para que o app que estamos testando seja instalado e executado no mesmo.

#6 – Como fazer testes mais avançados?

Consulte este post aqui que está bem completo, focado nesta questão de testes de apps usando diferentes configurações e recursos, incluindo como testar no seu smartphone.

#7 – Como copiar e inserir arquivos no AVD?

O AVD se comporta como um autêntico dispositivo Android, certo? E num dispositivo Android você consegue colocar e tirar arquivos do armazenamento interno dele, certo? Logo, o mesmo é possível de ser feito com o AVD!

A tarefa é simples, primeiro execute o seu AVD e deixe-o inicializar completamente. Em seguida, abra a ferramenta DDMS da sua IDE, no caso Android Studio é o Android Device Monitor, que fica no menu Tools > Android.

Uma vez com o Device Monitor aberto, que permite entre outras coisas ver como anda o consumo de recursos de hardware do seu AVD, você tem a aba File Explorer que permite mexer nas pastas e arquivos do mesmo (dê uma olhada na imagem e como estou mostrando o que está salvo dentro do AVD)! Use os botões da toolbar da direita da imagem para fazer as operações:

  • ícone do disquete para copiar um arquivo do seu smartphone pro computador;
  • ícone do smartphone para copiar um arquivo do seu computador pro smartphone.

Para quê você iria querer copiar arquivos do AVD? Para fazer um dump da sua base SQLite, por exemplo. Ou o inverso, para colocar arquivos estáticos dentro do AVD e usar eles no seu app. Na verdade você faz o que quiser com esse conhecimento, eu só queria te mostrar que era possível. 😀

#8 – Dicas de Performance

A melhor dica de performance é usar o seu próprio smartphone para os testes, conforme mencionado na dica #3 deste outro post aqui. Caso não seja possível, use a dica #11 para conhecer VMs concorrentes ao Android emulator padrão.

Melhorar a performance dos seus testes é talvez o maior ganho de performance que você possa ter, sem muito esforço. No entanto, também existem outras dicas, a saber:

  • troque seu HD por um SSD, a diferença de performance é gritante pois o maior gargalo da ferramenta é IO de disco;
  • crie seus AVDs com no mínimo 1GB de RAM, e certifique-se que seu computador tem essa memória sobrando pro AVD usar (caso contrário ele fará swap no disco);
  • se você usa notebook, mantenha-o na tomada, isso permite que ele opere com o máximo de performance;
  • só use um AVD por vez e somente um Android Studio por vez;
  • na verdade, use só o Android Studio e de repente um navegador com poucas abas abertas. O bicho é pesado…
  • tenha espaço em disco sobrando, curiosamente tudo fica muito lento quando há pouco espaço em disco no computador;
  • mantenha seu Android Studio atualizado, conforme dica #2;
  • rode a versão mais antiga de Android que puder no AVD, tipo 4.0 ou pior, 2.3 (!!!);
  • se você usa Windows, mantenha-o atualizado, ele fica muito lento quando está com atualizações pendentes ou rodando em background;
  • esteja conectado à Internet, o Android Studio fica mais lento quando está sem conexão (antigamente ele nem funcionava sem Internet);
  • se o processador do seu computador for antigo (2014 ou anterior) ou não for Intel em geral, use AVDs com arquitetura ARM, conforme mencionei na dica #3;
  • se o processador do seu computador for Intel recente (2014 ou mais), instale o Acelerador HAXM no SDK Manager e use somente AVDs com arquitetura X86 (dica #3 novamente);

Se tiver mais dicas de performance, deixe nos comentários!

#9 – Como gerar o APK para publicação?

O APK é o arquivo que permite a instalação do seu app em outros smartphones, ou seja, você precisa ter o APK do seu app criado para poder vendê-lo ou mesmo dá-lo de graça, não importa.

Eu falo em mais detalhes dessa dúvida aqui em ambos meus livros Meu primeiro app Android e Criando apps para empresas com Android, incluindo como configurar seu app pra download na Google Play e tudo mais. Pra resumir a geração do APK e não ser repetitivo, use o menu Build > Generate Signed APK, crie suas chaves de assinatura caso nunca tenha criado elas (elas assinam o seu app com seus dados pessoais, pra garantir depois que ele é seu mesmo) e escolha em qual pasta o APK será salvo.

Fácil, fácil!

#10 – IDEs concorrentes do Android Studio

Existem diversas maneiras de programar para Android usando desde a linguagem Lua com Corona SDK até HTML + CSS + JS com Phonegap. Mas se você ainda quiser se manter no Java, usando o SDK nativo tradicional, existem duas excelentes opções para programar seus aplicativos Android:

Clique nos links das ferramentas para ver tutoriais completos de como prepará-las para uso com Android, visto que elas não oferecem suporte nativo à plataforma.

E por hoje é só (chega né!). Tem mais alguma dúvida de Android Studio que eu não abordei aqui? Me manda aí embaixo nos comentários ou dá uma olhada no meu livro, que tem o link a seguir!

Criando apps para empresas com Android

Android Studio: Tutorial de Testes

Atualizado em 20/05/2017!

Testar bastante o seu app é importantíssimo antes de publicá-lo na Google Play. Mesmo que você não venha a publicá-lo e portanto não passe pelo crivo da análise do Google, é importante que seu app esteja bem testado para que não cause uma experiência ruim aos usuários e consequentemente ninguém o desinstale do smartphone.

No entanto, noto que muitos de meus alunos de cursos de Android e mesmo os leitores de meu livro que me mandam emails não entendem exatamente como testar o seu app corretamente usando as ferramentas do Android Studio. Muitos deles também não sabem que é possível fazer testes bem avançados, simulando diversos acontecimentos no smartphone mesmo se estiverem programando Android no Eclipse ou no NetBeans, via linha de comando.

Portanto, resolvi escrever este tutorial para ajudar com este tópico de como usar as ferramentas do Android Studio E da linha de comando para testar eficientemente os seus apps.

Vamos trabalhar em quatro tópicos nesse post (clique se quiser ir direto para um deles):

  1. Usando Extended Controls para testar apps no AVD
  2. Como usar linha de comando para manipular o AVD
  3. Como fazer testes no seu smartphone
  4. Máquinas virtuais concorrentes do Android Simulator

Vamos lá!

#1 – Usando Extended Controls para testar apps no AVD

Antes do Android Studio usávamos uma ferramenta chamada DDMS para fazer testes mais elaborados de nossos apps usando AVDs. Basicamente o DDMS simulava diversas características e comportamentos que os dispositivos poderiam enfrentar e consequentemente afetar nossos apps.

No Android Studio as ferramentas do DDMS ainda existem, mas foram integradas na aba Extended Controls do AVD, que fica na última opção à direita do AVD, como mostra a imagem abaixo:

Nessa aba Extended Controls (Controles Estendidos) nós temos acesso à diversos recursos bem interessantes, como um simulador de GPS (mostrado na foto acima), que eu já expliquei melhor nesse post onde ensino como fazer um app de GPS e nesse outro que eu ensino a usar mapas em seu app. Basicamente você pode simular posições GPS específicas ou até mesmo uma rota completa, com direito a fast-forward da rota (para ela ser feita mais rapidamente).

No Extended Controls também temos como mexer na rede do celular, como se tivesse acontecido uma troca de antena, por exemplo (muito comum quando se está usando o celular durante uma viagem de carro). Útil para testar como seu app se comportará quando a Internet oscilar (principalmente apps que usam bancos de dados remotos).

Você pode alterar também o nível de bateria do smartphone, para simular, por exemplo, uma queda de energia com seu app rodando. Muito útil, principalmente para apps multimídia como jogos e players.

Você pode simular estar recebendo uma ligação no meio do uso do app, ou ainda um SMS, com o texto que quiser.

E por fim, pode brincar a vontade com os sensores gravitacionais do AVD simulando que ele está sendo inclinado, por exemplo, para ativar os acelerômetros.

Cada um deles exigiria um post inteiro para exemplificar a criação do app que permitiria seu teste, então fica pra próxima! Além destas opções também existem outras que eu considerei menos importantes, como a simulação do uso de impressão digital, um recurso cada vez mais presente em aparelhos de ponta.

Se você ainda usa alguma ferramenta antiga para desenvolver apps para Android, ela deve usar o DDMS ainda, que muda um pouco em aparência mas que possui as mesmas funcionalidades que o Extended Controls. Além disso, o utilitário de linha de comando que eu vou te ensinar a usar no tópico abaixo é onipresente e nunca falha!

#2 – Como usar linha de comando para manipular o AVD

O Android Studio conecta-se aos AVDs usando um socket chamado ADB, ou Android Debug Bridge, ou Ponte de Depuração Android. Esse ADB permite que nos conectemos ao AVD em uma determinada porta e que a gente envie comandos para ele via telnet.

Na verdade, tudo o que os Extended Controls e o antigo DDMS permitem fazer visualmente acaba gerando comandos que são enviados ao AVD. Você pode usar a própria aba de Terminal existente no Android Studio, que fica lá embaixo na ferramenta, ou então abrir uma janela do console normalmente.

Para se conectar ao AVD é preciso que ele esteja em execução e que você use o seguinte comando no terminal:

Onde localhost é a máquina local (afinal, o AVD também está na máquina local) e 5554 é a porta de conexão com o AVD. O telnet irá pedir autorização para se conectar, mais especificamente você precisa informar o comando auth seguido de um auth token que fica guardado em um arquivo oculto chamado .emulator_console_auth_token, na sua pasta de usuário. No Mac e Linux é muito simples de pegar essa informação via terminal mesmo, com o comando:

Dentro desse arquivo tem apenas o auth token, é só copiar e executar o comando abaixo logo após o telnet:

Ele vai exibir um Ok e vai passar a aguardar comandos para manipulação do AVD via linha de comando. Alguns comandos úteis são:

help <comando>: o mais útil de todos, lista os comandos existentes ou, se você passar o comando, explica o mesmo. Ou seja, se você digitar apenas help no terminal, receberá uma lista como abaixo:

Agora, se digitar apenas ‘help comando’, você terá mais detalhes do mesmo, geralmente a lista de sub-comandos e/ou parâmetros do comando, como no caso do ‘geo’, por exemplo:

E podemos fazer isso para os sub-comandos também, indefinidamente, como neste caso em que estou indo mais à fundo do sub-comando geo fix:

Simples, não?!

geo fix <longitude> <latitude>: altera a coordenada geográfica do AVD, bom para simulação GPS, assim como fiz em meus posts de como fazer um app que use GPS. Atenção: é primeiro longitude e depois latitude e cada um dos valores é um double (use ponto como separador decimal, à moda USA). Se não souber a latitude e longitude dos pontos geográficos que deseja simular, você pode buscar o local na Wikipedia, lá sempre mostra essa informação.

kill: fecha o emulador que você está conectado, útil para quando ele trava tudo. Na verdade faz o mesmo que o comando kill normal do console, mas sem precisar saber o PID do processo, uma vez que você já está conectado no AVD.

network speed <gsm|gprs|edge|etc>: muda a rede de telefonia do celular para simular, principalmente, a queda no tráfego de dados. Muito útil para testar apps que necessitem da Internet por diversos motivos, como se conectar a APIs.

power capacity <porcentagem>: altera a carga da bateria do celular, muito usado principalmente para simular estar acabando a bateria do smartphone. Algumas aplicações de tempo-real, como jogos, necessitam que você faça algum tipo de procedimento nestes casos para que o jogador não perca seus dados se o telefone desligar abruptamente.

sms send <numero> <mensagem>: envia mensagens fakes ao celular. Você pode usar esse comando tanto para testar a chegada de mensagens aleatórias quanto para verificar o recebimento de mensagens do seu próprio sistema. No iPhone, por exemplo, é bem comum quando o iOS envia um SMS para o smartphone ele mesmo já ler quando o SMS chega e tomar a ação apropriada (códigos de confirmação, por exemplo).

avd <start|stop>: serve para inicializar ou interromper um AVD. O start é mais complicado e exige o caminho do arquivo da system image, além de outros parâmetros de configuração (os mesmos configurados visualmente durante a criação do AVD, na área Advanced do assistente). Já o stop é mais tranquilo. Esse comando não tem uma real utilidade para testes em si, mas mais para controle do AVD mesmo.

sensor set <nome> <x>:<y>:<z>: esse comando serve para manipular os sensores do smartphone, principalmente manipula os acelerômetros (sensor acceleration). Primeiro você deve usar ‘sensor status’ para listar os sensores existentes (enabled), e depois chama o ‘sensor set’ passando o nome do sensor e os valores que vai passar pra ele separados por ‘:’.

rotate: muda a orientação de tela em 90 graus (sentido horário). Simples e útil para mudar a orientação via linha de comando.

Existem outros comandos que você pode acessar e estudar facilmente pelo comando help, mas considero os elencados acima como os mais importantes.

#3 – Como fazer testes no seu smartphone

Essa dica é bem simples e ao mesmo tempo muito útil. De longe a melhor dica de performance em testes é usar o seu próprio smartphone para os mesmos. Além de testar a real usabilidade do seu app em um dispositivo de verdade, a execução é muito mais veloz do que no AVD.

Para conseguir isso, você vai ter de seguir alguns passos:

  1. para alguns modelos de celular, é importante ter o Google USB Driver instalado como add-on no seu SDK Manager. Dê uma verificada em como você instala add-ons na dica #3 deste tutorial aqui;
  2. vá nas Configurações do seu smartphone e depois vá até a área onde diz as informações do aparelho (Sobre ou algo parecido), nesta tela, pressione 7 vezes o Build Number do seu Android (versão de compilação) que vai habilitar as Opções do Desenvolvedor.
  3. Nas Opções do Desenvolvedor, habilite a opção Depuração USB e se quiser aproveitar que está aí, marque a opção de GPS Fake que eu não lembro o nome exato agora. 😛
  4. Agora volte ao menu de Configurações e entre em Segurança. Lá, marque que você quer permitir apps de Fontes Desconhecidas (os apps que você desenvolve são de uma fonte desconhecida).
  5. com o Android Studio fechado, conecte o smartphone no computador usando um cabo USB. Espere a instalação de drivers terminar.
  6. Alguns aparelhos, como os Motorola G, exigem a instalação de drivers adicionais. Se for esse o caso, busque na Internet pelo modelo do seu celular seguido das palavras “adb interface” que é o driver de comunicação pra funcionar com o Android Studio. A maioria dos dispositivos Samsung que testei não tinha esse problema.
  7. Agora abra o Android Studio e mande executar sua aplicação, deve aparecer o seu smartphone como uma das opções para uso.

Pronto!

#4 – Máquinas virtuais concorrentes do Android Simulator

Muita gente não reclama só da lentidão do Android Studio, mas principalmente da lentidão dos AVDs padrões, usando o Android Simulator. As máquinas virtuais nativas costumam demorar muito tempo para bootar seus SOs, mesmo quando usamos versões antigas como a Gingerbread (2.3) com RAM sobrando pra ela (1024MB). Isso obviamente atrapalha e muito os testes que você precisa fazer de seus apps.

Claro, as dicas de performance que eu dei na dica #8 deste post ajudam bastante, mas caso nenhuma lhe sirva, confere essa lista de opções para você testar seus apps Android com outras máquinas virtuais que não o AVD nativo:

  • Genymotion: o mais profissional de todos e que eu uso em alguns casos. Possui performance superior ao Android emulator tradicional e licença free para uso pessoal. Exige que você instale primeiro o VirtualBox na sua máquina.
  • BlueStacks: mais usado por gamers para testar APKs, o melhor nesta categoria de apps. Muito já usei em conjunto com FakeGPS para testar Pokemon Go e outros jogos.
  • Droid4x: novo e com alguns bugs, mas está crescendo bastante e promete muito para o futuro
  • Andyroid: também novo mas com algumas features bem legais como uma sincronização com seu desktop e a possibilidade de usar o seu smartphone real como sendo o “controle” da VM.
  • AMIDuOS: funciona só no Windows e é pago, mas já ouvi muitos elogios dele
  • YouWave: versão free cheia de ads, não gostei.
  • NOX: foco em games e concorrente do BlueStacks
  • Xamarin Android Player: mais usado pelo pessoal que usa o referido framework para apps multi-plataforma.
  • Manymo: Android emulator online, roda os apps no browser (!!!)
  • MEMU: começando agora, possuem muito chão pela frente pra ganharem mercado

Os dois únicos que eu realmente posso opinar, por ter usado bastante, são o GenyMotion, o mais profissional deles, e o BlueStacks, mais usado para testar APKs prontos, principalmente games. No caso do GenyMotion, você cria AVDs assim como no Android Studio e dá o play neles. Quando você for rodar um app no Android Studio para testar, ele vai lhe listar o AVD do GenyMotion que já está ligado. Bem simples.

Espero que tenham gostado das dicas e que consigam melhorar os testes dos seus apps!

Se quiserem ainda mais dicas bacanas do Android Studio, confiram este tutorial repleto delas.

Criando apps para empresas com Android

Como criar um app Android com mapa

Depois que escrevi o post sobre como criar um app Android com GPS muitos leitores me pediram para fazer uma parte 2, contendo um tutorial de como pinnar um local no mapa do Google dentro de um app. Isso é algo extremamente fácil de fazer em plataformas híbridas como Phonegap, mas gera um tanto de dúvidas em apps nativos, motivo do post de hoje.

Veremos neste post:

Criando e configurando o projeto

Primeiro, crie um novo projeto no Android Studio chamado MapApp com qualquer versão de Android acima da 4 e escolha como activity inicial uma do tipo Map Activity, como na imagem abaixo.

Isso irá criar alguns arquivos diferentes no seu projeto. O primeiro deles, google_maps_api.xml, estará na pasta values e será aberto automaticamente quando seu projeto for criado, indicando que você deve, antes de mais nada, obter uma API Key do Google Maps para poder fazer essa integração.

Para obter tal API, acesse esse link e preencha todos os dados que eles pedirem para obter uma chave. Se o link não funcionar é porque está configurado para minha aplicação, mas não se preocupe, esse link está comentado no seu google_maps_api.xml, então é só copiar e colar, como mostra a imagem abaixo:

Depois que inserir a api key onde diz YOUR API KEY HERE, mande rodar o seu app para que veja que ele já funciona, pinnando a localização de Sidney, na Australia. No entanto, é bem provável que seu emulador inicie, mas não rode o app, exibindo alguma mensagem como “your application relies on Google Play Services which is not supported by your device”, isso porque essas integrações com APIs do Google não funcionam em emuladores por padrão. Temos que criar um tipo especial de emulador para que funcione.

Criando o AVD com suporte a Google APIs

Primeiro, você terá de baixar o pacote Google APIs para a versão do Android que pretende emular, como a 5.1.1 na imagem abaixo:

Depois que baixar, você deverá criar um novo AVD, usando a versão “Google APIs” de Android, como mostra a imagem abaixo:

Já a imagem abaixo mostra a criação da mesma máquina, mas no Eclipse:

A primeira vez que executar esse AVD com Google APIs, ele provavelmente irá ficar parado um tempo atualizando com a mensagem “Google Play services are updating”. Aguarde até que termine e possa usá-lo corretamente (se ficar muito tempo travado nessa tela, experimente fechar apenas o Android Studio e abrir de novo, às vezes o ADB se perde).

Atenção: caso não esteja usando o emulador nativo do Android SDK (o que vem no Android Studio), usando ferramentas de terceiros como o Genymotion, por exemplo, não vai funcionar seu app de mapa. Para fazer funcionar nessas plataformas de terceiros, que não vem com o Google Play Services instalado, você vai precisar fazer mais alguns passos.

Exibindo o mapa

Depois que o AVD terminar de atualizar, e estiver plenamente funcionando apenas mande rodar seu app que você verá o mapa funcionando com um pin em Sidney, Australia.

O app está pinnando esta localização por causa desse trecho de código aqui, presente no método onMapReady da classe MapsActivity.java:

Ou seja, caso você fixe a latitude e longitude no construtor da variável sydney, o mapa irá pinnar o local informado, como abaixo, onde pinei -30, -51, próximo a Porto Alegre/RS.

‘Bora fazer ele pinnar sua localização atual?

Marcando a posição atual

Primeiro vamos pegar emprestado alguns códigos de outro tutorial aqui do blog, o Como criar um app Android com GPS, que ensina como pegar a localização atual do dispositivo em coordenadas geográficas (latitude e longitude).

No mesmo método onMapReady, vamos pegar as coordenadas geográficas atuais para instanciar o objeto corretamente, como abaixo:

Neste exemplo, usei um try/catch para suprimir a mensagem de erro de falta de permissão, desnecessária em Androids anteriores ao 6. Inclusive o próprio projeto já foi criado com a permissão de GPS devidamente adicionada no AndroidManifest.xml. Caso vá rodar este exemplo em um Android 6+, dê uma olhada na forma como pedi as permissões de GPS pro usuário corretamente no post sobre o GPS do Android.

Basicamente este código pega a informação de latitude e longitude atual fornecida pelo sensor de GPS e criar um marcador (pin, marker, etc) adicionando-o no mapa. Inclusive se você brincar via telnet com o seu emulador, consegue pinnar diversos locais usando o comandos geofix como abaixo:

O que acaba adicionando diversos pins no mapa. Mas como resolver isso?

Nessa variação final, eu adiciono apenas um marker, e vou atualizando ele conforme as coordenadas do GPS mudem, evitando os múltiplos pins no mapa (que podem ser úteis em algum projeto seu também). Por padrão, defini que o marker fica apontando para Porto Alegre/RS.

Lembrando que você pode alterar uma localização GPS fake no emulador facilmente pelos controles extendidos, usando as reticências na sidebar de apoio do emulador, conforme na imagem abaixo.

E por hoje é isso. O que achou deste tutorial? Funcionou para você? Deixe aí nos comentários a sua percepção!

Criando apps para empresas com Android