B01IJQ0AU6_EBOK

Prévia do material em texto

SUMÁRIO
Sobre o Autor
Antes de Começar
Para quem é este livro
1 Introdução
As Gerações de Celulares
Dispositivos Móveis e seus Nomes
Market Share Mundial
2 Introdução ao Android
A Plataforma
Versões do Android
Como desenvolver
O Mercado de Aplicativos
3 A Ferramenta Android Studio
Instalando
Configurando
Explorando
Testando
4 Interface Gráfica
Layouts
Widgets Comuns
Containers
Dialogs
Menus
5 Entendendo as Activities
Mas o que é uma Activity?
Criando uma Activity
Eventos
Iniciando e Finalizando Activities
6 Acesso à Dados Locais
Arquivos
Banco de Dados
7 Acesso a Dados Remotos
Usando APIs
Criando APIs
API JSON com PHP
API JSON com ASP.NET
API JSON com Java Servlets
API JSON com NodeJS
8 Considerações Finais
Projetos de Apps para empresas
Publicação na Google Play
Política de Privacidade
Seguindo em frente
SOBRE O AUTOR
Luiz Fernando Duarte Júnior é Bacharel em Ciência da Computação pela Universidade Luterana
do Brasil (ULBRA) e Especialista em Desenvolvimento de Aplicações para Dispositivos Móveis
pela Universidade do Vale do Rio dos Sinos (UNISINOS). Carrega ainda um diploma de
Reparador de Equipamentos Eletrônicos pelo SENAI e duas certificações Scrum para trabalhar
com Métodos Ágeis: Professional Scrum Developer e Professional Scrum Master.
Atuando na área de TI desde 2006, na maior parte do tempo como desenvolvedor, é apaixonado
por dispositivos móveis desde que teve o primeiro contato com celulares em 1998, mexendo em
um Gradiente Skyway de sua mãe.
De lá para cá teve oportunidade de lidar com dispositivos móveis em diferentes oportunidades,
incluindo um emprego na área desenvolvendo para a finada plataforma Palm OS, fora centenas
de projetos solitários em J2ME, até que conheceu Android em 2011.
Foi amor à primeira vista.
Trabalhando com Android desenvolveu diversos projetos para empresas, incluindo grandes
marcas como Embelleze, LG, Ford e Renault, além de ministrar cursos de Android para alunos
do curso superior de várias universidades.
Um grande entusiasta da plataforma, espera que com esse livro possa ajudar ainda mais pessoas a
criarem seus apps e aumentar a competitividade das empresas brasileiras.
Além de desenvolvedor de apps, atua como professor do ensino superior no curso tecnológico de
Análise e Desenvolvimento de Sistemas na Faculdade de Tecnologia de Porto Alegre (RS), é
autor do blog http://www.luiztools.com.br, onde fala sobre empreendedorismo e
desenvolvimento de software, especialmente mobile.
Conheça meus outros livros:
Programação Web com Node.js
Scrum e Métodos Ágeis: Um Guia Prático
Java para Iniciantes
Hackeando sua Carreira
MongoDB para Iniciantes
Criando aplicações móveis com Corona
http://www.luiztools.com.br
http://www.luiztools.com.br/livro-nodejs
http://www.luiztools.com.br/livro-agile
http://www.luiztools.com.br/livro-java-i
http://www.luiztools.com.br/livro-marketing-pessoal
http://www.luiztools.com.br/livro-mongodb
http://www.luiztools.com.br/livro-corona
ANTES DE COMEÇAR
Antes de começarmos, é bom você ler esta seção para evitar surpresas e até para saber se este
livro é para você.
Para quem é este livro
Primeiramente, este livro não vai lhe ensinar a programar, ele exige que você já saiba isso, ao
menos em um nível básico (final do segundo semestre da faculdade de computação, por
exemplo). Segundo, este livro exige que você já tenha conhecimento técnico prévio sobre
smartphones, que ao menos saiba mexer em um e que preferencialmente possua um.
Parto do pressuposto que você é ou já foi um estudante de Técnico em informática, Ciência da
Computação, Sistemas de Informação, Análise e Desenvolvimento de Sistemas ou algum curso
semelhante. Usarei diversos termos técnicos ao longo do livro que são comumente aprendidos
nestes cursos e que não tenho o intuito de explicar aqui.
O foco deste livro é em ensinar o básico de programação de aplicativos para smartphones
Android focando nas pessoas jurídicas, ou seja, apps para empresas, que sempre foi o meu foco.
Simples assim. Não vou ensinar nada de iOS ou Windows Phone, apenas Android. Darei foco
aos smartphones, muito embora tudo o que foi visto aqui possa ser aplicado à tablets, sem
problemas.
Novamente, ensinarei o básico. Nenhum tópico avançado será tratado aqui e nenhuma API muito
específica, apenas o que já é nativo da plataforma Android e completamente focado para
empresas, novamente, apps para empresas pequenas e profissionais liberais. Não faremos um
Instagram ou um Angry Birds, mas muitos conceitos podem ser aplicados para criar um app
profissional de mensagens semelhante ao WhatsApp ou jogos simples no estilo Quiz.
Novamente, ensinarei a construir aplicativos. Nenhum game será exemplificado no decorrer do
livro e sugiro que busque livros específicos sobre o assunto se é isso que deseja fazer (em meu
blog você encontra outro livro que fala de games: http://www.luiztools.com.br). Como o foco
não é multimídia ou entretenimento, tão poucos os apps serão muito bonitos, focando na
simplicidade e sobriedade. Deixo o design por conta de quem está lendo, enquanto construímos
as interfaces de maneira simples e funcional.
Ao término deste livro você estará apto a construir aplicativos simples para smartphones
Android, com componentes de interface, transições de telas, layouts personalizados, integração
com APIs externas, banco de dados local e podendo testar tudo isso no seu próprio smartphone
ou no simulador Android que vem junto com a ferramenta de desenvolvimento que utilizaremos.
Além disso, terá uma noção abrangente do cenário mobile atual e do mercado em que está se
inserindo.
Atenção: se você não sabe o básico de Java, leia esse livro primeiro Java para Iniciantes, do
mesmo autor.
http://www.luiztools.com.br/livro-java-i
1 INTRODUÇÃO
Estamos vivendo uma Revolução Mobile. Ninguém tem dúvidas disso. A pergunta é: você está
preparado para surfar esta onda?
A teoria dos celulares é de 1947, mas somente em 1973 que a Motorola se tornou a pioneira
desse mercado ao construir o primeiro protótipo funcional de um telefone celular que, dizem as
histórias, foi utilizado pelo diretor da Motorola na época para realizar uma ligação para seu rival
da AT&T avisando que ele havia ganho a corrida tecnológica pelo primeiro celular.
Entretanto, ainda levou 10 anos para os primeiros aparelhos celulares chegarem ao mercado com
tamanho em torno de 30cm e pesando 1kg. O preço? Módicos U$4.000 que tornavam este um
item de luxo tanto quanto os carros que eram equipados com estes aparelhos, como Rolls Royces
e Bentleys. Sim, ou você acha que as pessoas carregavam aparelhos de 1kg no bolso?
No início os celulares eram usados somente para realizar ligações telefônicas. Somente em 1993
que surgiu o SMS, o sistema de envio de mensagens que até o surgimento recente do WhatsApp
dominava a mensageria telefônica mundial, pondo bilhões no bolso das operadoras.
Ainda nesse ano não tão longe do início da década de 90, surgiram os primeiros celulares com
funções PDA, como agenda de contatos, calendário de compromissos, alarmes, etc quando a
IBM passou a investir mais forte neste mercado. Os celulares estavam se tornando cada vez mais
úteis.
Em 1996, este artefato tecnológico começou a ganhar uma conotação de status. Não exatamente
neste ano que ter um celular se tornou motivo de status, mas foi em 1996 que a Motorola
novamente foi pioneira lançando o famoso Motorola StarTac, com design inspirado na nave
espacial da série Star Trek. Sim, design.
Estávamos entrando em uma era onde os celulares eram quase peças do vestuário como os
relógios. Na verdade, mais à frente os celulares acabaram substituindo parcialmente os relógios
de pulso, e de certa forma tem de combinar com a personalidade e vestes do seu dono, não é
mesmo?
Avançando no tempo, em 2001, a Kyocera, uma fabricante não tão famosa no Brasil, lançou o
primeiro smartphone do mercado. Ok, não era tão “smart” assim, não tinha tantos recursos
quanto os atuais, mas tinha um sistema operacional de verdade e não um firmware embarcado
em um hardware. Ele podia ser formatado, podiater aplicativos instalados. Não tínhamos à essa
altura uma loja de aplicativos ou sequer a liberdade de desenvolvê-los, mas abriu as portas para
as inovações que surgiram mais tarde.
Selfie tem sido a palavra mais usada atualmente nas redes sociais. Mas você parou para pensar o
que gerou essa onda de narcisismo digital?
Foi em 2002 que a Sanyo, outra fabricante de celulares pouco conhecida aqui no ocidente teve a
ideia de lançar um celular que viesse com uma câmera digital embutida. Claro, era uma câmera
VGA de 0.3MP, mas que gerou uma revolução na fotografia digital, permitindo que fabricantes
como a Nokia se tornasse a maior vendedora de câmeras digitais do mundo no ano seguinte,
devido ao sucesso de seus smartphones, principalmente a linha N Series.
Mas e a Internet? Hoje todos vivemos conectados à ela com nossos smartphones, certo?
Apenas em 2003 que o primeiro smartphone se conectou à web real, o HTC Danger. Além disso
ele foi o primeiro smartphone com comandos por voz algo que hoje é muito popular com o Siri
da Apple e o Google Now do Google.
E a revolução continuou em 2003 com a Nokia lançando o primeiro smartphone focado em
games, o Nokia N-Gage, que inclusive tinha um formato peculiar de console portátil, plataforma
de games e até algum tipo de rede social para os jogadores. Nokia Arena ou algo assim.
Foi em 2004 que a Motorola voltou a inovar com seus celulares-design, lançando o famosíssimo
Motorola Razr, mais conhecido como V3, que durante 3 anos consecutivos se manteve na lista
dos celulares mais vendidos no mundo inteiro, e aqui no Brasil não foi exceção.
Ter um V3 era chamar a atenção toda vez que tinha de tirá-lo do bolso para tirar uma foto,
atender uma ligação ou...praticamente apenas isso. O V3 não era um celular de ponta mesmo na
sua época, seu apelo era mais social, com design ultra fino, teclado no melhor estilo Tron e duas
câmeras de diferentes qualidades dependendo da versão.
E quantas versões, hein! Tinha V3 padrão (prata), Black, Pink, Dolce & Gabanna (dourado) e
muitas outras, sendo que o hardware variava pouco e o design mudava basicamente a cor.
Curioso não?!
Foi em 2005 que a Motorola lançou outro marco da indústria com a série Rokr que eram
celulares focados em ser os melhores tocadores de música do mercado. Com enorme capacidade
de armazenamento, um bom player e caixas estéreo de alta potência, os Rokrs eram junto com os
Sony Walkman os melhores celulares para se escutar música na época, fazendo a alegria de
quem tinha grana para comprá-los e escutar no caminho para a faculdade ou trabalho.
Foi praticamente o início da morte dos MP3 Players, que duraram no mercado mais alguns anos
até se extinguirem completamente. Afinal, para quê carregar um celular e um MP3 no bolso, se
um bom Rokr resolve os dois problemas?
Em 2007 temos o maior marco da indústria mobile moderna. Algo como a Revolução Francesa
dos dispositivos móveis, uma vez que toda uma indústria nova foi criada neste ano, a indústria
dos apps.
Foi com a Apple, que em seu princípio era uma empresa de computadores, que virou uma
empresa de tocadores de música com iPod, que criou o mais incrível de todos os smartphones até
então, o iPhone.
Mas o mais incrível de 2007 não é o lançamento do iPhone em si, que era um excelente telefone
e trazia um conceito completamente novo , com uma experiência completamente focada no
touchscreen (que não era uma tecnologia nova, diga-se de passagem), mas no ecossistema que a
Apple criou junto ao iTunes e a App store. Agora, qualquer desenvolvedor em qualquer lugar do
mundo podia escrever seu próprio aplicativo e distribuí-lo em um marketplace, alcançando
clientes do mundo inteiro.
O desenvolvimento de apps, até então centralizado nas mãos das empresas credenciadas junto às
fabricantes, agora estava aberto a qualquer desenvolvedor com um computador na mão e uma
ideia na cabeça. Se você hoje está pensando em desenvolver um app para colocar na Apple Store
ou na Google Play, agradeça à Apple por ter criado este modelo de distribuição de apps que
forçou toda a indústria a se reinventar.
Não demorou muito até o Google se manifestar e querer entrar nesta briga, lançando junto com a
HTC o primeiro smartphone Android, seu novíssimo sistema operacional, em 2008, o HTC
Dream.
Enquanto que o mercado esquentou absurdamente em 2010 com a Samsung se tornando a maior
fabricante de celulares do mundo, com a Nokia perdendo a liderança com seu defasado sistema
Symbian, com a BlackBerry entrando em colapso e perdendo seu lugar até mesmo para a
Microsoft, a Apple não se acomodava e antes do lendário Steve Jobs dizer adeus à empresa (e ao
mundo), o iPad foi lançado, iniciando todas em uma nova corrida por tablets de todos os tipos,
tamanhos e fabricantes. Os tablets não eram algo novo, fizeram parte de um passado não tão
distante, mas um passado desconectado que fez com que não fossem bem sucedidos. Hoje, um
tablet conectado à Internet é tão útil quanto um notebook ou computador para 90% das pessoas, e
muito mais conveniente.
A história não termina aqui, mas acho que você já entendeu, não é mesmo?
Market Share Mundial
Os números de 2017 mostram uma supremacia do sistema operacional Android sobre todos os
outros. Se esse livro tivesse sido escrito na década de 90 com revisões a cada 10 anos, mostraria
o quanto esse mercado mudou com o passar dos anos, com o surgimento e desaparecimento de
sistemas operacionais e fabricantes.
Esses números são de uma pesquisa da IDC e mostra que o Android reina no mundo inteiro, com
variações em cada continente, mas sempre com alguma folga, como nos EUA onde tem 60% do
mercado e na China, onde tem 90%.
2 INTRODUÇÃO AO ANDROID
Você sabia que não foi o Google que criou o Android?
O sistema operacional Android foi criado em 2005 por uma startup chamada Android Inc. Que
foi comprada pela empresa de Mountain View e se tornou a equipe que criou este fantástico SO.
Apenas em outubro de 2008 que tivemos o lançamento oficial do Android no mercado com o
primeiro smartphone Android, o HTC Dream.
Mais tarde, em 2010 tivemos o lançamento do Samsung Galaxy Tab, o primeiro tablet com
Android.
Talvez a maior inovação trazida pelo Android não tenha sido suas APIs, suporte a múltiplos
hardwares, não somente celulares, mas sim o fato de ser uma plataforma aberta, com todos seu
código fonte disponível para download e customização, inclusive para fins comerciais como bem
tem feito a Samsung nos últimos anos, que hoje fatura mais com o Android do que o próprio
Google.
A Plataforma
O Android é um sistema operacional que compartilha o mesmo kernel do Linux, escrito em C e
C++ com um pouco de linguagem de montagem Assembly.
Ao contrário do que se pensa o Android não é escrito em Java, o que na verdade o faria muito
lento se fosse verdade.
Outro mito relacionado ao Android é de que ele é de propriedade do Google.
Embora o Google seja o principal mantenedor da plataforma, o Android é propriedade da Open
Handset Alliance, um consórcio de empresas criado pelo Google e com participantes das
principais fabricantes de celulares do mundo como Motorola, Samsung e LG.
Curiosamente, em 2012 o Google comprou a divisão de mobilidade da Motorola, seja para
aumentar seu poder sobre o mercado ou apenas pensando em capitalizar melhor a plataforma.
Além do sistema operacional, a plataforma engloba uma camada de aplicação ou middleware, em
Java, onde a maioria dos aplicativos reside, conforme mostra a imagem abaixo.
Nesta camada o Android já entrega alguns apps genéricos como um browser webkit, um alarme,
uma agenda de contatos, uma calculadora e mais alguns.
A plataforma Android oferece suporte nativo à biblioteca gráfica OpenGL ES 2D e 3D para
renderização de apps e games, além de suporte nativo ao banco de dados SQLite.
Versões do Android
Desde seu lançamento em versões Alfa e Beta, o Android teve diversas versões, sempre com
nomes de sobremesas e em ordem alfabética, começando na letra C uma vez que já tivemos a A
(Alfa) e B (Beta).
O número de API entre parênteses é o número da biblioteca dedesenvolvimento, que usaremos
mais tarde.
● Versão 1.5 Cupcake (API 3)
● Versão 1.6 Donut (API 4)
● Versão 2.0 a 2.1 Eclair (API 7)
● Versão 2.2 Frozen Yogurt (ou FroYo, API 8)
● Versão 2.3 Ginger Bread (API 9 e 10)
● Versão 3.0 Honeycomb (API 11 a 13)
● Versão 4.0 Ice-cream Sandwich (API 14 e 15)
● Versão 4.1 à 4.3 Jellybean (APIs 16, 17 e 18)
● Versão 4.4 Kit Kat (API 19 e 20)
● Versão 5.0 Lollipop (API 21 e 22)
● Versão 6.0 Marshmallow (API 23)
● Versão 7.0 Nougat (API 24 e 25)
● Versão 8.0 Oreo (API 26)
Até a versão 2.3 o Android era praticamente 100% focado para smartphones e o uso destas
versões do Android em tablets era sofrível, embora existente até os dias atuais em dispositivos de
segunda linha do mercado chinês.
Somente na versão 3.0 que o Android passou a atender de verdade o mercado de tablets com a
versão Honeycomb, que era exclusiva para esse tipo de dispositivo. No entanto, essa nova versão
trouxe à tona outro problema da plataforma: a fragmentação.
No mundo inteiro diversos fabricantes lançaram celulares e tablets com versões diferentes do
Android, o que gera problemas até hoje para os usuários, vendedores, fabricantes e nós,
desenvolvedores.
A OHA e principalmente o Google tentou consertar essa fragmentação com a versão 4.0, a Ice-
cream Sandwich que visava unificar as vantagens da versão 2.3.3 com o suporte à tablets da
versão 3.0 em uma versão completamente reescrita e reestilizada.
Mais recentemente em 2014, o Google deu um novo empurrão em sua plataforma anunciando no
Google IO, seu evento global para os desenvolvedores, que estaria lançando versões do Android
para automóveis e wearables, ou seja, em breve teremos Android em nossos carros, óculos,
relógios e até mesmo roupas!
E a empresa californiana não está para brincadeira, junto com grandes montadoras como a
Hyundai, o Google montou em analogia à OHA a Open Automotive Alliance, com o intuito de
definir os padrões e escrever o futuro dos computadores de bordo e centrais multimídias dos
carros usando a plataforma Android.
Não obstante, o próprio Google Glass, óculos de realidade aumentada do Google que ainda
engatinha nas vendas, usa a plataforma Android.
E por fim, o suporte à Smart TVs e a aparelhos da linha branca como as geladeiras inteligentes
da Brastemp, mostram que o Android veio para ficar.
Como desenvolver
A dita plataforma Android não é apenas um sistema operacional. O Google não nos presenteou
apenas com um grande e gratuito sistema operacional para smartphones e tablets, mas com todo
um set de recursos para desenvolver para ele.
Para desenvolver para Android você precisa ter instalado em sua máquina o JDK (Java
Development Kit) e o Android SDK (Software Development Kit), que está disponível
publicamente aos desenvolvedores desde setembro de 2008.
Isto considerando o desenvolvimento nativo tradicional, com a linguagem Java. Neste post em
meu blog falo de outras possibilidades de desenvolvimento para Android:
http://www.luiztools.com.br/post/conheca-os-frameworks-de-desenvolvimento-mobile/
Como ambientes de desenvolvimento pode-se utilizar Eclipse, Netbeans ou IntelliJ, entre outras.
O SDK oficial engloba o ADT ou Android Development Toolkit, um kit de desenvolvimento que
pode ser instalado em IDEs compatíveis que fornece recursos de compilação e de conexão, como
o ADB, a Android Debug Bridge, e de simulação, como o AVD ou Android Virtual Device. Mas
nem só de plugins e componentes vive o SDK, ele possui todas as bibliotecas e APIs para
manipular os apps nativos da plataforma e os recursos de hardware do dispositivo, como GPS,
acelerômetros, tela sensível ao toque, redes de dados, etc.
Mas o desenvolvimento para Android, que é um sistema tradicional escrito em C, não está
restrito a esta linguagem. Pode-se desenvolver em Android com a plataforma .NET, com
HTML+CSS+JS, com a própria linguagem C e C++ (usando o NDK, o Native Development
http://www.luiztools.com.br/post/conheca-os-frameworks-de-desenvolvimento-mobile/
Kit), com a linguagem brasileira Lua e com muitas outras, com diferentes níveis de performance,
compatibilidade e sets de recursos.
Apesar dos aplicativos Android em sua maioria serem escritos em Java, a máquina virtual Java
(JVM) que roda nos dispositivos Android não é a tradicional que roda em desktops. E desde a
versão Kit Kat, existem variações: alguns dispositivos mais antigos usam a VM Dalvik, enquanto
outros mais novos usam a VM ART (Android Runtime).
Ambas são máquinas virtuais reduzidas, com seu próprio set de instruções (compatível entre
elas) e que não lê os mesmos bytecodes do Java desktop, ou seja, não há compatibilidade entre
os binários de ambas plataformas, e mesmo através de recompilação, nem todas bibliotecas Java
tradicionais funcionam no Android.
Tenha isso em mente, principalmente se quiser converter alguma aplicação desktop para mobile.
Se quiser mais sobre a Dalvik especificamente, recomendo a leitura deste post em meu blog:
http://www.luiztools.com.br/post/tudo-sobre-maquina-virtual-dalvik-do-android/
O Mercado de Aplicativos
O mercado de apps irá movimentar U$77 bilhões em 2017 segundo a Gartner, devido a um
volume de 268 bilhões de downloads de apps. São 2 milhões de apps para download na App
Store e mais 2.2 milhões na Google Play.
A empregabilidade de desenvolvedores de aplicativos está entre as mais altas do mundo, mesmo
dentro de um setor como a TI que já impressiona pelos números. Nos EUA os salários beiram os
U$100/h e mesmo dentro do Brasil não é raro encontrar empresas pagando salários de R$5.000 a
R$12.000 para bons desenvolvedores de aplicativos, conforme mostrado pelo site Glassdoor:
https://www.glassdoor.com/Salaries/brazil-android-developer-salary-
SRCH_IL.0,6_IN36_KO7,24.htm
O mais impressionante de tudo isso é que para entrar nesse mercado não é preciso muito.
Você pode desenvolver para Android com qualquer plataforma e com uma infinidade de
ferramentas gratuitas. Ao contrário do iOS, você pode distribuir e vender seus aplicativos
livremente sem pagar royalties a ninguém. Caso queira publicar na Google Play existe uma taxa
única de U$25 contra os U$99 anuais da Apple. 
Ou seja, todo o investimento é o de um computador e do seu tempo. Claro, se você está lendo
isso é porque comprou este livro também, então teve mais algum investimento ☺.
Devido a isso de vez em quando aparecem grandes cases de sucesso surpreendentes, como caso
de Robert Nay que aos 14 anos, estudante da 8a série da escola elementar, criou o game Bubble
Ball que com 9 milhões de downloads desbancou o trono de Angry Birds à época.
Tudo isso com um livro de programação mobile que encontrou na biblioteca de sua escola.
Mas que tipos de aplicativos movem este mercado?
Muitas são as opções de aplicativos para desenvolver, mas algumas categorias lideram em
números:
Consumo de API
Basicamente um app de consumo de conteúdo é um app que não possui conteúdo próprio, que se
conecta a alguma API ou feed para carregar seu conteúdo, como os apps de redes sociais, leitores
http://www.luiztools.com.br/post/tudo-sobre-maquina-virtual-dalvik-do-android/
https://www.glassdoor.com/Salaries/brazil-android-developer-salary-SRCH_IL.0,6_IN36_KO7,24.htm
de feed RSS, revistas digitais, mobile bankings, entre outros.
Utilitários
Um app utilitário é um app que lhe ajuda a realizar outras tarefas como ver o saldo da sua conta
bancária, escrever e-mails, ou os discos virtuais.
Entram aqui também os diversos apps de fotografia e compartilhamento de imagem e os apps
mensageiros e de localização.
Advergames
Advergames são os jogos associados a grandes marcas de produtos, como os jogos da Pepsi,
Toddynho, Doritos, Axe, Boticário e Rexona, só para citar alguns.
As grandes marcas estão cada vez mais investindo em jogos para engajar seu público de uma
maneira mais lúdica e alguns projetos de jogos que chegam nas agências digitais e estúdios
desenvolvimento chegam na casa dos R$100 mil.
Casual Games
Jogos casuais existem há décadas, divertindo seus jogadores nas horaslivres, nas filas dos
bancos, no ônibus e nas longas viagens.
Um jogo casual é aquele que é simples de jogar mas extremamente viciante.
Geralmente um jogo casual tem muitos níveis com pouca variação, para lhe manter o maior
tempo possível jogando, mas sem uma história geralmente. Em celulares, onde a jogabilidade é
limitada, os jogos casuais reinam absoluto.
Títulos como Clash Royale, Bejeweled e Candy Crush são exemplos de jogos casuais sendo que
a Supercell, empresa criadora do Clash Royale, vale bilhões no mercado de capitais.
Adaptações de Grandes Games
Grandes empresas de games como a Electronic Arts (EA) atualmente investem mais nas
plataformas móveis do que nos consoles e PCs.
Em parte isso se deve ao baixo índice de pirataria dos jogos mobile e ao custo de produção
menor que o dos jogos tradicionais. Seja lá o motivo, as adaptações de grandes games como
FIFA e Pro Evolution Soccer para celulares tem rendido milhões às contas de suas produtoras, só
para citar dois exemplos.
Futilidades
Nesta categoria encontram-se todos apps que não possuem uma utilidade prática mas que ainda
assim fazem enorme sucesso.
Exemplos incluem um ventilador que não faz vento, um app que zumbifica as fotos dos seus
amigos, flatulência digital e por aí vai.
Ganhando dinheiro com apps
Diversos são os valores destes aplicativos e 80% de todo o faturamento do mercado de apps
mobile vem de games gratuitos, que mais tarde vendem bens dentro do jogo ou usam de
publicidade. Os demais games possuem valores entre U$0,99 e U$12, sendo que a imensa
maioria se encontra na extremidade de menor valor.
Seja qual for o gênero ou preço, o fato é que o mercado de apps está bombando.
Empresas como a Evernote, possuem 100 milhões de usuário que geram mais de U$150 milhões
ao ano.
O Waze, popular app de mapas e rotas possui mais de 40 milhões de usuário e foi comprado pelo
Google por U$1,3 bilhões.
A Supercell, criadora de sucessos como Hay Day e Clash of Clans teve 51% de suas ações
compradas por U$1,5 bilhões por um banco japonês. 
Outra notória compra foi a do Instagram, que com 260 milhões de usuários foi comprado pelo
Facebook, no valor de U$1 bilhão entre dinheiro e ações da própria empresa.
A Google Play possui atualmente mais de 2.2 milhões de apps e por dia são ativados 850 mil
dispositivos Android no mundo.
O que você está esperando para ter o seu lugar ao sol?
Se quiser saber mais sobre como ganhar dinheiro com apps, recomendo este post do meu blog
http://www.luiztools.com.br/post/fiz-um-app-e-agora-como-ganho-dinheiro/
http://www.luiztools.com.br/post/fiz-um-app-e-agora-como-ganho-dinheiro/
3 A FERRAMENTA ANDROID STUDIO
Existem diversas ferramentas possíveis de se usar para desenvolver aplicativos para Android.
Nenhuma delas supera a criatividade e competência de um bom desenvolvedor, mas todas
ajudam a aumentar sua produtividade e lhe permitem criar apps cada vez mais profissionais.
Escolher uma boa ferramenta é uma boa maneira de começar na frente no desenvolvimento de
apps, uma vez que uma má ferramenta pode lhe atrasar em demasia ou mesmo fazer com que
perca tempo com configurações ou mesmo falhas de software ao invés de apenas programar.
Recomendo e uso no desenvolvimento deste livro a ferramenta oficial do Google, chamada de
Android Studio, uma IDE construída sobre o IntelliJ, outra IDE de código aberto assim como o
famoso Eclipse.
O Android Studio encontra-se, na época de escrita deste livro, na sua versão 3 e tem se mostrado
bem estável e com atualizações mensais, o que é uma boa vantagem, mostrando que o Google
realmente está investindo tempo e dinheiro no seu desenvolvimento.
Usaremos esta ferramenta durante os estudos do livro e pode baixá-la neste link (não instale
ainda): https://developer.android.com/studio/index.html .
Caso deseje usar outra ferramenta, em meu blog ensino como usar:
● Eclipse: http://www.luiztools.com.br/post/como-programar-apps-android-no-eclipse/
● NetBeans: http://www.luiztools.com.br/post/como-programar-apps-android-no-
netbeans/
Instalando
Antes de instalar o Android Studio você irá precisar ter o JDK instalado em sua máquina, que
pode ser baixado no site oficial da Oracle (na época de escrita deste livro a versão mais recente é
a Java 8): http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-
2133151.html
No site da Oracle existirão uma dezena de versões do JDK para baixar, procure o seu sistema
operacional na lista e baixe a versão mais recente.
Baixe e instale o JDK apenas avançando durante o instalador, para somente depois mandar
instalar o Android Studio. Caso você não instale nessa ordem, o Android Studio não irá
encontrar sozinho o JDK e exigirá que você configure seu sistema operacional manualmente,
definindo uma variável de ambiente JAVA_HOME para a pasta do seu JDK.
Assim que estiver com o JDK instalado, baixe a última versão do Android Studio (que na época
em que escrevo este livro é a 2.2) no site oficial: https://developer.android.com/studio/index.html
Baixe e instale o Android Studio apenas avançando durante o instalador. Após a instalação, siga
em frente executando pela primeira vez o Android Studio, seja pelo menu Inicializar do
Windows, pela pasta de aplicativos no Mac OSX ou como quer que chamem o “Inicializar do
Linux”.
Atenção: certifique-se de instalar o Android Studio em um caminho que não contenha espaços
em branco ou acentos, para evitar problemas de compatibilidade mais tarde.
https://developer.android.com/studio/index.html
http://www.luiztools.com.br/post/como-programar-apps-android-no-eclipse/
http://www.luiztools.com.br/post/como-programar-apps-android-no-netbeans/
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
https://developer.android.com/studio/index.html
Configurando
Ao abrir o Android Studio você deve visualizar a seguinte tela, logo após a splash screen. Clique
na opção Configure (no rodapé à direita) e depois em SDK Manager.
No SDK Manager você gerencia a versão das ferramentas do Android SDK que está usando com
o Android Studio, bem como quais versões de Android você tem instaladas na sua máquina.
Por padrão junto com a instalação já vem com a versão mais recente instalada e a menos que vá
desenvolver para alguma versão específica, essa será o suficiente para os exemplos deste livro.
Caso queira baixar alguma versão específica, ou tenha de atualizar alguma coisa no SDK,
marque as opções que deseja e clique no botão Ok que tudo será baixado e talvez você tenha que
reinicializar o Android Studio para que tudo volte a funcionar normalmente.
Mais tarde, já com a IDE aberta no modo de edição de código, caso deseje abrir o SDK Manager,
você pode clicar no ícone do mesmo que fica no lado direito da barra de ferramentas, com a seta
para baixo no Android (indicando download).
Evite a tentação de sair marcando todas opções e prefira as versões mais genéricas do Android
para trabalhar, como a versão 4.0.3, que atende a boa parte das exigências.
Você deve estar se perguntando: “Mas e as demais versões?”.
O Android tem uma característica peculiar que se você está desenvolvendo um software para a
versão 4 da plataforma, todas as versões mais recentes conseguirão usar este app, mas o contrário
não é válido.
Então não seria uma boa desenvolver sempre para a 1.5?
NÃO!
Isso porque a versão de SDK que escolhemos, também chamada de Minimum SDK restringe as
bibliotecas a que temos acesso. Por exemplo, se queremos usar algum recurso de comunicação
NFC, só encontraremos API para isso na versão 4.0 do Android.
Explorando
O Android Studio é uma IDE bem completa.
Possui um editor de código com code complete (ele vai te dando dicas conforme vai escrevendo
as palavras) e highlight syntax (ele colore as palavras reservadas conforme suas funções, bem
como comentários).
Possui ferramentas de depuração muito boas e já vem 100% integrado com o Android SDK,
incluindo alguns botões exclusivos e projetos para os apps que podemos querer criar.
Para explorar a IDE melhor vamos criar nosso primeiro projeto comela. Para isso, clique em
Start a New Android Project na tela inicial, ou se já estiver dentro da ferramenta, vá no menu
File > New Project.
Mantenha as informações iniciais que indicam o nome da aplicação (My Application), o domínio
da empresa e a pasta do projeto (dentro da pasta do seu usuário) e clique em Next.
Na tela que se abrir, a Target Android Devices, selecione a opção “Phones e Tablets”, informe
versão 4.0.3 do Android na opção Minimum SDK, ou a mais próxima que tiver disso. O Android
Studio vai lhe informar a porcentagem de dispositivos Android que seu app irá funcionar, o que
para a 4.0.3 é 100% dos dispositivos mundiais (ninguém usa mais a 2 ou 3).
Next e poderá escolher qual modelo de app irá usar para criar o seu. Escolha a opção Empty
Activity, que explicaremos do que se trata mais tarde.
Atenção: se você selecionar uma versão de Android que ainda não tenha baixado para sua
máquina, o Android Studio irá começar o download por conta própria agora mesmo, o que pode
demorar um pouco.
Avance e chegará à última tela, que lhe pede o nome da Activity (nem sabemos o que é isso
ainda), o nome do Layout e o Título da Activity. Deixe tudo como está e mande encerrar
clicando no botão de Finish.
Agora sim podemos explorar a ferramenta!
Atenção: o Android Studio é uma ferramenta bem pesada e com uso constante de Internet. Você
verá que muitas vezes ele poderá estar um pouco lento, principalmente nesta primeira etapa de
criação e configuração do projeto e mais para frente em etapas de compilação. Nesse post do
meu blog eu dou várias dicas de como melhorar a performance dele:
http://www.luiztools.com.br/post/como-deixar-o-android-studio-mais-rapido/
Project
Na imagem acima temos a seção Project, que lista toda a estrutura de pastas e arquivos do
projeto.
Mais tarde iremos estudar exatamente para que servem cada uma destas pastas e arquivos.
Por ora, apenas note que os fontes do nosso aplicativo ficam em app/java/ e por fim o pacote das
suas classes Java, onde estão a lógica do seu app. No meu caso é o pacote com o nome de
com.example.luizfduartejr.myapplication
Atenção: Se você não estiver vendo algo muito parecido com isso na sua ferramenta pode estar
com uma configuração de visualização do projeto diferente da minha. Note um botão “Android”
logo acima da pasta app, clicando nele você pode mudar a forma de ver e gerenciar o projeto.
O Menu View
Caso perca esta seção (Project) ou outra qualquer, você pode facilmente exibi-las novamente
usando o menu View > Tool Windows e escolhendo a janela ou seção que “perdeu” durante o
desenvolvimento.
É no menu View que temos também dois recursos muito interessantes para pessoas como eu, que
tem de dar cursos de Android: Enter Presentation Mode e Enter Full Screen.
A primeira opção otimiza toda área de trabalho do Android Studio para exibição em um telão,
com foco no editor de código em si. A segunda opção maximiza a área de trabalho e é indicado
para trabalhar em projetos com grande quantidade de código Java a ser analisado, e até mesmo
para aumentar o foco do desenvolvedor no projeto sem ser distraído com outras janelas.
Qualquer uma destas opções pode ser revertida acessando o mesmo menu View novamente e
clicando em Exit Presentation Mode ou Exit Full Screen, respectivamente.
Editor de Código
No centro da IDE, desde que uma classe Java esteja aberta (como MyActivity.java), você verá o
editor de código, organizado em abas para melhorar a navegabilidade entre os documentos que
estão sendo editados no momento, com a possibilidade de fechar quaisquer documentos que não
http://www.luiztools.com.br/post/como-deixar-o-android-studio-mais-rapido/
estão sendo usados no botão ‘x’ no canto direito de cada aba.
Cada um desses documentos pode ser aberto através da seção Project à esquerda, que foi vista no
tópico anterior. Por ora vamos nos ater às funcionalidades e não ao código que foi gerado
automaticamente durante a criação do projeto com o modelo Empty Activity.
Código 1: disponível em luiztools.com.br/livro-android-fontes
public class MainActivity extends AppCompatActivity {
@Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
}
}
O editor de código possui recursos de autocomplete e de highlight syntax, o que aumenta e muito
a produtividade e legibilidade do código, respectivamente.
A IDE também irá lhe avisar em tempo real sobre erros de codificação grifando as palavras em
vermelho, além de dicas de melhorias no seu código grifando as palavras em amarelo.
Na margem esquerda do editor temos algumas setas que permitem ocultar ou exibir pequenos
trechos do código, geralmente delimitados por chaves, indicando escopos isolados (ou seja,
grupos de comandos com um objetivo comum).
Outra característica do editor é que quando digitamos o nome de uma classe ainda não
referenciada, ele pode sugerir que você crie a classe automaticamente ou que importe uma classe
já existe com esse nome.
Editor de Layout
Com um arquivo de layout aberto, como activity_main.xml que foi gerado e deve estar em outra
aba do editor, o editor de código é substituído pelo Editor de Layout no centro da IDE, conforme
mostra a figura abaixo:
Neste Editor temos duas formas de visualização, que podem ser acessadas pelas abas no rodapé
do editor: “Design” e “Text”. Clique em cada uma delas e veja a diferença.
Com o modo Text selecionado, vemos basicamente o conteúdo do arquivo XML em si,
permitindo que toda a interface seja construída apenas através do uso correto das tags XML
permitidas e interpretadas pelo Android.
É dessa maneira que as interfaces gráficas são construídas em Android, o interpretador da
máquina virtual Java reduzida do Android lê o arquivo XML, sabendo exatamente o quê, onde e
como devem ser renderizados cada um dos elementos da interface.
Note que mesmo com a aba Text selecionada, ainda temos uma ferramenta visual à direita para
nos ajudar a entender o que estamos criando.
Quando alteramos o texto de algum controle na esquerda, o mesmo é automaticamente exibido
no simulador à esquerda.
Não obstante, o editor de código XML é muito bom e conta também com recursos como code
complete (vai dando sugestões enquanto você escreve) e highlight syntax (colore as palavras de
acordo com sua função), tornando muito produtiva a tarefa de construção de interfaces em modo
texto.
Ainda assim, se você preferir, pode utilizar a aba Design para construir sua interface
visualmente, arrastando componentes da Palette, que fica à esquerda do simulador.
A cada componente arrastado, um trecho novo de código é adicionado em background ao
arquivo XML de interface, ou seja, no fundo, só existe uma forma de construir o layout, sendo
que a Palette é apenas um recurso gráfico para facilitar sua vida.
O mais comum é que seja utilizado uma mescla das duas abordagens, utilizando a Palette para
criar o componente na interface e usando a aba Text para configurar o layout e suas propriedades
e às vezes até para copiar e colar alguns trechos.
Falando em propriedades, cada um dos atributos do nó XML do arquivo de layout é considerado
uma propriedade do componente.
Além disso, quando selecionamos um componente no modo de edição visual, na direita aparece
uma seção Properties, com as propriedades passíveis de configuração daquele componente,
conforme mostra a imagem abaixo, quando selecione com o mouse um TextView (rótulo de
texto):
Estas propriedades tanto podem ser manipuladas visualmente pela seção Properties quanto em
modo texto. Note que as mesmas propriedades aparecem nesse trecho de código do arquivo
XML de layout:
Código 2: disponível em luiztools.com.br/livro-android-fontes
<TextView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:text="Hello world!" />
E com isso terminamos nossa exploração inicial da interface da IDE Android Studio. A seguir,
testaremos esse app de teste, rodando nossa primeira simulação!
Testando
Para testar o AndroidStudio vamos criar nosso primeiro app, que na verdade será apenas um app
que exibirá a frase Olá Mundo na tela do simulador do smartphone.
Seguindo os passos da seção anterior, teremos um app de Hello World já pronto e basta
configurarmos um dispositivo virtual de testes, os chamados AVDs (Android Virtual Devices).
Para isso, com o Android Studio aberto, clique no ícone do AVD Manager, localizado na
Toolbar, com o ícone de um smartphone com o Android no cantinho.
Isso irá abrir a janela AVD Manager, como mostrado abaixo. O AVD Manager serve para
gerenciar as máquinas virtuais Android que usaremos para a maioria dos testes e exemplos
práticos deste livro.
Obviamente nada é melhor do que testar seus aplicativos em um dispositivo de verdade, o que
ensinaremos mais à frente, mas por ora, é importante conhecermos as ferramentas nativas para
teste.
No exemplo acima eu já possuo dois dispositivos virtuais de teste configurados.
Para criar um novo, clique no botão Create Virtual Device, que abrirá o wizard de configuração
do dispositivo. Neste wizard definimos todas as características de hardware e software do nosso
aparelho virtual.
Na primeira tela escolhemos a plataforma, “Phone”, o modelo de exemplo, “Nexus One” e
avançamos com o botão “Next”.
Na tela seguinte escolhemos a imagem do sistema que vamos utilizar no emulador.
Por padrão o Android Studio vem com a imagem do Android mais recente instalado, mas esta
janela do wizard irá lhe listar mesmo as imagens que você ainda não baixou, o que forçará o seu
download automaticamente se escolher alguma delas.
Se você tem um computador antigo ou sem CPU Intel (+5 anos), sugiro usar a versão 4.0.3 com
chip ARM (armeabi ou arm-v7). Se seu computador for mais novo e possuir chip Intel, selecione
o Android Lollipop com chip Intel (x86).
Na última janela do wizard temos a opção de definir o nome da máquina virtual (que deve ser
único e preferencialmente sem acentos), a escala da tela (para que seja melhor exibido no seu
computador, uma vez que alguns dispositivos podem ter resoluções maiores que a do seu
monitor).
Existem outras opçòes mais avançadas que não vem ao caso agora.
Antes de finalizar você pode ainda querer definir algumas configurações avançadas clicando em
“Show Advanced Settings”, como memória RAM do dispositivo (sugiro 1GB para Android 4+),
câmera frontal/traseira (que pode ser configurada para usar sua webcam ou uma imagem pré-
definida), memória interna, cartão SD, teclado físico e por aí vai.
Conforme necessitarmos de tais recursos de hardware voltaremos nesta parte para configurá-los.
Clique em Finish e nossa VM será criada em poucos minutos, bastando clicar no botão de Play
para iniciar a emulação.
Atenção: A inicialização do Android pode demorar bastante dependendo das configurações da
sua máquina, então não é algo que irá querer vivenciar a cada vez que fizer uma alteração em seu
código. A dica é: após inicializar uma vez um AVD completamente, não o feche, até que não
tenha mais nada para programar em Android por hoje. Deixe a janela do AVD aberta, inclusive
podendo a fechar a janela do AVD Manager. Quando for testar seu código Java no dispositivo
virtual, ele já estará pronto e irá executar mais rapidamente.
Agora voltando ao Android Studio, com nosso app de Olá Mundo pronto de fábrica, vamos
clicar no botão de executar nosso aplicativo (Run), que é um ícone de Play na toolbar.
Quando clicamos neste botão uma compilação é realizada em nosso projeto e quaisquer erros de
compilação que existirem serão apresentados para que você resolva antes de continuar.
Caso não existam erros de compilação (o que não quer dizer que seu app está necessariamente
funcionando) o Android Studio irá perguntar em qual dispositivo o app será instalado para testes.
Note que ele lista tanto os dispositivos virtuais quanto os reais, caso algum esteja plugado via
USB no computador.
Ao marcar a opção “Use same device for future launches” fará com que o Android Studio não
lhe questione mais sobre qual dispositivo irá usar para testes, usando sempre o mesmo. Como
resultado, veremos nosso aplicativo rodando no simulador Android recém-criado.
Caso você queira testar no seu smartphone e ele não esteja aparecendo na lista de dispositivos
certifique-se que:
● a opção Depuração USB está habilitada (USB Debugging). Ela fica dentro de Opções
do Desenvolvedor, um menu secreto em alguns aparelhos, mas que geralmente abre
quando tocamos várias vezes no item Versão do Android.
● a opção Fontes Desconhecidas está habilitada (Unknown Sources). Ela fica dentro da
área de Segurança do Android.
● o cabo USB está devidamente conectado e o smartphone foi reconhecido
corretamente pelo seu sistema operacional. Muitos modelos exigem instalação do driver
de depuração, chamado ADB Interface, que pode ser obtido no Google pesquisando
juntamente com o nome do seu modelo de smartphone
Várias são as razões pelas quais vale o esforço de realizar os passos acima e testar seus apps
diretamente no smartphone, mas a principal delas é a performance.
É muito, mas muito mais rápido usar o smartphone para testes do que as máquinas virtuais
Android.
4 INTERFACE GRÁFICA
Vimos no capítulo anterior todo o básico para começarmos a utilizar o Android Studio para
criação e testes de apps simples.
Neste capítulo veremos o essencial sobre a construção da interface gráfica de nossos apps e o
funcionamento de seus controles para criar os efeitos desejados.
Toda Activity (imagine uma tela por enquanto) que possui interface gráfica deve carregar um
arquivo de layout logo que é criada, como uma de suas primeiras ações.
Isso é feito usando o método setContentView, que esperar o identificador único do layout que
será usado, que fica em R.layout (basicamente o nome do arquivo de layout sem a extensão
.xml).
Código 3: disponível em luiztools.com.br/livro-android-fontes
public class MainActivity extends AppCompatActivity {
@Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
}
}
Com isso dizemos que vamos exibir o layout activity_main.xml durante a execução da Activity
MainActivity.java e a partir da linha imediatamente abaixo à esta chamada, passa a ser possível
manipular todos os aspectos da interface desta tela do app.
Layouts
Um layout define a estrutura visual para sua interface com o usuário. Cada “tela” de um
aplicativo Android possui um arquivo de layout. Na plataforma Android, a aparência dos layouts
são descritas em arquivos XML que ficam na pasta res/layout do seu projeto, sendo que
inicialmente o próprio Android Studio já cria um layout padrão para você.
Em geral os layouts estão associados a uma classe Activity de nome semelhante, mas também é
possível criar layouts independente de código Java, clicando com o botão direito do mouse sobre
a pasta layout e selecionando a opção New > Layout resource file.
Assim como na biblioteca Swing para criação de aplicações gráficas desktop em Java, os
arquivos de layout definem os elementos de maneira relativa, e não absoluta como em
plataformas visuais de desenvolvimento como Delphi e Visual Basic.
Toda a organização dos componentes na tela, chamados em Java de widgets e em Android de
views, respeita a ordem prevista pelo gerenciador (ou gerenciadores) de layout que estivermos
utilizando. Voltando ao exemplo da aplicação MainApplication que apenas imprime um Hello
World na tela, note como o arquivo XML de layout inicia com a definição de um nó
ConstraintLayout.
Código 4: disponível em luiztools.com.br/livro-android-fontes
<ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:tools="http://schemas.android.com/tools"
 android:layout_width="match_parent"
 android:layout_height="match_parent"
 android:paddingLeft="@dimen/activity_horizontal_margin"
 android:paddingRight="@dimen/activity_horizontal_margin"
 android:paddingTop="@dimen/activity_vertical_margin"
 android:paddingBottom="@dimen/activity_vertical_margin"tools:context=".MainActivity">
<TextView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:text="Hello World!" />
</ConstraintLayout>
Todo arquivo XML de layout deve começar indicando qual o gerenciador de layout que irá
utilizar e, por padrão, o Android Studio cria com o gerenciador ConstraintLayout, que é o que
possui a maior responsividade de layout entre diferentes resoluções de dispositivo. Isso garante
que seu app irá se ajustar dinamicamente a cada tela sem precisar reescrever seu código.
De qualquer forma, dentro do nó raiz do Layout temos seus atributos, iniciados com “android:”,
a saber:
● layout_width: largura do layout. O valor match_parent garante que ele irá ocupar
toda a largura da tela do dispositivo.
● layout_height: o mesmo que o anterior, mas para altura do app.
● paddingLeft: a margem interna esquerda que os componentes dentro desse layout
terão de respeitar.
● paddingRight, paddingTop, paddingBottom: o mesmo anterior, só que para a direita,
para cima e para baixo, respectivamente.
Outras propriedades úteis ainda incluem:
● background: define uma imagem ou cor de fundo para a tela do aplicativo. As cores
são definidas através de constantes do Android, como @android:color/black e
@color/holo_blue_dark. Caso opte por uma imagem, a mesma deve estar na pasta
res/drawable do seu projeto, e é referenciada aqui com a sintaxe
@drawable/nomeDaImagem, sem a extensão da mesma.
Esses atributos são independentes do tipo de layout que escolhemos para nossa tela e recomenda-
se que você fique apenas com o ConstraintLayout, que é o mais atual e mais responsivo (se
ajusta melhor aos diferentes dispositivos)..
Atenção para unidades de medida: embora estejamos muito acostumados com o uso de pixels
(px) para medidas de resolução, em Android recomenda-se o uso de pixels independentes de
densidade (dp). Isso se deve ao fato de que diferentes dispositivos possuem resoluções diferentes
com densidade de pixels por polegada também diferente. O uso de dp ao invés de px torna o
dimensionamento dos componentes mais relativo e menos absoluto, evitando que alguns
componentes fiquem muito grandes ou pequenos em dispositivos com resoluções muito
diferentes do que as originais dos testes.
Constraint Layout
Constraint Layout é o gerenciador de layouts mais recente da plataforma Android. Ele é o
resultado das melhores características existentes nos layouts Relative e Linear, juntos em um
layout só. Ele baseia-se no conceito de posicionamento relativo de elementos (assim como o
Relative), onde cada componente está relativo à outro; e também possui preenchimento
proporcional de espaços (assim como no Linear), onde podemos definir de maneira semelhante a
porcentagem, o quanto de espaço cada componente vai ocupar.
Atenção: Apesar de ser um recurso novo da plataforma, ele é distribuído como uma biblioteca
que oferece suporte às versões de Android 2.3 ou superiores (API 9+). Caso esta opção de
Layout não esteja aparecendo para você, certifique-se de estar com as opções "ConstraintLayout
for Android" e "Solver for Contraint Layout" instaladas no seu SDK Manager (na seção SDK
Tools). Depois de instalar esses pacotes, você deve reiniciar o Android Studio e a partir de então
terá a opção de criar layouts com esse recurso.
Constraints significa algo como "restrições" ou "limitações", e são essas restrições que são o
cerne por trás do funcionamento deste layout manager, sendo fundamentais para sua utilização
entender elas primeiro.
Para definir a posição de um componente no ConstraintLayout você deve adicionar ao menos
uma constraint horizontal e uma vertical para a view. Cada constraint representa uma conexão ou
alinhamento em relação à outra view, o layout parent ou mesmo uma linha-guia invisível (??).
Cada constraint define a posição da view a partir de seus eixos vertical e horizontal; motivo pelo
qual temos de definir no mínimo essas duas constraints, embora seguidamente precisaremos de
mais de duas para conseguir os comportamentos desejados.
Quando você arrasta e solta uma view no Layout Editor, ela fica exatamente onde você deixar
ela, mesmo que não possua constraint alguma. No entanto, isso é apenas para tornar o seu
trabalho mais fácil quando estiver posicionando os elementos; se uma view não possui
constraints, ela ficará no canto superior esquerdo da tela automaticamente (0,0).
Embora a falta de uma constraint não cause um erro de compilação, o Layout Editor indicará a
falta de constraints como um erro na toolbar. Para ajudar você a não esquecer de constraints, o
Layout Editor pode automaticamente adicionar as constraints para você com os recursos
Autoconnect e "Infer Constraints" que são novidades na ferramenta e que mostrarei mais adiante.
Na imagem abaixo, eu arrastei um Button para o editor visual de interfaces.
Quando você solta o componente ele exibe bordas ao seu redor com ícones quadrados para
redimensionamento nos cantos do componente e ícones circulares para constraints nas laterais
dele.
Clique no componente para selecioná-lo. Então clique e segure um dos ícones circulares
(constraint handle) arrastando até um ponto de ancoragem disponível (a face de outro
componente, do parent layout ou uma linha-guia). Quando você soltar, a constraint será criada,
com uma margem default separando os dois componentes, como mostra abaixo.
Outra alternativa é simplesmente arrastar seus componentes e usar os recursos Autoconnect
(ícone U) e Infer Constraints (ícone de estrelas amarelas), acessíveis na toolbar logo acima do
Layout Editor.
O resultado, independente do método utilizado, vai ancorar o seu Button em alguma(s)
extremidade(s) da tela ou ainda em outros componentes.
Quando estiver criando constraints, lembre-se das seguintes regras:
● Cada componente deve ter ao menos duas constraints: uma vertical e uma horizontal.
● Você pode criar constraints somente entre um constraint handle (o ícone circular na
lateral) e um ponto de ancoragem que compartilhem o mesmo plano, ou seja, vertical
com vertical e horizontal com horizontal.
● Cada constraint handle pode ser usado para apenas uma constraint, mas você pode
criar várias constraints (de diferentes componentes) para um mesmo ponto de
ancoragem.
Para remover uma constraint, selecione o componente e então clique no constraint handle. Ou
remova todas constraints selecionando a view e depois clicando em "Clear Constraints" na
toolbar (ícone do x vermelho).
Quando adicionamos outros componentes à este layout, podemos ancorar estes novos
componentes em outros já existentes, como fazíamos com RelativeLayout no passado. No
exemplo abaixo, ancorei o plano vertical do segundo botão logo abaixo do primeiro botão.
Você notou que a linha da constraint fica "serrilhada" quando adicionamos constraints às duas
laterais do componente?
Neste caso elas atuam como âncoras opostas, cada uma puxando o componente para o seu lado, o
que resulta, por padrão, em uma centralização mesmo, como podem ver na imagem anterior.
Quando temos vários componentes no mesmo plano (horizontal ou vertical) podemos adicionar
pesos à eles, bem como remover as margens default e muito mais técnicas avançadas que
veremos ao longo do livro.
Por ora, exercite o posicionamento de componentes na tela tentando montar uma "cruz" com
Buttons. Será que você consegue?
Calma, eu não puxei todas essas constraints aí na mão, apenas posicionei os Buttons onde
gostaria que eles ficassem e usei o recurso Infer Constraints da toolbar do Layout Editor. Fácil,
não?!
É bem comum a necessidade de fazer um ajuste fino depois de utilizar esse recurso, pois ele tenta
criar as constraints para posicionar os elementos de maneira muito eficiente, mas não consegue
acertar 100% das vezes.
Outros Gerenciadores de Layout
Existem outros gerenciadores de layout como RelativeLayout, LinearLayout, etc. Entretanto,
devido à fragmentação da plataforma Android e flexibilidade do ConstraintLayout apresentado
acima, aconselha-se o uso do mesmo paraconstrução de seus apps.
Widgets Comuns
Durante os estudos do ConstraintLayout na seção anterior tivemos que criar um layout básico e
com isso você já deve saber o básico de arrastar e soltar componentes usando o editor visual.
Mas agora vamos realmente estudar os componentes do Android!
Widget é o nome dado aos componentes utilizados para compor uma interface gráfica em Java.
O termo vem de Windows + Gadgets, ou seja, “bugigangas de janelas”. A seguir iremos ver
alguns dos principais widgets disponíveis para a plataforma Android e como utilizá-los em
nossos apps.
Cada widget possui uma responsabilidade específica dentro dos aplicativos Android e conhecer
os essenciais lhe dará um conjunto poderoso de ferramentas para a construção de apps
corporativos.
Todo Widget possui uma série de propriedades que podem ser configuradas para que ele
aparente e se comporte da maneira desejada. Você pode configurá-las pelo editor visual ou pelo
editor XML, sendo este último bem preciso e fácil de usar, por causa do recurso de code
complete que permite ao desenvolvedor digitar apenas parte do nome da propriedade e a
ferramenta já completa para você.
Todo widget possui essencialmente duas propriedades obrigatórias:
● layout_width: largura do componente, podendo ser fixa em dps ou relativa como
match_parent (preenche toda largura do container externo) e wrap_content (expande
conforme o conteúdo do widget)
● layout_height: altura do componente, que se comporta de maneira análoga ao
layout_width
Caso você deseje manipular (inclusive ler) este widget no seu código Java, mais tarde, deverá
também definir um ID único para cada um dos seus componentes, usando a propriedade
android:id com a seguinte sintaxe @+id/widgetId, substituindo widgetId pelo identificador único
que deseje (como de praxe, sem acentos, espaços ou hífem).
Atenção com Ids: além das regras básicas de que um id não pode ter acentos, espaços ou hífem
é interessante que além de não se repetirem na mesma tela que eles não se repitam na mesma
aplicação, para evitar confusões depois. Outra dica é adotar um padrão de nomenclatura como
prefixo + função, muito comum entre diversos programadores.
Por exemplo, se trocarmos a visualização do Layout Editor para Text ao invés de Design,
veremos o código XML que gera aquela aparência dos botões que posicionamos no exercício
anterior.
Código 5: disponível em luiztools.com.br/livro-android-fontes
<Button
 android:id="@+id/btnNorte"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:text="Button"
 tools:layout_constraintTop_creator="1"
 tools:layout_constraintRight_creator="1"
 app:layout_constraintRight_toRightOf="parent"
 android:layout_marginTop="16dp"
 tools:layout_constraintLeft_creator="1"
 app:layout_constraintLeft_toLeftOf="parent"
 app:layout_constraintTop_toTopOf="parent" />
Note como boa parte deste código não foi escrita por mim, mas na verdade gerado pelo editor
visual. Aqui, a única alteração que fiz foi na propriedade android:id, que defini como
@+id/btnNorte, representando o botão mais ao norte no layout. Coloquei esse nome para ser
fácil de entender onde está cada componente mesmo que você esteja visualizando o XML ao
invés de estar vendo o Design.
A maioria dessas propriedades são idênticas à todos componentes que estudaremos neste
capítulo. Passaremos por cada um dos componentes principais da plataforma estudando suas
principais propriedades.
TextView
O TextView é o componente padrão para exibição de textos estáticos (que não permitem edição
do usuário) em apps Android.
Chamado de Label na maioria das outras plataformas, possui essencialmente a propriedade text,
que define o texto a ser exibido e as propriedades iniciadas por ‘font’ que definem as
configurações visuais do texto, como tamanho, cor, família, etc.
Para colocar um TextView em um formulário, você deve arrastá-lo da paleta para dentro do seu
layout, obtendo o código XML que segue (neste exemplo foi usado um Large Text):
Código 14: disponível em luiztools.com.br/livro-android-fontes
<TextView
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:textAppearance="?android:attr/textAppearanceLarge"
 android:text="Texto Grande"
 android:id="@+id/lblTeste" />
Note que defini a propriedade text como “Texto Grande” e a propriedade id como
“@+id/lblTeste”. O resultado esperado é bem simples, como segue:
Para manipular este TextView através do nosso código Java, devemos criar uma variável do tipo
TextView em nossa Activity, carregando-a com o método findViewById, que mostra a
importância de definirmos bons ids para nossos controles, visando nos lembrarmos deles depois.
Esse tipo de carregamento somente funciona se o controle existir no XML que foi carregado pelo
setContentView, bem como se chamarmos o controle após o carregamento do setContentView,
como no exemplo.
Código 15: disponível em luiztools.com.br/livro-android-fontes
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
setContentView(R.layout.activity_my);
TextView lblTeste = (TextView)findViewById(R.id.lblTeste);
String teste = lblTeste.getText().toString();
 lblTeste.setText("Outro teste");
}
Neste exemplo, carregamos a lblTeste e depois lemos seu conteúdo, para em seguida trocarmos
ele usando os métodos getText (leitura) e setText (escrita). Note que o método getText() do
TextView não retorna uma String, mas sim um CharSequence. Basta convertermos o mesmo
com o bom e velho toString() e o problema está resolvido.
EditText
Tão comum e útil quanto os TextViews, os controles EditText são campos de texto que podem
ser manipulados tanto via código quanto pelo usuário. O que diferem os EditText do Android dos
TextBox tradicionais de outras plataformas é o uso do teclado virtual. Muito comum em
smartphones, os teclados virtuais possibilitam que dispositivos touch exibam um teclado
completo para digitação nos campos, poupando custos de hardware (com teclados físicos) e
proporcionando uma experiência mais intuitiva.
Código 16: disponível em luiztools.com.br/livro-android-fontes
<EditText
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:inputType="textPersonName"
 android:text=""
 android:id="@+id/txtTeste"/>
Uma vez que a digitação em teclados virtuais nem sempre é tão prática quanto em teclados
convencionais, onde temos mais espaço para posicionar as teclas (e mãos), o Android fornece a
opção de definir o tipo de entrada que vai ser disponibilizada para o usuário, como textos
numéricos, nomes próprios, senhas, etc, o que muda automaticamente o comportamento do
teclado virtual, que passa a exibir primariamente os números ou letras, por exemplo.
Na paleta de componentes estão disponíveis uma série de componentes EditText pré-
configurados e você deve usá-los conforme a necessidade, sendo que suas configurações básicas
não mudam. Arraste um para um layout XML e veja o que acontece com o teclado virtual
quando você executa esse app no emulador Android: ele se ajusta para a digitação ser mais
coerente com o campo.
Esse efeito é da propriedade inputType que define o tipo de texto que planejamos colocar nesse
EditText. No caso do inputType estar com o valor textPersonName, o próprio teclado virtual vai
gerenciar o uso de maiúsculas e minúsculas nas palavras que irão compor o nome próprio que
será escrito, sem a necessidade de Shift ou Caps-Lock. Outros inputTypes possíveis incluem
numberDecimal, que faz com que o teclado virtual já venha com os números à mostra.
Independente do inputType do EditText, a sua manipulação através de código Java é idêntica.
Sempre que quiser definir o texto presente no EditText ou ler a informação que o usuário inseriu
lá, use o seguinte código Java:
Código 17: disponível em luiztools.com.br/livro-android-fontes
EditText txtTeste = (EditText)findViewById(R.id.txtTeste);
String texto = txtTeste.getText().toString();
txtTeste.setText("Novo teste");
Nesteexemplo, carregamos o EditText usando método findViewById, disponível em todas
Activities do seu projeto, passando o id do controle que estamos carregando. Imediatamente
abaixo podemos manipular qualquer propriedade do EditText, incluindo a notória propriedade
text, através dos métodos get e set definidos na especificação Java.
Atenção sobre foco: é possível colocar no editor XML uma marcação (tag) especial para dizer
que um EditText requer o foco da tela (i.e. será o primeiro a ser preenchido), conforme mostrado
abaixo.
Código 18: disponível em luiztools.com.br/livro-android-fontes
<EditText
 android:layout_width="match_parent"
 android:layout_height="wrap_content">
 <requestFocus />
</EditText>
Entretanto, caso o EditText seja o primeiro campo do formulário, ele automaticamente será o
foco da tela. Algumas vezes não queremos isso, como em barras de pesquisa, e para desabilitar
este recurso automático basta definirmos no layout imediatamente acima as propriedades
focusable=true e focusableInTouchMode=true.
Em geral você irá usar TextViews como rótulos e EditTexts como entradas de texto, em uma
combinação muito comum de ser vista em formulários de qualquer plataforma (web, desktop e
mobile). Entretanto, o controle EditText também lhe permite incluir um rótulo temporário dentro
do mesmo, como os populares placeholders da web, usando a propriedade android:hint. Um hint
fica visível com o texto que você definir até que o usuário toque no campo e preencha o seu
valor personalizado. Isto pode ser utilizado tanto para dar mais informações ao usuário quanto
para eliminar por completo o uso de rótulos e criar formulários que usem melhor dos espaços da
tela, como no exemplo abaixo.
Button e ImageButton
Nenhum formulário está completo sem botões. Seja para salvar, cancelar, limpar ou validar um
formulário, o widget Button pode ser usado. A diferença crucial entre o Button tradicional e o
ImageButton é que o segundo pode possuir uma imagem criada por você ao invés do tradicional
formato retangular com texto dentro. No mais, são exatamente iguais.
Arraste um Button para seu formulário (sendo que o Android define alguns tamanhos pré-
definidos de botões na paleta que podem lhe ajudar) e teremos o seguinte código no editor XML.
Código 19: disponível em luiztools.com.br/livro-android-fontes
<Button
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:text="Botão"
 android:id="@+id/btnTeste" />
Não há muito o que configurar em um botão tradicional. Você pode definir seu layout_width e
layout_height (largura e altura do botão), seu text, seu id (para ser usado depois no código Java)
e talvez até seu background (cor de fundo). Independente de qualquer configuração, é certo que
você irá querer que seu botão dispare algum código Java quando clicado. Para fazer isso, vamos
modificar levemente o código apresentado acima para incluir uma propriedade muito importante,
a onClick:
Código 20: disponível em luiztools.com.br/livro-android-fontes
<Button
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:text="Botão"
 android:id="@+id/btnTeste"
 android:onClick="exibirMensagem" />
Na propriedade onClick definimos o nome do método público da Activity que será executado
quando este botão for clicado. Caso este método não exista, isso irá gerar um erro no app, então
vamos até o código de nossa Activity para programar este método, que deve conter o mesmo
nome colocado na propriedade onClick, bem como apenas um parâmetro, do tipo View (essa é
uma obrigação do Android).
Código 21: disponível em luiztools.com.br/livro-android-fontes
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_cadastro);
}
public void exibirMensagem(View v){
 Toast.makeText(this, "Exemplo!", Toast.LENGTH_LONG).show();
}
O trecho de código que foi colocado dentro do método exibirMensagem é o chamado Toast em
Android. Um Toast (“torrada”) é uma mensagem de alerta que aparece e some sozinha, sem
interação do usuário. Os três parâmetros do método estático makeText são o contexto de
execução, a mensagem e o tempo de duração do Toast na tela. Quando botão for clicado, irá
exibir o Toast, como na imagem a seguir.
Como você já deve ter entendido, para cada botão que eu quiser que seja disparado em minha
Activity, terei de criar um método para tratar o evento onClick dele. Embora essa não seja a
única maneira de fazer a ligação do evento onClick como código Java, sem sombra de dúvida é a
mais fácil. Também é possível criar apenas um método para tratar todos os botões, pois o
parâmetro view contém todas as informações sobre qual o botão que disparou este método.
Entretanto esta abordagem não é usual, a menos que muitos botões tenham comportamentos
muito parecidos, como em uma calculadora.
Atenção com o Toast: é muito comum os programadores esquecerem que o Toast exige a
chamada do método show() para que apareça de fato na tela do app.
Para finalizar, com relação ao ImageButton, a única alteração a ser feita é a exibição de uma
imagem que já deve estar em seu projeto, na pasta de res/drawable, como esta abaixo, por
exemplo (vip.png). Cada imagem deve ter um nome único (como de praxe, não pode conter
acentos, hífen ou espaços) e este nome servirá como identificador único da mesma na aplicação.
Configuramos a imagem no botão da seguinte maneira:
Código 22: disponível em luiztools.com.br/livro-android-fontes
<ImageButton
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:src="@drawable/salvar"
 android:onClick="salvar"
 android:id="@+id/btnImagem"/>
Note que a propriedade src define qual a imagem que vai ser utilizada, sem a sua extensão (neste
caso, salvar.png). Note também que o ImageButton também possui uma propriedade onClick,
que define o método Java a ser executado na Activity que carregar este layout, assim como o
botão tradicional.
Atenção sobre imagens: imagens de botões geralmente são ícones que ilustram o que aquele
botão faz, como um disquete para salvar ou uma lixeira para excluir. Um bom site para baixar
ótimos ícones gratuitos é o http://www.iconfinder.com e outro é o http://www.findicons.com.
Você também pode carregar a imagem dinamicamente a partir da web ou a partir do cartão SD
do dispositivo do usuário, em tempo de execução. Para isto, veja mais à frente o funcionamento
do carregamento dinâmico de imagens como o widget ImageView, que é idêntico ao
ImageButton, com exceção de que não dispara eventos ao ser clicado.
Spinner
Muitas vezes precisamos exibir diversas opções aos usuários mas temos um espaço limitado para
tal. Um Spinner é um widget que permite que o usuário selecione apenas uma opção dentre
inúmeras disponíveis, como uma lista de estados ou de profissões. Em alguns frameworks este
controle também é chamado de ComboBox ou DropDownList.
Arraste um Spinner para um layout XML e vamos configurá-lo!
Código 23: disponível em luiztools.com.br/livro-android-fontes
<Spinner
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
http://www.iconfinder.com
http://www.findicons.com
 android:id="@+id/spinner" />
As opções que serão listadas no Spinner podem ser configuradas via arquivo XML ou via código
Java. Para configurar via arquivo XML (maneira mais fácil) você deve criar dentro da pasta
res/values um novo arquivo XML (Values resource files) com o nome de estados.xml (por
exemplo).
Coloque o seguinte conteúdo dentro dele:
Código 24: disponível em luiztools.com.br/livro-android-fontes
<?xml version="1.0" encoding="utf-8"?>
<resources>
 <string-array name="estados">
 <item>RS</item>
 <item>SC</item>
 <item>PR</item>
 </string-array>
</resources>
Neste exemplo coloquei apenas os 3 estados do sul do país para não ficar tão extenso, mas você
deve ter entendido a ideia. Aqui criamos um array de Strings com o nome de “estados”, contendo
diversos itens, sendo cadaitem a sigla de um estado.
Agora no Spinner, para linkarmos o XML de estados com o widget, usamos a propriedade
entries, como segue:
Código 25: disponível em luiztools.com.br/livro-android-fontes
<Spinner
 android:layout_width="wrap_content"
 android:layout_height="wrap_content"
 android:id="@+id/spinner"
 android:entries="@array/estados"/>
Com isso, carrega-se o conteúdo do arquivo estados.xml para dentro do Spinner durante a
criação da tela no app, automaticamente, como mostra na imagem abaixo.
A outra maneira de carregarmos os itens do Spinner é através de código Java. A primeira opção é
ótima quando sua lista possui um número pré-definido de elementos e isto não será alterado no
decorrer do uso do app. Entretanto, em alguns casos é necessário carregar os dados de alguma
fonte externa, ou gerá-los dinamicamente por algum motivo.
A criação de um spinner dinâmico é idêntico ao que foi mostrado antes, exceto que não
definimos a propriedade entries do mesmo no XML e nem precisamos criar um arquivo XML
como feito com os estados. A grande mágica se dá no código Java onCreate da Activity, como
segue:
Código 26: disponível em luiztools.com.br/livro-android-fontes
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.cliente);
String[] array = {"RS","SC","PR"};
 ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
android.R.layout.simple_spinner_item, array);
 Spinner spinner = (Spinner)findViewById(R.id.spinner);
spinner.setAdapter(adapter);
}
Note que carregamos o spinner através do método findViewById buscando pelo id definido no
XML de layout. Logo abaixo, temos um array estático de Strings com os estados do sul/sudeste
do Brasil. Note que este array pode ser gerado dinamicamente ou mesmo criado através de uma
fonte externa, para que na linha de baixo, possamos inseri-lo em um ArrayAdapter. O Android
trabalha com ArrayAdapters para adequar cada elemento de um array a um layout de item e
usamos para isso um layout padrão do Android denominado
android.R.layout.simple_spinner_item, embora existam diversas outras opções e inclusive
podemos criar o nosso próprio layout de item para spinner.
O efeito é o mesmo do método anterior, como mostrado a seguir.
Caso a gente queira descobrir qual item que foi selecionado, no clique de um botão Salvar, por
exemplo, basta utilizarmos o método getSelectedItem() do Spinner, que retorna um object que
facilmente pode ser convertido para String usando toString(). O exemplo abaixo também mostra
como podemos definir, via código Java, qual será o elemento selecionado do Spinner.
Código 27: disponível em luiztools.com.br/livro-android-fontes
//carrega o spinner em uma variável local
Spinner spinner = (Spinner)findViewById(R.id.spinner);
//pega o item selecionado do Spinner em formato texto
String uf = spinner.getSelectedItem().toString();
//muda o item selecionado do spinner passando a posição
spinner.setSelection(1);
E por último, mas não menos importante, existem ocasiões em que você quer que alguma ação
seja realizada toda vez que um item for selecionado (imediatamente). Nestes casos, você deve
linkar o controle spinner com um código Java em sua Activity. Não há qualquer alteração a ser
realizada no XML do exemplo de carregamento do Spinner, apenas no código Java da Activity,
como segue.
Código 28: disponível em luiztools.com.br/livro-android-fontes
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.cliente);
String[] array = {"RS","SC","PR"};
 ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
android.R.layout.simple_spinner_item, array);
 final Spinner spinner = (Spinner)findViewById(R.id.spinner);
spinner.setAdapter(adapter);
spinner.setOnItemSelectedListener(new Spinner.OnItemSelectedListener() {
 @Override
 public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
 String uf = spinner.getSelectedItem().toString();
 Toast.makeText(getBaseContext(), "UF selecionado: " + uf,
Toast.LENGTH_LONG).show();
}
@Override
 public void onNothingSelected(AdapterView<?> parent) {
}
});
}
Note como foi criado uma variável Spinner no escopo da classe mas fora do evento onCreate.
Isso garante que a variável seja carregada apenas uma vez no onCreate e chamada quantas vezes
precisar dentro a activity. Este evento será disparado toda vez que um item do spinner for
selecionado.
Para o código a ser executado, apenas um Toast exibindo o estado que foi selecionado. Note que
poderia ser a chamada Java que você quisesse, como por exemplo carregar outro spinner na
sequência com as cidades daquele estado, por exemplo, ou ocultar/exibir outro campo.
O Spinner é um componente muito poderoso e ele permite inclusive que possamos criar layouts
inteiramente personalizados. Claro, essa não é uma tarefa muito trivial e é de necessidade
duvidosa uma vez que listagens complexas deveriam ser ListViews (ver mais adiante, na seção
de Containers). Entretanto, existe mais uma coisa “avançada” que devemos aprender antes de
avançar para o próximo widget: Spinners com chave-valor!
Basicamente queremos que o Spinner exiba um texto, como o nome do estado, mas quando a
gente quiser ler o que foi selecionado, queremos pegar um código, como a sigla do estado. Como
fazer isso? É mais fácil do que parece e primeiramente iremos precisar criar uma classe Estado
no package principal do nosso app. Nossa classe Estado, que está ilustrada abaixo, possui apenas
dois atributos (nome e sigla), um construtor e a sobrecarga do método toString forçando os
objetos de Estado a retornarem o seu nome quando forçados a se tornarem Strings. Por quê?
Veremos daqui a pouco, apenas confie em mim por enquanto!
Código 29: disponível em luiztools.com.br/livro-android-fontes
public class Estado {
 private String nome;
 private String sigla;
public Estado(String nome, String sigla){
 this.nome = nome;
 this.sigla = sigla;
}
public String getNome(){ return this.nome; }
 public String getSigla(){ return this.sigla; }
@Override
 public String toString(){ return this.nome; }
}
A seguir, o código de carregamento do nosso ArrayList de estados, que obviamente poderia ser
carregado a partir de um banco de dados ou webservice. Por ora, deixaremos estático dentro do
evento onCreate de uma Activity qualquer (a mesma que terá o Spinner de estados). Após
carregarmos os estados, criamos nosso ArrayAdapter, mas desta vez ao invés de usarmos Strings
simples usaremos um ArrayAdapter<Estado> que permite que coloquemos o nosso List<Estado>
dentro, para em seguida carregar nosso Spinner e definirmos o adapter com setAdapter.
Código 30: disponível em luiztools.com.br/livro-android-fontes
List<Estado> array = new ArrayList<>();
array.add(new Estado("Rio Grande do Sul", "RS"));
array.add(new Estado("Santa Catarina", "SC"));
array.add(new Estado("Paraná", "PR"));
ArrayAdapter<Estado> adapter = new ArrayAdapter<>(this,
android.R.layout.simple_spinner_item, array);
final Spinner spinner = (Spinner)findViewById(R.id.spinner);
spinner.setAdapter(adapter);
Como pode ter notado, este trecho é praticamente idêntico ao do Spinner normal que usa apenas
Strings. A diferença maior se dará em seu comportamento, então vamos programar o evento de
item selecionado do Spinner:
Código 31: disponível em luiztools.com.br/livro-android-fontes
spinner.setOnItemSelectedListener(new Spinner.OnItemSelectedListener() {
 @Override
 public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
 Estado uf = (Estado)spinner.getSelectedItem();
 Toast.makeText(getBaseContext(), "UF selecionado: " + uf.getSigla(),
Toast.LENGTH_LONG).show();
}
@Override
 public void onNothingSelected(AdapterView<?> parent) {
}
});
Note que ao usar o método getSelectedItem() sobre o objeto spnEstados conseguimos obter
acesso ao objeto Estado original e com isso podemos