Google Android

Desenvolvimento de Aplicativos Móveis usando “Android Studio”

Flávio Augusto de Freitas

Copyright © 2020 Flávio Augusto de Freitas

P UBLICADO POR F LÁVIO AUGUSTO DE F REITAS

GITHUB . COM / ZZ 4 FFF

Licensed under the Creative Commons Attribution-NonCommercial 3.0 Unported License (the
“License”). You may not use this file except in compliance with the License. You may obtain a
copy of the License at [Link] Unless required
by applicable law or agreed to in writing, software distributed under the License is distributed on an
“AS IS ” BASIS , WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and limitations under the License.

Primeira impressão?, Ainda não

 Sumário

I Introdução

1 Prefácio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Quem é o autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

II Visão geral

3 Visão geral sobre o Google Android . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.1 Introdução 15
3.2 Estrutura geral da plataforma Google Android 15
3.2.1 A arquitetura do Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.2 Aplicações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.3 Android Runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.4 Linux Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Para qual versão do Android devemos desenvolver as aplicações? 15

III Configuração

4 Ferramentas de Desenvolvimento para Android . . . . . . . . . . . . . . . . 19

4.1 A ferramenta de desenvolvimento Android Studio 19
4.2 Gerenciar Seu Projeto 65
4.3 Programar o app 81
4.3.1 Visão Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.4 Executar apps no Android Emulator 196
4.4.1 Visão Geral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
4.5 Seu Primeiro Programa Android Java - Hello, World! 304
4.5.1 Um Tutorial de Como Construir um App Android Hello World . . . . . . . . . . . . . 304
4.5.2 A Importância de Package Names e API Level . . . . . . . . . . . . . . . . . . . . . . . 307
4.5.3 Finalize o Assistente Create New Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
4.5.4 Executar o App Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
4.6 Observações gerais sobre o Android Studio 310
4.7 Baixando e configurando os componentes da ferramenta de desenvolvi-
mento 310

IV Introdução

5 Começando a programar no Android . . . . . . . . . . . . . . . . . . . . . . . . 313

5.1 Conhecendo a estrutura geral de um projeto no Android Studio 313
5.1.1 O diretório “app” (application) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.2 O diretório “res” (resources) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.3 O diretório “drawable” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.4 O diretório “layout” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.5 O diretório “values” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.6 O diretório “mipmap” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.1.7 O diretório “menu” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
5.2 Visão geral da ferramenta de desenvolvimento 314
5.3 Executando a nossa aplicação 314

V Widgets

6 Conhecendo as widgets do Android . . . . . . . . . . . . . . . . . . . . . . . . . 317

6.1 A paleta de componentes e suas widgets 317

VI Aplicações

7 Aplicativos Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

7.1 Desenvolvendo uma calculadora básica 321
7.1.1 Aplicação da calculadora em execução . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
7.2 Desenvolvendo uma aplicação simples de compras 321
7.3 Desenvolvendo uma aplicação de cálculo de salário 321
7.4 Desenvolvendo uma aplicação de lista de contatos 321
7.5 Desenvolvendo uma aplicação que visualiza imagens 321
8 Aplicativos Não Tão Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
8.1 Desenvolvendo um Sistema de Cadastro (Primeira versão) 323

9 Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

10 Propriedades e Eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

10.1 Widget TextView 327
10.2 Widget EditText 327
10.3 Widget Button 327
10.4 Widget CheckBox/RadioButton 327
10.5 Widget ListView 327
10.6 Widget ImageView 327

VII Conclusão
11 Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
Livros 333
Artigos 333
Outros 333
I
Introdução

1 Prefácio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Quem é o autor . . . . . . . . . . . . . . . . . . . . . 11
 1. Prefácio

Este livro não tem a pretensão de ensinar programação em Android Studio para pessoas que
não tenham conhecimentos básicos de programação e orientação à objetos, nem aqueles que não
tenham conhecimentos básicos de programação Java com orientação à objetos. Assim, seguiremos
utilizando a plataforma de desenvolvimento Android Studio, programação em linguagem Kotlin,
ainda que de um modo bem básico, afim de aclimatar você com esta linguagem e as demais que
advirão.
As experiências com alunos e professores mostrou ao autor deste livro os principais pontos de
dificuldades no aprendizado. Isso motivou uma abordagem um pouco diferente para este livro em
relação ao que é comum na maioria dos livros sobre o assunto.
A cada seção, apresentaremos diversos programas que servirão de motivação para os principais
conceitos da linguagem Kotlin. Os programas complementarão o aprendizado, pois ajudam a fixar
os conceitos vistos no livro e estimulam o estudante para conceitos avançados que fogem do escopo
deste livro.
Este livro foi composto usando a linguagem de typesetting LATEX 2ε usando a paleta de cores
oficial da Google para o Android conforme [androidlicensinglogo].
 2. Quem é o autor

Eu, professor Flávio Augusto de Freitas integro os quadros do Instituto Federal de Educação,
Ciência e Tecnologia do Sudeste de Minas Gerais - Campus Rio Pomba desde o ano de 1996.
Possuo graduação em Formação Prof. Disc. Especial. 2º Grau - Esquema I - CEFET-PR
Unidade de Curitiba (1996) e graduação em Tecnologia em Processamento de Dados pelo Centro
de Ensino Superior de Juiz de Fora (1994).
Sou Especialista em Matemática pela Unigranrio - RJ (1999). Atualmente sou professor de
EBTT - IF Sudeste de Minas Gerais de Rio Pomba e professor da graduação no curso de Ciência
da Computação.
Tenho experiência na área de Ciência da Computação, com ênfase em Engenharia de Software,
atuando principalmente nos seguintes temas: Android, Java e Matemática.
II
Visão geral

3 Visão geral sobre o Google Android . . 15

3.1 Introdução
3.2 Estrutura geral da plataforma Google Android
3.3 Para qual versão do Android devemos desenvolver
as aplicações?
 3. Visão geral sobre o Google Android

3.1 Introdução
O Android é uma plataforma de software que permite criar aplicativos para dispositivos móveis,
como smartphones e tablets.
O Android foi desenvolvido pela Google™, e posteriormente pela OHA (Open Handset
Alliance), uma organização que une várias empresas com o objetivo de criar padrões abertos para
dispositivos móveis.

3.2 Estrutura geral da plataforma Google Android

3.2.1 A arquitetura do Android
3.2.2 Aplicações
3.2.3 Android Runtime
3.2.4 Linux Kernel
3.3 Para qual versão do Android devemos desenvolver as aplicações?
III
Configuração

4 Ferramentas de Desenvolvimento para

Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1 A ferramenta de desenvolvimento Android Studio
4.2 Gerenciar Seu Projeto
4.3 Programar o app
4.4 Executar apps no Android Emulator
4.5 Seu Primeiro Programa Android Java - Hello, World!
4.6 Observações gerais sobre o Android Studio
4.7 Baixando e configurando os componentes da fer-
ramenta de desenvolvimento
 4. Ferramentas de Desenvolvimento para Android

4.1 A ferramenta de desenvolvimento Android Studio

O Android Studio é o ambiente de desenvolvimento integrado (IDE, na sigla em inglês) oficial

para o desenvolvimento de apps para Android e é baseado no IntelliJ IDEA (link em inglês). Além
do editor de código e das ferramentas de desenvolvedor avançadas do IntelliJ, o Android Studio
oferece ainda mais recursos para aumentar sua produtividade na compilação de apps Android,
como:

• Um sistema de compilação flexível baseado em Gradle

• Um emulador rápido com inúmeros recursos
• Um ambiente unificado que possibilita o desenvolvimento para todos os dispositivos Android
• A aplicação de alterações para enviar alterações de código e recursos ao aplicativo em
execução sem reiniciar o aplicativo
• Modelos de código e integração com GitHub para ajudar a criar recursos comuns de apps e
importar exemplos de código
• Frameworks e ferramentas de teste cheios de possibilidades
20 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Ferramentas de lint para detectar problemas

de desempenho, usabilidade, compatibilidade com versões, entre outros
• Compatibilidade com C++ e NDK
• Compatibilidade integrada com o Google Cloud Platform, facilitando a integração do Google
Cloud Messaging e do App Engine.
Esta seção traz uma introdução aos recursos básicos do Android Studio. Para ver um resumo
das alterações mais recentes, consulte Notas da versão do Android Studio.
Estrutura do projeto
Cada projeto no Android Studio contém um ou mais módulos com arquivos de código-fonte e
de recursos. Os tipos de módulos incluem:
• Módulos de apps Android
• Módulos de biblioteca
• Módulos do Google App Engine
Por padrão, o Android Studio exibe os arquivos do projeto na visualização de projetos Android,
como mostrado na Figura 1. Essa visualização é organizada por módulos para permitir o acesso
rápido aos principais arquivos de origem do projeto.
Todos os arquivos de criação podem ser vistos no nível superior em Gradle Scripts, e cada
módulo de app contém as pastas a seguir:
• manifests: contém o arquivo [Link].
• java: contém os arquivos de código-fonte do Java, incluindo o código de teste do JUnit
• res: contém todos os recursos que não são código, como layouts XML, strings de IU e
4.1 A ferramenta de desenvolvimento Android Studio 21

imagens em bitmap

A estrutura do projeto Android em disco difere dessa representação simplificada. Para ver a
estrutura de arquivos real do projeto, selecione Project na lista suspensa Project (exibida na Figura
1 como Android).

Também é possível personalizar a visualização dos arquivos do projeto para se concentrar em

aspectos específicos do desenvolvimento do app. Por exemplo, a escolha da visualização Problems
do projeto exibe links para os arquivos de origem que contêm erros reconhecidos de programação e
sintaxe, como a falta de uma tag de fechamento de elemento XML em um arquivo de layout.

Figura 2. Arquivos do projeto na visualização "Problems", mostrando um arquivo de layout

com problema.

Para ver mais informações, consulte Visão geral de projetos.

A interface do usuário

A janela principal do Android Studio é composta de diversas áreas lógicas, identificadas na

Figura 3.
22 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 3. Janela principal do Android Studio.

1. A barra de ferramentas permite realizar diversas ações, inclusive executar apps e inicializar
ferramentas do Android.
2. A barra de navegação ajuda a navegar pelo projeto e a abrir arquivos para edição. Ela
oferece uma visualização mais compacta da estrutura visível na janela Project.
3. A janela do editor é onde você cria e modifica o código. Dependendo do tipo de arquivo
atual, o editor pode mudar. Por exemplo, ao visualizar um arquivo de layout, o editor abre o
Editor de layout.
4. A barra de janela de ferramentas fica fora da janela do ambiente de desenvolvimento inte-
grado e contém os botões que permitem expandir ou recolher as janelas de cada ferramenta.
5. As janelas de ferramentas permitem acessar tarefas específicas, como gerenciamento de
projetos, pesquisa e controle de versões, entre outras. As janelas podem ser expandidas e
recolhidas.
6. A barra de status exibe o status do projeto e do próprio ambiente de desenvolvimento
integrado, bem como todos os avisos ou mensagens.
Você pode organizar a janela principal para ver mais espaço na tela ocultando ou movendo
barras e janelas de ferramentas. Também é possível usar atalhos de teclado para acessar a maioria
dos recursos do ambiente de desenvolvimento integrado.
A qualquer momento, você pode pesquisar o código-fonte, bancos de dados, ações, elementos
da interface do usuário, entre outros, pressionando duas vezes a tecla " "ou clicando na lupa no
canto superior direito da janela do Android Studio. Isso pode ser muito útil quando, por exemplo,
você quer localizar uma determinada ação do ambiente de desenvolvimento integrado e esqueceu a
forma de acionamento.
Janelas de ferramentas
Em vez de usar perspectivas predefinidas, o Android Studio segue o contexto e exibe automati-
4.1 A ferramenta de desenvolvimento Android Studio 23

camente as janelas de ferramentas relevantes de acordo com o trabalho. Por padrão, as janelas de
ferramentas mais comuns são fixadas na barra de janelas de ferramentas, nas bordas da janela de
aplicativos.

• Para expandir ou recolher uma janela de ferramentas, clique no nome da ferramenta na barra
de janelas de ferramentas. Também é possível arrastar, fixar, desafixar, anexar e desanexar
janelas de ferramentas.
• Para voltar ao layout padrão atual da janela de ferramentas, clique em Window > Restore
Default Layout ou personalize o layout padrão clicando em Window > Store Current Layout
as Default.
• Para mostrar ou ocultar toda a barra da janela de ferramentas, clique no ícone no canto
inferior esquerdo da janela do Android Studio.
• Para localizar uma janela de ferramentas específica, passe o cursor sobre o ícone de janela e
selecione-a no menu.

Também é possível usar atalhos de teclado para abrir janelas de ferramentas. A Tabela 1 lista
os atalhos para as janelas mais comuns.

Tabela 1. Atalhos de teclado para algumas janelas de ferramentas úteis.

Janela de ferramentas Windows e Linux Mac

Projeto Alt + 1 + 1
Controle de versões Alt + 9 + 9
Executar Shift + F10 ctrl + R
Depurar Shift + F9 ctrl + D
Logcat Alt + 6 + 6
Voltar ao editor
Ocultar todas as janelas de ferramentas Ctrl + + F12 + + F12

Caso queira ocultar todas as barras de ferramentas, janelas de ferramentas e guias do editor,
clique em View >Enter Distraction Free Mode. O Distraction Free Mode será ativado. Para sair
do Distraction Free Mode, clique em View> Exit Distraction Free Mode.

Você pode usar Speed Search para pesquisar e filtrar dentro da maioria das janelas de ferramentas
no Android Studio. Para usar ”Speed Search“, selecione a janela de ferramentas e digite a consulta
de pesquisa.

Para ver mais dicas, consulte Atalhos de teclado.

Preenchimento automático de código

O Android Studio tem três tipos de preenchimento automático de código, que podem ser
acessados usando atalhos de teclado.

Tabela 2. Atalhos de teclado para preenchimento automático de código.

24 Capítulo 4. Ferramentas de Desenvolvimento para Android

Tipo Descrição Windows e Linux Mac

Preenchimento bá- Exibe sugestões básicas para va- Ctrl + Espaço ctrl + Espaço
sico riáveis, tipos, métodos, expres-
sões, entre outros. Se você cha-
mar o preenchimento básico duas
vezes seguidas, verá mais resulta-
dos, incluindo membros privados
e membros estáticos não impor-
tados.
Preenchimento inte- Exibe opções relevantes de Control + + ctrl + + Espaço
ligente acordo com o contexto. O pre- Espaço
enchimento inteligente detecta
os tipos e os fluxos de dados
esperados. Se você chamar
o preenchimento inteligente
duas vezes seguidas, verá mais
resultados, incluindo cadeias.
Preenchimento de Preenche a declaração atual, adi- Control + + + +
declaração cionando parênteses, colchetes e
chaves ausentes, formatação etc.

Também é possível realizar correções rápidas e mostrar as ações de intenção pressionando

+ .
Encontrar código de amostra
O Buscador de exemplos de código do Android Studio ajuda a encontrar amostras de código
Android de alta qualidade oferecidas pelo Google de acordo com o símbolo em destaque no
momento no seu projeto. Para saber mais, acesse Encontrar exemplos de código.
Navegação
Veja a seguir algumas dicas de navegação no Android Studio.
• Alterne entre os arquivos acessados recentemente com a ação Recent Files. Pressione Ctrl +
E (no Mac, + E ) para chamar a ação “Recent Files”. Por padrão, o último arquivo
acessado é selecionado. Também é possível acessar qualquer janela de ferramentas por meio
da coluna esquerda dessa ação.
• Veja a estrutura do arquivo atual com a ação File Structure. Chame a ação “File Structure”
pressionando Ctrl + F12 (no Mac, + F12 ). Essa ação permite navegar rapidamente para
qualquer parte do arquivo atual.
• Pesquise e navegue para uma classe específica no projeto com a ação Navigate to Class.
Chame a ação pressionando Ctrl + N (no Mac, + O ). A ação “Navigate to Class” é
compatível com expressões sofisticadas, incluindo maiúsculas intermediárias (camel humps),
caminhos, navegar para linha e correspondência do nome do meio, entre muitas outras. Se
você chamar a ação duas vezes seguidas, ela mostrará os resultados das classes do projeto.
• Navegue para um arquivo ou pasta com a ação Navigate to File. Chame a ação “Navigate to
File” pressionando Ctrl + + N (no Mac, + + O ). Para pesquisar pastas em vez
de arquivos, adicione uma / ao final da expressão.
• Navegue para um método ou campo por nome com a ação Navigate to Symbol. Chame a
ação “Navigate to Symbol” pressionando Ctrl + + Alt + N (no Mac, + + O ).
• Encontre todos os fragmentos do código que referenciam a classe, método, campo, parâmetro
ou declaração na posição atual do cursor pressionando Alt + F7 (no Mac, + F7 ).
4.1 A ferramenta de desenvolvimento Android Studio 25

Estilo e formatação
Durante a edição, o Android Studio aplica automaticamente formatação e estilos, conforme
especificado nas configurações de estilo do código.
Você pode personalizar as configurações de estilo do código de acordo com a linguagem de
programação, incluindo a especificação de convenções para tabulação e recuo, espaços, quebras
de linha, chaves e linhas em branco. Para personalizar suas configurações de estilo de código,
clique em File Settings Editor Code Style (no Mac, Android Studio Preferences Editor
Code Style ).
Embora o ambiente de desenvolvimento integrado aplique automaticamente a formatação
durante a edição, também é possível chamar explicitamente a ação Reformat Code pressionando
Ctrl + Alt + L (no Mac, + + L ) ou recuar automaticamente todas as linhas pressionando
Ctrl + Alt + I (no Mac, ctrl + + I ).

Figura 4. Código antes da formatação.

Figura 5. Código depois da formatação.

Conceitos básicos do controle de versões
O Android Studio é compatível com diversos sistemas de controle de versões (VCS, na sigla em
inglês), entre eles Git, GitHub, CVS, Mercurial, Subversion e Google Cloud Source Repositories.
Depois de importar o app para o Android Studio, use as opções do menu “VCS” do Android
Studio para ativar a compatibilidade do VCS com o sistema de controle de versões em questão, criar
um repositório, importar os novos arquivos para o controle de versões e realizar outras operações
de controle de versões:
1. No menu VCS do Android Studio, clique em Enable Version Control Integration.
2. No menu suspenso, selecione o sistema de controle de versões a ser associado à raiz do
projeto e clique em OK.
Agora, o menu “VCS” exibe diversas opções de controle de versões, de acordo com o sistema
selecionado.
Observação: também é possível usar a opção de menu File Settings Version Control para
definir e modificar as configurações do controle de versão.
Sistema de compilação Gradle
O Android Studio usa o Gradle como o sistema de compilação de base, com outros recursos
específicos do Android disponibilizados pelo Plug-in do Android para Gradle. Esse sistema de
compilação é executado como uma ferramenta integrada no menu do Android Studio e de forma
independente na linha de comando. Você pode usar os recursos do sistema de compilação para
26 Capítulo 4. Ferramentas de Desenvolvimento para Android

fazer o seguinte:
• Personalizar, configurar e ampliar o processo de programação.
• Criar diversos APKs para seu app com diferentes recursos usando o mesmo projeto e os
mesmos módulos.
• Reutilizar código e recursos nos conjuntos de origem.
A flexibilidade do Gradle permite que você faça tudo isso sem modificar os arquivos de
origem principais do seu app. Os arquivos de versão do Android Studio recebem o nome de
[Link]. Eles são arquivos de texto simples que usam a sintaxe do Groovy para configurar
a criação com elementos fornecidos pelo Plug-in do Android para Gradle. Cada projeto tem um
arquivo de compilação de nível superior para todo o projeto e arquivos de compilação de módulo
separados para cada módulo. Quando você importa um projeto existente, o Android Studio gera
automaticamente os arquivos de compilação versão.
Para saber mais sobre o sistema de compilação e como configurá-lo, consulte Configurar sua
compilação.
Variantes de compilação
O sistema de compilação pode ajudar a criar versões diferentes do mesmo aplicativo a partir de
um único projeto. Isso é útil quando existe uma versão gratuita e uma paga do app ou quando você
quer distribuir vários APKs para configurações de dispositivo diferentes no Google Play.
Para ver mais informações sobre a configuração de variantes de compilação, consulte Configurar
variações de versão.
Compatibilidade com vários APKs
A compatibilidade com vários APKs permite a criação eficiente de vários APKs com base na
densidade de tela ou no ABI. Por exemplo, é possível criar APKs separados de um app para as
densidades de tela hdpi e mdpi, considerando-os ao mesmo tempo uma variante única, além de
permitir que eles compartilhem configurações de APK de teste, javac, dx e ProGuard.
Para ver mais informações sobre a compatibilidade com vários APKs, leia Desenvolver vários
APKs.
Redução de recursos
A redução de recursos no Android Studio remove automaticamente os recursos não utilizados
do aplicativo empacotado e das dependências de biblioteca. Por exemplo, se o aplicativo estiver
usando o Google Play Services para acessar a funcionalidade do Google Drive e você não estiver
usando o Login do Google no momento, a redução poderá remover os diversos recursos drawable
dos botões SignInButton.
Observação: a redução de recursos é utilizada em conjunto com ferramentas de redução de
código, como o ProGuard.
Para ver mais informações sobre a redução de código e recursos, consulte Reduzir código e
recursos.
Gerenciamento de dependências
As dependências do projeto são especificadas por nome no arquivo [Link]. O Gradle
se encarrega de encontrar as dependências e disponibilizá-las na versão. Você pode declarar
dependências de módulos, dependências binárias remotas e dependências binárias locais no arquivo
[Link]. O Android Studio configura os projetos para usarem o Maven Central Repository por
padrão. Essa configuração está incluída no arquivo de compilação de nível superior do projeto.
Para saber mais sobre como configurar dependências, leia Adicionar dependências de compilação.
Ferramentas de depuração e criação de perfil
O Android Studio ajuda a depurar e a melhorar o desempenho do código, o que inclui ferra-
mentas de depuração em linha e análise de desempenho.
Depuração em linha
Use a depuração em linha para melhorar o acompanhamento do código na visualização do
4.1 A ferramenta de desenvolvimento Android Studio 27

depurador com a verificação em linha de referências, expressões e valores de variáveis. As

informações de depuração em linha incluem:
• Valores de variáveis em linha
• Objetos de referência que referenciam um objeto selecionado
• Valores de retorno de métodos
• Expressões de lambda e de operadores
• Valores de dicas

Figura 6. Valor de uma variável in-line.

Para ativar a depuração in-line, clique em Settings na janela Debug e selecione a caixa
de seleção de Show Values Inline.
Criadores de perfis de desempenho
O Android Studio oferece criadores de perfis de desempenho para que você acompanhe mais
facilmente o uso de memória e CPU do app, encontre objetos desalocados, localize vazamentos
de memória, otimize o desempenho de gráficos e analise solicitações de rede. Com seu app em
execução em um dispositivo ou emulador, abra a guia Android Profiler.
Para ver mais informações sobre criadores de perfis de desempenho, consulte Ferramentas de
criação de perfis de desempenho.
Despejo de heap
Durante o monitoramento do uso de memória no Android Studio, você pode iniciar a coleta
de lixo e, ao mesmo tempo, despejar o heap do Java de um instantâneo de alocação heap em um
arquivo de formato binário HPROF específico do Android. O visualizador de HPROF exibe classes,
instâncias de cada classe e uma árvore de referência para ajudar a acompanhar o uso de memória e
localizar vazamentos.
Para ver mais informações sobre como trabalhar com despejos de heap, consulte Analisar o
heap e as alocações.
Memory Profiler
Você pode usar o Memory Profiler para rastrear a alocação de memória e observar onde os
objetos são alocados quando você realiza determinadas ações. O conhecimento dessas alocações
permite otimizar o desempenho e o uso da memória do app por meio do ajuste das chamadas de
métodos relacionadas a essas ações.
Para ver informações sobre como rastrear e analisar alocações, consulte Analisar o heap e as
alocações.
Acesso a arquivos de dados
As ferramentas do SDK do Android, como Systrace e logcat, geram dados de desempenho e
depuração para uma análise detalhada de aplicativos.
Para ver os arquivos de dados gerados que estão disponíveis, abra a janela de ferramentas
"Captures". Na lista de arquivos gerados, clique duas vezes em um arquivo para exibir os dados.
Clique com o botão direito do mouse em qualquer arquivo .hprof para convertê-lo ao formato
padrão para analisar o uso de RAM.
28 Capítulo 4. Ferramentas de Desenvolvimento para Android

Inspeções de código
Sempre que você compila um programa, o Android Studio executa automaticamente inspeções
de lint configuradas e outras inspeções do ambiente de desenvolvimento integrado (link em inglês)
para ajudar a identificar e corrigir problemas na qualidade estrutural do código.
A ferramenta de lint verifica os arquivos de origem do projeto Android para localizar possí-
veis bugs e melhorias de otimização em relação a critérios de precisão, segurança, desempenho,
usabilidade, acessibilidade e internacionalização.

Figura 7. Resultados de uma inspeção de lint no Android Studio.

Além das verificações de lint, o Android Studio também realiza inspeções de código do IntelliJ
e valida anotações para otimizar o fluxo de trabalho da programação.
Para ver mais informações, consulte Melhorar seu código com verificações de lint.
Anotações no Android Studio
O Android Studio é compatível com anotações para variáveis, parâmetros e valores de retorno
para ajudar a detectar bugs, como exceções de ponteiros nulos e conflitos de tipos de recursos. O
Android SDK Manager empacota a biblioteca Support-Annotations no Android Support Repository
para uso com o Android Studio. O Android Studio valida as anotações configuradas durante a
inspeção do código.
Para ver mais detalhes sobre as anotações do Android, consulte Melhorar a inspeção de código
com anotações.
Mensagens de registro
Durante a criação e execução do app no Android Studio, você pode ver a saída do adb e as
mensagens de registro do dispositivo na janela Logcat.
Criação de perfis de desempenho
Para criar perfis de desempenho para a CPU, memória e rede do seu app, abra o Android Profiler
clicando em View > Tool Windows > Android Profiler.
Instalar o Android Studio
A configuração do Android Studio pode ser feita com apenas alguns cliques.
Primeiro, verifique se você fez o download da versão mais recente do Android Studio.
Windows
Para instalar o Android Studio no Windows, faça o seguinte:
1. Se você fez o download de um arquivo .exe(recomendado), clique duas vezes nele para
iniciá-lo.
Se você fez o download de um arquivo .zip, descompacte o ZIP, copie a pasta android-studio
para a pasta Arquivos de Programas, abra a pasta android-studio > bin e execute [Link]
(para máquinas de 64 bits) ou [Link] (para máquinas de 32 bits).
4.1 A ferramenta de desenvolvimento Android Studio 29

2. Siga os passos do assistente de configuração no Android Studio e instale todos os pacotes do

SDK recomendados.
É isso. O vídeo a seguir mostra cada etapa do procedimento de configuração ao usar o download
do .exe recomendado.
O Android Studio informará a disponibilidade de novas ferramentas e outras APIs por meio de
uma janela pop-up. Além disso, você pode verificar se há atualizações clicando em Help > Check
for Update.
Mac
Para instalar o Android Studio no Mac, faça o seguinte:
1. Execute o arquivo DMG do Android Studio.
2. Arraste e solte o Android Studio na pasta Aplicativos e execute-o.
3. Selecione se você quer ou não importar as configurações anteriores do Android Studio e
clique em OK.
4. O assistente de configuração do Android Studio orientará você no restante da configuração,
incluindo o download dos componentes do Android SDK necessários para o desenvolvimento.
É isso. O vídeo a seguir mostra todas as etapas do procedimento de configuração recomendado.
O Android Studio informará a disponibilidade de novas ferramentas e outras APIs por meio
de uma janela pop-up. Além disso, você pode verificar se há atualizações clicando em Android
Studio > Check for Updates.
Observação: se você usa o Android Studio no macOS Mojave ou versão mais recente, talvez
receba uma solicitação para permitir que o ambiente de desenvolvimento integrado acesse agenda,
contatos ou fotos. Essa solicitação é causada por novos mecanismos de proteção de privacidade
para aplicativos que acessam arquivos no diretório principal. Portanto, se o projeto incluir arquivos
e bibliotecas no diretório principal e você receber essa solicitação, selecione Não permitir.
Linux
Para instalar o Android Studio no Linux, faça o seguinte:
1. Descompacte o arquivo .zip transferido por download em um local apropriado para seus
aplicativos, como /usr/local/ para seu perfil de usuário ou /opt/ para usuários compartilhados.
Se você estiver usando uma versão de 64 bits do Linux, primeiro instale as bibliotecas necessá-
rias para máquinas de 64 bits.
2. Para iniciar o Android Studio, abra um terminal, navegue até o diretório android-studio/bin/
e execute [Link].
3. Selecione se você quer ou não importar as configurações anteriores do Android Studio e
clique em OK.
4. O assistente de configuração do Android Studio orientará você no restante da configuração,
incluindo o download dos componentes do Android SDK necessários para o desenvolvimento.
Dica: para disponibilizar o Android Studio na sua lista de apps, selecione Tools > Create
Desktop Entry na barra de menus do Android Studio.
Bibliotecas necessárias para máquinas de 64 bits
Se você estiver executando uma versão do Ubuntu de 64 bits, será necessário instalar algumas
bibliotecas de 32 bits com o seguinte comando:
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386
Se você estiver executando o Fedora de 64 bits, o comando será:
sudo yum install zlib.i686 ncurses-libs.i686 bzip2-libs.i686
É isso.
O Android Studio informará a disponibilidade de novas ferramentas e outras APIs por meio de
uma janela pop-up. Além disso, você pode verificar se há atualizações clicando em Help > Check
for Update.
Chrome OS
30 Capítulo 4. Ferramentas de Desenvolvimento para Android

Siga as seguintes etapas para instalar o Android Studio no Chrome OS:

1. Instale o Linux para Chrome OS, se ainda não tiver feito isso.
2. Abra o app Arquivos e localize o pacote DEB na pasta Downloads em Meus arquivos.
3. Com o botão direito do mouse, clique no pacote DEB e selecione Instalar com o Linux
(Beta).

4. Selecione se você quer importar ou não as configurações anteriores do Android Studio e

clique em OK.
5. O assistente de configuração do Android Studio orientará você no restante da configuração,
incluindo o download de componentes do Android SDK necessários para o desenvolvimento.
6. Após a conclusão da instalação, inicie o Android Studio no acesso rápido ou no terminal do
Chrome OS Linux executando [Link] no diretório de instalação padrão:
/opt/android-studio/bin/[Link]
É isso. O Android Studio informará a disponibilidade de novas ferramentas e outras APIs por
meio de uma janela pop-up. Além disso, você pode verificar se há atualizações clicando em Help >
Check for Update.
Observação: atualmente, o Android Studio, no Chrome OS, é compatível com a implantação
do aplicativo apenas em um dispositivo de hardware conectado. Para saber mais, consulte Executar
apps em um dispositivo de hardware.
Migrar para o Android Studio
A migração de projetos para o Android Studio exige a adaptação a uma nova estrutura de
projeto, ao sistema de compilação e às funcionalidades do ambiente de desenvolvimento integrado.
Para migrações de projetos Android do Eclipse, o Android Studio oferece uma ferramenta de
importação que permite mover rapidamente o código existente para projetos do Android Studio
e arquivos de compilação com base no Gradle. Para ver mais informações, consulte Migrar do
Eclipse.
4.1 A ferramenta de desenvolvimento Android Studio 31

Se você está migrando do IntelliJ e o projeto já usa o Gradle, basta abrir o projeto existente no
Android Studio. Se você está usando o IntelliJ, mas o projeto ainda não usa o Gradle, uma pequena
preparação manual é necessária antes de importar o projeto para o Android Studio. Para ver mais
informações, consulte Migrar do IntelliJ.
Conceitos básicos do Android Studio
Veja a seguir algumas das principais diferenças que você deve conhecer para preparar a migração
para o Android Studio.
Organização de projetos e módulos
O Android Studio é baseado no ambiente de desenvolvimento integrado IntelliJ IDEA. Para
conhecer os princípios básicos desse ambiente, como navegação, preenchimento de código e atalhos
de teclado, consulte Conheça o Android Studio.
O Android Studio não usa espaços de trabalho. Portanto, projetos separados são abertos em
janelas distintas dele. O Android Studio organiza código em projetos, que contêm tudo o que define
o app Android, desde o código-fonte até configurações da compilação e código de teste. Cada
projeto contém um ou mais módulos, que permitem dividir o projeto em unidades distintas de
funcionalidade. Os módulos podem ser compilados, testados e depurados de modo independente.
Para ver mais informações sobre projetos e módulos do Android Studio, consulte a Visão geral
de projetos.
Sistema de compilação baseado em Gradle
O sistema de compilação do Android Studio é baseado no Gradle e usa arquivos de configu-
ração de compilação criados na sintaxe do Groovy para facilitar a capacidade de ampliação e a
personalização.
Projetos baseados no Gradle oferecem recursos consideráveis para o desenvolvimento em
Android, entre eles:
• Compatibilidade com bibliotecas binárias (AARs). Não é mais necessário copiar origens
de bibliotecas nos próprios projetos. Basta declarar uma dependência, e a biblioteca é
automaticamente transferida por download e combinada ao projeto. Isso inclui a combinação
automática de recursos, entradas de manifesto, regras de exclusão do ProGuard e regras de
lint personalizadas, entre outros, durante a compilação.
• Compatibilidade com variantes de compilação. Por exemplo, as variantes de compilação
permitem compilar versões diferentes do app (como uma gratuita e uma profissional) para o
mesmo projeto.
• Facilidade de configuração e personalização de compilações. Por exemplo, é possível
recuperar nomes e códigos de versão a partir de tags do Git como parte da compilação.
• O Gradle pode ser usado a partir do ambiente de desenvolvimento integrado, mas também
da linha de comando e de servidores de integração contínua, como o Jenkins, o que gera a
mesma compilação em qualquer lugar, a qualquer momento.
Para ver mais informações sobre como usar e configurar o Gradle, consulte Configurar sua
compilação.
Dependências
As dependências de biblioteca no Android Studio usam declarações de dependência do Gradle
e dependências do Maven para bibliotecas de origem e binárias locais conhecidas com coordenadas
do Maven. Para saber mais, leia Configurar variações de compilação.
Código de teste
No Eclipse ADT, testes de instrumentação são programados em projetos separados e integrados
por meio do elemento <instrumentation> ao arquivo de manifesto. O Android Studio disponibiliza
um diretório androidTest/ no conjunto de origem principal do projeto para que você possa adicionar
e manter facilmente o código de teste de instrumentação na mesma visualização de projeto. Além
disso, o Android Studio oferece um diretório test/ no conjunto de origem principal do projeto para
32 Capítulo 4. Ferramentas de Desenvolvimento para Android

testes locais da JVM.

Migrar do Eclipse
O Android Studio oferece uma ferramenta de importação automática para projetos Android
criados com o Eclipse.
Pré-requisitos de migração
Antes de migrar o app do Eclipse para o Android Studio, veja as etapas a seguir para garantir
que o projeto esteja pronto para conversão e verifique se as configurações de ferramentas necessárias
estão no Android Studio:
No Eclipse ADT:
• Verifique se o diretório raiz do Eclipse ADT contém o arquivo [Link]. Além
disso, o diretório raiz precisa conter os arquivos .project e .classpath do Eclipse ou os
diretórios res/ e src/.
• Compile o projeto para garantir que as atualizações mais recentes de espaço de trabalho e
projeto sejam salvas e incluídas na importação.
• Transforme em comentários todas as referências aos arquivos de biblioteca do espaço de
trabalho do Eclipse ADT nos arquivos [Link] ou .classpath a serem importados.
Essas referências podem ser adicionadas ao arquivo [Link] após a importação. Para
saber mais, consulte Configurar sua versão.
• Pode ser útil registrar o diretório do espaço de trabalho, as variáveis de caminho e todos os
mapeamentos de caminho reais que podem ser usados para especificar caminhos relativos,
variáveis e referências de recursos vinculados não resolvidos. O Android Studio permite
especificar manualmente todos os caminhos não resolvidos durante o processo de importação.
No Android Studio:
• Faça o download do Android Studio, caso ainda não tenha feito. Se você já tem o Android
Studio, confirme se é a versão estável mais recente clicando em Help > Check for Updates
(no Mac, Android Studio > Check for Updates).
• Como o Android Studio não migra nenhum plug-in de terceiros do Eclipse ADT, anote
todos os plug-ins de terceiros que você usa no Eclipse. Você pode verificar se há recursos
equivalentes no Android Studio ou pesquisar um plug-in compatível no repositório de plug-
ins para Android Studio do IntelliJ. Use a opção de menu File > Settings > Plugins para
gerenciar plug-ins no Android Studio.
• Se você pretende executar o Android Studio atrás de um firewall, defina as configurações de
proxy para o Android Studio e o SDK Manager. O Android Studio exige conexão de Internet
para sincronização do assistente de configuração, acesso a bibliotecas de terceiros, acesso
a repositórios remotos, inicialização e sincronização do Gradle e atualizações de versão do
Android Studio. Para saber mais, consulte Configurações do proxy.
Importar projetos do Eclipse para o Android Studio
Decida como importará os projetos atuais do Eclipse ADT de acordo com a estrutura deles:
• Se você tem vários projetos relacionados compartilhando o mesmo espaço de trabalho no
Eclipse ADT, importe o primeiro como um projeto e adicione os projetos relacionados
subsequentes como módulos do projeto.
• Se os projetos do Eclipse ADT compartilham dependências no mesmo espaço de trabalho,
mas não têm qualquer outra relação, importe cada projeto do Eclipse ADT individualmente
para o Android Studio como um projeto separado. O Android Studio mantém as dependências
compartilhadas entre os projetos recém-criados como parte do processo de importação.
• Se o projeto do Eclipse ADT inclui bibliotecas nativas (C/C++), consulte Vincular o Gra-
dle à biblioteca nativa para ver instruções de como incluir suas bibliotecas nativas como
dependências de compilação do Gradle.
Importar como projeto:
4.1 A ferramenta de desenvolvimento Android Studio 33

1. Inicie o Android Studio e feche todos os projetos abertos nele.

2. No menu do Android Studio, clique em File > New > Import Project.
• Como alternativa, na tela "Welcome", clique em Import project (Eclipse ADT, Gradle
etc.).
3. Selecione a pasta do projeto do Eclipse ADT com o arquivo [Link] e clique
em OK.

4. Selecione a pasta de destino e clique em Next.

5. Selecione as opções de importação e clique em Finish.

6. Durante o processo de importação, você verá uma solicitação para migrar todas as dependên-
cias de bibliotecas e projetos para o Android Studio e adicionar as declarações de dependência
ao arquivo [Link]. Consulte Criar uma biblioteca Android para ver mais informações
sobre esse processo.

O processo de importação também substitui todas as bibliotecas de origem e binárias conhecidas

e os arquivos JAR que têm coordenadas Maven conhecidas com dependências do Maven. Portanto,
não é mais necessário manter essas dependências manualmente. As opções de importação também
permitem inserir o diretório do espaço de trabalho e todos os mapeamentos de caminho reais para
lidar com quaisquer caminhos, variáveis de caminho e referências de recursos vinculados não
resolvidos.
34 Capítulo 4. Ferramentas de Desenvolvimento para Android

7. O Android Studio importa o app e exibe o resumo da importação do projeto. Leia o resumo
para ver detalhes sobre a reestruturação do projeto e o processo de importação.
4.1 A ferramenta de desenvolvimento Android Studio 35

Após a importação do projeto do Eclipse ADT para o Android Studio, cada pasta de módulo
de app no Android Studio conterá o conjunto de origem completo para esse módulo, incluindo os
diretórios src/main/ e src/androidTest/, recursos, arquivo de compilação e manifesto do Android.
Antes de iniciar o desenvolvimento de apps, é preciso resolver todos os problemas mostrados no
resumo de importação do projeto para garantir que a reestruturação do projeto e o processo de
importação tenham sido concluídos corretamente.
Importar como módulo:
1. Inicie o Android Studio e abra o projeto ao qual você quer adicionar o módulo.
2. No menu do Android Studio, clique em File > New > Import Module.
3. Selecione a pasta do projeto do Eclipse ADT com o arquivo [Link] e clique
em OK.
4. Modifique o nome do módulo, se quiser, e clique em Next.
5. Durante o processo de importação, você verá uma solicitação para migrar todas as de-
pendências de bibliotecas e projetos para o Android Studio e adicionar as declarações de
dependência ao arquivo [Link]. Para saber mais sobre a migração de dependências
de biblioteca e projeto, consulte Criar uma biblioteca Android. O processo de importação
também substitui todas as bibliotecas de origem e binárias conhecidas e os arquivos JAR
que têm coordenadas Maven conhecidas com dependências do Maven. Portanto, não é mais
necessário manter essas dependências manualmente. As opções de importação também
permitem inserir o diretório do espaço de trabalho e todos os mapeamentos de caminho
reais para lidar com quaisquer caminhos, variáveis de caminho e referências de recursos
vinculados não resolvidos.
36 Capítulo 4. Ferramentas de Desenvolvimento para Android

6. Clique em Finish.
Validar projetos importados
Depois de concluir o processo de importação, use as opções de menu "Build"e "Run"do Android
Studio para compilar o projeto e verificar a saída. Se o projeto não estiver sendo criado corretamente,
verifique as configurações a seguir:
• Verifique se as versões instaladas das ferramentas correspondem às configurações do projeto
Eclipse. Para isso, clique no botão "Android SDK Manager"no Android Studio ou em Tools
> SDK Manager para abrir o SDK Manager. O Android Studio herda as configurações do
SDK Manager e do JDK do projeto importado do Eclipse.
• Para conferir outras configurações do Android Studio, clique em File > Project Structure e
verifique o seguinte:
– Em SDK Location, confirme se o Android Studio tem acesso aos locais e versões
corretos de SDK, NDK e JDK.
Observação: se você tiver usado as configurações padrão, o Eclipse ADT terá instalado o SDK
do Android em User\user-name\android-sdks\ no Windows e em Users/user-name/Library/Android/sdk/
no Mac.
• Em Project, confirme a versão do Gradle, a versão do plug-in do Android e os repositórios
relacionados.
• Em Modules, confirme as configurações de app e módulo, como configuração de assinatura
e dependências de biblioteca.
• Se o projeto depender de outro projeto, verifique se essa dependência está definida correta-
mente no arquivo [Link] na pasta do módulo do app. Para saber mais sobre a definição
de dependências, consulte Configurar variações de versão.
Se, depois de verificar essas configurações, os problemas inesperados persistirem durante a
compilação e execução do projeto no Android Studio, modifique o projeto do Eclipse ADT e
reinicie o processo de importação.
Observação: a importação de um projeto do Eclipse ADT para o Android Studio cria um novo
projeto do Android Studio e não afeta o projeto existente do Eclipse ADT.
Migrar do IntelliJ
Se o projeto do IntelliJ usar o sistema de compilação do Gradle, você poderá importar o projeto
automaticamente para o Android Studio. Se o projeto do IntelliJ usar o Maven ou outro sistema
de compilação, será necessário configurá-lo para usar o Gradle antes de fazer a migração para o
Android Studio.
Importar um projeto do IntelliJ baseado no Gradle
Se você já usa o Gradle com o projeto do IntelliJ, pode abri-lo no Android Studio seguindo as
etapas a seguir:
1. Clique em File > New > Import Project.
2. Selecione o diretório do projeto do IntelliJ e clique em OK. Seu projeto será aberto no
Android Studio.
Importar um projeto do IntelliJ que não usa o Gradle
Se o projeto do IntelliJ ainda não usa o sistema de compilação Gradle, você tem duas opções
para importar o projeto para o Android Studio:
• Crie um novo projeto vazio no Android Studio e copie o código-fonte existente nos diretórios
associados ao novo projeto. Para ver mais informações, consulte Migrar criando um novo
projeto vazio.
• Crie manualmente um novo arquivo de versão do Gradle para o projeto e importe o projeto e
o novo arquivo de versão para o Android Studio. Para ver mais informações, consulte Migrar
criando um arquivo de compilação personalizado do Gradle.
Migrar criando um novo projeto vazio
4.1 A ferramenta de desenvolvimento Android Studio 37

Para migrar o projeto para o Android Studio criando um novo projeto vazio e copiando os
arquivos de origem para os novos diretórios, faça o seguinte:

1. Abra o Android Studio e clique em File > New > New Project.
2. Insira um nome para o projeto do app, especifique o local onde ele deve ser criado e clique
em Next.
3. Selecione os formatos onde o app será executado e clique em Next.
4. Clique em Add No Activity e em Finish.
5. Na janela Project da ferramenta, clique na seta para abrir uma lista suspensa e selecione a
visualização Project para ver e analisar a organização do novo projeto do Android Studio.
Para saber mais sobre como mudar visualizações e como o Android Studio estrutura projetos,
consulte Arquivos de projetos.
6. Navegue até o local selecionado para o novo projeto e mova o código, testes de unidade,
testes de instrumentação e recursos dos diretórios do projeto antigo para os locais corretos na
estrutura do novo projeto.
7. No Android Studio, clique em File > Project Structure para abrir a caixa de diálogo Project
Structure. Verifique se o módulo do app está selecionado no painel esquerdo.
8. Faça as modificações necessárias na guia Properties do projeto (por exemplo, modifique a
minSdkVersion ou a targetSdkVersion).
9. Clique em Dependencies e adicione todas as bibliotecas de que o projeto depende como

dependências do Gradle. Para adicionar uma nova dependência, clique em Add ,

selecione o tipo de dependência que gostaria de adicionar e siga as instruções.
10. Clique em OK para salvar as modificações.
11. Clique em Build > Make Project para testar a versão do projeto e resolva todos os erros
pendentes.

Migrar criando um arquivo de compilação personalizado do Gradle

Para migrar o projeto para o Android Studio criando um novo arquivo de compilação do Gradle
que aponte para arquivos de origem existentes, faça o seguinte:

1. Antes de começar, faça backup dos arquivos do projeto em um local separado, porque o
processo de migração modificará o conteúdo do projeto atual.
2. Em seguida, crie um arquivo no diretório do projeto com o nome [Link]. O arquivo
[Link] conterá todas as informações necessárias para que o Gradle funcione na sua
versão.

Por padrão, o Android Studio espera que o projeto seja organizado como mostrado na Figura 8.
38 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 8. Estrutura padrão do projeto para um módulo de app para Android.

Como o projeto IntelliJ não usa a mesma estrutura, o arquivo [Link] precisa direcionar os
diretórios de origem da versão para as pastas existentes (por exemplo, res/ e src/) em vez da nova
estrutura de diretórios padrão. O exemplo de arquivo [Link] a seguir inclui a configuração
básica de uma versão do Gradle, bem como um bloco sourceSets{} dentro do bloco android{}
para definir os diretórios de origem corretos e mover os testes e tipos de compilação para evitar
conflitos de nomenclatura. Copie o bloco de código abaixo para o arquivo [Link] e aplique
todas as mudanças necessárias para trabalhar com a configuração de projeto existente. Por exemplo,
pode ser necessário incluir mais dependências, usar uma versão de destino de SDK diferente ou
especificar outros locais para os diretórios de origem.
// This buildscript{} block configures the code driving the build
buildscript {
/**
* The nested repositories{} block declares that this build uses the
* jcenter repository.
*/
repositories {
jcenter()
}

/**
* This block declares a dependency on the 3.5.2 version
* of the Gradle plugin for the buildscript.
*/
dependencies {
classpath ’[Link]:gradle:3.5.2’
}
}

/**
* This line applies the [Link] plugin. Note that you should
4.1 A ferramenta de desenvolvimento Android Studio 39

* only apply the [Link] plugin. Applying the Java plugin as

* well will result in a build error.
*/
apply plugin: ’[Link]’

/**
* This dependencies block includes any dependencies for the project itself. The
* following line includes all the JAR files in the libs directory.
*/
dependencies {
compile fileTree(dir: ’libs’, include: [’*.jar’])
// Add other library dependencies here (see the next step)
}

/**
* The android{} block configures all of the parameters for the Android build.
* You must provide a value for at least the compilation target.
*/
android {
compileSdkVersion 28

/**
* This nested sourceSets block points the source code directories to the
* existing folders in the project, instead of using the default new
* organization.
*/
sourceSets {
main {
[Link] ’[Link]’
[Link] = [’src’]
[Link] = [’src’]
[Link] = [’src’]
[Link] = [’src’]
[Link] = [’res’]
[Link] = [’assets’]
}

// Move the tests to tests/java, tests/res, etc...

[Link](’tests’)

/**
* Move the build types to build-types/<type>
* For instance, build-types/debug/java, build-types/debug/[Link], ...
* This moves them out of them default location under src/<type>/... which would
* conflict with src/ being used by the main source set.
* Adding new build types or product flavors should be accompanied
* by a similar customization.
*/
[Link](’build-types/debug’)
40 Capítulo 4. Ferramentas de Desenvolvimento para Android

[Link](’build-types/release’)
}
}

Para ver mais informações sobre a configuração e a personalização de um arquivo de versão do

Gradle, leia Configurar sua compilação.
Em seguida, identifique quais projetos de biblioteca você está usando. Com o Gradle, não é
mais necessário adicionar essas bibliotecas como projetos de código-fonte. Em vez disso, elas
podem ser referenciadas no bloco dependencies{} do arquivo de versão. O sistema de compilação
processará essas bibliotecas, incluindo o download, a combinação dos recursos e a combinação
das entradas de manifesto. O exemplo a seguir adiciona as declarações do Google Play Services e
diversas bibliotecas de suporte ao bloco dependencies{} mostrado no exemplo de arquivo de versão
acima.
...
dependencies {
compile fileTree(dir: ’libs’, include: [’*.jar’])

// Google Play Services

compile ’[Link]:play-services:9.8.0’

// Support Libraries
compile ’[Link]:appcompat-v7:28.0.0’
compile ’[Link]:cardview-v7:28.0.0’
compile ’[Link]:design:28.0.0’
compile ’[Link]:gridlayout-v7:28.0.0’
compile ’[Link]:leanback-v17:28.0.0’
compile ’[Link]:mediarouter-v7:28.0.0’
compile ’[Link]:palette-v7:28.0.0’
compile ’[Link]:recyclerview-v7:28.0.0’
compile ’[Link]:support-annotations:28.0.0’
compile ’[Link]:support-v13:28.0.0’
compile ’[Link]:support-v4:28.0.0’

// Note: these libraries require the "Google Repository"and "Android Repository"

// to be installed via the SDK manager.
}

3. Para receber ajuda na determinação das instruções de declaração corretas para suas bibliotecas,
consulte o Gradle, please (link em inglês) para ver as instruções certas com base no Maven
Central.
4. Salve o arquivo [Link] e feche o projeto no IntelliJ. Navegue até o diretório do projeto
e exclua o diretório .idea e todos os arquivos .iml dentro do projeto.
5. Inicie o Android Studio e clique em File > New > Import Project.
6. Localize o diretório do projeto, clique no arquivo [Link] criado acima para selecioná-lo
e clique em OK para importar o projeto.
7. Clique em Build > Make Project para testar o arquivo de versão, criando o projeto e
resolvendo todos os erros encontrados.
A seguir
Depois de migrar o projeto para o Android Studio, leia Compilar e executar o app para saber
4.1 A ferramenta de desenvolvimento Android Studio 41

mais sobre a criação com o Gradle e a execução do app no Android Studio.

Dependendo do projeto e do fluxo de trabalho, você também pode se interessar por controle de
versões, gerenciamento de dependências, assinatura e empacotamento de apps ou configuração e
atualização do Android Studio. Para começar a usar o Android Studio, leia Conheça o Android
Studio.
Configurar o controle de versões
O Android Studio é compatível com diversos sistemas de controle de versões, incluindo Git,
GitHub, CVS, Mercurial, Subversion e Google Cloud Source Repositories.
Depois de importar o app para o Android Studio, use as opções do menu "VCS"do Android
Studio para ativar a compatibilidade do VCS com o sistema de controle de versões em questão, criar
um repositório, importar os novos arquivos para o controle de versões e realizar outras operações
de controle de versões.
1. No menu "VCS"do Android Studio, clique em Enable Version Control Integration.
2. Selecione um sistema de controle de versões para associar à raiz do projeto no menu suspenso
e clique em OK. Serão exibidas diversas opções de controle de versões no menu "VCS", de
acordo com o sistema selecionado.
Observação: também é possível usar a opção de menu File > Settings > Version Control para
definir e modificar as configurações do controle de versões.
Para ver mais informações sobre como trabalhar com o controle de versões, consulte Referência
do controle de versões do IntelliJ (link em inglês).
Repositórios de Suporte do Android Support e Repositório do Google Play Services
Embora o Eclipse ADT use a Biblioteca de Suporte do Android e a Biblioteca do Google
Play Services, o Android Studio substitui essas bibliotecas durante o processo de importação
pelo Repositório de Suporte do Android e o Repositório do Google para manter funcionalidades
compatíveis e aceitar novos recursos do Android. No Android Studio, essas dependências são
adicionadas como dependências do Maven por meio das coordenadas conhecidas do Maven.
Portanto, essas dependências não precisam ser atualizadas manualmente.
No Eclipse, para usar uma Biblioteca de Suporte, é necessário modificar as dependências de
classpath do projeto no ambiente de desenvolvimento para cada Biblioteca de Suporte a ser usada.
No Android Studio, não é mais necessário copiar origens de biblioteca nos projetos. Basta declarar
uma dependência para que a biblioteca seja transferida por download e combinada automaticamente
com o projeto. Isso inclui a combinação automática em recursos, entradas de manifesto, regras de
exclusão do ProGuard e regras de lint personalizadas no momento da compilação. Para ver mais
informações sobre dependências, consulte Configurar variações de compilação.
Assinatura de apps
Se um certificado de depuração foi usado pelo app no Eclipse ADT, o Android Studio continua
referenciando esse certificado. Caso contrário, a configuração de depuração usa o keystore de
depuração gerado pelo Android Studio, com uma senha conhecida e uma chave padrão com senha
conhecida, localizado em $HOME/.android/[Link]. O tipo de compilação de depuração
será definido para usar automaticamente essa configuração de depuração quando o projeto for
executado ou depurado no Android Studio.
Durante a criação do app, o Android Studio aplica o certificado de lançamento usado no Eclipse
ADT. Se nenhum certificado de lançamento for localizado durante o processo de importação,
adicione a configuração de assinatura de lançamento ao arquivo [Link] ou use a opção de
menu Build > Generate Signed APK para abrir o Generate Signed APK Wizard. Para saber mais
sobre como assinar seu app, consulte Assinar o app.
Ajustar o tamanho máximo de heap do Android Studio
Por padrão, o Android Studio tem um tamanho de heap máximo de 1280 MB. Se você estiver
trabalhando em um projeto grande ou se o sistema tiver muita RAM, será possível melhorar o
42 Capítulo 4. Ferramentas de Desenvolvimento para Android

desempenho aumentando o tamanho máximo de heap.

Atualizações de software
O Android Studio é atualizado separadamente do plug-in para Gradle, das ferramentas de
compilação e das ferramentas do SDK. Você pode especificar quais versões quer usar com o
Android Studio.
Por padrão, o Android Studio oferece atualizações automáticas sempre que uma nova versão
estável é lançada. No entanto, é possível optar por atualizações mais frequentes e também receber
versões de pré-lançamento ou Beta.
Para ver mais informações sobre como atualizar o Android Studio e usar versões de pré-
lançamento e Beta, consulte Fique atualizado.
Configurar o Android Studio
O Android Studio oferece assistentes e modelos para verificar os requisitos de sistema, como o
Java Development Kit (JDK) e a RAM disponível, assim como para definir configurações padrão,
como uma emulação de Android Virtual Device (AVD) otimizada padrão e imagens de sistema
atualizadas. Este documento descreve as definições de configuração adicionais que você poderá
usar para personalizar o uso do Android Studio.
O Android Studio oferece acesso a dois arquivos de configuração por meio do menu Help:
• [Link]: personalize opções para a máquina virtual Java (JVM, na sigla em inglês)
do Studio, como tamanho da heap e do cache. Nas máquinas Linux, esse arquivo pode ser
chamado de [Link], dependendo da versão do Android Studio.
• [Link]: personalize propriedades do Android Studio, como o caminho da pasta de
plug-ins ou o tamanho máximo de arquivo permitido.
Para a documentação específica sobre a configuração e o uso do emulador e do dispositivo,
consulte os seguintes tópicos:
• Gerenciamento de dispositivos virtuais
• Uso de dispositivos de hardware
• Drivers USB OEM
Encontrar os arquivos de configuração
Os dois arquivos de configuração são armazenados na pasta de configuração do Android Studio.
O nome da pasta depende da versão do Studio. Por exemplo, o Android Studio 3.3 tem o nome de
pasta AndroidStudio3.3. A localização da pasta depende do sistema operacional:
• Windows: %USERPROFILE%\.CONFIGURATION_FOLDER
• macOS: ~/Library/Preferences/CONFIGURATION_FOLDER
• Linux: ~/.CONFIGURATION_FOLDER
Você também pode usar as variáveis de ambiente a seguir para apontar para arquivos de
modificação específicos em outros lugares:
• STUDIO_VM_OPTIONS: defina o nome e o local do arquivo .vmoptions
• STUDIO_PROPERTIES: defina o nome e o local do arquivo .properties
• STUDIO_JDK: defina o JDK a ser usado para executar o Studio
Personalizar opções da VM
O arquivo [Link] permite personalizar opções para a JVM do Android Studio. Para
aumentar o desempenho do Studio, a opção mais comum é ajustar o tamanho máximo de heap, mas
também é possível usar o arquivo [Link] para modificar outras configurações padrão,
como tamanho inicial de heap, tamanho do cache e chaves de coleta de lixo do Java.
Para criar um novo arquivo [Link] ou para abrir o arquivo existente, realize as
seguintes etapas:
1. Clique em Help > Edit Custom VM Options. Se você nunca editou opções de VM para o
Android Studio antes, o ambiente de desenvolvimento integrado solicitará que você crie um
novo arquivo [Link]. Clique em Yes para criar o arquivo.
4.1 A ferramenta de desenvolvimento Android Studio 43

2. O arquivo [Link] é aberto na janela do editor do Android Studio. Edite o arquivo

para adicionar suas próprias opções personalizadas de VM. Para uma lista completa das
opções personalizáveis da JVM, consulte a página Java HotSpot VM Options da Oracle (em
inglês).

O arquivo [Link] criado é adicionado ao arquivo [Link] padrão, localizado

no diretório bin/ dentro da pasta de instalação do Android Studio.

Você nunca deve editar diretamente o arquivo [Link] localizado na pasta do programa
Android Studio. Embora seja possível acessar o arquivo para ver as opções padrão de VM do
Studio, edite apenas seu próprio arquivo [Link] para garantir que você não modifique
configurações padrão importantes do Android Studio. Portanto, no arquivo [Link],
modifique somente os atributos desejados e permita que o Android Studio continue usando valores
padrão para todos os atributos não alterados.

Tamanho máximo de heap

Por padrão, o tamanho máximo de heap do Android Studio é 1.280 MB. Se você está trabalhando
em um projeto grande ou se o sistema tem bastante RAM disponível, é possível melhorar o
desempenho aumentando o tamanho máximo de heap nos processos do Android Studio, como o
ambiente de desenvolvimento integrado principal, o daemon do Gradle e o do Kotlin.

O Android Studio verifica automaticamente se é possível fazer otimizações de tamanho de heap

e envia uma notificação se detectar que o desempenho pode ser aprimorado.

Figura 9. Notificação sobre as configurações recomendadas de memória.

Se você está usando um sistema de 64 bits com 5 GiB de RAM ou mais, também é possível
ajustar manualmente os tamanhos de heap do seu projeto. Para isso, siga estas etapas:

1. Clique em File > Settings na barra de menu (ou Android Studio > Preferences no macOS).
2. Clique em Appearance & Behavior > System Settings > Memory Settings.
44 Capítulo 4. Ferramentas de Desenvolvimento para Android

3. Ajuste os tamanhos de heap de acordo com sua preferência.

4. Clique em Apply.
Caso tenha alterado o tamanho de heap do ambiente de desenvolvimento integrado, é necessário
reiniciar o Android Studio para que as novas configurações de memória sejam aplicadas.
Observação: a alocação de memória em excesso pode prejudicar o desempenho.
Exportar e importar configurações do ambiente de desenvolvimento integrado
Você pode exportar um arquivo [Link] com todas ou um subconjunto das suas configurações
preferidas de ambiente de desenvolvimento integrado para um projeto. Esse arquivo JAR poderá
ser importado para outros projetos e/ou disponibilizado para importação pelos seus colegas nos
projetos deles.
Para mais informações, consulte Exportar e importar configurações no IntelliJ IDEA (link em
inglês).
Personalizar propriedades do ambiente de desenvolvimento integrado
O arquivo [Link] permite que você personalize as propriedades do ambiente de desen-
volvimento integrado para o Android Studio, como o caminho para os plug-ins instalados pelo
usuário e o tamanho máximo de arquivo compatível com esse ambiente. O arquivo [Link]
é mesclado com as propriedades padrão do ambiente de desenvolvimento integrado para que você
possa especificar apenas as propriedades de modificação.
Para criar um novo arquivo [Link] ou abrir o arquivo existente, realize as seguintes
etapas:
1. Clique em Help > Edit Custom Properties. Se você nunca editou as propriedades do
ambiente de desenvolvimento integrado, o Android Studio solicitará a criação de um novo
arquivo [Link]. Clique em Yes para criar o arquivo.
2. O arquivo [Link] é aberto na janela do editor do Android Studio. Edite o arquivo
para adicionar suas propriedades personalizadas de ambiente de desenvolvimento integrado.
4.1 A ferramenta de desenvolvimento Android Studio 45

O arquivo [Link] a seguir inclui as propriedades de ambiente de desenvolvimento

integrado habitualmente personalizadas. Para ver uma lista completa de propriedades, leia sobre o
arquivo [Link] para IntelliJ IDEA (link em inglês).
#---------------------------------------------------------------------
# Uncomment this option if you want to customize path to user installed plugins folder. Make
sure
# you’re using forward slashes.
#---------------------------------------------------------------------
# [Link]=${[Link]}/plugins
#---------------------------------------------------------------------
# Maximum file size (kilobytes) IDE should provide code assistance for.
# The larger file is the slower its editor works and higher overall system memory requirements
are
# if code assistance is enabled. Remove this property or set to very large number if you need
# code assistance for any files available regardless their size.
#---------------------------------------------------------------------
[Link]=2500
#---------------------------------------------------------------------
# This option controls console cyclic buffer: keeps the console output size not higher than the
# specified buffer size (Kb). Older lines are deleted. In order to disable cycle buffer use
# [Link]=disabled
#---------------------------------------------------------------------
[Link]=1024
#---------------------------------------------------------------------
# Configure if a special launcher should be used when running processes from within IDE.
# Using Launcher enables "soft exit"and "thread dump"features
#---------------------------------------------------------------------
[Link]=false
#---------------------------------------------------------------------
# To avoid too long classpath
#---------------------------------------------------------------------
[Link]=false
#---------------------------------------------------------------------
# There are two possible values of [Link] property: "heavy"and "medium".
# If you have WM configured as "Focus follows mouse with Auto Raise"then you have to
# set this property to "medium". It prevents problems with popup menus on some
# configurations.
#---------------------------------------------------------------------
[Link]=heavy
#---------------------------------------------------------------------
# Use default anti-aliasing in system, i.e. override value of
# "Settings|Editor|Appearance|Use anti-aliased font"option. May be useful when using Windows
# Remote Desktop Connection for instance.
#---------------------------------------------------------------------
[Link]=false
#---------------------------------------------------------------------
# Disabling this property may lead to visual glitches like blinking and fail to repaint
# on certain display adapter cards.
#---------------------------------------------------------------------
46 Capítulo 4. Ferramentas de Desenvolvimento para Android

[Link]=true
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under Windows.
#---------------------------------------------------------------------
sun.java2d.d3d=false
#---------------------------------------------------------------------
# Workaround for slow scrolling in JDK6
#---------------------------------------------------------------------
[Link]=false
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under X Window.
#---------------------------------------------------------------------
[Link]=false
#---------------------------------------------------------------------
# Workaround to avoid long hangs while accessing clipboard under Mac OS X.
#---------------------------------------------------------------------
# [Link]=True
#---------------------------------------------------------------------
# Maximum size (kilobytes) IDEA will load for showing past file contents -
# in Show Diff or when calculating Digest Diff
#---------------------------------------------------------------------
# [Link]=20480
Configurar o ambiente de desenvolvimento integrado para máquinas com pouca memó-
ria
Se estiver executando o Android Studio em uma máquina com especificações inferiores às
recomendadas (consulte Requisitos do sistema), você poderá personalizar o ambiente de desenvol-
vimento integrado para aumentar o desempenho na máquina, da seguinte forma:
• Reduza o tamanho de heap máximo disponível para o Android Studio: reduza o ta-
manho de heap máximo do Android Studio para 512 MB. Para mais informações sobre a
alteração do tamanho de heap máximo, consulte Tamanho de heap máximo.
• Atualize o Gradle e o plug-in do Android para Gradle: atualize para as versões mais
recentes do Gradle e do plug-in do Android para Gradle para garantir o uso dos aprimora-
mentos de desempenho mais recentes. Para mais informações sobre a atualização do Gradle
e do plug-in do Android para Gradle, consulte as Notas da versão do plug-in do Android para
Gradle.
• Ative o modo de economia de energia: a ativação do modo de economia de energia desliga
diversas operações de segundo plano que fazem uso intenso de memória e bateria, incluindo
realce de erros e inspeções em tempo real, pop-up automático de conclusão de código e
compilação incremental automática em segundo plano. Para ativar o modo de economia de
energia, clique em File > Power Save Mode.
• Desative verificações desnecessárias de lint: para alterar quais verificações de lint o An-
droid Studio executa no seu código, faça o seguinte:
1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a
caixa de diálogo Settings.
2. No painel esquerdo, expanda a seção Editor e clique em Inspections.
3. Clique nas caixas de seleção para marcar ou desmarcar verificações de lint de acordo
com as necessidades do projeto.
4. Clique em Apply ou OK para salvar as alterações.
4.1 A ferramenta de desenvolvimento Android Studio 47

• Depure em um dispositivo físico: a depuração em um emulador usa mais memória que a

depuração em um dispositivo físico. Assim, você pode melhorar o desempenho geral do
Android Studio depurando em um dispositivo físico.
• Inclua apenas os serviços necessários do Google Play como dependências: incluir o
Google Play Services como dependências no seu projeto aumenta a quantidade de memória
necessária. Inclua apenas as dependências necessárias para melhorar o uso de memória e o
desempenho. Para mais informações, consulte Adicionar o Google Play Services ao projeto.
• Ative o modo off-line para o Gradle? se você tiver largura de banda limitada, ative o modo
off-line para evitar que o Gradle tente fazer o download de dependências ausentes durante a
compilação. Quando o modo off-line está ativado, o Gradle emite um erro de compilação se
houver dependências ausentes, em vez de tentar fazer o download delas. Para ativar o modo
off-line, faça o seguinte:
1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a
caixa de diálogo Settings.
2. No painel esquerdo, expanda Build, Execution, Deployment e clique em Gradle.
3. Em "Global Gradle settings", marque a caixa de seleção Offline work.
4. Clique em Apply ou OK para que as alterações entrem em vigor.
• Reduza o tamanho de heap máximo disponível para o Gradle: o tamanho de heap
máximo padrão do Gradle é de 1.536 MB. Reduza o valor modificando a propriedade
[Link] no arquivo [Link], conforme mostrado abaixo:
# Make sure to gradually decrease this value and note
# changes in performance. Allocating too lttle memory may
# also decrease performance.
[Link] = -Xmx1536m

• Não ative a compilação paralela: o Android Studio pode compilar módulos independentes
em paralelo. No entanto, se você tiver um sistema com pouca memória, não ative esse recurso.
Para verificar essa configuração, faça o seguinte:
1. Clique em File > Settings (no macOS, Android Studio > Preferences) para abrir a
caixa de diálogo Settings.
2. No painel esquerdo, expanda Build, Execution, Deployment e clique em Compiler.
3. Verifique se a opção Compile independent modules in parallel está desmarcada.
4. Se você fez uma alteração, clique em Apply ou OK para que ela entre em vigor.
Definir a versão do JDK
Uma cópia do OpenJDK mais recente é fornecida empacotada com o Android Studio 2.2 ou
versão posterior. Essa é a versão de JDK recomendada para uso com projetos Android. Para usar o
JDK empacotado, faça o seguinte:
1. Abra o projeto no Android Studio e selecione File > Project Structure na barra de menus.
2. Na página SDK Location, em JDK location, marque a caixa de seleção Use embedded
JDK.
3. Clique em OK.
Por padrão, a versão da linguagem Java usada para compilar o projeto é baseada na compileSdk-
Version do projeto (porque versões diferentes do Android são compatíveis com versões distintas do
Java). Se necessário, você pode modificar essa versão Java padrão adicionando o seguinte bloco
CompileOptions {} ao arquivo [Link]:
android {
compileOptions {
sourceCompatibility [Link]\_1\_6
targetCompatibility [Link]\_1\_6
48 Capítulo 4. Ferramentas de Desenvolvimento para Android

}
}

Para ver mais informações sobre onde compileSdkVersion é definido, leia sobre o arquivo de
compilação de nível de módulo.
Definir configurações do proxy
Os proxies atuam como pontos de conexão intermediários entre clientes HTTP e servidores da
Web que adicionam segurança e privacidade às conexões de Internet.
Para que haja compatibilidade com a execução do Android Studio protegida por um firewall,
defina as configurações de proxy para o ambiente de desenvolvimento integrado do Android Studio.
Use a página de configurações para o proxy HTTP do ambiente de desenvolvimento integrado do
Android Studio para fazer isso.
Para executar o plug-in do Android para Gradle na linha de comando ou em máquinas em que o
Android Studio não foi instalado, como servidores de integração contínua, defina as configurações
do proxy no arquivo de compilação do Gradle.
Observação: depois da instalação inicial do pacote do Android Studio, ele poderá ser executado
com acesso à Internet ou off-line. No entanto, o Android Studio exige uma conexão com a Internet
para sincronização do assistente de configuração, acesso a bibliotecas de terceiros, acesso a
repositórios remotos, inicialização e sincronização do Gradle e atualizações de versão do Android
Studio.
Configurar o proxy do Android Studio
O Android Studio é compatível com configurações de proxy HTTP para que você possa executá-
lo com a proteção de um firewall ou de uma rede segura. Para definir as configurações de proxy
HTTP no Android Studio:
1. Na barra de menus, clique em File > Settings (no macOS, clique em Android Studio >
Preferences).
2. No painel esquerdo, clique em Appearance & Behavior > System Settings > HTTP Proxy.
A página de proxy HTTP será exibida.
3. Selecione Auto-detect proxy settings para usar um URL de configuração automática de
proxy para as configurações de proxy, ou Manual proxy configuration para inserir manu-
almente todas as configurações. Para ver uma explicação detalhada dessas configurações,
consulte {Proxy HTTP (link em inglês).
4. Clique em Apply ou OK para que as alterações entrem em vigor.
Configurações de proxy HTTP para o plug-in Android para Gradle
Para executar o plug-in do Android na linha de comando ou em máquinas em que o Android
Studio não esteja instalado, defina as configurações de proxy do plug-in do Android para Gradle no
arquivo de compilação do Gradle.
Para configurações de proxy HTTP específicas de aplicativos, defina as configurações de proxy
no arquivo [Link] de acordo com cada módulo do aplicativo.
apply plugin: ’[Link]’

android {
...

defaultConfig {
...
[Link]=[Link]
[Link]=443
[Link]=userid
4.1 A ferramenta de desenvolvimento Android Studio 49

[Link]=password
[Link]=domain
}
...
}

Para configurações de proxy HTTP para todo o projeto, defina as configurações de proxy no
arquivo gradle/[Link].
# Project-wide Gradle settings.
...

[Link]=[Link]
[Link]=443
[Link]=username
[Link]=password
[Link]=domain

[Link]=[Link]
[Link]=443
[Link]=username
[Link]=password
[Link]=domain

...

Para informações sobre o uso de propriedades do Gradle para configurações de proxy, consulte
o Guia do usuário do Gradle (link em inglês).
Observação: ao usar o Android Studio, as definições da página de configurações para proxy
HTTP do ambiente de desenvolvimento integrado do Android Studio modificam essas configurações
no arquivo [Link].
Otimizar o desempenho do Android Studio no Windows
O desempenho do Android Studio no Windows pode ser afetado por diversos fatores. Esta
seção descreve como você pode otimizar as configurações do Android Studio para ter o melhor
desempenho possível no Windows.
Minimizar o impacto do software antivírus na velocidade de compilação
Alguns softwares antivírus podem interferir no processo de compilação do Android Studio,
fazendo com que as compilações sejam executadas de maneira muito mais lenta. Quando você
executa uma versão no Android Studio, o Gradle compila os recursos e o código-fonte do seu app e,
em seguida, agrupa os recursos compilados em um APK. Durante esse processo, muitos arquivos
são criados no seu computador. Se seu software antivírus estiver habilitado para verificação em
tempo real, o antivírus poderá forçar a interrupção do processo de compilação sempre que um
arquivo for criado enquanto o antivírus verifica esse arquivo.
Para evitar esse problema, você pode excluir determinados diretórios da verificação em tempo
real do software antivírus.
Cuidado: para garantir que seu computador seja protegido contra softwares maliciosos, não
desative completamente a verificação em tempo real nem o software antivírus.
A lista a seguir mostra o local padrão de cada diretório do Android Studio que você precisa
excluir da verificação em tempo real:
50 Capítulo 4. Ferramentas de Desenvolvimento para Android

Descrição Local
Cache do Gradle %USERPROFILE%\.gradle
Projetos do Android Studio %USERPROFILE%\AndroidStudioProjects
SDK do Android %USERPROFILE%\AppData\Local\Android\SDK
Arquivos de sistema do Android Studio C:\Program Files\Android\Android Studio\system

Personalizar locais de diretório para ambientes controlados pela Política de grupo

Se uma Política de grupo limitar os diretórios que você pode excluir da verificação em tempo
real no seu computador, mova os diretórios do Android Studio para um dos locais que a Política de
grupo centralizada já exclui.
A lista a seguir mostra como personalizar o local de cada diretório do Android Studio, em que
C:\WorkFolder é o diretório que a Política de grupo já exclui:
Cache do Gradle
Defina a variável de ambiente GRADLE_USER_HOME para apontar para C:\WorkFolder\.gradle.
Projetos do Android Studio
Mova ou crie diretórios de projeto em um subdiretório adequado de C:\WorkFolder. Por
exemplo, C:\WorkFolder\AndroidStudioProjects.
SDK do Android
Siga estas etapas:
1. No Android Studio, abra a caixa de diálogo Settings (Preferences no macOS) e navegue até
Appearance & Behavior > System Settings > Android SDK.
2. Altere o valor de Android SDK Location para C:\WorkFolder\AndroidSDK.
Para evitar o download do SDK novamente, copie o diretório existente do SDK, localizado em
%USERPROFILE%\AppData\Local\Android\SDK por padrão, para o novo local.
Arquivos de sistema do Android Studio
Siga estas etapas:
1. No Android Studio, clique em Help > Edit Custom Properties.
O Android Studio solicita que você crie um arquivo [Link] se ainda não tiver um.
2. Adicione a seguinte linha ao arquivo [Link]:
3. [Link]=c:/workfolder/studio/caches/trunk-system
Configurar dependências de compilação off-line
Se você quiser criar seu projeto sem uma conexão de rede, siga as etapas abaixo para configurar
o ambiente de desenvolvimento integrado para usar as versões off-line do Android Gradle Plugin e
as dependências do Google Maven.
Caso você ainda não tenha feito isso, faça o download dos componentes off-line na página de
downloads.
Fazer o download dos componentes off-line e descompactá-los
Depois de fazer o download dos componentes off-line, descompacte o conteúdo deles no
diretório a seguir, que talvez você precise criar se ainda não existir:
• No Windows: %USER_HOME%/.android/manual-offline-m2/
• No macOS e no Linux: ~/.android/manual-offline-m2/
Para atualizar os componentes off-line, faça o seguinte:
1. Exclua o conteúdo dentro do diretório manual-offline-m2/.
2. Faça novamente o download dos componentes off-line.
3. Descompacte o conteúdo dos arquivos ZIP que você salvou para o diretório manual-offline-
m2/.
Incluir componentes off-line no seu projeto do Gradle
4.1 A ferramenta de desenvolvimento Android Studio 51

Para que o sistema de compilação do Android use os componentes off-line que você transferiu
por download e descompactou, é necessário criar um script, conforme descrito abaixo. Lembre-
se de que você precisa criar e salvar esse script apenas uma vez, mesmo depois de atualizar os
componentes off-line.
1. Crie um arquivo de texto vazio com o seguinte caminho e nome de arquivo:
• No Windows: %USER_HOME%/.gradle/init.d/[Link]
• No macOS e no Linux: ~/.gradle/init.d/[Link]
2. Abra o arquivo de texto e inclua o seguinte script:
def reposDir = new File([Link][’[Link]’], ".android/manual-offline-m2")
def repos = new ArrayList()
[Link] {[Link](it) }
[Link]()

allprojects {
buildscript {
repositories {
for (repo in repos) {
maven {
name = "injected_offline_${[Link]}"
url = [Link]().toURL()
}
}
}
}
repositories {
for (repo in repos) {
maven {
name = "injected_offline_${[Link]}"
url = [Link]().toURL()
}
}
}
}

Salve o arquivo de texto.

(Opcional) Se você quiser verificar se os componentes off-line funcionam como previsto,
remova os repositórios on-line dos arquivos [Link] do projeto, conforme mostrado abaixo.
Depois de confirmar que seu projeto foi compilado corretamente sem esses repositórios, você pode
colocá-los novamente nos arquivos [Link].
buildscript {
repositories {
// Hide these repositories to test your build against
// the offline components. You can include them again after
// you’ve confirmed that your project builds ‘offline’.
// google()
// jcenter()
}
...
}
52 Capítulo 4. Ferramentas de Desenvolvimento para Android

allprojects {
repositories {
// google()
// jcenter()
}
...
}

Observação: esse script é válido para todos os projetos do Gradle abertos na estação de
trabalho.
Atalhos do teclado
O Android Studio tem atalhos de teclado para muitas ações comuns. A Tabela 1 mostra os
atalhos de teclado padrão de cada sistema operacional. Como o Android Studio é baseado no
IntelliJ IDEA, lembre-se de que você pode encontrar mais atalhos na documentação de referência
de mapa de teclado do IntelliJ IDEA (link em inglês).
Observação: além dos atalhos padrão da Tabela 1 abaixo, você pode escolher entre diversos
atalhos pré-configurados ou criar outros personalizados. Para saber mais sobre como personalizar
os atalhos de teclado, consulte Configurar atalhos de teclado personalizados abaixo.
Tabela 1. Atalhos de teclado padrão para sistemas operacionais Windows/Linux e Mac.

Descrição Windows/Linux Mac

Geral
Salvar tudo Ctrl + S + S
Sincronizar Ctrl + Alt + Y + + Y
Maximizar/minimizar editor Ctrl + + F12 ctrl + + F12
Adicionar aos favoritos Alt + + F + + F
Inspecionar arquivo atual com perfil Alt + + I + + I
atual
Troca rápida de esquema Ctrl + ‘ (acento grave) ctrl + ‘ (acento grave)
Abrir caixa de diálogo das configura- Ctrl + Alt + S + , (vírgula)
ções
Abrir caixa de diálogo da estrutura do Ctrl + Alt + + S + ; (ponto e vírgula)
projeto
Alternar entre guias e janelas de ferra- Ctrl + ctrl +
menta
Navegar e buscar no Studio
Buscar em todos os locais (incluindo duas vezes duas vezes
código e menus)
Localizar Ctrl + F + F
Localizar próximo F3 + G
Localizar anterior + F3 + + G
Substituir Ctrl + R + R
Localizar ação Ctrl + + A + + A
Buscar por nome de símbolo Ctrl + Alt + + N + + O
Localizar classe Ctrl + N + O
Localizar arquivo (em vez da classe) Ctrl + + N + + O
Localizar no caminho Ctrl + + F + + F
Abrir pop-up de estrutura de arquivos Ctrl + F12 + F12
4.1 A ferramenta de desenvolvimento Android Studio 53

Descrição Windows/Linux Mac

Navegar entre guias abertas do editor Alt + ou Alt + ctrl + ou ctrl +
Ir para a fonte F4 ou Ctrl + F4 ou +
Abrir a guia do editor atual em uma + F4 + F4
nova janela
Pop-up de arquivos abertos recente- Ctrl + E + E
mente
Pop-up de arquivos editados recente- Ctrl + + E + + E
mente
Ir para último local editado Ctrl + + + +
Fechar guia do editor ativo Ctrl + F4 + W
Voltar à janela do editor a partir da ja- Esc
nela de uma ferramenta
Esconder janela da ferramenta ativa ou Shift + Esc +
recentemente ativa
Ir para linha Ctrl + G + L
Abrir hierarquia de tipos Ctrl + H ctrl + H
Abrir hierarquia de métodos Ctrl + + H + + H
Abrir hierarquia de chamadas Ctrl + Alt + H ctrl + + H
Visualizar layouts
Aumentar/diminuir zoom Ctrl + + ou Ctrl + − + + ou + −
Ajustar à tela Ctrl + 0 + 0
Tamanho real Ctrl + + 1 + + 1
Ferramentas de design: Layout Edi-
tor
Alternar entre os modos Design e Blue- B B
print
Alternar entre os modos retrato e paisa- O O
gem
Alternar dispositivos D D
Forçar atualização R R
Alternar painel de erros de renderização E E
Excluir restrições ou Ctrl + clique ou + clique
Aumentar zoom Ctrl + + adição + + adição
Diminuir zoom Ctrl + − + −
Ajustar à tela Ctrl + 0 + 0
Movimentar Manter a barra de espaço pres- Manter a barra de espaço pres-
sionada + clicar e arrastar sionada + clicar e arrastar
Ir para XML Ctrl + B + B
Selecionar todos os componentes Ctrl + A + A
Selecionar vários componentes + clique ou Ctrl + clique + clique ou + clique
Ferramentas de design: editor de na-
vegação
Aumentar zoom Ctrl + + adição + + adição
Diminuir zoom Ctrl + − + −
Ajustar à tela Ctrl + 0 + 0
54 Capítulo 4. Ferramentas de Desenvolvimento para Android

Descrição Windows/Linux Mac

Movimentar Manter a barra de espaço pres- Manter a barra de espaço pres-
sionada + clicar e arrastar sionada + clicar e arrastar
Ir para XML Ctrl + B + B
Alternar painel de erros de renderização E E
Agrupar no gráfico aninhado Ctrl + G + G
Percorrer os destinos ou Shift + ou +
Selecionar todos os destinos Ctrl + A + A
Selecionar vários destinos Shift + clique ou Ctrl + + clique ou + clique
clique
Escrever código
Gerar código (getters, setters, constru- Alt + Insert + N
tores, hashCode/equals, toString, novo
arquivo, nova classe)
Modificar métodos Ctrl + O ctrl + O
Implementar métodos Ctrl + I ctrl + I
Envolver com (if...else / try...catch / Ctrl + Alt + T + + T
etc.)
Excluir linha em que o cursor está Ctrl + Y +
Recolher/expandir bloco de código Ctrl + − ou ctrl + + + − ou + +
atual
Recolher/expandir todos os blocos de Ctrl + Shift + − ou Ctrl + + + − ou + +
código Shift + + +
Duplicar linha ou seleção atual Ctrl + D + D
Preenchimento automático de código Ctrl + Espaço ctrl + Espaço
básico
Preenchimento automático de código Ctrl + Shift + Espaço ctrl + + Espaço
inteligente (filtra a lista de métodos e
variáveis por tipo esperado)
Completar declaração Ctrl + Shift + + +
Busca rápida na documentação Ctrl + Q ctrl + J
Mostrar parâmetros do método selecio- Ctrl + P + P
nado
Ir para declaração (diretamente) Ctrl + B ou Ctrl + clique + B ou + clique
Ir para implementações Ctrl + Alt + B + + B
Ir para supermétodo/superclasse Ctrl + U + U
Abrir busca rápida de definição Ctrl + + I + Y
Alternar visibilidade da janela de ferra- Alt + 1 + 1
mentas do projeto
Alternar favorito F11 F3
Alternar favorito com mnemônico Ctrl + F11 + F3
Comentar/remover marca de comentá- Ctrl + / + /
rio com comentário de linha
Comentar/remover marca de comentá- Ctrl + Shift + / + + /
rio com comentário de bloco
Selecionar blocos de código cada vez Ctrl + W +
maiores
4.1 A ferramenta de desenvolvimento Android Studio 55

Descrição Windows/Linux Mac

Retornar seleção atual ao estado ante- Ctrl + Shift + W +
rior
Ir para o início do bloco de código Ctrl + [ + + [
Ir para o fim do bloco de código Ctrl + ] + + ]
Selecionar até o início do bloco de có- Ctrl + Shift + [ + + + [
digo
Selecionar até o fim do bloco de código Ctrl + Shift + ] + + + ]
Excluir até o fim da palavra Ctrl + Delete +
Excluir até o início da palavra Ctrl + +
Otimizar importações Ctrl + Alt + O ctrl + + O
Correção rápida do projeto (mostrar Alt + Enter + Enter
ações de intent e correções rápidas)
Reformatar código Ctrl + Alt + L + + L
Inserir recuo automático nas linhas Ctrl + Alt + I ctrl + + I
Inserir/remover recuo nas linhas ou Shift + ou +
Junção inteligente de linhas Ctrl + Shift + J ctrl + + J
Divisão inteligente de linhas Ctrl + Enter +
Começar nova linha Shift + +
Avançar/retornar para erro destacado F2 ou Shift + F2 F2 ou + F2
Criar e executar
Criar Ctrl + F9 + F9
Criar e executar Shift + F10 ctrl + R
Aplicar mudanças e reiniciar a atividade Ctrl + F10 ctrl + + R
Aplicar mudanças de código Ctrl + Alt + F10 ctrl + + + R
Depurar
Depurar Shift + F9 ctrl + D
Pular F8 F8
Entrar F7 F7
Entrada inteligente Shift + F7 + F7
Sair Shift + F8 + F8
Ir para local do cursor Alt + F9 + F9
Avaliar expressão Alt + F8 + F8
Retomar programa F9 + + R
Alternar ponto de interrupção Ctrl + F8 + F8
Ver pontos de interrupção Ctrl + Shift + F8 + + F8
Refatorar
Copiar F5 F5
Mover F6 F6
Excluir com segurança Alt + Delete +
Renomear Shift + F6 + F6
Mudar assinatura Ctrl + F6 + F6
Inline Ctrl + Alt + N + + N
Extrair método Ctrl + Alt + M + + M
Extrair variável Ctrl + Alt + V + + V
Extrair campo Ctrl + Alt + F + + F
Extrair constante Ctrl + Alt + C + + C
56 Capítulo 4. Ferramentas de Desenvolvimento para Android

Descrição Windows/Linux Mac

Extrair parâmetro Ctrl + Alt + P + + P
Histórico local/controle de versões
Confirmar projeto para VCS Ctrl + K + K
Atualizar projeto no VCS Ctrl + T + T
Ver mudanças recentes Alt + Shift + C + + C
Abrir pop-up do VCS Alt + ‘ (acento grave) ctrl + V

Configurar atalhos de teclado personalizados

Você pode escolher dentre diversos atalhos pré-configurados ou modificar um deles para criar
um novo atalho personalizado nas configurações de atalho do Android Studio.
Para abrir as configurações de atalhos de teclado, selecione File > Settings (no Mac, Android
Studio > Preferences) e vá até o painel Keymap.

Figura 10. Janela de configurações de atalhos de teclado do Android Studio.

1. Menu suspenso de atalhos: selecione o atalho que você quer usar nesse menu para alternar
entre os atalhos predefinidos.
2. Lista de ações: clique com o botão direito em uma ação para modificá-la. Você pode
adicionar mais atalhos para a ação, adicionar atalhos de mouse para associar uma ação a
um clique ou remover atalhos atuais. Se você estiver usando um atalho pré-configurado, a
alteração dos atalhos de uma ação criará automaticamente uma cópia do atalho e adicionará
suas alterações à cópia.
3. Botão "Copy": selecione um atalho do menu suspenso para usar como ponto de partida e
clique em Copy para criar um novo atalho personalizado. Você pode modificar o nome e os
atalhos.
4. Botão "Reset": selecione um atalho no menu suspenso e clique em Reset para revertê-lo à
configuração original.
5. Caixa de pesquisa: digite aqui para buscar um atalho pelo nome da ação.
6. Pesquisar por atalho: clique em Find Actions by Shortcut e digite o nome de um atalho
para pesquisar ações relacionadas.
Recursos de acessibilidade
4.1 A ferramenta de desenvolvimento Android Studio 57

Este documento descreve os recursos de acessibilidade no Android Studio 2.2 e versões

posteriores.
Compatibilidade do leitor de tela
No momento, os leitores de tela são compatíveis apenas com o Android Studio no Windows.
Uma variedade de leitores de tela está disponível para Windows, mas a compatibilidade com o
Android Studio varia:
• NVDA: recomendamos o uso do NVDA 2015 ou posterior (link em inglês), porque ele era o
leitor de tela predominante durante o desenvolvimento do suporte de acessibilidade para o An-
droid Studio. Se você utilizar a versão de 32 bits do NVDA, precisará instalar o JRE de 32 bits
na sua máquina, porque essa versão do NVDA requer C:\Windows\SysWOW64\WindowsAccessBridge-
[Link] para funcionar com o Android Studio. Se o NVDA não puder localizar esse arquivo, a
janela de log de eventos do NVDA exibirá a mensagem "Java Access Bridge não disponível".
• JAWS: não recomendamos o uso do Android Studio com o JAWS, porque podem ocorrer
problemas significativos de desempenho ao navegar em alguns lugares no Android Studio
durante o uso do JAWS.
• Windows Eyes: não recomendamos o uso do Android Studio com Windows Eyes, já que,
durante a instalação, o Windows Eyes substitui as bibliotecas de acessibilidade de todos
os JDKs e JREs na sua máquina por versões mais antigas que não são compatíveis com o
Android Studio.
• Windows Narrator incorporado: não recomendamos o Windows Narrator, porque ele não
é compatível com acessibilidade Java, de modo geral.
Ativar suporte para leitores de tela
Para configurar um leitor de tela com o Android Studio em um computador Windows, siga
estas etapas:
1. Instale o leitor de tela.
2. Verifique se você instalou a versão correta do Java para seu leitor de tela, da seguinte maneira:
• Se seu leitor de tela for de 32 bits, instale o JRE de 32 bits versão 1.7 ou posterior.
• Se seu leitor de tela for de 64 bits, instale o JRE de 64 bits versão 1.7 ou posterior.
3. Para ativar o Java Access Bridge, abra o prompt de comando e digite JRE_HOME\bin\jabswitch
-enable, em que JRE_HOME é o diretório do JRE na sua máquina.
4. Seu computador pode ter várias versões de alguns componentes importantes do Java Access
Bridge, que podem não ser compatíveis entre as versões. Para verificar se a configuração do
Java Access Bridge está correta, confirme se você possui as versões corretas dos seguintes
arquivos importantes, conforme descrito abaixo:
Se seu leitor de tela for de 32 bits:
• Verifique se C:\Windows\SysWOW64\[Link] está presente e tem
um número de versão 7.x.x.x ou posterior. A descrição do arquivo precisa ser "Java (TM)
Platform SE 7".
• Confirme se a data de modificação dos arquivos JRE_HOME\lib\ext\[Link] e
JRE_HOME\jre\lib\ext\[Link] (em que JRE_HOME é o diretório inicial do JRE na sua
máquina) é a mesma dos outros arquivos nos diretórios deles. Se as datas da última modifi-
cação desses arquivos forem diferentes das dos outros arquivos nos respectivos diretórios,
elas podem ter sido substituídas pelo instalador do Windows Eyes. Nesse caso, você precisa
reinstalar o JDK/JRE para garantir que esteja executando as versões corretas desses arquivos.
Se o leitor de tela tiver 64 bits:
• Verifique se C:\Windows\System32\[Link] está presente e tem
um número de versão 7.x.x.x ou posterior. A descrição do arquivo precisa ser "Java (TM)
Platform SE 7".
• Confirme se a data de modificação dos arquivos JRE_HOME\lib\ext\[Link] e
58 Capítulo 4. Ferramentas de Desenvolvimento para Android

JRE_HOME\jre\lib\ext\[Link] (em que JRE_HOME é o diretório inicial do JRE na sua

máquina) é a mesma dos outros arquivos nos diretórios deles. Se as datas da última modifi-
cação desses arquivos forem diferentes das dos outros arquivos nos respectivos diretórios,
elas podem ter sido substituídas pelo instalador do Windows Eyes. Nesse caso, você precisa
reinstalar o JDK/JRE para garantir que esteja executando as versões corretas desses arquivos.
5. Para ativar o suporte a leitores de tela no Android Studio, clique em File > Settings >
Appearance & Behavior > System Settings, marque a caixa de seleção Support screen
readers e reinicie o Android Studio. Essa configuração garante que a experiência do Android
Studio seja otimizada para usuários de leitores de tela, por exemplo, personalizando a
navegação pelo teclado. Se você estiver usando o Jaws, lembre-se de que é necessário iniciar
o Jaws antes de iniciar o Android Studio para que essa configuração entre em vigor.
Usar o teclado
Você pode usar os atalhos do teclado para navegar por todos os controles no Android Studio.
Observação? alguns elementos do Android Studio só podem ser acessados pelo teclado ao usar
o recurso de navegação por objeto (ou semelhante) do leitor de tela. Para ajuda sobre navegação
por objeto ou equivalente, consulte a documentação do leitor de tela, como o Guia do usuário do
NVDA (link em inglês).
Esta seção inclui os atalhos de teclado mais úteis para navegar pelo Android Studio. Para ver
um guia completo dos atalhos de teclado padrão do Android Studio, consulte Atalhos de teclado.
Ativar o menu principal
Para abrir o menu principal e outros menus de nível superior, use estes atalhos:
• Para abrir o menu principal, pressione F10.
• Para abrir um menu de nível superior em um computador Windows, pressione Alt+[mnemônico].
Por exemplo, para abrir o menu "File", pressione Alt+F.
Navegar entre arquivos e janelas de ferramenta
Para navegar entre arquivos e janelas de ferramenta, use estes atalhos:
• Para ir para uma janela de ferramenta, pressione Alt+[número] (no Mac, +[número]). Por
exemplo, para mover para a janela da ferramenta "Project structure", pressione Alt+0 (no
Mac, +0).
• Para alternar entre arquivos e janelas de ferramenta, pressione Control+Tab (no Mac, +Tab).
Para percorrer todas as entradas, continue pressionando Control+Tab.
Usar a barra de navegação
A barra de navegação permite percorrer arquivos em um projeto usando os seguintes atalhos:
• Para ativar a barra de navegação, pressione Alt+Home (no Mac, +Fn+seta para a esquerda).
• Para alternar entre itens na hierarquia de navegação, pressione a seta para a esquerda ou para
a direita.
• Para abrir uma janela pop-up exibindo o conteúdo do item atual, pressione a barra de espaço.
Desativar o dobramento de código
Por padrão, o editor do Android Studio dobra parte do texto em regiões expansíveis. Por
exemplo, a lista "import"no início de um arquivo de origem Java é dobrada em uma única linha
contendo o texto "import . . . ".
Ao usar um leitor de tela, o dobramento de código pode dificultar a navegação. Para modificar as
opções de dobramento de código, clique em File > Settings > Editor > General > Code Folding
(no Mac, File > Properties > Editor > General > Code Folding).
Desativar recursos de inserção automática
Por padrão, o Android Studio insere automaticamente chaves, aspas ou parênteses de fecha-
mento.
Ao usar um leitor de tela, a inserção automática pode não ser útil. Para modificar as opções de
inserção automática, clique em File > Settings > Editor > General > Smart Keys (no Mac, File
4.1 A ferramenta de desenvolvimento Android Studio 59

> Properties > Editor > General > Smart Keys).

Desativar o pop-up automático de conclusão de código
Por padrão, o Android Studio mostra automaticamente o pop-up de conclusão de código quando
determinadas sequências de teclas são digitadas e, se encontrar apenas uma correspondência,
inserções automáticas correspondentes. Esse comportamento pode criar uma experiência confusa
com leitores de tela.
Para modificar as opções de pop-up automático e inserção automática para conclusão de código,
clique em File > Settings > Editor > General > Code Completion (no Mac, File > Properties >
Editor > General > Code Completion).
Erros de acesso, avisos e inspeções de código
Use o teclado para ver e navegar pelos erros, avisos e inspeções de código.
Analisar erros em todos os arquivos em um projeto
Quando você clica em Build > Make Project, todos os avisos e erros aparecem na janela
Messages. A janela Messages pode ser acessada a partir do Android Studio 2.2. Veja o histórico
de bugs (link em inglês).
Para analisar os erros na janela Messages, use estes atalhos:
• Para ativar a janela Messages, pressione Alt+0 (no Mac, +0).
• Para navegar por todas as mensagens, pressione as setas para cima e para baixo.
Como alternativa, você pode usar o editor de texto para ver e navegar por todos os erros. Se
quiser usar o editor para analisar os erros, pressione Control+Alt+seta para cima/baixo (no Mac,
+ +seta para cima/baixo).
Analisar erros e inspeções de código em um único arquivo
Para analisar erros em um único arquivo, use estes atalhos:
• Para ir para o erro seguinte ou anterior, pressione F2 ou Control+F2 (no Mac, +F2).
• Para abrir uma dica contendo a mensagem de erro, pressione Control+F1 (no Mac, +F1).
Para navegar para todas as inspeções de código, não apenas erros, clique em File > Settings
> Editor > General (no Mac, File > Preferences > Editor > General) e desmarque ’Next error’
action goes to high priority problems only.
Usar o recuo da guia
Por padrão, o Android Studio usa o caractere de espaço para recuo. Os usuários de leitores de
tela podem preferir o recuo da guia porque a verbalização é mais concisa.
Para alterar o recuo da guia, clique em File > Settings > Editor > Code Style > Java > Tabs
and Indents (no Mac, File > Preferences > Editor > Code Style > Java > Tabs and Indents) e
marque a caixa de seleção Use tab character.
Usar o Layout Editor
A partir do Android Studio 2.2, o Layout Editor não está totalmente acessível. Veja o histórico
de bugs (link em inglês). Uma solução temporária é abrir arquivos de layout no modo de texto por
padrão. Veja o histórico de bugs (link em inglês).
Para abrir arquivos de layout no modo de visualização de texto por padrão, clique em File >
Settings > Editor > Layout Editor (no Mac, File > Preferences > Editor > Layout Editor) e
marque a caixa de seleção Prefer XML Editor.
Atualizar o Ambiente de desenvolvimento integrado e o SDK Tools
Depois de instalar o Android Studio, é fácil manter em dia o ambiente de desenvolvimento
integrado dele e as ferramentas do Android SDK com atualizações automáticas e o Android SDK
Manager.
Atualizar o ambiente de desenvolvimento integrado e alterar canais
O Android Studio usa uma pequena caixa de diálogo em forma de balão para avisar sobre a
disponibilidade de atualizações para o ambiente de desenvolvimento integrado. No entanto, você
60 Capítulo 4. Ferramentas de Desenvolvimento para Android

pode verificar isso manualmente clicando em Help > Check for Update (no Mac, Android Studio
> Check for Updates).
As atualizações do Android Studio estão disponíveis nos canais de lançamento a seguir:
• Canal Canary: são versões de vanguarda absoluta, atualizadas aproximadamente uma vez
por semana e disponibilizadas para download em [Link]/studio/preview.
Além de receber versões canary do Android Studio, você também receberá versões de pré-
lançamento de outras ferramentas do SDK, entre elas o Android Emulator.
Essas versões estão sujeitas a mais bugs, mas são testadas. Além disso, queremos oferecer
acesso antecipado a elas para que você possa testar novos recursos e enviar seu feedback. Esse
canal não é recomendado para desenvolvimento de produção.
• Canal Dev: são versões canary escolhidas manualmente e aprovadas em uma rodada com-
pleta de testes internos.
• Canal Beta: são versões candidatas a lançamento baseadas em versões canary estáveis e
lançadas para coletar feedback antes de serem disponibilizadas no Canal Stable.
• Canal Stable: é a versão estável oficial disponível para download em [Link]/studio.
Se quiser testar um dos canais de lançamento (Canary, Dev ou Beta) sem deixar de usar a
compilação Stable para os projetos de produção do Android, instale ambos lado a lado.
Para alterar o canal de atualização de uma instalação existente, siga estas etapas:
1. Para abrir a janela Preferences, clique em File > Settings (no Mac, Android Studio >
Preferences).
2. No painel à esquerda, clique em Appearance & Behavior > System Settings > Updates.
3. Verifique se a opção Automatically check for updates está marcada e selecione um canal
na lista suspensa (consulte a Figura 11).
4. Clique em Apply ou OK.

Figura 11. As preferências de atualização do Android Studio.

Excluir diretórios não usados do Android Studio
4.1 A ferramenta de desenvolvimento Android Studio 61

Quando você executa uma versão principal do Android Studio pela primeira vez, ela busca
diretórios que contêm caches, configurações, índices e registros de versões do Android Studio para
as quais uma instalação correspondente não é encontrada. Em seguida, a caixa de diálogo Delete
Unused Android Studio Directories exibe locais, tamanhos e horários das últimas modificações
desses diretórios não usados e mostra uma opção para excluí-los.
Estes são os diretórios que o Android Studio pode excluir:
• Linux: ~/.AndroidStudio[Preview]_version_
• Mac: ~/Library/{Preferences, Caches, Logs, Application Support}/AndroidStudio[Preview]_version_
• Windows: %USER%\.AndroidStudio[Preview]_version_
Atualizar ferramentas com o SDK Manager
O Android SDK Manager ajuda a fazer o download de ferramentas, plataformas e outros
componentes do SDK necessários para desenvolver apps. Depois do download, é possível encontrar
cada pacote no diretório indicado como o Android SDK Location, conforme a Figura 12.
Para abrir o SDK Manager no Android Studio, clique em Tools > SDK Manager ou em SDK
Manager na barra de ferramentas. Se não estiver usando o Android Studio, faça o download de
ferramentas usando a ferramenta de linha de comando sdkmanager.
Quando uma atualização estiver disponível para um pacote, um traço será exibido na caixa
de seleção ao lado do pacote.
• Para instalar um item novo ou atualizar um existente, clique na caixa de seleção para que ela
exiba uma marca de verificação.
• Para desinstalar um pacote, clique na caixa de seleção para desmarcá-la.
As atualizações pendentes são indicadas na coluna esquerda com um ícone de download .
As remoções pendentes são indicadas com uma cruz vermelha .
Para atualizar os pacotes selecionados, clique em Apply ou OK e aceite os termos de licença.

Figura 12. O Android SDK Manager.

Pacotes recomendados
62 Capítulo 4. Ferramentas de Desenvolvimento para Android

Considere cuidadosamente as ferramentas a seguir na guia SDK Tools:

Android SDK Build-Tools
Obrigatória. Inclui ferramentas para compilar apps Android. Consulte as notas da versão do
SDK Build Tools.
Android SDK Platform-Tools
Obrigatória. Inclui diversas ferramentas necessárias para a plataforma Android, entre elas a
ferramenta adb.
Android SDK Tools
Obrigatória. Inclui ferramentas essenciais, como o ProGuard. Veja as notas da versão das
ferramentas do SDK.
Android Emulator
Recomendada. Uma ferramenta de emulação de dispositivo baseada em QEMU que pode ser
usada para depurar e testar seus aplicativos em um ambiente de execução Android real. Consulte as
notas da versão do Android Emulator.
Observação: a maioria das bibliotecas de API oferecidas anteriormente pelos pacotes do
Repositório de suporte (como a Android Support Library, o Layout restrito, os serviços do Google
Play e o Firebase) agora é disponibilizada no repositório Maven do Google. Os projetos criados
com o Android Studio 3.0 e versões posteriores incluem automaticamente esse repositório na confi-
guração da compilação. Caso você esteja usando um projeto mais antigo, adicione manualmente o
repositório Maven do Google ao arquivo [Link].
Na guia SDK Platforms, também é necessário instalar pelo menos uma versão da plataforma
Android. Cada versão oferece diversos pacotes diferentes. Para fazer o download apenas dos
pacotes necessários, clique na caixa de seleção ao lado do nome da versão.
Para ver todos os pacotes disponíveis para cada plataforma Android, clique em Show Package
Details, na parte inferior da janela. Em cada versão de plataforma, você encontrará os pacotes a
seguir:
Android SDK Platform
Obrigatório. Para compilar o aplicativo, é preciso ter pelo menos uma plataforma no seu
ambiente. Para oferecer a melhor experiência do usuário nos dispositivos mais recentes, use a
última versão de plataforma como destino de compilação. Ainda será possível executar o app
em versões anteriores. No entanto, para execução em dispositivos com a versão mais recente do
Android, é necessário compilá-lo com a versão mais recente da plataforma para usar os novos
recursos.
Intel ou ARM System Images
Recomendado. A imagem de sistema é necessária para executar o Android Emulator. Cada
versão de plataforma contém as imagens de sistema compatíveis. Você também pode fazer o
download das imagens de sistema posteriormente durante a criação de Android Virtual Devices
(AVDs) no AVD Manager. Selecione "Intel"ou "ARM"de acordo com o processador do computador
de desenvolvimento.
Observação: se você pretende usar APIs dos serviços do Google Play (incluindo o Firebase),
precisará utilizar a imagem de sistema do Google APIs ou do Google Play (que inclui o app Play
Store).
A lista acima não é absoluta e você pode adicionar outros sites para o download de outros
pacotes de terceiros.
Em algumas situações, um pacote do SDK pode exigir uma revisão mínima específica de
outra ferramenta. Nesse caso, o SDK Manager exibe uma notificação com um aviso e adiciona as
dependências à sua lista de downloads.
Dica: você também pode personalizar o arquivo [Link] para que cada projeto use uma
cadeia e opções de compilação específicas. Para ver mais informações, consulte Configuração de
4.1 A ferramenta de desenvolvimento Android Studio 63

compilações do Gradle.
Editar ou adicionar sites de ferramentas do SDK
Para gerenciar em que sites de SDK o Android Studio verifica a existência de atualizações de
ferramentas do Android e de terceiros, clique na guia SDK Update Sites. Você pode adicionar
outros sites que hospedam ferramentas próprias e fazer o download de pacotes nesses sites.
Por exemplo, uma operadora de celular ou fabricante de dispositivos pode oferecer outras
bibliotecas de API compatíveis com dispositivos próprios com Android. Para desenvolver usando
essas bibliotecas, você pode instalar o pacote do Android SDK desses terceiros adicionando o URL
das ferramentas do SDK deles ao SDK Manager na guia SDK Update Sites.
Se uma operadora ou fabricante de dispositivos hospedou um arquivo repositório de com-
plementos do SDK no próprio site, siga estas etapas para adicionar esse site ao Android SDK
Manager:
1. 1. Clique na guia SDK Update Sites.
2. Clique em Add na parte inferior da janela.
3. Insira o nome e o URL do site do terceiro e clique em OK.
4. Verifique se a caixa de seleção está marcada na coluna Enabled.
5. Clique em Apply ou OK.
Os pacotes do SDK disponíveis no site aparecerão na guia SDK Platforms ou SDK Tools,
conforme o caso.
Download automático de pacotes ausentes com o Gradle
Quando você executa uma compilação da linha de comando ou usa o Android Studio 3.3 ou
posteriores, o Gradle pode fazer o download automático de pacotes de SDK ausentes de que um
projeto depende, desde que os termos de licença do SDK correspondente já tenham sido aceitos por
meio do SDK Manager.
Quando você aceita os termos de licença usando o SDK Manager, o Android Studio cria um
diretório de licenças dentro do diretório inicial do SDK. Esse diretório de licenças é necessário para
que o Gradle faça o download automático dos pacotes que estão faltando.
Observação: esse diretório de licenças não é gerado quando você aceita os termos de licença
usando a ferramenta de linha de comando android. Para usar esse recurso, aceite os termos primeiro
usando o SDK Manager.
Se você aceitou os termos de licença em uma estação de trabalho, mas queira compilar seus
projetos em outra, pode exportar suas licenças copiando o diretório de licenças aceitas. Para copiar
as licenças em outra máquina, siga estas etapas:
1. Em uma máquina com o Android Studio instalado, clique em Tools > Android > SDK
Manager. Na parte superior da janela, procure o "Android SDK Location".
2. Acesse esse diretório e localize licenses/ dentro dele. Caso não encontre o diretório licenses/,
volte para o Android Studio, atualize suas ferramentas de SDK e verifique se aceitou os
termos de licença. Ele estará disponível quando você retornar ao diretório inicial do Android
SDK.
3. Copie todo o licenses/ e cole-o no diretório inicial do Android SDK na máquina em que você
quer compilar seus projetos.
Agora o Gradle poderá fazer o download automático dos pacotes ausentes necessários para seu
projeto.
Esse recurso é desativado automaticamente para compilações executadas no Android Stu-
dio, uma vez que o SDK Manager processa o download de pacotes ausentes no ambiente de
desenvolvimento integrado. Você também pode desativar manualmente esse recurso configurando
[Link]=false no arquivo [Link] do projeto.
Noções básicas do fluxo de trabalho do desenvolvedor
O fluxo de trabalho para desenvolver um app para Android é conceitualmente o mesmo que o
64 Capítulo 4. Ferramentas de Desenvolvimento para Android

de outras plataformas de apps. No entanto, para criar com eficiência um app bem projetado para
Android, são necessárias algumas ferramentas especializadas. A lista a seguir fornece uma visão
geral do processo para criar um app Android e inclui links para algumas ferramentas do Android
Studio que você precisa usar em cada fase de desenvolvimento.

1. Configurar seu espaço de trabalho

Esta é a fase que você provavelmente já concluiu: instalar o Android Studio e criar um projeto.
Para ver um tutorial sobre o Android Studio que ensina alguns fundamentos de desenvolvimento
do Android, confira também o guia sobre como Criar seu primeiro app.
2. Programar o app
Agora você pode começar a trabalhar. O Android Studio inclui uma variedade de ferramentas e
inteligência para ajudar você a trabalhar mais rápido, desenvolver códigos de qualidade, projetar
uma IU e criar recursos para diferentes tipos de dispositivo. Para ver mais informações sobre as
ferramentas e os recursos disponíveis, consulte Programe o aplicativo.
3. Criar e executar
Nessa fase, você cria seu projeto em um pacote APK depurável que pode ser instalado e
executado no emulador ou em um dispositivo Android. Para ver mais informações sobre como
executar seu código, consulte Compilar e executar seu aplicativo.
 4.2 Gerenciar Seu Projeto 65

Você também pode começar a personalizar sua versão. Por exemplo, você pode criar variantes
de compilação que produzam diferentes tipos de APK do mesmo projeto e reduzir o código e os
recursos para tornar o arquivo APK menor. Para ver como começar a personalizar sua compilação,
consulte Configurar sua compilação.
4. Depurar, criar perfil e testar
Esta é a fase iterativa, em que você continua a programar seu app, mas com foco na eliminação
de bugs e na otimização do desempenho do app. Obviamente, criar testes ajudará você nesses
esforços.
Para ver informações sobre tarefas básicas de depuração, leia Depure seu aplicativo e Gravar e
visualizar registros.
Para ver e analisar várias métricas de desempenho, como uso de memória, tráfego de rede,
impacto na CPU, entre outras, consulte Ferramentas de criação de perfil de desempenho.
E para ver uma introdução à criação de testes, consulte Testar o aplicativo.
5. Publicar
Quando estiver tudo pronto para liberar seu app para os usuários, considere alguns outros
aspectos, como o controle de versões do app e a assinatura dele com uma chave. Para ver mais
informações, consulte Publicar o aplicativo.

4.2 Gerenciar Seu Projeto

Visão geral de projetos
Os projetos no Android Studio contêm tudo o que define o espaço de trabalho para um app, do
código-fonte e recursos ao código de teste e configurações de compilação. Quando você inicia um
novo projeto, o Android Studio cria a estrutura necessária para todos os seus arquivos e os torna
visíveis na janela Project à esquerdo do ambiente de desenvolvimento integrado (clique em View >
Tool Windows > Project). Essa página oferece uma visão geral dos principais componentes do
seu projeto.
Módulos
Módulo é uma coleção de arquivos de origem e configurações de compilação que permitem
dividir o projeto em unidades distintas de funcionalidade. O projeto pode ter um ou mais módulos, e
um módulo pode usar outro como dependência. Cada módulo pode ser individualmente compilado,
testado e depurado.
Muitas vezes, módulos extras são úteis para criar bibliotecas de código no projeto ou quando
você quer criar conjuntos de código e recursos diferentes para tipos de dispositivo distintos,
como smartphones e wearables, mas mantendo todos os arquivos no escopo do mesmo projeto e
compartilhando algum código.
Você pode adicionar um novo módulo ao projeto clicando em File > New > New Module.
O Android Studio oferece alguns tipos diferentes de módulo:
Módulo de app Android
Oferece um contêiner para o código-fonte, os arquivos de recursos e configurações do app,
como o arquivo de compilação do módulo e o arquivo de manifesto do Android. Quando você cria
um novo projeto, o nome do módulo padrão é "app".
Na janela Create New Module, o Android Studio oferece os seguintes tipos de módulo de app:
• Módulo de smartphone e tablet
• Módulo de Wear OS
• Módulo de Android TV
• Módulo de Glass
Cada um deles fornece arquivos essenciais e alguns modelos de código adequados ao tipo de
dispositivo ou app correspondente.
66 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para ver mais informações sobre a adição de um módulo, leia Adicionar módulo para um novo
dispositivo.
Módulo de recurso dinâmico
Representa um recurso modularizado do seu app que pode aproveitar a Dynamic Delivery do
Google Play. Por exemplo, com módulos de recursos dinâmicos, você pode oferecer aos usuários
determinados recursos do seu app sob demanda ou como experiências instantâneas por meio do
Google Play Instant.
Para saber mais, leia Adicionar compatibilidade com Dynamic Delivery.
Módulo de biblioteca

Fornece um contêiner para o código reutili-

zável, que pode servir de dependência em outros módulos de app ou ser importado para outros
projetos. Em termos de estrutura, o módulo de biblioteca é igual ao módulo de app. No entanto,
quando compilado, ele cria um arquivo de código em vez de um APK, e por isso não pode ser
instalado em um dispositivo.
Na janela Create New Module, o Android Studio oferece os seguintes módulos de biblioteca:
• Biblioteca do Android: esse tipo de biblioteca pode conter todos os tipos de arquivo compatí-
veis em um projeto Android, incluindo código-fonte, recursos e arquivos de manifesto. A
compilação gera um arquivo ARchive do Android (AAR), que pode ser adicionado como
dependência dos módulos do seu app Android.
• Biblioteca Java: esse tipo de biblioteca pode conter apenas arquivos de origem em Java. O
resultado da compilação é um arquivo Java Archive (JAR), que você pode adicionar como
dependência de módulos do seu app Android ou outros projetos Java.
Módulo do Google Cloud
Oferece um contêiner para o código de back-end do Google Cloud. Esse módulo tem as
dependências e o código necessários para um back-end do Java App Engine, que usa HTTP simples,
Cloud Endpoints e Cloud Messaging para se conectar ao seu app. Você pode desenvolver seu
back-end para fornecer os serviços em nuvem de que seu app precisa.
4.2 Gerenciar Seu Projeto 67

O uso do Android Studio para desenvolver o módulo do Google Cloud permite gerenciar o
código do app e do back-end no mesmo projeto. Também é possível executar e testar o código de
back-end localmente e usar o Android Studio para implantar o módulo de Google Cloud.
Para ver mais informações sobre a execução e implantação de um módulo do Google Cloud,
consulte Como executar, testar e implantar o back-end.
Algumas pessoas também usam o termo "subprojeto"em vez de "módulo". Isso não representa
um problema, porque o Gradle também chama os módulos de projetos. Por exemplo, quando você
cria um módulo de biblioteca e quer adicioná-lo como dependência a um módulo de app Android, é
necessário declará-lo da seguinte forma:
dependencies {
compile project(’:my-library-module’)
}

Arquivos de projetos
Por padrão, o Android Studio exibe os arquivos do seu projeto na visualização Android. Essa
visualização não reflete a hierarquia de arquivos real no disco, mas é organizada por módulos e
tipos de arquivo para simplificar a navegação entre os principais arquivos de origem do seu projeto,
ocultando alguns arquivos ou diretórios pouco usados. Veja a seguir algumas mudanças estruturais
com relação à estrutura no disco:
• Mostra todos os arquivos de configuração da compilação do projeto em um grupo Gradle
Script de nível superior.

• Mostra todos os arquivos de manifesto de cada mó-

dulo em um grupo no nível de módulos (quando existem arquivos de manifesto diferentes
68 Capítulo 4. Ferramentas de Desenvolvimento para Android

para variações de produto e tipos de compilação diferentes).

• Mostre todos os arquivos de recursos alternativos em um único grupo, em vez de em pastas
separadas por qualificador de recurso. Por exemplo, todas as versões de densidade do ícone
na tela de início podem ser vistas lado a lado.
Em cada módulo de app Android, os arquivos são mostrados nos seguintes grupos:
manifestos
Contém o arquivo [Link].
java
Contém os arquivos de código-fonte Java, separados por nome de pacote, incluindo o código de
teste JUnit.
res
Contém todos os recursos que não são código, como layouts XML, strings de IU e imagens
bitmap, divididos em subdiretórios correspondentes. Para saber mais informações sobre todos os
tipos de recursos possíveis, consulte Fornecimento de recursos.
A visualização de projeto Android
Para ver a estrutura de arquivos real do projeto, incluindo todos os arquivos ocultos na visuali-
zação do Android, selecione Project no menu suspenso na parte superior da janela Project.
Quando você seleciona a visualização Project, pode ver um número muito maior de arquivos e
diretórios. Os mais importantes são:
module-name/
build/
Contém saídas de compilação.
libs/
Contém bibliotecas privadas.
src/
Contém todos os arquivos de código e recursos do módulo nos seguintes subdiretórios:
androidTest/
Contém o código dos testes de instrumentação executados em um dispositivo Android. Para ver
mais informações, consulte a documentação do Android Test.
main/
Contém os arquivos do conjunto de origem "main": o código Android e os recursos compar-
tilhados por todas as variantes de compilação. Os arquivos para outras variantes de compilação
residem em diretórios irmãos, como src/debug/ para o tipo de compilação de depuração.
[Link]
Descreve a natureza do aplicativo e de cada um dos componentes dele. Para ver mais informa-
ções, consulte a documentação [Link].
java/
Contém os códigos-fonte Java.
jni/
Contém o código nativo que usa a Java Native Interface (JNI). Para ver mais informações,
consulte a documentação do Android NDK.
gen/
Contém os arquivos Java gerados pelo Android Studio, como o arquivo [Link] e as interfaces
criadas de arquivos AIDL.
res/
Contém recursos de aplicativos, como arquivos drawable, arquivos de layout e strings de IU.
Consulte Recursos de aplicativos para ver mais informações.
assets/
4.2 Gerenciar Seu Projeto 69

Contém o arquivo que precisa ser compilado em um arquivo .apk no estado em que está. Você
pode navegar nesse diretório da mesma maneira que um sistema de arquivos típico usando URIs e
ler arquivos como um fluxo de bytes usando AssetManager . Por exemplo, esse é um bom local
para texturas e dados de jogos.
test/
Contém código para testes locais executados na JVM host.
[Link] (módulo)
Define as configurações de compilação do módulo.
[Link] (projeto)
Define a configuração de compilação que se aplica a todos os módulos. Esse arquivo faz parte
do projeto, então precisa ser mantido no controle de revisões em conjunto com todo o código-fonte
restante.
Para saber mais sobre outros arquivos de compilação, consulte Configurar sua compilação.
Configurações de estrutura de projetos
Para alterar várias configurações do seu projeto do Android Studio, abra a caixa de diálogo
Project Structure clicando em File > Project Structure. Ela contém as seguintes seções:
• SDK Location: define a localização do JDK, Android SDK e Android NDK que seu projeto
usa.
• Project: define a versão do Gradle e do plug-in do Android para Gradle, bem como o nome
da localização do repositório.
• Developer Services: contém configurações para componentes complementares do Android
Studio do Google ou de terceiros. Consulte Developer Services abaixo.
• Modules: permite que você edite configurações de compilação específicas do módulo,
incluindo o SDK de destino e mínimo, a assinatura do app e as dependências da biblioteca.
Consulte Modules abaixo.
Developer Services
A seção Developer Services da caixa de diálogo Project Structure contém páginas de confi-
guração para vários serviços que você pode usar com seu app. Essa seção contém as seguintes
páginas:
• Google AdMob: permite ativar o componente Google AdMob do Google, que ajuda você a
entender os usuários e exibir anúncios personalizados para eles.
• Analytics: permite ativar o Google Analytics, que ajuda a medir as interações dos usuários
com seu app em diversos dispositivos e ambientes.
• Authentication: permite que os usuários utilizem o Login do Google para fazer login no seu
app com as Contas do Google deles.
• Cloud: permite ativar os serviços do Firebase baseados em nuvem para seu app.
• Notifications: permite usar o Google Cloud Messaging para a comunicação entre o app e o
servidor.
A ativação de qualquer um desses serviços pode fazer com que o Android Studio adicione
dependências e permissões necessárias ao seu app. Cada página de configuração lista essas e outras
ações que o Android Studio realizará se você ativar o serviço associado.
Modules
A seção de configurações Modules permite alterar as opções de configuração de cada um dos
módulos do seu projeto. A página de configurações de cada módulo é dividida nas seguintes guias:
• Properties: especifica as versões do SDK e das ferramentas de compilação usadas para
compilar o módulo.
• Signing: especifica o certificado usado para assinar o APK.
• Flavors: permite criar diversas variações de compilação, em que cada variação especifica
um conjunto de configurações, como a versão mínima e pretendida do SDK do módulo e
70 Capítulo 4. Ferramentas de Desenvolvimento para Android

o código e o nome da versão. Por exemplo, é possível definir uma variação que tenha um
SDK com versão mínima 15 e versão pretendida 21 e outra variação que tenha um SDK com
versão mínima 19 e versão pretendida 23.
• Build Types: permite criar e modificar configurações de compilação, conforme descrito
em Configuração de compilações do Gradle. Por padrão, cada módulo tem os tipos de
compilação debug e release, mas tipos adicionais podem ser definidos, se necessário.
• Dependências: lista as dependências de biblioteca, arquivo e módulo para este módulo. É
possível adicionar, modificar e excluir dependências nesse painel. Para obter mais informa-
ções sobre dependências de módulos, consulte Configurar compilações do Gradle.

Criar um projeto

O Android Studio facilita a criação de apps Android em vários formatos, como celulares, tablets,
TVs e dispositivos Wear. Esta página mostra como iniciar um novo projeto de app Android ou
importar um projeto existente.

Se você não tiver um projeto aberto, o Android Studio exibirá a tela de boas-vindas, onde
poderá criar um novo projeto clicando em Start a new Android Studio project.

Se você tiver um projeto aberto, comece a criar um novo projeto selecionando File > New >
New Project no menu principal.

Em seguida, você verá o assistente Create New Project, que permite escolher o tipo de projeto
que você quer criar e o preenche com o código e recursos para dar os primeiros passos. Esta página
orienta você durante a criação de um novo projeto usando o assistente Create New Project.

Escolher seu projeto

Na tela Choose your project, selecione o tipo de projeto a ser criado a partir de categorias
de formatos de dispositivo, mostradas como guias próximas à parte superior do assistente. Por
exemplo, a Figura 13 mostra um projeto com uma atividade básica do Android para um smartphone
e um tablet selecionados.
4.2 Gerenciar Seu Projeto 71

Figura 13. Na primeira tela do assistente, escolha o tipo de projeto que você quer criar.

Selecionando o tipo de projeto que você quer criar, o Android Studio pode incluir uma amostra
de código e de recursos para ajudar você a começar.

Depois de fazer uma seleção, clique em Next.

Configurar seu projeto

A próxima etapa é definir algumas configurações e criar seu novo projeto, conforme descrito
abaixo e mostrado na Figura 14. Se você estiver criando um projeto C++ nativo, leia Criar um
novo projeto com compatibilidade com C/C++ para saber mais sobre as opções necessárias para
configurá-lo.
72 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 14. Configure seu novo projeto com algumas definições.

1. Em Name, especifique o nome do seu projeto.
2. Em Package name, especifique o nome do pacote. Por padrão, esse nome de pacote também
se torna o ID do aplicativo, que você pode alterar mais tarde.
3. Em Save location, especifique onde você quer armazenar localmente o projeto.
4. Em Language, selecione o idioma que você quer que o Android Studio use ao criar um
código de amostra para o novo projeto. Lembre-se de que você não precisa usar apenas esse
idioma para criar o projeto.
5. Em Minimum API level, selecione o nível mínimo da API com o qual o app será compatível.
Quando você seleciona um nível de API inferior, o app fica limitado a um número menor de
APIs modernas do Android. No entanto, uma porcentagem maior de dispositivos Android
consegue executar seu app. O contrário é verdadeiro quando você seleciona um nível de API
superior. Se você quiser ver mais informações para ajudar na sua decisão, clique em Help
me choose.
6. Se o tipo de projeto selecionado for compatível com experiências instantâneas por meio do
Google Play Instant e você quiser ativá-las para seu app, marque a caixa ao lado de This
project will support instant apps. Para saber mais, leia Criar seu primeiro app instantâneo.
7. Se você quiser que o projeto use bibliotecas AndroidX por padrão, que são substituições
aprimoradas das Android Support Libraries, marque a caixa ao lado de Use AndroidX
4.2 Gerenciar Seu Projeto 73

artifacts. Para saber mais, leia a visão geral do AndroidX.

8. Quando você achar que está tudo pronto para criar o projeto, clique em Finish.

O Android Studio cria seu novo projeto com alguns recursos e códigos básicos para você dar
os primeiros passos. Se, posteriormente, você decidir adicionar compatibilidade com um formato
de dispositivo diferente, poderá adicionar um módulo ao projeto. Além disso, se você quiser
compartilhar código e recursos entre os módulos, poderá criar uma biblioteca Android.

Para saber mais sobre a estrutura dos projetos Android e os tipos de módulo, leia Visão geral de
projetos. Se esse é seu primeiro desenvolvimento em Android, comece com os Primeiros passos no
Android.

Importar um projeto

Para importar um projeto local existente para o Android Studio, faça o seguinte:

1. Clique em File > New > Import Project.

2. Na janela exibida, navegue até o diretório raiz do projeto que você quer importar.
3. Clique em OK.

O Android Studio abre o projeto em uma nova janela do ambiente de desenvolvimento integrado
e indexa o conteúdo correspondente.

Se você estiver importando um projeto do controle de versões, use o menu File > New > Project
from Version Control. Para ver mais informações sobre como importar projetos do controle de
versões, leia Procedimentos específicos de VCS (link em inglês) do IntelliJ.

Se você está importando um projeto do ADT para Eclipse no Android Studio, a forma como
você adiciona o projeto depende da estrutura dele. Para ler mais sobre como importar projetos do
Eclipse, consulte Migrar do Eclipse.

Adicionar código Kotlin

O Android Studio 3.0 e versões posteriores tem total compatibilidade com o Kotlin. Por isso,
é fácil adicionar arquivos Kotlin ao projeto existente e converter o código da linguagem Java em
Kotlin. Você pode usar todas as ferramentas existentes do Android Studio com seu código Kotlin,
como o preenchimento automático, verificador de lint, refatoração, depuração e muito mais.

Se você estiver iniciando um novo projeto e quiser usar Kotlin, consulte Criar um projeto.
Confira também nossos códigos Kotlin de amostra.

Adicionar Kotlin a um projeto existente

1. Clique em File > New e selecione um dos vários modelos do Android. Se a lista de modelos
não for exibida nesse menu, abra antes a janela Project e selecione o módulo do seu app.
74 Capítulo 4. Ferramentas de Desenvolvimento para Android

2. No assistente exibido, selecione Kotlin em Source language.

4.2 Gerenciar Seu Projeto 75

3. Prossiga no assistente até concluir.

Como alternativa, você pode clicar em File > New > Kotlin File/Class para criar um arquivo
básico. Se essa opção não for exibida, abra a janela Project e selecione o diretório java. A janela
New Kotlin File/Class oferece várias opções para o tipo de arquivo, mas qual será escolhido não
importa, porque o Kotlin o alterará automaticamente se depois você mudar o tipo de declaração.
Por padrão, os novos arquivos Kotlin são salvos em src/main/java/. Pode ser mais fácil ver os
arquivos Kotlin e Java em um único local. Mas se você preferir separar os arquivos Kotlin dos
arquivos Java, pode colocar os Kotlin em src/main/kotlin/. Nesse caso, será necessário incluir esse
diretório na configuração sourceSets:
android {
sourceSets {
[Link] += ’src/main/kotlin’
}
}

Converter código Java existente em código Kotlin

Abra um arquivo Java e selecione Code > Convert Java File to Kotlin File.
76 Capítulo 4. Ferramentas de Desenvolvimento para Android

Ou crie um novo arquivo Kotlin (File > New > Kotlin File/Class) e cole o código Java nesse
arquivo. Quando solicitado, clique em Yes para converter o código em Kotlin. Você pode marcar
Don’t show this dialog next time, o que facilitará o despejo de snippets de código Java nos
arquivos Kotlin.

Para ver mais informações sobre o uso de código Kotlin e Java no seu projeto, leia sobre a
interoperabilidade do Kotlin com a linguagem Java (link em inglês).
Criar uma biblioteca Android
Estruturalmente, uma biblioteca Android é igual a um módulo de app para Android. Ela pode
conter tudo o que é necessário para criar um app, inclusive código-fonte, arquivos de recursos e
um manifesto do Android. No entanto, em vez de ser compilada em um APK para execução em
um dispositivo, uma biblioteca Android é compilada em um arquivo Archive do Android (AAR),
que pode ser usado como dependência de um módulo de app para Android. Diferentemente dos
arquivos JAR, os arquivos AAR podem conter recursos Android e um arquivo de manifesto, o que
permite empacotar recursos compartilhados como layouts e drawables, além de classes e métodos
Java.
Um módulo de biblioteca é útil nas seguintes situações:
• Ao compilar vários apps que usam alguns componentes em comum, como atividades, serviços
ou layouts de IU.
• Ao compilar um app que existe em várias variações de APK, como uma versão gratuita e
paga, e os mesmos componentes essenciais são necessários nas duas versões.
Nos dois casos, basta mover os arquivos que você quer reutilizar para um módulo de biblioteca
e adicioná-la como dependência para cada módulo de app. Esta página ensina a proceder nas duas
situações.
Criar um módulo de biblioteca
Para criar um novo módulo de biblioteca no projeto, faça o seguinte:
1. Clique em File > New > New Module.
2. Na janela Create New Module exibida, clique em Android Library e em Next.
Existe também uma opção para criar uma biblioteca Java, que cria um arquivo JAR tradicional.
Embora um arquivo JAR seja útil para muitos projetos e principalmente quando é necessário
compartilhar código com outras plataformas, esse tipo de arquivo não permite a inclusão de
recursos Android nem arquivos de manifesto, o que é muito útil para reutilização de código em
projetos Android. Portanto, este guia se concentra na criação de bibliotecas Android.
3. Atribua um nome à biblioteca, selecione uma versão mínima de SDK para o código na
biblioteca e clique em Finish.
Após a conclusão da sincronização do projeto Gradle, o módulo de biblioteca será exibido no
painel Project à esquerda. Se a pasta do novo módulo não for exibida, verifique se a janela está
mostrando a visualização Android.
Converter um módulo de aplicativo em um módulo de biblioteca
Se você tiver um módulo de app com todo o código que quer reutilizar, poderá transformá-lo
em um módulo de biblioteca da seguinte forma:
1. Abra o arquivo de nível de módulo [Link].
2. Exclua a linha do applicationId. Apenas um módulo de app para Android pode definir isso.
3. Na parte superior do arquivo, você verá o seguinte:
4.2 Gerenciar Seu Projeto 77

apply plugin: ’[Link]’

Altere para o seguinte:

apply plugin: ’[Link]’

4. Salve o arquivo e clique em File > Sync Project with Gradle Files.
É isso. A estrutura inteira do módulo se mantém, mas ele passa a operar como uma biblioteca
Android e a compilação criará um arquivo AAR em vez de APK.
Quando quiser compilar um arquivo AAR, selecione o módulo da biblioteca na janela Project
e clique em Build > Build APK.
Adicionar uma biblioteca como dependência
Para usar o código de uma biblioteca Android em outro módulo de app, faça o seguinte:
1. Adicione a biblioteca ao projeto de uma das maneiras a seguir. Se você criou o módulo da
biblioteca no mesmo projeto, ela já estará lá :
• Adicione o arquivo AAR (ou JAR) compilado. A biblioteca precisa estar pronta:
1. Clique em File > New > New Module.
2. Clique em Import .JAR/.AAR Package e em Next.
3. Insira a localização do arquivo AAR ou JAR e clique em Finish.
• Importe o módulo de biblioteca para o projeto. A fonte da biblioteca passa a fazer parte
do projeto:
1. Clique em File > New > Import Module.
2. Insira a localização do diretório do módulo de biblioteca e clique em Finish.
O módulo de biblioteca é copiado para o projeto, portanto, você pode até editar o código da
biblioteca. Se você quiser manter uma única versão do código da biblioteca, provavelmente não é o
que você quer. Em vez disso, adicione o arquivo AAR compilado como descrito acima.
2. Verifique se a biblioteca é a primeira do arquivo [Link], como mostrado abaixo para
uma biblioteca denominada "my-library-module":
include ’:app’, ’:my-library-module’

Abra o arquivo [Link] do módulo do app e adicione uma nova linha ao bloco dependencies,
conforme mostrado no snippet a seguir:
dependencies {
implementation project(":my-library-module")
}

4. Clique em Sync Project with Gradle Files.

No exemplo acima, a configuração implementation adiciona a biblioteca chamada my-library-
module como uma dependência de versão para todo o módulo do app. Se você quiser a biblioteca
apenas para uma determinada variante de compilação, use buildVariantNameImplementation em
vez de implementation. Por exemplo, se você quiser incluir a biblioteca apenas na versão "pro"do
seu produto, o código será assim:
productFlavors {
pro { ... }
}
dependencies {
proImplementation project(":my-library-module")
}
78 Capítulo 4. Ferramentas de Desenvolvimento para Android

Todo o código e todos os recursos da biblioteca Android passam a estar disponíveis para o
módulo do app, e o arquivo AAR da biblioteca é empacotado com o APK durante a compilação.
No entanto, se quiser compartilhar separadamente o arquivo AAR, você poderá encontrá-lo
em project-name/module-name/build/outputs/aar/ e gerá-lo novamente clicando em Build > Make
Project.
Observação: para saber mais sobre gerenciamento de dependências, leia Usar gerenciamento
de dependências com reconhecimento de variantes.
Escolher os recursos que serão públicos
Por padrão, todos os recursos de uma biblioteca são públicos. Para tornar todos os recursos
implicitamente privados, é necessário definir pelo menos um atributo específico como público. Os
recursos incluem todos os arquivos do diretório res/ do projeto, como imagens. Para evitar que
os usuários da biblioteca acessem recursos destinados exclusivamente para uso interno, use esse
mecanismo automático de designação de privacidade declarando um ou mais recursos públicos.
Como alternativa, faça com que todos os recursos sejam privados adicionando uma tag <public />
vazia, que não marca nada como público e torna todos os recursos privados.
Para declarar um recurso público, adicione uma declaração <public> ao arquivo [Link] da
biblioteca. Se você não tiver adicionado recursos públicos antes, será necessário criar o arquivo
[Link] no diretório res/values/ da biblioteca.
O código de exemplo a seguir cria dois recursos públicos de string com os nomes my-
lib_app_name e mylib_public_string:
<resources>
<public name="mylib_app_name"type="string"/>
<public name="mylib_public_string"type="string"/>
</resources>

Torne públicos todos os recursos que você quer que fiquem visíveis para os desenvolvedores
que usam a biblioteca.
Além de evitar que os usuários da biblioteca vejam sugestões de preenchimento de código dos
recursos internos da biblioteca, os atributos implicitamente privados também permitem renomear
ou remover recursos privados sem afetar os clientes da biblioteca. Os recursos privados são filtrados
no preenchimento de código, e o Lint emite um alerta quando você tenta fazer uma referência a um
recurso privado.
Ao criar uma biblioteca, o Plug-in do Android para Gradle extrai as definições de recursos
públicos para o arquivo [Link], que, depois disso, é empacotado dentro do arquivo AAR.
Considerações de desenvolvimento de módulos de biblioteca
Esteja ciente dos comportamentos e limitações abaixo ao desenvolver módulos de biblioteca e
apps dependentes.
Depois de adicionar referências a módulos de biblioteca ao módulo do app Android, você pode
definir a prioridade relativa. Durante a compilação, as bibliotecas são mescladas com o app, uma
de cada vez, começando pela biblioteca de menor prioridade até a de maior prioridade.
• Conflitos de mesclagem de recursos
As ferramentas de compilação mesclam recursos de um módulo de biblioteca com os de um
módulo de app dependente. Se um determinado código de recurso for definido nos dois módulos, o
recurso do app será usado.
Se ocorrerem conflitos entre várias bibliotecas AAR, será usado o recurso da biblioteca listada
primeiro na lista de dependências (perto da parte superior do bloco dependencies).
Para evitar conflitos de recursos para IDs de recursos comuns, considere usar um prefixo ou
outro esquema de nomenclatura consistente exclusivo para o módulo, ou exclusivo em todos os
módulos do projeto.
4.2 Gerenciar Seu Projeto 79

• Em versões multimódulo, as dependências JAR são tratadas como dependências tran-

sitivas
Quando você adiciona uma dependência JAR a um projeto de biblioteca que gera um AAR, o
JAR é processado pelo módulo da biblioteca e empacotado com o AAR correspondente.
No entanto, se seu projeto incluir um módulo de biblioteca consumado por um módulo de app,
o módulo de app tratará a dependência JAR local de biblioteca como uma dependência transitiva.
Nesse caso, o JAR local será processado pelo app do módulo que consumi-lo e não pelo módulo da
biblioteca. Isso é feito para agilizar as compilações incrementais que são causadas por alterações
no código do módulo da biblioteca.
Qualquer conflito de recursos Java causado por dependências JAR locais precisa ser resolvido
no módulo do app que consome a biblioteca.
• Um módulo de biblioteca pode depender de uma biblioteca JAR externa
É possível desenvolver um módulo de biblioteca que depende de uma biblioteca externa Por
exemplo, a biblioteca externa do Maps. Nesse caso, o app dependente precisa ser criado em um
destino que inclua a biblioteca externa (por exemplo, o complemento Google APIs). Observe
também que o módulo de biblioteca e o app dependente precisam declarar a biblioteca externa em
um elemento <uses-library> dos arquivos de manifesto deles.
• O atributo minSdkVersion do módulo do app precisa ser igual ou maior que a versão
definida pela biblioteca
Uma biblioteca é compilada como parte do módulo do app dependente, portanto, as APIs
usadas no módulo da biblioteca precisam ser compatíveis com a versão de plataforma compatível
com o módulo do app.
• Cada módulo de biblioteca cria a própria classe R
Ao criar os módulos de apps dependentes, os módulos de biblioteca são compilados em um
arquivo AAR, que é adicionado ao módulo do app. Portanto, cada biblioteca tem a própria classe R,
nomeada de acordo com o nome do pacote da biblioteca. A classe R gerada a partir do módulo
principal e do módulo de biblioteca é criada em todos os pacotes necessários, incluindo o pacote do
módulo principal e os pacotes das bibliotecas.
• Um módulo de biblioteca pode incluir um arquivo de configuração do ProGuard pró-
prio
Se você tiver um projeto de biblioteca usado para compilar e publicar um AAR, você poderá
adicionar um arquivo de configuração do ProGuard à configuração de compilação da biblioteca
e o plug-in Android Gradle aplicará as regras do ProGuard especificadas. As ferramentas de
criação incorporam esse arquivo no arquivo AAR gerado para o módulo de biblioteca. Ao adicionar
a biblioteca a um módulo de app, o arquivo ProGuard da biblioteca é anexado ao arquivo de
configuração do ProGuard ([Link]) do módulo do app.
A incorporação de um arquivo ProGuard no módulo de biblioteca garante que os módulos
de apps que dependem da biblioteca não precisem atualizar manualmente os próprios arquivos
ProGuard para usar a biblioteca. Quando o sistema de compilação do Android Studio cria o app, ele
usa as diretivas do módulo do app e da biblioteca. Portanto, não é necessário executar um redutor
de código na biblioteca em uma etapa separada.
Para adicionar as regras do ProGuard ao seu projeto de biblioteca, especifique o nome do
arquivo com a propriedade consumerProguardFiles dentro do bloco defaultConfig do arquivo
[Link] da biblioteca. Por exemplo, o snippet a seguir define [Link] como o
arquivo de configuração ProGuard da biblioteca:
android {
defaultConfig {
consumerProguardFiles ’[Link]’
}
80 Capítulo 4. Ferramentas de Desenvolvimento para Android

...
}

• No entanto, se o módulo da sua biblioteca faz parte de uma versão multimódulo compilada
em um APK e não gera um arquivo AAR, execute a redução de código apenas no módulo de
app que consome a biblioteca. Para saber mais sobre as regras do ProGuard e o uso delas,
leia Reduzir, ofuscar e otimizar o aplicativo.
• Testar um módulo de biblioteca é o mesmo que testar um app
A principal diferença é que a biblioteca e as dependências dela são incluídas automaticamente
como dependências do APK de teste. Isso quer dizer que o APK de teste não inclui apenas o próprio
código, mas também o AAR da biblioteca e todas as dependências correspondentes. Como não há
um "app em teste"separado, a tarefa androidTest instala (e desinstala) apenas o APK de teste.
Ao mesclar vários arquivos de manifesto, o Gradle segue a ordem de prioridade padrão e mescla
o manifesto da biblioteca com o manifesto principal do APK de teste.
Anatomia de um arquivo AAR
A extensão de arquivo de um arquivo AAR é .aar, e o tipo de artefato Maven também precisa
ser aar. O arquivo em si é um arquivo zip contendo estas entradas obrigatórias:
• /[Link]
• /[Link]
• /res/
• /[Link]
• /[Link]
Além disso, um arquivo AAR pode incluir uma ou mais destas entradas opcionais:
• /assets/
• /libs/[Link]
• /jni/abi_name/[Link], em que abi_name é uma das ABIs compatíveis com o Android
• /[Link]
• /[Link]
• /[Link]
Definir integração contínua
Os sistemas de integração contínua permitem que você desenvolva e teste seu app automatica-
mente toda vez que as atualizações para o sistema de controle de origem. Você pode usar qualquer
ferramenta de integração contínua que possa iniciar uma compilação do Gradle para compilar seus
projetos do Android Studio.
Para executar os testes como parte da compilação é preciso configurar seu servidor de integração
contínua para usar o Android Emulator ou usar o Firebase Test Lab para executar seus testes.
Para informações específicas sobre como configurar a integração contínua do seu projeto
Android com o Jenkins e o Firebase Test Lab, consulte Como usar o Firebase Test Lab para o
Android com sistemas de integração contínua.
Observação: use o SDK Manager para aceitar os contratos de licença para qualquer pacote
que seu app exigir em cada máquina em que você compilar seu app. Se você não tiver instalado
o Android Studio no seu servidor de integração contínua, exporte manualmente os contratos de
licença para o servidor de compilação a partir de uma máquina em que eles foram aceitos com
o SDK Manager antes de compilar seu app no servidor. Para saber mais sobre o processo de
exportação de licença, leia Fazer o download automático de pacotes ausentes com o Gradle.
 4.3 Programar o app 81

4.3 Programar o app

4.3.1 Visão Geral
O Android Studio inclui ferramentas para cada fase do desenvolvimento, mas, o mais importante é
simplesmente programar o app: escrever o código, compilar layouts, criar imagens e ser produtivo
durante todo o processo.
Este é o assunto desta seção: as ferramentas que ajudam a você a programar rapidamente um
app.
Produtividade da programação
Veja a seguir alguns recursos que ajudam a aumentar a produtividade durante a programação.
Preencher código automaticamente
O preenchimento de código acelera o desenvolvimento do app, reduzindo os erros de digitação
e a necessidade de procurar nomes de classes, métodos e variações. O editor de código oferece os
preenchimentos básico, inteligente e de frase.
Saiba mais sobre o preenchimento de código.
Criar modelos personalizados de preenchimento de código
Os modelos dinâmicos permitem inserir snippets de código para preencher rapidamente peque-
nos fragmentos de código. Para inserir um modelo dinâmico, digite a abreviação dele e pressione a
tecla Tab. O Android Studio insere o snippet associado ao modelo no código.
Por exemplo: a abreviação newInstance seguida por Tab insere o código de uma nova instância
de fragmento com marcadores de argumentos. Ou digite fbc para inserir o método findViewById()
juntamente da sintaxe de cast e de ID de recurso.
Para ver a lista de modelos dinâmicos compatíveis e personalizá-los, clique em File > Settings
> Editor > Live Templates.
Saiba mais sobre Modelos dinâmicos (link em inglês).
Realizar correções rápidas com o lint
O Android Studio oferece uma ferramenta de verificação de código denominada lint, que ajuda
a identificar e corrigir problemas com a qualidade estrutural do código, sem executar o app nem
programar testes.
Sempre que o app é compilado, o Android Studio executa o lint para verificar se os arquivos
de origem contêm possíveis bugs e identificar melhorias de otimização em relação a critérios de
precisão, segurança, desempenho, usabilidade, acessibilidade e internacionalização.
Saiba mais sobre o lint.
Ver a documentação e os detalhes de recursos
Para ver a documentação de uma API, coloque o cursor no nome do método/membro/classe e
aperte F1.
Há também informações disponíveis para outros recursos, como imagens e temas. Por exemplo,
se você colocar o cursor no nome do tema no arquivo de manifesto do Android e pressionar F1,
poderá ver a hierarquia de herança do tema e cores ou imagens dos diversos atributos.
Criar novos arquivos rapidamente
Para criar um novo arquivo, clique no diretório que você quer usar na janela "Project"e pressione
Alt + Insert (no Mac, + N). O Android Studio mostra uma pequena janela com uma lista de tipos
de arquivos sugeridos adequados para o diretório selecionado.
Trabalhar com recursos
O Android Studio contém os seguintes recursos e ferramentas que ajudam a criar e gerenciar
arquivos de recursos.
Saiba mais sobre como adicionar recursos.
Criar imagens para todas as densidades de tela
O Android Studio inclui uma ferramenta denominada Vector Asset Studio, que ajuda a criar
imagens compatíveis com cada densidade de tela. Você pode fazer upload do próprio arquivo SVG
82 Capítulo 4. Ferramentas de Desenvolvimento para Android

para edição ou selecionar um dos diversos ícones do Material Design oferecidos pelo Google. Para
começar, clique em File > New > Vector Asset.
Saiba mais sobre o Vector Asset Studio.
Visualizar imagens e cores
Quando você referencia imagens e ícones no código, uma visualização da imagem é exibida na
margem esquerda para ajudar a verificar a referência de imagem ou ícone.
Para ver a imagem no tamanho original, clique na miniatura na margem esquerda. Ou posicione
o cursor na referência em linha para o ativo e pressione F1 para ver os detalhes da imagem, inclusive
todos os tamanhos alternativos.
Criar novos layouts
O Android Studio oferece um editor de layouts avançado que permite arrastar e soltar widgets
no layout e visualizá-lo durante a edição do XML.
Para começar, clique no módulo a que você quer adicionar o layout e depois em File > New >
XML > Layout XML File.
Saiba mais sobre o Layout Editor.
Traduzir strings de IU
A ferramenta Translations Editor oferece uma visualização única de todos os recursos traduzidos,
facilitando a alteração ou adição de traduções e a localização de traduções ausentes, sem precisar
abrir cada versão do arquivo [Link]. Você pode inclusive fazer upload do arquivo de strings
para solicitar serviços de tradução.
Para começar, clique com o botão direito em qualquer cópia do arquivo [Link] e depois em
Open Translations Editor.
Saiba mais sobre o Translations Editor.
Adicionar código de um modelo
O Android Studio oferece modelos de código que seguem as práticas recomendadas de design
e desenvolvimento do Android para que você crie apps elegantes e funcionais. Você pode usar
modelos para criar novos módulos de app, atividades individuais ou outros componentes específicos
de projetos Android.
Alguns modelos oferecem código básico para contextos de uso comuns, como gavetas de
navegação ou telas de login. Você pode escolher entre esses modelos de atividade e de módulo de
app ao criar seu projeto, adicionar um novo módulo de app a um projeto existente ou adicionar uma
nova atividade a um módulo de app.
Além das atividades, também é possível usar modelos para adicionar outros componentes
de projetos Android a um app existente. Esses modelos incluem componentes de código, como
serviços e fragmentos, e componentes que não são de código, como pastas e arquivos XML.
Esta página discute como adicionar componentes de projetos Android, como atividades, ao seu
projeto e descreve os modelos de atividades normalmente utilizados e que estão disponíveis no
Android Studio. Observe que a maioria dos modelos depende da Android Support Library para
incluir os princípios de interface do usuário baseada no Material Design.
Adicionar um componente de projeto
4.3 Programar o app 83

Figura 15. O menu de modelos, que pode ser acessado emFile > New ou clicando com o botão
direito do mouse na janela Project.

A lista de modelos fornecida pelo Android Studio cresce constantemente. O Android Studio
agrupa modelos por tipo de componente adicionado, como uma Activity (Atividade) ou um arquivo
XML, como mostrado na Figura 15.

Para adicionar um componente de projeto Android usando um modelo, use a janela Project

. Clique com o botão direito do mouse na pasta em que quer adicionar o novo componente e
selecione New. Será exibida uma lista de tipos de modelos, como mostrado na Figura 15, baseada
nos componentes que podem ser adicionados à pasta em que você clicou.

Quando você seleciona o modelo que quer adicionar, uma janela de assistente correspondente
é exibida e solicita as informações de configuração do componente, como o nome dele. Após
a inserção das informações de configuração, o Android Studio cria e abre os arquivos do novo
componente. Ele também executa uma compilação do Gradle para sincronizar seu projeto.

Embora você também possa usar o menu File > New do Android Studio para criar um novo
componente de projeto Android, navegar até a pasta desejada na janela Project garante que você
crie o componente no local correto.

Selecionar um modelo de atividade

Um dos usos mais comuns dos modelos é a adição de novas atividades a um módulo de app
existente. Por exemplo, para criar uma tela de login para os usuários do seu app, adicione uma
atividade com o modelo Atividade de login.

Esta seção abrange os modelos de atividade usados normalmente para app de smartphone e
tablet. O Android Studio também fornece modelos para diversos tipos de módulo de app diferentes,
incluindo Wear OS, Android TV e Cloud App Engine. Você pode ver os modelos desses tipos de
módulo diferentes durante a criação de um módulo de app. Também há modelos para módulos e
atividades mais específicos de API, como Google AdMobs Ads e Google Maps.

Os modelos de smartphone e tablet a seguir oferecem os componentes de código para contextos

de uso específicos, como fazer login em uma conta, apresentar uma lista de itens com detalhes ou
rolar um bloco longo de texto. Cada um deles pode servir como um módulo de app completo ou
uma atividade individual.

Atividade básica
84 Capítulo 4. Ferramentas de Desenvolvimento para Android

Este modelo cria um app simples, com uma barra de apps e um botão de ação flutuante. Ele é
um ponto de partida para seu projeto, oferecendo os componentes de IU mais usados.
O modelo inclui:
• AppBar
• FloatingActionButton
• Dois arquivos de layout: um para a atividade e outro para separar o conteúdo de texto
Atividade de navegação inferior

Este modelo oferece uma barra de navegação inferior padrão para uma atividade, o que permite
que os usuários acessem e alternem facilmente entre visualizações de nível superior com um único
toque. Use este modelo quando o aplicativo tiver de três a cinco destinos de nível superior. Para ver
mais informações, consulte as diretrizes de design do componente de navegação inferior (link em
inglês).
O modelo inclui:
• AppBar
• Um único arquivo de layout com um exemplo de layout para a navegação inferior
Atividade vazia
4.3 Programar o app 85

Este modelo cria uma atividade vazia e um único arquivo de layout, com uma amostra de
conteúdo de texto. Ele permite começar a criar do zero a atividade ou o módulo do seu app.
O modelo inclui:
• Um único arquivo de layout com conteúdo de texto
Atividade em tela cheia

Este modelo cria um app que alterna entre uma visualização em tela cheia principal e uma
visualização com controles padrão de interface do usuário (IU). A visualização em tela cheia é o
padrão. O usuário pode ativar a visualização padrão tocando na tela do dispositivo.
O modelo inclui:
• Implementação de listener de toque para ocultar os elementos de visualização padrão
• Botão exibido na visualização padrão, mas que não faz nada
• AppBar para a visualização padrão
• Um único arquivo de layout com a visualização em tela cheia e um layout de frame para
elementos de visualização padrão
Atividade de login
86 Capítulo 4. Ferramentas de Desenvolvimento para Android

Este modelo cria uma tela de login padrão. A interface do usuário inclui campos de e-mail e
senha e um botão de login. Normalmente, o modelo é usado como modelo de atividade e não como
modelo de módulo de app.
O modelo inclui:
• Implementação de AsyncTask para processar operações de rede separadamente da linha de
execução principal da interface do usuário
• Indicador de progresso durante operações de rede
• Um único arquivo de layout com a IU de login recomendada:
– Campos de entrada de e-mail e senha
– Botão de login
Fluxo mestre/detalhe

Este modelo cria um app que é uma exibição de lista de itens e uma exibição dos detalhes de
um item individual. Um clique em um item na tela da lista abre uma tela com os detalhes do item.
O layout das duas exibições depende do dispositivo que executa o app.
O modelo inclui:
• A atividade representando a lista de itens
• Opções de atividade e fragmento para exibir os detalhes de um item individual
• FloatingActionButton em cada tela
• Barra de ferramentas recolhível para a tela de detalhes de item
• Arquivos de layout de recurso alternativo para configurações de dispositivos diferentes
Atividade da gaveta de navegação
4.3 Programar o app 87

Este modelo cria uma Atividade básica com um menu de gaveta de navegação. A barra de
navegação se expande do lado esquerdo ou direito do app e é exibida juntamente à barra normal do
app.
O modelo inclui:
• Implementação da gaveta de navegação com um DrawerLayout, processadores de eventos
correspondentes e opções de menu de exemplo
• AppBar
• FloatingActionButton
• Arquivos de layout e o cabeçalho da gaveta de navegação, além dos do modelo de Atividade
básica
Atividade de rolagem

Este modelo cria um app com uma barra de ferramentas recolhível e uma visualização com ro-
lagem para conteúdo de texto longo. Conforme a página é rolada para baixo, a barra de ferramentas,
que pode servir como cabeçalho, fecha automaticamente, e o botão de ação flutuante desaparece.
O modelo inclui:
• Barra de ferramentas recolhível no lugar do AppBar normal
• FloatingActionButton
• Dois arquivos de layout: um para a atividade e um para separar o conteúdo do texto em um
NestedScrollView
Atividade de configurações
88 Capítulo 4. Ferramentas de Desenvolvimento para Android

Este modelo cria uma atividade que exibe preferências ou configurações do usuário para um app.
Ele amplia a classe PreferenceActivity e é mais comumente usado como um modelo de atividade
do que como um modelo de módulo de app.
O modelo inclui:
• Atividade que amplia PreferenceActivity
• Arquivos XML (no diretório res/xml/ do seu projeto) para definir as configurações exibidas
Atividade em guias

Este modelo cria um app com várias seções, navegação por deslizamento e uma barra de app.
As seções são definidas como fragmentos entre os quais você pode deslizar para a esquerda ou
direita para navegar.
O modelo inclui:
• AppBar
• Adaptador que amplia o FragmentPagerAdapter e cria um fragmento para cada seção
• Instância de ViewPager, um gerenciador de layout para deslizamento entre seções
• Dois arquivos de layout: um para a atividade e um para fragmentos individuais
Encontrar exemplos de código
O Android Studio oferece uma seleção de amostras e modelos de código para você usar para
4.3 Programar o app 89

acelerar o desenvolvimento de aplicativos. Procure códigos de exemplo para aprender a criar

diferentes componentes para seus aplicativos. Use modelos para criar novos módulos de aplicativos,
atividades individuais ou outros componentes específicos de projetos Android.
Esta página descreve como acessar e usar amostras de código Android de alta qualidade
oferecidos pelo Google. Para mais informações sobre modelos, consulte Adicionar código de um
modelo.
Na caixa de diálogo Browse Samples
Você pode usar o navegador de amostras para selecionar, visualizar e importar uma ou mais
amostras de aplicativos como projetos. Você também pode navegar pelo código-fonte no GitHub.
1. Selecione File > New > Import Sample.
2. Use a caixa de pesquisa ou a barra de rolagem para navegar pelas amostras.
3. Quando você encontrar uma amostra do seu interesse, destaque-a e visualize-a.
4. Se você quiser importá-la como um projeto, clique em Next e em Finish.

Figura 16. Caixa de diálogo Browse Samples com amostra destacada na coluna da esquerda e
visualizada na coluna da direita.
In-line do editor
O Code Sample Browser do Android Studio ajuda a encontrar amostras de código Android com
base no símbolo em destaque no momento no seu projeto.
1. No código, destaque uma variável, tipo ou método.
90 Capítulo 4. Ferramentas de Desenvolvimento para Android

2. Clique com o botão direito do mouse para exibir o menu de contexto.

3. No menu de contexto, selecione Find Sample Code.
Os resultados da pesquisa aparecem em uma janela de ferramentas, como mostrado na Figura
17.
4. No painel esquerdo da janela das ferramentas, selecione uma amostra.
5. Em seguida, role pelo painel da direita para encontrar as linhas de código destacadas que são
usadas na amostra selecionada.

Figura 17. O Code Sample Browser.

Adicionar módulo para um dispositivo novo
Os módulos oferecem um contêiner para o código-fonte do app, arquivos de recursos e confi-
gurações do app, como o arquivo de compilação do módulo e o arquivo de manifesto do Android.
Cada módulo pode ser individualmente compilado, testado e depurado.
O Android Studio usa módulos para facilitar a adição de novos dispositivos ao projeto. Seguindo
algumas etapas simples no Android Studio, você pode criar um módulo para conter um código
específico a um tipo de dispositivo, como Wear OS ou Android TV. O Android Studio cria
automaticamente os diretórios de módulos, como diretórios de origem e de recursos, e um arquivo
[Link] padrão apropriado para o tipo de dispositivo. Além disso, o Android Studio cria
módulos de dispositivos com as configurações recomendadas de compilação, como o uso da
biblioteca Leanback para módulos da Android TV.
Esta página descreve como adicionar um novo módulo para um dispositivo específico.
O Android Studio também facilita a adição de uma biblioteca ou módulo do Google Cloud ao
projeto. Para saber detalhes sobre como criar um módulo de biblioteca, acesse Criar um módulo de
biblioteca.
Criar um novo módulo
Para adicionar um novo módulo no projeto para um novo dispositivo, faça o seguinte:
1. Clique em File > New > New Module.
2. Na janela Create New Module exibida, o Android Studio oferece os seguintes módulos de
dispositivos:
• Módulo de smartphone e tablet
• Módulo de Wear OS
• Módulo de Android TV
• Módulo de Glass
Selecione o módulo para o dispositivo que você quer usar e clique em Next.
3. No formulário Configure your new module, insira os seguintes detalhes:
• Application Name: esse nome é usado como o título do ícone na tela de início do app
para o novo módulo.
• Module Name: esse texto é usado como o nome da pasta em que os arquivos de
4.3 Programar o app 91

código-fonte e de recursos são visíveis.

• Package Name: é o namespace Java para o código no seu módulo. Ele é adicionado
como o atributo package no arquivo de manifesto do Android do módulo.
• Minimum SDK: essa configuração indica a versão mínima da plataforma Android que
é compatível com o módulo do app. Esse valor define o atributo minSdkVersion no
arquivo [Link], que pode ser editado posteriormente.
Em seguida, clique em Next.
4. Dependendo do módulo de dispositivo selecionado, a página a seguir exibe uma seleção dos
modelos de código adequados que você pode escolher para usar como atividade principal.
Clique em um modelo de atividade com que você quer iniciar e depois em Next. Se você
não precisa de uma atividade, clique em Add No Activity e em Finish para concluir.
5. Se você escolher um modelo de atividade, insira as configurações dela na página Customize
the Activity. A maioria dos modelos precisa de um Activity Name, Layout Name, Title e
Source Language, mas cada modelo tem configurações específicas de atividade. Clique em
Finish. Quando você cria um módulo de app com um modelo de atividade, pode executar e
testar imediatamente o módulo no dispositivo.
O Android Studio cria todos os arquivos necessários para o novo módulo e sincroniza o projeto
com os arquivos do Gradle do novo módulo. A adição de um módulo a um novo dispositivo também
adiciona todas as dependências necessárias para o dispositivo de destino ao arquivo de compilação
do módulo.
Quando a sincronização do projeto do Gradle for concluída, o novo módulo será exibido na
janela Project à esquerda. Caso você não veja a pasta do novo módulo, verifique se a janela está
exibindo a visualização Android.
Importar um módulo
Para importar um módulo existente para o projeto, faça o seguinte:
1. Clique em File > New > Import Module.
2. Na caixa Source directory, digite ou selecione o diretório dos módulos que você quer
importar:
• Se você está importando um módulo, indique o diretório raiz.
• Se você está importando vários módulos de um projeto, indique a pasta do projeto.
Para cada módulo dentro da pasta, uma caixa é exibida, indicando Source location e
Module name. Verifique se a caixa Import está marcada para cada módulo que você
quer importar.
Se os módulos tiverem outras dependências, elas estarão listadas para importação em Additio-
nal required modules.
3. Digite os nomes dos módulos a serem usados nos campos Module name.
4. Clique em Finish.
Depois da importação do módulo, ele é exibido na janela Project, à esquerda.
Próximas etapas
Depois de adicionar um novo módulo, você pode modificar o código e os recursos dele, definir
as configurações de compilação e compilá-lo. Também é possível executar e depurar o módulo
como qualquer outro app.
• Para saber mais sobre as configurações de compilação de um módulo, consulte Arquivo de
compilação de nível de módulo.
• Para compilar e executar um módulo específico, consulte Selecionar e compilar um módulo
diferente.
Você também pode adicionar código e recursos para oferecer compatibilidade com o novo
dispositivo. Para ver mais informações sobre como desenvolver módulos de app para tipos de
dispositivo diferentes, consulte a documentação correspondente:
92 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Para módulos do Wear OS: Criar e executar um app para wearables

• Para módulos da Android TV: Introdução a apps para TV
• Para módulos do Glass: Início rápido do GDK

À medida que você desenvolve um novo módulo, pode criar um código independente de
dispositivo que já está duplicado em um módulo de app diferente. Em vez de manter o código
duplicado, mova o código compartilhado para um módulo de biblioteca e adicione essa biblioteca
como uma dependência aos módulos de app. Para ver mais informações sobre como criar um
módulo de biblioteca adicioná-lo como dependência, consulte Criar uma biblioteca Android.

Criar um tipo ou classe Java

Com a caixa de diálogo Create New Class e os modelos de arquivo correspondentes, o Android
Studio ajuda a criar rapidamente os novos tipos e classes a seguir:

• Classes Java
• Classes de enumeração e singleton
• Tipos de interface e anotação

Depois que você preencher os campos da caixa de diálogo Create New Class e clicar em OK,
o Android Studio criará um arquivo .java contendo o código do esqueleto, incluindo uma declaração
package, todas as importações necessárias, um cabeçalho e uma declaração de classe ou tipo. Em
seguida, você pode adicionar seu código a esse arquivo.

Modelos de arquivo especificam como o Android Studio gera o código do esqueleto. Você pode
usar os modelos de arquivo fornecidos com o Android Studio como estão ou personalizá-los para
adequar ao seu processo de desenvolvimento.

Ver e personalizar modelos de arquivo

O Android Studio oferece modelos de arquivo que determinam como novas classes e tipos Java
são criados com a caixa de diálogo Create New Class. Você pode personalizar esses modelos.
4.3 Programar o app 93

Figura 18. A caixa de diálogo Create New Class.

Os modelos de arquivo do Android Studio incluem o código Velocity Template Language
(VTL) e variáveis que lidam com essas opções adicionais. A caixa de diálogo Create New Class
usa os modelos de arquivo AnnotationType, Class, Enum, Interface e Singleton.
Para ver e modificar os modelos, bem como para localizar personalizações, siga estas etapas:
1. Realize uma das seguintes ações:
• Para Windows ou Linux, selecione File > Settings > Editor > File and Code Templa-
tes > Files.
• Para macOS, selecione Android Studio > Preferences > Editor > File and Code
Templates > Files.
Na lista de modelos, os nomes dos modelos internos estão em negrito. Os nomes de modelos
personalizados são exibidos com uma cor de destaque, como azul.
2. Personalize os modelos de arquivo conforme necessário.
Se você quiser usar os campos da caixa de diálogo Create New Class, verifique se as alterações
estão de acordo com o código do modelo de arquivo do Android Studio.
Para mais informações sobre modelos de arquivo, incluindo VTL, consulte Modelos de arquivo
e código e Caixa de diálogo File and Code Templates (links em inglês).
Criar uma classe ou um tipo Java
O Android Studio ajuda a criar novas classes Java, classes de enumeração e singleton e tipos de
interface e anotação baseados em modelos de arquivo.
94 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para criar uma nova classe ou tipo Java, siga estas etapas:
1. Na janela Project, clique com o botão direito do mouse em um arquivo ou pasta Java e
selecione New > Java Class.
Como alternativa, selecione um arquivo ou pasta Java na janela Project ou clique em um
arquivo Java no Code Editor. Em seguida, selecione File > New > Java Class.
O item selecionado determina o pacote padrão para a nova classe ou tipo.
2. Na caixa de diálogo Create New Class, preencha os campos:
• Name: o nome da nova classe ou tipo. Ele precisa obedecer aos requisitos de nome
Java. Não digite uma extensão de nome de arquivo.
• Kind: selecione a categoria da classe ou do tipo.
• Superclass: a classe da qual a nova classe herda. Você pode digitar o nome do pacote
e da classe ou apenas da classe e, em seguida, clicar duas vezes em um item da lista
suspensa para preenchê-lo automaticamente.
• Interface(s): uma ou mais interfaces que a nova classe ou tipo implementa. As
interfaces devem ser separadas por uma vírgula seguida por um espaço opcional. Você
pode digitar o nome do pacote e da interface ou apenas da interface e, em seguida,
clicar duas vezes em um item da lista suspensa para preenchê-lo automaticamente.
O preenchimento automático funciona apenas para o nome da primeira interface. Observe que,
embora a vírgula e o nome da interface a seguir possam gerar um erro de dica, você pode ignorá-lo
porque ele não afeta o código gerado.
• Package: o pacote em que a classe ou o tipo residirá. O padrão aparecerá automaticamente
no campo. Se você digitar um nome de pacote no campo, as partes do identificador de pacote
que não existirem serão destacadas em vermelho. Nesse caso, o Android Studio cria o pacote
depois que você clica em OK. Esse campo precisa conter um valor. Caso contrário, o arquivo
Java não conterá uma declaração package, e a classe ou o tipo não será colocado em um
pacote no projeto.
O padrão depende de como você iniciar a caixa de diálogo Create New Class. Se você selecio-
nar um arquivo ou pasta Java na janela Project, o padrão será o pacote para o item selecionado. Se
você clicar em um arquivo Java no Code Editor, o padrão será o pacote que contém esse arquivo.
• Visibility: selecione se a classe ou o tipo ficará visível para todas as classes ou apenas para
aquelas no próprio pacote.
• Modifiers: selecione o modificador Abstract ou Final para uma Class ou nenhum.
• Show Select Overrides Dialog: para um Kind de Class, marque essa opção para abrir a
caixa de diálogo Select Methods to Override/Implement após clicar em OK. Nessa caixa
de diálogo, você pode selecionar métodos que quer substituir ou implementar, e o Android
Studio gerará um código de esqueleto para esses métodos.
Todos os campos que não se aplicam ao Kind ficam ocultos.
3. Clique em OK.
O Android Studio cria um arquivo Java com código de esqueleto que você pode modificar. Ele
abre o arquivo no Code Editor.
Observação: você pode criar uma classe singleton selecionando File > New > Singleton ou
File > New > Java Class. A última técnica oferece mais opções.
Modelos de arquivos do Android Studio
Esta seção lista o código do modelo de arquivo do Android Studio escrito na linguagem de script
VTL, seguido pelas definições das variáveis. Os valores fornecidos na caixa de diálogo Create
New Class tornam-se os valores das variáveis do modelo. Observe que as linhas que começam
com #if (${VISIBILITY} se estendem até a chave aberta ({).
Modelo de arquivo AnnotationType
#if (${PACKAGE_NAME} != )package ${PACKAGE_NAME};#end
4.3 Programar o app 95

#if (${IMPORT_BLOCK} != )${IMPORT_BLOCK}

#end
#parse("File [Link]")
#if (${VISIBILITY} == "PUBLIC")public #end @interface ${NAME} #if (${INTERFACES}
!= )extends ${INTERFACES} #end {
}
Modelo de arquivo Class
#if (${PACKAGE_NAME} != )package ${PACKAGE_NAME};#end
#if (${IMPORT_BLOCK} != )${IMPORT_BLOCK}
#end
#parse("File [Link]")
#if (${VISIBILITY} == "PUBLIC")public #end #if (${ABSTRACT} == "TRUE")abstract
#end #if (${FINAL} == "TRUE")final #end class ${NAME} #if (${SUPERCLASS} != )extends
${SUPERCLASS} #end #if (${INTERFACES} != )implements ${INTERFACES} #end {
}
Modelo de arquivo Enum
#if (${PACKAGE_NAME} != )package ${PACKAGE_NAME};#end
#if (${IMPORT_BLOCK} != )${IMPORT_BLOCK}
#end
#parse("File [Link]")
#if (${VISIBILITY} == "PUBLIC")public #end enum ${NAME} #if (${INTERFACES} !=
)implements ${INTERFACES} #end {
}
Modelo de arquivo Interface
#if (${PACKAGE_NAME} != )package ${PACKAGE_NAME};#end
#if (${IMPORT_BLOCK} != )${IMPORT_BLOCK}
#end
#parse("File [Link]")
#if (${VISIBILITY} == "PUBLIC")public #end enum ${NAME} #if (${INTERFACES} !=
)implements ${INTERFACES} #end {
#end {
}
Modelo de arquivo Singleton
#if (${PACKAGE_NAME} != )package ${PACKAGE_NAME};#end
#if (${IMPORT_BLOCK} != )${IMPORT_BLOCK}
#end
#parse("File [Link]")
#if (${VISIBILITY} == "PUBLIC")public #end class ${NAME} #if (${SUPERCLASS} !=
)extends ${SUPERCLASS} #end #if (${INTERFACES} != )implements ${INTERFACES} #end {
private static final ${NAME} ourInstance = new ${NAME}();
#if (${VISIBILITY} == "PUBLIC")public #end static ${NAME} getInstance() {
return ourInstance;
}
private ${NAME}() {
}
}
Variáveis de modelo de arquivo
96 Capítulo 4. Ferramentas de Desenvolvimento para Android

O Android Studio substitui as variáveis do modelo de arquivo pelos valores do arquivo Java
gerado. Você pode inserir os valores na caixa de diálogo Create New Class. O modelo tem as
seguintes variáveis que você pode usar:
• IMPORT_BLOCK: uma lista delimitada por nova linha de declarações import Java necessá-
rias para oferecer compatibilidade com qualquer superclasse ou interfaces, ou uma string vazia
(). Por exemplo, se você implementar apenas a interface Runnable e não estender nada, essa
variável será "import [Link];\n". Se você implementar a interface Runnable e es-
tender a classe Activity, ela será "import [Link];\[Link];\n".
• VISIBILITY: se a classe terá acesso público ou não. Pode ter o valor PUBLIC ou PAC-
KAGE_PRIVATE.
• SUPERCLASS: um nome de classe único ou vazio. Se presente, haverá uma cláusula extends
${SUPERCLASS} após o novo nome de classe.
• INTERFACES: uma lista de interfaces separadas por vírgulas ou vazia. Se presente, haverá
uma cláusula implements ${INTERFACES} após a superclasse ou após o nome de classe, se
não houver superclasse. Para tipos de interface e anotação, as interfaces têm a palavra-chave
extends.
• ABSTRACT: se a classe precisa ser abstrata ou não. Pode ter o valor TRUE ou FALSE.
• FINAL: se a classe precisa ser final ou não. Pode ter o valor TRUE ou FALSE.
Usar recursos da linguagem Java 8
O Android Studio 3.0 e versões mais recentes é compatível com todos os recursos da linguagem
Java 7 e com um subconjunto de recursos da linguagem Java 8, que variam de acordo com a versão
da plataforma. Esta página descreve os recursos da linguagem Java 8 que você pode usar, como
configurar seu projeto adequadamente para usá-los e possíveis problemas conhecidos. Para ter uma
visão geral, assista também o vídeo a seguir.
Observação: o uso de recursos da linguagem Java 8 é opcional no desenvolvimento de apps
para Android. Você pode manter os valores de compatibilidade de origem e destino definidos como
Java 7, mas ainda será necessário compilar usando o JDK 8.
O Android Studio é compatível com alguns recursos da linguagem Java 8 e com algumas
bibliotecas de terceiros que os utilizam. Como mostrado na Figura 1, o conjunto de ferramentas
padrão implementa os novos recursos da linguagem executando transformações de bytecode,
denominadas desugar, na saída do compilador javac. O Jack não é mais compatível, e é necessário
desativá-lo para usar a compatibilidade integrada com o Java 8 no conjunto de ferramentas padrão.

Figura 19. Compatibilidade com recursos da linguagem Java 8 usando transformações de

bytecode desugar.
4.3 Programar o app 97

Para começar a usar os recursos da linguagem Java 8 compatíveis, atualize o plug-in do Android
para a versão 3.0.0 (ou mais recente). Em seguida, para cada módulo que usa os recursos da
linguagem Java 8 (no código-fonte ou nas dependências), atualize as opções Source Compatibility
e Target Compatibility para 1.8 na caixa de diálogo Project Structure, conforme mostrado na
Figura 20 (clique em File > Project Structure).

Figura 20. Compatibilidade com recursos da linguagem Java 8 usando transformações de

bytecode desugar.
Você também pode fazer a configuração diretamente no arquivo [Link] correspondente:
android {
...
// Configure only for each module that uses Java 8
// language features (either in its source code or
// through dependencies).
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
// For Kotlin projects
kotlinOptions {
jvmTarget = "1.8"
}
}

Observação: se o Android Studio detectar que o projeto está usando o Jack, Retrolambda ou
98 Capítulo 4. Ferramentas de Desenvolvimento para Android

DexGuard (links em inglês), o ambiente de desenvolvimento integrado usará a compatibilidade

com o Java 8 oferecida por essas ferramentas. No entanto, é recomendado migrar para o conjunto
de ferramentas padrão.
Recursos e APIs compatíveis com a linguagem Java 8
O Android Studio não é compatível com todos os recursos da linguagem Java 8, mas essa
compatibilidade está sendo ampliada em versões futuras do ambiente de desenvolvimento integrado.
Dependendo da minSdkVersion usada, alguns recursos e APIs já estão disponíveis, conforme
descrito na tabela abaixo.

Recurso da linguagem Java 8 minSdkVersion compatível

Expressões lambda Todas. O Android não é compatível com a serialização de
Referências de métodos (link em inglês) Todas.
Anotações de tipo (link em inglês) Todas. No entanto, as informações de anotação de tipo estã
Métodos de interface padrão e estáticos (link em inglês) Todas.
Repetição de anotações (link em inglês) Todas.
API da linguagem Java 8 minSdkVersion compatível
[Link] API de nível 24 ou mais recente.
[Link](Class) API de nível 24 ou mais recente.
[Link] API de nível 24 ou mais recente.
[Link] API de nível 24 ou mais recente.
[Link]() API de nível 24 ou mais recente.
[Link] API de nível 24 ou mais recente.

Além dos recursos e APIs da linguagem Java 8 descritos acima, o Android Studio 3.0 e versões
mais recentes ampliam a compatibilidade com try-with-resources (link em inglês) para todos os
níveis de API do Android.
No momento, desugar não é compatível com [Link] ou [Link]
(links em inglês). Se o código-fonte ou uma das dependências do módulo usar um desses métodos,
será necessário especificar minSdkVersion 26 ou versão mais recente. Caso contrário, ocorrerá o
seguinte erro:
Dex: Error converting bytecode to dex:
Cause: signature-polymorphic method called without --min-sdk-version >= 26
Em alguns casos, pode ocorrer que o módulo não use os métodos invoke ou invokeExact, mesmo
se incluídos em uma dependência de biblioteca. Portanto, para continuar usando essa biblioteca
com minSdkVersion 25 ou versões anteriores, ative a redução de código e remova os métodos não
usados. Se isso não funcionar, use outra biblioteca que não utilize os métodos incompatíveis.
Migrar para o conjunto de ferramentas padrão
Se o Android Studio detectar que o projeto está usando Jack, Retrolambda ou DexGuard, o
ambiente de desenvolvimento integrado usará a compatibilidade com o Java 8 oferecida por essas
ferramentas. No entanto, em comparação com o conjunto de ferramentas padrão, faltam a essas
ferramentas algumas funcionalidades e compatibilidade. Portanto, siga as instruções desta seção
para migrar para o conjunto de ferramentas padrão do Android Studio.
Migrar do Jack
O conjunto de ferramentas Jack está obsoleto, de acordo com este anúncio (em inglês). Se
o projeto depender do Jack, faça a migração usando a compatibilidade com o Java 8 incorporada
ao conjunto de ferramentas padrão do Android Studio. O uso do conjunto de ferramentas padrão
também oferece compatibilidade com bibliotecas de terceiros que usam recursos da linguagem Java
8 e ferramentas que dependem de arquivos .class intermediários.
4.3 Programar o app 99

Para desativar o Jack e mudar para o conjunto de ferramentas padrão, basta remover o bloco
jackOptions do arquivo [Link] do módulo:
android {
...
defaultConfig {
...
// Remove this block.
jackOptions {
enabled true
...
}
}

// Keep the following configuration in order to target Java 8.

compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
// For Kotlin projects
kotlinOptions {
jvmTarget = "1.8"
}
}

Migrar do Retrolambda
Em comparação com o conjunto de ferramentas padrão do Android Studio, o Retrolambda não
é compatível com bibliotecas de terceiros que usam recursos da linguagem Java 8. Para migrar para
o conjunto de ferramentas padrão, remova a dependência do Retrolambda do arquivo [Link]
do projeto:
buildscript {
...
dependencies {
// Remove the following dependency.
classpath ’[Link]:gradle-retrolambda:<version_number>’
}
}

Além disso, remova o plug-in do Retrolambda e o bloco retrolambda do arquivo [Link]

de cada módulo:
// Remove the following plugin.
apply plugin: ’[Link]’
...
// Remove this block after migrating useful configurations.
retrolambda {
...
// If you have arguments for the Java VM you want to keep,
// move them to your project’s [Link] file.
jvmArgs ’-Xmx2048m’
}
100 Capítulo 4. Ferramentas de Desenvolvimento para Android

Desativar compatibilidade com recursos da linguagem Java 8

Se você tiver problemas relacionados à compatibilidade com recursos da linguagem Java 8,
poderá desativar essa compatibilidade adicionando o seguinte ao arquivo [Link]:
[Link]=false

Para nos ajudar a melhorar a compatibilidade com o Java 8, informe um bug.

Adicionar recursos de app
Os recursos do app, como bitmaps e layouts, são organizados em diretórios específicos de tipo
dentro do diretório res/ de cada módulo. Você também pode adicionar versões alternativas de cada
arquivo que são otimizadas para diferentes configurações de dispositivo (como uma versão de alta
resolução de um bitmap para telas de alta densidade).
O Android Studio ajuda você a adicionar recursos novos e alternativos de várias maneiras,
dependendo do tipo de recurso que você quer adicionar. Esta página descreve como adicionar
arquivos de recursos básicos, como alterar a localização dos recursos e como funciona a mescla de
recursos.
Consulte também as seguintes páginas para ver detalhes sobre como criar tipos de recursos
específicos:
• Para adicionar arquivos de layout, consulte Criar uma IU com o Layout Editor.
• Para adicionar arquivos de string, consulte Localizar a IU com o Translations Editor.
• Para adicionar bitmaps, consulte Criar ícones com o Image Asset Studio.
• Para adicionar arquivos SVG, consulte Adicionar gráficos vetoriais de várias densidades.
Para informações sobre como referenciar os recursos do código do app, consulte Fornecimento
de recursos.
Adicionar um arquivo de recurso XML
Embora as páginas vinculadas acima descrevam fluxos de trabalho personalizados para cada
tipo de recurso, você pode adicionar qualquer arquivo de recurso XML seguindo estas etapas:
1. Clique no módulo de app de destino na janela Project (na visualização Android ou Project)
e selecione File > New > Android resource file.
4.3 Programar o app 101

2. Preencha os detalhes na caixa de diálogo:

• File name: digite o nome do arquivo XML (não requer o sufixo .xml).
• Resource type: selecione o tipo de recurso que você quer criar.
• Root element: se aplicável, selecione o elemento XML raiz do arquivo. Alguns tipos
de recurso são compatíveis com apenas um tipo de elemento raiz. Portanto, dependendo
do tipo selecionado acima, isso pode não ser editável.
• Source set: selecione o conjunto de origem onde você quer salvar o arquivo.
• Directory name: o diretório precisa ser nomeado de uma maneira específica para os
qualificadores de configuração e tipo de recurso. Portanto, não edite isso, a menos que
você queira adicionar qualificadores de configuração ao nome do diretório manualmente
(consulte Available qualifiers).
• Available qualifiers: em vez de digitar qualificadores de configuração para o diretório
de layout, você pode adicioná-los clicando em um qualificador na lista à esquerda e,
em seguida, clicando em Add .
3. Depois de adicionar todos os qualificadores desejados, clique em OK.
Dica: clique com o botão direito do mouse em um diretório de recursos existente na pasta res e
selecione New > type-name resource file. Isso abre uma versão simplificada da caixa de diálogo
New Resource File, que é específica do tipo de recurso desejado.
Dica: alguns recursos complexos exigem vários arquivos de recursos XML. Por exemplo, um
drawable vetorial animado tem um objeto de drawable vetorial e um objeto de animação, o que
requer pelo menos três arquivos XML. Você pode manter os três arquivos XML separados se
precisar reutilizar um ou mais deles. Porém, se os arquivos XML forem usados apenas para esse
drawable vetorial animado, você poderá usar o formato de recurso in-line fornecido na Android
Asset Packaging Tool (AAPT). Com a AAPT, você pode definir todos os três recursos em um único
arquivo XML. Para mais informações, consulte Recursos XML in-line complexos.
Adicionar um diretório de recursos
Se você precisar adicionar um novo diretório de recursos, siga estas etapas:
1. Clique no módulo do app de destino na janela Project e selecione File > New > Android
resource directory.

2. Preencha os detalhes na caixa de diálogo:

102 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Directory name: o diretório precisa ser nomeado de uma maneira específica para os
qualificadores de combinação de configuração e tipo de recurso. Portanto, não edite
isso, a menos que você queira adicionar qualificadores de configuração ao nome do
diretório manualmente (use Available qualifiers).
• Resource type: selecione o tipo de recurso que você quer criar.
• Source set: selecione o conjunto de origem onde você quer o layout.
• Available qualifiers: em vez de digitar qualificadores de configuração para o diretório
de layout, você pode adicioná-los clicando em um qualificador na lista à esquerda e,
em seguida, clicando em Add .
3. Depois de adicionar todos os qualificadores desejados, clique em OK.
Alterar seu diretório de recursos
Por padrão, seus recursos estão localizados em module-name/src/source-set-name/res/. Por
exemplo, os recursos do conjunto de origem principal do seu módulo estão em src/main/res/ e os
recursos do conjunto de origem de depuração estão em src/debug/res/.
No entanto, você pode alterar esses caminhos para qualquer outro local (relativo ao arquivo
[Link]) com a propriedade [Link] no bloco sourceSets {}. Exemplo:
android {
sourceSets {
main {
[Link] = [’resources/main’]
}
debug {
[Link] = [’resources/debug’]
}
}
}

Você também pode especificar vários diretórios de recursos para um conjunto de origem e,
então, as ferramentas de compilação serão mescladas. Exemplo:
android {
sourceSets {
main {
[Link] = [’res1’, ’res2’]
}
}
}

Observação: se dois diretórios de recursos ou mais contiverem o mesmo arquivo de recurso,

ocorrerá um erro durante a mescla de recursos.
Para mais informações, leia sobre conjuntos de origem.
Mescla de recursos
Os recursos do arquivo do APK final podem vir de três origens diferentes:
• O conjunto de origem principal (geralmente localizado em src/main/res/)
• Conjuntos de origem de variantes de compilação
• Bibliotecas do Android (AARs)
Quando todos os recursos de cada conjunto de origem ou biblioteca são exclusivos, todos eles
são adicionados ao APK final. Um recurso será considerado exclusivo se o nome do arquivo for
exclusivo no diretório do tipo de recurso e no qualificador do recurso (se definido).
Se houver duas ou mais versões correspondentes do mesmo recurso, somente uma versão será
4.3 Programar o app 103

incluída no APK final. As ferramentas de compilação selecionam qual versão manter com base na
seguinte ordem de prioridade (prioridade mais alta à esquerda):

variante de compilação > tipo de compilação > variação de produtos > conjunto de origem
principal > dependências de biblioteca

Por exemplo, se o conjunto de origem principal contiver:

• res/layout/[Link]
• res/layout-land/[Link]

E o tipo de compilação de depuração contiver:

• res/layout/[Link]

Então, o APK final incluirá res/layout/[Link] do tipo de compilação de depuração e res/layout-

land/[Link] do conjunto de origem principal.

No entanto, se sua configuração de compilação especificar várias pastas de recursos para um

determinado conjunto de origem e houver conflitos entre essas origens, ocorrerá um erro e a mescla
falhará porque cada diretório de recursos tem a mesma prioridade.

Criar uma IU com o Layout Editor

No Layout Editor, você pode criar rapidamente layouts de compilação arrastando elementos de
IU para um editor de design visual, em vez de escrever manualmente o XML do layout. O Design
Editor pode exibir uma visualização do layout em vários dispositivos e versões do Android, e você
pode redimensionar dinamicamente o layout para garantir que funcione bem em tamanhos de tela
diferentes.

O Layout Editor é particularmente útil para criar um novo layout com o ConstraintLayout, um
gerenciador de layouts fornecido em uma biblioteca de suporte compatível com o Android 2.3 (API
de nível 9) ou versões posteriores.

Esta página oferece uma visão geral da interface do Layout Editor. Para saber mais sobre os
fundamentos de layout, consulte Layouts. Para saber mais sobre como criar um layout com o
ConstraintLayout, consulte Criar uma IU responsiva com o ConstraintLayout.

Introdução ao Layout Editor

O Layout Editor é exibido quando você abre um arquivo de layout XML.

As partes do editor são as seguintes, identificadas pelos números da Figura 21:

1. Palette: lista de visualizações e de grupos de visualizações que você pode arrastar para o
layout.
2. Component Tree: hierarquia de visualização do seu layout.
3. Toolbar: botões para configurar a aparência do layout no editor e para alterar alguns atributos
do layout.
4. Design editor: layout na visualização "Design", "Blueprint"ou ambas.
5. Attributes: controles para os atributos da visualização selecionada.
104 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 21. O Layout Editor.

Quando você abre um arquivo de layout XML, o Design Editor é exibido por padrão (como
mostrado na Figura 21).
Para editar o XML do layout no editor de texto, clique na guia Text na parte inferior da janela.
No editor de texto, você também pode ver a Palette, a Component Tree e o Design Editor clicando
em Preview no lado direito da janela. A janela Attributes não está disponível no editor de texto.
Dica: você pode alternar entre os editores de design e texto pressionando Alt + + seta
direita/esquerda (Control + + seta direita/esquerda no Mac).
Alterar a aparência da visualização
Os botões na linha superior do Design Editor permitem configurar a aparência do layout no
editor. Essa barra de ferramentas também está disponível na janela Preview do editor de texto.

Figura 22. Botões da barra de ferramentas do Layout Editor que configuram a aparência do
layout.
Os botões disponíveis são os seguintes, identificados pelos números da Figura 22:
1. Design and blueprint: selecione como quer visualizar o layout no editor. Selecione a
visualização Design (uma visualização real do layout), a Blueprint (somente os contornos
de cada visualização) ou Design + Blueprint para ver as duas, lado a lado.
Dica: pressione B para alternar essas visualizações.
2. Screen orientation and layout variants: selecione entre as orientações de tela paisagem e
retrato, ou outros modos de tela para os quais o aplicativo oferece layouts alternativos, como
o modo noturno. Esse menu também contém comandos para criar uma nova variante de
layout.
3. Device type and size: selecione o tipo de dispositivo (smartphone/tablet, Android TV ou
4.3 Programar o app 105

Wear OS) e a configuração de tela (tamanho e densidade). Você pode escolher entre diversos
tipos de dispositivos pré-configurados e suas próprias definições de AVD ou iniciar um novo
AVD selecionando Add Device Definition na lista.
Dica: para redimensionar o tamanho do dispositivo, arraste o canto inferior direito do layout.
4. API version: selecione a versão do Android onde quer visualizar o layout.
5. App theme: selecione o tema de IU a ser aplicado na visualização. Isso funciona apenas
para os estilos de layout compatíveis. Portanto, diversos temas dessa lista resultam em erro.
6. Language: selecione o idioma de exibição de strings de IU. A lista exibe apenas os idiomas
disponíveis nos recursos de string. Para editar as traduções, clique em Edit Translations no
menu suspenso (consulte Localizar a IU com o Translations Editor).
Observação: essas configurações não têm efeito no código ou manifesto do aplicativo (a menos
que você opte por adicionar um novo arquivo de layout em Layout Variants) e afetam apenas a
visualização do layout.
Criar um novo layout
Para adicionar um novo layout ao aplicativo, comece criando um arquivo de layout no diretório
layout/ padrão do projeto, para que ele seja aplicado a todas as configurações de dispositivos. Assim
que tiver um layout padrão, você poderá criar variações de layout para configurações de dispositivos
específicas (como para telas xlarge).
Há diferentes formas de criar um novo layout conforme a visualização da janela Project, mas o
procedimento a seguir pode ser acessado em qualquer visualização:
1. Na janela Project, clique no módulo (como app) em que você quer adicionar um layout.
2. No menu principal, selecione File > New > XML > Layout XML File.
3. Na caixa de diálogo exibida, insira um nome para o arquivo, a tag do layout raiz e o conjunto
de origem a que o layout pertence. Em seguida, clique em Finish.
Veja a seguir algumas outras formas de iniciar um arquivo de layout (embora as caixas de
diálogo exibidas sejam diferentes):
• Se você selecionou a visualização Project na janela Project: abra o diretório res do módulo
de aplicativo, clique com o botão direito no local onde quer adicionar o layout e clique em
New > Layout resource file.
• Se você selecionou a visualização Android na janela Project: clique com o botão direito na
pasta layout e selecione New > Layout resource file.
Criar uma variante de layout
Se você já tem um layout e quer criar uma versão alternativa para otimizar o layout para
tamanhos ou orientações de tela diferentes, siga estas etapas:
1. Abra o arquivo de layout original e verifique se você vê o Design Editor (clique na guia
Design na parte inferior da janela).
2. Clique em Orientation for Preview na barra de ferramentas. Na lista suspensa, clique
em uma variante sugerida, como Create Landscape Variant, para finalizar ou clique em
Create Other e continue com a próxima etapa.
3. Na caixa de diálogo exibida, basta definir os qualificadores de recurso para o nome do
diretório. Você pode digitar no Directory name ou escolher na lista Available qualifiers,
um de cada vez, e clicar em Add .
4. Depois de adicionar todos os qualificadores, clique em OK.
Quando você tem diversas variações do mesmo layout, é possível alternar facilmente entre elas
na lista exibida clicando em Layout Variants .
Para saber mais sobre como criar layouts para telas diferentes, consulte Compatibilidade com
tamanhos de tela diferentes.
Converter uma visualização ou layout
106 Capítulo 4. Ferramentas de Desenvolvimento para Android

Você pode converter uma visualização para outro tipo de visualização, bem como converter um
layout (grupo de visualização) para outro tipo de layout.
1. Clique na guia Design na parte inferior da janela do editor.
2. Na Component Tree, clique com o botão direito do mouse na visualização ou no layout e
clique em Convert view.
3. Na caixa de diálogo exibida, escolha o novo tipo de visualização ou layout e clique em
Apply.
Converter um layout em ConstraintLayout
O ConstraintLayout é um grupo de visualização disponível na biblioteca Constraint Layout,
incluída no Android Studio 2.2 ou posterior. Ele foi criado do zero em conjunto com o Layout Editor.
Portanto, tudo fica acessível do Design Editor e você nunca precisará editar o XML manualmente.
O melhor de tudo é que o sistema de layout baseado em restrições permite criar a maioria dos
layouts sem aninhar nenhum grupo de visualização.
Para melhorar o desempenho do layout, você precisa converter layouts antigos para o Cons-
traintLayout.
Para converter um layout existente para o ConstraintLayout, faça o seguinte:
1. Abra o layout existente no Android Studio e clique na guia Design na parte inferior da janela
do editor.
2. Na janela Component Tree, clique com o botão direito no layout e clique em Convert
layout to ConstraintLayout.
O comando para converter especificamente um layout para o ConstraintLayout é mais inteligente
ao inferir restrições e preservar o layout que o comando simples Convert view descrito na seção
anterior.
Para saber mais sobre como criar um layout com ConstraintLayout, consulte Criar uma IU
responsiva com o ConstraintLayout.
Encontrar itens na "Palette"
Para procurar uma visualização ou um grupo de visualizações pelo nome na Palette, clique
no botão Search na parte superior da paleta ou simplesmente comece a digitar o nome do item
quando a janela Palette estiver ativa.
Os itens usados com frequência podem ser encontrados na categoria Common na Palette. Para
adicionar um item a essa categoria, clique com o botão direito do mouse em uma visualização ou
em um grupo de visualização na Palette e clique em Favorite no menu de contexto.
Abrir documentação na "Palette"
Para abrir a documentação de referência do Android Developers para uma visualização ou um
grupo de visualização, selecione o elemento de IU na Palette e pressione +F1.
Para abrir a documentação sobre diretrizes do Material Design para uma visualização ou um
grupo de visualização, clique com o botão direito do mouse no elemento de IU na Palette e
selecione Material Guidelines no menu de contexto. Se não existir nenhuma entrada específica
para o item, esse comando abrirá a página inicial da documentação sobre diretrizes do Material
Design (link em inglês).
Adicionar visualizações ao layout
Para começar a criar um layout, basta arrastar visualizações e grupos de visualização da
Palette para o Design Editor. Quando você posiciona uma visualização no layout, o editor exibe
informações sobre o relacionamento dela com o restante do layout.
Se você está usando o ConstraintLayout, pode criar restrições automaticamente usando os
recursos "Infer Constraints"e "Autoconnect".
Editar atributos da visualização
4.3 Programar o app 107
108 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 23. A janela Attributes.

Em vez de editar as propriedades da visualização no XML, é possível fazer isso na janela
Attributes (no lado direito do Layout Editor). Essa janela somente está disponível quando o Design
Editor está aberto. Portanto, verifique se selecionou a guia Design na parte inferior da janela.
Quando você seleciona uma exibição clicando nela na Component Tree ou no Design Editor,
a janela Attributes exibe as seguintes informações, como indicado na Figura 23:
1. A seção Declared Attributes, que lista os atributos especificados no arquivo de layout. Para
adicionar um atributo, clique em Add no canto superior direito da seção.
2. Inspetor de visualização, com controles de estilo de largura/altura. Para visualizações em
um ConstraintLayout, esta seção também mostra a tendência de restrição e lista as restrições
que a visualização usa. Para mais informações, consulte Criar uma IU responsiva com o
ConstraintLayout.
3. Uma lista de atributos comuns para a visualização selecionada. Para ver todos os atributos
disponíveis, expanda a seção All Attributes na parte inferior da janela.
4. O botão "Search". Clique nele para procurar um atributo de visualização específico.
5. O indicador à direita de cada valor de atributo é sólido
o valor é uma referência de recurso e vazio
quando não é. Isso permite que você reconheça valores codificados rapidamente. Clicar
nesse indicador em qualquer um desses estados abre a janela de diálogo Resources, em que
você pode selecionar uma referência de recurso para o atributo correspondente.
6. Atributos com erros ou avisos são destacados, com realces em vermelho para erros e em
laranja para avisos. Um exemplo de erro é uma entrada inválida em um atributo de definição
de layout (como na figura). Um exemplo de aviso é o uso de um valor codificado quando
uma referência de recurso é esperada (como na figura).
Adicionar dados de amostra à visualização
Como muitos layouts do Android dependem de dados de tempo de execução, pode ser difícil
visualizar a aparência de um layout durante a criação do design do seu aplicativo. No Android Studio
3.2 e posteriores, você pode adicionar dados de visualização de amostra a TextView, ImageView ou
RecyclerView a partir do Layout Editor.
Observação: ao adicionar dados de amostra a View, o Android Studio faz alterações no seu
projeto como se você estivesse usando dados próprios. É possível modificar essas alterações
conforme necessário.
Você pode clicar com o botão direito do mouse em um desses tipos de visualização e escolher
Set Sample Data para exibir a janela Design-time View Attributes, conforme mostrado na Figura
24.

Figura 24. A janela Design-time View Attributes.

Em um TextView, há várias opções de categorias de texto de amostra diferentes. Ao usar o
4.3 Programar o app 109

texto de amostra, o Android Studio preenche o atributo text de TextView com os dados de amostra
escolhidos. Só será possível escolher o texto de amostra na janela Design-time View Attributes
se o atributo text estiver vazio.

Figura 25. TextView com dados de amostra.

Em um ImageView, há opções diferentes de imagens de amostra. Quando você escolhe
uma imagem de amostra, o Android Studio preenche o atributo tools:src de ImageView (ou de
tools:srcCompat, se estiver usando a Biblioteca de Suporte).

Figura 26. ImageView com dados de amostra.

Em um RecyclerView, há opções de conjuntos de modelos com imagens e textos de amostra,
que podem ser escolhidas. Ao usar esses modelos, o Android Studio adiciona um arquivo ao
seu diretório res/layout, recycler_view_item.xml, que contém o layout dos dados de amostra. O
Android Studio também adiciona os metadados ao RecyclerView para exibir corretamente os dados
de amostra.
110 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 27. RecyclerView com dados de amostra.

Mostrar avisos e erros do layout
Todos os problemas detectados no layout são indicados na Component Tree com um ícone de

ponto de exclamação ( ou ) ao lado da visualização correspondente. Para visualizar

os detalhes do erro, clique no ícone.
Para ver todos os problemas conhecidos em uma janela abaixo do editor, clique em Show

Warnings and Errors ( ou ) na barra de ferramentas.

Nessa janela, você também pode ativar Show issues on the preview, que adiciona um ícone
de aviso ou erro a cada visualização correspondente (somente na visualização "Design"e não na
visualização "Blueprint").
Fazer o download de fontes e aplicá-las ao texto
Ao usar o Android 8.0 (API de nível 26) ou a Biblioteca de Suporte 26.0.0 ou posterior, você
pode selecionar entre centenas de fontes seguindo estas etapas:
4.3 Programar o app 111

1. No Layout Editor, clique na guia Design para visualizar o layout no Design Editor.
2. Clique em uma visualização de texto.
3. Na janela Attributes, expanda textAppearance e clique para expandir a caixa de diálogo
fontFamily.
4. Role até a parte inferior da lista e clique em More Fonts para abrir a caixa de diálogo
Resources.
5. Na caixa de diálogo Resources, selecione uma fonte navegando na lista ou digitando na
barra de pesquisa na parte superior. Ao selecionar uma fonte listada em Downloadable,
você poderá clicar em Create downloadable font para carregar a fonte no momento da
execução (como uma fonte disponível para download) ou clicar em Add font to project para
empacotar a fonte TTF no APK. As fontes listadas em Android são fornecidas no sistema
Android. Portanto, não é necessário fazer o download delas nem empacotá-las no APK.
6. Clique em OK.

Gerenciar os recursos de IU do app com o Resource Manager

O Resource Manager é uma nova janela de ferramentas para importar, criar, gerenciar e usar
recursos no app. Você pode abrir a janela de ferramentas selecionando View > Tool Windows
> Resource Manager na barra de menus ou selecionando Resource Manager na barra lateral
esquerda.
112 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 1: o Resource Manager

1. Clique em Add para adicionar um novo recurso ao projeto. Você pode adicionar
ativos de imagem, de vetor, recursos ou pode importar recursos para o projeto.
4.3 Programar o app 113

2. A lista suspensa do módulo permite visualizar recursos específicos de um módulo.

3. Use a barra de pesquisa para pesquisar o módulo selecionado para um recurso.
4. O Resource Manager gerencia os drawables, as cores e os layouts do app. Use essas guias
para alternar entre cada tipo de recurso.
5. O botão de filtro permite mostrar recursos de bibliotecas externas.
6. A área de conteúdo principal exibe visualizações dos recursos. Clique com o botão direito do
mouse em um recurso para ver um menu de contexto em que, entre outras coisas, você pode
renomear o recurso e pesquisar no app onde o recurso é usado.
7. Clique nestes botões para visualizar os recursos como blocos ou listas.
8. Clique nestes botões para alterar o tamanho da visualização dos recursos.

Além dos recursos mencionados acima, o Resource Manager oferece uma maneira simples de
importar drawables em massa para o projeto. Você pode arrastar e soltar os arquivos de imagem,
incluindo arquivos SVG, diretamente para o Resource Manager ou pode usar o assistente Import
Drawables. Para mais informações, consulte a seção Importar recursos para o projeto abaixo.

Clique duas vezes em um recurso para que o Resource Manager exiba informações mais
detalhadas. Se você tiver várias versões de um recurso, essa visualização detalhada exibirá cada
versão junto com os qualificadores associados, conforme mostrado na Figura 28. Você também
pode clicar duas vezes em uma versão específica para abri-la em uma janela do editor.
114 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 28. O Resource Manager mostra versões de um recurso de imagem para diferentes
densidades de tela.
Importar drawables para seu projeto
Você pode importar recursos de imagem arrastando e soltando os arquivos ou pastas de recursos
diretamente para o Resource Manager. Depois de soltar os recursos no Resource Manager, a caixa
de diálogo Import drawables aparecerá. Nela, você poderá ver o resumo dos recursos e adicionar
os qualificadores necessários antes de importar.
Observação: para ver uma lista dos tipos de imagem compatíveis, consulte Formatos de mídia
compatíveis.
Para importar recursos de imagem para seu projeto, faça o seguinte:
1. Arraste e solte suas imagens diretamente na janela do Resource Manager no Android Studio.
Como alternativa, você pode clicar no ícone de adição (+), escolher Import Drawables,
4.3 Programar o app 115

conforme mostrado na Figura 29, e selecionar os arquivos e pastas que quer importar.

Figura 29. Seleção de Import Drawables no menu suspenso.

2. A caixa de diálogo Import drawables será exibida. Conforme mostrado na Figura 30,
essa caixa de diálogo exibe uma lista dos recursos que você está importando. Se você
estiver fornecendo várias versões do mesmo recurso, precisará adicionar qualificadores de
configuração de dispositivo que descrevam a configuração específica compatível com o
recurso. Por exemplo, se você estiver fornecendo várias versões do mesmo recurso para
diferentes densidades de tela, poderá adicionar um qualificador Density para cada versão.
Observe que, se dois ou mais recursos tiverem o mesmo nome e qualificadores, apenas uma
versão será importada. Para mais informações sobre qualificadores de recursos, consulte
Fornecimento de recursos alternativos.
116 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 30. A caixa de diálogo Import Drawables.

3. Quando você achar que está tudo pronto para importar seus recursos, clique no botão Import.

Na janela do Resource Manager, os recursos agora estão prontos para serem usados no projeto,
como mostrado na Figura 31.
4.3 Programar o app 117

Figura 31. O Resource Manager agora mostra suas imagens importadas.

Analisar automaticamente densidades de drawables
Quando você importar um arquivo ou uma pasta e o caminho tiver um qualificador de densidade,
o Resource Manager aplicará automaticamente esse qualificador como parte da importação. O
Resource Manager pode analisar os qualificadores de densidade do Android e os fatores de escala
do iOS.
Esta tabela lista como diferentes densidades compatíveis são representadas para Android e iOS:

Densidade Qualificador de densidade do Android Fator de e

Baixa densidade (aproximadamente 120 dpi) ldpi não compa
Média densidade (aproximadamente 160 dpi) mdpi escala orig
Alta densidade (aproximadamente 240 dpi) hdpi não compa
Densidade extra-alta (aproximadamente 320 dpi) xhdpi @2x
Densidade extra-extra-alta (aproximadamente 480 dpi) xxhdpi @3x
Densidade extra-extra-extra-alta (aproximadamente 640 dpi) xxxhdpi @4x

Veja alguns exemplos de como os caminhos de entrada se traduzem em caminhos de recursos

após a importação:
Qualificador de densidade do Android: hdpi
Caminho de entrada: /UserFolder/icon1/hdpi/[Link]
Caminho de recurso: <projectFolder>/<moduleFolder>/src/main/res/drawable-hdpi/[Link]
Qualificador de densidade do Android: xxhdpi
Caminho de entrada: /UserFolder/icon1/abc-xxhdpi/[Link]
Caminho de recurso: <projectFolder>/<moduleFolder>/src/main/res/drawable-xxhdpi/[Link]
Fator de escala do iOS: @2x
Caminho de entrada: /UserFolder/icon1/icon@[Link]
Caminho de recurso: <projectFolder>/<moduleFolder>/src/main/res/drawable-xhdpi/[Link]
Fator de escala do iOS: @2x
Caminho de entrada: /UserFolder/icon1/icon@2x_alternate.png
Caminho de recurso: <projectFolder>/<moduleFolder>/src/main/res/drawable-xhdpi/icon_alternate.png
118 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para mais informações sobre como oferecer compatibilidade com dispositivos com densidades
de pixel diferentes, consulte Compatibilidade com densidades de pixel diferentes.
Arrastar e soltar drawables no layout
Você pode arrastar e soltar drawables do Resource Manager diretamente em um layout. Quando
você solta um recurso em um layout, o Resource Manager cria uma ImageView correspondente
para esse drawable, como mostrado na Figura 4.1:

(a) Clicar e segurar, ... (b) ... arrastar e soltar, e... (c) ... dimensionar.

Figura 4.1: Arrastar e soltar drawables em um layout na visualização Design.

Você também pode arrastar e soltar na visualização XML da guia Text, conforme mostrado na
Figura 4.2:

(a) Clicar e segurar, ... (b) ... arrastar e soltar, e... (c) ... pronto. Código inserido.

Figura 4.2: Arrastar e soltar drawables em um layout da visualização Text.

Ao soltar um drawable em um layout na guia Text, o código gerado será diferente, dependendo
de onde você soltar o layout:
• Se você soltar um drawable em uma área em branco, o Resource Manager gerará uma
ImageView correspondente.
• Se você soltar um drawable em qualquer atributo, o Resource Manager substituirá esse valor
de atributo por uma referência ao drawable.
• Se você soltar um drawable em um elemento ImageView existente, o Resource Manager
substituirá o atributo de origem correspondente.
Projetar temas de apps com o Theme Editor
Alerta: a partir da versão 3.3, o Theme Editor não está mais incluído no Android Studio.
O Android Studio inclui um assistente visual, denominado "Theme Editor", que ajuda a:
• criar e modificar temas para seu app;
• ajustar temas para diferentes classificadores de recursos;
• visualizar o efeito das mudanças de cor em elementos comuns de IU.
Esta página apresenta as tarefas básicas que podem ser realizadas com o Theme Editor e explica
como fazer isso.
Conceitos básicos do Theme Editor
Esta seção descreve como acessar o Theme Editor e como é o layout.
Acessar o Theme Editor
Há duas formas de abrir o Theme Editor:
4.3 Programar o app 119

• Em um arquivo XML de estilos aberto, como [Link], clique em Open editor perto do
canto superior direito da janela do arquivo.
• No menu Tools, escolha Theme Editor.
Navegar pelo Theme Editor
A tela principal do Theme Editor é dividida em duas seções. O lado esquerdo do editor mostra
qual é a aparência de elementos de IU específicos, como a barra de apps ou um botão suspenso,
quando o tema atual é aplicado a eles. O lado direito do editor mostra o nome do tema visualizado no
momento, o módulo onde o tema é definido e as configurações dos recursos do tema, como Theme
parent e colorPrimary. Você pode modificar os temas de projeto alterando essas configurações de
recursos.
Temas e cores
O Theme Editor permite criar novos temas, modificar temas existentes e gerenciar as cores os
compõem.
Criar novos temas
Para criar um tema, siga estas etapas:
1. Abra o menu suspenso Theme ao lado do canto superior direito do Theme Editor.
2. Clique em Create New Theme.
3. Na caixa de diálogo New Theme, insira um nome para o novo tema.
4. Na lista Parent theme name, clique no pai do qual o tema herda os recursos iniciais.
Renomear temas
Para renomear um tema, siga estas etapas:
1. Abra o menu suspenso Theme ao lado do canto superior direito do Theme Editor.
2. Clique em Rename nome-do-tema.
3. Na caixa de diálogo Rename, insira um novo nome para o tema.
4. Opcional: para ver a aparência das alterações, clique em Preview.
5. Para aplicar as alterações, clique em Refactor.
Alterar recursos de cor
Para alterar um recurso de cor existente, como colorPrimary, siga estas etapas:
1. No Theme Editor, clique no quadrado colorido ao lado do nome do recurso que você quer
alterar. A caixa de diálogo Resources é exibida, mostrando uma lista de grupos de cores à
esquerda, e configurações e informações da cor de recurso selecionada à direita.
2. Defina uma cor para o recurso de tema selecionando uma opção no painel esquerdo ou
definindo uma nova cor, conforme descrito abaixo.
Selecionar uma cor
As cores são listadas na coluna à esquerda da caixa de diálogo Resources e organizadas nos
seguintes grupos:
• Project: são as cores dentro do seu projeto. Algumas podem ser editadas porque fazem parte
das origens do seu projeto, enquanto outras não podem ser editadas porque pertencem às
bibliotecas inclusas no projeto.
• android: são os recursos de cor que pertencem ao namespace do Android. Eles fazem parte
do framework Android e não podem ser editados.
• Theme Attributes: são os atributos do tema selecionado. Eles são referenciados pelo tema e
podem ser alterados dependendo do tema escolhido. Os atributos do tema nunca são editáveis
na caixa de diálogo Resources.
Definir uma nova cor
120 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 34. O editor de cores.

1. No menu suspenso no canto superior direito da caixa de diálogo Resources, clique em Add
new resource > New color Value. A caixa de diálogo Resource exibe um painel editável à
direita, com um campo Name para que você possa inserir um nome para a cor personalizada.
2. Crie a cor personalizada da seguinte maneira. As etapas correspondem aos destaques na
Figura 34.
1. Digite um nome para sua nova cor no campo Name que está em branco. Nenhum
espaço ou caractere especial é permitido no nome. Sublinhados e números podem ser
usados.
2. Escala de cores, campo Custom color e conta-gotas:
• Na escala de cores, clique na cor que você quer usar. A cor é exibida no campo
Custom color.
• Você pode usar o conta-gotas à esquerda do campo Custom color para selecionar
uma cor. Clique no conta-gotas e depois em algum item visível em qualquer
lugar da tela do computador. A cor no campo Custom color será mudada para a
cor escolhida.
3. Logo abaixo do campo Custom color, use os campos editáveis e o menu suspenso à
esquerda para especificar uma cor RGB, HSB ou ARGB por meio de valores numéricos.
O equivalente HEX da sua cor será exibido no campo editável mais à direita.
4.3 Programar o app 121

4. Para definir a opacidade e o matiz da cor, mova os controles deslizantes abaixo da

escala de cores.
5. Selecione um dos quadrados de cor predefinidos disponíveis. A cor será exibida no
campo Custom color, e o nome será alterado para o nome da cor selecionada.
3. Clique em OK para salvar suas configurações. A caixa de diálogo Resources será fechada,
levando você de volta para o Theme Editor.
Modificar uma cor
Você pode modificar qualquer cor editável. Se os campos de cor, matiz, opacidade e nome,
bem como os campos do Configurador do dispositivo, estiverem editáveis, você poderá editar a cor.
Consulte Selecionar cor se quiser saber por que alguns campos são editáveis e outros não.
1. Ajuste as configurações.
2. Clique em OK.
Corresponder à cor do Material Design
Se você definiu ou modificou uma cor de projeto personalizada, pode verificar se a cor cor-
responde à cor mais próxima da paleta do Material Design clicando em CLOSEST MATERIAL
COLOR, ao lado de Custom color. O Android Studio muda os valores de cor e opacidade da cor
escolhida para os valores da cor do Material Design mais parecida e substitui Custom color pelo
nome da cor da paleta do Material Design.
Observação: o recurso CLOSEST MATERIAL COLOR só fica disponível quando a cor ainda
não pertence ao Material Design.
Ver listas e cores de estado
O Theme Editor permite visualizar as cores associadas a estados diferentes. Para isso, abra
a caixa de diálogo Resources clicando no quadrado colorido localizado ao lado do nome de um
recurso de lista de estados editável. A caixa de diálogo Resources exibe uma lista de estados, como
Selected, e o valor da cor associada ao estado. Clique na cor de um estado para escolher um valor
de cor diferente.
Para aumentar o controle sobre os estados, veja e edite as propriedades relacionadas diretamente
no arquivo XML que as define. Para saber mais, consulte a documentação da classe ColorStateList.
Configurações específicas de dispositivos
Quando uma cor é editável, você pode escolher configurações específicas de dispositivos para
seu app. Para isso, siga estas etapas:
1. Abra a caixa de diálogo Resources. Para ver mais informações sobre como abrir a caixa de
diálogo Resources, consulte Mudar recursos de cor.
2. Selecione uma cor de Project e, na parte inferior do painel direito, clique para expandir
Device Configuration, exibindo o conjunto de origens e o nome do arquivo XML que contém
recurso, além de uma lista de diretórios específicos da configuração para colocar o arquivo.
3. Se necessário, altere o nome do arquivo XML.
4. Marque as caixas ao lado dos diretórios correspondentes às configurações específicas dos dis-
positivos com os quais você pretende manter compatibilidade. Configurações sem diretórios
especificados usarão por padrão o diretório values.
Para ver mais informações sobre a relação entre nomes de diretórios e configurações, consulte
Compatibilidade com várias telas. Para saber mais sobre os nomes de diretório compatíveis,
consulte Como fornecer recursos.
Adicionar gráficos vetoriais de várias densidades
O Android Studio inclui uma ferramenta denominada Vector Asset Studio, que ajuda a adicionar
ícones do Material Design e importar arquivos Scalable Vector Graphic (SVG) e Adobe Photoshop
Document (PSD) para um projeto como recursos drawable vetoriais. O uso de drawables vetoriais
em vez de bitmaps reduz o tamanho do APK, uma vez que o mesmo arquivo pode ser redimensio-
nado para diferentes densidades de tela, sem perda de qualidade da imagem. Para versões mais
122 Capítulo 4. Ferramentas de Desenvolvimento para Android

antigas do Android que não são compatíveis com drawables vetoriais, o Vector Asset Studio pode,
durante a compilação, transformar drawables vetoriais em diferentes tamanhos de bitmap para cada
densidade de tela.
Sobre o Vector Asset Studio
O Vector Asset Studio adiciona um gráfico vetorial ao projeto como arquivo XML que descreve
a imagem. A manutenção de um único arquivo XML pode ser mais fácil que a atualização de
diversos gráficos rasterizados em várias resoluções.
O Android 4.4 (API nível 20) e versões anteriores não são compatíveis com drawables vetoriais.
Se o nível mínimo de API for definido como um desses níveis de API, você terá duas opções para
usar o Vector Asset Studio: gerar arquivos Portable Network Graphic (PNG), o padrão, ou usar a
Biblioteca de Suporte.
Para manter compatibilidade com versões anteriores, o Vector Asset Studio gera imagens
rasterizadas do drawable vetorial. Os drawables vetoriais e rasterizados são empacotados juntos
no APK. Você pode fazer referência a drawables vetoriais como Drawable em código Java ou
@drawable em código XML. Quando o app for executado, a imagem vetorial ou rasterizada
correspondente será automaticamente exibida, dependendo do nível de API.
Se você quiser usar somente drawables vetoriais, use a Biblioteca de Suporte do Android 23.2
ou uma versão mais recente. Essa técnica exige uma mudança no arquivo [Link] antes de
executar o Vector Asset Studio, conforme descrito em Compatibilidade com versões anteriores
da Biblioteca de Suporte. A classe VectorDrawableCompat na Biblioteca de Suporte permite a
compatibilidade com VectorDrawable no Android 2.1 (API de nível 7) ou versão mais recente.
Tipos de gráficos vetoriais compatíveis
A especificação de Material Design do Google oferece ícones do Material Design que podem ser
usados em apps para Android. O Vector Asset Studio ajuda você a escolher, importar e dimensionar
ícones do Material Design, bem como a definir opacidade e a configuração de espelhamento da
direita para a esquerda (RTL, na sigla em inglês).
O Vector Asset Studio também permite importar seus arquivos SVG e PSD. O SVG é um
padrão aberto baseado em XML do World Wide Web Consortium (W3C). O formato do arquivo
PSD é compatível com recursos do Adobe Photoshop. O Vector Asset Studio é compatível com os
padrões básicos, mas não com todos os recursos dos formatos SVG e PSD. Quando você especifica
um arquivo SVG ou PSD, o Vector Asset Studio informa imediatamente se o código de gráficos é
compatível ou não. Ele converte o arquivo em um arquivo XML contendo código VectorDrawable.
Se ocorrerem erros, verifique se o drawable vetorial foi exibido corretamente. Para ver mais
informações sobre os recursos permitidos do PSD, consulte Compatibilidade e restrições para
arquivos PSD.
Para o Android 5.0 (API de nível 21) ou versões mais recentes, você pode usar a classe
AnimatedVectorDrawable para animar as propriedades da classe VectorDrawable. Com a Biblioteca
de Suporte, você pode usar a classe AnimatedVectorDrawableCompat para animar as propriedades
da classe VectorDrawable para o Android 3.0 (API de nível 11) ou versões mais recentes. Para ver
mais informações, consulte Animar drawables vetoriais.
Considerações para arquivos SVG e PSD
Um drawable vetorial é adequado para ícones simples. Os ícones do Material Design (link
em inglês) oferecem bons exemplos dos tipos de imagens que funcionam bem como drawables
vetoriais em um app. Por outro lado, muitos ícones de inicialização de apps têm muitos detalhes e
funcionam melhor como imagens rasterizadas.
O carregamento inicial de um drawable vetorial pode custar mais ciclos de CPU do que
a imagem rasterizada correspondente. Depois disso, o uso de memória e o desempenho são
semelhantes para os dois. Recomendamos que você limite uma imagem vetorial a, no máximo, 200
x 200 dp. Caso contrário, o desenho pode ser muito demorado.
4.3 Programar o app 123

Embora os drawables vetoriais sejam compatíveis com uma ou mais cores, em muitos casos
faz sentido colorir os ícones de preto (android:fillColor="#FF000000"). Dessa forma, é possível
adicionar uma tonalidade ao vetor drawable colocado em um layout, e a cor do ícone mudará para a
cor da tonalidade. Se a cor do ícone não for preta, ela poderá se mesclar com a tonalidade em vez
de substituí-la.
Soluções de compatibilidade com versões anteriores de drawables vetoriais
A tabela a seguir resume as duas técnicas que podem ser usadas para compatibilidade com
versões anteriores:

Técnica Drawables no APK Elementos XML VectorDrawable Versão

Geração de Vetorial e Subconjunto SVG: P
PNGs rasterizado compatível do And
para o G
1.5.0 ou
recente
PSD:
Android
Studio 2
posterio
Biblioteca de Suporte 23.2 ou mais recente Vetorial Totalmente compatível Plug-in

O uso de drawables vetoriais pode produzir um APK menor, mas o carregamento inicial desses
drawables pode ser mais demorado.
Geração de PNGs
O Android 5.0 (API nível 21) ou mais recente é compatível com drawables vetoriais. Se o
app tiver um nível de API mínimo inferior a esse, o Vector Asset Studio adicionará o arquivo
de drawable vetorial ao projeto. Além disso, durante a compilação, o Gradle criará imagens
rasterizadas PNG em várias resoluções. O Gradle gera as densidades de PNG especificadas pela
propriedade generatedDensities (link em inglês) da Domain Specific Language (DSL) em um
arquivo [Link].
Para o Android 5.0 (API de nível 21) ou versões mais recentes, o Vector Asset Studio é
compatível com todos os elementos VectorDrawable. Para compatibilidade com o Android 4.4
(API nível 20) ou anterior, o Vector Asset Studio é compatível com os seguintes elementos XML:
<vector>
• android:width
• android:height
• android:viewportWidth
• android:viewportHeight
• android:alpha
<group>
• android:rotation
• android:pivotX
• android:pivotY
• android:scaleX
• android:scaleY
• android:translateX
• android:translateY
<path>
• android:pathData
124 Capítulo 4. Ferramentas de Desenvolvimento para Android

• android:fillColor
• android:strokeColor
• android:strokeWidth
• android:strokeAlpha
• android:fillAlpha
• android:strokeLineCap
• android:strokeLineJoin
• android:strokeMiterLimit

É possível alterar o código XML gerado pelo Vector Asset Studio, embora isso não seja
considerado uma prática recomendada. A alteração de valores no código não deve causar problemas,
desde que os valores sejam válidos e estáticos. Se você quiser adicionar elementos XML, precisará
ter certeza de que eles são compatíveis com base no nível mínimo de API.

Biblioteca de Suporte

Essa técnica exige a Biblioteca de Suporte do Android 23.2 ou mais recente e o Plug-in
do Android para o Gradle 2.0 ou mais recente, e usa somente drawables vetoriais. A classe
VectorDrawableCompat na Biblioteca de Suporte permite a compatibilidade com VectorDrawable
no Android 2.1 (API de nível 7) ou versões mais recentes.

Antes de usar o Vector Asset Studio, é necessário adicionar uma instrução ao arquivo [Link]:

android {
defaultConfig {
[Link] = true
}
}

dependencies {
compile ’[Link]:appcompat-v7:23.2.0’
}

Também é necessário usar técnicas de programação compatíveis com a Biblioteca de Suporte,

como usar o atributo app:srcCompat em vez de android:src para os drawables vetoriais. Para ver
mais informações, consulte Biblioteca de Suporte do Android 23.2 (link em inglês).

Executar o Vector Asset Studio

Para iniciar o Vector Asset Studio:

1. No Android Studio, abra o projeto de um app para Android.

2. Na janela Project, selecione a visualização Android.
3. Clique com o botão direito na pasta res e selecione New > Vector Asset.

Algumas outras visualizações e pastas do projeto também têm esse item de menu.

O Vector Asset Studio é exibido.

4.3 Programar o app 125

Figura 35. Vector Asset Studio.

4. Se a caixa de diálogo Need Newer Android Plugin for Gradle for exibida, corrija a versão do
Gradle da seguinte forma:
a. Selecione File > Project Structure.
b. Na caixa de diálogo Project Structure, selecione Project.
c. No campo Android Plugin Version, altere a versão do Plug-in do Android para Gradle
para 1.5.0 ou uma versão mais recente e clique em OK.
O Gradle sincroniza o projeto.
d. Na visualização Android da janela Project, clique com o botão direito na pasta res e selecione
New > Vector Asset.
O Vector Asset Studio é exibido.
5. Continue em Importar um gráfico vetorial.
Importar um gráfico vetorial
O Vector Asset Studio ajuda a importar um arquivo de gráfico vetorial para o projeto do app.
Siga um destes procedimentos:
• Adicionar um ícone do Material Design
• Importar um arquivo SVG ou PSD
Adicionar um ícone do Material Design
Depois de abrir o Vector Asset Studio, é possível adicionar um ícone do Material Design da
seguinte forma:
1. No Vector Asset Studio, selecione Material Icon.
2. No campo "Icon", clique no botão.
3. A caixa de diálogo Select Icon é exibida. Você pode filtrar quais ícones são visíveis sele-
cionando uma categoria na lista à esquerda ou inserindo sua opção no campo de pesquisa,
conforme mostrado na Figura 36.
126 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 36. Filtrar ícones do Material Design no Vector Asset Studio.

Selecione um ícone do Material Design e clique em OK. O ícone será exibido em Vector
Drawable Preview.
4. Opcionalmente, mude o nome, o tamanho, a opacidade e a configuração de espelhamento da
direita para a esquerda (RTL, na sigla em inglês) do recurso:
• Name: se não quiser usar o nome padrão, digite um novo. O Vector Asset Studio
criará automaticamente um nome único (adicionando um número ao final do nome)
se esse nome de recurso já existir no projeto. O nome pode conter apenas caracteres
minúsculos, sublinhados e dígitos.
• Override: selecione essa opção para ajustar o tamanho da imagem. Quando você digita
um novo tamanho, a alteração é exibida na área de visualização.
O padrão é 24 x 24 dp, definido na especificação do Material Design. Desmarque a caixa de
seleção para voltar ao padrão.
• Opacity: use o controle deslizante para ajustar a opacidade da imagem. A alteração é exibida
na área de visualização.
• Enable auto mirroring for RTL layout: selecione essa opção para exibir uma imagem
espelhada quando a direção do layout for da direita para a esquerda, não da esquerda para a
direita. Por exemplo, alguns idiomas são lidos da direita para a esquerda. Se você tiver um
ícone de seta, poderá ser necessário exibir uma imagem espelhada do ícone nesse caso. Se
você estiver trabalhando com um projeto antigo, também poderá ser necessário adicionar
android:supportsRtl="true"ao manifesto do app. O espelhamento automático é compatível
com o Android 5.0 (API de nível 21) ou versões mais recentes, bem como com a Biblioteca
de Suporte.
5. Clique em Next.
6. Você também tem a opção de alterar o diretório dos módulos e recursos:
• Res Directory: selecione o conjunto de origem do recurso onde quer adicionar o
drawable vetorial: src/main/res, src/debug/res e src/release/res ou um conjunto de
origem definido pelo usuário. O conjunto de origem principal é aplicado a todas as
4.3 Programar o app 127

variantes de compilação, inclusive depuração e lançamento. Os conjuntos de origem

de depuração e lançamento substituem o conjunto de origem principal e são aplicados
a uma versão de compilação. O conjunto de origem de depuração é usado apenas
para depuração. Para definir um novo conjunto de origem, selecione File > Project
Structure > app > Build Types. Por exemplo, você pode definir um conjunto de
origem Beta e criar uma versão de ícone que contenha o texto "BETA"no canto inferior
direito. Para saber mais, consulte Configurar variantes de compilação.

A área Output Directories exibe o drawable vetorial e o diretório onde ele será exibido.

7. Clique em Finish.

O Vector Asset Studio adiciona um arquivo XML que define o drawable vetorial ao projeto
na pasta app/src/main/res/drawable/. Na visualização Android da janela Project, é possível ver o
arquivo XML vetorial gerado na pasta drawable.

8. Compile o projeto.

Se o nível mínimo de API for Android 4.4 (API nível 20) ou anterior e você não tiver ativado
a técnica da Biblioteca de Suporte, o Vector Asset Studio gerará arquivos PNG. Na visualização
Project Files da janela Project, você poderá ver os arquivos PNG e XML na pasta app/build/genera-
ted/res/pngs/debug/.

Não edite os arquivos rasterizados gerados. Em vez disso, trabalhe com o arquivo XML vetorial.
O sistema de compilação gera automaticamente novos arquivos rasterizados quando necessário.
Portanto, não é necessário mantê-los.

Importar um arquivo SVG ou PSD

Depois de abrir o Vector Asset Studio, é possível importar um arquivo SVG ou PSD da seguinte
forma:

1. No Vector Asset Studio, selecione Local file.

O arquivo deve estar em uma unidade local. Se estiver localizado na rede, por exemplo, será
necessário antes fazer o download dele para uma unidade local.

2. Especifique um Image file clicando em . . . .

A imagem será exibida em Vector Drawable Preview.

Se o arquivo SVG ou PSD tiver recursos incompatíveis, será exibido um erro na parte inferior
do Vector Asset Studio, conforme mostrado na Figura 37.
128 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 37. Exibição de erros no Vector Asset Studio.

Se forem exibidos erros, será necessário garantir a renderização correta do drawable vetorial
importado. Role a lista para ver os erros.
Para ver uma lista dos elementos compatíveis, consulte Soluções de compatibilidade com
versões anteriores de drawables vetoriais. Para ver mais informações sobre os arquivos PSD
permitidos, consulte Compatibilidade e restrições para arquivos PSD.
3. Opcionalmente, altere o nome, o tamanho, a opacidade e a configuração de espelhamento da
direita para a esquerda (RTL, na sigla em inglês) do recurso:
• Name: se não quiser usar o nome padrão, digite um novo. O Vector Asset Studio
criará automaticamente um nome único (adicionando um número ao final do nome)
se esse nome de recurso já existir no projeto. O nome pode conter apenas caracteres
minúsculos, sublinhados e dígitos.
• Override: selecione essa opção para ajustar o tamanho da imagem. Assim, o tamanho
será alterado com as dimensões da própria imagem. Sempre que você alterar o tamanho,
a alteração será exibida na área de visualização. O padrão é 24 x 24 dp, definido na
especificação do Material Design (link em inglês).
• Opacity: use o controle deslizante para ajustar a opacidade da imagem. A alteração é
exibida na área de visualização.
• Enable auto mirroring for RTL layout: selecione essa opção para exibir uma imagem
espelhada quando a direção do layout for da direita para a esquerda, não da esquerda
para a direita. Por exemplo, alguns idiomas são lidos da direita para a esquerda. Se você
tiver um ícone de seta, poderá ser necessário exibir uma imagem espelhada do ícone
nesse caso. Se você estiver trabalhando com um projeto antigo, poderá ser necessário
adicionar android:supportsRtl="true"ao manifesto do app. O espelhamento automático
é compatível com o Android 5.0 (API nível 21) ou mais recente, bem como com a
4.3 Programar o app 129

Biblioteca de Suporte.
4. Clique em Next.
5. Se quiser, você poderá mudar o diretório de recursos:
• Res Directory: selecione o conjunto de origem do recurso onde quer adicionar o
drawable vetorial: src/main/res, src/debug/res e src/release/res ou um conjunto de
origem definido pelo usuário. O conjunto de origem principal é aplicado a todas as
variantes de compilação, inclusive depuração e lançamento. Os conjuntos de origem
de depuração e lançamento substituem o conjunto de origem principal e são aplicados
a uma versão de compilação. O conjunto de origem de depuração é usado apenas
para depuração. Para definir um novo conjunto de origem, selecione File > Project
Structure > app > Build Types. Por exemplo, você pode definir um conjunto de
origem Beta e criar uma versão de ícone que contenha o texto "BETA"no canto inferior
direito. Para saber mais, consulte Configurar variantes de compilação.
A área Output Directories exibe o drawable vetorial e o diretório onde ele será exibido.
6. Clique em Finish.
O Vector Asset Studio adiciona um arquivo XML que define o drawable vetorial ao projeto
na pasta app/src/main/res/drawable/. Na visualização Android da janela Project, é possível ver o
arquivo XML vetorial gerado na pasta drawable.
7. Compile o projeto.
Se o nível mínimo de API for Android 4.4 (API nível 20) ou anterior e você não tiver ativado
a técnica da Biblioteca de Suporte, o Vector Asset Studio gerará arquivos PNG. Na visualização
Project Files da janela Project, você poderá ver os arquivos PNG e XML na pasta app/build/genera-
ted/res/pngs/debug/.
Não edite os arquivos rasterizados gerados. Em vez disso, trabalhe com o arquivo XML vetorial.
O sistema de compilação gera automaticamente novos arquivos rasterizados quando necessário.
Portanto, não é necessário mantê-los.
Adicionar um drawable vetorial a um layout
Em um arquivo de layout, você pode definir qualquer widget relacionado a ícones, como
ImageButton, ImageView e assim por diante, apontando para um drawable vetorial. Por exemplo, o
layout a seguir mostra um drawable vetorial exibido em um botão:

Figura 4. Um drawable vetorial exibido no botão de um layout:

Para exibir um drawable vetorial em um widget, como mostrado na figura:
130 Capítulo 4. Ferramentas de Desenvolvimento para Android

1. Abra um projeto e importe um drawable vetorial.

Esse exemplo usa um projeto Phone/Tablet gerado com o assistente de novo projeto.
2. Na visualização Android da janela Project, clique duas vezes em um arquivo XML de layout,
como content_main.xml.
3. Clique na guia Design para exibir o Layout Editor.
4. Arraste o widget ImageButton da janela Palette para o editor de layout.
5. Na caixa de diálogo Resources, selecione Drawable no painel esquerdo e depois o drawable
vetorial importado. Clique em OK.
O drawable vetorial será exibido no ImageButton do layout.
6. Para alterar a cor da imagem para a cor de realce definida no tema, na janela Properties,
localize a propriedade tint e clique em . . . .
7. Na caixa de diálogo Resources, selecione Color no painel esquerdo e depois colorAccent.
Clique em OK.
A cor da imagem é alterada para a cor de realce no layout.
Se o projeto usar a Biblioteca de Suporte, o código de ImageButton deverá ser semelhante a
este:
<ImageButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:srcCompat="@drawable/ic_build_black_24dp"
tools:layout_editor_absoluteX="11dp"
tools:layout_editor_absoluteY="225dp"
android:id="@+id/imageButton"
android:tint="@color/colorAccent"/>

Se o projeto não usar a Biblioteca de Suporte, o código do drawable vetorial deverá ser
android:src="@drawable/ic_build_black_24dp".
Fazer referência a um drawable vetorial em código
Normalmente, você pode fazer referência a um recurso de drawable vetorial de forma gené-
rica no código. Quando o app é executado, a imagem vetorial ou rasterizada correspondente é
automaticamente exibida, dependendo do nível de API:
• Na maioria dos casos, é possível fazer referência a drawables vetoriais como @drawable no
código XML ou Drawable no código Java.
Por exemplo, o layout de código XML a seguir aplica a imagem a uma visualização:
<ImageView
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:src="@drawable/myimage"/>

O código Java a seguir recupera a imagem como Drawable:

KotlinJava
val drawable = [Link]([Link], theme)
O método getResources() fica na classe Context, que se aplica a objetos da IU, como atividades,
fragmentos, layouts, visualizações e outros.
Se o app usar a Biblioteca de Suporte (mesmo que você não tenha uma instrução vector-
[Link] = true no arquivo [Link]), também será possível referenciar um
drawable vetorial com uma instrução app:srcCompat. Exemplo:
<ImageView
android:layout_height="wrap_content"
4.3 Programar o app 131

android:layout_width="wrap_content"
app:srcCompat="@drawable/myimage"/>

Pode ser necessário fazer um typecast do recurso drawable para sua classe exata, como quando
é necessário usar recursos específicos da classe VectorDrawable.
Para isso, você pode usar código Java como o seguinte:
KotlinJava
if ([Link].SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
val vectorDrawable = drawable as VectorDrawable
} else {
val bitmapDrawable = drawable as BitmapDrawable
}

Só é possível acessar recursos de drawables vetoriais na linha de código principal.

Na técnica da Biblioteca de Suporte, você precisa usar técnicas de programação compatíveis
com essa biblioteca. Para ver mais informações, consulte Android Support Library 23.2.
Modificar código XML gerado pelo Vector Asset Studio
Você pode modificar o código XML do drawable vetorial, mas não os PNGs e o código XML
correspondente gerados durante a compilação. No entanto, isso não é recomendável.
Quando você usar a técnica de geração de PNGs, o Vector Asset Studio verificará se o drawable
vetorial e os PNGs são correspondentes e se o manifesto contém o código correto. Se você adicionar
código não compatível no Android 4.4 (API nível 20) ou anterior, as imagens vetorial e do PNG
poderão ser diferentes. Também é preciso verificar se o manifesto contém o código compatível com
as alterações.
Para modificar o arquivo XML vetorial quando você não está usando a técnica da Biblioteca de
Suporte:
1. Na janela Project, clique duas vezes no arquivo XML vetorial gerado na pasta drawable.
O arquivo XML será exibido no editor e nas janelas Preview.

Figura 38. Arquivo XML vetorial exibido no Code Editor e na janela "Preview".
2. Edite o código XML de acordo com o que é compatível com o nível de API mínimo:
• Android 5.0 (API de nível 21) e versões mais recentes: o Vector Asset Studio é
compatível com todos os elementos Drawable e VectorDrawable. É possível adicionar
elementos XML e alterar valores.
• Android 4.4 (API de nível 20) e versões anteriores: o Vector Asset Studio é compatí-
vel com todos os elementos Drawable e com um subconjunto dos elementos Vector-
Drawable. Consulte Soluções de compatibilidade de drawables vetoriais com versões
anteriores para ver uma lista. É possível alterar valores no código gerado e adicionar
elementos XML compatíveis.
132 Capítulo 4. Ferramentas de Desenvolvimento para Android

3. Compile o projeto e verifique se o drawable vetorial e as imagens rasterizadas correspondentes

têm a mesma aparência.
Lembre-se de que os PNGs gerados podem ser exibidos de forma diferente na janela Preview e
no app. Essa diferença é causada pelos mecanismos de renderização diferentes e pelas possíveis
alterações feitas no drawable vetorial antes da compilação. Se você adicionar código ao arquivo
XML vetorial criado pelo Vector Asset Studio, nenhum recurso incompatível no Android 4.4 (API
nível 20) ou anterior aparecerá nos arquivos PNG gerados. Como resultado, quando você adicionar
código, será sempre necessário verificar se os PNGs gerados correspondem ao drawable vetorial.
Para isso, você pode clicar duas vezes no PNG na visualização Project Files da janela Project. A
margem esquerda do Code Editor também exibe a imagem PNG quando o código faz referência ao
drawable, conforme mostrado na Figura 39.

Figura 39. Imagem PNG exibida na margem esquerda do Code Editor.

Excluir um drawable vetorial de um projeto
Para excluir um drawable vetorial de um projeto:
1. Na janela Project, exclua o arquivo XML vetorial gerado selecionando-o e pressionando a
tecla Delete ou selecione Edit > Delete.
A caixa de diálogo Safe Delete será exibida.
2. Também é possível selecionar opções para saber onde o arquivo é usado no projeto. Depois
disso, clique em OK.
O Android Studio exclui o arquivo do projeto e da unidade. No entanto, se você optou por
pesquisar os locais do projeto onde o arquivo é usado e alguns desses usos foram encontrados, é
possível visualizá-los e decidir se quer excluir esse arquivo ou não.
3. Selecione Build > Clean Project.
Todos os arquivos PNG e XML gerados automaticamente e correspondentes ao drawable
vetorial excluído serão removidos do projeto e da unidade.
Entregar um app que contém drawables vetoriais
Se você usou a técnica da Biblioteca de Suporte ou seu nível de API mínimo é o Android 5.0
(API nível 21) ou posterior, o APK conterá os drawables vetoriais adicionados com o Vector Asset
Studio. Esses APKs serão menores do que se as imagens vetoriais fossem convertidas em PNGs.
Se seu nível mínimo de API inclui o Android 4.4 (API nível 20) ou anterior e você tem
drawables vetoriais e imagens rasterizadas correspondentes no projeto, há duas opções para entregar
os arquivos do APK:
4.3 Programar o app 133

• Crie um APK que inclui os drawables vetoriais e as representações rasterizadas correspon-

dentes. Essa solução é a mais simples de implementar.
• Crie APKs separados para níveis de API diferentes. Quando você não inclui as imagens
rasterizadas correspondentes no APK para o Android 5.0 (API nível 21) ou posterior, o APK
pode ter um tamanho muito menor. Para ver mais informações, consulte Compatibilidade
com vários APKs.
Compatibilidade e restrições para arquivos PSD
O Vector Asset Studio não é compatível com todos os recursos de arquivos PSD. A lista a seguir
resume as características compatíveis e incompatíveis de arquivos PSD, bem como alguns detalhes
de conversão.
Documento
Compatíveis:
• Os modos de cor bitmap, grayscale, indexed, RGB, Lab ou CMYK de arquivos PSD
• Uma resolução de cores de 8, 16 ou 32 bits
Detalhes de conversão:
• As dimensões do documento PSD se tornam as dimensões do drawable vetorial e da janela
de visualização.
Incompatíveis:
• Os modos de cor duotone ou multichannel de arquivos PSD
Formas
Compatíveis:
• Máscaras de recorte, se a base do recorte for outra forma
• Operações de forma, incluindo combinação/adição, interseção, subtração e exclusão
Incompatíveis:
• Regra de preenchimento par-ímpar usada por formas do Photoshop. No Android 6.0 (API
nível 23) e anterior, os drawables vetoriais são compatíveis apenas com a regra de preen-
chimento não zero. Em formas com autointerseção, essa limitação pode levar a diferenças
de renderização entre o PSD e o drawable vetorial resultante. Para corrigir esse problema,
adicione android:fillType="evenOdd"à forma no drawable vetorial. Por exemplo:
<vector xmlns:android="[Link]
android:viewportHeight="168"
android:height="24dp"
android:viewportWidth="209"
android:width="24dp">

<path
android:fillAlpha="1.0"
android:fillColor="#000000"
android:fillType="evenOdd"
android:pathData="M24,58 L24,167 L114,167 L114,66 M64,1 L64,96 L208,96 L208,8
M1,97 L146,139 L172,47"/>
</vector>

Traços e preenchimentos
Compatíveis:
• Traços, incluindo cor, opacidade, largura, união, extremidade, traços interrompidos e alinha-
mento
• Preenchimentos e traços com cor sólida
• Cores de traço e preenchimento especificadas como RGB, Lab ou CMYK
134 Capítulo 4. Ferramentas de Desenvolvimento para Android

Detalhes de conversão:
• Se um traço for tracejado, recortado usando uma base de recorte ou usar um alinhamento
diferente do centro, o Vector Asset Studio o converterá em uma forma de preenchimento no
drawable vetorial.
Incompatíveis:
• Cores de preenchimentos e traços não sólidas, como gradientes
Opacidade
Compatíveis:
• Camadas de forma com opacidade 0
Detalhes de conversão:
• O Vector Asset Studio multiplica a opacidade do preenchimento pela opacidade da camada
para calcular o alfa do preenchimento.
• A ferramenta multiplica a opacidade da base de recorte (se existir) pelo alfa do preenchimento
para calcular o alfa do preenchimento final.
• A ferramenta multiplica a opacidade do traço pela opacidade da camada para calcular o alfa
do traço.
• A ferramenta multiplica a opacidade da base de recorte (se existir) pelo alfa do traço para
calcular o alfa do traço final.
Camadas
Compatíveis:
• Qualquer camada de forma visível
Detalhes de conversão:
• O Vector Asset Studio preserva o nome das camadas no arquivo do drawable vetorial.
Incompatíveis:
• Efeitos de camada
• Camadas de ajuste e texto
• Modos de mistura (ignorados)
Compatibilidade e restrições para arquivos SVG
O Vector Asset Studio não é compatível com todos os recursos de arquivo SVG. A seção a
seguir resume os recursos compatíveis e incompatíveis quando a ferramenta converte um arquivo
SVG em um VectorDrawable, bem como alguns detalhes de conversão.
Recursos compatíveis
VectorDrawable é compatível com todos os recursos do Tiny SVG 1.2, exceto para texto (links
em inglês).
Formas
VectorDrawable é compatível com caminhos SVG (link em inglês).
A ferramenta converte formas primitivas, como círculos, quadrados e polígonos, em caminhos
(link em inglês).
Transformações
A ferramenta é compatível com matrizes de transformação e as aplica diretamente a caminhos
filhos.
Grupos
A ferramenta é compatível com elementos de grupos para translação, dimensionamento e
rotação. Grupos não são compatíveis com propriedades de opacidade.
A ferramenta também aplica qualquer estilo de grupo ou opacidade a caminhos filhos.
Preenchimentos e traços
Os caminhos podem ser preenchidos e traçados com cores sólidas ou gradientes (linear, radial
ou angular). Apenas traços centralizados são compatíveis. Modos de mistura não são compatíveis.
Caminhos tracejados não são compatíveis.
4.3 Programar o app 135

Máscaras
A ferramenta é compatível com uma máscara de recorte por grupo.
Recursos incompatíveis com o importador de SVG
Qualquer recurso não listado na seção Recursos compatíveis acima é incompatível. Veja alguns
recursos incompatíveis importantes:
• Efeitos de filtro: efeitos como sombra projetada, desfoques e matriz de cor não são compatí-
veis.
• Texto: recomendamos que a conversão de texto em formas seja feita com outras ferramentas.
• Preenchimentos de padrões.
Criar ícones de app com o Image Asset Studio
O Android Studio tem uma ferramenta chamada Image Asset Studio, que ajuda você a criar os
próprios ícones de app com ícones do Material Design (link em inglês), imagens personalizadas e
strings de texto. Ele gera um conjunto de ícones na resolução correta para toda densidade de pixels
compatível com o app. O Image Asset Studio coloca os ícones gerados recentemente em pastas
específicas de cada densidade no diretório res/ do projeto. No momento da execução, o Android
emprega os recursos corretos com base na densidade da tela do dispositivo em que o app está sendo
executado.
O Image Asset Studio ajuda a gerar os seguintes tipos de ícone:
• Ícones na tela de início
• Barra de ações e ícones de guia
• Ícones de notificação
Sobre o Image Asset Studio
O Image Asset Studio ajuda a criar diversos tipos de ícones em diferentes densidades e mostra
exatamente onde eles precisam ser colocados no projeto. As seções a seguir descrevem os tipos de
ícone que você pode criar e as imagens e os textos que pode usar.
Ícones adaptáveis e legados na tela de início
Um ícone na tela de início é uma imagem que representa o app para os usuários. Ele pode:
• aparecer na lista de apps instalados em um dispositivo e na tela inicial;
• representar atalhos para acessar o app (por exemplo, o ícone de atalho de um contato que
abre informações detalhadas);
• ser usado por apps de inicialização;
• ajudar o usuário a encontrar seu app no Google Play.
Ícones adaptáveis na tela de início podem ser exibidos em diversas formas em diferentes
modelos de dispositivo e estão disponíveis no Android 8.0 (API nível 26) e versões posteriores. O
Android Studio 3.0 introduz a compatibilidade com a criação de ícones adaptáveis por meio do
Image Asset Studio. O Image Asset Studio gera visualizações de um ícone adaptável em formatos
de círculo, quadrado arredondado e quadrado, assim como uma visualização completa do ícone. O
Image Asset Studio também gera visualizações legadas, redondas e para a Google Play Store.
Um ícone legado na tela de início é uma imagem que representa o app na tela e na janela inicial
do dispositivo. Esse tipo de ícone é usado em dispositivos com Android 7.1 (API de nível 25) ou
versões anteriores, que não são compatíveis com ícones adaptáveis e não exibem tantos formatos
variados nos respectivos modelos.
O Image Asset Studio coloca os ícones nos locais adequados nos diretórios res/mipmap-density/.
Além disso, ele cria uma imagem de 512 x 512 pixels, perfeitamente adequada para a Google Play
Store.
É recomendável usar o estilo do Material Design para ícones na tela de início, mesmo quando
há compatibilidade com versões anteriores do Android.
Para ver mais informações, consulte Ícones adaptáveis na tela de início e Ícones de produto –
Material Design(link em inglês).
136 Capítulo 4. Ferramentas de Desenvolvimento para Android

Barra de ações e ícones de guia

Os ícones da barra de ações são elementos gráficos que representam ações necessárias indivi-
duais. Para ver mais informações, consulte Adicionar e processar ações, Barra de app – Material
Design e Design da barra de ações (dois últimos links em inglês).
Os ícones de guia são elementos gráficos usados para representar guias individuais em uma
interface com várias guias. Todo ícone de guia tem dois estados: não selecionado e selecionado.
Para ver mais informações, leia Criar visualizações deslizáveis com guias e Guias – Material Design
(link em inglês).
O Image Asset Studio coloca os ícones nos locais corretos nos diretórios res/drawable-density/.
É recomendável usar o estilo do Material Design para ícones de guia e da barra de ações, mesmo
quando há compatibilidade com versões anteriores do Android. Use appcompat e outras Bibliotecas
de Suporte para oferecer sua IU com Material Design a versões mais antigas da plataforma.
Como alternativa ao Image Asset Studio, você pode usar o Vector Asset Studio para criar ícones
de guia e da barra de ações. Os drawables vetoriais são adequados para ícones simples e podem
reduzir o tamanho do APK.
Ícones de notificação
Uma notificação é uma mensagem que pode ser exibida para o usuário fora da IU normal
do app. O Image Asset Studio coloca os ícones de notificação nos locais corretos dos diretórios
res/drawable-density/:
• Os ícones para Android 2.2 (API de nível 8) e versões anteriores são colocados nos diretórios
res/drawable-density/.
• Os ícones para o Android 2.3 ao 2.3.7 (APIs de nível 9 e 10) são colocados nos diretórios
res/drawable-density-v9/.
• Os ícones para o Android 3 (API de nível 11) e mais recentes são colocados nos diretórios
res/drawable-density-v11/.
Se o app for compatível com as versões de Android 2.3 a 2.3.7 (APIs de nível 9 e 10), o Image
Asset Studio gerará uma versão cinza do ícone. As versões mais recentes do Android usam o ícone
branco gerado pelo Image Asset Studio.
Para saber mais, consulte Notificações, Material Design para notificações (link em inglês),
Notificações, mudanças no Android 5.0, Notificações, Android 4.4 e versões anteriores e Ícones da
barra de status, Android 3.0 e versões anteriores (link e inglês).
Clip art
O Image Asset Studio facilita a importação de ícones do Material Design do Google em
formatos VectorDrawable e PNG. Para isso, basta selecionar um ícone na caixa de diálogo. Para
saber mais, consulte Ícones do Material Design.
Imagens
Você pode importar as próprias imagens e ajustá-las para o tipo do ícone. O Image Asset Studio
é compatível com os seguintes tipos de arquivo: PNG (preferível), JPG (aceitável) e GIF (não
recomendado).
Strings de texto
O Image Asset Studio permite digitar uma string de texto em diversas fontes e colocá-la em um
ícone. Ele converte o ícone baseado em texto para arquivos PNG para diferentes densidades. Você
pode usar as fontes instaladas no seu computador.
Executar o Image Asset Studio
Para iniciar o Image Asset Studio, faça o seguinte:
1. Na janela Project, selecione a visualização Android.
2. Clique com o botão direito na pasta res e selecione New > Image Asset.
4.3 Programar o app 137

3. Continue seguindo as etapas abaixo para:

• criar ícones adaptáveis e legados na tela de início em apps compatíveis com o Android
8.0;
• criar apenas um ícone legado na tela de início em apps compatíveis com versões do
Android anteriores à 7.1;
• criar um ícone de guia ou de barra de ações;
• criar um ícone de notificação.
Criar ícones adaptáveis e legados na tela de início
Observação: se o app for compatível com versões do Android anteriores à 7.1, siga as
instruções para criar apenas um ícone legado na tela de início.
Depois de abrir o Image Asset Studio, adicione ícones adaptáveis e legados seguindo estas
etapas:
1. No campo Icon Type, selecione Launcher Icons (Adaptive & Legacy).
2. Na guia Foreground Layer, selecione um Asset Type e especifique o ativo no campo abaixo:
• Selecione Image para especificar o caminho de um arquivo de imagem.
• Selecione Clip Art para especificar uma imagem do conjunto de ícones do Material
Design.
• Selecione Text para especificar uma string de texto e selecionar uma fonte.
3. Na guia Background Layer, selecione um Asset Type e especifique o ativo no campo abaixo.
Você pode selecionar uma cor ou especificar uma imagem para usar como camada de fundo.
4. Na guia Legacy, revise as configurações padrão e confirme que você quer gerar ícones
legados, redondos e para a Google Play Store.
5. Como alternativa, você pode mudar o nome e as configurações de exibição de cada guia
Foreground Layer e Background Layer:
• Name: caso não queira usar o nome padrão, digite um novo. Se esse nome de recurso
já existir no projeto, conforme indicado por um erro na parte inferior do assistente, ele
será substituído. O nome só pode conter caracteres minúsculos, sublinhados e dígitos.
• Trim: para ajustar a margem entre a imagem do item e a borda do ativo de origem,
selecione Yes. Essa operação remove espaços transparentes sem alterar a proporção.
Para manter o ativo de origem inalterado, selecione No.
138 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Color: para alterar a cor de um ícone Clip Art ou Text, clique no campo. Na caixa de
diálogo Select Color, especifique uma cor e clique em Choose. O novo valor aparecerá
no campo.
• Resize: use o controle deslizante para especificar um fator de escala em porcentagem
para redimensionar um ícone de Image, Clip Art ou Text. Esse controle é desativado
para a camada de segundo plano quando você especifica um ativo do tipo Color.
6. Clique em Next.
7. Você também pode mudar o diretório de recursos: selecione o conjunto de origem de recursos
onde quer adicionar o ativo de imagem, isto é, src/main/res, src/debug/res, src/release/res
ou um conjunto de origem personalizado. O conjunto de origem principal se aplica a todas
as variações de compilação, inclusive depuração e lançamento. Os conjuntos de origem de
depuração e lançamento substituem o conjunto de origem principal e são aplicados a uma
versão de compilação. O conjunto de origem de depuração é usado apenas para depuração.
Para definir um novo conjunto de origem, selecione File > Project Structure > app > Build
Types. Por exemplo, você pode definir um conjunto de origem Beta e criar uma versão
de ícone que contenha o texto "BETA"no canto inferior direito. Para saber mais, consulte
Configurar variações de versão.
8. Clique em Finish. O Image Asset Studio adiciona as imagens às pastas mipmap de cada
densidade.
Criar um ícone legado na tela de início
Observação: se o app é compatível com o Android 8.0, siga as instruções para criar ícones
adaptáveis e legados na tela de início.
Depois de abrir o Image Asset Studio, é possível adicionar um ícone na tela de início da seguinte
forma:
1. No campo Icon Type, selecione Launcher Icons (Legacy Only).
2. Selecione um Asset Type e especifique o ativo no campo abaixo:
• No campo Clip Art, clique no botão.
Na caixa de diálogo Select Icon, selecione um ícone do Material Design e clique em OK.
• No campo Path, especifique o caminho e o nome do arquivo da imagem. Clique em . . . para
usar uma caixa de diálogo.
• No campo Text, digite uma linha de texto e selecione uma fonte.
O ícone será exibido à direita da área Source Asset e na parte inferior do assistente na área de
visualização.
3. Se quiser, você pode mudar o nome e as configurações de exibição:
• Name: caso você não queira usar o nome padrão, digite um novo. Se esse nome
de recurso já existir no projeto, conforme indicado por um erro na parte inferior
do assistente, ele será substituído. O nome só pode conter caracteres minúsculos,
sublinhados e dígitos.
• Trim: para ajustar a margem entre a imagem do item e a borda do ativo de origem,
selecione Yes. Essa operação remove espaços transparentes sem alterar a proporção.
Para manter o ativo de origem inalterado, selecione No.
• Padding: se quiser ajustar o padding do ativo de origem nos quatro lados, mova o
controle deslizante. Selecione um valor entre -10% e 50%. Se você também selecionar
Trim, o corte acontecerá primeiro.
• Foreground: para alterar a cor do primeiro plano de um ícone de Clip Art ou Text,
clique no campo. Na caixa de diálogo Select Color, especifique uma cor e clique em
Choose. O novo valor aparecerá no campo.
• Background: para alterar a cor de fundo, clique no campo. Na caixa de diálogo Select
Color, especifique uma cor e clique em Choose. O novo valor aparecerá no campo.
4.3 Programar o app 139

• Scaling: para ajustar o tamanho do ícone, selecione Crop ou Shrink to Fit. Com a opção
"Crop", as bordas da imagem podem ser recortadas, mas com a opção "Shrink"isso não
é possível. Caso o ativo de origem ainda não esteja bem ajustado, você pode alterar o
padding.
• Shape: para colocar um pano de fundo atrás do ativo de origem, selecione uma forma,
seja de círculo, quadrado, retângulo vertical ou horizontal. Para inserir um pano de
fundo transparente, selecione None.
• Effect: se quiser adicionar um efeito de orelha de cachorro no canto superior direito de
um quadrado ou retângulo, selecione DogEar. Caso contrário, selecione None.
O Image Asset Studio coloca o ícone dentro de um quadrado transparente para que haja um
pouco de padding nas extremidades. O padding oferece espaço adequado para inserir o efeito
padrão de ícone com sombra projetada.
4. Clique em Next.
5. Se quiser, você poderá mudar o diretório de recursos:
• Res Directory: selecione o conjunto de origem de recursos onde você quer adicionar o
ativo de imagem src/main/res, src/debug/res, src/release/res ou um conjunto de origem
definido pelo usuário. O conjunto de origem principal é aplicado a todas as variações de
compilação, inclusive depuração e lançamento. Os conjuntos de origem de depuração e
lançamento substituem o conjunto de origem principal e são aplicados a uma versão
de compilação. O conjunto de origem de depuração é usado apenas para depuração.
Para definir um novo conjunto de origem, selecione File > Project Structure > app >
Build Types. Por exemplo, você pode definir um conjunto de origem Beta e criar uma
versão de ícone que contenha o texto "BETA"no canto inferior direito. Para saber mais,
consulte Configurar variações de compilação.
A área Output Directories mostra as imagens e pastas em que elas aparecerão na visualização
Project Files da janela Project.
6. Clique em Finish.
O Image Asset Studio adiciona as imagens às pastas mipmap de cada densidade.
Criar um ícone de guia ou de barra de ações
Depois de abrir o Image Asset Studio, é possível adicionar um ícone de guia ou de barra de
ações da seguinte forma:
1. No campo Icon Type, selecione Action Bar and Tab Icons.
2. Selecione um Asset Type e especifique o ativo no campo abaixo:
• No campo Clip Art, clique no botão.
Na caixa de diálogo Select Icon, selecione um ícone do Material Design e clique em OK.
• No campo Path, especifique o caminho e o nome do arquivo da imagem. Clique em . . . para
usar uma caixa de diálogo.
• No campo Text, digite uma linha de texto e selecione uma fonte.
O ícone será exibido à direita da área Source Asset e na parte inferior do assistente na área de
visualização.
3. Se quiser, você pode mudar o nome e as opções de exibição:
• Name: caso você não queira usar o nome padrão, digite um novo. Se esse nome
de recurso já existir no projeto, conforme indicado por um erro na parte inferior
do assistente, ele será substituído. O nome só pode conter caracteres minúsculos,
sublinhados e dígitos.
• Trim: para ajustar a margem entre a imagem do item e a borda do ativo de origem,
selecione Yes. Essa operação remove espaços transparentes sem alterar a proporção.
Para manter o ativo de origem inalterado, selecione No.
• Padding: se quiser ajustar o padding do ativo de origem nos quatro lados, mova o
140 Capítulo 4. Ferramentas de Desenvolvimento para Android

controle deslizante. Selecione um valor entre -10% e 50%. Se você também selecionar
Trim, o corte acontecerá primeiro.
• Theme: selecione HOLO_LIGHT ou HOLO_DARK. Ou, para especificar uma cor na
caixa de diálogo Select Color, selecione CUSTOM e clique no campo Custom color.
O Image Asset Studio cria o ícone dentro de um quadrado transparente para que haja um pouco
de padding nas extremidades. O padding oferece espaço adequado para inserir o efeito padrão de
ícone com sombra projetada.
4. Clique em Next.
5. Se quiser, você poderá mudar o diretório de recursos:
• Res Directory: selecione o conjunto de origem de recursos onde você quer adicionar o
ativo de imagem src/main/res, src/debug/res, src/release/res ou um conjunto de origem
definido pelo usuário. O conjunto de origem principal é aplicado a todas as variações de
compilação, inclusive depuração e lançamento. Os conjuntos de origem de depuração e
lançamento substituem o conjunto de origem principal e são aplicados a uma versão
de compilação. O conjunto de origem de depuração é usado apenas para depuração.
Para definir um novo conjunto de origem, selecione File > Project Structure > app >
Build Types. Por exemplo, você pode definir um conjunto de origem Beta e criar uma
versão de ícone que contenha o texto "BETA"no canto inferior direito. Para saber mais,
consulte Configurar variações de compilação.
A área Output Directories mostra as imagens e pastas em que elas aparecerão na visualização
Project Files da janela Project.
6. Clique em Finish.
O Image Asset Studio adiciona as imagens nas pastas drawable de cada densidade.
Criar um ícone de notificação
Depois de abrir o Image Asset Studio, é possível adicionar um ícone de notificação da seguinte
forma:
1. No campo Icon Type, selecione Notification Icons.
2. Selecione um Asset Type e especifique o ativo no campo abaixo:
• No campo Clip Art, clique no botão.
Na caixa de diálogo Select Icon, selecione um ícone do Material Design e clique em OK.
• No campo Path, especifique o caminho e o nome do arquivo da imagem. Clique em . . . para
usar uma caixa de diálogo.
• No campo Text, digite uma linha de texto e selecione uma fonte.
O ícone será exibido à direita da área Source Asset e na parte inferior do assistente na área de
visualização.
3. Se quiser, você pode mudar o nome e as opções de exibição:
• Name: caso você não queira usar o nome padrão, digite um novo. Se esse nome
de recurso já existir no projeto, conforme indicado por um erro na parte inferior
do assistente, ele será substituído. O nome só pode conter caracteres minúsculos,
sublinhados e dígitos.
• Trim: para ajustar a margem entre a imagem do item e a borda do ativo de origem,
selecione Yes. Essa operação remove espaços transparentes sem alterar a proporção.
Para manter o ativo de origem inalterado, selecione No.
• Padding: se quiser ajustar o padding do ativo de origem nos quatro lados, mova o
controle deslizante. Selecione um valor entre -10% e 50%. Se você também selecionar
Trim, o corte acontecerá primeiro.
O Image Asset Studio cria o ícone dentro de um quadrado transparente para que haja um pouco
de padding nas extremidades. O padding oferece espaço adequado para inserir o efeito padrão de
ícone com sombra projetada.
4.3 Programar o app 141

4. Clique em Next.
5. Se quiser, você poderá mudar o diretório de recursos:
• Res Directory: selecione o conjunto de origem de recursos onde você quer adicionar o
ativo de imagem src/main/res, src/debug/res, src/release/res ou um conjunto de origem
definido pelo usuário. O conjunto de origem principal é aplicado a todas as variações de
compilação, inclusive depuração e lançamento. Os conjuntos de origem de depuração e
lançamento substituem o conjunto de origem principal e são aplicados a uma versão
de compilação. O conjunto de origem de depuração é usado apenas para depuração.
Para definir um novo conjunto de origem, selecione File > Project Structure > app >
Build Types. Por exemplo, você pode definir um conjunto de origem Beta e criar uma
versão de ícone que contenha o texto "BETA"no canto inferior direito. Para saber mais,
consulte Configurar variações de compilação.
A área Output Directories mostra as imagens e pastas em que elas aparecerão na visualização
Project Files da janela Project.
6. Clique em Finish.
O Image Asset Studio adiciona as imagens nas pastas drawable de cada densidade e versão.
Referenciar um recurso de imagem no código
Normalmente, você pode referenciar um recurso de imagem de forma genérica no código.
Quando o app for executado, a imagem relacionada será exibida automaticamente, dependendo do
dispositivo:
• Na maioria dos casos, é possível referenciar recursos de imagem como @drawable no código
XML ou Drawable no código Java.
Por exemplo, o código XML do layout a seguir exibe o drawable em uma ImageView:
<ImageView
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:src="@drawable/myimage"/>

O código Java a seguir recupera a imagem como Drawable:

KotlinJava
val drawable = [Link]([Link], theme)

O método getResources() fica na classe Context, que se aplica a objetos da IU, como atividades,
fragmentos, layouts, visualizações e outros.
Se o app usar a Biblioteca de Suporte, será possível referenciar um recurso de imagem no
código XML com uma declaração app:srcCompat.
Exemplo:
<ImageView
android:layout_height="wrap_content"
android:layout_width="wrap_content"
app:srcCompat="@drawable/myimage"/>

Só é possível acessar recursos de imagem a partir da linha de execução principal.

Depois de inserir o recurso de imagem no diretório res/ do projeto, referencie-o no código Java
ou no layout XML usando o ID de recurso. O código Java a seguir define um ImageView para usar
o recurso drawable/[Link]:
KotlinJava
findViewById<ImageView>([Link]).apply {
setImageResource([Link])
142 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para ver mais informações, consulte Acesso aos recursos.

Para ícones na tela de início, o arquivo [Link] precisa referenciar o local mipmap/.
O Image Asset Studio adiciona esse código automaticamente. O código do arquivo de manifesto a
seguir referencia o ícone ic_launcher no diretório mipmap/:
<application android:name="ApplicationTitle"
android:label="@string/app_label"
android:icon="@mipmap/ic_launcher">

Excluir ícones de um projeto

Para remover um ícone do projeto:
1. Na janela Project, selecione a visualização Android.
2. Expanda a pasta res/minimap para ícones na tela de início ou a pasta res/drawable para
outros tipos de ícone.
3. Localize a subpasta que tem o nome do ícone que você quer excluir.
Essa pasta contém o ícone em diferentes densidades.
4. Selecione a pasta e pressione a tecla Delete.
Você também pode selecionar Edit > Delete ou clicar com o botão direito do mouse no arquivo
e selecionar Delete.
A caixa de diálogo Safe Delete será exibida.
5. É possível também selecionar opções para descobrir onde o ícone é usado no projeto. Depois
disso, clique em OK.
O Android Studio exclui os arquivos do projeto e da unidade. No entanto, se você optou por
pesquisar os locais do projeto onde os arquivos são usados e alguns usos foram encontrados, é
possível visualizar esses arquivos e decidir se quer excluí-los ou não. Você precisa excluir ou
substituir essas referências para compilar o projeto.
6. Selecione Build > Clean Project.
O Android Studio remove todos os arquivos de imagem gerados que correspondem ao recurso
de imagem excluído. Ele os remove do projeto e da unidade.
7. Se necessário, corrija os erros que ainda persistem devido a partes do código que referenciam
o recurso.
O Android Studio destaca esses erros no código. Depois de remover todas as referências do
código, você poderá criar o projeto novamente.
Criar bitmaps redimensionáveis (arquivos 9-Patch)
A ferramenta Draw 9-patch é um editor WYSIWYG integrado ao Android Studio que permite
criar imagens de bitmap automaticamente redimensionáveis, que se adaptam ao conteúdo da
visualização e ao tamanho da tela. Determinadas partes da imagem são dimensionadas no eixo
horizontal ou vertical, de acordo com os indicadores delineados dentro da imagem.
Para saber os conceitos básicos sobre as imagens NinePatch e como elas funcionam, leia a
seção sobre Drawables NinePatch no documento Canvas e Drawables.
4.3 Programar o app 143

Figura 40. Imagem NinePatch na ferramenta Draw 9-patch do Android Studio.

Veja um guia rápido para criar uma imagem NinePatch usando a ferramenta Draw 9-patch no
Android Studio. Você precisará da imagem em PNG com que quer criar uma imagem NinePatch.
1. No Android Studio, clique com o botão direito na imagem em PNG da qual você quer criar
uma imagem NinePatch e depois em Create 9-patch file.
2. Digite um nome para o arquivo da sua imagem NinePatch e clique em OK . A imagem será
criada com a extensão de arquivo .[Link].
3. Clique duas vezes no novo arquivo NinePatch para abri-lo no Android Studio. O espaço de
trabalho será aberto.
O painel à esquerda é a área de desenho, onde você pode editar as linhas dos trechos esticáveis
e da área destinada ao conteúdo. O painel à direita é a área de visualização, onde é possível ver a
imagem depois de esticada.
4. Clique dentro do perímetro de 1 pixel para delinear as linhas que definem os trechos esticáveis
e a área (opcional) do conteúdo. Clique com o botão direito (no Mac, mantenha
pressionado e clique) para apagar as linhas delineadas anteriormente.
5. Quando terminar, clique em File Save para salvar as alterações.
Você pode abrir um arquivo NinePatch existente no Android Studio clicando duas vezes nele.
Para garantir que as imagens NinePatch sejam dimensionadas para um tamanho menor correta-
mente, verifique se alguma região esticável tem pelo menos 2x2 pixels. Caso contrário, elas podem
desaparecer em uma redução de tamanho. Além disso, coloque um pixel a mais como margem
de segurança nas imagens antes e depois das regiões esticáveis para evitar interferência durante o
dimensionamento, o que pode alterar a cor das linhas de divisão.
144 Capítulo 4. Ferramentas de Desenvolvimento para Android

Observação: um arquivo PNG normal (*.png) será carregado com uma borda de um pixel
vazia adicionada em torno da imagem, onde você pode delinear os trechos esticáveis e a área do
conteúdo. Um arquivo NinePatch salvo anteriormente (*.[Link]) será carregado da forma em que
está, sem área de desenho adicionada, porque essa área já existe.

Figura 41. Imagem NinePatch mostrando conteúdo, trechos e trechos ruins.

Os controles opcionais são:
• Zoom: ajusta o nível de zoom da imagem na área de desenho.
• Patch scale: ajusta a dimensão das imagens na área de visualização.
• Show lock: exibe a área não desenhável da imagem ao passar o cursor.
• Show patches: mostra os trechos esticáveis na área de desenho (um trecho rosa é esticável),
conforme mostrado na figura 2 acima.
• Show content: destaca a área de conteúdo nas imagens de visualização (a área roxa é a que
pode receber conteúdo), conforme mostrado na figura 2.
• Show bad patches: adiciona uma borda vermelha em torno dos trechos que podem produzir
ruídos ou distorções na imagem quando esticada, conforme mostrado na figura 2. A coerência
visual da imagem esticada será mantida se você eliminar todos os trechos ruins.
Criar imagens WebP
O WebP é um formato de arquivo de imagem do Google que oferece compactação com perda
(como JPEG) e transparência (como PNG), mas pode proporcionar uma compactação melhor que
JPEG ou PNG. Imagens WebP com perda são compatíveis com o Android 4.0 (API de nível 14) e
versões posteriores, e imagens WebP sem perda e transparentes são compatíveis com o Android 4.3
(API de nível 18) e posteriores. Esta página mostra como converter imagens para o formato WebP
e como converter imagens WebP para o formato PNG.
4.3 Programar o app 145

Observação: como a compatibilidade com imagens WebP transparentes e sem perda está dispo-
nível apenas no Android 4.3 e versões posteriores, seu projeto precisa declarar uma minSdkVersion
de 18 ou superior para criar imagens WebP sem perda ou transparentes usando o Android Studio.
Para saber mais sobre o formato de imagem WebP, consulte o site do WebP. Para mais informa-
ções sobre como selecionar o formato de imagem correto para melhorar a velocidade de download,
consulte Reduzir tamanhos de download de imagens.
Converter imagens para WebP
O Android Studio pode converter imagens PNG, JPG, BMP ou GIFs estáticas para o formato
WebP. Você pode converter imagens individuais ou pastas de imagens. Para converter uma imagem
ou pasta de imagens, proceda da seguinte forma:
1. Clique com o botão direito do mouse em um arquivo de imagem ou em uma pasta contendo
vários arquivos de imagens e clique em Convert to WebP.
2. A caixa de diálogo Converting Images to WebP será aberta. As configurações padrão
dependem da configuração minSdkVersion para o módulo atual.

Figura 42. A caixa de diálogo "Converting Images to WebP".

3. Selecione a codificação com ou sem perda. A codificação sem perda só estará disponível se
sua minSdkVersion estiver definida como 18 ou superior. Se você selecionar a codificação
com perda, defina a qualidade da codificação e escolha se quer ou não visualizar cada imagem
convertida antes de salvar.
Você também pode optar por ignorar a conversão de arquivos em que a versão codificada seja
maior que a original ou de arquivos com transparência ou um canal alfa. Como o Android Studio
só permite criar imagens WebP transparentes se sua minSdkVersion estiver definida como 18 ou
superior, a caixa de seleção Skip images with transparency/alpha channel será automaticamente
selecionada se minSdkVersion for inferior a 18.
Observação: arquivos 9-patch não podem ser convertidos para imagens WebP. A ferramenta
de conversão sempre ignora automaticamente imagens 9-patch.
4. Clique em OK para começar a conversão. Se você estiver convertendo mais de uma imagem,
a conversão terá uma única etapa e poderá ser desfeita para reverter todas as imagens
convertidas de uma só vez.
Se você tiver selecionado a conversão sem perda acima, ela será feita imediatamente. Suas
imagens serão convertidas no local original. Se você selecionou conversão com perdas, prossiga
para a próxima etapa.
5. Se você tiver selecionado conversão com perda e optado por visualizar cada imagem conver-
tida antes de salvar, o Android Studio mostrará cada imagem durante a conversão para que
146 Capítulo 4. Ferramentas de Desenvolvimento para Android

você possa inspecionar o resultado. Se você tiver preferido não visualizar, o Android Studio
pulará essa etapa e converterá as imagens imediatamente. Durante a etapa de visualização, é
possível ajustar a configuração de qualidade para cada imagem, conforme descrito abaixo.

Figura 43. Conversão do formato JPG para o WebP com 75% de qualidade.

A Figura 43 mostra a imagem JPG original à esquerda e a imagem WebP codificada com perda
à direita. A caixa de diálogo mostra o tamanho do arquivo da imagem original e da convertida.
Você pode arrastar o controle deslizante para a esquerda ou direita para alterar a configuração de
qualidade e ver imediatamente o efeito na imagem codificada e no tamanho do arquivo.

A área do meio mostra os pixels que são diferentes entre a imagem original e a codificada. Na
Figura 43, com a qualidade configurada como 75%, quase não há diferença entre as duas imagens.
A Figura 44 mostra a mesma imagem codificada com a qualidade definida como 0%.
4.3 Programar o app 147

Figura 44. Conversão do formato JPG para o WebP com 0% de qualidade.

Observação: se você configurar a qualidade como 100% e o minSdkVersion estiver definido

como 18 ou superior, o Android Studio alternará automaticamente para a codificação sem perda.

Selecione uma configuração de qualidade para cada imagem que você revisar. Se você está
convertendo mais de uma imagem, clique em Next para avançar para a próxima.

6. Clique em Finish. Suas imagens serão convertidas no local original.

Converter imagens WebP para PNG

Se você quiser usar uma imagem WebP do seu projeto para outra finalidade (por exemplo, em
uma página da Web que precisa exibir imagens corretamente em um navegador não compatível
com WebP), poderá usar o Android Studio para converter imagens WebP para o formato PNG. Para
converter uma imagem WebP para PNG, proceda da seguinte forma:

1. Clique com o botão direito do mouse em uma imagem WebP no Android Studio e clique em
Convert to PNG.
2. Uma caixa de diálogo será exibida, perguntando se você quer converter a imagem para PNG,
excluindo o arquivo WebP original ou mantendo-o com o novo arquivo PNG. Clique em Yes
para excluir o arquivo WebP original ou em No para manter o arquivo WebP e o arquivo
PNG. Sua imagem será convertida imediatamente.

Localizar a IU com o Translations Editor

O Translations Editor oferece uma visualização consolidada e editável de todos os seus recursos
de string padrão e traduzidos.

Para ver uma introdução sobre como traduzir seu app para diferentes idiomas, leia Compatibili-
dade com diferentes idiomas e culturas.
148 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 45. O Translations Editor mostrando o texto do app antes da tradução.

Recursos de string
Os recursos de string de um projeto estão contidos em arquivos [Link]. Seu projeto tem
um arquivo [Link] padrão que contém recursos de string no idioma padrão do app, aquele que
você espera que a maioria dos usuários fale. Você também pode ter arquivos [Link] traduzidos
que contenham recursos de string para outros idiomas que você quer que seu app acomode.
Depois de concluir o arquivo [Link] padrão, você mesmo poderá adicionar as traduções ou
pagar um serviço profissional para fazê-las. De qualquer forma, você poderá aproveitar os recursos
do Android Studio para gerenciar e testar textos localizáveis. Para saber mais sobre serviços de
tradução profissional, consulte Solicitar serviços de tradução.
Abrir o Translations Editor
Você pode acessar o Translations Editor nos seguintes locais do Android Studio.
Abrir a partir da visualização Android
1. No painel Project > Android à esquerda, selecione ModuleName > res > values.
2. Clique com o botão direito do mouse no arquivo [Link] e selecione Open Translations
Editor.
O Translations Editor exibe os pares de chave-valor do arquivo [Link].
Observação: quando você tem arquivos [Link] traduzidos, seu projeto tem várias pastas
values correspondentes com sufixos indicando o idioma, como values-es para espanhol. Seu arquivo
[Link] padrão fica sempre na pasta values (sem sufixo).
A Figura 1 mostra o texto padrão do app (neste caso, em inglês) no Translations Editor para
um app simples antes do trabalho de tradução. O conteúdo dos arquivos [Link] traduzidos
aparecerá à direita da coluna Untranslatable, com uma coluna por idioma, conforme mostrado na
Figura 46.
Abrir a partir de [Link]
Você pode acessar o Translations Editor a partir de qualquer um dos seus arquivos [Link].
1. No painel Project > Android à esquerda, selecione ModuleName > res > values.
2. Clique duas vezes em [Link] para abrir o arquivo para edição.
3. Em [Link], clique no link Open editor no canto superior direito.
Observação: se você clicar no link Hide notification, o link Open editor desaparecerá. Para
que ele volte a ser exibido, feche e reabra o projeto.
Abrir a partir do Design Editor
Você pode abrir o Translations Editor a partir do Design Editor do Layout Editor para editar o
texto padrão e o traduzido para que se adaptem melhor ao seu layout. Para saber mais sobre como
alternar idiomas no Design Editor, consulte Exibir texto traduzido no Design Editor.
4.3 Programar o app 149

1. No painel Project > Android à esquerda, selecione ModuleName > res > layout.
2. Clique duas vezes em content_main.xml para abrir o arquivo para edição.
3. Clique na guia Design no canto inferior esquerdo para exibir o Design Editor.
4. No Design Editor, selecione a lista suspensa Language .
5. Selecione Edit Translations .
Configurar linhas não traduzíveis
No Translations Editor, você pode selecionar Unstranslatable para indicar que não quer que
o texto da linha em questão seja traduzido. O texto que você não quer que seja traduzido pode ser
um texto específico do produto, como nomes comerciais e marcas registradas, ou termos técnicos
que não tenham tradução.
Quando você marca Untranslatable, a linha correspondente no arquivo [Link] padrão
adiciona translatable="false". No exemplo a seguir, EasyApp na linha superior não é traduzido
porque é o nome do produto.
<resources>
<string name="app_name"translatable="false">EasyApp</string>
<string name="action_settings">Settings</string>
<string name="easy_app">I am a Simple App!</string>
<string name="next_page">Next Page</string>
<string name="second_page_message">I am the Second Page!</string>
<string name="title_activity_second">SecondActivity</string>
</resources>

Adicionar e excluir idiomas

O Translations Editor é compatível com BCP 47 e combina códigos de localidade e região
(país) em uma única seleção para as localizações desejadas. Uma localidade define mais do que o
idioma. Ela inclui a formatação específica do país para itens como data e hora, moedas e decimais.
Para adicionar um idioma, faça o seguinte:

1. No Translations Editor, clique no ícone de globo .

2. Na lista suspensa, selecione o idioma que você quer adicionar.
O novo idioma aparece no Translations Editor, e uma pasta values-* com um arquivo
[Link] é adicionada ao projeto. Por exemplo, values-es para espanhol.
Para excluir um idioma, faça o seguinte:
Você pode excluir um idioma no Translations Editor excluindo todos os valores da coluna
(consulte Editar, adicionar ou excluir texto) ou pode excluir a pasta do projeto referente a esse
idioma, da seguinte maneira:
1. No painel Project > Android à esquerda, selecione ModuleName > res.
2. Clique com o botão direito na pasta values-* do idioma que você quer excluir. Por exemplo,
values-hi para hindi.
3. Na lista suspensa, selecione Delete para excluir a pasta e o respectivo arquivo [Link].
Editar, adicionar e excluir texto
Você pode editar as configurações de texto diretamente no arquivo [Link] ou com o
Translations Editor. Esta seção descreve a abordagem do Translations Editor. No Translations
Editor, é possível editar, adicionar ou excluir texto por meio da visualização em lista ou pelo
campo Translation na parte inferior do Translations Editor.
150 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 46. Visualização em lista na parte superior e o campo Translation na parte inferior.
Visualização em lista
Para editar ou adicionar texto, faça o seguinte:
1. Clique duas vezes na célula em que você quer editar ou adicionar texto.
2. Copie e cole usando os atalhos de teclado ou, se você tem um teclado compatível com
diacríticos (sinais gráficos e de acentuação), digite diretamente na visualização em lista.
3. Use a tecla Tab ou mova o cursor para fora do campo.
Para excluir texto, faça o seguinte:
1. Clique duas vezes na célula que você quer excluir.
2. Na visualização em lista, selecione o texto e pressione Delete.
3. Use a tecla Tab ou mova o cursor para fora do campo.
Campo "Translation"
Para editar ou adicionar texto, faça o seguinte:
1. Na visualização em lista, clique uma vez na célula em que você quer editar ou adicionar
texto.
2. No campo Translation, copie e cole usando os atalhos de teclado ou, se você tem um teclado
compatível com diacríticos (sinais gráficos e de acentuação), digite diretamente no campo
Translation.
3. Use a tecla Tab ou mova o cursor para fora do campo.
Para excluir texto, faça o seguinte:
1. Clique uma vez na célula que você quer excluir.
2. No campo Translation, selecione o texto e pressione Delete.
Adicionar e excluir chaves
No Translations Editor, a coluna Key lista os identificadores exclusivos de cada item de
dados nos arquivos [Link]. Você pode adicionar e excluir chaves usando o Translations Editor.
Quando você exclui uma chave, o Translations Editor também a exclui, junto com todas as traduções
associadas a ela. O Translations Editor usa a refatoração "Safe Delete"para excluir uma chave, para
que você saiba se o texto da chave é usado em outro local e ter a oportunidade de fazer os ajustes
necessários antes de excluir a chave. A refatoração "Safe Delete"garante que seu código ainda seja
compilado depois que você excluir a chave.
Para adicionar uma chave, faça o seguinte:

1. No Translations Editor, clique em Add Key .

2. Na caixa de diálogo, digite um nome de chave, o valor padrão e a localização do arquivo
[Link] padrão.
4.3 Programar o app 151

Figura 47. Adicionar uma chave.

Para excluir uma chave, faça o seguinte:
1. No Translations Editor, selecione a chave que você quer excluir.
2. Clique em Remove Keys .
3. Na caixa de diálogo Delete, decida se quer uma exclusão segura e se quer pesquisar em
comentários e strings e clique em OK.

Figura 48. Caixa de diálogo "Delete".

Se não houver referências (usos) à chave excluída ou se todas as referências puderem ser
recolhidas com segurança, a chave será excluída. Caso contrário, o "Translations Editor"exibirá a
caixa de diálogo Usages Detected com informações sobre os problemas detectados.

Figura 49. Caixa de diálogo "Delete".

4. Selecione View Usages para revisar o que será excluído. A caixa de diálogo Find Safe
Delete Conflicts mostra todos os usos que não é seguro excluir, para que você possa editar o
152 Capítulo 4. Ferramentas de Desenvolvimento para Android

código correspondente.

Figura 50. Usos inseguros.

5. Clique com o botão direito do mouse em um uso para exibir o menu de contexto e selecione
Jump to Source para fazer as alterações necessárias.
6. No painel Find Safe Delete Conflicts, selecione Rerun Safe Delete para garantir que não
haja outros usos que precisem de atenção.
7. Quando os usos forem apagados, clique em Do Refactor para excluir a chave.
Corrigir erros
A Figura 51 mostra o Translations Editor exibindo o conteúdo dos arquivos [Link] em
inglês, espanhol e francês. O texto em vermelho indica linhas com erros.

Figura 51. Texto em vermelho indica uma condição de erro que precisa ser corrigido.
Para corrigir um erro, passe o mouse sobre o texto em vermelho para exibir uma explicação do
problema e a respectiva resolução.
Ao fazer mudanças no Translations Editor, os arquivos [Link] subjacentes serão atualiza-
dos com essas mudanças. Quando você mudar um arquivo [Link], a coluna correspondente no
Translations Editor será atualizada.
Exemplo de correções do Translations Editor:
• A Figura 51 mostra que a linha app_name está com a opção Untranslatable marcada, mas
há uma tradução em espanhol na linha. Exclua a tradução em espanhol para corrigir o erro.
• A Figura 51 mostra que a linha next_page está sem tradução em francês. Use o teclado
para copiar Page Suivante na célula para corrigir o erro. Uma operação de copiar e colar no
teclado copia o texto com os diacríticos para a célula.
Exibir texto traduzido no Design Editor
Para ver como o texto traduzido será exibido no layout do app, alterne o texto entre as versões
padrão e traduzidas no Design Editor, da seguinte maneira:
1. No painel Project > Android à esquerda, selecione ModuleName > res > layout.
2. Clique duas vezes em content_main.xml para abrir o arquivo para edição.
3. Clique na guia Design no canto inferior esquerdo para exibir o Design Editor.
4. No Design Editor, selecione a lista suspensa Language .
5. Selecione Edit Translations .
4.3 Programar o app 153

6. Selecione o idioma que você quer usar para ver o app.

Figura 52. Lista suspensa de idiomas com espanhol selecionado.

O Design Editor exibe o layout do app no idioma selecionado, que nesse caso é o espanhol.

Figura 53. O Design Editor exibe o texto traduzido em espanhol.

Configurar o Design Editor para o idioma padrão
Para restaurar o idioma para o padrão, selecione es > Language .

Figura 54. Configurar para o idioma padrão.

Gerenciar e testar texto localizável
A plataforma Android e o Android Studio oferecem vários recursos para ajudar a gerenciar e
testar o texto localizável do app. Esses recursos têm opções para ajudar a lidar com problemas
com scripts da direita para a esquerda (RTL), como árabe ou hebraico. Testar seu texto localizável
permite fazer mudanças no texto da IU e no layout antes de confirmar suas mensagens para o
repositório de origem para serem enviadas para tradução posteriormente.
Refatorar seu projeto para compatibilidade com RTL
O Android Studio tem um comando de refatoração que é compatível com texto bidirecional nos
elementos TextView, ConstraintLayout e LinearLayout. Isso permite que seus apps exibam texto
em scripts da esquerda para a direita (LTR, na sigla em inglês) e da direita para a esquerda (RTL, na
sigla em inglês) e que os usuários editem esses textos. O comando também oferece espelhamento
automático de layouts de IU do app e de todos os widgets de visualização. Para ver a mudança
de direção do texto e o espelhamento de layout, você também precisa definir as propriedades de
154 Capítulo 4. Ferramentas de Desenvolvimento para Android

direção de texto e layout no Layout Editor.

O procedimento a seguir mostra como refatorar seu projeto para que seja compatível com RTL:
1. Selecione Refactor Add RTL support where possible para exibir a caixa de diálogo mos-
trada na Figura 55.

Figura 55. Adicionar compatibilidade com RTL.

• Se o elemento <application> no seu arquivo [Link] não tiver o atributo
android:supportsRTL="true", marque a caixa de seleção Update [Link].
• Se a targetSdkVersion do app for 17 ou posterior, selecione Replace Left/Right Properties
with Start/End Properties. Nesse caso, suas propriedades precisam usar "start"e "end", em
vez de "left"e "right". Por exemplo, android:paddingLeft torna-se android:paddingStart.
• Se a targetSdkVersion do app for 16 ou anterior, selecione Generate -v17 Versions. Nesse
caso, o XML precisa usar os dois conjuntos de propriedades. Por exemplo, seu XML precisa
usar android:paddingLeft e android:paddingStart.
2. Para exibir a janela Find Refactoring Preview, clique em Run.

Figura 56. Verificar a visualização.

3. Clique em Do Refactor.
Para saber mais sobre como refatorar seu projeto para compatibilidade com RTL, consulte
Compatibilidade nativa com RTL no Android 4.2 (link em inglês).
Propriedades de direção de texto e layout
A janela "Properties"à direita oferece a propriedade textDirection para ser usada com widgets
de texto e a propriedade layoutDirection para ser usada com widgets de layout para alterar a
direção dos componentes de texto e layout. As propriedades de direção são listadas na janela
Properties à direita e funcionam com API de nível 17 ou posterior.
Para ver a mudança da direção do texto e o espelhamento de layout, você também precisa
refatorar o projeto para que seja compatível com RTL. Em inglês, a mudança de direção do texto
move apenas a pontuação do lado direito para o lado esquerdo do texto: por exemplo, "Hello
World!"se torna "!Hello World". Para ver a mudança de texto de LTR para RTL, é necessário usar
4.3 Programar o app 155

uma linguagem RTL no seu app. Se você quiser usar o inglês e ver o texto alternar para RTL
para fins de teste, use pseudolocalidades. Pseudolocalidades são independentes do comando de
refatoração e das propriedades de direção.
Para acessar e usar as propriedades de direção, faça o seguinte:
1. No Layout Editor, selecione um widget de texto.
2. Abra a janela Properties e procure a propriedade RTL que você quer usar.
Para configurar o valor da propriedade, selecione um dos seguintes:
• firstStrong: padrão para a visualização raiz. O primeiro caractere direcional forte determina
a direção do parágrafo. Se não houver um caractere direcional forte, a direção do parágrafo
será a direção do layout da visualização.
• anyRtl: a direção do parágrafo será RTL se contiver algum caractere RTL forte e será LTR
se contiver algum caractere LTR forte. Se não houver nenhum, a direção do parágrafo será a
direção de layout resolvida da visualização.
• ltr: a direção do parágrafo é LTR.
• rtl: a direção do parágrafo é RTL.
• locale: a direção do parágrafo vem da localidade do sistema.
• inherit: padrão. Use a direção definida no pai.
Observação: caracteres direcionais fortes têm a própria direção predefinida, por exemplo, a
maioria dos caracteres alfabéticos e silábicos, dígitos não europeus e não árabes, ideogramas Han e
caracteres de pontuação específicos desses scripts.
3. Para revisar o texto e o layout invertidos, execute o app.
Pseudolocalidades
Uma pseudolocalidade é uma localidade simulada projetada para assumir as características de
idiomas que causam problemas de IU, layout, RTL e outros quando um aplicativo é traduzido. As
pseudolocalidades oferecem traduções instantâneas e automáticas que podem ser lidas em inglês
para todas as mensagens localizáveis. Isso possibilita que você detecte mensagens não traduzíveis
no código-fonte.
Para saber mais sobre como usar pseudolocalidades, consulte Testar seu app com pseudolocali-
dades.
Adicionar Android App Links
Android App Links são URLs HTTP que direcionam os usuários diretamente a um conteúdo
específico no seu app para Android. Os Android App Links podem direcionar mais tráfego para
seu app, ajudar você a descobrir qual conteúdo é mais usado e facilitar o compartilhamento e a
localização de conteúdo em um app instalado.
Para adicionar compatibilidade com Android App Links:
1. Crie filtros de intent no seu manifesto.
2. Adicione o código às atividades do seu app para lidar com links de entrada.
3. Associe o app e o site a Digital Asset Links.
O App Links Assistant, no Android Studio 2.3 e versões mais recentes, simplifica o processo
com um assistente passo a passo, conforme descrito abaixo.
Para mais informações sobre como os links de apps funcionam e os benefícios que eles oferecem,
leia Processar Android App Links.
Adicionar filtros de intent
O App Links Assistant no Android Studio pode ajudar a criar filtros de intent no manifesto e
mapear URLs existentes do site para atividades no app. O App Links Assistant também adiciona o
código Java do modelo em cada atividade correspondente para processar o intent.
Para adicionar filtros de intent e processamento de URL, siga estas etapas:
1. Selecione Tools > App Links Assistant.
156 Capítulo 4. Ferramentas de Desenvolvimento para Android

2. Clique em Open URL Mapping Editor e, em seguida, clique em Add no final da lista
do URL Mapping para adicionar um novo mapeamento de URL.
3. Adicione detalhes do novo mapeamento de URL:

Figura 57. Adicione detalhes básicos sobre a estrutura de links do site para mapear URLs para
atividades no app.
1. Insira o URL do site no campo Host.
2. Adicione um path, pathPrefix ou pathPattern para os URLs que você quer mapear. Por
exemplo, se você tiver um app de compartilhamento de receitas, com todas as receitas dispo-
níveis na mesma atividade, e as receitas do site correspondente estiverem todas no mesmo
diretório /recipe, use pathPrefix e insira /recipe. Dessa forma, o URL [Link]
[Link]/recipe/grilled-potato-salad será mapeado para a atividade selecionada na etapa a
seguir.
3. Selecione a Activity (atividade) para a qual os URLs levarão os usuários.
4. Clique em OK.
4. O App Links Assistant adiciona filtros de intent com base no mapeamento de URL ao arquivo
[Link] e o destaca no campo Preview. Se você quiser fazer mudanças, clique
em Open [Link] para editar o filtro de intent. Saiba mais sobre os filtros de
intent no Android.
Observação: para que mais links funcionem sem que o app seja atualizado, é preciso definir
um mapeamento que seja compatível com URLs que serão adicionados no futuro. Além disso,
lembre-se de incluir um URL na tela inicial do app para que ele seja incluído nos resultados da
pesquisa.
5. Para verificar se o mapeamento de URLs funciona corretamente, insira um URL no campo
Check URL Mapping e clique em Check Mapping. Se estiver funcionando corretamente,
a mensagem de êxito mostrará que o URL que você inseriu será mapeado para a atividade
selecionada.
Gerenciar links de entrada
Depois de verificar se o mapeamento de URLs está funcionando corretamente, adicione uma
lógica para processar o intent criado.
1. Clique em Select Activity no App Links Assistant.
2. Selecione uma atividade na lista e clique em Insert Code.
O App Links Assistant adiciona código ao arquivo Java da sua atividade, semelhante ao que se
segue. Observe que, atualmente, o App Links Assistant não é compatível com Kotlin, portanto,
será necessário adicionar esse código manualmente.
KotlinJava
override fun onCreate(savedInstanceState: Bundle?) {
[Link](savedInstanceState)
4.3 Programar o app 157

val appLinkIntent = intent

val appLinkAction = [Link]
val appLinkData = [Link]

No entanto, esse código não está completo por si só. Agora, você precisa realizar uma ação
com base no URI em appLinkData, como exibir o conteúdo correspondente. Por exemplo, para o
app de compartilhamento de receitas, seu código pode se parecer com o exemplo a seguir:

KotlinJava

override fun onCreate(savedInstanceState: Bundle?) {

[Link](savedInstanceState)
...
handleIntent(intent)
}

override fun onNewIntent(intent: Intent) {

[Link](intent)
handleIntent(intent)
}

private fun handleIntent(intent: Intent) {

val appLinkAction = [Link]
val appLinkData: Uri? = [Link]
if (Intent.ACTION_VIEW == appLinkAction) {
appLinkData?.lastPathSegment?.also { recipeId ->
[Link]("content://com.recipe_app/recipe/")
.buildUpon()
.appendPath(recipeId)
.build().also { appData ->
showRecipe(appData)
}
}
}
}

Associar o app ao site

Depois de configurar a compatibilidade de URLs para o app, o App Links Assistant gera um
arquivo Digital Asset Links que você pode usar para associar o site ao app.

Como alternativa ao uso do arquivo Digital Asset Links, você pode associar seu site e app no
Search Console.

Para associar o app e o site usando o App Links Assistant, clique em Open Digital Asset
Links File Generator no App Links Assistant e siga estas etapas:
158 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 58. Insira detalhes sobre o site e o app para gerar um arquivo Digital Asset Links.
1. Informe o Site domain e o Application ID.
2. Para incluir compatibilidade no arquivo Digital Asset Links do Smart Lock para senhas
(link em inglês), selecione a opção Support sharing credentials between the app and the
website e digite o URL de login do seu site. Isso adiciona a seguinte string ao arquivo
Digital Asset Links, declarando que o app e o site compartilham credenciais de login: dele-
gate_permission/common.get_login_creds. Saiba mais sobre como oferecer compatibilidade
com o Smart Lock para senhas (link em inglês) no seu app.
3. Especifique a configuração de assinatura ou selecione um arquivo de keystore. Você precisa
selecionar o arquivo de configuração ou keystore apropriado para a compilação de versão
final ou de depuração do app. Se você quiser configurar a compilação de produção, use a
configuração da versão final. Se você quiser testar sua compilação, use a configuração de
depuração.
4. Clique em Generate Digital Asset Links file.
5. Depois que o Android Studio gerar o arquivo, clique em Save file para fazer o download
dele.
6. Faça upload do arquivo [Link] para seu site, com acesso de leitura para todos, em
[Link]
Importante: o sistema verifica o arquivo Digital Asset Links por meio do protocolo HTTPS
4.3 Programar o app 159

criptografado. Verifique se o arquivo [Link] está acessível por meio de uma conexão
HTTPS, independentemente de o filtro de intent do app incluir https.
7. Clique em Link and Verify para confirmar que você fez upload do arquivo Digital Asset
Links correto para o local correspondente.
Saiba mais sobre como associar o site ao app por meio do arquivo Digital Asset Links em
Declarar associações de sites.
Testar os links do app
Para verificar se os links abrem a atividade correta, siga estas etapas:
1. Clique em Test App Links no App Links Assistant.
2. Digite o URL que você quer testar no campo URL, por exemplo, [Link]
potato-salad.

Figura 59. O App Links Assistant exibe uma mensagem de êxito e abre o app no conteúdo
especificado quando o URL que você está testando é mapeado para uma atividade no app.
3. Clique em Run Test.
4. Se o mapeamento de URL não estiver configurado corretamente ou não existir, será exibida
uma mensagem de erro sob o URL na janela Test App Links. Se o mapeamento de URL
existir, o Android Studio iniciará o app no dispositivo ou emulador na atividade especificada,
sem exibir a caixa de diálogo de desambiguação ("seletor"do app), e mostrará uma mensagem
de êxito na janela do App Link Testing. Se o Android Studio não conseguir iniciar o app,
uma mensagem de erro será exibida na janela Run do Android Studio.
Para testar o Android App Links por meio do App Links Assistant, você precisa ter um
dispositivo conectado ou um dispositivo virtual disponível com o Android 6.0 (API de nível 23) ou
versão mais recente. Para mais informações, veja como conectar um dispositivo ou criar um AVD.
Adicionar indexação de apps do Firebase
Depois de adicionar os Android App Links ao seu app, você pode adicionar o código de
indexação de apps do Firebase a uma atividade para conseguir um novo engajamento com o app a
partir de outros recursos da Pesquisa Google, incluindo sugestões de preenchimento automático e
pesquisa dentro de apps. Saiba mais na documentação de Indexação de apps do Firebase.
Para adicionar a indexação de apps do Firebase ao app, use o Firebase Assistente no Android
Studio e expanda a seção App Indexing para ver instruções passo a passo.
Conectar-se ao Firebase
160 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 60. A janela da ferramenta Assistant no Android Studio.

O Firebase é uma plataforma móvel que ajuda a desenvolver aplicativos de alta qualidade,
expandir sua base de usuários e lucrar mais. O Firebase é composto de recursos complementares
que você pode combinar de acordo com suas necessidades, sendo o Google Analytics para Firebase
o principal. Você pode explorar e integrar serviços do Firebase no seu aplicativo diretamente do
Android Studio usando a janela Assistant mostrada na Figura 60.
Primeiro, verifique se você instalou o Google Repository versão 26 ou posterior realizando as
seguintes etapas:
1. Clique em Tools > SDK Manager.
2. Clique na guia SDK Tools.
3. Marque a caixa de seleção do Google Repository e clique em OK.
4. Clique em OK para instalar.
5. Clique em Background para concluir a instalação em segundo plano ou aguarde a conclusão
da instalação e clique em Finish.
Agora, você pode abrir e usar a janela do Assistant no Android Studio seguindo estas etapas:
1. Clique em Tools > Firebase para abrir a janela Assistant.
4.3 Programar o app 161

2. Clique para expandir um dos recursos listados (por exemplo, o "Analytics") e, em seguida,
clique no tutorial Get Started para se conectar ao Firebase e adicionar o código necessário
ao seu aplicativo.
Para mais informações sobre como usar os serviços do Firebase, consulte a documentação do
Firebase.
Melhorar seu código com verificações de lint
Além de garantir que seu app atenda aos requisitos funcionais compilando testes, é importante
saber se o código tem problemas estruturais, executando-o com lint. A ferramenta lint ajuda a
encontrar códigos com estrutura ineficiente que podem afetar a confiabilidade e eficiência dos seus
apps Android e dificultar a manutenção do código.
Por exemplo, arquivos de recursos XML com namespaces não utilizados desperdiçam espaço e
processamento. Outros problemas estruturais, como o uso de elementos obsoletos ou chamadas de
API incompatíveis com as versões visadas da API, podem causar falhas na execução do código. O
lint pode ajudar você a acabar com esses problemas.
Para melhorar ainda mais o desempenho do lint, adicione anotações ao código.
Visão geral
O Android Studio oferece uma ferramenta de verificação de código denominada lint para ajudar
a identificar e corrigir problemas com a qualidade estrutural do código, sem executar o app nem
programar casos de teste. Cada problema detectado pela ferramenta é relatado com uma mensa-
gem descritiva e um nível de gravidade, permitindo priorizar rapidamente quais aprimoramentos
essenciais são necessários. Além disso, você pode reduzir o nível de gravidade dos problemas para
ignorar aqueles que não são relevantes para o projeto, bem como aumentar esse nível para destacar
problemas específicos.
A ferramenta lint verifica os arquivos de origem do projeto Android para localizar possíveis bugs
e melhorias de otimização em relação a critérios de precisão, segurança, desempenho, usabilidade,
acessibilidade e internacionalização. Ao usar o Android Studio, as inspeções configuradas de lint
e do ambiente de desenvolvimento integrado são executadas sempre que você cria seu app. No
entanto, você pode executar inspeções manualmente ou executar o lint na linha de comando.
Observação: quando o código é compilado no Android Studio, outras inspeções de código do
IntelliJ são executadas para otimizar a análise do código.
A Figura 61 mostra como a ferramenta lint processa os arquivos de origem do app.

Figura 61. Fluxo de trabalho da verificação de código com a ferramenta lint.

Arquivos de origem do app
Os arquivos de origem consistem emarquivos que compõem o projeto Android, incluindo
arquivos Java, Kotlin e XML, ícones e arquivos de configuração do ProGuard.
O arquivo [Link]
162 Capítulo 4. Ferramentas de Desenvolvimento para Android

Um arquivo de configuração usado para especificar todas as verificações do lint que você quer
excluir e para personalizar os níveis de gravidade dos problemas.
Ferramenta lint
Uma ferramenta de verificação de código estático que pode ser executada no projeto Android na
linha de comando ou no Android Studio (consulte Executar inspeções manualmente). A ferramenta
lint verifica a existência de problemas estruturais no código que possam afetar a qualidade e o
desempenho de um aplicativo Android. É altamente recomendável que você corrija todos os erros
detectados pelo lint antes de publicar o aplicativo.
Resultados da verificação do lint
Os resultados do lint podem ser vistos no console ou na janela Inspection Results do Android
Studio. Consulte Executar inspeções manualmente.
Executar o lint na linha de comando
Se você está usando o Android Studio ou o Gradle, use o wrapper do Gradle para invocar a
tarefa lint do seu projeto inserindo um dos seguintes comandos no diretório raiz do seu projeto:
• No Windows:
• gradlew lint
No Linux ou Mac:
./gradlew lint
O resultado será semelhante ao seguinte:
> Task :app:lint
Ran lint on variant release: 5 issues found
Ran lint on variant debug: 5 issues found
Wrote HTML report to file:<path-to-project>/app/build/reports/[Link]
Wrote XML report to file:<path-to-project>/app/build/reports/[Link]
Quando a ferramenta lint conclui a verificação, ela informa caminhos para as versões XML e
HTML do relatório. Você pode navegar até o relatório em HTML e abri-lo no navegador, conforme
mostrado na Figura 62.

Figura 62. Exemplo de relatório do lint em HTML.

Se seu projeto incluir variantes de compilação e você quiser executar a tarefa lint apenas para
4.3 Programar o app 163

uma determinada variante, converta a primeira letra do nome da variante em maiúscula e acrescente
o prefixo lint.
gradlew lintDebug
Para saber mais sobre como executar tarefas do Gradle na linha de comando, consulte Compilar
seu app na linha de comando.
Executar o lint com a ferramenta autônoma
Se você não está usando o Android Studio ou o Gradle, use a ferramenta autônoma do lint
depois de instalar as Ferramentas do SDK do Android do SDK Manager. Em seguida, localize a
ferramenta lint no diretório android_sdk/tools/.
Para executar o lint em uma lista de arquivos em um diretório de projeto, use o seguinte
comando:
lint [flags] <project directory>
Por exemplo, você pode emitir o comando a seguir para verificar os arquivos no diretório
myproject e nos subdiretórios. O ID de problema MissingPrefix indica que o lint verifique apenas a
existência de atributos XML sem o prefixo de namespace Android.
lint --check MissingPrefix myproject
Para ver a lista completa de sinalizadores e argumentos da linha de comando compatíveis com
a ferramenta, use este comando:
lint --help
O exemplo a seguir mostra a saída do console quando o comando do lint é executado em um
projeto denominado Earthquake.
$ lint Earthquake
Scanning Earthquake: ...............................................................................................................................
Scanning Earthquake (Phase 2): .......
[Link]: Warning: <uses-sdk> tag appears after <application> tag [Manifes-
tOrder]
<uses-sdk android:minSdkVersion="7"/>
ˆ
[Link]: Warning: <uses-sdk> tag should specify a target API level (the
highest verified version; when running on later versions, compatibility behaviors may be enabled)
with android:targetSdkVersion="?"[UsesMinSdkAttributes]
<uses-sdk android:minSdkVersion="7"/>
ˆ
res/layout/[Link]: Warning: The resource [Link] appears to be unused
[UnusedResources]
res: Warning: Missing density variation folders in res: drawable-xhdpi [IconMissingDensity-
Folder]
0 errors, 4 warnings
A saída acima lista quatro avisos e nenhum erro: três avisos (ManifestOrder, UsesMinSdkAttri-
butes e UnusedResources) no arquivo [Link] do projeto e um aviso (IconMissing-
DensityFolder) no arquivo de layout [Link].
Configurar o lint para suprimir alertas
Por padrão, quando você executa uma verificação do lint, a ferramenta procura todos os
problemas compatíveis com ela. Também é possível restringir os problemas verificados pelo lint
e atribuir níveis de gravidade a eles. Por exemplo, você pode suprimir a verificação do lint para
problemas específicos que não são relevantes para o projeto, bem como configurar o lint para relatar
problemas não críticos com um nível mais baixo de gravidade.
A verificação do lint pode ser configurada para níveis diferentes:
• Globalmente (todo o projeto)
164 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Módulo do projeto
• Módulo de produção
• Módulo de teste
• Arquivos abertos
• Hierarquia de classe
• Escopos do sistema de controle de versões (VCS, na sigla em inglês)
Configurar o lint no Android Studio
A ferramenta incorporada lint verifica o código enquanto você usa o Android Studio. Os avisos
e erros podem ser visualizados de duas formas:
• Como texto em uma janela pop-up no Code Editor. Quando o lint encontra um problema,
a ferramenta destaca o código problemático em amarelo ou, para problemas mais graves,
sublinha o código em vermelho.
• Na janela Inspection Results do lint, depois de clicar em Analyze > Inspect Code. Consulte
Executar inspeções manualmente.
Configurar o arquivo do lint
Especifique as preferências de verificação do lint no arquivo [Link]. Se você estiver criando
esse arquivo manualmente, coloque-o no diretório raiz do projeto Android.
O arquivo [Link] consiste em uma tag pai <lint> que abrange um ou mais elementos filhos
<issue>. O lint define um valor de atributo id exclusivo para cada <issue>.
<?xml version="1.0"encoding="UTF-8"?>
<lint>
<!-- list of issues to configure -->
</lint>

Você pode alterar o nível de gravidade ou desativar a verificação do lint para um problema
definindo o atributo de gravidade na tag <issue>.
Dica: para ver uma lista completa dos problemas detectados pelo lint e seus IDs corresponden-
tes, execute o comando lint --list.
Exemplo de arquivo [Link]
O exemplo a seguir mostra o conteúdo de um arquivo [Link].
<?xml version="1.0"encoding="UTF-8"?>
<lint>
<!-- Disable the given check in this project -->
<issue id="IconMissingDensityFolder"severity="ignore"/>

<!-- Ignore the ObsoleteLayoutParam issue in the specified files -->

<issue id="ObsoleteLayoutParam">
<ignore path="res/layout/[Link]"/>
<ignore path="res/layout-xlarge/[Link]"/>
</issue>

<!-- Ignore the UselessLeaf issue in the specified file -->

<issue id="UselessLeaf">
<ignore path="res/layout/[Link]"/>
</issue>

<!-- Change the severity of hardcoded strings to "error-->

<issue id="HardcodedText"severity="error"/>
</lint>
4.3 Programar o app 165

Configurar a verificação do lint para arquivos de origem Java, Kotlin e XML

É possível desativar a verificação do lint para arquivos de origem Java, Kotlin e XML.
Dica: gerencie o recurso de verificação do lint para arquivos de origem Java, Kotlin ou XML
na caixa de diálogo Default Preferences. Selecione File > Other Settings > Default Settings e, no
painel à esquerda da caixa de diálogo Default Preferences, selecione Editor > Inspections.
Como configurar a verificação do lint em Java ou Kotlin
Para desativar a verificação do lint para uma classe ou um método específico do seu projeto
Android, adicione a anotação @SuppressLint ao código.
O exemplo a seguir mostra como desativar a verificação do lint para o problema NewApi no
método onCreate. A ferramenta lint continuará verificando a existência do problema NewApi em
outros métodos dessa classe.
KotlinJava
@SuppressLint("NewApi")
override fun onCreate(savedInstanceState: Bundle?) {
[Link](savedInstanceState)
setContentView([Link])

O exemplo a seguir mostra como desativar a verificação do lint para o problema ParserError na
classe FeedProvider:
KotlinJava
@SuppressLint("ParserError")
class FeedProvider : ContentProvider() {

Para suprimir a verificação de todos os problemas do lint no arquivo, use a palavra-chave all, da
seguinte forma:
KotlinJava
@SuppressLint("all")

Como configurar a verificação do lint em XML

Use o atributo tools:ignore para desativar a verificação do lint para seções específicas de
arquivos XML. Coloque o valor de namespace a seguir no arquivo [Link] para que a ferramenta
lint reconheça o atributo:
namespace xmlns:tools="[Link]

O exemplo a seguir mostra como desativar a verificação do lint para o problema UnusedResour-
ces no elemento <LinearLayout> de um arquivo de layout XML. O atributo ignore é herdado pelos
elementos filhos do elemento pai em que o atributo é declarado. Nesse exemplo, a verificação do
lint para o elemento filho <TextView> também é desativada.
<LinearLayout
xmlns:android="[Link]
xmlns:tools="[Link]
tools:ignore="UnusedResources">

<TextView
android:text="@string/auto_update_prompt"/>
</LinearLayout>
166 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para desativar mais de um problema, relacione aqueles que você quer desativar em uma string
separada por vírgulas. Por exemplo:
tools:ignore="NewApi,StringFormatInvalid"

Para suprimir a verificação de todos os problemas do lint no elemento XML, use a palavra-chave
all, da seguinte forma:
tools:ignore="all"

Configurar opções do lint com o Gradle

O plug-in do Android para Gradle permite configurar algumas opções do lint, por exemplo, quais
verificações serão executadas ou ignoradas, usando o bloco lintOptions {} no arquivo [Link]
do módulo. O snippet de código a seguir mostra algumas propriedades que podem ser configuradas.
android {
...
lintOptions {
// Turns off checks for the issue IDs you specify.
disable ’TypographyFractions’,’TypographyQuotes’
// Turns on checks for the issue IDs you specify. These checks are in
// addition to the default lint checks.
enable ’RtlHardcoded’,’RtlCompat’, ’RtlEnabled’
// To enable checks for only a subset of issue IDs and ignore all others,
// list the issue IDs with the ’check’ property instead. This property overrides
// any issue IDs you enable or disable using the properties above.
check ’NewApi’, ’InlinedApi’
// If set to true, turns off analysis progress reporting by lint.
quiet true
// if set to true (default), stops the build if errors are found.
abortOnError false
// if true, only report errors.
ignoreWarnings true
}
}
...

Criar valores de referência de alertas

Você pode capturar um instantâneo do conjunto atual de alertas do projeto e usar essa captura
como valor de referência para futuras execuções de inspeção. Assim, apenas novos problemas
serão relatados. O instantâneo como valor de referência permite que você comece a usar o lint
para indicar falha na compilação sem ter que voltar atrás e resolver todos os problemas existentes
primeiro.
Para criar um instantâneo como valor de referência, modifique o arquivo [Link] do projeto
da seguinte maneira:
android {
lintOptions {
baseline file("[Link]")
}
}

Quando você adiciona essa linha pela primeira vez, o arquivo [Link] é criado para
4.3 Programar o app 167

estabelecer o valor de referência. A partir desse momento, as ferramentas lerão o arquivo apenas
para determinar o valor de referência. Se você quiser criar um novo valor de referência, exclua
manualmente o arquivo e execute o lint novamente para recriá-lo.
Em seguida, execute o lint no ambiente de desenvolvimento integrado (Analyze > Inspect
Code) ou na linha de comando, conforme mostrado a seguir. A saída imprime a localização do
arquivo [Link]. O local do arquivo na sua configuração pode ser diferente daquele que é
mostrado aqui.
$ ./gradlew lintDebug
...
Wrote XML report to [Link]
Created baseline file /app/[Link]
A execução de lint registra todos os problemas atuais no arquivo [Link]. O conjunto
de problemas atuais é chamado de valor de referência, e você poderá verificar o arquivo lint-
[Link] no controle de versões se quiser compartilhá-lo com outras pessoas.
Personalizar o valor de referência
Se você quer adicionar alguns tipos de problemas, mas não todos, ao valor de referência,
é possível especificar os problemas a serem adicionados editando o [Link] do projeto da
seguinte maneira:
android {
lintOptions {
check ’NewApi’, ’HandlerLeak’
baseline file("[Link]")
}
}

Depois de criar o valor de referência, se você adicionar qualquer alerta novo ao codebase, o lint
listará apenas os bugs recém-introduzidos.
Alerta de valor de referência
Quando os valores de referência estiverem em vigor, você receberá um alerta informando que
um ou mais problemas foram filtrados porque já estavam listados no valor de referência. O objetivo
desse alerta é ajudar você a se lembrar de que configurou um valor de referência, porque gostaria
de corrigir todos os problemas em algum momento.
Esse alerta não mostra apenas o número exato de erros e alertas que foram filtrados, mas
também monitora os problemas que não são mais relatados. Essas informações indicam se você
realmente corrigiu os problemas. Assim você pode recriar o valor de referência para evitar que o
erro volte sem ser detectado.
Observação: valores de referência são ativados quando você executa inspeções no modo de
lote no ambiente de desenvolvimento integrado, mas eles são ignorados pelas verificações no editor
executadas em segundo plano quando você está editando um arquivo. Isso acontece porque os
valores de referência destinam-se aos casos em que um codebase tem um grande número de alertas,
mas você quer corrigir os problemas localmente enquanto trabalha no código.
Executar manualmente inspeções
Execute manualmente inspeções configuradas do lint e outras inspeções do ambiente de de-
senvolvimento integrado selecionando Analyze > Inspect Code. Os resultados da inspeção são
exibidos na janela Inspection Results.
Definir escopo e perfil da inspeção
Selecione os arquivos que você quer analisar (escopo da inspeção) e as inspeções que serão
executadas (perfil de inspeção), da seguinte forma:
168 Capítulo 4. Ferramentas de Desenvolvimento para Android

1. Na visualização Android, abra o projeto e selecione ele mesmo, uma pasta ou um arquivo
para analisar.
2. Na barra de menus, selecione Analyze Inspect Code .
3. Na caixa de diálogo Specify Inspection Scope, revise as configurações.

Figura 63. Revise as configurações do escopo da inspeção.

A combinação de opções exibida na caixa de diálogo Specify Inspection Scope varia de acordo
com o item selecionado, ou seja, se ele é um projeto, uma pasta ou um arquivo. É possível alterar
o objeto da inspeção selecionando um dos outros botões de opção. Consulte a caixa de diálogo
Specify Inspection Scope para ver uma descrição de todos os campos possíveis na caixa de diálogo
Specify Inspection Scope.
• Quando você seleciona um projeto, arquivo ou diretório, a caixa de diálogo Specify Inspec-
tion Scope exibe o caminho para o Project, File ou Directory selecionado.
• Quando você seleciona mais de um projeto, arquivo ou diretório, a caixa de diálogo Specify
Inspection Scope exibe um botão de opção marcado para Selected files.
4. Em Inspection profile, mantenha o perfil padrão (Project Default).
5. Clique em OK para executar a inspeção. A Figura 64 mostra os resultados do lint e de outras
inspeções do ambiente de desenvolvimento integrado gerados pela execução de Inspect
Code:

Figura 64. Selecione um problema para ver a resolução.

6. Na visualização em árvore no painel à esquerda, veja os resultados da inspeção ampliando e
selecionado categorias de erro, tipos e problemas.
O painel à direita exibe o relatório de inspeção para a categoria de erro, tipo ou problema
selecionado e informa o nome e a localização do erro. Se for o caso, o relatório de inspeção exibirá
outras informações, como um resumo do problema, para ajudar na correção.
7. Na visualização em árvore no painel à esquerda, clique com o botão direito em uma categoria,
tipo ou problema para exibir o menu de contexto.
Dependendo do contexto, é possível realizar algumas ou todas estas ações: ir para a origem,
excluir e incluir itens selecionados, suprimir problemas, editar configurações, gerenciar alertas de
4.3 Programar o app 169

inspeção e executar uma inspeção novamente.

Para ver descrições dos botões da barra de ferramentas à esquerda, dos itens do menu de
contexto e dos campos do relatório de inspeção, consulte Janela da ferramenta de inspeção.
Usar um escopo personalizado
Você pode usar um dos escopos personalizados fornecidos no Android Studio da seguinte
forma:
1. Na caixa de diálogo Specify Inspection Scope, clique em Custom scope.
2. Clique na lista suspensa Custom scope para exibir as opções.

Figura 65. Selecione o escopo personalizado que você quer usar.

• Project Files: todos os arquivos do projeto atual.
• Project Production Files: somente os arquivos de produção do projeto atual.
• Project Test Files: somente os arquivos de teste do projeto atual. Consulte Tipos e localiza-
ção de testes.
• Open Files: somente os arquivos abertos do projeto atual.
• Module <seu-módulo>: somente os arquivos da pasta do módulo correspondente do projeto
atual.
• Current File: somente o arquivo atual do projeto atual. Exibido quando você seleciona um
arquivo ou uma pasta.
• Class Hierarchy: quando você seleciona este escopo e clica em OK, uma caixa de diálogo é
exibida com todas as classes do projeto atual. Use o campo Search by Name da caixa de
diálogo para filtrar e selecionar as classes a serem inspecionadas. Se você não filtrar a lista
de classes, a inspeção do código verificará todas as classes.
3. Clique em OK.
Criar um escopo personalizado
Quando você quiser inspecionar uma seleção de arquivos e diretórios diferente de todos os
escopos personalizados disponíveis, poderá criar um escopo personalizado.
1. Na caixa de diálogo Specify Inspection Scope, selecione Custom scope.
2. Clique nos três pontos após a lista suspensa Custom Scope.
170 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 66. Caixa de diálogo "Specify Inspection Scope".

A caixa de diálogo Scopes é exibida.

Figura 67. Criar um escopo personalizado.

3. Clique em Add para definir um novo escopo.

4. Na lista suspensa Add Scope, selecione Local.

Os escopos locais e compartilhados são usados no projeto pelo recurso Inspect Code. Um
escopo Shared também pode ser usado por outros recursos do projeto com um campo de escopo.
Por exemplo, quando você clica em Edit Settings para alterar as configurações de Find Usa-
ges, a caixa de diálogo exibida terá um campo Scope, em que é possível selecionar um escopo
compartilhado.
4.3 Programar o app 171

Figura 68. Selecione um escopo compartilhado na caixa de diálogo Find Usages.

5. Atribua um nome ao escopo e clique em OK.
O painel à direita da caixa de diálogo Scopes é preenchido com opções que permitem definir o
escopo personalizado.
6. Na lista suspensa, selecione Project.
Será exibida uma lista dos projetos disponíveis.
Observação: é possível criar o escopo personalizado para projetos ou pacotes. Nos dois casos,
as etapas são as mesmas.
7. Amplie as pastas do projeto, selecione os itens que você quer adicionar ao escopo personali-
zado e clique em um dos botões à direita.

Figura 69. Definir um escopo personalizado.

• Include: inclui esta pasta e os arquivos pertencentes a ela, mas não inclui nenhuma das
subpastas.
• Include Recursively: inclui esta pasta e todos os arquivos pertencentes a ela, bem como
subpastas e arquivos relacionados.
• Exclude: exclui esta pasta e os arquivos pertencentes a ela, mas não exclui nenhuma das
subpastas.
• Exclude Recursively: exclui esta pasta e todos os arquivos pertencentes a ela, bem como
subpastas e arquivos relacionados.
A figura 10 mostra que a pasta main é incluída e que a pasta java é incluída recursivamente.
A cor azul indica pastas incluídas parcialmente, e a cor verde indica pastas e arquivos incluídos
172 Capítulo 4. Ferramentas de Desenvolvimento para Android

recursivamente.

Figura 70. Exemplo de padrão de um escopo personalizado.

• Se você selecionar a pasta java e clicar em Exclude Recursively, o destaque em verde
desaparecerá na pasta java e em todas as pastas e arquivos relacionados.
• Se, em vez disso, você selecionar o arquivo [Link] destacado em verde e clicar
em "Exclude", o arquivo [Link] perderá o destaque, mas todos os demais itens na
pasta java continuarão destacados em verde.
8. Clique em OK. O escopo personalizado é exibido na parte inferior da lista suspensa.
Revisar e editar perfis de inspeção
O Android Studio é disponibilizado com vários perfis do lint e outros perfis de inspeção,
atualizados por meio do Android. Você pode usar esses perfis como estão ou editar os nomes,
descrições, níveis de gravidade e escopos. Também é possível ativar e desativar grupos inteiros de
perfis ou perfis individuais em um grupo.
Para acessar a caixa de diálogo Inspections:
1. Selecione Analyze > Inspect Code.
2. Na caixa de diálogo Specify Scope em Inspection Profile, clique em More.
A caixa de diálogo Inspections é exibida com uma lista de inspeções compatíveis e as respecti-
vas descrições.
4.3 Programar o app 173

Figura 71. Inspeções compatíveis e descrições relacionadas.

3. Selecione a lista suspensa Profile para alternar entre inspeções Default (Android Studio)
e Project Default (o projeto ativo). Para saber mais, consulte a página do IntelliJ Specify
Inspection Scope Dialog (link em inglês).
4. Na caixa de diálogo Inspections no painel à esquerda, selecione uma categoria de perfil de
nível superior ou amplie um grupo e selecione um perfil específico. Quando você seleciona
uma categoria de perfil, pode editar todas as inspeções dela como uma única inspeção.
5. Selecione a lista suspensa Manage que você quer copiar ou renomear ou em que quer
adicionar descrições ou exportar e importar inspeções.
6. Ao concluir, clique em OK.
Melhorar a inspeção de código com anotações
O uso de ferramentas de inspeção de código, como o lint, pode ajudar você a encontrar
problemas e melhorar o código, mas elas não passam disso. Os IDs de recurso do Android, por
exemplo, usam um int para identificar strings, gráficos, cores e outros tipos de recurso. Nesse caso,
as ferramentas de inspeção não conseguem determinar quando você especificou um recurso de
string onde precisaria ter especificado uma cor. Essa situação significa que o app poderá renderizar
de forma incorreta ou apresentar falha geral na execução, mesmo se você usar a inspeção de código.
As anotações permitem disponibilizar dicas para ferramentas de inspeção de código, como
o lint, ajudando a detectar os problemas de código mais sutis. Elas são adicionadas na forma de
tags de metadados, anexadas a variáveis e parâmetros, e retornam valores para inspecionar os
valores de retorno dos métodos, parâmetros passados, campos e variáveis locais. Quando usadas
com ferramentas de inspeção de código, as anotações podem ajudar a detectar problemas, como
exceções de ponteiro nulo e conflitos de tipo de recurso.
O Android é compatível com várias anotações por meio da Annotations Support Library.
Acesse a biblioteca por meio do pacote [Link].
Observação: se um módulo tem uma dependência em um processador de anotações, você
precisa usar a configuração de dependências "annotationProcessor"para adicioná-la. Para saber
mais, leia Usar a configuração de dependências do processador de anotações.
Adicionar anotações ao projeto
Para ativar as anotações no projeto, adicione a dependência support-annotations à biblioteca ou
ao app. Todas as anotações adicionadas serão verificadas quando você executar uma inspeção de
código ou uma tarefa lint.
Adicionar dependência da Annotations Support Library
A Annotations Support Library é publicada no repositório Maven do Google. Para adicionar a
Annotations Support Library ao projeto, inclua a seguinte linha no bloco dependencies do arquivo
[Link]:
174 Capítulo 4. Ferramentas de Desenvolvimento para Android

dependencies {
implementation ’[Link]:support-annotations:28.0.0’
}

Depois, na barra de tarefas ou na notificação de sincronização exibida, clique em Sync Now.

Se você usa anotações no próprio módulo de biblioteca, elas são incluídas como parte do
artefato do Archive do Android (AAR) em formato XML no arquivo [Link]. Adicionar a
dependência support-annotations não introduz uma dependência para nenhum usuário abaixo no
fluxo da biblioteca.
Observação: se você estiver usando a biblioteca appcompat, não precisará adicionar a depen-
dência support-annotations. Como a biblioteca appcompat já depende da biblioteca de anotações,
você tem acesso às anotações.
Para ver uma lista completa de anotações incluídas no repositório de suporte, analise a referência
da Annotations Support Library ou use o recurso de preenchimento automático para exibir as opções
disponíveis para a declaração import [Link]..
Realizar inspeções no código
Para iniciar uma inspeção de código no Android Studio, que contém anotações de validação e
verificação automática do lint, selecione Analyze > Inspect Code na barra de menu. O Android
Studio exibe mensagens de conflito para sinalizar eventuais problemas em que o código entra em
conflito com anotações e sugerir possíveis soluções.
Você também pode impor as anotações executando a tarefa lint pela linha de comando. Embora
isso possa ser útil para sinalizar problemas junto a um servidor de integração contínua, observe que
a tarefa lint não impõe anotações de nulidade (somente o Android Studio faz isso). Para saber mais
sobre como ativar e executar inspeções do lint, acesse Melhorar seu código com lint.
Embora os conflitos de anotação gerem alertas, esses avisos não impedem a compilação do app.
Anotações de nulidade
Adicione as anotações @Nullable e @NonNull para verificar a nulidade de uma determinada
variável, parâmetro ou valor de retorno. A anotação @Nullable indica uma variável, parâmetro ou
valor de retorno que pode ser nulo, enquanto que @NonNull indica uma variável, parâmetro ou
valor de retorno que não pode ser nulo.
Por exemplo, se uma variável local que contém um valor nulo é passada como um parâmetro a
um método com a anotação @NonNull vinculada a esse parâmetro, criar o código gera um alerta
que indica um conflito de não nulidade. Por outro lado, tentar referenciar o resultado de um método
marcado com @Nullable sem antes verificar se o resultado é nulo gera um alerta de nulidade. Você
só pode usar @Nullable no valor de retorno de um método se todo uso do método for explicitamente
verificado quanto à nulidade.
O exemplo a seguir vincula a anotação @NonNull aos parâmetros context e attrs para verificar
se os valores do parâmetro passados não são nulos. Ele também verifica se o método onCreateView()
retorna nulo: Observe que, com o Kotlin, não é necessário usar a anotação @NonNull porque ela
será adicionada automaticamente ao bytecode gerado quando um tipo não anulável for especificado:
KotlinJava
import [Link]
...

/** Add support for inflating the <fragment> tag. **/

fun onCreateView(
name: String?,
context: Context,
attrs: AttributeSet
4.3 Programar o app 175

): View? {
...
}
...

Análise de valores nulos

O Android Studio é compatível com a execução de uma análise de valores nulos para determinar
e inserir anotações de valores nulos automaticamente no código. Uma análise de valores nulos
verifica os contratos em todas as hierarquias de método no código para detectar:
• Métodos chamadores que podem retornar nulo
• Métodos que não devem retornar nulo
• Variáveis, como campos, variáveis locais e parâmetros, que podem ser nulos
• Variáveis, como campos, variáveis locais e parâmetros, que não podem ter valor nulo
Em seguida, a análise insere automaticamente as anotações de nulo apropriadas nos locais
detectados.
Para realizar uma análise de valores nulos no Android Studio, selecione Analyze > Infer
Nullity. O Android Studio insere as anotações @Nullable e @NonNull do Android nos locais
detectados no código. Depois de executar uma análise de valores nulos, é recomendado verificar as
anotações inseridas.
Observação: ao adicionar anotações de nulidade, o recurso de preenchimento automático
pode sugerir as anotações @Nullable e @NotNull do IntelliJ em vez das anotações de nulidade do
Android. Esse recurso também pode importar de forma automática a biblioteca correspondente. No
entanto, o verificador lint do Android Studio só busca anotações de nulidade do Android. Durante a
revisão das suas anotações, verifique se o projeto está usando as anotações de nulidade do Android
para que o verificador do lint possa emitir notificações corretas ao longo da inspeção de código.
Anotações de recurso
A validação de tipos de recurso pode ser útil porque as referências do Android a recursos, como
drawables e strings, são passadas na forma de números inteiros. O código que espera que um
parâmetro referencie um tipo específico de recurso, como drawables, pode ser passado no tipo de
referência esperado de int, mas referenciar, na verdade, outro tipo de recurso, como [Link].
Por exemplo, adicionar anotações @StringRes para verificar se um parâmetro de recurso contém
uma referência [Link], como mostrado aqui:
KotlinJava
abstract fun setTitle(@StringRes resId: Int)

Durante a inspeção de código, a anotação gera um alerta se uma referência a [Link] não é
passada no parâmetro.
Anotações para os outros tipos de recursos, como @DrawableRes, @DimenRes, @ColorRes
e @InterpolatorRes, podem ser adicionadas usando o mesmo formato de anotação e executadas
durante a inspeção do código. Se o parâmetro for compatível com diversos tipos de recurso, será
possível colocar mais de uma dessas anotações nele. Use @AnyRes para indicar que o parâmetro
com a anotação pode ser de qualquer tipo de recurso R.
Embora você possa usar @ColorRes para especificar que um parâmetro precisa ser um recurso
de cor, um número inteiro de cor (no formato RRGGBB ou AARRGGBB) não é reconhecido
como um recurso de cor. Use a anotação @ColorInt para indicar que um parâmetro precisa ser
um número inteiro de cor. As ferramentas de criação sinalizarão códigos incorretos que passarem
aos métodos com anotações um ID de recurso de cor como [Link], em vez de um
número inteiro de cor.
Anotações de linha de execução
176 Capítulo 4. Ferramentas de Desenvolvimento para Android

As anotações de linha de execução verificam se um método é chamado em um tipo específico

de linha de execução. As anotações de linha de execução a seguir são compatíveis:
• @MainThread
• @UiThread
• @WorkerThread
• @BinderThread
• @AnyThread
Observação: as ferramentas de criação tratam as anotações @MainThread e @UiThread
como intercambiáveis. Portanto, você pode chamar métodos @UiThread a partir de métodos
@MainThread e vice-versa. No entanto, é possível que uma linha de execução de IU seja diferente
da linha de execução principal no caso de apps do sistema terem diversas visualizações em diferentes
linhas de execução. Portanto, você precisa inserir a anotação @UiThread em métodos associados à
hierarquia de visualizações de um app e a anotação @MainThread somente em métodos associados
ao ciclo de vida de um app.
Se todos os métodos de uma classe compartilharem a mesma exigência de linha de execução,
você poderá adicionar uma única anotação de linha de execução à classe para verificar se todos os
métodos nessa classe são chamados no mesmo tipo de linha de execução.
Um uso comum da anotação de linha de execução é para validar modificações de método
na classe AsyncTask, uma vez que essa classe realiza operações em segundo plano e publica os
resultados somente na linha de execução de IU.
Anotações de limitação de valor
Use as anotações @IntRange, @FloatRange e @Size para validar os valores dos parâmetros
passados. Tanto @IntRange quanto @FloatRange funcionam melhor se aplicadas a parâmetros
para os quais os usuários têm mais chance de não entender o intervalo corretamente.
A anotação @IntRange confirma que um valor de número inteiro ou longo de parâmetro está
dentro de um intervalo especificado. O exemplo a seguir garante que o parâmetro alpha contenha
um valor de número inteiro de 0 a 255:
KotlinJava
fun setAlpha(@IntRange(from = 0, to = 255) alpha: Int) { ... }

A anotação @FloatRange verifica se um valor de parâmetro flutuante ou duplo está dentro de

um intervalo específico de valores de ponto flutuante. O exemplo a seguir garante que o parâmetro
alpha contenha um valor flutuante de 0,0 a 1,0:
KotlinJava
fun setAlpha(@FloatRange(from = 0.0, to = 1.0) alpha: Float) {...}

A anotação @Size verifica o tamanho de um conjunto ou de uma matriz, além do tamanho de

uma string. A anotação @Size pode ser usada para verificar as seguintes qualidades:
• Tamanho mínimo (como @Size(min=2))
• Tamanho máximo (como @Size(max=2))
• Tamanho exato (como @Size(2))
• Um número do qual o tamanho precisa ser múltiplo (como @Size(multiple=2))
Por exemplo, @Size(min=1) verifica se um conjunto está vazio e @Size(3) confirma que uma
matriz contém exatamente três valores. O exemplo a seguir garante que a matriz location contenha
pelo menos um elemento:
KotlinJava
fun getLocation(button: View, @Size(min=1) location: IntArray) {
[Link](location)
}
4.3 Programar o app 177

Anotações de permissão
Use a anotação @RequiresPermission para validar as permissões do autor da chamada de um
método. Para verificar a presença de uma única permissão de uma lista de permissões válidas, use
o atributo anyOf. Para verificar a presença de um conjunto de permissões, use o atributo allOf.
O exemplo a seguir insere uma anotação no método setWallpaper() para garantir que o autor da
chamada do método tenha a permissão permission.SET_WALLPAPERS:
KotlinJava
@RequiresPermission([Link].SET_WALLPAPER)
@Throws(IOException::class)
abstract fun setWallpaper(bitmap: Bitmap)

Neste exemplo, o autor da chamada do método copyFile() é obrigado a ter permissões de leitura
e gravação no armazenamento externo:
KotlinJava
@RequiresPermission(allOf = [
[Link].READ_EXTERNAL_STORAGE,
[Link].WRITE_EXTERNAL_STORAGE
])
fun copyFile(dest: String, source: String) {
...
}
Para permissões de intents, coloque o requisito de permissão no campo "string"que define o
nome da ação da intent:
KotlinJava
@RequiresPermission([Link])
const val ACTION_REQUEST_DISCOVERABLE = "[Link].REQUEST_DISCOVERABL

Para permissões de provedores de conteúdo nos casos em que é preciso separar permissões
de acesso para leitura das de gravação, encapsule cada requisito de permissão em uma anotação
@[Link] ou @[Link] :
KotlinJava
@[Link](RequiresPermission(READ_HISTORY_BOOKMARKS))
@[Link](RequiresPermission(WRITE_HISTORY_BOOKMARKS))
val BOOKMARKS_URI = [Link]("content://browser/bookmarks")

Permissões indiretas
Quando uma permissão depende do valor específico atribuído a um parâmetro do método, use
@RequiresPermission no parâmetro, sem listar as permissões específicas. Por exemplo, o método
startActivity(Intent) usa uma permissão indireta sobre o intent passado para o método:
KotlinJava
abstract fun startActivity(@RequiresPermission intent: Intent, bundle: Bundle?)

Quando você usa permissões indiretas, as ferramentas de criação realizam uma análise do fluxo
de dados para verificar se o argumento passado no método tem alguma anotação @RequiresPermis-
sion. Em seguida, elas aplicam todas as anotações existentes do parâmetro ao próprio método. No
exemplo startActivity(Intent), as anotações na classe Intent geram os alertas resultantes em usos
inválidos de startActivity(Intent) quando um intent sem as permissões apropriadas é passado para o
método, como mostrado na Figura 1.
178 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 72. O alerta gerado por uma anotação de permissões indiretas no método startActi-
vity(Intent).
As ferramentas de criação geram o alerta em startActivity(Intent) a partir da anotação no nome
da ação de intent correspondente na classe Intent:
KotlinJava
@SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
@RequiresPermission([Link].CALL_PHONE)
const val ACTION_CALL = "[Link]"

Se necessário, é possível trocar @RequiresPermission por @[Link] e/ou

@[Link] ao inserir anotação em um parâmetro do método. No entanto, para
permissões indiretas, não é recomendável usar @RequiresPermission com nenhuma anotação de
permissão de leitura ou gravação.
Anotações de valor de retorno
Use a anotação @CheckResult para confirmar que o resultado ou valor de retorno de um método
é efetivamente usado. Em vez de inserir a anotação @CheckResult em todo método não nulo,
adicione a anotação para esclarecer os resultados de métodos possivelmente confusos. Por exemplo,
novos desenvolvedores Java muitas vezes acreditam erroneamente que <String>.trim() remove
espaços em branco da string original. Inserir a anotação @CheckResult no método sinaliza usos de
<String>.trim() em que o autor da chamada não faz nada com o valor de retorno do método.
O exemplo a seguir insere uma anotação no método checkPermissions() para garantir que
o valor de retorno do método seja realmente referenciado. Nele, o método enforcePermission()
também é indicado como uma opção a ser sugerida ao desenvolvedor como substituto:
KotlinJava
@CheckResult(suggest = "#enforcePermission(String,int,int,String)")
abstract fun checkPermission(permission: String, pid: Int, uid: Int): Int

Anotações CallSuper
Use a anotação @CallSuper para confirmar que um método substituto chame a superimplemen-
tação do método. O exemplo a seguir insere uma anotação no método onCreate() para garantir que
todas as implementações de método substituto chamem [Link]():
KotlinJava
@CallSuper
override fun onCreate(savedInstanceState: Bundle?) {
}

Anotações Typedef
Use as anotações @IntDef e @StringDef para poder criar anotações enumeradas de conjuntos
de números inteiros e strings para validar outros tipos de referência de código. As anotações
Typedef garantem que determinado parâmetro, valor de retorno ou campo referencie um conjunto
específico de constantes. Elas também permitem que o preenchimento de código ofereça as
constantes permitidas automaticamente.
As anotações Typedef usam @interface para declarar o novo tipo de anotação enumerada.
As anotações @IntDef e @StringDef, junto com a @Retention, inserem a nova anotação e são
necessárias para definir o tipo enumerado. A anotação @Retention([Link])
4.3 Programar o app 179

instrui o compilador a não armazenar os dados da anotação enumerada no arquivo .class.

O exemplo a seguir ilustra as etapas para criar uma anotação que garanta que um valor passado
como um parâmetro de método referencie uma das constantes definidas:
KotlinJava
import [Link]
//...
// Define the list of accepted constants and declare the NavigationMode annotation
@Retention([Link])
@IntDef(NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS)
annotation class NavigationMode

// Declare the constants

const val NAVIGATION_MODE_STANDARD = 0
const val NAVIGATION_MODE_LIST = 1
const val NAVIGATION_MODE_TABS = 2

abstract class ActionBar {

// Decorate the target methods with the annotation

// Attach the annotation
@get:NavigationMode
@setparam:NavigationMode
abstract var navigationMode: Int

Se o parâmetro mode não referenciar uma das constantes definidas (NAVIGATION_MODE_STANDARD,

NAVIGATION_MODE_LIST ou NAVIGATION_MODE_TABS) na criação desse código, um
alerta será gerado.
Você também pode combinar @IntDef e @IntRange para indicar que um número inteiro pode
ser um conjunto específico de constantes ou um valor dentro de um intervalo.
Ativar combinação de constantes com sinalizações
Se os usuários puderem combinar as constantes permitidas com uma sinalização (como |, &, ˆ
etc.), você poderá definir uma anotação com o atributo flag para verificar se um parâmetro ou valor
de retorno referencia um padrão válido. O exemplo a seguir cria a anotação DisplayOptions com
uma lista de constantes DISPLAY_ válidas:
KotlinJava
import [Link]
...

@IntDef(flag = true, value = [

DISPLAY_USE_LOGO,
DISPLAY_SHOW_HOME,
DISPLAY_HOME_AS_UP,
DISPLAY_SHOW_TITLE,
DISPLAY_SHOW_CUSTOM
])
@Retention([Link])
annotation class DisplayOptions
180 Capítulo 4. Ferramentas de Desenvolvimento para Android

...

Se o parâmetro ou o valor de retorno decorado não referenciar um padrão válido durante a

compilação do código com um sinalizador de anotação, um alerta será gerado.
Anotação Keep
A anotação @Keep garante que uma classe ou um método com anotação não seja removido
quando o código for minimizado no momento da compilação. Normalmente, essa anotação é
adicionada aos métodos e classes acessados por meio de reflexão para evitar que o compilador trate
o código como não usado.
Cuidado: as classes e os métodos em que você insere anotações usando @Keep são sempre
exibidos no APK do app, mesmo que você nunca os referencie dentro da lógica do app.
Para manter o app pequeno, considere se é necessário preservar cada anotação @Keep. Se você
usar reflexão para acessar uma classe ou um método com anotação, use um -if condicional nas
regras do ProGuard, especificando a classe que faz as chamadas de reflexão.
Para ver mais informações sobre como reduzir seu código e especificar códigos que não podem
ser removidos, consulte Reduzir código e recursos.
Anotações de visibilidade de código
Use as seguintes anotações para denotar a visibilidade de partes específicas de código, como
métodos, classes, campos ou pacotes.
Tornar visível para testes
A anotação @VisibleForTesting indica que um método com anotação é mais visível que o
normalmente necessário para tornar o método passível de teste. Essa anotação conta com o
argumento otherwise opcional, que permite designar qual seria a visibilidade do método se não
houvesse a necessidade de torná-lo visível para teste. O lint usa o argumento otherwise para aplicar
a visibilidade pretendida.
No exemplo a seguir, myMethod() normalmente é private, mas tem pacotes privados para testes.
Com a designação [Link] a seguir, o lint exibirá uma mensagem se esse
método for chamado de fora do contexto permitido pelo acesso private, como de uma unidade de
compilação diferente.
KotlinJava
@VisibleForTesting(otherwise = [Link])
fun myMethod() {
...
}

Você também pode especificar @VisibleForTesting(otherwise = [Link]) para

indicar que existe um método somente para testes. Esse formulário representa o mesmo que usar
@RestrictTo(TESTS). Ambos executam a mesma verificação no lint.
Restringir uma API
A anotação @RestrictTo indica que o acesso à API com anotação (pacote, classe ou método) é
limitado da seguinte forma:
Subclasses
Use o formulário de anotação @RestrictTo([Link]) para restringir o
acesso da API somente a subclasses.
Apenas as classes que ampliem a classe com anotação poderão ter acesso à API. O modificador
protected do Java não é suficientemente restritivo porque permite o acesso de classes não relaciona-
das dentro do mesmo pacote. Além disso, há casos em que você quer deixar um método public
para flexibilidade futura porque nunca pode criar um método protected anterior e um método public
modificado, mas quer dar uma dica de que a classe se destina para usos dentro da classe ou apenas
4.3 Programar o app 181

de subclasses.
Bibliotecas
Use o formulário de anotação @RestrictTo([Link].GROUP_ID) para restringir o
acesso da API apenas às suas bibliotecas.
Apenas o código da sua biblioteca pode acessar a API com anotação. Isso permite não apenas
organizar o código em qualquer hierarquia de pacotes que você quiser, mas também compartilhar o
código entre um grupo de bibliotecas relacionadas. Essa opção já está disponível para as Bibliotecas
de Suporte que têm muito código de implementação não destinado a uso externo, mas que precisa
ser public para ser compartilhado entre as várias Bibliotecas de Suporte complementares.
Observação: as classes e os pacotes da Biblioteca de Suporte do Android agora têm a anota-
ção @RestrictTo(GROUP_ID). Isso significa que, se você usar acidentalmente essas classes de
implementação, o lint alertará que essa ação não é recomendada.
Teste
Use o formulário de anotação @RestrictTo([Link]) para impedir que outros
desenvolvedores acessem suas APIs de teste.
Apenas o código de teste pode acessar a API com anotação. Isso evita que outros desenvolve-
dores usem para desenvolvimento as APIs criadas apenas para fins de teste.
Referência de atributos de ferramentas
O Android Studio é compatível com vários atributos XML no namespace tools que permitem
recursos de tempo de design (como qual layout exibir em um fragmento) ou comportamentos em
tempo de compilação (como o modo de redução aplicado aos recursos XML). Quando você cria seu
app, as ferramentas de compilação removem esses atributos para que não haja efeito no tamanho do
APK ou no comportamento do ambiente de execução.
Para usar esses atributos, adicione o namespace tools ao elemento raiz de cada arquivo XML
em que você quer usá-los, conforme mostrado aqui:
<RootTag xmlns:android="[Link]
xmlns:tools="[Link] >

Atributos de processamento de erros

Os atributos a seguir ajudam a suprimir mensagens de aviso de lint.
tools:ignore
Destinado a: qualquer elemento
Usado por: lint
Esse atributo aceita uma lista separada por vírgulas de IDs de problemas de lint que você quer
que as ferramentas ignorem neste elemento ou em qualquer um dos descendentes dele.
Por exemplo, você pode dizer às ferramentas para ignorar o erro MissingTranslation:
<string name="show_all_apps"tools:ignore="MissingTranslation">All</string>

tools:targetApi
Destinado a: qualquer elemento
Usado por: lint
Esse atributo funciona da mesma forma que a anotação @TargetApi no código Java: ele permite
especificar o nível da API (como um número inteiro ou um nome de código) que é compatível com
esse elemento.
Isso informa às ferramentas que você acredita que esse elemento (e qualquer filho) será usado
apenas no nível de API especificado ou em níveis posteriores. Isso impede que o lint avise se esse
elemento ou os atributos dele não estão disponíveis no nível da API que você especificou como
minSdkVersion.
182 Capítulo 4. Ferramentas de Desenvolvimento para Android

Por exemplo, você pode usar isso porque GridLayout está disponível somente no nível de API
14 e posteriores, mas você sabe que esse layout não é usado para versões anteriores:
<GridLayout xmlns:android="[Link]
xmlns:tools="[Link]
tools:targetApi="14">

No entanto, você pode usar GridLayout a partir da Biblioteca de Suporte.

tools:locale
Destinado a: <resources>
Usado por: lint, editor do Android Studio
Para evitar avisos do corretor ortográfico, isso informa às ferramentas qual é o idioma/a locali-
dade padrão dos recursos no elemento <resources> fornecido, porque as ferramentas presumem
que seja o inglês. O valor precisa ser um qualificador de localidade válido.
Por exemplo, você pode adicionar isso ao arquivo values/[Link] (os valores de string
padrão) para indicar que o idioma usado para as strings padrão é espanhol em vez de inglês:
<resources xmlns:tools="[Link]
tools:locale="es">

Atributos de visualização no tempo de design

Os seguintes atributos definem características de layout que são visíveis apenas na visualização
do layout do Android Studio.
tools: em vez de android:
Destinado a: <View>
Usado por: editor de layout do Android Studio
Você pode inserir dados de amostra na visualização de layout usando o prefixo tools: em vez
de android: com qualquer atributo <View> da estrutura do Android. Isso é útil quando o valor do
atributo não é preenchido até o tempo de execução, mas você quer ver o efeito antecipadamente, na
visualização do layout.
Por exemplo, se o valor do atributo android:text for definido no tempo de execução ou você
quiser ver o layout com um valor diferente do padrão, será possível adicionar tools:text para
especificar algum texto somente para a visualização do layout.

Figura 73. O atributo tools:text define "Google Voice"como o valor da visualização do layout.
Você pode adicionar o atributo de namespace android: (que é usado no tempo de execução) e o
atributo tools: correspondente (que modifica o atributo de tempo de execução apenas na visualização
do layout).
Você também pode usar um atributo tools: para desmarcar um atributo somente para a visu-
alização do layout. Por exemplo, se você tiver um FrameLayout com vários filhos, mas quiser
ver apenas um filho na visualização do layout, poderá configurar os outros para ficarem invisíveis,
conforme mostrado aqui:
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
4.3 Programar o app 183

android:text="First"/>

<Button
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Second"
tools:visibility="invisible" />

Ao usar o Layout Editor na visualização de design, a janela Properties também permite editar
alguns atributos de visualização de tempo de design. Cada atributo de tempo de design é indicado
com um ícone de chave inglesa ao lado do nome do atributo para distingui-lo do atributo real
com o mesmo nome.
tools:context
Destinado a: qualquer raiz <View>
Usado por: lint, editor de layout do Android Studio
Esse atributo declara com qual atividade esse layout está associado por padrão. Isso ativa
recursos no editor ou na visualização do layout que exigem confirmação da atividade, como qual
será o tema de layout na visualização e onde inserir os gerenciadores onClick ao fazer uma correção
rápida (Figura 2).

Figura 74. A correção rápida para o atributo onClick só funciona se você definir tools:context.
Você pode especificar o nome da classe de atividade usando o mesmo prefixo de ponto do
arquivo de manifest (excluindo o nome completo do pacote). Exemplo:
<[Link]
xmlns:android="[Link]
xmlns:tools="[Link]
tools:context=".MainActivity">

Dica: você também pode selecionar o tema para a visualização do layout na barra de ferramentas
do Layout Editor.
tools:itemCount
Destinado a: <RecyclerView>
Usado por: editor de layout do Android Studio
Para um determinado RecyclerView, esse atributo especifica o número de itens que o editor de
layout precisa renderizar na janela Preview.
Exemplo:
184 Capítulo 4. Ferramentas de Desenvolvimento para Android

<[Link]
android:id="@+id/recyclerView"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:itemCount="3"/>

tools:layout
Destinado a: <fragment>
Usado por: editor de layout do Android Studio
Esse atributo declara qual layout você quer que a visualização do layout desenhe dentro
do fragmento, porque a visualização do layout não pode executar o código de atividade que
normalmente aplica o layout.
Exemplo:
<fragment android:name="[Link]"
tools:layout="@layout/list_content"/>

tools:listitem / tools:listheader / tools:listfooter

Destinado a: <AdapterView> (e subclasses como <ListView>)
Usado por: editor de layout do Android Studio
Esses atributos especificam qual layout será exibido na visualização do layout para os itens,
cabeçalho e rodapé de uma lista. Todos os campos de dados no layout são preenchidos com
conteúdo numérico, como "Item 1", para que os itens da lista não sejam repetitivos.
Exemplo:
<ListView xmlns:android="[Link]
xmlns:tools="[Link]
android:id="@android:id/list"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:listitem="@layout/sample_list_item"
tools:listheader="@layout/sample_list_header"
tools:listfooter="@layout/sample_list_footer"/>

Observação: esses atributos não funcionam para ListView no Android Studio 2.2, mas isso foi
corrigido na versão 2.3 (problema 215172).
tools:showIn
Destinado a: qualquer raiz <View> em um layout referido por <include>
Usado por: editor de layout do Android Studio
Esse atributo permite apontar para um layout que usa esse layout como uma inclusão para que
você possa visualizar (e editar) esse arquivo como ele aparece enquanto incorporado no layout pai.
Exemplo:
<TextView xmlns:android="[Link]
xmlns:tools="[Link]
android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
tools:showIn="@layout/activity_main"/>

Agora, a visualização do layout mostra esse layout TextView da maneira como ele aparece
dentro do layout activity_main.
4.3 Programar o app 185

tools:menu
Destinado a: qualquer raiz <View>
Usado por: editor de layout do Android Studio
Esse atributo especifica qual menu a visualização do layout precisa mostrar na barra de apps. O
valor pode ser um ou mais IDs de menu, separados por vírgulas (sem @menu/ ou qualquer prefixo
de ID e sem a extensão .xml). Exemplo:
<?xml version="1.0"encoding="utf-8"?>
<LinearLayout xmlns:android="[Link]
xmlns:tools="[Link]
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:menu="menu1,menu2"/>

tools:minValue / tools:maxValue
Destinado a: <NumberPicker>
Usado por: editor de layout do Android Studio
Esses atributos definem valores mínimos e máximos para uma visualização NumberPicker.
Exemplo:
<NumberPicker xmlns:android="[Link]
xmlns:tools="[Link]
android:id="@+id/numberPicker"
android:layout_width="match_parent"
android:layout_height="wrap_content"
tools:minValue="0"
tools:maxValue="10"/>

tools:openDrawer
Destinado a: <DrawerLayout>
Usado por: editor de layout do Android Studio
Esse atributo permite abrir um DrawerLayout no painel Preview do editor de layout. Você
também pode modificar de que maneira o editor renderiza o layout passando um dos seguintes
valores:

Constante Valor Descrição

final 800005 Envie o objeto para o final do contêiner, sem alterar o tamanho dele.
esquerda 3 Envie o objeto para a esquerda do contêiner, sem alterar o tamanho dele.
direita 5 Envie o objeto para a direita do contêiner, sem alterar o tamanho dele.
início 800003 Envie o objeto para o início do contêiner, sem alterar o tamanho dele.

Exemplo:
<[Link]
xmlns:android="[Link]
xmlns:tools="[Link]
android:id="@+id/drawer_layout"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:openDrawer="start"/>
186 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recursos "@tools:sample/*"
Destinado a: qualquer visualização que seja compatível com texto ou imagens da IU.
Usado por: editor de layout do Android Studio
Esse atributo permite injetar dados ou imagens de marcador na visualização. Por exemplo, se
você quiser testar como o layout se comporta com o texto, mas ainda não tiver concluído o texto da
IU para seu app, use o texto do marcador da seguinte maneira:
<TextView xmlns:android="[Link]
xmlns:tools="[Link]
android:layout_width="wrap_content"
android:layout_height="wrap_content"
tools:text="@tools:sample/lorem"/>

A tabela a seguir descreve os tipos de dados de marcadores de posição que você pode injetar
nos layouts.

Valor do atributo Descrição dos dados do marcador

@tools:sample/full_names Nomes completos que são gerados aleatoriamente a partir da combinação de @
@tools:sample/first_names Nomes comuns.
@tools:sample/last_names Sobrenomes comuns.
@tools:sample/cities Nomes de cidades de todo o mundo.
@tools:sample/us_zipcodes Caixas postais dos EUA geradas aleatoriamente.
@tools:sample/us_phones Números de telefone gerados aleatoriamente, com o seguinte formato: (800) 55
@tools:sample/lorem Texto de marcador derivado do latim.
@tools:sample/date/day_of_week Datas e horários aleatórios para o formato especificado.
@tools:sample/date/ddmmyy
@tools:sample/date/mmddyy
@tools:sample/date/hhmm
@tools:sample/date/hhmmss
@tools:sample/avatars Drawables de vetor que você pode usar como avatares de perfil.
@tools:sample/backgrounds/scenic Imagens que você pode usar como planos de fundo.

Atributos de redução de recursos

Os atributos a seguir permitem que você ative verificações de referência estritas e declare se
quer manter ou descartar certos recursos ao usar a redução de recursos.
Para ativar a redução de recursos, defina a propriedade shrinkResources como true no arquivo
[Link] (junto a minifyEnabled para a redução de código). Exemplo:
android {
...
buildTypes {
release {
shrinkResources true
minifyEnabled true
proguardFiles getDefaultProguardFile(’[Link]’),
’[Link]’
}
}
}

tools:shrinkMode
4.3 Programar o app 187

Destinado a: <resources>
Usado por: ferramentas de compilação com redução de recursos
Esse atributo permite que você especifique se as ferramentas de compilação usarão o "modo
de segurança"(reproduzir com segurança e manter todos os recursos explicitamente citados e que
possam ser referenciados dinamicamente com uma chamada para [Link]()) ou o
"modo estrito"(manter apenas os recursos explicitamente citados no código ou em outros recursos).
O padrão é usar o modo de segurança (shrinkMode="safe"). Para usar o modo estrito, adicione
shrinkMode="strict"à tag <resources>, como mostrado aqui:
<?xml version="1.0"encoding="utf-8"?>
<resources xmlns:tools="[Link]
tools:shrinkMode="strict"/>

Quando você ativa o modo estrito, pode ser necessário usar tools:keep para manter os re-
cursos que foram removidos, mas que você realmente quer, e usar tools:discard para remover
explicitamente ainda mais recursos.
Para mais informações, consulte Reduza seus recursos.
tools:keep
Destinado a: <resources>
Usado por: ferramentas de compilação com redução de recursos
Ao usar a redução de recursos para remover recursos não utilizados, esse atributo permite que
você especifique recursos que gostaria de manter, geralmente porque eles são referenciados indire-
tamente no tempo de execução, por exemplo, passando um nome de recurso gerado dinamicamente
para [Link]().
Para usá-la, crie um arquivo XML no diretório de recursos (por exemplo, em res/raw/[Link])
com uma tag <resources> e especifique cada recurso que deve ser mantido no atributo tools:keep
como uma lista separada por vírgulas. Você pode usar o caractere asterisco como curinga. Exemplo:
<?xml version="1.0"encoding="utf-8"?>
<resources xmlns:tools="[Link]
tools:keep="@layout/used_1,@layout/used_2,@layout/*_3"/>

Para mais informações, consulte Reduza seus recursos.

tools:discard
Destinado a: <resources>
Usado por: ferramentas de compilação com redução de recursos
Ao usar a redução de recursos para remover recursos não utilizados, esse atributo permite
que você especifique aqueles que quer descartar de modo manual, geralmente porque o recurso é
referenciado, mas de uma maneira que não afeta seu app, ou porque o plug-in do Gradle deduziu
incorretamente que o recurso é referenciado.
Para usá-la, crie um arquivo XML no diretório de recursos (por exemplo, em res/raw/[Link])
com uma tag <resources> e especifique cada recurso que deve ser mantido no atributo tools:discard
como uma lista separada por vírgulas. Você pode usar o caractere asterisco como curinga. Exemplo:
<?xml version="1.0"encoding="utf-8"?>
<resources xmlns:tools="[Link]
tools:discard="@layout/unused_1"/>

Para mais informações, consulte Reduza seus recursos.

Compilar e executar o app
O Android Studio configura novos projetos para implantar no Android Emulator ou em um
dispositivo conectado com apenas alguns cliques. Depois que seu app for instalado, o Instant Run
188 Capítulo 4. Ferramentas de Desenvolvimento para Android

permitirá que você faça alterações no código sem criar um novo APK.
Para criar e executar seu app, selecione Run Run na barra de menus (ou clique em Run Ù
na barra de ferramentas). Se estiver executando o app pela primeira vez, o Android Studio solicitará
que você selecione um destino de implantação, conforme mostrado na Figura 75. Selecione um
dispositivo para instalar e executar seu app.

Figura 75. A caixa de diálogo Select Deployment Target mostra os dispositivos disponíveis.
Se a caixa de diálogo mostrar a mensagem "No USB devices or running emulators detected",
será necessário configurar e conectar o dispositivo ou iniciar um emulador clicando em um dispo-
sitivo listado em Available Virtual Devices. Se não houver dispositivos virtuais listados, clique
em Create New Virtual Device e siga o assistente de configuração do dispositivo virtual (consulte
Criar e gerenciar dispositivos virtuais).
Para exibir a caixa de diálogo Select Deployment Target, desmarque Use same device for fu-
ture launches ou pare o app com Run Stop app ou Stop  e, em seguida, inicie-o novamente.
Observação: também é possível implantar seu app no modo de depuração clicando em Debug
. Executar o app no modo de depuração permite que você defina pontos de interrupção no
código, examine variáveis e avalie expressões no momento execução, além de executar ferramentas
de depuração. Para saber mais, consulte Depurar seu app.
Alterar a configuração de execução/depuração
Quando você executa o app pela primeira vez, o Android Studio usa uma configuração de
execução padrão. A configuração de execução especifica se o app será implantado a partir de
um APK ou de um Android App Bundle, o módulo a ser executado, o pacote a ser implantado, a
atividade a ser iniciada, o dispositivo de destino, as configurações do emulador, as opções do logcat
e muito mais.
A configuração padrão de execução/depuração cria um APK, inicia a atividade de projeto
padrão e usa a caixa de diálogo Select Deployment Target para seleção de dispositivo de des-
tino. Se as configurações padrão não forem adequadas ao seu projeto ou módulo, você pode
personalizar as configurações de execução/depuração ou mesmo criar novas configurações nos
níveis de projeto, padrão e módulo. Para editar uma configuração de execução/depuração, seleci-
one Run Edit Configurations . Para mais informações, consulte Criar e editar configurações de
execução/depuração.
4.3 Programar o app 189

Alterar a variante de compilação

Por padrão, o Android Studio cria a versão de depuração do app destinada apenas para uso
durante o desenvolvimento, quando você clica em Executar.
Para alterar a variante de compilação que o Android Studio usa, selecione Build > Select Build
Variant na barra de menus (ou clique em Build Variants na barra de janelas de ferramentas)
e, em seguida, selecione uma variante de compilação no menu suspenso. Por padrão, novos
projetos são configurados com duas variantes de compilação: uma variante de depuração e outra de
lançamento. É necessário compilar a versão de lançamento para preparar o app para lançamento
para o público.
Para criar outras variações do app, cada uma com recursos ou requisitos de dispositivo diferentes,
você pode Configurar variações de compilação.
Criar o projeto
O botão Run Ù cria e implanta o app em um dispositivo. No entanto, se quiser criar seu app
para compartilhar ou fazer upload para o Google Play, você precisará usar uma das opções no menu
Build de modo a compilar partes do projeto ou ele todo. Antes de selecionar qualquer uma das
opções de compilação listadas na tabela 1, primeiro selecione a variante de compilação a ser usada.
Observação: o Android Studio requer que o AAPT2 crie pacotes de apps, o que é ativado
para novos projetos por padrão. No entanto, para ter certeza de que isso está ativado em projetos
existentes, inclua android.enableAapt2=true no arquivo [Link] e reinicie o daemon
Gradle executando ./gradlew --stop na linha de comando.
Tabela 1. Opções de compilação no menu Build.

Item de menu Descrição

Make Module Compila no módulo selecionado todos os ar-
quivos de origem que foram modificados desde
a última compilação, assim como todos os mó-
dulos dos quais o módulo selecionado depende
recursivamente. A compilação inclui arquivos
de origem dependente e quaisquer tarefas as-
sociadas. Você pode selecionar o módulo a ser
compilado selecionando o nome do módulo ou
um dos arquivos dele na janela Project. Esse
comando não gera um APK.
Make Project Faz todos os módulos.
Clean Project Exclui todos os arquivos de compilação inter-
mediários/armazenados em cache.
Rebuild Project Executa o Clean Project para a variante de
compilação selecionada e produz um APK.
190 Capítulo 4. Ferramentas de Desenvolvimento para Android

Item de menu Descrição

Build Bundle(s) / APK(s) > Build APK(s) Cria um APK de todos os módulos no projeto
atual para a variante selecionada. Quando a
compilação for concluída, uma notificação de
confirmação será exibida, fornecendo um link
para o arquivo APK e um link para analisá-lo
no APK Analyzer.
Se a variante de compilação selecionada for
um tipo de depuração, o APK será assinado
com uma chave de depuração e estará pronto
para ser instalado. Se você selecionou uma
variante de versão, o APK não estará assinado
por padrão, e você precisará assinar o APK
manualmente. Como alternativa, é possível
selecionar Build > Generate Signed Bundle
/ APK na barra de menus.
O Android Studio salva os APKs criados em
project-name/module-
name/build/outputs/apk/.
Build Bundle(s) / APK(s) > Build Bundle(s) Cria um Android APP Bundle de todos os
módulos no projeto atual para a variante
selecionada. Quando a compilação for
concluída, uma notificação de confirmação
será exibida, fornecendo um link para o pacote
de apps e um link para análise no APK
Analyzer.
Se a variante de compilação selecionada for
um tipo de depuração, o pacote de apps será
assinado com uma chave de depuração e você
poderá usar o bundletool para implantar seu
app do pacote de apps em um dispositivo
conectado. Se você selecionou uma variante
de versão, o pacote de apps não estará
assinado por padrão e você precisará assiná-lo
manualmente usando jarsigner. Como
alternativa, selecione Build > Generate
Signed Bundle / APK na barra de menus.
O Android Studio salva os APKs criados em
project-name/module-
name/build/outputs/bundle/.
Generate Signed Bundle / APK Abre uma caixa de diálogo com um assistente
para uma nova configuração de assinatura e
cria um APK ou um pacote de apps assinado.
Você precisa assinar seu app com uma chave
de versão para poder fazer upload para o Play
Console. Se quiser mais informações sobre a
assinatura de apps, consulte Assinar seu app.
4.3 Programar o app 191

Observação: o botão Run cria um APK com testOnly="true", o que significa que o APK
só pode ser instalado via adb (que o Android Studio usa). Se você quiser um APK depurável que as
pessoas possam instalar sem o adb, selecione a variante de depuração e clique em Build Bundle(s)
/ APK(s) > Build APK(s).
Para mais detalhes sobre as tarefas que o Gradle executa para cada comando, abra a janela
Build conforme descrito na próxima seção. Para mais informações sobre o Gradle e o processo de
compilação, consulte Configurar sua compilação.
Monitorar o processo de compilação
Veja detalhes sobre o processo de compilação clicando em View > Tool Windows > Build (ou
clicando em Build na barra da janela de ferramentas). A janela exibe as tarefas que o Gradle
executa para compilar seu app, conforme mostrado na Figura 76.

Figura 76. A janela de saída "Build"no Android Studio.

1. Guia Build: exibe as tarefas que o Gradle executa como uma árvore, onde cada nó re-
presenta uma fase de compilação ou um grupo de dependências de tarefas. Se você
receber erros de tempo de criação ou tempo de compilação, inspecione a árvore e se-
lecione um elemento para ler a saída do erro, conforme mostrado na Figura 77 abaixo.

Figura 77. Inspecione a janela de saída "Build"em busca de mensagens de erro.

2. Guia Sync: exibe as tarefas que o Gradle executa para sincronizar com os arquivos de projeto.
Assim como na guia Build, se você encontrar um erro de sincronização, selecione elementos
na árvore para ver mais informações sobre o erro.
3. Restart: executa a mesma ação que selecionar Build > Make Project, gerando arquivos
intermediários de compilação para todos os módulos do projeto.
192 Capítulo 4. Ferramentas de Desenvolvimento para Android

4. Toggle view: alterna entre a exibição da execução da tarefa como uma árvore gráfica e a
exibição de uma saída de texto mais detalhada do Gradle. Essa é a mesma saída que você vê
na janela Gradle Console no Android Studio 3.0 e versões anteriores.
Se suas variantes de compilação usam variações de produto, o Gradle também invoca tarefas
para compilar essas variações. Para ver a lista de todas as tarefas de compilação disponíveis, clique
em View > Tool Windows > Gradle (ou clique em Gradle na barra da janela de ferramentas).
Se ocorrer um erro durante o processo de compilação, o Gradle pode recomendar algumas
opções de linha de comando para ajudar você a resolver o problema, como --stacktrace ou --debug.
Para usar opções de linha de comando com seu processo de compilação:
1. Abra a caixa de diálogo Settings ou Preferences.
• No Windows ou no Linux, selecione File > Settings na barra de menus.
• No Mac OSX, selecione Android Studio > Preferences na barra de menus.
2. Navegue para Build, Execution, Deployment > Compiler.
3. No campo de texto ao lado de Command-line Options, insira suas opções de linha de
comando.
4. Clique em OK para salvar e sair.
O Gradle aplicará essas opções de linha de comando na próxima vez que você tentar compilar
seu app.
Sobre o Instant Run
No Android Studio 2.3 e versões posteriores, o Instant Run reduz significativamente o tempo
necessário para atualizar seu APK com alterações de código e recurso. Depois de implantar seu app
em um dispositivo de destino executando o Android 5.0 (API de nível 21) ou posterior, clique em
Apply Changes para enviar determinadas alterações de código e recursos ao app em execução sem
criar um novo APK e, em alguns casos, sem sequer reiniciar a atividade atual. Os botões Run e
Debug estão sempre disponíveis para você enviar suas alterações e forçar o reinício de um app.
No entanto, você pode descobrir que usar o botão Apply Changes oferece um fluxo de trabalho
mais rápido para a maioria das alterações incrementais no app.
Dica: você também pode pressionar Control + F10 (ou Control + + R no Mac) para aplicar as
alterações com o Instant Run.
A ação Apply Changes está disponível somente quando você atende às seguintes condições:
• Cria um APK do app usando uma variante de compilação de depuração. O Instant Run ainda
não é compatível para implantação a partir de um pacote de apps.
• Usa o plug-in do Android para Gradle versão 2.3.0 ou posterior.
• Define minSdkVersion como 15 ou superior no arquivo [Link] de nível de módulo do
app.
• Implanta o app em um dispositivo de destino que executa o Android 5.0 (API de nível 21) e
posterior.
Para mais informações sobre como ativar o Instant Run, acesse a seção sobre como como
configurar seu projeto.
O Instant Run envia as alterações realizando um hot swap, warm swap ou cold swap. O tipo
de swap executado depende do tipo de alteração feita. Quando você clica em Apply Changes
depois de fazer uma alteração de código ou recurso no app em execução, o Instant Run determina
automaticamente a melhor maneira de enviar a alteração para o dispositivo de destino, conforme
descrito na tabela a seguir.
Clicar em Run (ou Debug ) força um cold swap e uma reinicialização do app. Se você
fizer uma alteração no manifesto do app ou em um recurso mencionado pelo manifesto, o Android
Studio sempre enviará as alterações com uma reinstalação completa do APK.
4.3 Programar o app 193

Alteração de código Comportamento em Apply Changes

• Alteração do código de implementação Executa um hot swap: esse é o tipo mais
de um método existente rápido e torna as alterações visíveis muito
mais rapidamente. O app continua em
execução, e um método stub com a nova
implementação será usado na próxima vez em
que ele for chamado.
Hot swaps não reinicializam objetos no app
em execução. Antes de você ver algumas
atualizações, talvez seja necessário reiniciar a
atividade atual, selecionando Run > Restart
Activity ou reiniciar o app, clicando em Run.
(ou Debug ). Por padrão, o Android
Studio automaticamente reinicia a atividade
atual após realizar um hot swap. Se não quiser
esse comportamento, você poderá desativar as
reinicializações automáticas de atividades.
• Alteração ou remoção de um recurso Executa um warm swap: esse ainda é muito
existente rápido, mas o Instant Run precisa reiniciar a
atividade atual quando ela envia os recursos
alterados ao app. O app continua em execução,
mas a tela pode apresentar uma breve
oscilação conforme a atividade é reiniciada, o
que é normal.
Alterações no código estrutural, como: Executa um cold swap: esse é um pouco mais
• Adição, remoção ou alteração de: lento porque, embora um novo APK não seja
– uma anotação; necessário, o Instant Run precisa reiniciar
– um campo de instância; todo o app quando ele enviar alterações no
– um campo estático; código estrutural.
– uma assinatura de método
estático;
– uma assinatura de método de
instância.
• Alteração de qual classe pai gera a
classe atual
• Alteração da lista de interfaces
implementadas
• Alteração do inicializador estático da
classe
• Reordenação de elementos de layout
que usam IDs de recurso dinâmicos
194 Capítulo 4. Ferramentas de Desenvolvimento para Android

Alteração de código Comportamento em Apply Changes

• Alteração no manifesto do app Ao fazer alterações no manifesto do app ou
• Alteração de recursos referenciados nos recursos referenciados pelo manifesto,
pelo manifesto do app clicar em Apply Changes reimplanta uma
• Alteração em um elemento de IU do versão completa do app com essas alterações.
sistema Android, como um widget ou Isso ocorre porque determinadas informações
uma notificação sobre o app, como nome, recursos de ícone do
app e filtros de intent, são determinadas pelo
manifesto quando o APK é instalado no
dispositivo.
Se o processo de compilação atualizar
automaticamente qualquer parte do manifesto
do app, como iteração automática de
versionCode ou versionName, você não
poderá se beneficiar de todo o desempenho do
Instant Run. Ao usar o Instant Run, desative
as atualizações automáticas para qualquer
parte do manifesto do app nas variantes de
compilação de depuração.
Ao atualizar um elemento da IU do sistema
Android, como um widget ou uma notificação,
você precisa clicar em Run (ou Debug
).

Observação: se for necessário reiniciar o app após uma falha, não o inicie a partir do dispositivo
de destino. Reiniciar o app pelo dispositivo de destino não aplica as alterações de código desde o
último cold swap ou compilação incremental. Para iniciar o app com todas as alterações recentes,
clique em Run (ou Debug) no Android Studio.
Desativar a reinicialização automática de atividades
Ao executar um hot swap, seu app continua em execução, mas o Android Studio reinicia
automaticamente a atividade atual. Para desativar essa configuração padrão:
1. Abra a caixa de diálogo Settings ou Preferences.
• No Windows ou no Linux, selecione File > Settings na barra de menus.
• No Mac OSX, selecione Android Studio > Preferences na barra de menus.
2. Navegue até Build, Execution, Deployment > Instant Run.
3. Desmarque a caixa ao lado de Restart activity on code changes.
Se a reinicialização automática de atividades estiver desativada, você poderá reiniciar a atividade
atual manualmente pela barra de menus selecionando Run > Restart Activity.
Configurar o projeto para o Instant Run
O Android Studio ativa o Instant Run por padrão para projetos compilados usando o plug-in do
Android para Gradle 2.3.0 ou versão posterior.
Para atualizar um projeto existente com a versão mais recente do plug-in:
1. Abra a caixa de diálogo Settings ou Preferences.
2. Navegue para Build, Execution, Deployment > Instant Run e clique em Update Project,
conforme mostrado na Figura 78.
Se a opção de atualizar o projeto não for exibida, ele já está atualizado com a versão mais
recente do plug-in do Android para Gradle. No entanto, verifique se a caixa ao lado de Enable
Instant Run está marcada.
4.3 Programar o app 195

Figura 78. Atualização do plug-in do Android para Gradle para um projeto existente.
Para começar a usar o Instant Run, você também precisa alterar a variante de compilação
para uma versão de depuração do seu app e implantá-la em um dispositivo de destino que execute
o Android 5.0 (API de nível 21) ou versão posterior. Para saber mais técnicas que aceleram a
compilação, leia Otimizar a velocidade da sua compilação.
Excluir seu projeto do Windows Defender
Em sistemas Windows, o Windows Defender pode causar lentidão durante o uso do Instant
Run. Se você estiver usando o Windows Defender, é recomendável excluir a pasta do seu projeto
do Android Studio das verificações de malware do Windows Defender (link em inglês).
Melhorar os tempos de compilação ao usar o Crashlytics
Se sua versão do plug-in Fabric Gradle for anterior à 1.21.6, o Crashlytics poderá aumentar os
tempos de compilação. Para melhorar o desempenho de compilação ao desenvolver o app, você
pode atualizar o plug-in para a versão mais recente ou desativar o Crashlytics para sua variante de
compilação de depuração.
Limitações do Instant Run
O Instant Run foi projetado para agilizar o processo de compilação e implantação na maioria
das situações. No entanto, alguns aspectos do Instant Run podem afetar o comportamento e a
compatibilidade com o app. Se você tiver algum outro problema durante o uso do Instant Run, ative
a geração de registros extra e informe um bug.
Implantação em vários dispositivos
O Instant Run usa diferentes técnicas para executar hot, warm e cold swaps específicos ao nível
de API do dispositivo de destino. Por esse motivo, ao implantar um app em vários dispositivos de
uma vez, o Android Studio desativa o Instant Run temporariamente.
Multidexação do seu app
Se minSdkVersion for definido para 21 ou mais, o Instant Run configurará seu app automatica-
mente para multidexar. Como o Instant Run só funciona com a versão de depuração do app, pode
ser preciso configurar o app para multidex ao implantar sua variante de compilação de versão.
Execução de testes instrumentados e criadores de perfil de desempenho
Testes instrumentados carregam o APK de depuração e um APK de teste no mesmo processo
em um dispositivo de teste, permitindo que métodos de controle modifiquem o ciclo de vida normal
do app e executem testes. Ao executar ou depurar testes instrumentados, o Android Studio não
injeta outros métodos necessários para o Instant Run e desativa o recurso.
Ao criar um perfil de app, você precisa desativar o Instant Run. Há um pequeno impacto
no desempenho ao usar o Instant Run e um impacto ligeiramente maior ao substituir métodos
com um hot swap. Esse impacto no desempenho pode interferir nas informações fornecidas pelas
ferramentas de geração de perfis de desempenho. Além disso, os métodos stub gerados com cada
hot swap podem complicar rastreamentos de pilha.
Usar plug-ins de terceiros
O Android Studio desativa temporariamente a Java Code Coverage Library (JaCoCo) e o
ProGuard ao usar o Instant Run. Como o Instant Run só funciona com compilações de depuração,
isso não afeta a compilação de lançamento.
Alguns plug-ins de terceiros que realizam melhorias de bytecode podem causar problemas na
instrumentação do Instant Run para seu app. Se você tiver esses problemas, mas quiser continuar
usando o Instant Run, desative esses plug-ins para sua variante de compilação de depuração.
Também é possível melhorar a compatibilidade com plug-ins de terceiros registrando um bug.
Enviar alterações para apps de vários processos
 196 Capítulo 4. Ferramentas de Desenvolvimento para Android

O Instant Run só instrumenta o processo principal do seu app para executar hot swaps e warm
swaps. Ao enviar alterações de código para outros processos do app, como alterações em uma
implementação de método ou um recurso existente, o Instant Run executa um cold swap.
Abrir seu app em um perfil de trabalho
Se você executar o app com o Instant Run e o abrir usando um perfil de trabalho (ou outro
perfil secundário), ele falhará porque os arquivos DEX instrumentados usados pelo Instant Run só
poderão ser acessados pelo espaço do usuário do perfil principal.
Se você quiser continuar usando o Instant Run, evite abrir o app com o perfil de trabalho e
assegure que sua configuração de execução não use a sinalização --user user_id.
Se você precisar usar seu app com o perfil de trabalho, recomendamos criar uma nova con-
figuração de execução que inclua a sinalização --user user_id, especificando o ID do usuário do
perfil de trabalho. Você pode encontrar o ID do usuário executando adb shell pm list users na
linha de comando. Quando você usa a sinalização --user, o Android Studio desativa o Instant Run
apenas para essa implantação. O Instant Run funcionará novamente quando você alternar para uma
configuração sem a sinalização --user.
Desativar o Instant Run
Para desativar o Instant Run:
1. Abra a caixa de diálogo Settings ou Preferences.
2. Navegue até Build, Execution, Deployment > Instant Run.
3. Desmarque a caixa ao lado de Enable Instant Run.

4.4 Executar apps no Android Emulator

4.4.1 Visão Geral
O Android Emulator simula dispositivos Android no seu computador. Assim, você pode testar o
aplicativo em diversos dispositivos e níveis de API do Android, sem precisar ter cada dispositivo
físico.
O emulador oferece quase todos os recursos de um dispositivo Android real. É possível simular
o recebimento de chamadas telefônicas e mensagens de texto, especificar o local do dispositivo,
simular diferentes velocidades de rede, simular rotação e outros sensores de hardware, acessar a
Google Play Store e muito mais.
O teste do app no emulador é, de certa forma, mais rápido e mais fácil do que fazer isso em um
dispositivo físico. Por exemplo, você pode transferir dados mais rapidamente para o emulador do
que para um dispositivo conectado via USB.
O emulador vem com configurações predefinidas para diversos smartphones e tablets Android,
e também para dispositivos Wear OS e Android TV.
Assista o vídeo a seguir para ter uma visão geral de alguns recursos do emulador.
Você pode usar o emulador manualmente, por meio da interface gráfica do usuário, e programa-
ticamente, por meio da linha de comando e do console do emulador. Para ver uma comparação dos
recursos disponíveis em cada interface, consulte Comparação de ferramentas do Android Emulator.
Requisitos e recomendações
O Android Emulator tem outras exigências além dos requisitos básicos de sistema do Android
Studio, que são descritos a seguir:
• Ferramentas do SDK 26.1.1 ou mais recente
• Processador de 64 bits
• Windows: CPU compatível com Unrestricted Guest (UG)
• HAXM 6.2.1 ou mais recente (HAXM 7.2.0 ou mais recente recomendado)
O uso da aceleração de hardware apresenta outros requisitos no Windows e no Linux:
4.4 Executar apps no Android Emulator 197

• Processador Intel no Windows ou no Linux: processador Intel compatível com Intel VT-x,
Intel EM64T (Intel 64) e funcionalidade Bit de desativação de execução (Bit XD)
• Processador AMD no Linux: processador AMD compatível com AMD Virtualization (AMD-
V) e Supplemental Streaming SIMD Extensions 3 (SSSE3)
• Processador AMD no Windows: Android Studio 3.2 ou mais recente e Windows 10 com
a versão de abril de 2018 ou mais recente para a funcionalidade da Windows Hypervisor
Platform (WHPX) (link em inglês)
Para ser compatível com o Android 8.1 (API de nível 27) e imagens de sistema mais recentes, a
webcam conectada precisa ter capacidade para capturar quadros de 720p.
Suspensão de uso para sistemas Windows de 32 bits
O Android Emulator passou a ser obsoleto em junho de 2019 para sistemas Windows de 32
bits. A compatibilidade com o emulador para Windows de 32 bits continuará válida até junho de
2020, incluindo correções de bugs críticos, mas nenhum recurso novo será adicionado. Se você
está usando o emulador em um sistema Windows de 32 bits, recomendamos que se prepare para
migrar para um sistema Windows de 64 bits.
Se você está usando o emulador em um sistema Windows de 32 bits, pode usar o SDK Manager
para instalar a versão mais recente do emulador para o Windows de 32 bits.
Instalar o emulador
Para instalar o Android Emulator, selecione o componente Android Emulator na guia SDK
Tools do SDK Manager. Para ver instruções, consulte Atualizar ferramentas com o SDK Manager.
Dispositivos virtuais Android
Cada instância do Android Emulator usa um Dispositivo virtual Android (AVD, na sigla em
inglês) para especificar a versão do Android e as características de hardware do dispositivo simulado.
Para testar seu app de forma eficaz, crie um AVD que modele cada dispositivo em que você espera
que o app seja executado. Para criar e gerenciar AVDs, use o AVD Manager.
Cada AVD funciona como um dispositivo independente, com o próprio armazenamento privado
para dados do usuário, cartão SD e assim por diante. Por padrão, o emulador armazena os dados
do usuário e do cartão SD, bem como o cache, em um diretório específico para esse AVD. Ao ser
iniciado, o emulador carrega os dados do usuário e do cartão SD a partir do diretório do AVD.
Executar um app no Android Emulator
É possível executar o app de um projeto do Android Studio ou um app instalado no Android
Emulator da mesma forma que você executaria qualquer app em um dispositivo.
Para iniciar o Android Emulator e executar um app no projeto:
1. No Android Studio, crie um Dispositivo virtual Android (AVD) que o emulador possa usar
para instalar e executar seu app.
2. Na barra de ferramentas, selecione o AVD em que você quer executar o app no menu suspenso
do dispositivo de destino.
198 Capítulo 4. Ferramentas de Desenvolvimento para Android

3. Clique em Run .
Se você receber um erro ou uma mensagem de alerta na parte superior da caixa de diálogo,
clique no link para corrigir o problema ou ver mais informações.
Alguns erros precisam ser corrigidos antes de continuar, como determinados erros do Hardware
Accelerated Execution Manager (Intel HAXM).
No macOS, se você vir um erro Warning: No DNS servers found ao iniciar o emulador, verifique
se tem um arquivo /etc/[Link]. Se não tiver esse arquivo, digite o seguinte comando em uma
janela de terminal:
ln -s /private/var/run/[Link] /etc/[Link]
Iniciar o Android Emulator sem executar um app antes
Para iniciar o emulador:
1. Abra o AVD Manager.
2. Clique duas vezes em um AVD ou clique em Run
.
O Android Emulator é carregado.
Com emulador em execução, você pode executar projetos do Android Studio e escolher o
emulador como dispositivo de destino. Também é possível arrastar um ou mais APKs para o
emulador para instalá-los e executá-los.
Instalar e adicionar arquivos
Para instalar um arquivo de APK no dispositivo emulado, arraste esse arquivo para a tela do
emulador. Uma caixa de diálogo do APK Installer é exibida. Depois que a instalação for concluída,
você poderá ver o app na lista de apps.
Para adicionar um arquivo ao dispositivo emulado, arraste esse arquivo para a tela do emulador.
O arquivo é colocado no diretório /sdcard/Download/. Para ver o arquivo pelo Android Studio, use
o Device File Explorer. Também é possível vê-lo no dispositivo por meio do app Downloads ou
Files, dependendo da versão do dispositivo.
Snapshots
Um snapshot é uma imagem armazenada de um Android Virtual Device (AVD) que preserva
todo o estado do dispositivo no momento em que foi salvo. Isso inclui as configurações do SO,
o estado do aplicativo e os dados do usuário. É possível retornar a um estado salvo do sistema
carregando um snapshot a qualquer momento. Assim, você não perde tempo esperando que o
sistema operacional e os aplicativos no dispositivo virtual sejam reiniciados, além de poupar o
esforço de fazer seu app voltar para o estado em que você quer retomar o teste. A inicialização de
um dispositivo virtual por meio do carregamento de um snapshot é muito semelhante à inicialização
de um dispositivo físico a partir de um estado de suspensão, em vez de inicializá-lo a partir de um
estado desligado.
Para cada AVD, você pode ter um snapshot de inicialização rápida e quantos snapshots gerais
quiser.
A maneira mais simples de usufruir dos snapshots é usar aqueles de inicialização rápida. Por
padrão, cada AVD é configurado para salvar automaticamente um snapshot de inicialização rápida
ao sair e para carregar a partir de um snapshot de inicialização rápida ao iniciar.
Na primeira vez que um AVD é iniciado, ele precisa realizar uma inicialização a frio, que é
como ligar um dispositivo. Se o Quick Boot estiver ativado, todas as inicializações subsequentes
serão carregadas a partir do snapshot especificado, e o sistema será restaurado para o estado salvo
nesse snapshot.
Os snapshots são válidos para a imagem do sistema, configuração do AVD e recursos do
emulador com que são salvos. Ao fazer uma alteração em qualquer uma dessas áreas, todos os
snapshots do AVD afetado se tornam inválidos. Qualquer atualização das configurações do Android
4.4 Executar apps no Android Emulator 199

Emulator, da imagem de sistema ou do AVD redefine o estado salvo do AVD. Sendo assim, na
próxima vez em que você iniciar o AVD, ele precisará realizar uma inicialização a frio.
A maioria dos controles para salvar, carregar e gerenciar snapshots está nas guias Snapshots e
Settings no painel Snapshots na janela Extended controls do emulador.

Você também pode controlar as opções do Quick Boot ao iniciar o emulador pela linha de
comando.
Salvar snapshots de inicialização rápida
Ao fechar um AVD, você pode especificar se o emulador salva automaticamente um snapshot
quando você o fecha. Para controlar esse comportamento, faça o seguinte:
1. Abra a janela Extended controls do emulador.
2. Na categoria Snapshots de controles, navegue até a guia Settings.
3. Use o menu suspenso Auto-save current state to Quickboot para selecionar uma das
seguintes opções:
• Yes: sempre salva um snapshot do AVD quando você fecha o emulador. Esse é o
padrão.
Observação: quando snapshots de inicialização rápida automática estiverem ativados, você
poderá ignorar o salvamento de um snapshot mantendo a tecla pressionada ao fechar o emulador.
• No: não salva um snapshot do AVD quando você fecha o emulador.
Sua seleção se aplica somente ao AVD que está aberto no momento. Não é possível salvar
snapshots enquanto o adb está off-line. Por exemplo, enquanto o AVD ainda está sendo inicializado.
Salvar snapshots gerais
Embora você só possa ter um snapshot de inicialização rápida para cada AVD, pode ter vários
snapshots gerais para cada um deles.
Para salvar um snapshot geral, abra a janela Extended controls do emulador, selecione a
categoria Snapshots e clique no botão Take snapshot, no canto inferior direito da janela.
Para editar o nome e a descrição do snapshot selecionado, clique no botão de edição , na
parte inferior da janela.
200 Capítulo 4. Ferramentas de Desenvolvimento para Android

Excluir um snapshot
Para excluir um snapshot manualmente, abra a janela Extended controls do emulador, selecione
a categoria Snapshots, selecione o snapshot e clique no botão de exclusão , na parte inferior da
janela.
Você também pode especificar se quer que o emulador exclua automaticamente os snapshots
que se tornam inválidos, por exemplo, quando as configurações do AVD ou a versão do emulador
mudam. Por padrão, o emulador perguntará se você quer excluir snapshots inválidos. Essa
configuração pode ser mudada com o menu Delete invalid snapshots na guia Settings do painel
Snapshots.
Carregar um snapshot
Para carregar um snapshot a qualquer momento, abra a janela Extended controls do emulador,
selecione a categoria Snapshots, escolha um snapshot e clique no botão de carregamento , na
parte inferior da janela.
No Android Studio 3.2 e versões mais recentes, cada configuração de dispositivo inclui um
controle Boot option nas configurações avançadas da caixa de diálogo Virtual Device Configuration.
Nesse controle, você pode especificar qual snapshot será carregado quando o AVD for iniciado.
Desativar o Quick Boot
Se você quer desativar o Quick Boot para que o AVD sempre realize uma inicialização a frio,
faça o seguinte:
1. Selecione Tools > AVD Manager e clique em Edit this AVD .
2. Clique em Show Advanced Settings e role para baixo até Emulated Performance.
3. Selecione Cold boot.
Inicializar a frio uma vez
Em vez de desativar completamente o Quick Boot, você pode fazer uma única inicialização a
frio clicando em Cold Boot Now no menu suspenso do AVD no AVD Manager.

Requisitos e solução de problemas para snapshots

• Os snapshots não são compatíveis com o Android 4.0.4 (API nível 15) ou anterior.
• Os snapshots não são compatíveis com imagens de sistema ARM para o Android 8.0 (API
de nível 26).
• Se o emulador falhar durante a inicialização a partir de um snapshot, selecione Cool Boot
Now para o AVD no AVD Manager e envie um relatório do bug.
• Os snapshots não são confiáveis quando a renderização de software está ativada. Se os
snapshots não funcionarem, clique em Edit this AVD no AVD Manager e mude a opção
Graphics para Hardware ou Automatic.
• Carregar ou salvar um snapshot é uma operação que consome muita memória. Se você não
tiver RAM suficiente quando uma operação de carregamento ou de salvamento for iniciada,
o sistema operacional poderá alternar o conteúdo da RAM para o disco rígido, o que pode
4.4 Executar apps no Android Emulator 201

diminuir muito a velocidade da operação. Se você notar uma demora exagerada para carregar
ou salvar snapshots, poderá acelerar essas operações liberando RAM. Uma boa maneira de
fazer isso é fechando os aplicativos que não são essenciais para seu trabalho.
Navegar na tela do emulador
Use o cursor do mouse do computador para imitar o movimento do dedo na tela touchscreen,
selecione itens de menu e campos de entrada e clique em botões e controles. Use o teclado do
computador para digitar caracteres e inserir atalhos do emulador.
Tabela 1. Gestos para navegar no emulador.

Recurso Descrição
Deslizar o dedo na tela Aponte para a tela, pressione o botão principal do mouse e mantenha
Arrastar um item Aponte para um item na tela, pressione o botão principal do mouse e
Tocar Aponte para a tela, pressione o botão principal
(dar um toque) do mouse e solte. Por exemplo, você pode
clicar em um campo de texto para começar a
digitar nele, selecionar um app ou pressionar
um botão.
Tocar duas vezes Aponte para a tela, pressione o botão principal do mouse rapidament
Tocar e manter pressionado Aponte para um item na tela, pressione o botão principal do mouse, m
Digitar Você pode digitar no emulador usando o teclado do computador ou u
Fazer gesto de pinça unindo e afastando os Ao pressionar "Control"( no Mac), uma
dedos interface multitoque de gestos de pinça é
exibida. O mouse funciona como o primeiro
dedo, e o ponto de fixação é o segundo dedo.
Arraste o cursor para mover o primeiro ponto.
Clicar com o botão esquerdo do mouse
funciona como tocar em ambos os pontos, e
soltar o botão funciona como levantar os
dedos.
Deslizar verticalmente Abra um menu vertical na tela e use a roda de rolagem (botão de rola

Realizar ações comuns no emulador

Para realizar ações comuns com o emulador, use o painel à direita, conforme descrito na Tabela
2.
Você pode usar atalhos de teclado para realizar várias ações comuns no emulador. Para ver uma
lista completa de atalhos no emulador, pressione F1 (no Mac, + /) e veja o painel "Help"na janela
Extended controls.
Tabela 2. Ações comuns no emulador.

Recurso Descrição
Fechar Fecha o emulador.

Minimizar Minimiza a janela do emulador.

Redimensionar Redimensiona o emulador da mesma forma que faria com qualquer o

Liga/desliga Clique para ligar ou desligar a tela.
Clique e mantenha pressionado para ligar ou desligar o dispositivo.
202 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recurso Descrição
Aumentar volume Clique para ver um controle deslizante e aumentar o volume. Clique

Diminuir volume Clique para ver um controle deslizante e diminuir o volume. Clique n

Girar para a esquerda Gira o dispositivo 90 graus no sentido anti-horário.

Girar para a direita Gira o dispositivo 90 graus no sentido horário.

Fazer captura de tela Clique para capturar a tela do dispositivo. Para saber mais detalhes, c

Entrar no modo de zoom Clique para que o cursor mude para o ícone de
zoom. Para sair do modo de zoom, clique no
botão novamente.
Aumentar e diminuir o zoom no modo de
zoom:
• Clique com o botão esquerdo do mouse
para aumentar o zoom em 25%, até no
máximo cerca de duas vezes a resolução
da tela do dispositivo virtual.
• Clique com o botão direito do mouse
para diminuir o zoom.
• Clique com o botão esquerdo do mouse
e arraste para selecionar uma área
retangular na qual aumentar o zoom.
• Clique com o botão direito do mouse e
arraste a caixa de seleção para voltar ao
zoom padrão.
Para movimentar no modo de zoom, mantenha
"Control"( no Mac) pressionado ao mesmo
tempo em que pressiona as teclas de seta no
teclado.
Para tocar na tela do dispositivo no modo de
zoom, clique com a tecla Control pressionada
(no Mac, clique com a tecla pressionada).
Voltar Volta para a tela anterior ou fecha uma caixa de diálogo, o menu de o

Início Volta para a tela inicial.

Visão geral Toque para abrir uma lista de imagens de

miniaturas dos apps usados recentemente.
(Apps recentes) Para abrir um app, toque nele. Para remover
uma miniatura da lista, deslize-a para a
esquerda ou para a direita. Esse botão não é
compatível com o Wear OS.
4.4 Executar apps no Android Emulator 203

Recurso Descrição
Dobrar Em dispositivos dobráveis, dobra o dispositivo para exibir a menor co

Desdobrar Em dispositivos dobráveis, desdobra o dispositivo para exibir a maio

Menu Pressione Control + M (no Mac, + M) para simular o botão de men

Mais Clique para acessar outros recursos e configurações, descritos na pró

Gravação de tela
É possível gravar vídeo e áudio do Android Emulator e salvar a gravação em um arquivo WebM
ou GIF animado.
Os controles de gravação de tela estão na guia Screen record da janela Extended controls.
Dica: também é possível abrir os controles de gravação de tela pressionando Control + + R
(no Mac, + + R).
Para iniciar a gravação da tela, clique no botão Start recording na guia Screen record. Para
interromper a gravação, clique em Stop recording.
Os controles para exibir e salvar o vídeo gravado ficam na parte inferior da guia Screen record.
Para salvar o vídeo, escolha WebM ou GIF no menu da parte inferior da guia e clique em Save.
Você também pode gravar e salvar uma gravação de tela do emulador usando a seguinte opção
na linha de comando:
adb emu screenrecord start --time-limit 10 [path to save video]/sample_video.webm
Capturas de tela
Para capturar a tela do dispositivo virtual, clique no botão Take screenshot .
O emulador cria um arquivo PNG com o nome Screenshot_yyyymmdd-[Link] usando ano,
mês, dia, hora, minuto e segundo da captura. Por exemplo, Screenshot_20160219-[Link].
Por padrão, a captura de tela é salva na área de trabalho do computador. Para mudar o local em
que as capturas de tela são salvas, use o controle Screenshot save location na categoria Settings,
na janela Extended controls do emulador.
É possível fazer capturas de tela na linha de comando com uma das opções a seguir:
• screenrecord screenshot [destination-directory]
• adb emu screenrecord screenshot [destination-directory]
Câmera de cena virtual e ARCore
Use a câmera de cena virtual em um ambiente virtual para realizar experimentos com apps de
realidade aumentada (RA) criados com o ARCore (link em inglês).
Para ver informações sobre como usar a câmera de cena virtual no emulador, consulte Executar
apps de RA no Android Emulator (link em inglês).
Ao usar o emulador com um app de câmera, você pode importar uma imagem em formato
PNG ou JPEG e usá-la em uma cena virtual. Para escolher uma imagem a ser usada em uma
cena virtual, clique em Add image na guia Camera > Virtual scene images na janela Extended
controls. Esse recurso pode ser usado para importar imagens personalizadas, como códigos QR,
para uso com qualquer app baseado em câmera. Para saber mais, consulte Adicionar imagens
aumentadas à cena (link em inglês).
Testar ações comuns de RA com macros
É possível reduzir significativamente o tempo necessário para testar ações comuns de RA
usando as macros predefinidas no emulador. Por exemplo, use uma macro para redefinir todos os
sensores do dispositivo para o estado padrão.
204 Capítulo 4. Ferramentas de Desenvolvimento para Android

Antes de usar macros, siga as etapas em Executar apps de RA no Android Emulator (link em
inglês) para configurar a câmera de cena virtual do app, executar seu app no emulador e atualizar o
ARCore. Em seguida, siga estas etapas para usar macros no emulador:
1. Com o emulador em execução e o app conectado ao ARCore, clique em More no painel
do emulador.
2. Selecione Record and Playback > Macro Playback.
3. Escolha a macro que você quer usar e clique em Play.
É possível interromper uma macro ativa clicando em Stop.
Controles estendidos, configurações e ajuda
Use os controles estendidos para enviar dados, mudar propriedades do dispositivo, controlar
apps e muito mais. Para abrir a janela Extended controls, clique em More no painel do
emulador.
Você pode usar atalhos de teclado para realizar muitas dessas tarefas. Para ver uma lista
completa de atalhos no emulador, pressione F1 (no Mac, + /) para abrir o painel "Help".
Tabela 3. Detalhes dos controles estendidos.
4.4 Executar apps no Android Emulator 205

Recurso Descrição
Local O emulador permite simular as informações
de "Meu local": o local onde o dispositivo
emulado está localizado no momento. Por
exemplo, se você clicar em Meu local no
Google Maps e enviar uma localização, o
mapa a mostrará.
Para enviar uma localização de GPS:
1. Selecione Decimal ou Sexagesimal.
2. Especifique a localização.
No modo decimal, insira um valor para
Latitude no intervalo de -90,0 a +90,0 graus e
um valor para Longitude no intervalo de
-180,0 a +180,0 graus.
No modo sexagesimal, insira um valor de três
partes para Latitude no intervalo de -90 a +90
graus, 0 a 59 minutos e 0,0 a 60,0 segundos.
Insira um valor de Longitude no intervalo de
-180 a +180 graus, 0 a 59 minutos e 0,0 a 60,0
segundos.
Para a latitude, “-” indica sul e “+” indica
norte. Para a longitude, “-” indica oeste e “+”
indica leste. O “+” é opcional.
Também é possível especificar um valor para
Altitude no intervalo de -1.000,0 a +10.000,0
metros.
3. Clique em Enviar.
Para usar dados geográficos de um arquivo
GPX (GPS Exchange) ou KML (Keyhole
Markup Language):
1. Clique em Load GPX/KML.
2. Na caixa de diálogo do arquivo,
selecione um arquivo no computador e
clique em Open.
3. Se quiser, selecione um valor em Speed
para a velocidade.
A velocidade tem o valor padrão Delay
(Speed 1X). Você pode aumentar a velocidade
em duas vezes (Speed 2X), três vezes (Speed
3X) e assim por diante.
4. Clique em Run .
206 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recurso Descrição
Rede celular O emulador permite que você simule diversas
condições de rede. Você pode aproximar a
velocidade de rede de diferentes protocolos ou
especificar a opção Full, que transfere dados
na velocidade máxima permitida pelo
computador. Especificar um protocolo de rede
é sempre mais lento do que a opção Full.
Também é possível especificar o status de rede
de dados e voz, como roaming. Os valores
padrão são definidos no AVD.
Selecione uma opção para Network type:
• GSM: Global System for Mobile
Communications
• HSCSD: High-Speed Circuit-Switched
Data
• GPRS: Generic Packet Radio Service
• EDGE: Enhanced Data rates for GSM
Evolution
• UMTS: Universal Mobile
Telecommunications System
• HSPDA: High-Speed Downlink Packet
Access
• LTE: Long-Term Evolution
• Full (padrão): usa a rede
disponibilizada pelo computador
Selecione uma opção para Signal strength, a
intensidade do sinal:
• None
• Poor
• Moderate (padrão)
• Good
• Great
Selecione uma opção para Voice status (status
de voz), Data status (status dos dados) ou para
ambos:
• Home (padrão)
• Roaming
• Searching
• Denied (somente chamadas de
emergência)
• Unregistered (desativado)
4.4 Executar apps no Android Emulator 207

Recurso Descrição
Bateria Você pode simular as propriedades da bateria
de um dispositivo para saber como é o
desempenho do app em diferentes condições.
Para selecionar um valor para Charge level, o
nível de carregamento, use o controle
deslizante.
Selecione um valor para Charger connection,
o tipo de conexão:
• None
• AC charger
Selecione um valor para Battery health, a
integridade da bateria:
• Good (padrão)
• Failed
• Dead
• Overvoltage
• Overheated
• Unknown
Selecione um valor para Battery status, o
status da bateria:
• Unknown
• Charging (padrão)
• Discharging
• Not charging
• Full

Telefone O emulador permite que você simule o

recebimento de chamadas telefônicas e
mensagens de texto.
Para iniciar uma chamada para o emulador:
1. Selecione ou digite um número de
telefone no campo From.
2. Clique em Call Device.
3. Também é possível clicar em Hold Call
para colocar a chamada em espera.
4. Para encerrar a chamada, clique em
End Call.
Para enviar uma mensagem de texto para o
emulador:
1. Selecione ou digite um número de
telefone no campo From.
2. Digite uma mensagem no campo SMS
message.
3. Clique em Send Message.
208 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recurso Descrição
Botão direcional Se o AVD tiver o botão direcional ativado no
perfil de hardware, você poderá usar os
controles desse botão com o emulador. No
entanto, nem todos os dispositivos são
compatíveis com o botão direcional, por
exemplo, um relógio Android. Os botões
simulam as seguintes ações:

Impressão digital Esse controle pode simular até 10 verificações

de impressões digitais diferentes. Você pode
usá-lo para testar a integração de impressões
digitais no seu app. Esse recurso está
desativado para Android 5.1 (API de nível 22)
e anteriores e para Wear OS.
Para simular uma verificação de impressão
digital no dispositivo virtual faça o seguinte:
1. Prepare um app para receber uma
impressão digital.
2. Selecione um valor para Fingerprint.
3. Clique em Touch Sensor.
4.4 Executar apps no Android Emulator 209

Recurso Descrição
Virtual sensors > Accelerometer Esse controle permite que você teste seu app
em relação a alterações na posição do
dispositivo, na orientação dele ou em ambos.
Por exemplo, você pode simular gestos, como
inclinação e rotação. O acelerômetro não
acompanha a posição absoluta do dispositivo,
ele apenas detecta quando uma alteração está
acontecendo. O controle simula a maneira
como os sensores do acelerômetro e do
magnetômetro respondem quando você move
ou gira um dispositivo real.
Ative o sensor do acelerômetro no AVD para
usar esse controle.
O controle informa eventos
TYPE_ACCELEROMETER nos eixos x, y e z.
Esses valores incluem gravidade. Por exemplo,
se o dispositivo estiver suspenso no espaço
sideral, ele experimentará aceleração zero
(todos os valores de x, y e z serão 0). Quando
o dispositivo está na Terra, posicionado com a
tela para cima sobre uma mesa, a aceleração é
0, 0 e 9,8 devido à gravidade.
O controle também informa eventos
TYPE_MAGNETIC_FIELD, que medem o
campo magnético do ambiente nos eixos x, y e
z em microteslas (µT ).
Para girar o dispositivo em torno dos eixos x,
y e z, selecione Rotate e siga um destes
procedimentos:
• Ajuste os controles deslizantes Yaw,
Pitch e Roll e observe a posição no
painel superior.
• Mova a representação do dispositivo no
painel superior, observe os fatores Yaw,
Pitch e Roll (guinada, inclinação e
rolagem) e como os valores resultantes
do acelerômetro mudam.
Para ver mais informações sobre como a
guinada, a inclinação e a rolagem são
calculadas, consulte Calcular a orientação do
dispositivo.
Para mover o dispositivo horizontalmente (x)
ou verticalmente (y), selecione Move e siga
um destes procedimentos:
• Ajuste os controles deslizantes X e Y e
observe a posição no painel superior.
• Mova a representação do dispositivo no
painel superior, observe os valores dos
controles deslizantes X e Y e como os
valores resultantes do acelerômetro
mudam.
Para posicionar o dispositivo em 0, 90, 180 ou
270 graus:
• Na área Device rotation, selecione um
210 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recurso Descrição
Virtual sensors > Additional sensors O emulador pode simular vários sensores de
posição e de ambiente. Ele permite ajustar os
seguintes sensores, para que você possa
testá-los com seu app:
• Ambient temperature: esse sensor
ambiental mede a temperatura do ar
ambiente.
• Magnetic field: esse sensor de posição
mede o campo magnético do ambiente
nos eixos X, Y e Z, respectivamente. Os
valores são dados em microteslas (µT ).
• Proximity: esse sensor de posição
mede a distância de um objeto. Por
exemplo, ele pode notificar um
smartphone de que um rosto está perto
dele para fazer uma chamada. O sensor
de proximidade precisa estar ativado no
AVD para usar esse controle.
• Light: esse sensor ambiental mede a
iluminância. Os valores são dados em
unidades de lux.
• Pressure: esse sensor ambiental mede a
pressão do ar ambiente. Os valores são
dados em unidades de milibar (hPa).
• Relative Humidity: esse sensor
ambiental mede a umidade relativa do
ambiente.
Para ver mais informações sobre esses
sensores, consulte Visão geral dos sensores,
Sensores de posição e Sensores de ambiente.
Snapshots Consulte Snapshots.
Gravação de tela Consulte Gravação de tela.
4.4 Executar apps no Android Emulator 211

Recurso Descrição
Settings > General • Emulator window theme: selecione
"Light"ou "Dark".
• Send keyboard shortcuts to: por
padrão, algumas combinações de
teclado acionam atalhos de controle do
emulador. Se você estiver
desenvolvendo um app que inclui
atalhos de teclado, como um app
direcionado a dispositivos com teclados
Bluetooth, poderá mudar essa
configuração para enviar todas as
entradas do teclado para o dispositivo
virtual, inclusive aquelas que seriam um
atalho no emulador.
• Screenshot save location: clique no
ícone de pasta para especificar um local
onde as capturas da tela do emulador
serão salvas.
• Use detected ADB location: se você
está executando o emulador no Android
Studio, selecione essa configuração
(padrão). Se você executar o emulador
fora do Android Studio e quiser que ele
use um executável específico do adb,
desmarque essa opção e especifique o
local das Ferramentas do SDK do
Android. Se essa configuração estiver
incorreta, alguns recursos como a
captura de tela e a instalação de app
"arraste e solte"não funcionarão.
• When to send crash reports:
selecione "Always", "Never"ou "Ask".
• Show window frame around device:
por padrão, os emuladores com
arquivos de aparência de dispositivo são
exibidos sem moldura de janela.

Settings > Proxy Por padrão, o emulador usa as configurações de proxy HTTP do And
212 Capítulo 4. Ferramentas de Desenvolvimento para Android

Recurso Descrição
Settings > Advanced • OpenGL ES renderer: selecione o
tipo de aceleração gráfica. Isso é
equivalente à opção de linha de
comando -gpu.
– Autodetect based on host:
permite que o emulador escolha
entre aceleração gráfica de
hardware ou de software com base
na configuração do computador.
Ele verifica se o driver da GPU
corresponde a uma lista de drivers
de GPU defeituosos conhecidos e,
em caso afirmativo, o emulador
desativa a emulação de hardware
gráfico e usa a CPU.
– ANGLE (apenas para Windows):
use o ANGLE Direct3D (link em
inglês) para renderizar elementos
gráficos no software.
– SwiftShader: use o SwiftShader
(link em inglês) para renderizar
elementos gráficos no software.
– Desktop native OpenGL: use a
GPU no computador host. Essa
opção normalmente é a mais
rápida. No entanto, alguns drivers
apresentam problemas na
renderização de elementos
gráficos OpenGL. Sendo assim,
essa pode não ser uma escolha
confiável.
• OpenGL ES API level: seleciona a
versão máxima do OpenGL ES para
usar no emulador.
– Autoselect: permite que o
emulador escolha a versão do
OpenGL ES com base na
compatibilidade com hosts e
convidados.
– Renderer maximum (up to
OpenGL ES 3.1): tenta usar a
versão máxima do OpenGL ES.
– Compatibility (OpenGL ES
1.1/2.0): usa a versão do OpenGL
ES compatível com a maioria dos
ambientes.
4.4 Executar apps no Android Emulator 213

Recurso Descrição
Help > Keyboard Shortcuts Esse painel mostra uma lista completa de
atalhos de teclado do emulador. Para abrir
esse painel enquanto trabalha no emulador,
pressione F1 (no Mac, +/).
Para que os atalhos funcionem, a opção Send
keyboard shortcuts no painel de
configurações General precisa ser definida
como Emulator controls (default).
Help > Emulator Help Para acessar a documentação on-line do
emulador, clique em Documentation.
Para informar um bug no emulador, clique em
Send feedback. Para ver mais informações,
consulte Como informar bugs do emulador.
Help > About Veja que porta do adb é usada pelo emulador,
além dos números de versão do Android e do
emulador. Compare a versão mais recente
disponível do emulador com a sua para
determinar se você tem o software mais
recente instalado.
O número de série do emulador é
emulator-adb_port, que você pode especificar
como opção de linha de comando do adb, por
exemplo.

Wi-Fi
Ao usar um AVD com API de nível 25 ou posterior, o emulador disponibiliza um ponto de
acesso Wi-Fi simulado ("AndroidWifi") e o Android se conecta automaticamente a ele.
Você pode desativar o Wi-Fi no emulador executando o emulador com o parâmetro da linha de
comando -feature -Wifi.
Limitações
O Android Emulator não inclui hardware virtual para:
• Bluetooth
• NFC
• Inserção/ejeção de cartão SD
• Fones de ouvido conectados ao dispositivo
• USB
O emulador de relógio do Wear OS não tem o botão "Visão geral"(Apps recentes), botão
direcional nem sensor de impressão digital.
Criar e gerenciar dispositivos virtuais
Um Android Virtual Device (AVD) é uma configuração que define as características de um
smartphone ou tablet Android, Wear OS, Android TV ou um dispositivo Android Automotive OS
que você queira simular no Android Emulator. O AVD Manager é uma interface que pode ser
iniciada no Android Studio para ajudar a criar e gerenciar AVDs.
Para abrir o AVD Manager, siga um dos procedimentos a seguir:
• Selecione Tools > AVD Manager.
• Clique em AVD Manager na barra de ferramentas.
214 Capítulo 4. Ferramentas de Desenvolvimento para Android

Sobre AVDs
AVDs contêm um perfil de hardware, imagem de sistema, área de armazenamento, aparência e
outras propriedades.
Recomendamos que você crie um AVD para cada imagem do sistema que possa ser compatível
com o app, com base na configuração <uses-sdk> do manifesto.
Perfil de hardware
O perfil de hardware define as características de fábrica de um dispositivo. O AVD Manager
é pré-carregado com alguns perfis de hardware, como dispositivos Pixel, e você pode definir e
personalizar os perfis de hardware conforme necessário.
Apenas alguns perfis de hardware são indicados para incluir a Play Store. Isso indica que esses
perfis são totalmente compatíveis com CTS e podem usar imagens do sistema que incluem o app
Play Store.
Imagens do sistema
Uma imagem do sistema identificada com APIs do Google inclui acesso ao Google Play
Services. Uma imagem do sistema identificada com o logotipo do Google Play na coluna Play
Store inclui o app Google Play Store, bem como o acesso ao Google Play Services. Isso inclui a
guia Google Play na caixa de diálogo Extended controls, que oferece um botão para a atualização
do Google Play Services no dispositivo.
Para garantir a segurança do app e uma experiência consistente nos dispositivos físicos, as
imagens do sistema com a Google Play Store inclusa são assinadas com uma chave de versão, o
que significa que não é possível receber privilégios elevados (raiz) com elas. Se você precisar de
privilégios elevados (raiz) para auxiliar na solução de problemas do app, use as imagens do sistema
do Android Open Source Project (AOSP) que não contêm apps ou serviços do Google.
Área de armazenamento
O AVD tem uma área de armazenamento dedicada no seu computador de desenvolvimento. Ele
armazena dados de usuários de dispositivos, como apps instalados e configurações, além de um
cartão SD emulado. Se necessário, você pode usar o AVD Manager para excluir permanentemente
os dados do usuário, de modo que o dispositivo fique com os mesmos dados de um dispositivo
novo.
Aparência
Uma aparência de emulador especifica a aparência de um dispositivo. O AVD Manager oferece
algumas aparências predefinidas. Também é possível definir as próprias aparências ou usar aquelas
disponibilizadas por terceiros.
AVD e recursos do app
Verifique se a definição do AVD inclui os recursos de dispositivo necessários para o app.
Consulte Propriedades de um perfil de hardware e Propriedades de um AVD para ver listas de
recursos que podem ser definidos nos AVDs.
Criar um AVD
4.4 Executar apps no Android Emulator 215

Dica: se você quiser iniciar o app em um emulador, execute o app no Android Studio e, na
caixa de diálogo Select Deployment Target exibida, clique em Create New Virtual Device.

Para criar um novo AVD:

1. Abra o AVD Manager clicando em Tools > AVD Manager.

2. Clique em Create Virtual Device na parte inferior da caixa de diálogo do AVD Manager.

A página Select Hardware é exibida.

Somente alguns perfis de hardware são indicados para incluir a Play Store. Isso indica que
esses perfis são totalmente compatíveis com CTS e podem usar imagens do sistema que incluem o
app Play Store.

3. Selecione um perfil de hardware e clique em Next.

Caso você não veja o perfil de hardware que quer usar, pode criar ou importar um.

A página System Image é exibida.

216 Capítulo 4. Ferramentas de Desenvolvimento para Android

4. Selecione a imagem de sistema de um nível de API específico e clique em Next.

A guia Recommended lista as imagens de sistema recomendadas. As demais guias incluem

uma lista mais completa. O painel à direita descreve a imagem de sistema selecionada. As imagens
x86 são executadas com mais rapidez no emulador.

Se você vir a opção Download ao lado da imagem do sistema, clique nela para fazer o download
da imagem. Para isso, é preciso estar conectado à Internet.

O nível de API do dispositivo de destino é importante, uma vez que seu app não poderá ser
executado em uma imagem de sistema com um nível de API inferior ao exigido pelo app, conforme
especificado no atributo minSdkVersion do arquivo de manifesto. Para ver mais informações
sobre a relação entre o nível de API do sistema e o minSdkVersion, consulte Controlar versões de
aplicativos.

Se o app declarar um elemento <uses-library> no arquivo de manifesto, o app exigirá uma

imagem de sistema em que essa biblioteca externa esteja presente. Se você quiser executar o app
em um emulador, crie um AVD que inclua a biblioteca necessária. Para isso, pode ser preciso usar
um componente de complemento para a plataforma do AVD. Por exemplo, o complemento de APIs
do Google contém a biblioteca do Google Maps.

A página Verify Configuration é exibida.

4.4 Executar apps no Android Emulator 217

5. Altere as propriedades do AVD conforme necessário e clique em Finish.

Clique em Show Advanced Settings para mostrar mais configurações, como a aparência.
O novo AVD é exibido na página Your Virtual Devices ou na caixa de diálogo Select Deploy-
ment Target.
Para criar um AVD de uma cópia:
1. Na página Your Virtual Devices do AVD Manager, clique com o botão direito em um AVD
e selecione Duplicate.
Ou clique em Menu  e selecione Duplicate.
A página Verify Configuration é exibida.
2. Clique em Change ou Previous se precisar fazer alterações nas páginas System Image e
Select Hardware.
3. Faça suas alterações e clique em Finish.
O AVD é exibido na página Your Virtual Devices.
Criar um perfil de hardware
O AVD Manager oferece perfis de hardware predefinidos para dispositivos comuns. Assim, você
pode adicioná-los facilmente às definições do seu AVD. Se você precisar definir outro dispositivo,
poderá criar um novo perfil de hardware. Você pode definir um novo perfil de hardware do início
ou copiar um perfil de hardware como ponto de partida. Os perfis de hardware pré-carregados não
são editáveis.
Para criar um novo perfil de hardware desde o início:
1. Na página Select Hardware, clique em New Hardware Profile.
2. Na página Configure Hardware Profile, altere as propriedades do perfil de hardware con-
forme necessário.
3. Clique em Finish.
Seu novo perfil de hardware é exibido na página Select Hardware. Também é possível criar
um AVD que use o perfil de hardware clicando em Next. Ou clique em Cancel para voltar à página
Your Virtual Devices ou à caixa de diálogo Select Deployment Target.
Para criar um perfil de hardware de uma cópia:
1. Na página Select Hardware, selecione o perfil de hardware e clique em Clone Device.
Ou então, clique com o botão direito no perfil de hardware e selecione Clone.
218 Capítulo 4. Ferramentas de Desenvolvimento para Android

2. Na página Configure Hardware Profile, altere as propriedades do perfil de hardware con-

forme necessário.
3. Clique em Finish.
Seu novo perfil de hardware é exibido na página Select Hardware. Também é possível criar
um AVD que use o perfil de hardware clicando em Next. Ou clique em Cancel para voltar à página
Your Virtual Devices ou à caixa de diálogo Select Deployment Target.
Editar AVDs existentes
Na página Your Virtual Devices, você pode realizar as seguintes operações em um AVD
existente:
• Para editar um AVD, clique em Edit this AVD Ò e faça suas alterações.
• Para excluir um AVD, clique com o botão direito nele e selecione Delete . Ou então, clique
em Menu  e selecione Delete.
• Para mostrar os arquivos .ini e .img do AVD em questão no disco, clique com o botão direito
em um AVD e selecione Show on Disk. Ou então, clique em Menu  e selecione Show
on Disk.
• Para ver os detalhes de configuração de um AVD que você pode incluir em qualquer relatório
de bugs para a equipe do Android Studio, clique com o botão direito no AVD e selecione
View Details. Ou então, clique em Menu  e selecione View Details.
Editar perfis de hardware existentes
Na página Select Hardware, você pode realizar as seguintes operações em um perfil de
hardware existente:
• Para editar um perfil de hardware, selecione-o e clique em Edit Device. Ou então, clique
com o botão direito no perfil de hardware e selecione Edit. Em seguida, faça suas alterações.
• Para excluir um perfil de hardware, clique nele com o botão direito e selecione Delete.
Não é possível editar nem excluir os perfis de hardware predefinidos.
Executar e parar um emulador, e limpar os dados
Na página Your Virtual Devices, você pode realizar as seguintes operações em um emulador:
• Para executar um emulador que usa um AVD, clique duas vezes no AVD. Ou clique em
Launch Ù .
• Para interromper a execução de um emulador, clique com o botão direito em um AVD e
selecione Stop. Ou clique em Menu  e selecione Stop.
• Para limpar os dados de um emulador e retorná-lo ao mesmo estado da primeira definição,
clique com o botão direito em um AVD e selecione Wipe Data. Ou clique em Menu  e
selecione Wipe Data.
Importar e exportar perfis de hardware
Na página Select Hardware, você pode importar e exportar perfis de hardware:
• Para importar um perfil de hardware, clique em Import Hardware Profiles e selecione o
arquivo XML que contém a definição no seu computador.
• Para exportar um perfil de hardware, clique nele com o botão direito e selecione Export.
Especifique o local onde o arquivo XML que contém a definição será armazenado.
Propriedades de um perfil de hardware
Você pode especificar as seguintes propriedades de perfis de hardware na página Configure
Hardware Profile. As propriedades de configuração de um AVD substituem as propriedades de
um perfil de hardware, e as propriedades do emulador definidas enquanto ele está em execução
substituem ambas.
Os perfis de hardware predefinidos inclusos no AVD Manager não são editáveis. No entanto,
você pode copiá-los e editar as cópias.
4.4 Executar apps no Android Emulator 219

Propriedades de um perfil de hardware Descrição

Propriedades de um perfil de hardware Descrição

Device Name Nome do perfil de hardware. O nome pode conter letras maiúscu
Device Type Selecione uma das seguintes opções:
• Smartphone/Tablet
• Wear OS
• Android TV
• Dispositivo Chrome OS
• Android Automotive

Screen Size O tamanho físico da tela, em polegadas, medido na diagonal. Se

Screen Resolution Digite uma largura e uma altura em pixels para especificar o tota
Round Selecione essa opção se o dispositivo tiver uma tela redonda, com
Memory: RAM Digite o tamanho da RAM do dispositivo e selecione a unidade B
Input: Has Hardware Buttons (Back/Home/Menu) Marque essa opção se seu dispositivo tiver botões de navegação
Input: Has Hardware Keyboard Marque essa opção se seu dispositivo tiver um teclado de hardwa
Navigation Style Selecione uma das seguintes opções:
• None: nenhum controle de hardware. A
navegação é realizada pelo software
• D-pad: compatível com o botão
direcional
• Trackball
• Wheel
Essas opções destinam-se aos controles de
hardware do dispositivo em si. No entanto, os
eventos enviados para o dispositivo por um
controlador externo são os mesmos.
Supported Device States Selecione uma ou ambas as opções:
• Portrait: a orientação é mais alta do que
larga.
• Landscape: a orientação é mais larga do
que alta.
Se você selecionar ambas as opções, poderá
alternar entre as orientações no emulador. É
preciso selecionar pelo menos uma opção para
continuar.
Cameras Para ativar a câmera, selecione uma ou ambas
as opções:
• Back-Facing Camera: a lente está na
direção oposta ao usuário.
• Front-Facing Camera: a lente está na
direção do usuário.
Posteriormente, você poderá usar uma
webcam ou foto disponibilizada pelo
emulador para simular o registro de uma foto
com a câmera.
Sensors: Accelerometer Selecione se o dispositivo tiver um hardware que o ajude a deter
220 Capítulo 4. Ferramentas de Desenvolvimento para Android

Propriedades de um perfil de hardware Descrição

Sensors: Gyroscope Selecione se o dispositivo tiver um hardware que detecte rotação
Sensors: GPS Selecione se o dispositivo tiver um hardware compatível com a n
Sensors: Proximity Sensor Selecione se o dispositivo tiver um hardware que detecte se ele e
Default Skin Selecione uma opção que controle a aparência do dispositivo qu

Propriedades de um AVD
Você pode especificar as seguintes propriedades para as configurações do AVD na página
Verify Configuration. A configuração do AVD especifica a interação entre o computador de
desenvolvimento e o emulador, além das propriedades que você queira substituir no perfil de
hardware.
As propriedades da configuração do AVD substituem as propriedades do perfil de hardware. As
propriedades do emulador definidas enquanto ele está em execução substituem ambas.

Propriedade do AVD Descrição

AVD Name Nome do AVD. O nome pode conter letras maiúsculas e minú
AVD ID (Advanced) O nome de arquivo do AVD é derivado do código, e você pod
Hardware Profile Clique em Change para selecionar outro perfil de hardware n
System Image Clique em Change para selecionar outra imagem de sistema
Startup Orientation Selecione uma opção para a orientação inicial
do emulador:
• Portrait: a orientação é mais alta do que
larga.
• Landscape: a orientação é mais larga do
que alta.
Uma opção só será ativada se estiver
selecionada no perfil de hardware. Ao
executar o AVD no emulador, você poderá
alterar a orientação se ambas as opções forem
compatíveis com o perfil de hardware.
Camera (Advanced) Para ativar uma câmera, selecione uma ou
ambas as opções:
• Front: a lente está na direção oposta ao
usuário.
• Back: a lente está na direção do usuário.
A configuração Emulated produz uma
imagem gerada por software, e a configuração
Webcam usa a webcam do computador de
desenvolvimento para tirar uma foto.
Essa opção só será disponibilizada se for
selecionada no perfil de hardware. Ela não
está disponível para dispositivos Android
Wear e Android TV.
4.4 Executar apps no Android Emulator 221

Propriedade do AVD Descrição

Network: Speed (Advanced) Selecione um protocolo de rede para
determinar a velocidade da transferência de
dados:
• GSM: Global System for Mobile
Communications
• HSCSD: High-Speed Circuit-Switched
Data
• GPRS: Generic Packet Radio Service
• EDGE: Enhanced Data rates for GSM
Evolution
• UMTS: Universal Mobile
Telecommunications System
• HSDPA: High-Speed Downlink Packet
Access
• LTE: Long-Term Evolution
• Full (default): transfira dados com a
velocidade máxima permitida pelo
computador

Network: Latency (Advanced) Selecione um protocolo de rede para definir quanto tempo (at
Emulated Performance: Graphics Selecione como gráficos são renderizados no
emulador:
• Hardware: use a placa de vídeo do
computador para renderizar mais
rapidamente.
• Software: emule os elementos gráficos
no software, o que será útil se você tiver
problemas para renderizar na placa de
vídeo.
• Auto: deixe que o emulador decida a
melhor opção de acordo com sua placa
de vídeo.

Emulated Performance: Boot option • Cold boot: inicie o dispositivo a cada

(Advanced) vez, ligando-o a partir do estado de
dispositivo desligado.
• Quick boot: inicie o dispositivo
carregando o estado a partir de um
instantâneo salvo. Para saber mais
detalhes, consulte Executar o emulador
com Quick Boot.

Emulated Performance: Multi-Core CPU (Advanced) Selecione o número de núcleos de processador que você quer
Memory and Storage: RAM A quantidade de RAM no dispositivo. Esse valor é definido p
Memory and Storage: VM Heap O tamanho de heap da VM. Esse valor é definido pelo fabrica
Memory and Storage: Internal Storage A quantidade de espaço disponível na memória não removíve
Memory and Storage: SD Card A quantidade de espaço disponível para armazenar dados na
Device Frame: Enable Device Frame Selecione para ativar um quadro em volta da janela do emula
222 Capítulo 4. Ferramentas de Desenvolvimento para Android

Propriedade do AVD Descrição

Custom Skin Definition (Advanced) Selecione uma opção que controle a aparência do dispositivo
Keyboard: Enable Keyboard Input (Advanced) Selecione essa opção se quiser usar o teclado do hardware pa

Criar uma aparência de emulador

Uma aparência de emulador do Android é um conjunto de arquivos que definem os elementos
visuais e de controle da tela de um emulador. Se as definições de aparência disponíveis nas
configurações do AVD não atenderem aos seus requisitos, você poderá criar a própria definição de
aparência personalizada e aplicá-la ao AVD.
Cada aparência de emulador contém:
• Um arquivo [Link]
• Arquivos de layout para as orientações (paisagem, retrato) e configurações físicas compatíveis
• Arquivos de imagem para elementos de exibição, como plano de fundo, teclas e botões
Para criar e usar uma aparência personalizada:
1. Crie um novo diretório para salvar seus arquivos de configuração da aparência.
2. Defina a aparência visual em um arquivo de texto com o nome layout. Esse arquivo define
muitas características da aparência, como o tamanho e os recursos de imagem para botões
específicos. Por exemplo:
parts {
device {
display {
width 320
height 480
x 0
y 0
}
}

portrait {
background {
image background_port.png
}

buttons {
power {
image button_vertical.png
x 1229
y 616
}
}
}
...

3. Adicione os arquivos bitmap das imagens do dispositivo no mesmo diretório.

4. Especifique outras configurações de dispositivo específicas de hardware em um arquivo
[Link] para as configurações do dispositivo, como [Link] e [Link].
4.4 Executar apps no Android Emulator 223

5. Coloque os arquivos na pasta de aparências e selecione o arquivo como aparência personali-

zada.
Para ver informações mais detalhadas sobre como criar aparências de emulador, consulte
Especificação de arquivos de aparência para o Android Emulator no código-fonte das ferramentas.
Iniciar o emulador pela linha de comando
O Android SDK inclui um emulador de dispositivo Android, um dispositivo virtual que é
executado no computador. O Android Emulator permite desenvolver e testar apps Android sem
usar um dispositivo físico.
Esta página descreve os recursos de linha de comando que você pode usar com o Android
Emulator. Para mais informações sobre como usar a IU do Android Emulator, consulte Executar
aplicativos no Android Emulator.
Como iniciar o emulador
Use o comando emulator para iniciar o emulador, como uma alternativa para executar seu
projeto ou iniciá-lo com o AVD Manager.
Esta é a sintaxe básica da linha de comando para iniciar um dispositivo virtual a partir de um
prompt de terminal:
emulator -avd avd_name [ {-option [value]} . . . ]
Ou
emulator @avd_name [ {-option [value]} . . . ]
Por exemplo, se você iniciar o emulador a partir do Android Studio em execução em um Mac, a
linha de comando padrão será semelhante à seguinte:
/Users/janedoe/Library/Android/sdk/emulator/emulator -avd Nexus_5X_API_23 -netdelay
none -netspeed full
Você pode especificar opções de inicialização ao iniciar o emulador, mas não depois disso.
Para uma lista de nomes de AVD, digite o seguinte comando:
emulator -list-avds
Quando você usa essa opção, ela exibe uma lista de nomes de AVD do seu diretório inicial
do Android. Observe que você pode modificar o diretório inicial padrão configurando a variável
de ambiente ANDROID_SDK_HOME: a raiz do diretório específico do usuário onde toda a
configuração e o conteúdo do AVD é armazenado. Você poderia definir a variável de ambiente na
janela de terminal antes de iniciar um dispositivo virtual ou poderia defini-lo nas configurações de
usuário no sistema operacional. Por exemplo, no arquivo .bashrc no Linux.
Para parar o Android Emulator, basta fechar a janela do emulador.
Instalação de um app
Além de instalar um app no Android Studio ou na IU do emulador, é possível instalar o app em
um dispositivo virtual usando o utilitário adb.
Para instalar um app usando o adb e, em seguida, executá-lo e testá-lo, siga estas etapas gerais:
1. Crie e empacote o app em um APK, conforme descrito em Compilar e executar seu aplicativo.
2. Inicie o emulador a partir da linha de comando, conforme descrito na seção anterior, usando
qualquer opção de inicialização necessária.
3. Instale o app usando o adb.
4. Execute e teste o app no emulador.
Enquanto o emulador estiver em execução, você também poderá usar o Console do Emulator
para emitir comandos conforme necessário.
5. O dispositivo virtual preserva o app e os dados de estado dele nas reinicializações, em uma
partição de disco de dados do usuário ([Link]). Para limpar esses dados, inicie o
emulador com a opção -wipe-data ou limpe os dados no AVD Manager, por exemplo. Para
mais informações sobre a partição de dados do usuário e outro armazenamento, consulte a
224 Capítulo 4. Ferramentas de Desenvolvimento para Android

seção a seguir.
Para desinstalar um app, faça isso da maneira como você faria em um dispositivo Android.
Observação: o utilitário adb considera o dispositivo virtual como um dispositivo físico real.
Por esse motivo, talvez seja necessário usar a sinalização -d com alguns comandos adb comuns,
como install. A sinalização -d permite especificar quais dos vários dispositivos conectados precisam
ser usados como destino de um comando. Se você não especificar -d, o emulador segmentará o
primeiro dispositivo da lista dele.
Noções básicas sobre os diretórios e arquivos padrão
O emulador utiliza arquivos associados, sendo que o sistema AVD e os diretórios de dados
são os mais importantes. Ele ajuda a entender a estrutura de diretórios e arquivos do emulador
ao especificar opções de linha de comando. No entanto, não costuma ser necessário modificar os
diretórios ou arquivos padrão.
O Android Emulator usa o hipervisor Quick Emulator (QEMU, link em inglês). As versões
iniciais do Android Emulator usavam o QEMU 1 (goldfish) e versões posteriores usavam o QEMU
2 (ranchu).
Diretório do sistema AVD
O diretório do sistema contém as imagens do sistema Android que o emulador usa para simular
o sistema operacional. Ele tem arquivos somente leitura específicos da plataforma compartilhados
por todos os AVDs do mesmo tipo, incluindo o nível da API, a arquitetura da CPU e a variante do
Android. Os locais padrão são os seguintes:
• Mac OS X e Linux: ~/Library/Android/sdk/system-images/android-apiLevel/variant/arch/
• Microsoft Windows XP: C:\Documents and Settings\user\Library\Android\sdk\system-images\android-
apiLevel\variant\arch\
• Windows Vista: C:\Users\user\Library\Android\sdk\system-images\android-apiLevel\variant\arch\
Em que:
• apiLevel é um nível numérico de API, ou uma letra para versões de pré-lançamento. Por
exemplo, android-M indicava a versão de pré-lançamento do Android Marshmallow. No
lançamento, tornou-se uma API de nível 23, designada por android-23;
• variant é um nome que corresponde a recursos específicos implementados pela imagem do
sistema; por exemplo, google_apis ou android-wear;
• arch é a arquitetura de CPU de destino. Por exemplo, x86.
Use a opção -sysdir para especificar um diretório de sistema diferente para o AVD.
O emulador lê os seguintes arquivos do diretório do sistema.

Arquivo Descrição
kernel-qemu ou kernel-ranchu A imagem do kernel binário para o AVD. kernel-ranchu é o emulador do QEMU 2, a
[Link] A versão inicial somente leitura da imagem do sistema. Especificamente, a partição
[Link] A imagem da partição de inicialização. Este é um subconjunto de [Link] que é
[Link] A versão inicial da partição de dados, que aparece como data/ no sistema emulado e

Diretório de dados AVD

O diretório de dados AVD, também chamado de diretório de conteúdo, é específico para uma
única instância do AVD e contém todos os dados modificáveis do AVD.
O local padrão é o seguinte, onde name é o nome do AVD:
• Mac OS X e Linux: ~/.android/avd/[Link]/
• Microsoft Windows XP: C:\Documents and Settings\user\.android\[Link]\
• Windows Vista e versões posteriores: C:\Users\user\.android\[Link]\
Use a opção -datadir para especificar um diretório diferente de dados do AVD.
4.4 Executar apps no Android Emulator 225

A tabela a seguir lista os arquivos mais importantes contidos nesse diretório.

Arquivo Descrição
[Link] O conteúdo da partição de
dados, que aparece como
data/ no sistema emulado.
Quando você cria um novo
AVD, ou quando você usa a
opção -wipe-data para
redefinir o AVD para os
padrões de fábrica, o
emulador copia o arquivo
[Link] no diretório do
sistema para criar esse
arquivo.
Cada instância de dispositivo
virtual usa uma imagem de
dados do usuário gravável
para armazenar dados
específicos do usuário e da
sessão. Por exemplo, ela usa
a imagem para armazenar
dados, configurações, bancos
de dados e arquivos de apps
instalados de um usuário
único. Cada usuário tem um
diretório
ANDROID_SDK_HOME
diferente que armazena os
diretórios de dados para os
AVDs criados por esse
usuário. Cada AVD tem um
único arquivo
[Link].
[Link] A imagem da partição de cache, que aparece como cache/ no sistema emulado. Ela nã
226 Capítulo 4. Ferramentas de Desenvolvimento para Android

Arquivo Descrição
[Link] (Opcional) Uma imagem da
partição do cartão SD que
permite simular um cartão
SD em um dispositivo virtual.
Você pode criar um arquivo
de imagem de cartão SD no
AVD Manager ou usando a
ferramenta mksdcard. O
arquivo é armazenado no
computador de
desenvolvimento e precisa ser
carregado na inicialização.
Ao definir um AVD no AVD
Manager, você tem a opção
de usar um arquivo de cartão
SD gerenciado
automaticamente ou um
arquivo criado com a
ferramenta mksdcard. Você
pode ver o arquivo
[Link] associado a um
AVD no AVD Manager. A
opção -sdcard modifica o
arquivo do cartão SD
especificado no AVD.
Você pode procurar, enviar,
copiar e remover arquivos de
um cartão SD simulado
usando a IU do emulador ou
o utilitário adb enquanto o
dispositivo virtual estiver em
execução. Não é possível
remover um cartão SD
simulado de um dispositivo
virtual em execução.
Para copiar arquivos para o
arquivo de cartão SD antes de
carregá-lo, você pode montar
o arquivo de imagem como
um dispositivo de loop e
depois copiar os arquivos. Ou
use um utilitário como o
pacote mtools para copiar os
arquivos diretamente para a
imagem.
O emulador trata o arquivo
como um conjunto de bytes,
então o formato do cartão SD
não importa.
Observe que a opção
-wipe-data não afeta este
arquivo. Se você quiser
limpar o arquivo, é preciso
excluí-lo e, em seguida,
4.4 Executar apps no Android Emulator 227

Arquivo Descrição

Listar diretórios e arquivos usados pelo emulador

Você pode descobrir onde os arquivos estão localizados de duas maneiras:
• Ao iniciar o emulador a partir da linha de comando, use a opção -verbose ou -debug init e
observe a saída.
• Use o comando emulator -help-option para listar um diretório padrão. Exemplo:
• emulator -help-datadir
• Use ’-datadir <dir>’ to specify a directory where writable image files
• will be searched. On this system, the default directory is:
•
• /Users/me/.android
•
• See ’-help-disk-images’ for more information about disk image files.
Opções de inicialização de linha de comando
Esta seção lista as opções que você pode fornecer na linha de comando ao iniciar o emulador.
Observação: o Android Emulator está em contínuo desenvolvimento para torná-lo mais
confiável. Para ver mais informações sobre os problemas relatados em várias opções de linha de
comando e informar bugs, consulte o Rastreador de problemas do Android.
Opções usadas com mais frequência
A tabela a seguir lista as opções de inicialização da linha de comando que você pode usar com
mais frequência.

Opção da linha de comando Descrição

Inicialização rápida
-no-snapshot-load Executa uma inicialização a frio e salva o estado do emulador na saíd
-no-snapshot-save Executa uma inicialização rápida, se possível, mas não salva o estado
-no-snapshot Desativa completamente o recurso Quick Boot. Não carrega nem sal
Hardware do dispositivo
-camera-back mode Defina o modo de emulação para uma câmera
-camera-front mode voltada para trás ou para frente. Isso modifica
qualquer configuração de câmera no AVD.
O mode pode ter qualquer um dos seguintes
valores:
• emulated: o emulador simula uma
câmera no software.
• webcamn: o emulador usa uma webcam
conectada ao computador de
desenvolvimento, especificada por
número. Para uma lista de webcams,
use a opção -webcam-list. Por exemplo,
webcam0.
• none: desativa a câmera no dispositivo
virtual.
Exemplo:
emulator @Nexus_5X_API_23 -camera-back
webcam0
228 Capítulo 4. Ferramentas de Desenvolvimento para Android

Opção da linha de comando Descrição

-webcam-list Liste as webcams que estão disponíveis para
emulação no computador de desenvolvimento.
Por exemplo:
emulator @Nexus_5X_API_23 -webcam-list
List of web cameras connected to the
computer:
Camera ’webcam0’ is connected to device
’webcam0’
on channel 0 using pixel format ’UYVY’

No exemplo, a primeira webcam0 é o nome

que você usa na linha de comando. A segunda
webcam0 é o nome usado pelo sistema
operacional no computador de
desenvolvimento. O segundo nome varia de
acordo com o sistema operacional.
A partir das Ferramentas do SDK 25.2.4, o
nome do AVD é obrigatório, embora possa
não ser no futuro.
Imagens do disco e memória
-memory size Especifique o tamanho da RAM física de 128
a 4.096 MB. Exemplo:
emulator @Nexus_5X_API_23 -memory
2048

Esse valor substitui a configuração do AVD.

-sdcard filepath Especifique o nome do arquivo e o caminho
para um arquivo de imagem da partição do
cartão SD. Por exemplo:
emulator @Nexus_5X_API_23 -sdcard
C:/sd/[Link]
4.4 Executar apps no Android Emulator 229

Se o arquivo não for encontrado, o emulador

ainda será aberto, mas sem um cartão SD. O
comando retornará um aviso No SD Card
Image.
Se você não especificar essa opção, o padrão
será [Link] no diretório de dados (a
menos que o AVD especifique algo diferente).
Para detalhes sobre cartões SD emulados,
consulte o diretório de dados do AVD.
-wipe-data Exclua os dados do usuário e copie os dados
do arquivo de dados inicial. Essa opção limpa
os dados do dispositivo virtual e os retorna ao
mesmo estado em que foram definidos pela
primeira vez. Todos os apps e configurações
instalados são removidos. Exemplo:
emulator @Nexus_5X_API_23 -wipe-data

Por padrão, o arquivo de dados do usuário é [Link] e o arquivo de dados inicial é [Link], ambos re
Depurar
-debug tags

Para desativar uma tag, coloque um traço (-) na frente dela. Por exemplo, a opção a seguir exibe
todas as mensagens de depuração, exceto aquelas relacionadas a métricas e soquetes de rede:
-debug all,-socket,-metrics
Para ver uma lista de tags e descrições, use a opção -help-debug-tags. Exemplo:
emulator -help-debug-tags
Você pode definir as tags de depuração padrão na variável de ambiente ANDROID_VERBOSE.
Defina as tags que você quer usar em uma lista delimitada por vírgulas. Aqui está um exemplo
mostrando uma lista definida com as tags socket e gles:
ANDROID_VERBOSE=socket,gles

Isso é equivalente a usar:

-debug-socket -debug-gles
-debug-tag Ative um tipo de mensagem de depuração
-debug-no-tag específico. Utilize a forma no para desativar
um tipo de mensagem de depuração.
Exemplo:
emulator @Nexus_5X_API_23 -debug-all
-debug-no-metrics
230 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para uma lista de tags, use o comando emulator -help-debug-tags.

-logcat logtags Ative a exibição de mensagens do logcat para
uma ou mais tags e grave-as na janela de
terminal. Por exemplo, o comando a seguir
ativa mensagens de erro de todos os
componentes:
emulator @Nexus_5X_API_23 -logcat *:e

logtags usa o mesmo formato do comando adb logcat logtags (digite adb logcat -help para
ver mais informações). É uma lista de filtros de registro separados por espaço ou vírgula, no
formato componentName:logLevel. E componentName é um asterisco curinga (*) ou um nome de
componente, como ActivityManager, SystemServer, InputManager, WindowManager e assim por
diante. logLevel é um destes valores:
• v: detalhado
• d: depuração
• i: informativo
• w: nível de registro de aviso
• e: erro
• s: silencioso
O exemplo a seguir exibe mensagens do componente GSM no nível de registro informativo:
emulator @Nexus_5X_API_23 -logcat ’*:s GSM:i’

Se você não fornecer a opção -logcat na linha de comando, o emulador procurará a variável de ambiente ANDROID_
-show-kernel

Um uso dessa opção é verificar se o processo de inicialização funciona corretamente.

-verbose Imprima mensagens de inicia
emulador na janela do termin
emulator @Nexus_5X_API_2

Ele exibe quais arquivos e configurações estão realmente selecionados ao iniciar um dispositivo virtual definido em u
Rede
-dns-server servers
4.4 Executar apps no Android Emulator 231

Por padrão, o emulador tenta detectar os servidores DNS que você está usando e configura aliases especiais na rede d
-http-proxy proxy

proxy pode ser um dos seguintes:

[Link]
[Link]
O prefixo http:// pode ser omitido.
Se essa opção não for fornecida, o emulador
procurará a variável de ambiente http_proxy e
usará automaticamente qualquer valor
correspondente ao formato do proxy. Para
mais informações, consulte Usar o emulador
com um proxy
-netdelay delay Defina a emulação de latência de rede para um
dos seguintes valores de delay em
milissegundos:
• gsm: GSM/CSD (mín 150, máx 550).
• hscsd: HSCSD (mín 80, máx 400).
• gprs: GPRS (mín 35, máx 200).
• edge: EDGE/EGPRS (mín 80, máx
400).
• umts: UMTS/3G (mín 35, máx 200).
• hsdpa: HSDPA (mín 0, máx 0).
• lte: LTE (mín 0, máx 0).
• evdo: EVDO (mín 0, máx 0).
• none: sem latência, o padrão (mín 0,
máx 0).
• num: especifica a latência exata.
• min:max: especifica as latências mínima
e máxima individuais.
Exemplo:
emulator @Nexus_5X_API_23 -netdelay gsm

O emulador é compatível com a limitação de rede (limitando a largura de banda máxima da rede, também chamada d
-netfast
232 Capítulo 4. Ferramentas de Desenvolvimento para Android

Essa opção é o mesmo que especificar -netspeed full -netdelay none. Esses são os valores padrão para essas opções.
-netspeed speed

O emulador é compatível com a limitação de rede (limitando a largura de banda máxima da rede, também chamada d
-port port
4.4 Executar apps no Android Emulator 233

O valor padrão é 5554 para a primeira

instância de dispositivo virtual em execução
na sua máquina. Um dispositivo virtual
normalmente ocupa um par de portas
adjacentes: uma porta de console e uma porta
adb. O console do primeiro dispositivo virtual
em execução em uma determinada máquina
usa a porta do console 5554 e a porta adb 5555.
Instâncias subsequentes usam números de
porta crescentes de dois em dois, por exemplo,
5556/5557, 5558/5559 e assim por diante. O
intervalo é de 5554 a 5682, permitindo 64
dispositivos virtuais simultâneos.
As atribuições de porta geralmente são o
mesmo que especificar -ports port,{port + 1}.
A {port + 1} precisa estar livre e será
reservada para o adb. Se qualquer uma das
portas do console ou adb já estiver em uso, o
emulador não será iniciado. A opção -port
informa quais portas e número de série o
dispositivo virtual está usando e avisa se há
algum problema com os valores fornecidos.
Na IU do emulador, você pode ver o número
da porta do console no título da janela e
visualizar o número da porta do adb
selecionando Help > About.
Observe que, se o valor de port não for
uniforme e estiver no intervalo de 5554 a
5584, o dispositivo virtual será iniciado, mas
não ficará visível quando você usar o comando
adb devices se o servidor adb iniciar após o
emulador. Por esse motivo, recomendamos o
uso de um número de porta par para o console.
-ports Defina as portas TCP usadas para o console e
console-port,adb-port o adb. Exemplo:
emulator @Nexus_5X_API_23 -ports
5556,5559
234 Capítulo 4. Ferramentas de Desenvolvimento para Android

O intervalo de portas válido é de 5554 a 5682,

permitindo 64 dispositivos virtuais
simultâneos. A opção -ports informa quais
portas e número de série a instância do
emulador está usando e avisa se há algum
problema com os valores fornecidos.
Recomendamos usar a opção -port em vez
disso, quando possível. A opção -ports está
disponível para configurações de rede que
exigem configurações especiais.
Para mais informações sobre a configuração
de portas do console e do adb, consulte a
opção -port.
-tcpdump filepath Capture os pacotes de rede e armazene-os em
um arquivo. Exemplo:
emulator @Nexus_5X_API_23 -tcpdump
/path/[Link]

Use a opção para começar a capturar todos os

pacotes de rede que são enviados por meio da
LAN Ethernet virtual do emulador. Depois,
você pode usar uma ferramenta como o
Wireshark para analisar o tráfego.
Observe que essa opção captura todos os
pacotes Ethernet e não está limitada a
conexões TCP.
Sistema
-accel mode Configure a aceleração da VM do emulador.
Exemplo:
emulator @Nexus_5X_API_23 -accel auto
4.4 Executar apps no Android Emulator 235

A emulação acelerada funciona apenas para

imagens do sistema x86 e x86_64. No Linux,
ela depende da KVM. No Windows e Mac, ela
conta com CPU da Intel e um driver Intel
HAXM. Essa opção é ignorada se você não
estiver emulando um dispositivo x86 ou
x86_64.
Valores válidos para o mode são:
• auto: determina automaticamente se a
aceleração é compatível e a utiliza
quando possível (padrão).
• off: desativa totalmente a aceleração, o
que é útil principalmente para
depuração.
• on: força de aceleração. Se a KVM ou o
HAXM não estiverem instalados ou não
forem utilizáveis, o emulador não será
iniciado e imprimirá uma mensagem de
erro.
Para mais informações, consulte Configurar a
aceleração de hardware.
-accel-check Verifique se um hipervisor obrigatório para
aceleração de VM do emulador está instalado
(HAXM ou KVM). Exemplo:
emulator -accel-check

Para mais informações, consulte Determinar se o HAXM ou a KVM estão instalados.

-engine engine Especifique o mecanismo do
• auto: seleciona automa
mecanismo (padrão).
• classic: usa o antigo me
1.
• qemu2: usa o novo me
2.
Exemplo:
emulator @Nexus_5X_API_

A detecção automática precisa escolher o valor que fornece o melhor desempenho ao emular um determinado AVD. U
-gpu mode
236 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para mais informações, consulte Configurar a aceleração de gráficos na linha de comando.

-no-accel Desative a aceleração da
usar uma imagem do sis
É útil apenas para depura
especificar -accel off. Ex
emulator @Nexus_5X_A

Para mais informações, consulte Configurar a aceleração de hardware.

-nojni Desative as verificações estendidas de Java
-no-jni Native Interface (JNI) no ambiente de
execução do Android Dalvik ou ART.
Exemplo:
emulator @Nexus_5X_API_23 -nojni

Quando você inicia um dispositivo virtual, as verificações de JNI estendidas são ativadas por padrão. Para mais inform
-selinux {disabled|permissive}

Por padrão, o SELinux está em modo de imposição, o que significa que a política de segurança é aplicada. O modo pe
-timezone timezone
4.4 Executar apps no Android Emulator 237

Por padrão, o emulador usa o fuso horário do

computador de desenvolvimento. Use essa
opção para especificar um fuso horário
diferente ou se a detecção automática não
estiver funcionando corretamente. O valor de
timezone precisa estar no formato zoneinfo,
que é area/location ou area/subarea/location.
Exemplo:
• America/Los_Angeles
• Europe/Paris
• America/Argentina/Buenos_Aires
O fuso horário especificado precisa estar no
banco de dados zoneinfo.
-version Exibir o número da versão do emulador.
Exemplo:
emulator @Nexus_5X_API_23 -version

Ou
emulator -version

IU
-no-boot-anim Desativar a animação de inicialização durante
a inicialização do emulador para inicialização
mais rápida. Exemplo:
emulator @Nexus_5X_API_23 -no-boot-anim

Em computadores mais lentos, essa opção pode acelerar significativamente a sequência de inicialização.
-screen mode Defina o m
Exemplo:
emulator @
no-touch

O mode pode ter qualquer um dos seguintes valores:

• touch: emular uma tela touch (padrão).
• multi-touch: emular uma tela multi-touch.
• no-touch: desativar a emulação de tela touch e multi-touch.

Opções avançadas
As seguintes opções de inicialização de linha de comando estão disponíveis, mas não são usadas
normalmente pelo desenvolvedor médio de apps.
Nas descrições, o diretório de trabalho é o diretório atual no terminal onde você está inserindo
comandos. Para mais informações sobre o diretório do sistema AVD e o diretório de dados, assim
como sobre os arquivos armazenados neles, consulte Noções básicas sobre os diretórios e arquivos
padrão.
238 Capítulo 4. Ferramentas de Desenvolvimento para Android

Algumas dessas opções são apropriadas para desenvolvedores de apps externos e algumas delas
são usadas principalmente por desenvolvedores de plataformas. Os desenvolvedores de apps criam
apps Android e os executam em AVDs específicos. Os desenvolvedores de plataformas trabalham
no sistema Android e o executam dentro do emulador sem nenhum AVD pré-criado. Eles são
membros internos da equipe do Android, não são desenvolvedores de apps externos.

Opção avançada Breve descrição

-bootchart timeout Ative a inicialização, com um tempo limite em
segundos. Algumas imagens do sistema
Android têm um sistema init modificado que
integra um recurso de inicialização (link em
inglês). Você pode passar um período de
tempo limite de inicialização para o sistema
com essa opção. Se seu sistema init não tiver a
inicialização ativada, a opção não fará nada.
Essa opção é útil principalmente para
desenvolvedores de plataformas, não para
desenvolvedores de apps externos.
Exemplo:
emulator @Nexus_5X_API_23 -bootchart 120
-cache filepath Especifique um arquivo de imagem da
partição de cache. Forneça um nome de
arquivo e um caminho absoluto ou um
caminho relativo ao diretório de dados, para
configurar um arquivo de cache persistente. Se
o arquivo não existir, o emulador o criará
como um arquivo vazio. Se você não usar essa
opção, o padrão será um arquivo temporário
chamado [Link]. Para mais informações,
consulte o diretório de dados do AVD.
Exemplo:
emulator @Nexus_5X_API_23 -cache
~/.android/avd/Nexus_5X_API_23.avd/cache_persistent.img

-cache-size size Defina o tamanho da partição de cache em

MB. Se você não especificar essa opção, o
padrão será 66 MB. Normalmente, a maioria
dos desenvolvedores de apps não precisa dessa
opção, a menos que precisem fazer o
download de arquivos muito grandes, maiores
do que o cache padrão. Para mais informações
sobre o arquivo de cache, consulte o diretório
de dados do AVD.
Exemplo:
emulator @Nexus_5X_API_23 -cache-size
1000
4.4 Executar apps no Android Emulator 239

-data filepath Defina o arquivo de imagem da partição de

dados do usuário. Forneça um nome de
arquivo e um caminho absoluto ou um
caminho relativo para o diretório de trabalho,
para configurar um arquivo de dados do
usuário persistente. Se o arquivo não existir, o
emulador cria uma imagem a partir do arquivo
[Link] padrão, armazena-o no nome de
arquivo especificado e mantém os dados do
usuário no encerramento. Se você não usar
essa opção, o padrão será um arquivo
chamado [Link]. Para mais
informações sobre o arquivo de dados do
usuário, consulte o diretório de dados do AVD.
Exemplo:
emulator @Nexus_5X_API_23 -data
~/.android/avd/Nexus_5X_API_23.avd/userdata-
[Link]

-datadir dir Especifique um diretório de dados usando um

caminho absoluto. Para mais informações,
consulte o diretório de dados do AVD.
Exemplo:
emulator @Nexus_5X_API_23 -datadir
~/.android/avd/Nexus_5X_API_23.avd/mytest

-force-32bit Use o emulador de 32 bits em plataformas de

64 bits. Ocasionalmente, essa opção é útil
para testes ou depuração. Por exemplo, havia
um problema em que o emulador às vezes não
era executado no Windows de 64 bits, mas era
no de 32 bits. Essa opção foi útil para realizar
comparações a fim de depurar o problema.
Veja um exemplo:
emulator @Nexus_5X_API_23 -force-32bit

-help-disk-images Receba ajuda com relação às imagens de

disco. Fornece informações relevantes para
desenvolvedores de apps e de plataformas.
Exemplo:
emulator -help-disk-images
240 Capítulo 4. Ferramentas de Desenvolvimento para Android

-help-char-devices Receba ajuda com relação às especificações

do caractere device. Um parâmetro de device é
exigido por algumas opções de emulador.
Exemplo:
emulator -help-char-devices

Receba ajuda com relação às imagens de disco

relevantes para desenvolvedores de apps.
Explica onde os arquivos de imagem estão
localizados para um AVD criado com as
ferramentas do SDK. Exemplo:
-help-sdk-images emulator -help-sdk-images
-help-build-images Receba ajuda sobre imagens de disco
relevantes para desenvolvedores de
plataformas. Exemplo:
emulator -help-build-images
-initdata filepath Especifique a versão inicial da partição de
-init-data filepath dados. Depois de excluir permanentemente os
dados do usuário, o emulador copia o
conteúdo do arquivo especificado para os
dados do usuário (por padrão, o arquivo
[Link]) em vez de usar o arquivo
[Link] padrão como a versão inicial.
Especifique o nome do arquivo e um caminho
absoluto ou relativo para o diretório de
trabalho. Se você não especificar um caminho,
ele colocará o arquivo no diretório do sistema.
Para mais informações, consulte o diretório do
sistema AVD.
Exemplo:
emulator @Nexus_5X_API_23 -initdata
~/Library/Android/sdk/system-
images/android-23/
google_apis/x86/[Link]
-kernel filepath Use um kernel emulado específico. Se você
não especificar um caminho, o emulador
procurará no diretório do sistema. Se você não
especificar essa opção, o padrão será
kernel-ranchu. Para mais informações,
consulte o diretório do sistema AVD. Use a
opção -show-kernel para ver as mensagens de
depuração do kernel.
Exemplo:
emulator @Nexus_5X_API_23 -kernel
~/Library/Android/sdk/system-
images/android-23/
google_apis/x86/[Link] -show-kernel
4.4 Executar apps no Android Emulator 241

Receba ajuda com relação às imagens de disco

relevantes para desenvolvedores de apps.
Explica onde os arquivos de imagem estão
localizados para um AVD criado com as
ferramentas do SDK. Exemplo:
-help-sdk-images emulator -help-sdk-images
-noaudio Desative a compatibilidade com áudio para
-no-audio esse dispositivo virtual. Alguns computadores
Linux e Windows têm drivers de áudio com
falhas que causam sintomas diferentes, como
impedir que o emulador seja iniciado. Nesse
caso, você pode usar essa opção para superar o
problema. Como alternativa, você pode usar a
variável de ambiente QEMU_AUDIO_DRV
para alterar o back-end de áudio.
Exemplo:
emulator @Nexus_5X_API_23 -noaudio
-nocache Inicie o emulador sem uma partição de cache.
-no-cache Se você não usar essa opção, o padrão será um
arquivo temporário chamado [Link]. Essa
opção é apenas para desenvolvedores de
plataformas. Para mais informações, consulte
o diretório de dados do AVD.
Exemplo:
emulator @Nexus_5X_API_23 -nocache
-no-snapshot Iniba tanto o carregamento automático quanto
as operações de salvamento, fazendo com que
o emulador execute uma sequência de
inicialização completa e perca o próprio
estado quando fechado. Modifica a opção
-snapshot.
Exemplo:
emulator @Nexus_5X_API_23 -no-snapshot
-no-snapshot-load Evite que o emulador carregue o estado AVD
do armazenamento de snapshots. Execute uma
inicialização completa.
Exemplo:
emulator @Nexus_5X_API_23
-no-snapshot-load
-no-snapshot-save Evite que o emulador salve o estado do AVD
no armazenamento de snapshots ao sair, o que
significa que todas as alterações serão
perdidas.
Exemplo:
emulator @Nexus_5X_API_23
-no-snapshot-save
242 Capítulo 4. Ferramentas de Desenvolvimento para Android

Receba ajuda com relação às imagens de disco

relevantes para desenvolvedores de apps.
Explica onde os arquivos de imagem estão
localizados para um AVD criado com as
ferramentas do SDK. Exemplo:
-help-sdk-images emulator -help-sdk-images
-no-snapshot-update-time Não tente corrigir a hora do relógio do AVD
imediatamente na restauração do snapshot.
Essa opção pode ser útil durante o teste,
porque evita um salto de tempo repentino.
Porém, atualizações de tempo ainda serão
enviadas para o AVD a cada 15 segundos.
Exemplo:
emulator @Nexus_5X_API_23
-no-snapshot-update-time
-no-snapstorage Inicie o emulador sem ativar um arquivo para
armazenar ou carregar snapshots de estado,
forçando uma inicialização completa e
desativando a funcionalidade de snapshot de
estado. Essa opção modifica as opções
-snapstorage e -snapshot.
Exemplo:
emulator @Nexus_5X_API_23
-no-snapstorage
-no-window Desative a exibição da janela gráfica no
emulador. Essa opção é útil ao executar o
emulador em servidores que não têm exibição.
Você ainda poderá acessar o emulador por
meio do adb ou do console. Exemplo:
emulator @Nexus_5X_API_23 -no-window

-partition-size size Especifique o tamanho da partição de dados

do sistema em MB. Exemplo:
emulator @Nexus_5X_API_23 -partition-size
1024
4.4 Executar apps no Android Emulator 243

-prop name=value Defina uma propriedade do sistema Android

no emulador na inicialização. name precisa
ser um nome de propriedade de, no máximo,
32 caracteres sem espaços, e value precisa ser
uma string com, no máximo, 92 caracteres.
Você pode especificar várias opções de -prop
em uma linha de comando. Essa opção pode
ser útil para depuração. Exemplo:
emulator @Nexus_5X_API_23 -prop
[Link].level_raw=80
-prop [Link]=123456

-qemu args Passe argumentos para o software emulador QEMU. Observe que o Q
-qemu -h Veja a ajuda de -qemu. Exemplo:
emulator -qemu -h

-ramdisk filepath Especifique uma imagem de inicialização do

ramdisk. Especifique o nome do arquivo e um
caminho absoluto ou um caminho relativo
para o diretório de trabalho. Se você não usar
essa opção, o padrão será o arquivo
[Link] no diretório do sistema. Para
mais informações, consulte o diretório do
sistema AVD.
Exemplo:
emulator @Nexus_5X_API_23 -ramdisk
~/Library/Android/sdk/system-
images/android-23/
google_apis/x86/[Link]
244 Capítulo 4. Ferramentas de Desenvolvimento para Android

Informe a porta do console para um terceiro

remoto antes de iniciar a emulação. Pode ser
útil para um script de teste automatizado.
socket precisa usar um destes formatos:
• tcp:port[,server][,max=seconds][,ipv6]
•
unix:port[,server][,max=seconds][,ipv6]
Para mais informações, use a opção
-help-report-console conforme descrito em
-report-console socket Ajuda detalhada para uma opção específica.
-shell Crie um console do shell raiz no terminal
atual. Ele difere do comando adb shell das
seguintes maneiras:
• Cria um shell raiz que permite
modificar várias partes do sistema.
• Funciona mesmo se o daemon do adb
no sistema emulado estiver corrompido.
• Pressionar Ctrl + C (No Mac, +
C ) interrompe o emulador, em vez do
shell.
Exemplo:
emulator @Nexus_5X_API_23 -shell
4.4 Executar apps no Android Emulator 245
246 Capítulo 4. Ferramentas de Desenvolvimento para Android

Especifique o nome de um snapshot dentro de

um arquivo de armazenamento de snapshots
para iniciar e salvar operações
automaticamente. Em vez de executar uma
sequência de inicialização completa, o
emulador pode retomar a execução a partir de
um snapshot de estado anterior, que costuma
ser significativamente mais rápido. Quando
você fornece essa opção, o emulador carrega o
snapshot desse nome a partir da imagem e o
salva com o mesmo nome na saída. Se você
não usar essa opção, o padrão será uma
sequência de inicialização completa. Se o
snapshot especificado não existir, o emulador
executará uma sequência de inicialização
completa e uma operação de salvamento.
Consulte a opção -snapstorage para ver mais
informações sobre como especificar um
arquivo de armazenamento de snapshot e o
arquivo padrão.
emulator @Nexus_5X_API_23 -snapshot
snapshot2
É importante lembrar que no processo de
carregamento de um snapshot, todo o
conteúdo do sistema, os dados do usuário e as
imagens do cartão SD são substituídos com o
conteúdo que eles mantinham quando o
snapshot foi feito. A menos que você salve
essas informações em um snapshot diferente,
todas as alterações feitas desde então serão
perdidas.
Você também pode criar um snapshot a partir
do Console do Emulator usando o comando
avd snapshot save name. Para mais
informações, consulte Enviar comandos do
Console do Emulator para um dispositivo
-snapshot name virtual.
Especifique o nome de um snapshot dentro de
um arquivo de armazenamento de snapshots
para iniciar e salvar operações
automaticamente. Em vez de executar uma
sequência de inicialização completa, o
emulador pode retomar a execução a partir de
um snapshot de estado anterior, que costuma
ser significativamente mais rápido. Quando
você fornece essa opção, o emulador carrega o
snapshot desse nome a partir da imagem e o
salva com o mesmo nome na saída. Se você
não usar essa opção, o padrão será uma
sequência de inicialização completa. Se o
snapshot especificado não existir, o emulador
executará uma sequência de inicialização
completa e uma operação de salvamento.
Consulte a opção -snapstorage para ver mais
informações sobre como especificar um
4.4 Executar apps no Android Emulator 247

Especifique o nome de um snapshot dentro de

um arquivo de armazenamento de snapshots
para iniciar e salvar operações
automaticamente. Em vez de executar uma
sequência de inicialização completa, o
emulador pode retomar a execução a partir de
um snapshot de estado anterior, que costuma
ser significativamente mais rápido. Quando
você fornece essa opção, o emulador carrega o
snapshot desse nome a partir da imagem e o
salva com o mesmo nome na saída. Se você
não usar essa opção, o padrão será uma
sequência de inicialização completa. Se o
snapshot especificado não existir, o emulador
executará uma sequência de inicialização
completa e uma operação de salvamento.
Consulte a opção -snapstorage para ver mais
informações sobre como especificar um
arquivo de armazenamento de snapshot e o
arquivo padrão.
emulator @Nexus_5X_API_23 -snapshot
snapshot2
É importante lembrar que no processo de
carregamento de um snapshot, todo o
conteúdo do sistema, os dados do usuário e as
imagens do cartão SD são substituídos com o
conteúdo que eles mantinham quando o
snapshot foi feito. A menos que você salve
essas informações em um snapshot diferente,
todas as alterações feitas desde então serão
perdidas.
Você também pode criar um snapshot a partir
do Console do Emulator usando o comando
avd snapshot save name. Para mais
informações, consulte Enviar comandos do
Console do Emulator para um dispositivo
-snapshot name virtual.
-snapstorage filepath Especifique um arquivo de repositório que
contenha todos os snapshots de estado. Todos
os snapshots criados durante a execução serão
salvos nesse arquivo, e apenas os snapshots
que estiverem nesse arquivo poderão ser
restaurados durante a execução do emulador.
Se você não especificar essa opção, o padrão
será [Link] no diretório de dados. Se o
arquivo especificado não existir, o emulador
será iniciado, mas sem compatibilidade com o
salvamento ou carregamento de snapshots de
estado.
Exemplo:
emulator @Nexus_5X_API_23 -snapstorage
~/.android/avd/Nexus_5X_API_23.avd/snapshots-
[Link]
248 Capítulo 4. Ferramentas de Desenvolvimento para Android

Especifique o nome de um snapshot dentro de

um arquivo de armazenamento de snapshots
para iniciar e salvar operações
automaticamente. Em vez de executar uma
sequência de inicialização completa, o
emulador pode retomar a execução a partir de
um snapshot de estado anterior, que costuma
ser significativamente mais rápido. Quando
você fornece essa opção, o emulador carrega o
snapshot desse nome a partir da imagem e o
salva com o mesmo nome na saída. Se você
não usar essa opção, o padrão será uma
sequência de inicialização completa. Se o
snapshot especificado não existir, o emulador
executará uma sequência de inicialização
completa e uma operação de salvamento.
Consulte a opção -snapstorage para ver mais
informações sobre como especificar um
arquivo de armazenamento de snapshot e o
arquivo padrão.
emulator @Nexus_5X_API_23 -snapshot
snapshot2
É importante lembrar que no processo de
carregamento de um snapshot, todo o
conteúdo do sistema, os dados do usuário e as
imagens do cartão SD são substituídos com o
conteúdo que eles mantinham quando o
snapshot foi feito. A menos que você salve
essas informações em um snapshot diferente,
todas as alterações feitas desde então serão
perdidas.
Você também pode criar um snapshot a partir
do Console do Emulator usando o comando
avd snapshot save name. Para mais
informações, consulte Enviar comandos do
Console do Emulator para um dispositivo
-snapshot name virtual.

-sysdir dir Especifique um diretório do sistema usando

um caminho absoluto. Para mais informações,
consulte o diretório do sistema AVD.
Exemplo:
emulator @Nexus_5X_API_23 -sysdir
~/Library/Android/sdk/system-
images/android-23/
google_apis/x86/test
4.4 Executar apps no Android Emulator 249

-system filepath Especifique um arquivo de sistema inicial.

Forneça o nome do arquivo e um caminho
absoluto ou relativo ao diretório de trabalho.
Se você não usar essa opção, o padrão será o
arquivo [Link] no diretório do sistema.
Para mais informações, consulte o diretório do
sistema AVD. Por exemplo:
emulator @Nexus_5X_API_23 -system
~/Library/Android/sdk/system-
images/android-23/
google_apis/x86/[Link]

No Linux, use o sistema libstdc++ em vez da

versão empacotada com o sistema emulador.
Use essa opção apenas se o emulador não
iniciar normalmente, embora ela nem sempre
funcione. Como alternativa, defina a variável
de ambiente AN-
DROID_EMULATOR_USE_SYSTEM_LIBS
como 1.
Exemplo:
me-linux$ emulator @Nexus_5X_API_23
-use-system-libs -use-system-libs
-writable-system Use essa opção para ter uma imagem do
sistema gravável durante a sessão de
emulação. Para fazer isso:
1. Inicie um dispositivo virtual com a
opção -writable-system.
2. Insira o comando adb remount a partir
de um terminal de comando para dizer
ao emulador para reativar system/ como
leitura/gravação (ele é ativado como
somente leitura por padrão).
Observe que o uso dessa sinalização criará
uma cópia temporária da imagem do sistema
que pode ser muito grande (várias centenas de
MB), mas será destruída quando o emulador
sair.

Opções obsoletas
As seguintes opções da linha de comando estão obsoletas:
• -audio-in
• -audio-out
• -charmap
• -code-profile
• -cpu-delay
• -dpi-device
250 Capítulo 4. Ferramentas de Desenvolvimento para Android

• -dynamic_skin
• -enable-kvm
• -gps
• -image
• -keyset
• -help-keys
• -help-keyset-file
• -nand-limits
• -noskin
• -no-skin
• -onion
• -onion-alpha
• -onion-rotation
• -radio
• -ranchu
• -raw-keys
• -scale
• -shared-net-id
• -shell-serial
• -skin
• -skindir
• -trace
• -useaudio
Ajuda sobre opções de linha de comando
Esta seção descreve como receber ajuda com relação às opções de linha de comando. A seção
a seguir fornece informações mais detalhadas sobre as opções de linha de comando do emulador
normalmente usadas que estão disponíveis quando você inicia o emulador.
Listar todas as opções do emulador
Para imprimir uma lista de todas as opções do emulador, incluindo uma breve descrição, insira
este comando:
emulator -help
Ajuda detalhada para uma opção específica
Para imprimir ajuda para uma opção de inicialização específica, insira este comando:
emulator -help-option
Exemplo:
emulator -help-netspeed
Essa ajuda é mais detalhada que a descrição fornecida pela opção -help.
Ajuda detalhada para todas as opções
Para receber ajuda detalhada sobre todas as opções do emulador, insira este comando:
emulator -help-all
Listar variáveis de ambiente do emulador
Para ver uma lista de variáveis de ambiente do emulador, insira este comando:
emulator -help-environment
Você pode definir variáveis de ambiente na janela do terminal antes de iniciar um dispositivo
virtual, ou você pode configurá-lo pelas configurações de usuário no sistema operacional (como no
arquivo .bashrc no Linux).
Listar tags de depuração
Para imprimir uma lista de tags para as opções -debug, insira este comando:
emulator -help-debug-tags
4.4 Executar apps no Android Emulator 251

As opções -debug permitem ativar ou desativar mensagens de depuração de componentes

específicos do emulador, conforme especificado pelas tags.
Enviar comandos no console do emulador
Cada dispositivo virtual em execução dispõe de um console que permite consultar e controlar
o ambiente do dispositivo emulado. Por exemplo, é possível usar o console para gerenciar redi-
recionamentos de porta, características de rede e eventos de telefonia enquanto o app está sendo
executado no emulador.
Os comandos a seguir precisam de um emulador em execução. Para saber mais sobre como
executar um emulador, consulte Executar aplicativos no Android Emulator e Iniciar o emulador na
linha de comando.
Iniciar e parar uma sessão do console
Para acessar o console e inserir comandos, em uma janela de terminal, use telnet para se
conectar à porta do console e informe o token de autenticação. Cada vez que o console exibe OK,
ele está pronto para aceitar comandos. Não há um prompt típico.
Para conectar-se ao console de um dispositivo virtual em execução:
1. Abra uma janela de terminal e insira o seguinte comando:
telnet localhost console-port
O título da janela do emulador lista o número da porta do console. Por exemplo, o título da
janela para um emulador que usa a porta do console 5554 pode ser Nexus_5X_API_23:5554. Além
disso, o comando adb devices imprime uma lista de dispositivos virtuais em execução e os números
de porta de console correspondentes. Para ver mais informações, acesse Consultar instâncias de
emulador/dispositivo.
Observação: o emulador detecta conexões nas portas 5554 a 5585 e aceita conexões apenas
do localhost.
2. Depois que o console exibir OK, insira o comando auth auth_token.
Para que você insira comandos, o console do emulador requer autenticação. Além disso,
auth_token precisa corresponder ao conteúdo do arquivo .emulator_console_auth_token no seu
diretório inicial.
O comando telnet localhost console-port criará esse arquivo, que contém um token de autenti-
cação gerado aleatoriamente, caso ele não exista. Para desativar a autenticação, exclua o token do
arquivo .emulator_console_auth_token ou crie um arquivo vazio se ele não existir.
3. Depois de conectar-se ao console, insira os comandos.
Digite help, help command ou help-verbose para ver uma lista de comandos de console e saber
mais sobre comandos específicos.
4. Para sair da sessão de console, insira quit ou exit.
Veja um exemplo de sessão:
$ telnet localhost 5554
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying [Link]...
Connected to localhost.
Escape character is ’ˆ]’.
Android Console: Authentication required
Android Console: type ’auth <auth_token>’ to authenticate
Android Console: you can find your <auth_token> in
’/Users/me/.emulator_console_auth_token’
OK
auth 123456789ABCdefZ
Android Console: type ’help’ for a list of commands
252 Capítulo 4. Ferramentas de Desenvolvimento para Android

OK
help-verbose
Android console command help:
help|h|? print a list of commands
help-verbose print a list of cmmands with descriptions
ping check if the emulator is alive
automation record and play back macros for device state automation
event simulate hardware events
geo Geo-location commands
gsm GSM related commands
cdma CDMA related commands
crash crash the emulator instance
crash-on-exit simulate crash on exit for the emulator instance
kill kill the emulator instance
restart restart the emulator instance
network manage network settings
power power related commands
quit|exit quit control session
redir manage port redirections
sms SMS related commands
avd control virtual device execution
qemu connect to the QEMU virtual machine monitor
sensor manage emulator sensors
physics record and playback physical model state changes
finger manage emulator fingerprint
debug control the emulator debug output tags
rotate rotate the screen by 90 degrees
screenrecord record the emulator’s display
fold fold the device
unfold unfold the device
multidisplay create/modify/delete displays besides the default android display
try ’help <command>’ for command-specific help
OK
exit
Connection closed by foreign host.
Referência de comando do emulador
A tabela a seguir descreve os comandos do console do emulador com os parâmetros e valores
relacionados.
Tabela 1. Comandos do console do emulador
4.4 Executar apps no Android Emulator 253

Comandos gerais Descrição

avd {stop|start|status|name} Consulta, controla e gerencia o dispositivo
virtual da seguinte maneira:
• stop: para a execução do dispositivo.
• start: inicia a execução do dispositivo.
• status: consulta o status do dispositivo
virtual, que pode ser running ou
stopped.
• name: consulta o nome do dispositivo
virtual.

avd snapshot {list|save name|load name|delete

Salva e restaura o estado do dispositivo em
name} snapshots da seguinte maneira:
• list: lista todos os snapshots salvos.
• save name: salva o snapshot como
nome.
• load name: carrega o snapshot
nomeado.
• delete name: exclui o snapshot
nomeado.
O exemplo a seguir salva um snapshot com o
nome firstactivitysnapshot.
avd snapshot save firstactivitysnapshot

fold Dobra o dispositivo para exibir a menor configura-

ção de tela (se o dispositivo for dobrável e estiver
desdobrado no momento).
unfold Desdobra o dispositivo para exibir a maior configu-
ração de tela (se o dispositivo for dobrável e estiver
dobrado no momento).
kill Encerra o dispositivo virtual.
ping Verifica se o dispositivo virtual está sendo executado.
rotate Gira o AVD no sentido anti-horário em incrementos
de 45 graus.
Falha no emulador Descrição
crash Causa uma falha no emulador durante a execução do
app.
crash-on-exit Causa uma falha no emulador quando o app é encer-
rado.
Tags de depuração Descrição
254 Capítulo 4. Ferramentas de Desenvolvimento para Android

Comandos gerais Descrição

debug tags ... Ativa ou desativa mensagens de depuração de
partes específicas do emulador. O parâmetro
tags precisa ser um valor da lista de tags de
depuração que aparece quando você executa
emulator -help-debug-tags. Para ver mais
informações sobre a opção -help-debug-tags,
consulte Opções de emulador usadas com
mais frequência.
O exemplo a seguir ativa a tag radio:
debug radio

Redirecionamento de porta Descrição

redir list Lista o redirecionamento de porta atual.
redir add protocol:host-port:guest-port Adiciona um novo redirecionamento de porta,
da seguinte maneira:
• protocol: precisa ser tcp ou udp.
• host-port: número da porta a ser aberta
no host.
• guest-port: número da porta para a qual
rotear dados no emulador.

redir del protocol:host-port Exclui um redirecionamento de porta.

• protocol: precisa ser tcp ou udp.
• host-port: número da porta a ser aberta
no host.

Localização geográfica Descrição

Defina a localização geográfica relatada para
os apps em execução dentro de um emulador,
enviando um ponto GPS para o emulador.
Você poderá emitir o comando geo assim que
um dispositivo virtual estiver em execução. O
emulador define o local que você insere
criando um provedor de locais fictícios. Esse
provedor responde aos listeners de localização
definidos por apps e também informa o local
para o LocationManager. Qualquer app pode
consultar o gerenciador de localização para
ver o ponto GPS atual do dispositivo emulado
chamando LocationMana-
[Link]("gps")
geo fix longitude latitude satellites [altitude] Envia um ponto GPS simples para o emulador. Especifique longitude
4.4 Executar apps no Android Emulator 255

geo nmea sentence Envia uma sentença NMEA 0183 para o

dispositivo emulado, como se ela tivesse sido
enviada de um modem GPS emulado. Inicie
sentence com "$GP". Apenas as sentenças
"$GPGGA"e "$GPRCM"são compatíveis no
momento. O exemplo a seguir é uma sentença
de Dados de Posição do Sistema de
Posicionamento Global (GPGGA, na sigla em
inglês) que recebe o horário, a posição e os
dados de localização de um receptor GPS:
geo nmea $GPGGA
,[Link],[Link],a,[Link],a,x,xx,x.x,x.x,M,x.x,M,x.x,xxxx

Eventos falsos de hardware Descrição

event types Lista todos os tipos de eventos falsos. Para eventos que têm códigos,
event send types [types ...] Envia um ou mais tipos de eventos falsos.
event codes type Lista os códigos de evento para o tipo de evento falso especificado.
event send type[:code]:[value] [...] Envia um ou mais eventos falsos com códigos
opcionais e valores de código. O exemplo a
seguir envia três eventos em que os dois
últimos incluem um código de evento.
event send EV_PWR EV_SW:SW_LID
EV_REL:REL_X

event text message Envia uma string de caracteres que simulam p

Controlar o estado de energia relatado pelo emulador para apps Descrição
power display Exibe o estado da bateria e do carregador.
power ac {on|off} Define o estado de carregamento CA para on o
power status {unknown|charging|discharging|not-charging|full} Altera o status da bateria conforme especificad
power present {true|false} Define o estado de presença da bateria.
power health {unknown|good|overheat|dead|overvoltage|failure} Define o estado de integridade da bateria.
power capacity percent Define o estado da capacidade restante da bate
Status da conexão de rede Descrição
network status Verifica o status da rede e as características atu
256 Capítulo 4. Ferramentas de Desenvolvimento para Android

network delay latency Altera a latência da rede emulada.

O emulador permite simular vários níveis de
latência de rede para que você possa testar o
app em um ambiente mais próximo das
condições reais em que ele será executado.
Você pode definir um nível de latência ou um
intervalo na inicialização do emulador ou usar
o console para alterar a latência enquanto o
app está sendo executado no emulador.
Para definir a latência na inicialização, use a
opção de emulador -netdelay com um valor
compatível de latency, conforme listado na
lista de formatos de latência de rede abaixo.
Veja alguns exemplos:
emulator -netdelay gprs
emulator -netdelay 40,100

Para fazer alterações no atraso da rede enquanto o emulador está em execução, conecte-se ao
console e use o comando netdelay com um valor compatível de latency da lista de formatos de
latência de rede abaixo.
network delay gprs
network delay 40 100
4.4 Executar apps no Android Emulator 257

Formato de latência de rede:

O formato de latency da rede é um dos
seguintes (os números estão em milésimos de
segundo):
• gprs: GPRS, que usa um intervalo de
latência de no mínimo 150 e no máximo
550.
• edge: EDGE/EGPRS, que usa um
intervalo de latência de no mínimo 80 e
no máximo 400.
• umts: UMTS/3G, que usa um intervalo
de latência de no mínimo 35 e no
máximo 200.
• none: sem latência.
• num: emula a latência especificada em
milésimos de segundo.
• min:max: emula o intervalo de latência
especificado.

network speed speed O emulador permite simular várias taxas de

transferência de rede.
Você pode definir uma taxa de transferência
ou um intervalo na inicialização do emulador
ou usar o console para alterar a taxa enquanto
o app está sendo executado no emulador.
Para definir a velocidade da rede na
inicialização, use a opção de emulador
-netspeed com um valor compatível de speed,
conforme listado na lista de formatos de
velocidade de rede abaixo. Veja alguns
exemplos:
emulator -netspeed gsm @Pixel_API_26
emulator -netspeed 14.4,80 @Pixel_API_26

Para fazer alterações na velocidade da rede enquanto o emulador está em execução, conecte-se
ao console e use o comando network speed com um valor compatível de speed da lista de formatos
de velocidade da rede abaixo.
network speed 14.4 80
258 Capítulo 4. Ferramentas de Desenvolvimento para Android

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

network capture {start|stop} file

Emulação de telefonia
O emulador Android inclui os próprios modems emulados GSM e CDMA que permitem simular funções de telefonia
4.4 Executar apps no Android Emulator 259

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

gsm {call|accept|cancel|busy} phonenumber

260 Capítulo 4. Ferramentas de Desenvolvimento para Android

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

gsm {data|voice} state

gsm hold
4.4 Executar apps no Android Emulator 261

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

gsm list
gsm status
gsm signal {rssi|ber}

gsm signal-profile num

262 Capítulo 4. Ferramentas de Desenvolvimento para Android

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

cdma ssource source

cdma prl_version version

Gerenciar sensores no emulador
Esses comandos referem-se aos sensores que estão disponíveis no AVD. Além de usar o comando sensor, você pode v
sensor status
4.4 Executar apps no Android Emulator 263

Formato de velocidade da rede:

O formato de speed da rede é um dos
seguintes (os números estão em kilobits/s):
• gsm: GSM/CSD, que usa uma
velocidade de 14,4 de upload e 14,4 de
download.
• hscsd: HSCSD, que usa uma velocidade
de 14,4 de upload e 43,2 de download.
• gprs: GPRS, que usa uma velocidade de
40,0 de upload e 80,0 de download.
• edge: EDGE/EGPRS, que usa uma
velocidade de 118,4 de upload e 236,8
de download.
• umts: UMTS/3G, que usa uma
velocidade de 128,0 de upload e 1.920
de download.
• hsdpa: HSDPA, que usa uma
velocidade de 348,0 de upload e
14.400,0 de download.
• lte: LTE, que usa uma velocidade de
58.000 de upload e 173.000 de
download.
• evdo: EVDO, que usa uma velocidade
de 75.000 de upload e 280.000 de
download.
• full: velocidade ilimitada, mas depende
da velocidade de conexão do seu
computador.
• num: define uma taxa exata em
kilobits/s usada para upload e
download.
• up:down: define taxas exatas em
kilobits/s para upload e download
separadamente.

sensor get sensor-name

264 Capítulo 4. Ferramentas de Desenvolvimento para Android

Os valores de acceleration separados por dois pontos (:) referem-se às coordenadas x, y e z dos sensores virtuais desc
sensor set sensor-name
value-x:value-y:value-z

Emulação de SMS Descrição

sms send sender-phone-number textmessage Gera um SMS recebido emulado. A lista a
seguir descreve o parâmetro e os valores
relacionados:
• sender-phone-number: contém uma
string numérica arbitrária.
• textmessage: é a mensagem SMS.
O exemplo a seguir envia a mensagem
"olá"para o número de telefone 4085555555.
sms send 4085555555 hi there

O console encaminha a mensagem SMS para o framework do Android, que a passa para um app no emulador que pro
Simulação de impressão digital
finger touch fingerprint-id
finger remove

Simulação e validação de impressão digital

4.4 Executar apps no Android Emulator 265

Figura 1. Tela de autenticação de impressão digital.

Use o comando finger para simular e validar a autenticação de impressão digital para seu
app. Você precisa das Ferramentas do SDK 24.3 ou posterior e do Android 6.0 (API nível 23) ou
posterior.
Para simular e validar a autenticação de impressão digital, siga estas etapas:
1. Se você ainda não tem um código de impressão digital, cadastre uma nova impressão digital
no emulador selecionando Settings > Security > Fingerprint e seguindo as instruções de
cadastro.
2. Configure seu app para aceitar a autenticação de impressão digital. Quando essa configuração
é concluída, o dispositivo exibe a tela de autenticação de impressão digital.
3. Enquanto o app estiver exibindo a tela de autenticação de impressão digital, vá para o console
e insira o comando finger touch e o código de impressão digital que você criou. Isso simula
um toque do dedo.
4. Em seguida, insira o comando finger remove para simular a elevação do dedo.
Seu app responderá como se o usuário tivesse tocado e elevado o dedo do sensor de impressão
digital.
Configurar a rede do Android Emulator
266 Capítulo 4. Ferramentas de Desenvolvimento para Android

O emulador fornece recursos de rede versáteis que você pode usar para configurar ambientes
de teste e modelagem complexos para seu app. As seções a seguir apresentam a arquitetura e os
recursos da rede do emulador.
Espaço do endereço de rede
Cada instância do emulador é executada por trás de um serviço de roteador/firewall virtual
que o isola das interfaces e configurações de rede da máquina de desenvolvimento e da Internet.
Um dispositivo emulado não pode ver sua máquina de desenvolvimento ou outras instâncias de
emulador na rede. Em vez disso, ele vê apenas que está conectado por meio da Ethernet a um
roteador/firewall.
O roteador virtual de cada instância gerencia o espaço do endereço de rede 10.0.2/24. Todos
os endereços gerenciados pelo roteador estão na forma [Link], em que xx é um número. Os
endereços dentro desse espaço são pré-alocados pelo emulador/roteador da seguinte maneira:

Endereço de rede Descrição

[Link] Endereço do roteador/gateway
[Link] Alias especial para a interface de loopback do host
(ou seja, [Link] na sua máquina de desenvolvi-
mento)
[Link] Primeiro servidor DNS
[Link] / [Link] / [Link] Segundo, terceiro e quarto servidor DNS opcional
(se houver)
[Link] Interface de rede/Ethernet do dispositivo emulado
[Link] Interface de loopback do dispositivo emulado

As mesmas atribuições de endereço são usadas por todas as instâncias em execução no emulador.
Isso significa que, se você tiver duas instâncias em execução ao mesmo tempo na máquina,
cada uma delas terá o próprio roteador e, por trás disso, cada uma terá um endereço IP igual a
[Link]. As instâncias são isoladas por um roteador e não podem se ver na mesma rede. Para
ver informações sobre como permitir que as instâncias do emulador se comuniquem via TCP/UDP,
consulte Interconectar instâncias do emulador.
Além disso, o endereço [Link] na sua máquina de desenvolvimento corresponde à própria
interface de loopback do emulador. Caso você queira acessar serviços em execução na interface de
loopback da máquina de desenvolvimento (também conhecida como [Link] na sua máquina),
use o endereço especial [Link].
Por fim, os endereços pré-alocados de um dispositivo emulado são específicos do Android
Emulator e, provavelmente, serão muito diferentes em dispositivos reais (que também são muito
propensos a ter o endereço de rede traduzido, especificamente, por trás de um roteador/firewall).
Limitações da rede local
Apps Android em execução em um emulador podem se conectar à rede disponível na sua
estação de trabalho. No entanto, os apps se conectam por meio do emulador, não diretamente ao
hardware, e o emulador atua como um app normal na estação de trabalho. Isso pode causar algumas
limitações:
• A comunicação com o dispositivo emulado pode ser bloqueada por um programa de firewall
executado na máquina.
• A comunicação com o dispositivo emulado pode ser bloqueada por outro firewall/roteador
(físico) a que sua máquina esteja conectada.
O roteador virtual do emulador precisa conseguir lidar com todas as conexões e mensagens
TCP e UDP de saída em nome do dispositivo emulado, desde que o ambiente de rede da máquina
4.4 Executar apps no Android Emulator 267

de desenvolvimento permita isso. Não há limitações internas quanto a números ou intervalos de

porta, exceto a restrição imposta pelo sistema operacional e pela rede do host.
Dependendo do ambiente, o emulador pode não ser compatível com outros protocolos (como
ICMP, usado para "ping"). Atualmente, o emulador não é compatível com IGMP nem multicast.
Usar o redirecionamento de rede
Para se comunicar com uma instância de emulador por trás do roteador virtual, configure o
redirecionamento de rede nesse roteador. Os clientes podem se conectar a uma porta de convidado
especificada no roteador, enquanto o roteador direciona o tráfego de/para essa porta e para a porta
do host do dispositivo emulado.
Para configurar o redirecionamento de rede, crie um mapeamento de portas/endereços de host e
convidado na instância do emulador. Há duas maneiras de configurar o redirecionamento de rede:
usando os comandos do console do emulador ou a ferramenta adb, conforme descrito abaixo.
Configurar o redirecionamento por meio do Console do Emulator
Cada instância do emulador oferece um console de controle a que você pode se conectar para
emitir comandos específicos para essa instância. Você pode usar o comando do console redir para
configurar o redirecionamento conforme necessário para uma instância de emulador.
Primeiro, determine o número da porta do console para a instância do emulador de destino. Por
exemplo, o número da porta do console para a primeira instância do emulador iniciada é 5554. Em
seguida, conecte-se ao console da instância do emulador de destino, especificando o número de
porta do console, da seguinte maneira:
telnet localhost 5554
Depois de estabelecer a conexão, use o comando redir para trabalhar com o redirecionamento.
Para adicionar um redirecionamento, use:
add <protocol>:<host-port>:<guest-port>
em que <protocol> é tcp ou udp, e <host-port> e <guest-port> definem o mapeamento entre sua
máquina e o sistema simulado, respectivamente.
Por exemplo, o comando a seguir configura um redirecionamento que processa todas as
conexões TCP de entrada para sua máquina host (desenvolvimento) em [Link]:5000 e as passa
para o sistema emulado em [Link]:6000:
redir add tcp:5000:6000
Para excluir um redirecionamento, você pode usar o comando redir del. Para listar todos os
redirecionamentos de uma instância específica, use redir list. Para ver mais informações sobre esses
e outros comandos do console, consulte Usar o Console do Emulator.
Os números de porta são restringidos pelo ambiente local. Normalmente, isso significa que
não é possível usar números de porta do host abaixo de 1.024 sem ter privilégios especiais de
administrador. Além disso, não será possível configurar um redirecionamento para uma porta
do host que já esteja sendo usada por outro processo na máquina. Nesse caso, redir gera uma
mensagem de erro.
Configurar o redirecionamento por meio do adb
A ferramenta Android Debug Bridge (adb) oferece o encaminhamento de portas, uma ma-
neira alternativa de configurar o redirecionamento de rede. Para ver mais informações, consulte
Encaminhar portas, na documentação do adb.
No momento, o adb não oferece nenhuma maneira de remover um redirecionamento, exceto
por meio da eliminação do servidor do adb.
Definir as configurações de DNS do emulador
Na inicialização, o emulador lê a lista de servidores DNS que o sistema está usando no momento.
Em seguida, ele armazena os endereços IP de até quatro servidores nessa lista e configura aliases
para eles nos endereços emulados [Link], [Link], [Link] e [Link], conforme necessário.
No Linux e no OS X, o emulador extrai os endereços do servidor DNS analisando o arquivo
268 Capítulo 4. Ferramentas de Desenvolvimento para Android

/etc/[Link]. No Windows, o emulador extrai os endereços chamando a API GetNetworkPa-

rams(). Normalmente, isso significa que o emulador ignora o conteúdo do arquivo "hosts"(/etc/hosts
no Linux/OS X, %WINDOWS%/system32/HOSTS no Windows).
Ao iniciar o emulador na linha de comando, você também pode usar a opção -dns-server
<serverList> para especificar manualmente os endereços dos servidores DNS, em que <serverList>
é uma lista separada por vírgulas de nomes de servidores ou endereços IP. Essa opção poderá ser
útil se você encontrar problemas de resolução de DNS na rede emulada. Por exemplo, quando uma
mensagem "Unknown Host error"for exibida ao usar o navegador da Web.
Usar o emulador com um proxy
Em muitas redes corporativas, conexões diretas com a Internet não funcionam (elas são recusa-
das pelos administradores de rede), exceto quando acontecem por meio de um proxy específico.
Navegadores da Web e outros apps corporativos são pré-configurados para usar o proxy, para que
você possa navegar na Web. No caso de apps comuns, como o emulador, eles precisam saber que
há um proxy e precisam se conectar a ele.
Devido à natureza do HTTP, uma conexão direta com o servidor da Web e uma conexão por
meio de um proxy resultam em solicitações GET diferentes. O emulador reescreve de maneira
transparente as solicitações GET do dispositivo virtual antes de se comunicar com o proxy para que
ele funcione.
Se o emulador precisar acessar a Internet por meio de um servidor proxy, você poderá configurar
um proxy HTTP personalizado na tela Extended controls do emulador. Com o emulador aberto,

clique em More e depois em Settings e Proxy. Aqui, você pode definir as próprias
configurações de proxy HTTP.

Como alternativa, é possível configurar um proxy a partir da linha de comando com a opção
-http-proxy <proxy> ao iniciar o emulador. Nesse caso, você especifica as informações do proxy
em <proxy> em um destes formatos:
[Link]
ou
[Link]
A opção -http-proxy força o emulador a usar o proxy HTTP/HTTPS especificado para todas as
conexões TCP de saída. O redirecionamento para UDP não é compatível no momento.
Como alternativa, você pode definir a variável de ambiente http_proxy para o valor que quer
usar para <proxy>. Nesse caso, não é necessário especificar um valor para <proxy> no comando
4.4 Executar apps no Android Emulator 269

-http-proxy: o emulador verifica o valor da variável de ambiente http_proxy na inicialização e o

utiliza automaticamente, se definido.
Você pode usar a opção -debug-proxy para diagnosticar problemas de conexão de proxy.
Interconectar instâncias do emulador
Para permitir que uma instância do emulador se comunique com outra, configure o redireciona-
mento de rede necessário, conforme ilustrado abaixo.
Suponha que seu ambiente seja:
• A: sua máquina de desenvolvimento
• B: sua primeira instância de emulador, em execução em A
• C: sua segunda instância de emulador, também em execução em A
e você queira executar um servidor em B, a que C se conectará. Veja como configurá-lo:
1. Configure o servidor em B, detectando [Link]:<serverPort>.
2. No console B, configure um redirecionamento de A:localhost:<localPort> para B:[Link]:<serverPort>.
3. Em C, faça o cliente se conectar a [Link]:<localPort>.
Por exemplo, se você quiser executar um servidor HTTP, selecione <serverPort> como 80 e
<localPort> como 8080:
• B detecta em [Link]:80
• No console B, emita redir add tcp:8080:80
• C é conectado a [Link]:8080
Enviar uma chamada de voz ou SMS para outra instância de emulador
O emulador encaminha automaticamente chamadas de voz e mensagens SMS simuladas de
uma instância a outra. Para enviar uma chamada de voz ou SMS, use o app de telefone ou de
mensagem de texto, respectivamente, a partir de um dos emuladores.
Para iniciar uma chamada de voz simulada para outra instância de emulador:
1. Inicie o app de telefone na instância do emulador de origem.
2. Como número a ser discado, insira o número da porta do console da instância para que você
quer ligar. Você pode determinar o número da porta do console da instância de destino,
verificando o título da janela, em que o número da porta do console é relatado como "Android
Emulator (<port>)".
3. Pressione "Dial". Uma nova chamada de entrada é exibida na instância do emulador de
destino.
Para enviar uma mensagem SMS para outra instância de emulador, inicie o app de mensagem
de texto (se disponível). Especifique o número da porta do console da instância do emulador de
destino como o endereço do SMS, insira o texto da mensagem e envie. A mensagem será entregue
para a instância do emulador de destino.
Você também pode se conectar a um console do emulador para simular o recebimento de uma
chamada de voz ou de um SMS. Para ver mais informações, consulte Emulação de telefonia e
Emulação de SMS.
Criar seu app na linha de comando
Você pode executar todas as tarefas de compilação disponíveis para seu projeto Android usando
a ferramenta de linha de comando do wrapper Gradle (link em inglês). Ela está disponível como
um arquivo de lote para Windows ([Link]) e como um script de shell para Linux e Mac
([Link]), sendo acessível pela raiz de cada projeto criado com o Android Studio.
Para executar uma tarefa com o wrapper, use um dos seguintes comandos em uma janela do
Terminal (no Android Studio, selecione View Tool Windows Terminal ):
• No Windows:
gradlew task-name
No Mac ou Linux:
./gradlew task-name
270 Capítulo 4. Ferramentas de Desenvolvimento para Android

Para ver uma lista de todas as tarefas de compilação disponíveis para seu projeto, execute tasks:
gradlew tasks
O restante desta página descreve os conceitos básicos para criar e executar o app com o wrapper
Gradle. Para saber mais sobre como configurar a compilação para Android, leia Configurar sua
compilação.
Se preferir usar as ferramentas do Android Studio em vez das ferramentas da linha de comando,
leia Criar e executar seu app.
Sobre tipos de compilação
Por padrão, há dois tipos de compilação disponíveis para todo app Android: uma para depurar o
app, a compilação debug (depuração), e outra para disponibilizar o app aos usuários, a compilação
release (lançamento). A saída resultante de cada compilação precisa ser assinada com um certificado
para que você possa implantar seu app em um dispositivo. A compilação de depuração é assinada
automaticamente com uma chave de depuração fornecida pelas ferramentas do SDK (esse método
não é seguro e, por isso, não pode ser usado para publicar na Google Play Store), e a compilação
final precisa ser assinada com sua própria chave privada.
Se você quiser criar o app para lançamento, é importante que também assine o app com a chave
de assinatura apropriada. Se ainda não tiver muita experiência nisso, você poderá executar seus
apps rapidamente em um emulador ou em um dispositivo conectado criando um APK de depuração.
Também é possível definir um tipo de compilação personalizado no arquivo [Link] e
configurá-lo para ser assinado como compilação de depuração incluindo debuggable true. Para
saber mais, consulte Configurar variantes de compilação.
Criar e implantar um APK
Ainda que criar um pacote de apps seja a melhor forma de empacotar seu app e fazer upload
dele para o Play Console, é mais indicado criar um APK para testar rapidamente uma compilação
de depuração ou para compartilhar seu app como um artefato implantável.
Compilar um APK de depuração
Para testar e depurar o app de forma imediata, você pode compilar um APK de depuração. O
APK de depuração é assinado com uma chave de depuração fornecida pelas ferramentas do SDK e
permite depuração com adb.
Para criar um APK de depuração, abra uma linha de comando e navegue até a raiz do diretório
do projeto. Para iniciar uma compilação de depuração, chame a tarefa assembleDebug:
gradlew assembleDebug
Desse modo, você criará um APK chamado module_name-[Link] em project_name/module_name/build/outputs/
O arquivo já estará assinado com a chave de depuração e alinhado com zipalign para você poder
instalá-lo em um dispositivo imediatamente.
Ou então, se quiser compilar o APK e instalá-lo imediatamente em um emulador em execução
ou dispositivo conectado, chame installDebug:
gradlew installDebug
A parte "Debug"nos nomes de tarefas acima é apenas uma versão, conhecida como CamelCase,
do nome da variante de compilação. Por isso, ela pode ser substituída pelo tipo ou variante de
compilação que você quiser montar ou instalar. Por exemplo, se você tiver uma variação de produto
"demo", poderá criar a compilação de depuração com a tarefa assembleDemoDebug.
Para ver todas as tarefas de compilação de instalação disponíveis para cada variante (incluindo
tarefas de desinstalação), execute a tarefa tasks.
Além disso, leia a seção abaixo sobre como executar o app no emulador e como executar o app
em um dispositivo.
Compilar um APK de versão final
Quando estiver tudo pronto para lançar e distribuir o app, crie um APK de versão final assinado
com sua chave privada. Para mais informações, acesse a seção sobre como assinar seu app na linha
4.4 Executar apps no Android Emulator 271

de comando.
Implantar seu app no emulador
Para usar o Android Emulator, você precisa criar um dispositivo virtual Android (AVD, na sigla
em inglês) usando o Android Studio.
Depois que tiver um AVD, inicie o Android Emulator e instale o app da seguinte forma:
1. Em uma linha de comando, navegue até android_sdk/tools/ e inicie o emulador especificando
o AVD:
emulator -avd avd_name
Se não tiver certeza de qual é o nome do AVD, execute emulator -list-avds.
Agora você pode instalar seu app usando uma das tarefas de instalação do Gradle mencionadas
na seção sobre como criar um APK de depuração ou a ferramenta adb.
Se o APK for criado usando um SDK de visualização para desenvolvedores (caso o targetSdk-
Version seja uma letra em vez de um número), você precisará incluir a opção -t com o comando
install para instalar um APK de teste.
adb install path/to/your_app.apk
2. Todos os APKs que você cria são salvos em project_name/module_name/build/outputs/apk/.
Para saber mais, leia Executar apps no Android Emulator.
Implantar seu app em um dispositivo físico
Antes de executar o app em um dispositivo, você precisa ativar a depuração USB no dispositivo.
Essa opção pode ser encontrada em Settings > Developer options.
Observação: no Android 4.2 e em versões mais recentes, as Opções do desenvolvedor ficam
ocultas por padrão. Para torná-las disponíveis, acesse Settings > About phone e toque em Build
number sete vezes. Retorne à tela anterior para encontrar as Opções do desenvolvedor.
Depois que o dispositivo estiver configurado e conectado via USB, você poderá instalar seu
app usando as tarefas de instalação do Gradle mencionadas na seção sobre como criar um APK de
depuração ou a ferramenta adb:
adb -d install path/to/your_app.apk
Todos os APKs que você cria são salvos em project_name/module_name/build/outputs/apk/.
Para saber mais, consulte Executar apps em um dispositivo de hardware.
Criar um pacote de apps
Os Android App Bundles incluem todos os recursos e o código compilados do seu app, mas
permitem a geração e a assinatura do APK para o Google Play.
Diferentemente de um APK, não é possível implantar um pacote de apps diretamente em um
dispositivo. Por isso, se você quiser testar ou compartilhar rapidamente um APK com outra pessoa,
crie um APK.
A maneira mais fácil de criar um pacote de apps é usando o Android Studio. No entanto, se
você precisar criar um pacote de apps a partir da linha de comando, use o Gradle ou bundletool,
conforme descrito nas seções abaixo.
Criar um pacote de apps com o Gradle
Se você preferir gerar um pacote de apps a partir da linha de comando, execute a tarefa do
Gradle bundleVariant no módulo base do seu app. Por exemplo, o comando abaixo cria um pacote
de apps para a versão de depuração do módulo base:
./gradlew :base:bundleDebug

Se você quiser criar um pacote assinado para fazer upload no Play Console, será necessário
configurar primeiro o arquivo [Link] do módulo base com as informações de assinatura do app.
Para saber mais, vá para a seção sobre como Configurar o Gradle para assinar seu app. Em seguida,
você poderá, por exemplo, criar a versão do seu app, e o Gradle gerará automaticamente um pacote
de apps e vai assiná-lo com as informações de assinatura fornecidas no arquivo [Link].
272 Capítulo 4. Ferramentas de Desenvolvimento para Android

Se você quiser assinar um pacote de apps como uma etapa separada, use o jarsigner para assinar
o pacote de apps na linha de comando.
Observação: não é possível usar o apksigner para assinar seu pacote de apps.
Criar um pacote de apps usando o bundletool
O bundletool é uma ferramenta de linha de comando que o Android Studio, o plug-in do
Android para Gradle e o Google Play usam para converter os recursos e o código compilados do
app em pacotes de apps e gerar APKs implantáveis desses pacotes.
Assim, embora seja útil testar pacotes de apps com o bundletool e recriar localmente como o
Google Play gera APKs, normalmente você não precisará invocar bundletool para criar o pacote
de apps. Em vez disso, use tarefas do Android Studio ou Gradle, conforme descrito nas seções
anteriores.
No entanto, se você não quiser usar tarefas do Android Studio ou Gradle para criar pacotes, por
exemplo, se usar um conjunto de ferramentas de compilação personalizado, poderá usar bundletool
na linha de comando para criar um pacote de apps a partir dos recursos e do código pré-compilados.
Faça o download do bundletool no repositório do GitHub, caso ainda não tenha feito.
Esta seção descreve como empacotar os recursos e o código compilados do app e como usar o
bundletool na linha de comando para convertê-los em um Android App Bundle.
Gerar o manifesto e recursos em formato .proto
O bundletool exige que determinadas informações sobre o projeto do seu app, como o manifesto
e os recursos do app, estejam no formato Buffer de protocolo do Google, que também é conhecido
como "protobuf"e usa a extensão de arquivo *.pb. Os protobufs fornecem um mecanismo de
neutralidade de idioma, plataforma neutra e extensível para a serialização de dados estruturados.
Eles são semelhantes ao XML, mas menores, mais rápidos e mais simples.
Fazer o download do AAPT2
Você pode gerar o arquivo de manifesto e a tabela de recursos do seu app no formato protobuf
usando a versão mais recente do AAPT2 do repositório Maven do Google.
Cuidado: não use a versão do AAPT2 incluída no pacote de ferramentas de desenvolvimento
do Android. Essa versão do AAPT2 não é compatível com bundletool.
Para fazer o download do AAPT2 do repositório Maven do Google, faça o seguinte:
1. Navegue até [Link] > aapt2 no índice do repositório.
2. Copie o nome da versão mais recente do AAPT2.
3. Insira o nome da versão que você copiou no seguinte URL e especifique seu sistema operacio-
nal de destino: [Link]
| linux | osx].jar
Por exemplo, para fazer o download da versão 3.2.0-alpha18-4804415 para Windows, use:
[Link]
[Link]
4. Navegue até o URL em um navegador. O download do AAPT2 será iniciado em breve.
5. Descompacte o arquivo JAR que você acabou de transferir.
Compilar e vincular os recursos do seu app
Use o AAPT2 para compilar os recursos do seu app com o seguinte comando:
aapt2 compile \
project_root/module_root/src/main/res/drawable/[Link]\
project_root/module_root/src/main/res/drawable/[Link] \
-o compiled_resources/
Observação: embora seja possível transmitir diretórios de recursos para AAPT2 usando a
sinalização --dir, isso recompila todos os arquivos no diretório, independentemente de quantos
arquivos realmente foram alterados.
4.4 Executar apps no Android Emulator 273

Durante a fase de vinculação, em que AAPT2 vincula seus diversos recursos compilados em
um único APK, instrua o AAPT2 a converter o manifesto e os recursos compilados do seu app no
formato protobuf incluindo a sinalização --proto-format, conforme mostrado abaixo:
aapt2 link --proto-format -o [Link] \
-I android_sdk/platforms/android_version/[Link]\
--manifest project_root/module_root/src/main/[Link] \
-R compiled_resources/*.flat \
--auto-add-overlay
Observação: como alternativa, ao especificar recursos compilados com a sinalização -R, você
pode especificar um arquivo de texto que inclua o caminho absoluto para cada um dos seus recursos
compilados, com cada caminho separado por um único espaço. Em seguida, você pode transmitir
esse arquivo de texto para AAPT2 da seguinte maneira: aapt2 link ... -R @compiled_resources.txt.
Agora, é possível extrair o conteúdo do APK de saída, como o [Link], resour-
[Link] e outros arquivos de recurso do seu app, no formato protobuf. Você precisa desses arquivos
ao preparar a entrada que o bundletool exige para criar seu pacote de apps, conforme descrito na
seção a seguir.
Código e recursos pré-compilados do pacote
Antes de usar o bundletool para gerar um pacote de apps para seu app, forneça arquivos ZIP que
contenham os recursos e o código compilados para um determinado módulo de app. O conteúdo
e a organização do arquivo ZIP de cada módulo é muito semelhante ao do formato Android App
Bundle. Por exemplo, é necessário criar um arquivo [Link] para o módulo base do seu app e
organizar seu conteúdo da seguinte forma:

Arquivo ou diretório Descrição

manifest/[Link] O manifesto do módulo no formato protobuf.
dex/... Um diretório com um ou mais arquivos DEX compi-
lados do seu app. Esses arquivos precisam ser nome-
ados da seguinte maneira: [Link], [Link],
[Link] etc.
res/... Contém os recursos do módulo no formato protobuf
para todas as configurações do dispositivo. Subdire-
tórios e arquivos precisam ser organizados de forma
semelhante a um APK típico.
root/..., assets/..., e lib/... Esses diretórios são idênticos aos descritos na seção
sobre o formato Android App Bundle.
[Link] A tabela de recursos do app no formato protobuf.

Depois de preparar os arquivos ZIP para cada módulo do app, você pode transmiti-los para
bundletool a fim de criar seu conjunto de apps, conforme descrito na seção a seguir.
Criar seu pacote de apps usando o bundletool
Para criar seu pacote de apps, use o comando bundletool build-bundle, conforme mostrado
abaixo.
bundletool build-bundle --modules=[Link] --output=[Link]
Observação: se você pretende publicar o pacote de apps, é necessário assiná-lo usando
jarsigner. Não é possível usar o apksigner para assinar o pacote de apps.
A tabela a seguir descreve sinalizações para o comando build-bundle em mais detalhes.
274 Capítulo 4. Ferramentas de Desenvolvimento para Android

Sinalização Descrição
--modules=[Link], path-to- Especifica a lista de arquivos ZIP do módulo que o
[Link],[Link] bundletool precisa usar para criar seu pacote de apps.
--output=[Link] Especifica o caminho e o nome do arquivo de saída
*.aab.
--config=[Link] Especifica o caminho para um arquivo de configura-
ção opcional que você pode usar para personalizar o
processo de compilação. Para saber mais, consulte
a seção sobre como personalizar a geração de APK
descendentes.
--metadata-file=target-bundle-path:local-file-
Instrui o bundletool a empacotar um arquivo
path de metadados opcional dentro do seu pacote
de apps. Você pode usar esse arquivo para
incluir dados, como os mapeamentos
ProGuard ou a lista completa de arquivos
DEX do app, que podem ser úteis para outras
etapas no conjunto de ferramentas ou em uma
app store.
target-bundle-path especifica um caminho
relativo à raiz do pacote de apps onde você
quer que o arquivo de metadados seja
empacotado, e local-file-path especifica o
caminho para o arquivo de metadados local.

Personalizar a geração de APKs descendentes

Os pacotes de apps incluem um arquivo [Link] que fornece metadados que as app
stores, como o Google Play, exigem ao gerar APKs do pacote. Embora o bundletool crie esse arquivo
para você, é possível configurar alguns aspectos dos metadados em um arquivo [Link] e
transmiti-lo ao comando bundletool build-bundle. O bundletool posteriormente converte e combina
esse arquivo com a versão protobuf incluída em cada pacote de apps.
Observação: para saber mais sobre como o JSON mapeia para o formato protobuf, leia
Mapeamento do JSON. No entanto, essa informação é mais avançada do que o necessário para esta
página.
Por exemplo, você pode controlar quais categorias de APKs de configuração serão ativadas
ou desativadas. O exemplo a seguir de um arquivo [Link] desativa os APKs de
configuração para que cada um segmente um idioma diferente (isto é, recursos para todos os
idiomas são incluídos nos respectivos APKs de recurso base ou dinâmico):
{
"optimizations": {
"splitsConfig": {
"splitDimension": [{
"value": "LANGUAGE",
"negate": true
}]
}
}
}
4.4 Executar apps no Android Emulator 275

No seu arquivo [Link], também é possível especificar que tipos de arquivos ficarão
descompactados ao empacotar APKs usando padrões glob, da seguinte maneira:
{
"compression": {
"uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
}
}

Lembre-se de que, por padrão, bundletool não compacta as bibliotecas nativas do seu app (no
Android 6.0 ou versão mais recente) e a tabela de recursos ([Link]). Para uma descrição
completa do que pode ser configurado em [Link], inspecione o arquivo [Link],
que é gravado usando a sintaxe Proto3.
Implantar o app em um pacote de apps
Se você criou e assinou um pacote de apps, use bundletool para gerar APKs e implantá-los em
um dispositivo.
Assinar o app na linha de comando
Você não precisa do Android Studio para assinar seu app. É possível assinar o app pela linha de
comando, usando apksigner para APKs ou jarsigner para pacotes de apps ou configurando o Gradle
para assiná-lo durante a compilação. De qualquer maneira, primeiro é necessário gerar uma chave
privada usando keytool, conforme mostrado abaixo.
keytool -genkey -v -keystore [Link] -keyalg RSA -keysize 2048 -validity 10000
-alias my-alias
O exemplo acima solicita senhas para o keystore e a chave, e para os campos "Nome distinto"da
sua chave. Em seguida, ele gera o keystore como um arquivo chamado [Link], salvando-
o no diretório atual (é possível movimentá-lo como quiser). O keystore contém uma única chave,
válida por 10.000 dias.
Agora você pode assinar o APK ou pacote de apps manualmente ou configurar o Gradle para
assinar seu app durante o processo de compilação, conforme descrito nas seções abaixo.
Assinar seu app manualmente na linha de comando
Se quiser assinar um pacote de apps na linha de comando, você pode usar o jarsigner. Se você
quiser assinar um APK em vez disso, será necessário usar zipalign e apksigner, conforme descrito
abaixo.
1. Abra uma linha de comando no Android Studio, selecionando View > Tool Windows >
Terminal e indo até o diretório onde o APK não assinado está localizado.
2. Alinhe o APK não assinado usando zipalign:
3. zipalign -v -p 4 [Link] [Link]
O zipalign garante que todos os dados descompactados comecem com um alinhamento de byte
específico em relação ao início do arquivo, o que pode reduzir a quantidade de RAM consumida
pelo app.
Assine o APK com a chave privada usando apksigner:
apksigner sign --ks [Link] --out [Link] [Link]
Este exemplo tem como saída o APK assinado em [Link] após assiná-lo com uma
chave privada e um certificado armazenados em um único arquivo de keystore: [Link].
A ferramenta apksigner oferece outras opções de assinatura, inclusive a de um arquivo APK
usando arquivos diferentes de chave privada e de certificado e a assinatura de um APK usando
vários assinantes. Para ver mais detalhes, consulte a referência apksigner.
Observação: para usar a ferramenta apksigner, é necessário ter a revisão 24.0.3 ou versão mais
recente do Android SDK Build Tools instalada. Atualize esse pacote usando o SDK Manager.
Verifique se o APK está assinado:
276 Capítulo 4. Ferramentas de Desenvolvimento para Android

apksigner verify [Link]

Configurar o Gradle para assinar seu app
Abra o arquivo [Link] no nível do módulo e adicione o bloco signingConfigs {} com
entradas para storeFile, storePassword, keyAlias e keyPassword. Depois, transmita esse objeto para
a propriedade signingConfig no seu tipo de compilação. Exemplo:
android {
...
defaultConfig { ... }
signingConfigs {
release {
// You need to specify either an absolute path or include the
// keystore file in the same directory as the [Link] file.
storeFile file("[Link]")
storePassword "password"
keyAlias "my-alias"
keyPassword "password"
}
}
buildTypes {
release {
signingConfig [Link]
...
}
}
}

Observação: nesse caso, o keystore e a senha da chave ficam visíveis diretamente no arquivo
[Link]. Para melhorar a segurança, remova as informações de assinatura do arquivo de
compilação.
Agora, quando você criar seu app invocando uma tarefa do Gradle, ele assinará o app e executará
o zipalign para você.
Além disso, como você configurou a compilação de lançamento com sua chave de assinatura, a
tarefa "install"(instalar) estará disponível para esse tipo de compilação. Assim, você pode compilar,
alinhar, assinar e instalar o APK da versão final em um emulador ou dispositivo; tudo isso com a
tarefa installRelease.
Um app assinado com sua chave privada está pronto para distribuição, mas antes é importante
que você leia mais sobre como publicar o app e analise a Lista de verificação de lançamento do
Google Play.
Publicar seu app
A publicação é o processo geral que disponibiliza aplicativos Android para os usuários. Quando
você publica um aplicativo Android, duas tarefas principais são realizadas:
• Preparação do aplicativo para lançamento
Durante a etapa de preparação, você compila uma versão de lançamento do aplicativo que pode
ser transferida por download e instalada pelos usuários em dispositivos Android.
• Lançamento do aplicativo para os usuários
Durante a etapa de lançamento, ocorre a divulgação, venda e distribuição da versão de lança-
mento do aplicativo para os usuários.
Esta página traz uma visão geral do processo a ser seguido durante a preparação para publicar
seu app. Se você pretende publicar no Google Play, consulte também a Lista de verificação de
4.4 Executar apps no Android Emulator 277

lançamento do Google Play.

Preparar o app para lançamento
A preparação do aplicativo para lançamento é um processo de várias etapas que envolve as
seguintes tarefas:
• Configurar o aplicativo para lançamento.
Como requisito mínimo, é preciso remover chamadas de Log e o atributo android:debuggable
do arquivo de manifesto. Também é preciso informar valores para os atributos android:versionCode
e android:versionName, localizados no elemento <manifest>. Além disso, pode ser necessário
definir diversas outras configurações para cumprir os requisitos do Google Play ou acomodar o
método usado para lançar o aplicativo.
Se você está usando arquivos de compilação do Gradle, pode usar o tipo de compilação release
para definir configurações para a versão publicada do app.
• Compilar e assinar uma versão de lançamento do aplicativo.
Você pode usar os arquivos de compilação do Gradle com o tipo de compilação release e assinar
uma versão de lançamento do aplicativo. Consulte Compilar e executar no Android Studio.
• Testar a versão de lançamento do aplicativo.
Antes de distribuir o aplicativo, é necessário testar minuciosamente a versão de lançamento em
pelo menos um dispositivo celular de destino e um dispositivo tablet de destino.
• Atualizar recursos do aplicativo para lançamento.
Todos os recursos do aplicativo, como arquivos multimídia e gráficos, precisam estar atualizados
e incluídos no aplicativo ou organizados nos servidores de produção adequados.
• Preparar os servidores e serviços remotos de que o aplicativo depende.
Se o aplicativo depende de servidores ou serviços externos, é preciso ter certeza de que eles são
seguros e prontos para produção.
Pode ser necessário executar diversas outras tarefas como parte do processo de preparação. Por
exemplo, você precisará de uma chave privada para assinar o aplicativo. Também será necessário
criar um ícone para o aplicativo. Além disso, você pode precisar de um Contrato de licença de
usuário final (EULA, na sigla em inglês) para proteger sua pessoa, organização e propriedade
intelectual.
Depois de concluir a preparação do aplicativo para lançamento, você terá um arquivo .apk
assinado para distribuir aos usuários.
Para saber como preparar o aplicativo para lançamento, consulte Preparar para o lançamento,
no guia do desenvolvedor. Esse tópico oferece instruções detalhadas para configurar e compilar a
versão de lançamento de um aplicativo.
Lançar seu app para os usuários
Você pode lançar aplicativos Android de diversas formas. Normalmente, os aplicativos são
lançados em uma loja como o Google Play, mas também é possível lançá-los no seu site ou enviá-los
diretamente aos usuários.
Lançar em uma loja de apps
Se você quer distribuir os apps ao público mais amplo possível, o ideal é lançá-los em uma loja
de apps, como o Google Play.
O Google Play é a principal loja de apps Android, o que o torna particularmente útil se você
quer distribuir os aplicativos a um grande público global. No entanto, você pode distribuir apps em
qualquer loja de apps ou usar várias lojas.
Lançar apps no Google Play
O Google Play é uma plataforma de publicação robusta que ajuda a divulgar, vender e distribuir
aplicativos Android para usuários no mundo todo. Ao lançar aplicativos usando o Google Play,
você tem acesso a um pacote de ferramentas para desenvolvedores que permitem analisar vendas,
identificar tendências de mercado e controlar para quem o aplicativo é distribuído. Você também terá
278 Capítulo 4. Ferramentas de Desenvolvimento para Android

acesso a diversos recursos para aumentar a receita, como o Faturamento em apps e o Licenciamento
de aplicativos. A grande disponibilidade de ferramentas e recursos, juntamente com diversos
recursos de comunidades de usuários finais, faz do Google Play a principal loja para vender e
comprar aplicativos Android.
O lançamento do aplicativo no Google Play é um processo simples que envolve três etapas
básicas:

• Preparar materiais promocionais.

Para aproveitar ao máximo os recursos de marketing e publicidade do Google Play, crie materiais
promocionais para o aplicativo, como capturas de tela, vídeos, imagens e textos promocionais.

• Configurar opções e carregar ativos.

O Google Play permite direcionar um aplicativo a um grupo mundial de usuários e dispositivos.

A definição de diversas configurações do Google Play permite escolher os países que você quer
alcançar, os idiomas em que o aplicativo será anunciado e o preço que você quer cobrar em cada
país. Também é possível configurar detalhes do anúncio, como tipo, categoria e classificação do
conteúdo do aplicativo. Depois de configurar as opções, você pode fazer upload dos materiais
promocionais, bem como do aplicativo na forma de rascunho (não publicado).

• Publicar a versão de lançamento do aplicativo.

Quando você tiver certeza de que as configurações de publicação estão definidas corretamente
e que o aplicativo enviado está pronto para ser lançado publicamente, clique em Publish no Play
Console e, em poucos minutos, o aplicativo estará disponível para download no mundo todo.
Para ver mais informações, consulte Google Play.
Lançar por meio de um site
Se você não quer lançar o app em uma loja como o Google Play, pode disponibilizá-lo para
download no próprio site ou servidor, inclusive em servidores particulares ou corporativos. Para
fazer isso, comece preparando o aplicativo para lançamento da maneira convencional. Em seguida,
basta hospedar o arquivo do APK pronto para lançamento no seu site e disponibilizar um link de
download para os usuários.
Quando o usuário navegar para o link de download no dispositivo Android, o arquivo será
transferido, e o sistema Android iniciará automaticamente a instalação no dispositivo. No entanto,
o processo de instalação só começará automaticamente se as configurações do usuário estiverem
definidas para permitir a instalação de apps provenientes de fontes desconhecidas.
Embora seja relativamente fácil lançar um aplicativo no próprio site, essa opção pode ser
ineficiente. Por exemplo, se você quiser monetizar o aplicativo, será preciso processar e rastrear
todas as transações financeiras por conta própria, e não será possível usar o serviço Faturamento
em apps do Google Play para vender produtos no app. Além disso, não será possível usar o Serviço
de licenciamento para evitar instalações e usos não autorizados do aplicativo.
Opção do usuário por apps e fontes desconhecidos
O Android protege os usuários contra a instalação e o download inadvertidos de apps de outros
locais que não uma app store primária, como o Google Play, que é confiável. Ele bloqueia essas
instalações até que o usuário ative a instalação de apps de outras fontes. O processo de ativação
depende da versão do Android usada no dispositivo do usuário:
4.4 Executar apps no Android Emulator 279

Figura 1. Tela de configurações do sistema Instalar apps desconhecidos, em que o usuário

concede permissão para que uma fonte específica instale apps desconhecidos.
• Nos dispositivos com Android 8.0 (API nível 26) e versões posteriores, o usuário precisa
acessar a tela de configurações do sistema Instalar apps desconhecidos para ativar a instalação
de apps de uma fonte específica.
• Nos dispositivos com Android 7.1.1 (API nível 25) e versões anteriores, o usuário precisa
ativar a configuração de sistema Fontes desconhecidas ou permitir a instalação única de um
app desconhecido.
Instalar apps desconhecidos
Nos dispositivos com Android 8.0 (API nível 26) e versões posteriores, o usuário precisa
conceder permissão para instalar apps de uma fonte que não seja uma app store primária. Para
isso, é necessário ativar a configuração Permitir instalações de apps para a fonte na tela de
configurações do sistema Instalar apps desconhecidos. A figura 1 ilustra esse processo.
Observação: o usuário pode alterar essa configuração para uma determinada fonte a qualquer
momento. Portanto, as fontes que instalam apps desconhecidos precisam sempre chamar can-
RequestPackageInstalls() para verificar se o usuário concedeu permissão a elas. Se esse método
retornar false, a fonte precisará solicitar que o usuário ative novamente a configuração Permitir
instalações de apps.
Fontes desconhecidas

Figura 2. Configuração Fontes desconhecidas, que determina se o usuário pode instalar apps
que não foram transferidos por download no Google Play.
Para que o usuário permita a instalação de apps que não são primários em dispositivos com An-
droid 7.1.1 (API nível 25) e versões anteriores, ele deve ativar a configuração Fontes desconhecidas
em Config. > Segurança, conforme mostrado na figura 2.
Observação: quando o usuário tenta instalar um app desconhecido em um dispositivo com
Android 7.1.1 (API nível 25) ou versões anteriores, o sistema pode mostrar uma caixa de diálogo
280 Capítulo 4. Ferramentas de Desenvolvimento para Android

perguntando se ele quer permitir que apenas um app desconhecido específico seja instalado.
Em quase todos os casos, recomendamos que o usuário permita a instalação de apenas um app
desconhecido por vez, caso essa opção esteja disponível.

Em ambos os casos, o usuário precisa alterar essa configuração antes de transferir por download
e instalar apps desconhecidos no dispositivo.

Observação: alguns provedores de rede não permitem que o usuário instale apps de fontes
desconhecidas.

Preparar para o lançamento

Para preparar o aplicativo para lançamento, configure, compile e teste uma versão de lançamento.
As tarefas de configuração são objetivas e envolvem tarefas básicas de limpeza e modificação do
código que ajudam a otimizar o aplicativo. O processo de compilação é semelhante ao de compilação
para depuração e pode ser realizado por meio de ferramentas do JDK e do Android SDK. As tarefas
de teste servem como uma verificação final para garantir que o aplicativo tenha o desempenho
esperado em condições reais. Quando concluir a preparação do aplicativo para lançamento, você
terá um arquivo APK assinado, que poderá ser distribuído diretamente aos usuários ou por meio de
uma loja de aplicativos como o Google Play.

Este documento resume as principais tarefas que precisam ser realizadas para preparar o
aplicativo para lançamento. As tarefas descritas neste documento se aplicam a todos os aplicativos
Android, independentemente da forma de lançamento ou distribuição para os usuários. Se você
estiver lançando seu aplicativo pelo Google Play, leia também a Lista de verificação para publicação
no Google Play.

Observação: como prática recomendada, o aplicativo deve cumprir todos os seus critérios de
lançamento quanto à funcionalidade, desempenho e estabilidade antes de você executar as tarefas
descritas neste documento.

Figura 1. A preparação para lançamento é uma tarefa de desenvolvimento necessária e é a

primeira etapa no processo de publicação.

Introdução

Para lançar o aplicativo para os usuários, é preciso criar um pacote pronto para lançamento que
os usuários possam instalar e executar em dispositivos Android. O pacote pronto para lançamento
contém os mesmos componentes que o arquivo APK de depuração, ou seja, código-fonte compilado,
recursos, arquivo de manifesto, entre outros, e é compilado usando as mesmas ferramentas de
compilação. No entanto, ao contrário do arquivo APK de depuração, o arquivo APK pronto para
lançamento é assinado com seu certificado e otimizado com a ferramenta zipalign.
4.4 Executar apps no Android Emulator 281

Figura 2. Cinco tarefas principais são realizadas para preparar o aplicativo para lançamento.
Normalmente, as tarefas de otimização e assinatura ocorrem de maneira ideal quando o apli-
cativo é compilado com o Android Studio. Por exemplo, você pode usar o Android Studio com
os arquivos de compilação do Gradle para compilar, assinar e otimizar o aplicativo de uma vez
só. Também é possível configurar os arquivos de compilação do Gradle para fazer o mesmo
em compilações executadas na linha de comando. Para saber mais sobre o uso de arquivos de
compilação do Gradle, consulte o guia Sistema de compilação.
Normalmente, para preparar o aplicativo para lançamento, você executa cinco tarefas principais
(veja a figura 2). Cada tarefa principal pode incluir uma ou mais tarefas menores, dependendo da
forma de lançamento do aplicativo. Por exemplo, se você está lançando o aplicativo no Google
Play, pode querer adicionar regras de filtragem especiais ao manifesto durante a configuração do
282 Capítulo 4. Ferramentas de Desenvolvimento para Android

aplicativo para lançamento. Da mesma forma, para atender às diretrizes de publicação do Google
Play, pode ser preciso preparar capturas de tela e criar textos promocionais durante a coleta de
materiais para o lançamento.
Normalmente, as tarefas listadas na figura 2 são realizadas depois de depurar e testar cuidadosa-
mente o aplicativo. O Android SDK contém diversas ferramentas para ajudar a testar e depurar
aplicativos Android. Para ver mais informações, consulte as seções Depurar seu app e Testar o
aplicativo no guia do desenvolvedor.
Coleta de materiais e recursos
Para preparar o aplicativo para lançamento, é preciso coletar diversos itens de suporte. Isso
inclui, no mínimo, as chaves criptográficas usadas na assinatura e um ícone do aplicativo. Também
é possível incluir um contrato de licença de usuário final.
Chaves criptográficas
O sistema Android exige que cada aplicativo instalado seja assinado digitalmente com um
certificado pertencente ao desenvolvedor do aplicativo, ou seja, um certificado cuja chave privada
pertence ao desenvolvedor. O sistema Android usa o certificado como forma de identificar o autor
de um aplicativo e estabelecer relações de confiança entre os aplicativos. O certificado usado na
assinatura não precisa ser assinado por uma autoridade de certificação. O sistema Android permite
assinar os aplicativos com um certificado autoassinado. Para saber mais sobre os requisitos para
certificados, consulte Assinar o aplicativo.
Importante: o aplicativo precisa ser assinado com uma chave criptográfica com período de
validade posterior a 22 de outubro de 2033.
Poderá ser necessário utilizar outras chaves de lançamento se o aplicativo acessar um serviço
ou usar uma biblioteca de terceiro que exija uma chave baseada na sua chave privada.
Ícone do app
Verifique se você tem um ícone de aplicativo e se ele atende às orientações para ícones (link
em inglês) recomendadas. O ícone ajuda o usuário a identificar o aplicativo na tela inicial de
um dispositivo e na janela "Launcher". Ele também aparece em "Manage Applications", "My
Downloads"e em outros locais. Além disso, serviços de publicação como o Google Play exibem o
ícone aos usuários.
Observação: se você está lançando o aplicativo no Google Play, é preciso criar uma versão do
ícone em alta resolução. Para ver mais informações, consulte Recursos gráficos para aplicativos.
Contrato de licença de usuário final
Considere a preparação de um contrato de licença de usuário final (EULA, na sigla em inglês)
para o aplicativo. Um EULA pode ajudar a proteger você, a organização e a propriedade intelectual.
Recomendamos disponibilizar um EULA com o aplicativo.
Materiais diversos
Também pode ser necessário preparar materiais promocionais e de marketing para divulgar o
aplicativo. Por exemplo, se você estiver lançando o aplicativo no Google Play, precisará preparar
textos promocionais e criar capturas de tela do aplicativo. Para ver mais informações, consulte
Recursos gráficos para aplicativos.
Configurar o aplicativo para lançamento
Depois de coletar todos os materiais de apoio, você pode começar a configurar o aplicativo
para lançamento. Esta seção oferece um resumo das mudanças de configuração que recomendamos
fazer no código-fonte, nos arquivos de recursos e no manifesto do aplicativo antes do lançamento.
Embora a maioria das alterações de configuração listadas nesta seção seja opcional, elas são
consideradas boas práticas de programação, e sugerimos que você as implemente. Em alguns casos,
essas alterações já podem ter sido feitas como parte do processo de desenvolvimento.
Escolher um bom nome para o pacote
Escolha um nome de pacote adequado para todo o período de validade do aplicativo. Não será
4.4 Executar apps no Android Emulator 283

possível alterar o nome do pacote depois de distribuir o aplicativo aos usuários. Você pode definir
o nome do pacote no arquivo de manifesto do aplicativo. Para ver mais informações, consulte a
documentação do atributo package.
Desativar a geração de registros e a depuração
Desative a geração de registros e a opção de depuração antes de compilar o aplicativo para
lançamento. Para desativar a geração de registros, remova as chamadas para os métodos Log nos
arquivos de origem. Para desativar a depuração, remova o atributo android:debuggable da tag
<application> no arquivo de manifesto ou defina o atributo android:debuggable como false nesse
mesmo arquivo. Além disso, remova todos os arquivos de registro ou de teste estáticos criados no
projeto.
Também recomendamos remover todas as chamadas de rastreamento a Debug adicionadas ao
código, como as chamadas aos métodos startMethodTracing() e stopMethodTracing().
Importante: se você está usando o WebView para exibir conteúdo pago ou se está usando
interfaces JavaScript, verifique se desativou a depuração do app, uma vez que ela permite que o
usuário injete scripts e extraia conteúdo usando o Chrome DevTools. Para desativar a depuração,
use o método [Link]().
Limpar os diretórios do projeto
Limpe o projeto e verifique se ele está de acordo com a estrutura de diretórios descrita em
Projetos Android. Arquivos perdidos ou órfãos esquecidos no projeto podem evitar a compilação
do aplicativo ou fazer com que ele tenha um comportamento imprevisível. Realize pelo menos as
seguintes tarefas de limpeza:
• Analise o conteúdo dos diretórios jni/, lib/ e src/. O diretório jni/ precisa conter apenas
arquivos de origem associados ao Android NDK, como arquivos .c, .cpp, .h e .mk. O
diretório lib/ deve conter apenas arquivos de bibliotecas privadas ou de terceiros, inclusive
bibliotecas pré-compiladas compartilhadas e bibliotecas estáticas (por exemplo, arquivos
.so). O diretório src/ deve conter apenas os arquivos de origem do aplicativo (arquivos .java e
.aidl). O diretório src/ não deve conter nenhum arquivo .jar.
• Confira se o projeto contém arquivos de dados privados ou reservados que não são usados
pelo aplicativo e remova-os. Por exemplo: procure no diretório res/ do projeto arquivos
antigos drawable, de layout e de valores que não são mais usados e exclua-os.
• Verifique se há bibliotecas de teste no diretório lib/ e remova-as se não estiverem mais sendo
usadas pelo aplicativo.
• Analise o conteúdo dos diretórios assets/ e res/raw/ para verificar a existência de arquivos
de ativos brutos e arquivos estáticos que precisam ser atualizados ou removidos antes do
lançamento.
Revisar e atualizar o manifesto e as configurações de compilação do Gradle
Verifique se os seguintes itens dos arquivos de manifesto e de compilação estão definidos
corretamente:
• Elemento <uses-permission>
Especifique apenas as permissões relevantes e necessárias para o aplicativo.
• Atributos android:icon e android:label
É preciso especificar os valores desses atributos, localizados no elemento <application>.
• Atributos android:versionCode e android:versionName
Recomendamos especificar os valores desses atributos, localizados no elemento <manifest>.
Para ver mais informações, consulte Controle de versões do aplicativo.
Existem vários outros elementos de arquivos de manifesto ou compilação que poderão ser
definidos se você estiver lançando o aplicativo no Google Play. Por exemplo, os atributos an-
droid:minSdkVersion e android:targetSdkVersion, localizados no elemento <uses-sdk>. Para ver
mais informações sobre essas e outras configurações do Google Play, consulte Filtros no Google
284 Capítulo 4. Ferramentas de Desenvolvimento para Android

Play.
Resolver problemas de compatibilidade
O Android oferece diversas ferramentas e técnicas para tornar o aplicativo compatível com uma
grande variedade de dispositivos. Para disponibilizar o aplicativo para o maior número possível de
usuários, faça o seguinte:
• Adicione compatibilidade para configurações com diversas telas.
Verifique se está cumprindo as práticas recomendadas para compatibilidade com diversas telas.
A compatibilidade com configurações para várias telas permite criar um aplicativo que funciona
corretamente e com boa aparência nos tamanhos de tela compatíveis com o Android.
• Otimize o aplicativo para dispositivos tablet do Android.
Se o aplicativo for projetado para dispositivos anteriores ao Android 3.0, torne-o compatível
com essa versão do Android seguindo as orientações e práticas recomendadas descritas em Otimizar
apps para o Android 3.0.
• Use a Biblioteca de Suporte.
Se o aplicativo for projetado para dispositivos com o Android 3.x, torne-o compatível com
versões anteriores do Android adicionando a Biblioteca de Suporte ao projeto dele. A Biblioteca
de Suporte oferece bibliotecas estáticas que podem ser adicionadas ao aplicativo Android, o que
permite usar APIs que não estão disponíveis em versões antigas da plataforma ou APIs de utilitários
que não fazem parte das APIs do framework.
Atualizar URLs para servidores e serviços
Se o aplicativo acessa servidores ou serviços remotos, você precisa usar o URL ou caminho de
produção para o servidor ou serviço, não o URL ou caminho de teste.
Implementar o licenciamento (para lançamento no Google Play)
Se você está lançando um aplicativo pago no Google Play, pode adicionar compatibilidade com
a licença dessa plataforma. O licenciamento permite controlar o acesso ao aplicativo dependendo
da compra ou não do aplicativo pelo usuário. O uso da licença do Google Play é opcional, mesmo
que você lance o app nessa plataforma.
Para ver mais informações sobre o Google Play Licensing Service e saber como usá-lo no
aplicativo, consulte Licenciamento do aplicativo.
Compilar o aplicativo para lançamento
Depois de concluir a configuração do aplicativo, você pode iniciar a compilação em um arquivo
APK pronto para lançamento, assinado e otimizado. O JDK contém as ferramentas para assinar
o arquivo APK (Keytool e Jarsigner). O Android SDK contém as ferramentas para compilar e
otimizar o arquivo APK. Se você está usando o Android Studio ou o sistema de compilação do
Gradle na linha de comando, pode automatizar todo o processo de compilação. Para ver mais
informações sobre como configurar as compilações do Gradle, consulte Configurar compilações do
Gradle.
Compilar com o Android Studio
Você pode usar o sistema de compilação do Gradle integrado ao Android Studio para criar um
arquivo APK pronto para lançamento, otimizado e assinado com a chave privada. Para saber como
configurar e executar compilações no Android Studio, consulte Compilar e executar no Android
Studio.
O processo de compilação presume que você tem um certificado e uma chave privada adequados
para assinar o aplicativo. Se você não tem um certificado e uma chave privada adequados, o Android
Studio pode ajudar a gerá-los. Para ver mais informações sobre o processo de assinatura, consulte
Assinar o aplicativo.
Preparar servidores e recursos externos
Se o aplicativo utilizar um servidor remoto, verifique se o servidor é seguro e se está configurado
para uso em produção. Isso é especialmente importante se você está implementando o Faturamento
4.4 Executar apps no Android Emulator 285

em apps e executando a etapa de verificação da assinatura em um servidor remoto.

Além disso, se o aplicativo busca conteúdo de um servidor remoto ou de um serviço em tempo
real (como um feed de conteúdo), verifique se o conteúdo que você oferece está atualizado e pronto
para produção.
Testar o aplicativo para o lançamento
O teste da versão de lançamento do aplicativo ajuda a garantir que ele seja executado correta-
mente em condições reais de dispositivos e rede. O ideal é testar o aplicativo em pelo menos um
dispositivo com tamanho de celular e em um com tamanho de tablet, para verificar se os elementos
da interface do usuário têm o tamanho correto e se o desempenho do aplicativo e o consumo de
bateria são aceitáveis.
Como ponto de partida para o teste, consulte O que testar. Este artigo oferece um resumo
de situações comuns no Android que precisam ser consideradas durante os testes. Quando você
concluir os testes e achar que o comportamento da versão de lançamento do aplicativo é adequado,
poderá lançá-lo para os usuários. Para ver mais informações, consulte Lançar o aplicativo para os
usuários. Se você estiver publicando o aplicativo no Google Play, consulte a Lista de verificação de
lançamento para o Google Play.
Controlar versões do app
O controle de versões é um componente essencial da estratégia de upgrade e manutenção do
app. O controle de versões é importante porque:
• os usuários precisam ter informações específicas sobre a versão do app instalada no disposi-
tivo e as versões de upgrade disponíveis para instalação;
• outros apps, inclusive aqueles publicados como um pacote, precisam consultar o sistema
para conseguir a versão do seu app, a fim de determinar a compatibilidade e identificar
dependências;
• os serviços usados para publicar seu app também podem precisar consultar a versão para
exibi-la aos usuários. Os serviços de publicação também podem ter de conferir a versão do
app para determinar a compatibilidade e estabelecer relações de upgrade/downgrade.
O sistema Android usa as informações da versão do seu app para evitar downgrades.O sistema
não usa informações de versão do app para aplicar restrições a upgrades ou à compatibilidade de
apps de terceiros. Em caso de restrições de versão, é o app que precisa aplicá-las e informar o
usuário sobre elas.
O sistema Android aplica a compatibilidade da versão do sistema, como determinada pela
configuração minSdkVersion nos arquivos de compilação. Essa configuração permite que o app
especifique a versão mínima da API de sistema compatível. Para ver mais informações, consulte
Especificar a versão mínima da API de sistema.
Definir informações de versão do aplicativo
Para determinar as informações de versão do seu app, defina valores para as configurações de
versão nos arquivos de compilação do Gradle. Esses valores são mesclados no arquivo de manifesto
do app durante o processo de compilação.
Observação: se o app definir a versão do app diretamente no elemento <manifest>, os valores
de versão no arquivo de compilação do Gradle modificarão as configurações no manifesto. Além
disso, a definição dessas configurações nos arquivos de compilação do Gradle permite especificar
valores diferentes para versões distintas do app. Para aumentar a flexibilidade e evitar uma possível
substituição na mesclagem do manifesto, remova esses atributos do elemento <manifest> e defina
as configurações de versão nos arquivos de compilação do Gradle.
Existem duas configurações, e os valores delas precisam ser sempre definidos:
• versionCode: um número inteiro positivo usado como número de versão interno. Esse
número é usado apenas para determinar se uma versão é mais recente que outra. Números
maiores indicam versões mais recentes. Esse não é o número de versão mostrado para os
286 Capítulo 4. Ferramentas de Desenvolvimento para Android

usuários, que é definido pela configuração versionName descrita abaixo. O sistema Android
usa o valor versionCode para proteger contra downgrades evitando que o usuário instale um
APK com um versionCode menor que o da versão instalada no dispositivo.
O valor é um número inteiro positivo. Assim, outros apps podem avaliá-lo programaticamente,
por exemplo, para verificar uma relação de upgrade ou downgrade. Você pode definir o valor como
qualquer inteiro positivo. No entanto, todo lançamento sucessivo do app precisa usar um valor
maior. Não é possível fazer upload de um APK na Play Store com um versionCode já usado em
uma versão anterior.
Observação: em algumas situações específicas, é possível que você queira fazer upload de
uma versão do app com um versionCode menor que o da versão mais recente. Por exemplo, se
você estiver publicando vários APKs, poderá ter intervalos de versionCode predefinidos para APKs
específicos. Para saber mais sobre como atribuir valores de versionCode para vários APKs, consulte
Compatibilidade com vários APKs.
Normalmente, a primeira versão do app é lançada com versionCode definido como 1. Nas
versões subsequentes, esse valor é sempre aumentado, independentemente de a versão ser um lança-
mento principal ou secundário. Isso significa que o valor de versionCode não tem necessariamente
uma grande semelhança com a versão de lançamento do app vista pelo usuário (veja versionName
abaixo). Apps e serviços de publicação não devem exibir esse valor de versão aos usuários.
Alerta: o maior valor de versionCode permitido pelo Google Play é 2100000000.
• versionName: um string usado como número de versão exibido aos usuários. Essa confi-
guração pode ser especificada como um string bruto ou uma referência a um recurso de
string.
O valor é um string, assim você pode descrever a versão do app como um string <ma-
jor>.<minor>.<point> ou como qualquer outro tipo de identificador de versão absoluto ou relativo.
A única finalidade de versionName é ser exibido aos usuários.
Você pode definir valores padrão para essas configurações incluindo-as no bloco defaultConfig
{}, aninhado dentro do bloco android {} do arquivo [Link] do módulo. É possível modificar
esses valores padrão para diferentes versões do app definindo valores separados para tipos de compi-
lação ou variações de produto individuais. O arquivo [Link] a seguir mostra as configurações
versionCode e versionName nos blocos defaultConfig {} e productFlavors {}.
android {
...
defaultConfig {
...
versionCode 2
versionName "1.1"
}
productFlavors {
demo {
...
versionName "1.1-demo"
}
full {
...
}
}
}

No bloco defaultConfig {} desse exemplo, o valor de versionCode indica que o APK atual
4.4 Executar apps no Android Emulator 287

contém a segunda versão do app, e o string versionName especifica que ela será exibida aos usuários
como versão 1.1. Esse arquivo [Link] também define duas variações do produto, "demo"e
"full". Como a variação "demo"do produto define versionName como "1.1-demo", a compilação
"demo"usa este versionName em vez do valor padrão. O bloco de variação do produto "full"não
define versionName, portanto, o valor padrão "1.1"é usado.
O framework Android oferece uma API que permite consultar o sistema para conseguir
informações de versão do app. Para ver as informações de versão, use o método getPacka-
geInfo([Link], int) do PackageManager.
Especificar requisitos de nível de API
Se o app exigir uma versão mínima específica da plataforma Android, você poderá especificar
esse requisito de versão como configurações de nível de API no arquivo [Link] do app.
Durante o processo de compilação, essas configurações são mescladas no arquivo de manifesto
do app. A especificação de requisitos de nível de API garante que o app seja instalado apenas em
dispositivos que utilizam uma versão compatível da plataforma Android.
Observação: se você especificar requisitos de nível de API diretamente no arquivo de manifesto
do app, as configurações correspondentes nos arquivos de compilação modificarão as configurações
do arquivo de manifesto. Além disso, a definição dessas configurações nos arquivos de compilação
do Gradle permite especificar valores diferentes para versões distintas do app. Para aumentar a
flexibilidade e evitar possíveis modificações na mesclagem do manifesto, remova esses atributos do
elemento <uses-sdk> e defina suas configurações de nível de API nos arquivos de compilação do
Gradle.
Existem duas configurações de nível de API:
• minSdkVersion: a versão mínima da plataforma Android em que o app será executado,
especificada pelo identificador do nível da API da plataforma.
• targetSdkVersion: especifica o nível de API para o qual o app foi projetado. Em alguns casos,
isso permite que o app use elementos do manifesto ou comportamentos definidos no nível de
API de destino em vez de ser restringido a usar somente aqueles definidos para o nível de
API mínimo.
Para especificar os requisitos de nível de API padrão em um arquivo [Link], adicione uma
ou mais das configurações acima ao bloco defaultConfig {}, aninhado dentro do bloco android {}.
Você também pode modificar esses valores padrão para versões diferentes do app adicionando as
configurações aos tipos de compilação ou variações de produto. O arquivo [Link] a seguir
especifica configurações padrão de minSdkVersion e targetSdkVersion no bloco defaultConfig {} e
modifica minSdkVersion para uma variação de produto.
android {
...
defaultConfig {
...
minSdkVersion 14
targetSdkVersion 24
}
productFlavors {
main {
...
}
afterLollipop {
...
minSdkVersion 21
}
288 Capítulo 4. Ferramentas de Desenvolvimento para Android

}
}

Ao preparar a instalação do app, o sistema verifica o valor dessas configurações e as compara à

versão do sistema. Se o valor de minSdkVersion for maior que o da versão do sistema, a instalação
do app será evitada.
Se você não especificar essas configurações, o sistema presumirá que o app é compatível com
todas as versões de plataforma.
Para ver mais informações, consulte a documentação do elemento de manifesto <uses-sdk> e o
documento Níveis de API. Para ver as configurações de compilação do Gradle, consulte Configurar
variações de compilação.
Assinar o app
O Android exige que todos os APKs sejam assinados digitalmente com um certificado antes de
serem instalados em um dispositivo ou atualizados. Se você usa Android App Bundles, você precisa
assinar apenas seu pacote de apps antes de enviá-lo para o Play Console, e a Assinatura de apps do
Google Play toma conta do resto. No entanto, você também pode assinar seu app manualmente
para upload no Google Play e em outras app stores.
Está página guia você por alguns conceitos importantes relacionados a assinatura e segurança
de apps, como assinar seu app para lançamento no Google Play com o Android Studio e como
ativar a Assinatura de apps pelo Google Play.
Veja a seguir uma visão geral de alto nível das etapas que você pode precisar seguir para assinar
e publicar um novo app no Google Play:
1. Gerar uma chave de upload e um keystore
2. Assinar seu app com a chave de upload
3. Ativar a "Assinatura de apps do Google Play"
4. Fazer o upload do seu app no Google Play
5. Preparar e lançar seu app
Se, em vez disso, seu app já estiver publicado na Google Play Store com uma chave de assinatura
de apps existente ou se você quiser escolher a chave de assinatura de um novo app em vez de
permitir que o Google gere uma, siga estas etapas:
1. Assine seu app com a chave de assinatura do seu app e selecione a opção para encriptar e
exportar a chave.
2. Faça o upload da chave de assinatura para ativar a "Assinatura de apps do Google Play".
3. (Recomendado) Gere e registre um certificado de upload para atualizações futuras do seu
app.
4. Faça o upload do seu app no Google Play.
5. Prepare e lance seu app.
Esta página também explora como gerenciar suas próprias chaves ao enviar seu app para outras
app stores. Se você não usa o Android Studio ou prefere assinar seu app na linha de comando, veja
como usar o apksigner.
Observação: se você estiver compilando um app do Wear OS, o processo de assinatura
do app pode ser um pouco diferente do descrito nesta página. Consulte as informações sobre
empacotamento e publicação de apps do Wear OS.
Assinatura de apps do Google Play
Com a "Assinatura de apps do Google Play", o Google gerencia e protege a chave de assinatura
do app e a utiliza para assinar seus APKs para distribuição. Como os pacotes de apps adiam a
compilação e assinatura de APKs para a Google Play Store, você precisa ativar a "Assinatura de
apps do Google Play"antes de fazer o upload desses pacotes. Isso tem os seguintes benefícios:
• Use o Android App Bundle e adicione compatibilidade com o Dynamic Delivery do Google
4.4 Executar apps no Android Emulator 289

Play. O Android App Bundle deixa seu app muito menor, simplifica as versões e conta com
recursos dinâmicos e experiências instantâneas.
• Aumente a segurança da sua chave de assinatura e torne possível o uso de uma chave de
upload diferente para assinar o pacote de apps enviado ao Google Play.
Observação: a Assinatura de apps do Google Play se aplica ao ciclo de vida do seu app. Para
garantir a segurança depois da ativação, não é possível recuperar uma cópia da chave de assinatura
do seu app nem excluí-la dos servidores Google sem excluir todo o app.
A Assinatura de apps do Google Play usa duas chaves: a chave de assinatura de apps e a
chave de upload, que são detalhadas na seção sobre Chaves e keystores. Você ficará com a chave
de upload e a usará para assinar seus apps quando fizer o upload deles na Google Play Store.
Dessa forma, você poderá solicitar uma redefinição de chave de upload se sua chave for perdida ou
comprometida. Como comparação, se você não tiver ativado a Assinatura de apps do Google Play
e perder a chave, você não poderá mais lançar atualizações do app.
Quando estiver pronto para publicar, assine seu app com o Android Studio e faça o upload no
Google Play. A chave com que você assinou seu app se torna a chave de upload. O Google usa o
certificado de upload para verificar sua identidade e assina seu(s) APK(s) com a chave de assinatura
de apps para distribuição, como mostrado na figura 1.
Se você ainda não tiver uma chave de assinatura de apps, gere uma durante o processo de
inscrição.
Observação: quando você ativar a Assinatura de apps do Google Play, não será possível fazer
o download da chave de assinatura do Google. Se você quiser usar a mesma chave de assinatura
em outras lojas, forneça sua própria chave quando ativar a "Assinatura de apps do Google Play" em
vez de permitir que uma seja gerada pelo Google.

Figura 1. Assinar um app com a "Assinatura de apps do Google Play"

Suas chaves são armazenadas na mesma infraestrutura usada para armazenar as chaves do
Google. Lá, elas são protegidas pelo serviço de gerenciamento de chaves do Google. Saiba mais
sobre a infraestrutura técnica do Google na Documentação de segurança do Google Cloud.
Na "Assinatura de apps do Google Play", se você perder sua chave de upload ou se ela for
comprometida, entre em contato com o Google para revogar sua chave de upload antiga e gerar
uma nova. Como a chave de assinatura do seu app é protegida pelo Google, você pode continuar
fazendo o upload de novas versões de seu app como atualizações para a versão original, mesmo
que mude de chave de upload. Para saber mais, leia Redefinir uma chave de upload privada perdida
ou comprometida.
A próxima seção descreve alguns termos e conceitos importantes relacionados a assinatura e
segurança de apps. Se preferir avançar e aprender a preparar seu app para upload na Google Play
Store, acesse Assinar seu app para lançamento.
Chaves, certificados e keystores
Para assinar seu app, é importante entender os conceitos e definições descritos abaixo.
Certificados
Um certificado de chave pública (arquivos .der ou .pem), também conhecido como certificado
digital ou certificado de identidade, contém a chave pública de um par de chaves pública/privada,
bem como alguns outros metadados (por exemplo, nome e local) que identificam o proprietário
detentor da chave privada correspondente.
290 Capítulo 4. Ferramentas de Desenvolvimento para Android

Ao assinar um app, a ferramenta de assinatura anexa o certificado a ele. O certificado associa o

APK ou o pacote de apps a você e a sua chave privada correspondente. Com isso, o Android pode
verificar se todas as atualizações futuras do app são autênticas e enviadas pelo autor original. A
chave usada para criar esse certificado é chamada de chave de assinatura do app.
Você pode fazer o download do certificado para a chave de assinatura do seu app e para sua
chave de upload na página de assinatura de apps do Play Console para registrar sua(s) chave(s) com
provedores de API. O certificado pode ser compartilhado com outras pessoas. Ele não contém sua
chave privada.
Cada app precisa usar o mesmo certificado durante toda a vida útil para que os usuários possam
instalar novas versões como atualizações. Para saber mais sobre os benefícios de usar o mesmo
certificado para todos os apps durante toda a vida útil, consulte Considerações sobre assinaturas
abaixo.
Uma impressão digital do certificado é uma representação curta e exclusiva de um certificado
que é solicitada frequentemente pelos provedores de API com o nome do pacote ao registrar um app
para usar o respectivo serviço. As impressões digitais MD5, SHA-1 e SHA-256 dos certificados de
upload e de assinatura de apps estão disponíveis na página de assinatura de apps do Play Console.
Para acessar outras impressões digitais, faça o download do certificado original (.der) na mesma
página.
A seguir estão os diferentes tipos de chaves e keystores:
• Chave de assinatura do app: chave usada para assinar APKs instalados no dispositivo de
um usuário. Como parte do modelo de atualização segura do Android, a chave de assinatura
nunca muda durante a vida útil do seu app. A chave de assinatura do app é privada e precisa
ser mantida em segredo. No entanto, é possível compartilhar o certificado gerado usando a
chave de assinatura do seu app.
• Chave de upload: chave usada para assinar o pacote de apps ou o APK antes do envio
para Assinatura de apps com o Google Play. A chave de upload precisa ser mantida em
segredo. No entanto, é possível compartilhar o certificado gerado usando a chave de upload.
É possível gerar uma chave de upload de uma das seguintes maneiras:
– Se você solicitar que o Google gere a chave de assinatura do app no momento da
ativação, a chave usada para assinar seu app no lançamento será definida como a chave
de upload.
– Se você fornecer a chave de assinatura do app ao Google quando ativar o recurso para
um app novo ou existente, você terá a opção de gerar uma nova chave de upload durante
ou após a ativação para aumentar a segurança.
– Se você não gerar uma nova chave de upload, continue usando a chave de assinatura do
app como chave de upload para assinar cada versão.
Dica: para manter suas chaves seguras, é importante que as chaves de upload e de assinatura do
app sejam diferentes.
• Keystore Java (.jks or .keystore): arquivo binário que serve como repositório de certificados
e chaves privadas.
• Ferramenta Play Encrypt Private Key (PEPK): use esta ferramenta para exportar chaves
privadas de um keystore Java e criptografá-las antes da transferência para o Google Play. Ao
fornecer a chave de assinatura do app para o Google, selecione a opção Export and upload
a key from a Java keystore e siga as instruções para fazer o download e usar a ferramenta.
Como alternativa, selecione a opção Export and upload a key (not using a Java keystore)
para fazer o download, revisar e usar o código-fonte aberto da ferramenta PEPK.
Assinar a compilação de depuração
Durante a execução ou depuração do projeto no ambiente de desenvolvimento integrado, o
Android Studio assina automaticamente o app com um certificado de depuração gerado pelas
4.4 Executar apps no Android Emulator 291

ferramentas do Android SDK. A primeira vez que um projeto é executado ou depurado no Android
Studio, o ambiente de desenvolvimento integrado cria automaticamente o keystore e o certificado
de depuração em $HOME/.android/[Link] e define as senhas do keystore e da chave.

Como o certificado de depuração é criado pelas ferramentas de compilação e, portanto, é

inseguro, a maioria das app stores (inclusive a Google Play Store) não aceita a publicação de um
app assinado com um certificado de depuração.

O Android Studio armazena automaticamente as informações de assinatura de depuração em

uma configuração de assinatura, evitando que você tenha que inseri-las a cada depuração. A
configuração de assinatura é um objeto que consiste em todas as informações necessárias para
assinar o app, inclusive a localização e a senha do keystore e o nome e a senha da chave. Não é
possível editar diretamente a configuração de assinatura de depuração, mas é possível configurar a
forma como você assina a compilação de lançamento.

Para maiores informações sobre como compilar e executar apps para depuração, consulte
Compilar e executar seu app.

Expiração do certificado de depuração

O certificado autoassinado usado para assinar o app na depuração tem uma data de validade de
30 anos a partir da criação. Quando o certificado expira, um erro de compilação é gerado.

Para corrigir esse problema, basta excluir o arquivo [Link] armazenado em um dos
seguintes locais:

• ~/.android/ no OS X e no Linux
• C:\Documents and Settings\user\.android\ no Windows XP
• C:\Users\user\.android\ no Windows Vista e no Windows 7, 8 e 10

Na próxima vez que você compilar e executar uma versão de depuração do seu app, o Android
Studio criará um novo keystore e uma nova chave de depuração.

Assinar seu app para lançamento no Google Play

Quando estiver pronto para publicar seu app, você precisará assiná-lo e enviá-lo para uma app
store, como o Google Play. Ao publicar seu app no Google Play, você pode ativar a "Assinatura de
apps do Google Play". Esta seção mostra como assinar seu app para lançamento e como ativar a
"Assinatura de apps do Google Play".

Gerar uma chave de upload e um keystore

Se você ainda não tem uma chave de upload, que é útil na ativação da "Assinatura de apps do
Google Play", você pode gerá-la com o Android Studio, da seguinte maneira:

1. Na barra de menus, clique em Build > Build > Generate Signed Bundle/APK.
2. Na caixa de diálogo Generate Signed Bundle or APK, selecione Android App Bundle ou
APK e clique em Next.
3. Abaixo do campo Key store path, clique em Create new.
4. Na janela New Key Store, forneça a seguinte informação para seu keystore e sua chave,
como mostra a figura 2.
292 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 2. Criar uma nova chave de upload e keystore no Android Studio.

5. Keystore
• Key store path: selecione o local onde o keystore será criado.
• Password: crie e confirme uma senha segura para o keystore.
6. Chave
• Alias: insira um nome de identificação para a chave.
• Password: crie e confirme uma senha segura para a chave. Essa senha precisa ser
diferente da escolhida para o keystore.
• Validity (years): defina o período da validade da chave em anos. A chave precisa ser
válida por 25 anos ou mais para que seja possível assinar atualizações de apps com a
mesma chave durante a vida útil do app.
• Certificate: insira algumas informações pessoais para o certificado. Essas informações
não são exibidas no app, mas são incluídas no certificado como parte do APK.
7. Após preencher o formulário, clique em OK.
8. Se você quiser compilar e assinar seu app com sua chave de upload, continue para a seção
sobre como Assinar seu app com a chave de upload. Se quiser gerar a chave e o keystore,
clique em Cancel.
Assinar seu app com sua chave
Se você já tiver uma chave de upload, use-a para assinar seu app. Se, em vez disso, seu app já
estiver assinado e publicado na Google Play Store com uma chave de assinatura existente, use-a
para assinar seu app e criptografe e exporte a chave para ativar a Assinatura de apps do Google Play.
4.4 Executar apps no Android Emulator 293

Posteriormente, você pode gerar uma chave de upload separada e registrar o certificado público da
chave de upload com o Google Play para assinar e fazer upload de atualizações para seu app.

Para assinar seu app com o Android Studio e exportar uma chave de assinatura existente, siga
estas etapas:

1. Se a caixa de diálogo Generate Signed Bundle or APK não estiver aberta, clique em Build
> Generate Signed Bundle/APK.
2. Na caixa de diálogo Generate Signed Bundle or APK, selecione Android App Bundle ou
APK e clique em Next.
3. Selecione um módulo na lista suspensa.
4. Especifique o caminho para seu keystore, o alias da chave e as senhas de ambos. Se você
ainda não preparou uma chave e um keystore de upload, gere uma chave e um keystore de
upload e volte para completar esta etapa.

Figura 3. Assinar o app com a chave de upload.

5. Se você estiver assinando um pacote de apps com uma chave de assinatura existente e quiser
ativar a Assinatura de apps do Google Play posteriormente, marque a caixa ao lado de
Export encrypted key e especifique um caminho para salvar a chave de assinatura como
um arquivo *.pepk criptografado. Você pode usar a chave de assinatura criptografada para
ativar a Assinatura de apps do Google Play em um app existente.
6. Clique em Next.
7. Na janela seguinte (mostrada na figura 4), selecione uma pasta de destino para o app assinado,
selecione o tipo de compilação e escolha a versão do produto, se houver mais de uma.
8. Se você estiver compilando e assinando um APK, você precisará selecionar quais Signature
Versions quer que sejam compatíveis com seu app. Para saber mais, leia Esquema de
assinatura de APK v2.
9. Clique em Finish.
294 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 4. Gere uma versão assinada do app para as variações do produto selecionadas.
Observação: se o projeto usar variações do produto, é possível selecionar mais de uma variação
mantendo pressionada a tecla Control no Windown/Linux ou a tecla no Mac OSX.

Figura 5. Clique no link na janela pop-up para analisar ou localizar seu pacote de apps ou
localizar a chave de assinatura exportada.
Depois do Android Studio terminar de compilar o app assinado, será possível localizar ou
analisar seu app clicando na opção adequada ("locate"ou "analyze") na notificação pop-up. Se
você selecionar a opção de exportar sua chave de assinatura, você poderá navegar rapidamente até
ela clicando na seta suspensa no canto inferior direito do pop-up para expandi-la. Depois disso,
clique em Show Exported Key File, como mostrado na figura 5.
Agora você está pronto para ativar a "Assinatura de apps do Google Play"no seu app e enviá-lo
para lançamento. Se você for novo no processo de publicação de apps, leia a Visão geral de
lançamento. Caso contrário, continue para a página sobre como Fazer upload do seu app no Play
Console.
Ativar a Assinatura de apps do Google Play
Conforme descrito anteriormente nesta página, a Assinatura de apps do Google Play é a forma
recomendada de assinar seu app para distribuição no Google Play. As etapas necessárias para ativar
a assinatura no seu app dependem dele ainda não ter sido publicado no Google Play ou já estar
assinado e publicado com uma chave de assinatura existente.
Ativar um novo app
Para ativar a assinatura em um app que ainda não foi publicado no Google Play, faça o seguinte:
1. Se você ainda não tiver feito isso, gere uma chave de upload e assine o app com ela.
2. Faça login no Play Console.
3. Siga as etapas para preparar e lançar sua versão para criar uma nova versão.
4. Depois de escolher a faixa de lançamento, configure a assinatura de apps na seção Deixar
que o Google crie e gerencie minha chave de assinatura do app, conforme descrito a
seguir:
4.4 Executar apps no Android Emulator 295

• Para que o Google Play gere uma chave de assinatura de apps para você e use-a para
assinar seu app, selecione Continuar. A chave usada para assinar a primeira versão
passará a ser a chave de upload, que será aplicada a versões futuras.
• Para usar a mesma chave de outro app da sua conta de desenvolvedor, selecione Opções
avançadas > Usar a mesma chave de outro app desta conta, selecione um app e
clique em Continuar.
• Para fornecer sua própria chave de assinatura para o Google usar ao assinar seu app,
selecione Opções avançadas e uma das opções que permite fazer upload de uma chave
privada e do certificado público correspondente de maneira segura.
Observação: se você ainda não tiver aceitado os Termos de Serviço, será necessário analisar
os termos e selecionar Aceitar para [Link] você ainda não quiser ativar a assinatura de apps,
você poderá fazer isso com um app existente a qualquer momento seguindo as instruções abaixo.
Na seção chamada Android App Bundles and APKs para add, clique em Procurar arquivos
para localizar e fazer upload do app assinado com a chave de upload. Para mais informações sobre
como lançar seu app, consulte preparar e lançar sua versão. Ao lançar seu app depois de ativar a
"Assinatura de apps do Google Play", o Google Play gera e gerencia a chave de assinatura do seu
app para você. Basta assinar atualizações subsequentes do seu app com a chave de upload antes de
enviá-lo para o Google Play.
Se você precisar criar uma nova chave de upload para seu app, consulte a seção sobre como
Redefinir uma chave de upload privada perdida ou comprometida.
Ativar um app existente
Se você estiver atualizando um app que já foi publicado no Google Play com uma chave de
assinatura existente, ative a "Assinatura de apps do Google Play"da seguinte maneira:
1. Se você ainda não fez isso, assine o app com a chave de assinatura existente e não se
esqueça de marcar a caixa ao lado de Export encrypted key para salvá-la como um arquivo
criptografado *.pepk. Você precisará desse arquivo em uma etapa posterior.
2. Faça login no Play Console e navegue até seu app.
3. No menu à esquerda, clique em Gerenciamento da versão > Assinatura de apps.
4. Se necessário, leia os Termos de Serviço e selecione Aceitar.
5. Selecione a opção que melhor descreve a chave de assinatura que você quer enviar para o
Google Play e siga as instruções mostradas. Por exemplo, se você tiver usado o Android
Studio para exportar a chave de assinatura do app, conforme descrito nesta página, selecione
Fazer upload de uma chave exportada do Android Studio e faça upload do arquivo *.pepk
da chave.
6. Clique em Inscrever-se.
Você verá uma página com os detalhes dos certificados de assinatura e upload do seu app. O
Google Play assinará seu app com a chave existente ao implantá-lo para os usuários. No entanto,
um dos maiores benefícios da "Assinatura de apps do Google Play"é a habilidade de separar a
chave usada para assinar o artefato enviado para o Google Play da chave que o Google Play usa
para assinar seu app para distribuição. Então, considere seguir as etapas da seção seguinte para
gerar e registrar uma chave de upload separada.
Gerar e registrar um certificado de upload
Ao publicar um app não assinado por uma chave de upload, o Google Play Console oferece
a opção de registrar uma para atualizações futuras do app. Essa é uma etapa opcional, mas
recomendamos publicar o app com uma chave diferente da usada pelo Google Play para distribuir
seu material aos usuários. Dessa forma, o Google mantém sua chave de assinatura segura e você
tem a opção de redefinir uma chave de upload privada perdida ou comprometida. Esta seção
descreve como criar uma chave de upload, gerar um certificado de upload a partir dela e registrar o
certificado com o Google Play para atualizações futuras do app.
296 Capítulo 4. Ferramentas de Desenvolvimento para Android

A seguir, descrevemos as situações em que você pode encontrar a opção de registrar um

certificado de upload no Play Console:
• Quando você publica um novo app assinado com uma chave de assinatura e ativa a "Assinatura
de apps do Google Play".
• Quando você está prestes a publicar um app existente com a "Assinatura de apps do Google
Play"já ativada, mas ele ainda está assinado com a própria chave de assinatura.
Se você não estiver publicando uma atualização para um app existente com a "Assinatura de
apps do Google Play"já ativada e quiser registrar um certificado de upload, siga as etapas abaixo e
continue para a seção sobre como redefinir uma chave de upload privada perdida ou comprometida.
Se você ainda não tiver feito isso, gere uma chave de upload e um keystore.
Depois de criar sua chave de upload e seu keystore, gere um certificado público da sua chave
de upload usando a keytool com o seguinte comando:
$ keytool -export -rfc
-keystore [Link]
-alias upload-alias
-file output_upload_certificate.pem
Agora que você tem seu certificado de upload, registre-o no Google quando solicitado no Play
Console ou leia a seção abaixo para registrá-lo com a equipe de suporte do Google Play.
Atualizar a chave de assinatura do seu app
Em algumas circunstâncias, pode ser necessário alterar a chave de assinatura do seu app. Você
pode querer uma chave criptograficamente mais forte, por exemplo, ou sua chave de assinatura pode
ter sido comprometida. No entanto, como os usuários só podem atualizar seu app se a atualização
for assinada com a mesma chave de assinatura, é difícil alterar a chave de um app já publicado.
Se você publicar seu app no Google Play, você poderá atualizar a chave de assinatura do app
publicado no Play Console: sua nova chave será usada para assinar novas instalações e atualizações
do app, enquanto a chave antiga será usada para assinar atualizações para usuários que instalaram
seu app antes da mudança.
Para saber mais, leia Fazer upgrade da chave de assinatura do app para novas instalações.
Redefinir uma chave de upload privada perdida ou comprometida
Se você perder sua chave de upload privada ou ela for comprometida, crie uma nova e entre em
contato com a equipe de suporte do Google Play para fazer a redefinição.
Observação: a redefinição da chave de upload não afetará a chave de assinatura do app usada
pelo Google Play para assinar novamente os APKs antes de enviar o conteúdo aos usuários.
Configurar o processo de compilação para assinatura automática do app
No Android Studio, é possível configurar o projeto para assinar automaticamente a versão de
lançamento do app durante o processo de compilação criando uma configuração de assinatura e
atribuindo-a ao tipo de compilação de lançamento. Uma configuração de assinatura consiste em
um local de keystore, uma senha de keystore, um alias da chave e uma senha da chave. Para criar
uma configuração de assinatura e atribuí-la ao tipo de compilação de lançamento usando o Android
Studio, siga estas etapas:
1. Na janela Project, clique com o botão direito no app e escolha Open Module Settings.
2. Na janela Project Structure, em Modules no painel esquerdo, clique no módulo que você
quer assinar.
3. Clique na guia Signing e depois em Add .
4. Selecione o arquivo do keystore, insira um nome para essa configuração de assinatura (é
possível criar mais de uma) e insira as informações necessárias.
4.4 Executar apps no Android Emulator 297

Figura 7. Janela de criação de uma nova configuração de assinatura.

5. Clique na guia Build Types.

6. Clique na compilação release.
7. Em Signing Config, selecione a configuração de assinatura que você acabou de criar.
298 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 8. Selecione uma configuração de assinatura no Android Studio.

8. Clique em OK.
Agora, cada vez que você criar uma versão de lançamento usando Build > Build Bundle(s)
/ APK(s) no Android Studio, o ambiente de desenvolvimento integrado assinará seu app auto-
maticamente com a configuração de assinatura especificada. Localize seus APKs ou pacotes de
apps assinados na pasta build/outputs/ dentro do diretório do projeto do módulo que você está
compilando.
Ao criar uma configuração de assinatura, as informações correspondentes serão incluídas em
texto simples nos arquivos de compilação do Gradle. Se você trabalha em equipe ou compartilha
publicamente seu código, remova as informações dos arquivos de compilação e armazene-as
separadamente para manter a segurança. Para saber mais sobre como remover informações de
assinatura dos arquivos de compilação, consulte Remover informações de assinatura dos arquivos
de compilação. Para saber mais sobre como manter as informações de assinatura seguras, leia
Proteger a chave.
Assinar cada variação de produto de forma diferente
Se o app usa versões de produto e você quer assinar cada versão de forma diferente, é possível
criar outras configurações de assinatura e atribuí-las a cada versão:
1. Na janela Project, clique com o botão direito no app e escolha Open Module Settings.
2. Na janela Project Structure, em Modules no painel esquerdo, clique no módulo que você
quer assinar.
3. Clique na guia Signing e depois em Add .
4. Selecione o arquivo do keystore, insira um nome para essa configuração de assinatura (é
possível criar mais de uma) e insira as informações necessárias.
4.4 Executar apps no Android Emulator 299

Figura 10. Janela de criação de uma nova configuração de assinatura.

5. Repita as etapas 3 e 4 conforme necessário até criar todas as configurações de assinatura.

6. Clique na guia Flavors.
7. Clique na variação que você quer configurar e selecione a configuração de assinatura adequada
no menu suspenso Signing Config.
300 Capítulo 4. Ferramentas de Desenvolvimento para Android

Figura 11. Definição de configurações de assinatura por variação de produto.

Repita para configurar todas as outras variações de produto.
8. Clique em OK.
Você também pode especificar as configurações de assinatura nos arquivos de configuração do
Gradle. Para mais informações, consulte Definir configurações de assinatura.
Gerenciar sua própria chave de assinatura
Se você escolher não ativar a "Assinatura de apps do Google Play", você pode gerenciar uma
chave de assinatura de apps e um keystore próprios. Você será responsável pela segurança da
chave e do keystore. Além disso, seu app não será compatível com o Android App Bundle e com
a Dynamic Delivery do Google Play.
Quando estiver pronto para criar uma chave e um keystore próprios, escolha uma senha forte
para seu keystore e outra tão forte quanto para cada chave privada armazenada nele. É necessário
manter o keystore em um local seguro e protegido. Se você perder o acesso a sua chave de assinatura
de apps ou se ela for comprometida, o Google não conseguirá recuperá-la e não será possível lançar
novas versões do seu app como atualizações do original. Para mais informações, consulte Proteger
sua chave.
Se você gerenciar uma chave de assinatura de app e um keystore próprios, você assinará seu
APK localmente usando sua chave de assinatura e fará o upload do APK assinado diretamente na
Google Play Store para distribuição, como mostra a figura 12.

Figura 12. Assinatura de um app ao gerenciar sua própria chave de assinatura de app.
Quando você usa a Assinatura de apps do Google Play o Google mantém sua chave de assinatura
4.4 Executar apps no Android Emulator 301

segura e garante que seus apps sejam assinados adequadamente e recebam atualizações durante
toda a vida útil. No entanto, se você decidir gerenciar sua chave de assinatura por conta própria,
tenha em conta algumas considerações.
Considerações sobre assinaturas
O app precisa ser assinado com o mesmo certificado durante toda a vida útil. Existem diversas
razões para isso:
• Atualização do app: quando o sistema instala uma atualização de um app, ele compara os
certificados da nova versão com os da versão atual. Se os certificados corresponderem, o
sistema permitirá a atualização. Se a nova versão for assinada com um certificado diferente,
será preciso atribuir um nome de pacote diferente para o app. Nesse caso, o usuário instala a
nova versão como um app completamente novo.
• Modularidade do app: o Android permite que APKs assinados pelo mesmo certificado
sejam executados no mesmo processo, se solicitado pelos apps, para que o sistema os
considere um único app. Dessa forma, é possível implantar o app em módulos, e os usuários
podem atualizar separadamente cada um dos módulos.
• Compartilhamento de código/dados por permissões: o Android oferece a aplicação de
permissões com base em assinaturas para que um app possa expôr a funcionalidade a outro
app assinado com um certificado especificado. A assinatura de vários APKs com o mesmo
certificado e usando verificações de permissão com base em assinatura permite que os apps
compartilhem códigos e dados com segurança.
Se você pretende oferecer compatibilidade com upgrades para um app, verifique se a chave de
assinatura dele tem um período de validade que ultrapasse a vida útil. Recomendamos um período
de validade de 25 anos ou mais. Quando o período de validade da chave expirar, os usuários não
poderão mais fazer o upgrade do app para novas versões de forma transparente.
Se você pretende publicar os apps no Google Play, a chave usada para assiná-los precisa ter
um período de validade posterior a 22 de outubro de 2033. O Google Play impõe esse requisito
para garantir que os usuários possam fazer o upgrade de apps de forma transparente quando novas
versões estiverem disponíveis.
Mantenha sua chave protegida
Se você escolher gerenciar e proteger sua chave de assinatura de app e seu keystore por conta
própria em vez de usar a Assinatura de apps do Google Play, a proteção da sua chave de assinatura
será de extrema importância, tanto para você quanto para o usuário. Se você permitir que alguém
use a chave ou deixar o keystore e as senhas em um local desprotegido, permitindo que terceiros
encontrem e usem essas informações, sua identidade de autor e a confiança dos usuários ficarão
comprometidas.
Observação: se você usar a "Assinatura de apps do Google Play", sua chave de assinatura de
app será mantida segura por meio da infraestrutura do [Link]ê ainda precisará manter sua
chave de upload protegida, conforme descrito abaixo. Se sua chave de upload for comprometida,
entre em contato com o Google para revogá-la e receber uma nova.
Se uma outra pessoa conseguir sua chave sem seu conhecimento ou sua permissão, ela poderá
assinar e distribuir apps que substituam ou corrompam seus apps autênticos com finalidades
indevidas. Essa pessoa também poderá, usando sua identidade, assinar e distribuir apps que
ataquem outros apps ou o próprio sistema, além de corromper e roubar dados dos usuários.
Sua chave privada será exigida para assinar todas as versões futuras do aplicativo. Se você
perder ou não souber a localização da chave, não poderá publicar atualizações para o app existente.
Não é possível gerar novamente uma chave que já existe.
Sua reputação como entidade desenvolvedora depende da proteção adequada da chave de
assinatura em todos os momentos até que a chave expire. Veja a seguir algumas dicas para manter a
chave protegida:
302 Capítulo 4. Ferramentas de Desenvolvimento para Android

• Escolha senhas fortes para o keystore e para a chave.

• Não dê nem empreste a chave privada e não permita que pessoas não autorizadas saibam as
senhas do keystore e da chave.
• Mantenha o arquivo do keystore que contém a chave privada em um local seguro e protegido.
Em geral, se você tomar precauções com bom senso para gerar, usar e armazenar a chave, ela
permanecerá segura.
Remover informações de assinatura dos arquivos de compilação
Ao criar uma configuração de assinatura, o Android Studio adiciona as informações de assi-
natura em texto simples aos arquivos [Link] do módulo. Se você está trabalhando com uma
equipe ou terceirizando o desenvolvimento do código, mantenha essas informações confidenci-
ais fora dos arquivos de compilação para que outras pessoas não possam acessá-las facilmente.
Para isso, crie um arquivo de propriedades separado para armazenar informações seguras e faça
referência a esse arquivo nos arquivos de compilação da seguinte forma:
1. Crie uma configuração de assinatura e atribua-a a um ou mais tipos de compilação. Essas
instruções presumem que você tenha configurado uma única configuração de assinatura para
o tipo de compilação de lançamento, como descrito em Configurar o processo de compilação
para assinatura automática do app.
2. Crie um arquivo denominado [Link] no diretório raiz do projeto. Esse arquivo
precisa conter as informações de assinatura da seguinte forma:
a. storePassword=myStorePassword
b. keyPassword=mykeyPassword
c. keyAlias=myKeyAlias
d. storeFile=myStoreFileLocation
3. No arquivo [Link] do módulo, adicione código para carregar o arquivo [Link]
antes do bloco android {}.
...

// Create a variable called keystorePropertiesFile, and initialize it to your

// [Link] file, in the rootProject folder.
def keystorePropertiesFile = [Link]("[Link]")

// Initialize a new Properties() object called keystoreProperties.

def keystoreProperties = new Properties()

// Load your [Link] file into the keystoreProperties object.

[Link](new FileInputStream(keystorePropertiesFile))

android {
...
}

Observação: você poderá optar por armazenar o arquivo [Link] em outro local
(por exemplo, na pasta do módulo em vez de na pasta raiz do projeto ou em um servidor de
compilações se estiver usando uma ferramenta de integração contínua). Nesse caso, modifique
o código acima para inicializar corretamente keystorePropertiesFile usando a localização real do
arquivo [Link].
Você pode fazer referência às propriedades armazenadas em keystoreProperties usando a sintaxe
keystoreProperties[’propertyName’]. Modifique o bloco signingConfigs do arquivo [Link]
4.4 Executar apps no Android Emulator 303

do módulo para fazer referência às informações de assinatura armazenadas em keystoreProperties

usando esta sintaxe.
android {
signingConfigs {
config {
keyAlias keystoreProperties[’keyAlias’]
keyPassword keystoreProperties[’keyPassword’]
storeFile file(keystoreProperties[’storeFile’])
storePassword keystoreProperties[’storePassword’]
}
}
...
}

5. Abra a janela da ferramenta Build Variants e verifique se o tipo de compilação de lançamento

está selecionado.
6. Selecione uma opção em Build > Build Bundle(s) / APK(s) para compilar um APK ou um
pacote de apps da compilação de lançamento. Você verá a saída de compilação no diretório
build/outputs/ do módulo.
Como os arquivos de compilação não contêm mais informações confidenciais, você pode
incluí-los no controle de origem ou carregá-los em uma base de código compartilhada. Não deixe
de manter o arquivo [Link] protegido. Para isso, pode ser necessário removê-lo do
sistema de controle de origem.
Fazer upload do seu app para o Play Console
Depois de criar e assinar a versão de lançamento do seu app, o próximo passo é fazer upload
dela para o Google Play para que seu app seja avaliado, testado e publicado. Antes de começar,
verifique se as seguintes condições foram atendidas:
1. Inscreva-se na Assinatura de apps do Google Play, caso ainda não tenha feito isso. Essa é a
maneira recomendada de fazer upload do seu app e assiná-lo. Se você criar e fizer upload de
um Android App Bundle, será necessário se inscrever na Assinatura de apps do Google Play.
2. O Google Play é compatível com downloads compactados de apps de somente 150 MB ou
menos. Para saber mais, leia Restrição de tamanho de download compactado.
Depois de atender às exigências acima, faça upload do seu app para o Play Console. Esta página
também descreve como você pode testar e atualizar seu pacote de apps após o upload.
Avaliar APKs usando o explorador de pacotes
Se você fizer upload do seu app como um Android App Bundle, o Play Console gerará
automaticamente APKs divididos e APKs diversos para todas as configurações de dispositivos
compatíveis com seu app. No Play Console, você pode usar o Explorador de pacote de apps para
ver todos os artefatos do APK que o Google Play gera, inspecionar os dados (como dispositivos
compatíveis e redução de tamanhos de APK) e fazer o download de APKs gerados para implantar e
testar localmente.
Para saber mais, leia o tópico de ajuda do Play Console sobre como Analisar os detalhes do seu
pacote de apps.
Testar o Dynamic Delivery usando a faixa de testes internos
A maneira mais fácil e mais rápida de testar seu app depois de fazer upload do pacote de apps é
utilizando a faixa de testes internos do Play Console. Essa nova faixa de testes tem como objetivo
compartilhar rapidamente seu app com uma quantidade limitada de testadores internos por meio do
Dynamic Delivery. Como o download e a instalação de módulos de recursos dinâmicos on demand
só podem ser testados por meio do Google Play, é importante fazer upload do seu pacote de apps
 304 Capítulo 4. Ferramentas de Desenvolvimento para Android

para a faixa de testes internos para ajustar esse tipo de experiência do usuário.

Para saber mais, leia Configurar um teste aberto, fechado ou interno.

Atualizar seu pacote de apps

Para atualizar seu app depois de fazer upload para o Play Console, é necessário aumentar o
código da versão incluído no módulo base e, então, criar e fazer upload de um novo pacote de apps.
Depois disso, o Google Play gera APKs atualizados com novos códigos de versão e os envia aos
usuários conforme necessário. Para ver mais informações, leia Gerenciar atualizações de apps.

4.5 Seu Primeiro Programa Android Java - Hello, World!

Fazer um programa de computador para mostrar a mensagem Hello, World! é tradicionalmente o

primeiro programa escrito para testar um sistema. Se você está começando a escrever programas
em Java para Android e acabou de instalar o Android Studio então porque não começar rodando
uma aplicação Hello, World!, ou app como agora é comumente conhecido.

4.5.1 Um Tutorial de Como Construir um App Android Hello World

Este tutorial o ajudará a criar um app básico Android Hello, World!. Isto é feito no Android
Studio Integrated Development Environment (IDE) com a linguagem de programação Java. Android
Studio e Java são suportados pela Google como um ambiente de desenvolvimento para produzir
apps. Studio também suporta a linguagem Kotlin para construir apps.

Quando um projeto de app Android é iniciado no Studio ele dá a você o programa Hello World
básico como um ponto de início. Este tutorial roda pelo feitio deste primeiro e básico app Android
Hello World. Esta seção assume que você configurou o Android Studio no seu computador e ele
está pronto para desenvolvimento. Para fazer isto num computador Windows veja o artigo Android
Studio Windows Install for PCs.
4.5 Seu Primeiro Programa Android Java - Hello, World! 305

Quando o Android Studio carregar selecione Start a new Android Studio project (ou use New
então New Project do menu File se um projeto existente está aberto).

Diversos tipos de projeto estão disponíveis, para o primeiro e simples app Hello World inicie
com a mais simples Empty Activity (uma Activity é o modo do Android dizer para um tela ou parte
de uma tela).
306 Capítulo 4. Ferramentas de Desenvolvimento para Android

Selecione Next e preencha os campos de configuração na caixa de diálogo Create New Project:
• Name - Hello World – o nome padrão visto na loja Google Play e no dispositivo.
• Package name – este padrão para [Link]. Ele é baseado num nome de
domínio revertido, [Link] por padrão, e o nome do app. Use seu próprio nome de
domínio, se você tiver um, ou o url de perfil online, você precisa fornecer um endereço único
para publicar na Google Play.
• Save location – aceite o padrão ou escolha uma localização.
• Language - Android está se movendo na direção de Kotlin como uma linguagem de desen-
volvimento, escolha Kotlin ou Java, aqui Java será usado.
Para este app simples, o restante das opções pode ser deixado como padrão, i.e. Minimum API
Level e instant apps desmarcados.
 4.5 Seu Primeiro Programa Android Java - Hello, World! 307

4.5.2 A Importância de Package Names e API Level

Aqui o Package name será padrão para [Link]. O Package Name é importante,
especialmente se você pretende publicar na Play store, outras app stores, ou na Internet. O que é o
Android Package Name? O Package Name serve como um método para identificar univocamente
um autor de um app, e diferentes apps de um autor, e.g. [Link]. Isto permite à
Google Play, e todos os dispositivos Android, distinguir sua aplicação de outras.

O modo recomendado para definer um Package Name é usar o endereço web em reverso,
sem as partes http e www, seguida por uma string de identificação relacionada à aplicação. Use
o endereço web de sua companhia, ou seu próprio domínio ou endereço web, e.g. o endereço
de um blog pessoal. Neste tutorial [Link] é mantido para o nome de domínio, portanto
o Package Name é [Link]. Assim, [Link] se torna um Namespace. O
domínio namespace será a primeira parte para todos os Package Names dos seus apps, com a última
parte referenciando um app particular. Se seus blog era [Link] então o Package
Name poderia ser [Link]. Atenção, não use [Link], reverta
seu próprio domínio, e.g. apps completos criados pelo autor usa [Link].
Mais, organizações produzem múltiplos apps devem manter registro dos Package Names usados,
para prevenir duplicatas.

O Minimun API level pode ser alterado se necessário. API suporta a Application Programming
Interface, e é a versão minima de Android que o app rodará. APIs recentes têm mais funções, mas
rodam em menos dispositivos. APIs antigas suportam uma variedade de dispositovos, mas não têm
todas as funções do último Android Software Development Kit (SDK). A loja Google Play não
suporta mais dispositivos anteriores à API 9 (Android 2.3 Gingerbread), e algumas funções da API
Android somente funcionam no Android Ice Cream Sandwich, API 14, e posteriores. Mais, o SDK
Studio pode produzir menssagens de aviso para algumas funções em APIs anteriores. Como uma
regra geral a menor API recomendada para selecionar deve combiner com a menor API suportada
pelo Google’s advertising AdMob code. No momento que este tutorial foi escrito, os requisitos
mínimos do AdMob eram Android API 14 (Ice Cream Sandwich, version 4.0.1).

4.5.3 Finalize o Assistente Create New Project

Selecione Finish, Studio irá preparer o projeto e iniciar a construção do app Hello World. Este app
padrão simples roda fora da caixa para mostrar uma mensagem Hello World na tela do Android.
Se esta é a primeira execução do Studio o componente OpenJDK (para Java) irá requisitar acesso
através do firewall Windows Defender. Permita o acesso e entre com a senha de administrador
do Windows na caixa de diálogo User Account Control se não estiver logado no Windows como
administrador.
308 Capítulo 4. Ferramentas de Desenvolvimento para Android

O app irá compilar no Studio, isto pode levar algum tempo, especialmente se o Android
Studio está sendo executado pela primeira vez. Verifique a barra de status na parte de baixo da IDE
do Android Studio IDE quando ela aparecer.

Quando o app é criado a Activity vazia será a primeira tela, que é mostrada no Studio.

Se não estiver selecionada clique na aba activity_main.xml ou entre no explorer do Project e

abra a activity_main.xml (na pasta layout sob res na árvore de projeto do app). Use a aba na parte
de baixo da área de edição para alternar entre as vistas Design (gráfica) e Text (código). (Se um
erro de renderização ocorrer veja o fim desta seção para possíveis soluções.)
O Android Studio IDE é dividido em várias áreas. Uma barra de menus e barra de ferramentas
na parte superior, uma barra de status na parte inferior. Acesso a vários exploradores na extrema
esquerda, uma área central de edição com guias, guias para vários utilitários abaixo da área de
edição e várias guias para diversas ferramentas à direita. A maioria dos ícones tem dicas de
ferramentas, portanto, passe o mouse pelo IDE para ver as funções dos vários itens visíveis.
 4.5 Seu Primeiro Programa Android Java - Hello, World! 309

O projeto Hello World pode ser explorado clicando na aba Project na esquerda do IDE Studio,
veja a árvore do projeto e use-a para abrir os arquivos. O código Java está sob a pasta java (veja
Android Project Structure). Dica: Para pesquisar por um arquivo em um projeto grande, clique na
árvore do projeto e comece a digitar o nome do arquivo.

4.5.4 Executar o App Hello World

O aplicativo está pronto para ser executado em um dispositivo físico ou em um dispositivo virtual
Android (AVD). Para executar em um dispositivo Android físico, o dispositivo deve estar conectado
ao computador com os drivers de dispositivo instalados. A depuração USB deve estar ativada no
dispositivo, através do Android developer mode options.

Pressione o botão verde play (o botão Run ’app’ da barra de ferramentas) para executar Hello
World. Como alternativa, use -F10 ou selecione Executar ... no menu Executar. O Studio
verificará a compilação e, se o AVD estiver instalado, inicie o dispositivo virtual (a menos que um
dispositivo físico esteja selecionado). Se mais de um AVD estiver configurado, pode ser necessário
escolher qual iniciar.
 310 Capítulo 4. Ferramentas de Desenvolvimento para Android

Quando um AVD precisa ser carregado, pode levar algum tempo, pois ele precisará inicializar. E
se o AVD estiver funcionando lentamente? Se o PC de desenvolvimento não for de alta especificação,
o AVD poderá ter problemas para executar. Nesse caso, é recomendável usar um dispositivo Android
real. Se o PC de desenvolvimento for de alta especificação, mas o AVD for lento, verifique se o
emulador virtualizado Intel x86 Atom, o Hardware Accelerated Execution Manager (HAXM) está
instalado e use uma imagem x86 AVD. Como alternativa, use uma API de nível inferior e uma tela
menor (por exemplo, um Nexus One), que requer menos CPU e recursos. Para mais informações
sobre como configurar um AVD, consulte o artigo Set Up an Android Virtual Device for App
Testing.
Para obter dicas sobre como usar o teclado com o AVD, consulte Android Emulator Key
Mapping. Depois que sua primeira programação Java Android estiver em execução, tente adicionar
funcionalidades. Investigue os recursos do Studio e familiarize-se com o IDE.

4.6 Observações gerais sobre o Android Studio

4.7 Baixando e configurando os componentes da ferramenta de desenvolvi-
mento
JVM
Android SDK
Android Studio
IV
Introdução

5 Começando a programar no Android 313

5.1 Conhecendo a estrutura geral de um projeto no
Android Studio
5.2 Visão geral da ferramenta de desenvolvimento
5.3 Executando a nossa aplicação
 5. Começando a programar no Android

5.1 Conhecendo a estrutura geral de um projeto no Android Studio

Para ver a estrutura de arquivos real do projeto, incluindo todos os arquivos ocultos na visualização
do Android, selecione Project no menu suspenso na parte superior da janela Project.
Quando você seleciona a visualização Project, pode ver um número muito maior de arquivos e
diretórios. Os mais importantes são:
module-name/
app/
build/
Contém saídas de compilação.
libs/
Contém bibliotecas privadas.
src/
Contém todos os arquivos de código e recursos do módulo nos seguintes subdiretó-
rios:
androidTest/
Contém o código dos testes de instrumentação executados em um dispositivo
Android. Para ver mais informações, consulte a documentação do Android
Test.
main/
Contém os arquivos do conjunto de origem "main": o código Android e os re-
cursos compartilhados por todas as variantes de compilação. Os arquivos para
outras variantes de compilação ficam em diretórios irmãos, como src/debug/
para o tipo de compilação de depuração.
[Link]
Descreve a natureza do aplicativo e de cada um dos componentes dele. Para
ver mais informações, consulte a documentação [Link].
java/
Contém os códigos-fonte Java.
 314 Capítulo 5. Começando a programar no Android

jni/
Contém o código nativo que usa a Java Native Interface (JNI). Para ver mais
informações, consulte a documentação do Android NDK.
gen/
Contém os arquivos Java gerados pelo Android Studio, como o arquivo [Link]
e as interfaces criadas de arquivos AIDL.
res/
Contém recursos de aplicativos, como arquivos drawable, arquivos de layout e
strings de IU. Consulte Recursos de aplicativo para ver mais informações.
assets/
Contém o arquivo que precisa ser compilado em um arquivo .apk no estado
em que está. Você pode navegar nesse diretório da mesma maneira que um
sistema de arquivos típico usando URIs e ler arquivos como um fluxo de bytes
usando AssetManager . Por exemplo, esse é um bom local para texturas e
dados de jogos.
test/
Contém código para testes locais executados na JVM host.
[Link] (módulo)
Define as configurações de compilação do módulo.
[Link] (projeto)
Define a configuração de compilação que se aplica a todos os módulos. Esse arquivo
faz parte do projeto, então precisa ser mantido no controle de revisões em conjunto com
todo o código-fonte restante.

5.1.1 O diretório “app” (application)

5.1.2 O diretório “res” (resources)
5.1.3 O diretório “drawable”
5.1.4 O diretório “layout”
5.1.5 O diretório “values”
5.1.6 O diretório “mipmap”
5.1.7 O diretório “menu”
5.2 Visão geral da ferramenta de desenvolvimento
5.3 Executando a nossa aplicação
V
Widgets

6 Conhecendo as widgets do Android 317

6.1 A paleta de componentes e suas widgets
 6. Conhecendo as widgets do Android

6.1 A paleta de componentes e suas widgets

A seção “Widgets”
A seção “Text Fields”
Um elemento da interface do usuário que exibe texto para o usuário. Para fornecer texto editável
pelo usuário, consulte EditText.
O exemplo de código a seguir mostra um uso típico, com um layout XML e código para
modificar o conteúdo da visualização de texto:
1 < LinearLayout
2 xmlns : android = " http :// schemas . android . com / apk / res / android "
3 android : layout_width = " match_parent "
4 android : layout_height = " match_parent " >
5 < TextView
6 android : id = " @ + id / text_view_id "
7 android : layout_height = " wrap_content "
8 android : layout_width = " wrap_content "
9 android : text = " @string / hello " / >
10 </ LinearLayout >

Este exemplo de código demonstra como modificar o conteúdo da visualização de texto definida
no layout XML anterior:
1 public class MainActivity extends Activity {
2
3 protected void onCreate ( Bundle savedInstanceState ) {
4 super . onCreate ( savedInstanceState ) ;
5 setContentView ( R . layout . activity_main ) ;
6 final TextView helloTextView = ( TextView ) findViewById ( R . id . text_view_id ) ;
7 helloTextView . setText ( R . string . user_greeting ) ;
8 }
9 }

A seção “Layouts”
A seção “Containers”
A seção “Date & Time”
A seção “Expert”
VI
Aplicações

7 Aplicativos Simples . . . . . . . . . . . . . . . . . 321

7.1 Desenvolvendo uma calculadora básica
7.2 Desenvolvendo uma aplicação simples de com-
pras
7.3 Desenvolvendo uma aplicação de cálculo de sa-
lário
7.4 Desenvolvendo uma aplicação de lista de conta-
tos
7.5 Desenvolvendo uma aplicação que visualiza ima-
gens

8 Aplicativos Não Tão Simples . . . . . . . . 323

8.1 Desenvolvendo um Sistema de Cadastro (Primeira
versão)

9 Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

10 Propriedades e Eventos . . . . . . . . . . . . . 327

10.1 Widget TextView
10.2 Widget EditText
10.3 Widget Button
10.4 Widget CheckBox/RadioButton
10.5 Widget ListView
10.6 Widget ImageView
 7. Aplicativos Simples

7.1 Desenvolvendo uma calculadora básica

7.1.1 Aplicação da calculadora em execução
7.2 Desenvolvendo uma aplicação simples de compras
7.3 Desenvolvendo uma aplicação de cálculo de salário
7.4 Desenvolvendo uma aplicação de lista de contatos
7.5 Desenvolvendo uma aplicação que visualiza imagens
 8. Aplicativos Não Tão Simples

8.1 Desenvolvendo um Sistema de Cadastro (Primeira versão)

9. Menus
 10. Propriedades e Eventos

10.1 Widget TextView

10.2 Widget EditText
10.3 Widget Button
10.4 Widget CheckBox/RadioButton
10.5 Widget ListView
10.6 Widget ImageView
VII
Conclusão

11 Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . 331

Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . 333
Livros
Artigos
Outros
11. Conclusão
 Bibliografia

Livros
Artigos
Outros