Google Android
para Tablets
Aprenda a desenvolver aplicações para
o Android – De smartphones a tablets
Ricardo R. Lecheta
Novatec
Copyright © 2012 Novatec Editora Ltda.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998.
É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização,
por escrito, do autor e da Editora.
Editor: Rubens Prates
Revisão gramatical: Alessandro Thomé
Editoração eletrônica: Carolina Kuwabata
Capa: DesignCRV
ISBN: 978-85-7522-292-8
Histórico de impressões:
Fevereiro/2012
Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
E-mail: [email protected]
Site: novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
Dados
Internacionais de Catalogação na Publicação
(Câmara Brasileira do Livro, SP, Brasil)
Lecheta, Ricardo R.
Google Android para tablets : aprenda a
desenvolver aplicações para o Android : de
smartphones a tablets / Ricardo R. Lecheta. -São Paulo : Novatec Editora, 2012.
Bibliografia.
ISBN 978-85-7522-292-8
1. Android (Programa de computador) 2. Aplicação
de programa - Desenvolvimento 3. Computação móvel
4. Google 5. Internet sem fio 6. Tablets I. Título.
12-00857
CDD-005.26
Índices para catálogo sistemático:
1. Android : Plataforma de desenvolvimento para
aplicativos móveis : Tablets : Programa de
computador
005.26
VC20120131
(CIP)
Sumário
Agradecimentos..................................................................................................................13
Sobre o autor......................................................................................................................14
Prefácio..............................................................................................................................15
Capítulo 1 ▪ Introdução.......................................................................................................16
1.1 Introdução.............................................................................................................. 16
1.2 Desenvolvendo desde smartphones até tablets......................................................... 16
1.3 Android 3.x – Honeycomb...................................................................................... 17
1.4 Android 4.x – Ice Cream Sandwich.......................................................................... 17
1.5 Organização do livro.............................................................................................. 19
Capítulo 2 ▪ Aplicativo de exemplo......................................................................................23
2.1 O projeto............................................................................................................... 23
2.2 Criando o projeto..................................................................................................26
2.3 Criando a tela principal – Dashboard......................................................................29
2.4 Criando os layouts de cabeçalho e rodapé............................................................... 35
2.5 Adicionando os eventos nos botões do dashboard...................................................38
2.6 A classe Carro........................................................................................................40
2.7 Arquitetura de integração com o legado.................................................................. 41
2.8 Requisição HTTP para ler o arquivo XML...............................................................42
2.9 Criando um projeto biblioteca para o projeto.......................................................... 49
2.10 Criando testes unitários com JUnit........................................................................ 53
2.11 Verificando se existe conexão de dados disponível..................................................58
2.12 Trabalhando com threads...................................................................................... 61
2.13 A classe AsyncTask................................................................................................63
2.14 Criando a interface para a lista de carros com um ListView.................................... 67
2.15 Criando o adapter para a lista de carros................................................................. 69
2.16 Encapsulando o AsyncTask para tornar o código mais simples................................ 81
2.17 Exibindo os detalhes do carro selecionado............................................................. 85
2.18 Exibindo a tela de sobre com um WebView............................................................ 92
2.19 Integrando Java e Javascript no WebView...............................................................94
2.20 Exibindo um ProgressBar enquanto o WebView não carrega.................................. 97
2.21 Considerações sobre o exemplo........................................................................... 100
7
8
Google Android para Tablets
Capítulo 3 ▪ Controlando o estado de sua activity............................................................... 101
3.1 Vertical e horizontal............................................................................................... 101
3.2 Forçando a tela a trabalhar na orientação desejada................................................ 102
3.3 Criando telas diferentes para a vertical e a horizontal............................................. 105
3.4 O problema: o Android destrói e recria a activity ao trocar de orientação................. 111
3.5 Salvando o estado da tela – onSaveInstanceState().................................................. 113
3.6 Salvando o estado da tela – onRetainNonConfigurationInstance()........................... 117
3.7 Salvando o estado da tela – Qual método utilizar?.................................................. 118
3.8 Fazer cache das imagens para melhorar a performance........................................... 122
3.9 Alternando o layout manualmente sem a necessidade de destruir e recriar a tela –
android:configChanges........................................................................................ 126
3.10 O problema com a configuração do android:configChanges................................. 129
3.11 Smartphones com teclado.................................................................................... 130
3.12 A tela de aguarde durante a busca dos carros......................................................... 131
Capítulo 4 ▪ Trabalhando com diversos tamanhos de tela................................................... 137
4.1 Introdução............................................................................................................137
4.2 Exemplo prático sobre o problema de resolução.................................................... 138
4.3 Termos e notações utilizadas..................................................................................143
4.4 Convertendo pixels em dp e vice-versa.................................................................. 150
4.5 Customizando as imagens conforme a densidade da tela........................................155
4.6 A tag <supports-screens> no AndroidManifest.xml............................................... 156
4.7 A ordem que o Android utiliza para buscar os prefixos.......................................... 159
4.8 Mantendo a compatibilidade com Android 1.6 ou superior.................................... 160
4.9 Mantendo a compatibilidade com Android 1.5 ou superior.................................... 160
4.10 Melhores práticas para a criação de telas.............................................................. 162
4.11 Aplicativo dos carros customizado para tela grande.............................................. 163
4.12 Instalando um add-on para simular o GalaxTab................................................... 164
4.13 Customizando a tela para o GalaxTab, tela = large................................................ 165
4.14 O problema de duplicar o código..........................................................................173
Capítulo 5 ▪ Android 3.x para tablets “Honeycomb”............................................................ 174
5.1 Introdução.............................................................................................................174
5.2 Desenvolvendo aplicações para o Android 3.x.........................................................176
5.3 Criando um Emulador para Android 3.x................................................................176
5.4 Executando a aplicação dos carros no Android 3.x..................................................178
5.5 Preparando o projeto para Android 3.x................................................................... 181
5.6 Customizando a ActionBar para Android 3.x ou superior....................................... 186
5.7 Identificando se é um tablet com Android 3.x........................................................ 187
Capítulo 6 ▪ Fragments..................................................................................................... 192
6.1 Introdução........................................................................................................... 192
6.2 O problema ao reutilizar views em diversas activities............................................. 193
6.3 Como controlar o conteúdo de diversas views e diversas threads em paralelo.......... 196
Sumário
9
6.4 Criando o projeto com Android 3.x........................................................................197
6.5 Alterando o exemplo para utilizar fragments......................................................... 202
6.6 Ciclo de vida de um fragment................................................................................212
6.7 Exemplo para debugar o ciclo de vida de um fragment...........................................216
6.8 Buscar um fragment na tela.................................................................................. 220
6.9 Criando os fragments dinamicamente com FragmentTransaction........................... 224
6.10 FragmentTransaction – mais alguns exemplos...................................................... 227
6.11 Fragment back stack............................................................................................ 230
6.12 Biblioteca de compatibilidade.............................................................................. 230
6.13 Migrando o projeto dos Fragments para utilizar a biblioteca de compatibilidade.... 231
6.14 Detalhes sobre o ciclo de vida de um Fragment.................................................... 236
6.15 O método setRetainInstance(boolean)................................................................. 238
6.16 Ciclo de vida de um FragmentTransaction........................................................... 239
Capítulo 7 ▪ ActionBar....................................................................................................... 243
7.1 Introdução............................................................................................................ 243
7.2 Preparando o projeto de exemplos......................................................................... 244
7.3 Adicionando itens de menu via API....................................................................... 244
7.4 Adicionando itens de menu via XML..................................................................... 246
7.5 Utilizando o ícone do aplicativo como a home....................................................... 248
7.6 Trabalhando com Tabs.......................................................................................... 253
7.7 Inserindo uma view customizada na barra............................................................. 258
7.8 Métodos utilitários da ActionBar........................................................................... 263
7.9 ActionBar em versões anteriores ao Android 3.x..................................................... 264
Capítulo 8 ▪ Migrando o aplicativo para tablets.................................................................. 267
8.1 Introdução........................................................................................................... 267
8.2 Criando o projeto................................................................................................ 272
8.3 Analisando a metodologia utilizada para a migração............................................. 273
8.4 Adicionando a biblioteca de compatibilidade no projeto........................................ 274
8.5 Criando a classe base para os fragments................................................................ 275
8.6 Criando o fragment para o dashboard.................................................................. 278
8.7 Criando o fragment para a tela de sobre................................................................ 282
8.8 Dividindo a tela do dashboard em duas partes nos tablets..................................... 285
8.9 Tratando o layout diferenciado para tablets........................................................... 289
8.10 Criando o fragment para a tela de detalhes do carro..............................................291
8.11 Criando o fragment para a tela de listagem de carros............................................ 295
8.12 Criando o layout para a listagem de carros para tablets........................................ 299
8.13 Utilizando o fragment de detalhes na direita........................................................ 302
8.14 Navegação por Tabs na ActionBar para tablets...................................................... 305
8.15 Criando os itens de menu na ActionBar................................................................312
8.16 Implementando a ação do item atualizar na ActionBar..........................................315
8.17 Implementado a busca de carros com o SearchView..............................................319
10
Google Android para Tablets
Capítulo 9 ▪ Android 4.x – Ice Cream Sandwich.................................................................. 325
9.1 Introdução............................................................................................................ 325
9.2 Configurando o emulador do Android 4.x............................................................. 325
9.3 Android 4.0 ICS possui API Level = 14................................................................... 327
9.4 Executando a aplicação no Android 4.x ICS........................................................... 328
9.5 Verificando as outras telas da aplicação no Android 4.x ICS.................................... 331
9.6 Customizando o texto da ActionBar...................................................................... 332
9.7 Utilizando o menu físico para acionar os itens de menu da ActionBar..................... 334
9.8 Troca de orientação na versão smartphone com Android 4.x ICS............................ 336
9.9 Travando a tela na horizontal para os tablets......................................................... 339
Capítulo 10 ▪ Animações................................................................................................... 341
10.1 A classe Animation...............................................................................................341
10.2 Criando o projeto para as animações................................................................... 343
10.3 AlphaAnimation................................................................................................. 348
10.4 RotateAnimation................................................................................................. 351
10.5 ScaleAnimation.................................................................................................. 356
10.6 TranslateAnimation............................................................................................ 359
10.7 AnimationSet..................................................................................................... 362
10.8 AnimationListener..............................................................................................366
10.9 LayoutAnimationController................................................................................ 370
10.10 Interpolator........................................................................................................ 371
10.11 ViewFlipper....................................................................................................... 373
10.12 View customizada com animação ...................................................................... 376
10.13 Inserindo uma animação no projeto dos carros................................................... 378
Capítulo 11 ▪ Animações com Android 3.0.......................................................................... 382
11.1 O problema com a API de animações no Android 2.x............................................ 382
11.2 Property Animation – A animação criada a partir do Android 3.x.........................388
11.3 A classe ValueAnimator....................................................................................... 389
11.4 A classe ObjectAnimator..................................................................................... 393
11.5 ObjectAnimator – Criando uma animação alpha................................................. 395
11.6 ObjectAnimator – Girando um objeto................................................................. 397
11.7 ObjectAnimator – Scale....................................................................................... 398
11.8 ObjectAnimator – Movendo um objeto pela tela.................................................. 399
11.9 Criando um conjunto de animações com a classe AnimatorSet..............................401
11.10 AnimatorListener............................................................................................... 402
11.11 Inserindo uma animação no projeto dos carros....................................................406
Capítulo 12 ▪ Google Analytics e Google Mobile Ads........................................................... 410
12.1 Introdução ao Google Analytics............................................................................410
12.2 Criando uma conta no Google Analytics.............................................................. 411
12.3 Fazendo o download do SDK do Google Analytics................................................413
12.4 Criando os pageviews..........................................................................................416
Sumário
11
12.5 Visualizando os relatórios....................................................................................418
12.6 Introdução ao Google Mobile Ads – AdMobs....................................................... 420
12.7 Google Mobile Ads..............................................................................................421
12.8 Registrando a aplicação no AdMobs.................................................................... 422
12.9 Configurando o projeto...................................................................................... 426
12.10 Como adicionar um anúncio com o AdView....................................................... 428
12.11 Alterando os layouts das telas de carros.............................................................. 430
12.12 Verificando os logs............................................................................................ 432
12.13 Voltando à administração da AdMobs................................................................ 433
12.14 Configurando um banner para a versão Tablet.................................................... 433
Capítulo 13 ▪ Google TV.................................................................................................... 438
13.1 Introdução.......................................................................................................... 438
13.2 Preparando o ambiente de desenvolvimento......................................................... 439
13.3 Instalando o KVM.............................................................................................. 439
13.4 Instalando o Google TV Add-On.........................................................................440
13.5 Executando o emulador do Google TV................................................................ 442
13.6 Instalando a aplicação dos carros........................................................................ 443
13.7 Mais sobre o Google TV...................................................................................... 445
Índice remissivo................................................................................................................ 447
Google Android
para Tablets
Aprenda a desenvolver aplicações para
o Android – De smartphones a tablets
Ricardo R. Lecheta
Novatec
Copyright © 2012 Novatec Editora Ltda.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998.
É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização,
por escrito, do autor e da Editora.
Editor: Rubens Prates
Revisão gramatical: Alessandro Thomé
Editoração eletrônica: Carolina Kuwabata
Capa: DesignCRV
ISBN: 978-85-7522-292-8
Histórico de impressões:
Fevereiro/2012
Primeira edição
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
Fax: +55 11 2950-8869
E-mail: [email protected]
Site: novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
Dados
Internacionais de Catalogação na Publicação
(Câmara Brasileira do Livro, SP, Brasil)
Lecheta, Ricardo R.
Google Android para tablets : aprenda a
desenvolver aplicações para o Android : de
smartphones a tablets / Ricardo R. Lecheta. -São Paulo : Novatec Editora, 2012.
Bibliografia.
ISBN 978-85-7522-292-8
1. Android (Programa de computador) 2. Aplicação
de programa - Desenvolvimento 3. Computação móvel
4. Google 5. Internet sem fio 6. Tablets I. Título.
12-00857
CDD-005.26
Índices para catálogo sistemático:
1. Android : Plataforma de desenvolvimento para
aplicativos móveis : Tablets : Programa de
computador
005.26
VC20120131
(CIP)
capítulo 1
Introdução
1.1 Introdução
Atualmente, diversas pesquisas apontam o Android como o sistema operacional
para smartphones que mais cresce no mundo. Sua arquitetura simples, flexível e
ao mesmo tempo poderosa permite com que ele seja a base para muitos produtos,
que se beneficiam de sua plataforma.
A disputa no mercado de mobilidade está extremamente acirrada, com diversas
inovações e lançamentos acontecendo em todos os lugares, e mesmo os especialistas sentem dificuldade em acompanhar tamanha evolução.
Estamos na década da mobilidade, onde smartphones e tablets farão cada vez
mais parte de nosso dia a dia, e o mercado busca incessantemente por especialistas
no assunto para desenvolver aplicativos comerciais e coorporativos para os mais
diversos setores, como varejo, saúde, economia, jogos e muito mais.
O objetivo deste livro é fornecer uma base sólida para que se acompanhe esse
mercado e que se desenvolvam aplicações competitivas com o simpático sistema
operacional do robozinho verde.
1.2 Desenvolvendo desde smartphones até tablets
Para que se compreenda este livro recomendam-se conhecimentos básicos de
Android, para que se consiga acompanhar os exemplos.
Nosso objetivo é desenvolver, passo a passo, uma aplicação que funcione
desde nos smartphones com Android 1.6 até nos novos tablets com Android 3.x
Honeycomb.
16
Capítulo 1 ■ Introdução
17
Recentemente também foi lançado o Android 4.x Ice Cream Sandwich, o qual
visa unir as plataformas de desenvolvimento dos smartphones e tablets e trazer
as novas APIs, que inicialmente estavam disponíveis apenas no Honeycomb para
os smartphones.
Com todas essas versões do Android e toda a diversidade de aparelhos com
diferentes tamanhos de tela e resolução, surge uma dificuldade em desenvolver
aplicativos compatíveis com todos eles.
Nesta obra, a cada capítulo vamos evoluir nosso projeto, utilizando várias
boas práticas e dicas de desenvolvimento à medida em que os assuntos vão sendo
abordados.
Como foco principal temos o desenvolvimento de uma aplicação única para
smartphones e tablets, e ainda usufruindo de novos recursos, como Fragments e
ActionBar, disponíveis a partir do Android 3.x – Honeycomb.
1.3 Android 3.x – Honeycomb
Com a popularização dos tablets e a grande busca dos usuários por esses equipamentos surgiu a necessidade de otimizar e customizar o Android para que se
usufrua ao máximo do tamanho de tela disponível nesses aparelhos.
A resposta do Google para essa demanda foi o lançamento do Android 3.x,
conhecido como Honeycomb, com o objetivo de fornecer ao usuário uma ótima
experiência ao utilizar os tablets.
Durante a leitura vamos estudar as novas APIs disponíveis a partir do Honeycomb, como Fragments e ActionBar, e otimizar o projeto do livro para tablets.
A figura 1.1 exibe a aplicação dos carros executando em um tablet.
1.4 Android 4.x – Ice Cream Sandwich
Depois que o Android 3.x – Honeycomb foi lançado, com novos recursos e funcionalidades, surgiu uma grande necessidade de unificar as plataformas de desenvolvimento entre os tablets e smartphones. Para isso foi lançado o tão aguardado
Android 4.x – Ice Cream Sandwich (ICS), que unificou o sistema operacional,
permitindo que os smartphones pudessem utilizar os últimos recursos e APIs
disponíveis no sistema operacional.
18
Google Android para Tablets
Figura 1.1 – Projeto dos carros executando em um tablet com Android 3.x – Honeycomb.
A figura 1.2 exibe a aplicação dos carros funcionando em um smartphone com
Android 4.x – ICS.
Figura 1.2 – Projeto dos carros executando em um smartphone com Android 4.x – ICS.
Capítulo 1 ■ Introdução
19
1.5 Organização do livro
Esta obra é dedicada aos desenvolvedores Android que já desenvolvem aplicativos para esse sistema operacional, ou pelo menos conhecem o básico sobre a
plataforma.
O desenvolvimento do projeto já começa a todo o vapor no capítulo 2 e com
uma abordagem simples e direta. Para começar é construída, passo a passo, uma
aplicação que lista diversos carros separados por categoria, com todos os detalhes
necessários para um bom entendimento do exemplo.
Assuntos avançados, como tratamento de threads, requisições http, parser de
xml e até como criar projetos de biblioteca com classes reutilizáveis e um projeto
de testes, são explicados e detalhados já no capítulo 2.
A figura 1.3 exibe o projeto que teremos executado no final do capítulo 2.
No capítulo 3 é explicado como o Android trata a troca de orientação, onde
vamos estudar como criar telas específicas para a vertical ou a horizontal, detalhes importantes sobre o ciclo de vida das aplicações e como salvar o estado das
informações corretamente durante a troca de orientação.
O capítulo 4 explica a fundo o maior problema que temos com o Android hoje,
que é o fato de existirem diversos aparelhos com diferentes tamanhos de telas e
resoluções. Existem celulares pequenos, grandes e tablets, que não se diferenciam
somente pelo tamanho das telas, mas também pela sua resolução. Nesse capítulo
vamos estudar todos os detalhes que você precisa saber para dominar esse assunto,
para que seja possível criarmos aplicações que funcionem em diversos tamanhos
de tela. Esse é um capítulo bem teórico e apresenta uma base muito forte que
todos os desenvolvedores Android precisam dominar.
O livro é muito prático, e os detalhes para tratar as telas na horizontal e criar
layouts diferenciados, assim como aspectos avançados do ciclo de vida da aplicação, são abordados de forma simples.
No capítulo 5 seguimos com nossa abordagem, e agora o próximo passo
será a introdução ao Android 3.x – Honeycomb, onde discutiremos aspectos
importantes que devem ser levados em consideração ao migrar as aplicações de
smartphones para tablets.
Os capítulos 6 e 7 fornecem uma base sólida para as novas APIs de Fragments
e ActionBar, criadas para auxiliar o desenvolvedor no aproveitamento do grande
espaço disponível nas grandes telas dos novos tablets de 10”, assim como ajudar
na organização e manutenção do código.
20
Google Android para Tablets
Figura 1.3 – Aplicação dos carros para smartphone Android 2.x.
O capítulo 8 é onde começamos a migração da aplicação dos carros para tablets. O
resultado depois da utilização dos novos conceitos pode ser visualizado na figura 1.4.
No final desse capítulo a aplicação estará pronta e funcional, e teremos em um
único build uma aplicação que funciona desde em smartphones com Android
1.6 até nos novos tablets com Android 3.x. Além disso, é exibido um layout diferenciado para cada tipo de tela, para que se aproveitem ao máximo os padrões e
recursos disponíveis na plataforma.
Capítulo 1 ■ Introdução
21
Figura 1.4 – Aplicação dos carros executando em um tablet com Android 3.x de 10”.
No capítulo 9 é feita a introdução ao Android 4.x – ICS, e vamos verificar como
a aplicação construída para tablets pode executar em um poderoso smartphone
que vai usufruir dos novos recursos, inclusive da navegação por Tabs na ActionBar.
Esta obra não para por aí, e os capítulos 10 e 11 explicam as bibliotecas disponíveis para animação no Android 2.x e o novo framework de animação criado a
partir do Android 3.x, respectivamente. Diversos exemplos simples e práticos são
criados para explicar as animações, e no final desses capítulos vamos turbinar a
aplicação dos carros e criar alguns efeitos especiais.
No capítulo 12 vamos estudar como exibir anúncios do Google Mobile Ads –
AdMobs na aplicação e a possibilidade de ter lucro com o aplicativo sempre que
algum usuário clicar sobre um anúncio.
Outro assunto que vamos estudar é como utilizar o Google Analytics para
monitorar as telas acessadas da aplicação, assim como diversos eventos gerados,
para descobrir como o usuário está utilizando tal aplicação e posteriormente ter
acesso a interessantes relatórios e métricas.
A figura 1.5 mostra os anúncios sendo exibidos na aplicação dos carros.
22
Google Android para Tablets
Figura 1.5 – Anúncios sendo exibidos na aplicação.
Para finalizar, no capítulo 13 vamos verificar como a aplicação executa no
emulador da Google TV e dar um primeiro grande passo para desenvolver para
essa plataforma. A figura 1.6 exibe a aplicação dos carros na Google TV.
Figura 1.6 – Google TV.
O objetivo deste livro é criar uma aplicação, que será desenvolvida passo a
passo juntamente com você, a cada capítulo. Boa leitura.