apostila_ Android Desenvolvimento Para Dispositivos Móveis

Prévia do material em texto

Profº. Luiz Carlos Querino Filho
É vedada, terminantemente, a cópia do material didático sob qualquer 
forma, o seu fornecimento para fotocópia ou gravação, para alunos 
ou terceiros, bem como o seu fornecimento para divulgação em 
locais públicos, telessalas ou qualquer outra forma de divulgação 
pública, sob pena de responsabilização civil e criminal.
 
SUMÁRIO
APRESENTAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Módulo 1 – Introdução ao Android e XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Aula 1 – Fundamentos do Sistema Operacional Android . . . . . . . . . . . . . . . . . . . . . . . 6
1.1. Características do Sistema Operacional Android . . . . . . . . . . . . . . . . . . . . . . . .6
1 .2 . Os Dispositivos Móveis Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Aula 2 – Introdução ao XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1. Conceitos básicos de XML (eXtensible Markup Language). . . . . . . . . . . . . . .11
2.2. Manipulação de documentos XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12
2.3. APIs: DOM, SAX e TrAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
Módulo 2 – Ambiente de Desenvolvimento Android . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Aula 3 – Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1. Baixando e instalando o Android Studio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16
3.2. Primeiro contato com o Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3. Seu primeiro aplicativo Android. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .24
3.4. Criando um dispositivo virtual Android (AVD) . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.5. Escrevendo o código do seu primeiro aplicativo. . . . . . . . . . . . . . . . . . . . . . . 33
Módulo 3 – View e Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Aula 4 – Widgets Básicos e Definição de View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.1. Widgets: os componentes de uma tela Android. . . . . . . . . . . . . . . . . . . . . . . . 39
4.2. Introdução ao Activity: a classe Java controladora de uma tela . . . . . . . . . .41
4.3. Mais Widgets: EditText, ImageView e Toast . . . . . . . . . . . . . . . . . . . . . . . . . . . .42
Aula 5 – Aprofundando o conhecimento sobre a classe Activity . . . . . . . . . . . . . . . . 45
5.1. O ciclo de vida de uma Activity: onCreate, onDestroy etc. . . . . . . . . . . . . . . . 45
5.2. Eventos de clique em botões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3. ListActivity = Activity + ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
Módulo 4 – Layouts e Intents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Aula 6 – Organizando a tela com gerenciadores de layout . . . . . . . . . . . . . . . . . . . . . 54
6.1. RelativeLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.2. LinearLayout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.3. Menus e Caixas de Diálogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Aula 7 – Intents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.1. Definição da classe Intent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2. Criando e abrindo uma nova tela com Intent . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.3. Passando valores para uma nova tela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Módulo 5 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
 
Aula 8 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.1. Banco de Dados SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
8.2. Criação do banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
8.3. Criação da classe DAO para acesso aos dados . . . . . . . . . . . . . . . . . . . . . . . 70
8.4. Incluindo, excluindo e exibindo registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Módulo 6 – Visão Geral de Recursos do SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Aula 9 – GPS, WebServices, Câmera e Áudio/Vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . 76
9.1. Acessando longitude, latitude e altitude por meio do GPS do aparelho . . . .76
9.2. Consumindo Web Services RESTful . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.3. Utilizando a câmera para fotos e vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.4. Reproduzindo arquivos de áudio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
Considerações Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Glossário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Referências bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
 
Pág. 5 de 95
APRESENTAÇÃO
Bem-vindo(a) à nossa disciplina, caro(a) aluno(a). Meu nome é Luiz, mas sou mais conhecido 
pelo meu sobrenome: Querino. Vou apresentar a você os conceitos (e, é claro, as práticas) essenciais 
para criação de aplicativos móveis (os famosos apps) para aparelhos equipados com o sistema 
operacional Android.
Certamente você já conhece os fundamentos de programação na linguagem Java, que abrange 
a criação dos tradicionais aplicativos desktop (que são executados nos computadores de mesa) e 
também dos aplicativos web, feitos para serem executados pela Internet, usando um navegador.
Estamos vivendo uma nova revolução na computação pessoal, ocasionada pelo aparecimento 
dos smartphones e tablets. As pessoas passaram a contar com esses tipos de aparelho no seu 
dia a dia, passando literalmente a “depender” deles! Isso abriu as portas dos desenvolvedores de 
software para um novo e empolgante segmento: a criação dos apps, os pequenos (mas poderosos) 
programas para dispositivos móveis.
Dentre os diversos aparelhos existentes no mercado, aqueles que executam o sistema operacional 
Android se destacam como os mais vendidos, justamente por serem acessíveis e estarem disponíveis 
em diversas configurações. Por isso, o Android é hoje o líder isolado no mercado de sistemas 
operacionais para dispositivos móveis (seguido pelo iOS da Apple em segundo lugar, e pelo Windows 
Phone da Microsoft,que ainda possui uma fatia bem pequena desse novo e disputadíssimo mercado).
O sistema operacional Android é desenvolvido primariamente pela Google, a gigante mundial 
que começou como um mecanismo de busca e hoje está presente em diversas áreas da TI. Desde 
o início, a Google tinha a intenção de popularizar o sistema operacional, por isso, ele está disponível 
em aparelhos de vários fabricantes, sendo que estes também participam ativamente do processo 
de desenvolvimento e atualização do Android.
Uma das medidas usadas pela Google para popularizar o Android foi ter optado pelo uso da 
linguagem Java para o desenvolvimento de aplicativos. Como Java já era uma linguagem amplamente 
conhecida e utilizada por milhões de desenvolvedores, estes poderiam fácil e rapidamente começar 
a desenvolver apps para Android!
 
Pág. 6 de 95
E é justamente aí que nós entramos! Como você já é um programador Java, nada melhor que 
acrescentar agora o desenvolvimento de aplicativos móveis Android no seu portfólio! Prepare-se, 
então, para entrar de cabeça na onda do momento: o desenvolvimento de apps!
Luiz Carlos Querino Filho
MÓDULO 1 – INTRODUÇÃO AO ANDROID E XML
Este primeiro módulo trata de uma rápida introdução ao sistema operacional Android, seus 
aplicativos e o mercado de apps. Em seguida, são apresentados alguns conceitos básicos da 
linguagem XML, amplamente usados nos projetos de aplicativos Android.
AULA 1 – FUNDAMENTOS DO SISTEMA OPERACIONAL ANDROID
1.1. Características do Sistema Operacional Android
De acordo com Querino (2013), a origem do sistema operacional Android remonta a uma empresa 
criada em 2003 no Vale do Silício, Califórnia (EUA), denominada Android Inc., por Andy Rubin, Rich 
Miner, Nick Sears e Chris White. Inicialmente, a empresa parecia mais uma dentre as centenas de 
startups criadas naquela região, com ideias mirabolantes de desenvolvimento de aplicações móveis 
e uma perspectiva de ser, quem sabe, a próxima Apple ou a próxima Google.
E foi justamente a Google que começou a prestar atenção na pequena empresa e seu potencial 
de inovação tecnológica. Em 2005, reconhecendo a qualidade daquilo que estava sendo criado na 
Android Inc., a Google comprou a empresa e deu início à criação de um novo sistema operacional 
para dispositivos móveis (celulares, naquela época), usando como base o código-fonte do Linux.
No dia 5 de novembro de 2007, a Google fez dois anúncios importantes: o primeiro, a formação 
do grupo Open Handset Alliance, encabeçado por ela e formado por diversas empresas do setor 
móvel, como Samsung, Sony e HTC; o segundo, anunciando o primeiro produto resultante do trabalho 
desse grupo – o sistema operacional Android (QUERINO FILHO, 2013).
O sistema passou, então, a ser testado e aprimorado, até que em setembro de 2008 foi lançado 
o Android 1.0 – a primeira versão disponível comercialmente. Finalmente, o mundo teria acesso a 
aparelhos equipados com o hoje já conhecido “robozinho verde” (figura 1).
 
Pág. 7 de 95
FIGURA 1 – Logo da Plataforma Android
Fonte: <https://commons.wikimedia.org/wiki/File:Android_robot.svg>
FIGURA 2 – Tela do Android 6.0.1 Marshmallow
Fonte: < https://pt.wikipedia.org/wiki/Android_Marshmallow#/media/File:Android_6.0-en.png >
Desde esse primeiro lançamento, muita coisa mudou. O Android assumiu a liderança do mercado 
de sistemas operacionais para dispositivos móveis, superando o iOS (que equipa o iPhone e o iPad 
da Apple), então líder até sua chegada, e hoje está presente em centenas de aparelhos dos mais 
diversos fabricantes. No momento da finalização deste material, a versão oficial mais recente do 
Android era a 6.0.1, denominada Marshmallow (figura 2).
É uma tradição da Google dar um codinome para cada versão do Android com o nome de um 
doce, sempre em ordem alfabética. Por exemplo, a primeira versão a ganhar esse tipo de “apelido” 
 
Pág. 8 de 95
foi a 1.5, chamada Cupcake. Em seguida, vieram Donut, Eclair, Froyo, Gingerbread, Honeycomb, 
Ice Crem Sandwich, Jelly Bean, KitKat, Lollipop e, finalmente, Marshmallow. A próxima versão já 
tem codinome anunciado: Nougat, conhecido no Brasil popularmente como “torrone”. Para cada 
versão, também é criado um desenho estilizado do robozinho verde como a sobremesa “da vez” 
(veja a figura 3).
FIGURA 3 – Codinomes das versões do Android
Fonte: <http://techtoward.com/wp-content/uploads/2014/02/Android-Versions-History.jpg>
1.2. Os Dispositivos Móveis Android
Existem hoje no mercado centenas de smartphones e tablets equipados com o sistema operacional 
Android, de modelos muito simples e mais acessíveis até os mais caros e sofisticados.
Fabricantes conhecidos como Samsung, Motorola, HTC e LG trazem ao usuário várias opções, 
com diferentes capacidades de processamento, memória e tamanho de tela. Isso proporciona ao 
usuário uma grande variedade de escolha, mas traz também uma nova preocupação ao desenvolvedor: 
como compatibilizar seu app para todas essas variedades de aparelhos?
Apesar de o sistema operacional ser o mesmo nos aparelhos que divulgam o fato de serem 
“Android”, há algumas peculiaridades a serem consideradas, segundo Querino Filho (2013):
• A diversidade de versões do Android: é possível encontrar hoje no mercado celulares com 
versões mais antigas (como 2.2 e 2.3) até as versões mais novas (como 6.0.1). Isso ocasiona 
variações significativas entre elas.
• Customizações ao Android original adicionadas pelos fabricantes: a natureza “livre e aberta” 
do Android possibilita aos fabricantes de aparelho fazerem pequenas (mas impactantes) 
mudanças no SO, de forma que ele aproveite ao máximo o recurso dos aparelhos.
 
Pág. 9 de 95
• Variações na configuração (hardware) de cada aparelho: como já citado, cada modelo tem 
uma configuração específica. Por exemplo, o tamanho de uma tela pode variar de cerca de 3 
a 7 polegadas em um smartphone e até mesmo mais de 10 polegadas em um tablet.
Como podemos ver, a versatilidade do Android é uma faca de dois gumes: dá ao usuário 
mais opções de escolha de um lado, mas dificulta um pouco de outro – o “nosso lado” como 
desenvolvedores, pois temos de preparar o aplicativo de forma que execute corretamente em várias 
configurações.
Manter a compatibilidade com o vasto universo de aparelhos Android é tão importante que a 
própria Google coloca no site oficial dos desenvolvedores – <http://developer.android.com/index.
html> – uma estatística sobre a diversidade atual de versões (figura 4).
FIGURA 4 – Estatística sobre as versões do Android em uso, em Agosto de 2016
Fonte: <http://developer.android.com/about/dashboards/index.html>
As estatísticas da figura 4 são geradas com base nos aparelhos com Android acessando a 
Google Play Store.
Podemos ver que, embora cerca de 80% dos usuários já estejam usando as versões mais 
recentes (da 4.4 em diante), uma fatia importante (cerca de 20%) ainda usa versões mais antigas. 
Esse percentual tende a ser ainda maior em países com população de baixa renda, em que celulares 
mais simples são mais vendidos.
O que isso significa para nós, desenvolvedores?
 
Pág. 10 de 95
Significa que, ao criarmos um app para Android, devemos nos assegurar que ele executará na 
maior quantidade possível de versões, para que possamos alcançar mais “clientes”. E para que isso 
aconteça, são necessários alguns cuidados na hora de criar seu app (falaremos mais sobre isso 
quando começarmos a criar os programas).
Outro fator a ser considerado: o tamanho e a resolução das telas. Veja o gráfico da figura 5.
Os dados e gráficos da figura 5, também gerados com base nos dispositivos que acessam 
a Google Play Store, mostram que há uma grande variedade de tamanhos de tela (e resoluções) 
nos aparelhos. Se o desenvolvedor não adequar seus apps para essas diferenças, poderá correr o 
risco de o seu aplicativo aparecer com a tela cortada, “bagunçada” ou exibindo gráficos com baixa 
qualidade.
FIGURA 5 – Estatísticas sobre o tamanho e a resoluçãode tela em uso nos dispositivos Android, em Agosto de 
2016
Fonte: <http://developer.android.com/about/dashboards/index.html>
 
Pág. 11 de 95
CURIOSIDADE
E QUANTO AO JAVA ME (ANTIGO J2ME)?
Bem antes de o Android existir, a linguagem Java já se fazia presente nos dispositivos móveis, por 
meio do “J2ME”, hoje conhecido como Java ME (Mobile Edition).
Mas não confunda os dois!
O Android é um sistema operacional completo, desenvolvido por um grupo de empresas lideradas 
pela Google, cujos aplicativos são escritos em Java. Já o Java ME é uma versão compacta da 
máquina virtual Java padrão, e foi criado para executar em dispositivos embarcados, incluindo alguns 
tipos de celulares.
O Android, visualmente mais rico e preparado para usar os recursos mais modernos dos 
smartphones, superou o Java ME como plataforma Java mais popular para dispositivos móveis, 
apesar de este último ainda marcar presença significativa em outros segmentos.
Fonte: Querino Filho (2013)
AULA 2 – INTRODUÇÃO AO XML
Antes de começarmos a criar nossos programas Android, vamos fazer uma rápida introdução 
à linguagem XML. Como você verá durante a disciplina, esta linguagem é intensamente usada 
dentro do Android, principalmente para especificação de dados e da estrutura básica das telas 
dos aplicativos.
2.1. Conceitos básicos de XML (eXtensible Markup Language)
Resumidamente falando, XML é uma linguagem usada para especificação de dados de uma 
maneira estruturada e significativa.
De acordo com Fawcett e Quin (2012), o XML surgiu e ganhou popularidade como uma maneira 
eficiente de troca de dados entre dispositivos e plataformas distintas, de forma que estes dados 
pudessem ser entendidos por qualquer uma das partes envolvidas. Outra característica importante 
do XML é que essas “partes” citadas possam ser tanto máquinas quanto humanos; ou seja, dados 
em XML são estruturados de forma que possam ser criados e lidos (interpretados) por um software 
ou pela pessoa que criou e está usando o software.
Sabemos que os computadores lidam com informações em bits (dígitos com valor zero ou um). 
Esse formato, denominado formato binário, é facilmente entendido por um computador, mas nem 
 
Pág. 12 de 95
tanto por um ser humano. Além disso, dados binários são codificados em uma forma específica 
de uma determinada arquitetura de computadores, o que dificulta ainda mais o uso destes dados 
por outro tipo de sistema.
Já os arquivos em formato texto (também conhecidos pela extensão .TXT, usada em muitos 
destes arquivos) também podem ser processados e lidos facilmente por um computador (pois cada 
caractere corresponde a uma dada sequência de bits), trazendo a vantagem de poderem ser lidos 
também por seres humanos. Uma desvantagem do uso de arquivos de formato texto, no uso para 
transferência de dados, está na definição de uma sintaxe adequada para a formatação dos dados, 
os chamados metadados. A definição dos metadados pode variar muito, além de ocupar um espaço 
significativo dentro do arquivo.
O XML veio para sanar os problemas inerentes aos formatos binário e texto!
Segundo Fawcett e Quin (2012), tudo começou com a criação do padrão SGML-Standard 
Generalized Markup Language para facilitar a especificação dos metadados de um arquivo texto. 
O SGML, apesar de já ser um bom começo no caminho de uma padronização para troca de dados, 
ainda era complexo demais – da sua simplificação surgiu, em 1996, o XML. Foi um passo tão 
importante para a Internet que já nasceu como um padrão do World Wide Web Consortium (W3C), 
a entidade que controla os padrões usados na web.
FIGURA 6 – World Wide Web Consortium
Fonte: <http://www.pcmanias.com/wp-content/uploads/2014/10/w3c.jpg>
 2.2. Manipulação de documentos XML
Para melhor entender o funcionamento do XML, vamos começar com um exemplo de arquivo 
no formato texto apresentado no Quadro 1.
 
Pág. 13 de 95
QUADRO 1 – Arquivo Texto
Detergente
Farinha de Trigo
Sabão em Pó
Olhando os dados do quadro 1, podemos deduzir que se trata de uma lista de produtos. Mas 
produtos do quê e de onde? Pode ser uma lista de compras de supermercado, um conjunto de 
produtos no estoque de uma empresa; poderíamos até mesmo complementar as linhas do arquivo 
com mais uma informação, como mostra o Quadro 2.
QUADRO 2 – Arquivo Texto Modificado
Detergente, 5
Farinha de Trigo, 2
Sabão em Pó, 4
Vemos agora que, após a descrição do produto, temos uma vírgula seguida de um número. O 
que significa este número? O preço de venda do produto? Ou sua quantidade de estoque?
Não podemos saber ao certo, pois estão faltando os metadados, ou seja, os dados sobre os 
dados – as informações sobre o que está especificado em cada linha.
Poderíamos transformar a listagem do Quadro 2 em um arquivo XML, em que tudo ficaria mais 
claro, como no Quadro 3.
QUADRO 3 – Arquivo XML
<estoque>
<produto descricao=”Detergente”quantidade=”5” />
<produto descricao=”Farinha de Trigo”quantidade=”2” />
<produto descricao=”Sabão em Pó” quantidade=”4” />
</estoque>
Agora sim sabemos que se trata de um estoque! E que cada item é um produto, com uma 
descrição e uma quantidade.
 
Pág. 14 de 95
Experimente escrever o código XML do Quadro 3 em um arquivo de texto (que você pode criar 
com o bloco de notas no Windows), salvá-lo com a extensão .xml e abri-lo em um navegador (o 
Firefox e o Chrome são os que apresentam melhores resultados neste sentido).
 Você poderá ver sua estrutura como na figura 7.
FIGURA 7 – Arquivo XML aberto no browser Firefox
Fonte: Autoria própria
Repare que o navegador “entende” a sintaxe do arquivo, separando os elementos e possibilitando 
que você expanda ou contraia cada um (clicando nos sinais de - e +).
2.3. APIs: DOM, SAX e TrAX
Criar arquivos XML manualmente, como fizemos na seção anterior, não é prático nem desejável. 
De forma semelhante, ler e interpretar seus dados diretamente também não é ideal – afinal de 
contas, o intuito é que as informações possam ser extraídas automaticamente do arquivo XML.
Para podermos usar os dados contidos em um arquivo XML em um programa, precisamos de 
um parser XML. O parser é capaz de extrair as informações de um arquivo XML e retorná-las em 
um formato adequado a um tipo de sistema ou linguagem (como um objeto em Java, por exemplo).
Um dos modelos para o qual os dados de um documento XML podem ser extraídos é o DOM 
(Document Object Model). Trata-se de uma representação em árvore do documento XML e é também 
usado em arquivos HTML. Veja, na figura 8, um gráfico mostrando a hierarquia de uma tabela HTML 
dentro do DOM.
 
Pág. 15 de 95
FIGURA 8 – Representação DOM de uma tabela
Fonte: <http://www.w3.org/TR/WD-DOM/introduction.html>
Outra forma de se especificar a estrutura de um arquivo XML são os DTDs (Document Type 
Definitions) e XML Schemas. Podemos dizer que, quando precisamos de uma representação de 
dados maior e mais detalhada, o uso de DTDs e XML Schemas é mais interessante que DOM. À 
medida que começarmos a usar XML no Android, você verá que XML Schemas são as formas para 
representar os dados que utiliza.
Java possui, há muito tempo, APIs próprias para a leitura e geração de arquivos XML. A SAX 
(Simple API for XML) é uma das opções, em que a leitura dos arquivos XML é feita de forma 
sequencial. Já a TrAX (Transformation API for XML), que faz parte da API JAXP, permite a conversão 
de um documento XML em outros formatos (FAWCETT e QUIN, 2012).
Dentro do Android, a maior parte da leitura e criação de arquivos XML é feita internamente pelo 
sistema operacional, evitando que o desenvolvedor precise utilizar diretamente API deste tipo.
 
Pág. 16 de 95
MÓDULO 2 – AMBIENTE DE DESENVOLVIMENTO ANDROID
Você já sabe neste momento que aplicativos Android são criados em Java. Mas não basta apenas 
ter o JDK instalado no seu computador para começar a criar seus apps – você precisa também do 
Android Studio. Trata-se do software usado para criarmos aplicativos Android, no qualestá incluído 
o Android SDK, um conjunto de APIs específicas deste sistema operacional, imprescindível para criar 
um aplicativo “com a cara do Android”. Neste módulo, você saberá como obter o Android Studio, 
instalá-lo e deixá-lo pronto para uso, assim como começar a criar seus próprios aplicativos em Java 
para o sistema do robô verde!
AULA 3 – ANDROID STUDIO
3.1. Baixando e instalando o Android Studio
Antes de qualquer coisa, certifique-se de que você já tem o JDK versão 8 instalado na sua 
máquina. Caso ainda não tenha, ou se você simplesmente deseja atualizar o seu JDK (o que é 
sempre uma boa ideia), acesse http://www.oracle.com/technetwork/java/javase/downloads/index.
html e faça o download. Lembre-se de baixar a versão correta para seu sistema operacional, de 32 
ou 64 bits, além de ajustar o link, caso este esteja desatualizado, ok?
Vamos agora ao download do Android Studio, uma IDE (Integrated Development Environment, 
ou Ambiente de Desenvolvimento Integrado, em português) que contém as bibliotecas básicas 
para desenvolver em Java para Android. Acesse http://developer.android.com e procure pelo link 
indicado na figura 9.
 
Pág. 17 de 95
FIGURA 9 – Link para download do Android Studio
Fonte: <http://developer.android.com>
Na tela seguinte, a versão adequada do Android Studio para seu sistema operacional poderá 
ser baixada, bastando clicar no botão indicado na figura 10.
 
Pág. 18 de 95
FIGURA 10 – Botão para download do Android Studio na versão do seu sistema operacional
Fonte: <https://developer.android.com/studio/index.html>
Em seguida, você deverá concordar com os termos do download do Android Studio marcando a 
caixa indicada pela seta e clicar no botão logo abaixo (figura 11) para iniciar o download do pacote 
de instalação.
FIGURA 11 – Concordando com os termos e iniciando o download
Fonte: <https://developer.android.com/studio/index.html>
 
Pág. 19 de 95
Finalmente começará o download. No caso de instalação em sistema operacional Windows, 
você possuirá, no término da transferência, um arquivo que, ao ser executado, iniciará o processo 
de instalação. Para sistemas operacionais Mac OS X e Linux, consulte as instruções exibidas no 
navegador após o download.
No caso de instalação no Windows, após executar o programa baixado, será exibida a tela 
mostrada na figura 12. Clique sobre o botão Next para começar o processo de instalação.
FIGURA 12 – Iniciando a instalação do Android Studio no Windows
Fonte: <https://developer.android.com/studio/index.html>
O procedimento de instalação é simples e segue o padrão da maioria dos instaladores de 
softwares para Windows: basta você manter selecionadas as opções default apresentadas e seguir 
clicando em Next até que o processo esteja concluído. No final da instalação, será exibida uma tela 
semelhante àquela mostrada na figura 13.
 
Pág. 20 de 95
FIGURA 13 – Finalizando o processo de instalação do Android Studio
Fonte: <https://developer.android.com/studio/index.html>
Ao clicar em Finish, como indicado na figura 13, o instalador será encerrado e o Android Studio 
passará a ser inicializado pela primeira vez.
AVISO!
Para executar o Android Studio de modo satisfatório, é recomendado que o computador possua pelo 
menos 4 GB de RAM.
3.2. Primeiro contato com o Android Studio
Ao abrir o Android Studio pela primeira vez, talvez você seja questionado se deseja importar as 
configurações usadas em uma versão anterior da ferramenta. Escolha a opção de sua preferência 
(ou simplesmente deixe marcada a opção padrão) e clique no botão OK (figura 14).
 
Pág. 21 de 95
FIGURA 14 – Opções da primeira inicialização do Android Studio
Fonte: Android Studio
Em seguida, o Android Studio realizará o download de componentes adicionais e fará a criação 
de um AVD (Android Virtual Device) automaticamente para você. Esse “dispositivo virtual Android” 
será usado para testar seu app no emulador incluído no Android Studio. Para que tudo seja feito 
automaticamente, clique no botão Next na tela exibida na figura 15.
FIGURA 15 – Fazendo as configurações finais do Android Studio
Fonte: Android Studio
Na tela seguinte (figura 16), mantenha a opção Standard selecionada e clique em Next.
 
Pág. 22 de 95
FIGURA 16 – Selecionando a opção padrão para finalizar a configuração
Fonte: Android Studio
Será então exibida uma tela mostrando os componentes adicionais que serão baixados e onde 
eles serão armazenados no seu computador (figura 17).
FIGURA 17 – Finalizando o assistente e configurações finais do Android Studio
Fonte: Android Studio
Clique em Finish para iniciar o download. Assim que ele for concluído, o Android Studio fará a 
autoconfiguração do AVD.
Caso seu computador suporte a virtualização VT-x, tudo deverá acontecer sem problema. 
Porém, caso não tenha, talvez seja mostrada, ao final da instalação, uma mensagem semelhante 
à apresentada na figura 18:
 
Pág. 23 de 95
FIGURA 18 – Tela final da configuração exibindo mensagem de erro
Fonte: Android Studio
IMPORTANTE
Com o intuito de acelerar a execução do emulador, o Android Studio inicialmente tenta criar um 
AVD com uma versão do Android para processadores x86, que poderá ser executada com excelente 
desempenho em computadores que suportam a tecnologia de virtualização VT-x com uso do 
software Intel HAXM. 
Caso seu computador apresente a mensagem em vermelho na figura 18 (ou algo semelhante), 
será necessário, antes de executar os programas no emulador, criar manualmente um AVD usando 
uma versão do Android para processadores ARM. Veja como isso é feito na próxima seção deste 
material.
De qualquer forma, tendo sido mostrada a mensagem de erro ou não, logo após o fechamento 
da janela mostrada na figura 18 será exibida a tela de boas-vindas do Android Studio (figura 19):
 
Pág. 24 de 95
FIGURA 19 – Tela de boas-vindas do Android Studio
Fonte: Android Studio
Clique no botão indicado pela seta na figura 19 para criar um novo projeto de aplicativo Android.
3.3. Seu primeiro aplicativo Android
Após clicar no botão indicado na figura 19, será iniciado o assistente de criação de um novo 
projeto. Na primeira tela (figura 20), você deverá informar um nome para o seu projeto (que será 
também o nome do seu app quando ele estiver instalado no aparelho). Para este exemplo, use o 
nome “Contador”.
FIGURA 20 – Primeira tela na criação de um novo projeto
Fonte: Android Studio
 
Pág. 25 de 95
Em Company Domain você pode colocar um nome de domínio Internet, que será usado, em 
formato reverso, nos pacotes das suas classes Java; se não tiver direito de uso de um domínio, 
pode usar uma valor fictício, como o indicado (example.com).
O seu projeto ficará salvo na pasta indicada em Project Location; você pode alterá-la, se quiser. 
Após definir as configurações desejadas, clique em Next.
Na próxima tela (figura 21) indicamos a plataforma alvo do aplicativo Android que criaremos. 
É possível criar apps para Android destinados a outras plataformas de aparelhos, como TVs, 
relógios (Wear) e até mesmo o famoso Google Glass, mas no nosso caso o alvo serão os principais 
dispositivos para esse sistema operacional: Phone and Tablet.
FIGURA 21 – Definindo a plataforma e versão mínima do Android
Fonte: Android Studio
Em Minimum SDK é possível estabelecer a versão mínima do Android necessária para que 
o aplicativo funcione. O padrão mostrado na tela da figura 21 (API 15: Android 4 .0 .3) indica que 
nosso app poderá ser executado em versões do Android iguais ou superiores a esta – assim, a 
abrangência do aplicativo aumenta, como dissemos. Porém, recursos novos acrescentados em 
versões posteriores poderão não estar disponíveis. A versão sugerida é uma boa escolha, pois 
proporciona um balanço entre disponibilidade de recursos novos e abrangência de uso (veja na 
figura 21 que a versão selecionada é a utilizada em cerca de 97,4% dos aparelhos ativos). Clique 
em Next para passar à próxima tela.Pág. 26 de 95
FIGURA 22 – Escolhendo um modelo para a tela principal do aplicativo
Fonte: Android Studio
Neste momento (figura 22) podemos escolher um modelo inicial para a tela principal do aplicativo. 
Nos nossos projetos escolheremos sempre a versão mais simples de tela: a Empty Activity, como 
indicado na figura 22, que traz uma tela em branco sem conteúdo específico. Selecione esse tipo 
e clique em Next.
A última tela do assistente de criação do projeto permite a definição do nome do arquivo de 
layout e a classe Java para a tela inicial (figura 23). Em breve, conheceremos melhor o papel destes 
arquivos. Deixe os valores default e clique em Finish para finalizar a criação do projeto.
FIGURA 23 – Escolhendo um modelo para a tela principal do aplicativo
Fonte: Android Studio
Após alguns segundos, seu projeto estará criado e pronto para ser modificado. A tela do Android 
Studio com um projeto recém-criado é semelhante à apresentada na figura 23. Caso não esteja 
 
Pág. 27 de 95
visualizando a tela do aplicativo como a mostrada na figura, abra, à esquerda, as pastas app\res\
layout e clique duas vezes sobre o arquivo activity_main .xml.
FIGURA 24 – Projeto Contador no Android Studio
Fonte: Android Studio
• À esquerda, temos a aba Project, em que são exibidos os arquivos do projeto. Os dois arquivos 
mais importantes para nós, por enquanto, são os seguintes:
◊	MainActivity .java, na pasta app\java\nome_do_pacote_de_classes: é o arquivo no qual 
escrevemos o código Java relativo aos eventos (ações) que ocorrem em uma tela. Por 
exemplo: quando a tela é criada ou quando o usuário toca em um botão.
◊	 activity_main .xml, na pasta app\res\layout: contém a especificação em XML do layout da 
tela do programa. É este arquivo que está aberto no momento e você pode vê-lo (no modo 
de layout gráfico) na parte central do Android Studio.
• Na parte central do Android Studio, são exibidos os arquivos atualmente abertos. Na figura 
24, o arquivo atualmente aberto é o activity_main .xml, que contém o layout da tela. Quando 
criamos o layout, podemos alternar entre a sua exibição gráfica (por meio da aba Design, 
na parte inferior) ou do seu código em XML (exibido no clique da aba Text). Outros arquivos 
abertos podem ser “trazidos para frente” por meio do uso das abas.
• No canto superior direito, temos a Component Tree (Árvore de Componentes). Ela é útil, pois 
mostra a hierarquia dos widgets na janela (os componentes que usamos para montar uma 
tela – como botões e rótulos de texto).
 
Pág. 28 de 95
• No canto inferior direito, temos Properties, a janela de propriedades. Ela é usada para 
modificarmos os atributos dos widgets existentes na tela. Por exemplo: clicando sobre um 
botão, podemos trocar o texto exibido dentro dele alterando a propriedade text.
• Por fim, na parte inferior do Android Studio, temos (ocultas na figura 24, mas que podem ser 
abertas clicando nos botões existentes) janelas de informações diversas. É ali que serão 
exibidas informações sobre a execução de um programa e localização de erros de compilação 
e execução.
Antes de começarmos a escrever o código do nosso aplicativo, precisamos assegurar que um 
AVD (Android Virtual Device) esteja disponível para testarmos o app no emulador. Esse AVD já pode 
ter sido criado para você automaticamente no momento da instalação. Porém, se uma mensagem de 
erro foi exibida ao seu final (como mostrado na figura 18), será necessário criar o AVD manualmente.
Se este foi o seu caso, siga as etapas da próxima seção, onde são dadas instruções sobre como 
criar o AVD caso ele não exista.
3.4. Criando um dispositivo virtual Android (AVD)
Para testar seus aplicativos você utilizará o emulador do Android incluído no Android Studio. 
Antes de utilizá-lo, é preciso criar um “dispositivo virtual Android” (AVD: Android Virtual Device), 
que é uma “imagem” do sistema operacional com uma configuração de hardware adequada para 
seus testes (simulando, assim, um dispositivo real).
Você precisa criar somente um AVD para testar seus programas. Porém, caso deseje (ou precise), 
pode criar AVDs com diferentes versões do Android e configurações de hardware variadas para testes.
Verifique se o AVD foi criado no momento da instalação clicando sobre o botão indicado na figura 
25. Este botão abre o AVD Manager, um gerenciador para criação e manutenção dos dispositivos 
virtuais.
 
Pág. 29 de 95
FIGURA 25 – Botão da barra de ferramentas para abertura do AVD Manager
Fonte: Android Studio
Se seu computador atendeu aos requisitos necessários, deve ter sido criado um AVD usando 
uma imagem do Android para processadores x86, que poderá ser executada em alto desempenho 
no seu computador. Caso não tenha sido possível a criação, e uma mensagem de erro semelhante 
à exibida na figura 18 tenha sido mostrada, será preciso criar um AVD usando uma imagem do 
Android para processadores ARM.
Caso seja exibida uma tela como a da figura 26, siga as próximas etapas para criar o AVD.
FIGURA 26 – AVD Manager: neste exemplo, nenhum AVD foi criado
Fonte: Android Studio
Para iniciar o processo de criação do AVD, clique no botão Create Virtual Device. Será mostrada 
a tela apresentada na figura 27.
 
Pág. 30 de 95
FIGURA 27 – Configurações do novo dispositivo virtual Android
Fonte: Android Studio
Neste ponto selecionamos uma configuração para o aparelho a ser emulado. Marque o Nexus 4 
dentro da categoria Phone. Ele tem um tamanho de tela semelhante a muitos aparelhos Android do 
mercado e serve perfeitamente como base para nossos aplicativos. Clique em Next para continuar.
Em seguida, precisaremos escolher a imagem do Android a ser usada na emulação. Lembre-se 
de que estamos criando um AVD porque o instalador do Android Studio não conseguiu gerar um 
dispositivo virtual padrão com a imagem x86 no seu computador. Por isso, deveremos escolher 
uma imagem destinada a outra família de processadores, a família ARM.
Para baixar a imagem do Android para ARM, clique na aba Other Images da tela na figura 28. 
Localize a imagem do Android Marshmallow (ou versão mais recente) para processador ARM 
(indicada na coluna ABI como armeabi-v7) e com suporte às APIs do Google, como a indicada pela 
seta na figura 28. Clique então em Download para que a imagem seja baixada.
 
Pág. 31 de 95
FIGURA 28 – Escolhendo a imagem do Android a ser usada no AVD
Fonte: Android Studio
Uma nova tela, exibida na figura 29, será exibida. Para iniciar o download, você precisa concordar 
com os termos de uso da imagem clicando em Accept e, posteriormente, em Next.
FIGURA 29 – Aceitando os termos e iniciando o download
Fonte: Android Studio
O download será então iniciado. Quando estiver finalizado, clique no botão Finish (figura 30).
 
Pág. 32 de 95
FIGURA 30 – Aceitando os termos e iniciando o download
Fonte: Android Studio
A nova imagem poderá agora ser selecionada, como indicado na figura 31. Clique sobre ele e, 
em seguida, no botão Next.
FIGURA 31 – Selecionando a imagem ARM para o AVD
Fonte: Android Studio
Os avisos em vermelho indicam que a CPU do computador em questão não suporta a tecnologia 
VT-x, por isso temos de criar um AVD com a imagem do Android para processador ARM. Como 
 
Pág. 33 de 95
indicado na outra mensagem logo abaixo, a emulação para x86 apresentaria um desempenho 
superior.
Na última tela de configuração do AVD (figura 32), podemos manter as configurações default 
e clicar no botão Finish.
FIGURA 32 – Última tela do processo de criação do AVD
Fonte: Android Studio
Tudo pronto! Pode fechar o AVD Manager e voltar ao projeto que criamos anteriormente; vamos 
finalmente implementá-lo!
3.5. Escrevendo o código do seu primeiro aplicativo
Para poder exemplificar a criação passo a passo de um aplicativo Android, vamos criar um 
programa simples, que realiza uma contagem com base em toques em um botão.
A primeira etapa na criação de um app geralmente é a montagem da sua interface.No Android, 
fazemos isso colocando e configurando os elementos visuais (widgets), e isso pode ser feito 
graficamente ou por meio da escrita direta do arquivo XML. Para escrever o layout de uma tela em 
XML, na parte inferior da janela central do Android Studio, clique na aba Text.
Você tem duas opções agora: pode construir sua interface graficamente, arrastando os widgets 
existentes na palheta (Palette) e configurando suas propriedades de acordo com a listagem do 
quadro 4, ou digitar diretamente seu código em XML.
 
Pág. 34 de 95
QUADRO 4 – Código do arquivo activity_main.xml (pasta res\layout do projeto)
<?xml version=”1.0” encoding=”utf-8”?> 
<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android” 
xmlns:tools=”http://schemas.android.com/tools” 
android:layout _ width=”match _ parent” 
android:layout _ height=”match _ parent” 
android:paddingBottom=”@dimen/activity _ vertical _ margin” 
android:paddingLeft=”@dimen/activity _ horizontal _ margin” 
android:paddingRight=”@dimen/activity _ horizontal _ margin” 
android:paddingTop=”@dimen/activity _ vertical _ margin” 
tools:context=”com.example.professores.contador.MainActivity”> 
<TextView 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:textAppearance=”?android:attr/textAppearanceLarge” 
android:text=”0” 
android:id=”@+id/txtContador” 
android:layout _ alignParentTop=”true” 
android:layout _ centerHorizontal=”true” 
android:layout _ marginTop=”41dp” /> 
<Button 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:text=”Contar” 
android:id=”@+id/button” 
android:layout _ below=”@+id/txtContador” 
android:layout _ centerHorizontal=”true” 
android:layout _ marginTop=”41dp” 
android:onClick=”onClickContar” /> 
</RelativeLayout>
Neste layout, temos um TextView, usado para exibição de um texto, e um Button, o qual, quando 
tocado, incrementará uma variável contadora que será posteriormente mostrada no TextView.
 
Pág. 35 de 95
O TextView recebeu o idtxtContador, e será por meio dele que faremos acesso a este widget 
pelo código Java.
Também modificamos a propriedade text de cada um deles, colocando nela o texto que será 
exibido (0 inicialmente para o TextView contador e “Contar” para o botão).
Repare, na última linha das configurações do Button, que definimos o valor onClickContar para 
sua propriedade onClick. Trata-se do nome do método Java que será disparado, dentro do arquivo 
MainActivity .java, quando o usuário clicar no botão.
CUIDADO NA HORA DE DEFINIR O NOME DO MÉTODO PARA onClick!
O nome que você coloca na propriedade onClick de um Button deve ser exatamente o mesmo que 
utilizará no código Java! Tome cuidado, pois maiúsculas e minúsculas fazem, sim, toda a diferença.
Vamos agora ao código Java. Abra o arquivo MainActivity .java, existente dentro da pasta java\
nome_do_seu_pacote do seu projeto (o nome do pacote dependerá do que foi colocado em Company 
domain no momento da criação do app – veja a figura 20). Deixe o código-fonte como o exibido 
no quadro 5.
 
Pág. 36 de 95
QUADRO 5 – Código do arquivo MainActivity.java (pasta java do projeto)
package com.example.professores.contador; 
 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.TextView; 
 
public class MainActivity extends AppCompatActivity { 
 
int contador = 0; 
 
public void onClickContar(View v) { 
 TextView txtContador = (TextView)findViewById(R.id.txtContador); 
contador++; 
 txtContador.setText(String.valueOf(contador)); 
 } 
 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity _ main); 
 } 
 
}
Começamos acrescentando os imports para duas classes do Android SDK que vamos utilizar: 
View e TextView.
Em seguida, no início da classe, declaramos uma variável int denominada contador e atribuímos 
0 a ela. Essa variável será criada assim que a janela for aberta (ou seja, assim que o programa 
começar), e será visível por todos os métodos existentes nela. Sua “vida útil” será a mesma da 
classe; como a classe corresponde à janela, enquanto a janela estiver ativa a variável será mantida.
 
Pág. 37 de 95
O método onClickContar será executado quando o usuário tocar no botão que colocamos 
na interface. Repare que este método deve ter o mesmo nome colocado no arquivo XML e deve, 
obrigatoriamente, ter o retorno e parâmetro especificados.
Os widgets colocados na interface não são diretamente acessíveis pelo código Java; por isso 
precisamos da primeira linha existente no método, na qual chamamos o importantíssimo comando 
findViewById() para “conectar” a variável local txtContador, declarada dentro do método, ao respectivo 
widget existente na interface (localizado por seu id em R .id .txtContador).
Em seguida, incrementamos o valor do inteiro contador e o colocamos convertido em String 
“dentro” do txtContador, nosso TextView, usando seu método setText().
Tudo pronto! Para executar o aplicativo e testá-lo no emulador, clique no botão da barra 
de ferramentas do Android Studio, selecione um AVD na tela que será mostrada e clique em OK. O 
resultado será semelhante ao apresentado na figura 33.
FIGURA 33 – Tela do aplicativo Contador
Fonte: Android Studio
 MÓDULO 3 – VIEW E ACTIVITY
Neste módulo entraremos mais a fundo no que é uma View e uma Activity no Android. Você 
verá que entender bem os conceitos por trás destas duas classes é essencial para desenvolver 
aplicativos mais completos. Aprenderá como usar outros widgets além do Button e do TextView 
vistos no módulo anterior e saberá como funciona o processo de abertura e exibição de uma tela, 
 
Pág. 38 de 95
por meio da sua Activity. Por fim, conhecerá a ListActivity e a ListView, que permitem a exibição 
rápida e prática de uma lista de itens na tela do Android.
AULA 4 – WIDGETS BÁSICOS E DEFINIÇÃO DE VIEW
No módulo anterior você ficou sabendo o que são widgets: os elementos que usamos para 
“construir” a tela de um aplicativo Android. Mas ainda não sabe que existe uma classe “pai” para 
todos esses objetos que colocamos na tela do Android: a View.
Basicamente, poderíamos definir uma View como um espaço retangular delimitado na tela 
do Android. Nessa definição se encaixam os widgets e, também, os gerenciadores de layout, que 
funcionam como “caixas” ou “containers” de outros widgets.
Todos pertencem a uma hierarquia de classes, que pode ser observada (parcialmente) na figura 
34.
FIGURA 34 – Parte da hierarquia de Views e Widgets do Android
Fonte: Querino Filho, 2013
Por isso, lembre-se: todo elemento colocado em uma tela do Android é, portanto, uma View. 
Isso possibilita, por exemplo, que possamos usar o comando findViewById para conectar o código 
Java a qualquer tipo de objeto na tela.
 
Pág. 39 de 95
FIGURA 35 – Palheta de widgets do Android
Fonte: Android Studio
4.1. Widgets: os componentes de uma tela Android
Como já sabemos, existem diversos widgets que podemos usar para montar uma tela de um 
aplicativo Android. Nós já usamos e conhecemos dois deles: o TextView e o Button.
Você pode conhecer os demais pela Palette do Android Studio (figura 35) ou consultando a 
documentação oficial da API do Android.
Você já percebeu que podemos colocar os widgets diretamente em uma tela arrastando os 
componentes a partir da palheta. Selecionando um widget, você pode configurar suas propriedades 
pela janela Properties, como na figura 36.
 
Pág. 40 de 95
FIGURA 36 – Configurando widgets graficamente
Fonte: Android Studio
Porém, desenvolvedores mais experientes, de acordo com os tutoriais e documentação 
disponibilizados pelo Google em developer.android.com (2014), preferem configurar a interface 
diretamente pelo código XML. Para editar a interface usando XML, clique sobre a aba indicada na 
figura 37.
FIGURA37 – Visualizando e editando a interface via XML
Fonte: Android Studio
 
Pág. 41 de 95
4.2. Introdução ao Activity: a classe Java controladora de uma tela
A classe MainActivity.java que existe em todo projeto Android criado contém o código necessário 
para manipular os eventos que acontecem com a tela.
Dê uma olhada no código “básico” de uma Activity recém-criada no quadro 6.
QUADRO 6 – Código do arquivo MainActivity.java de um projeto recém-criado
package com.example.professores.contador; 
 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
 
public class MainActivity extends AppCompatActivity { 
 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity _ main); 
 } 
 
}
Imediatamente, pela declaração da classe, você pode perceber que ela herda AppCompatActivity, 
uma classe existente no Android SDK que serve como base para nossas telas.
Como desenvolvedor Java experiente, você já notou a existência de um método e que ele está 
marcado com a anotação @Override, que indica que este método está sobrescrevendo um método 
recebido por herança da sua superclasse (AppComptaActivity).
O método em questão se chama onCreate. Como o próprio nome dá a entender, ele é executado 
quando o evento de criação da tela acontece, ou seja, assim que a tela aparece pela primeira vez.
Dentro dele, vemos uma chamada ao método original da superclasse – ele está lá para que 
uma tela básica em branco seja criada. Em seguida, vem uma parte fundamental: o comando 
setContentView. Perceba que passamos ao setContentView o nome do nosso arquivo de layout, 
 
Pág. 42 de 95
existente na pasta res/layout. Sim, é ele mesmo: o arquivo XML no qual definimos nossa interface! 
É graças ao setContentView que, ao invés de ficarmos com a tela branca padrão, temos a exibição 
do layout criado!
CURIOSIDADE
FAZENDO UMA EXPERIÊNCIA: DESATIVANDO O “setContentView”
Para entender melhor o “porquê” do setContentView, faça uma experiência com um dos seus projetos: 
comente (coloque duas barras no início da linha) o setContentView, dentro do método onCreate da 
classe MainActivity, execute o projeto e veja o resultado.
Sentiu falta de alguma coisa?
4.3. Mais Widgets: EditText, ImageView e Toast
Vamos conhecer agora mais alguns widgets bastante úteis, começando por um praticamente 
essencial: o EditText. É com ele que o usuário pode digitar informações para o aplicativo, por meio 
do uso do teclado virtual (ou físico em alguns poucos modelos).
O widget EditText pode ser configurado para restringir os caracteres que o usuário poderá digitar 
nele. Por exemplo, no caso de fornecimento de valores numéricos, é possível “travar” a entrada de 
caracteres que não sejam números, pontuação e sinal. Há também uma variação adequada para o 
fornecimento de números de telefone, por exemplo, que permite apenas números, parênteses e hífen.
Você pode adicionar o EditText diretamente pelo código XML ou pode simplesmente arrastar e 
soltar uma das suas variações existentes na palheta, dentro da categoria Text Fields (veja a figura 38).
 
Pág. 43 de 95
FIGURA 38 – Localização dos widgets EditText na palheta do Android Studio
Fonte: Android Studio
Todos os widgets existentes na palheta são EditText; o que diferencia um do outro aqui é sua 
configuração Input Type, que estabelece o controle sobre quais caracteres são permitidos.
Com um EditText na interface, você pode obter o valor digitado nele por seu método getText(), 
que deverá receber um toString() ao final para que seja convertido para uma String Java. Para 
colocar uma String em um EditText, usamos o seu método setText(), passando a String como seu 
parâmetro. Veja no quadro 7 exemplos de como utilizá-los.
QUADRO 7 – Exemplo de uso de um EditText em código Java
// Faz a conexão ao editText1 na interface
EditText editText1 = (EditText)findViewById(R.id.editText1);
// Obtém o conteúdo do editText1 e o converte para uma String Java básica
String textoNoEdit = editText1.getText().toString();
// Coloca no editText1 o conteúdo da String em letras maiúsculas
editText1.setText(textoNoEdit.toUpperCase());
Outro widget que pode ser bastante útil em seus projetos é o ImageView. Com ele, podemos 
exibir imagens e fotos em uma tela do Android.
Para utilizá-lo, basta copiar uma imagem para a pasta res\drawable do seu projeto. Você pode 
fazer isso simplesmente copiando o arquivo da imagem (com CTRL+C em um PC ou Command+C 
 
Pág. 44 de 95
em um Mac) e colando (com CTRL+V em um PC ou Command+V no Mac) na pasta drawable. Na 
tela que será exibida logo após colar, confirme a operação de cópia clicando em OK.
Após colocada a imagem, arraste um widget ImageView (ele está dentro da categoria Widgets da 
palheta) até alguma parte da sua tela. Clique duas vezes sobre ele e, na janela popup que aparecerá, 
especifique a imagem a ser utilizada na propriedade src (veja a figura 39)!
FIGURA 39 – Adicionando imagens a uma tela com ImageView
Fonte: Android Studio
É possível digitar o nome da imagem diretamente em src, colocando o identificador @drawable/ 
antes deste e omitindo sua extensão. Se preferir, clique nos três pontinhos à direita e, na janela que 
será exibida, localize sua imagem na aba Drawable.
Conheceremos agora mais um widget útil: o Toast. Ele não é encontrado na palheta de objetos 
– seu uso é realizado diretamente pelo código Java. Com o Toast, você consegue exibir mensagens 
curtas que desaparecem automaticamente após um período.
Para utilizá-lo, use um código semelhante ao do quadro 8.
 
Pág. 45 de 95
QUADRO 8 – Exemplo de uso de Toast
Toast.makeText(this, “Esta é uma mensagem rápida!”, Toast.LENGTH_SHORT).show();
O método makeText() recebe três parâmetros:
• Um indicador do contexto atual, que geralmente é a própria Activity, na qual o comando é 
executado – por essa razão, passamos this neste parâmetro;
• Uma String de texto com a mensagem a ser exibida;
• Uma constante que determina a duração da exibição da mensagem, que pode ser Toast .
LENGTH_LONG (para maior duração) ou Toast .LENGTH_SHORT (para menor duração).
NUNCA SE ESQUEÇA de chamar o método show() após makeText(), como no quadro 8! O método 
makeText cria a mensagem mas não a exibe; quem faz isso é o método show().
AULA 5 – APROFUNDANDO O CONHECIMENTO SOBRE A CLASSE ACTIVITY
A Activity, classe que funciona como uma controladora de uma tela do aplicativo Android, é 
bastante robusta e flexível. Existem vários eventos e estados de uma Activity, e o programador pode 
criar comportamentos específicos para cada uma delas. Nesta aula, conheceremos também uma 
Activity especial, a ListActivity, que possui embutida uma lista que pode ser usada para listagem 
de diversos tipos de informação.
5.1. O ciclo de vida de uma Activity: onCreate, onDestroy etc.
Já sabemos que, quando uma tela é criada, o seu método onCreate é invocado. Dentro dele, 
podemos colocar código de inicialização de valores e também definição dos elementos da interface, 
com base em um arquivo XML.
Porém, existem outros eventos em uma Activity que podem ser programados. Suponha, por 
exemplo, que no momento em que a Activity for fechada, você precisaria salvar dados ou gravar o 
estado atual do aplicativo para que possa ser restaurado depois. Pois bem, existe um evento que 
você pode sobrescrever para especificar o que fazer nesta situação!
Para compreender melhor o ciclo de vida de uma Activity, dê uma olhada no gráfico da figura 40.
 
Pág. 46 de 95
FIGURA 40 – Ciclo de vida de uma Activity
Fonte: <https://developer.android.com/images/training/basics/basic-lifecycle.png>
• Quando a Activity é criada, o evento onCreate() é disparado.
• Em seguida, ocorre o evento onStart(), logo antes da Activity finalmente ser exibida ao usuário.
• Quando a Activity atual fica parcialmente em segundo plano, em função de uma caixa de 
diálogo ou outra tela semitransparenteter sido aberta, ou seja, uma situação que não oculta 
totalmente a tela, esta entra no estado de onPause().
◊	No momento em que ocorre a desobstrução, a Activity continua após o evento onResume().
• No caso de uma nova tela ser aberta e ocultar totalmente a tela atual, dizemos que esta Activity 
entrou no estado de parada e executou o evento onStop().
◊	Neste caso, quando o usuário retorna à Activity que ficou “de baixo”, ela executa o evento 
onRestart() e posteriormente o onStart().
• Finalmente, logo antes da Activity ser totalmente fechada, ocorre o evento onDestroy().
 5.2. Eventos de clique em botões
Os cliques (ou melhor dizendo, toques) nos botões são as principais formas de programar ações 
em um aplicativo Android. Dizemos que ele é um evento e que será manipulado por um método 
dentro de uma classe Java (no caso, a Activity).
Definimos o nome do método que será disparado no toque de um botão por meio da sua 
propriedade onClick, dentro de um arquivo XML. Também pode ser designado por meio da interface 
 
Pág. 47 de 95
gráfica, usando a janela de propriedades. No caso do XML, a configuração da propriedade é feita 
como exibido no quadro 9.
QUADRO 9 – Exemplo de uso de configuração do evento onClick botão
<Button 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:text=”Incluir” 
android:id=”@+id/button” 
android:layout _ centerHorizontal=”true” 
android:layout _ marginTop=”36dp” 
android:onClick=”onClickIncluir” />
Depois de configurado o nome do método na propriedade, o método para o evento deve ter 
exatamente o mesmo nome que foi especificado. Também é obrigatório que o método seja public 
com retorno vazio (void) e que receba um objeto da classe View como parâmetro, como mostra o 
exemplo no quadro 10.
QUADRO 10 – Exemplo de método para evento onClick de um botão
public void onClickIncluir(View view) { 
 
// Lógica para execução no clique do botão, como por exemplo 
 // procedimentos para inclusão de um cliente no banco de dados 
 
}
5.3. ListActivity = Activity + ListView
Se você já deu uma boa olhada na palheta de widgets, pode ter visto um componente chamado 
ListView. Ele é bastante útil para uma série de aplicativos, pois torna muito fácil a exibição de dados 
em listas. Ele está dentro da categoria Containers da palheta (veja a figura 41).
 
Pág. 48 de 95
FIGURA 41 – Localização do widget ListView na palheta do Android Studio
Fonte: Android Studio
Você pode adicionar este ListView a uma tela de layout, conectá-lo ao código Java com 
findViewById() e depois programar o widget para exibir os dados. Mas há um jeito ainda mais 
prático e com mais opções: usar a ListActivity.
Trata-se de uma Activity especial, que já “sabe” como lidar com um ListView. Na verdade, ela 
traz em si um ListView embutido, e poderia até mesmo ser usada sem um arquivo de layout, mas 
vamos usá-la junto do activity_main.xml para que possamos customizá-lo.
Vamos supor que você está querendo criar uma lista de compras. O primeiro passo é criar um 
layout com um ListView para exibição da lista, assim como um EditText para o usuário escrever 
um nome de um item e um botão com a ação de incluí-lo. Um exemplo de layout dessa maneira 
pode ser visto no quadro 11.
 
Pág. 49 de 95
QUADRO 11 – Exemplo de arquivo de layout com ListView, EditText e Button.
<?xml version=”1.0” encoding=”utf-8”?> 
<RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android” 
xmlns:tools=”http://schemas.android.com/tools” 
android:layout _ width=”match _ parent” 
android:layout _ height=”match _ parent” 
android:paddingBottom=”@dimen/activity _ vertical _ margin” 
android:paddingLeft=”@dimen/activity _ horizontal _ margin” 
android:paddingRight=”@dimen/activity _ horizontal _ margin” 
android:paddingTop=”@dimen/activity _ vertical _ margin” 
tools:context=”com.example.professores.listadecompras.MainActivity”> 
<EditText 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:id=”@+id/edtProduto” 
android:layout _ alignParentTop=”true” 
android:layout _ alignParentLeft=”true” 
android:layout _ alignParentStart=”true” 
android:layout _ alignParentRight=”true” 
android:layout _ alignParentEnd=”true” /> 
<Button 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:text=”Incluir” 
android:id=”@+id/button” 
android:layout _ below=”@+id/edtProduto” 
android:layout _ alignParentLeft=”true” 
android:layout _ alignParentStart=”true” 
android:layout _ alignRight=”@+id/edtProduto” 
android:layout _ alignEnd=”@+id/edtProduto”
 
Pág. 50 de 95
android:onClick=”onClickAdicionar” /> 
<ListView 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:id=”@android:id/list” 
android:layout _ below=”@+id/button” 
android:layout _ alignParentLeft=”true” 
android:layout _ alignParentStart=”true” /> 
</RelativeLayout>
Os pontos principais neste layout são os seguintes:
• Colocamos no EditText, em que será digitado o item idedtProduto, para identificá-lo corretamente 
no código Java;
• No Button que vai realizar a inclusão do item digitado, configuramos seu evento onClick para 
disparar o método onClickAdicionar – este será o nome que deveremos usar na classe Java;
• No ListView, uma configuração fundamental para que ele possa ser usado na ListActivity: seu 
id tem que ser, obrigatoriamente, @android:id/list.
Na classe Java, teremos código para:
• Inicializar a lista com alguns valores (faremos isso no evento onCreate);
• Incluir um item na lista quando o usuário tocar no botão (isso será feito na programação do 
método onClickAdicionar);
• Excluir um item da lista quando ele for tocado (conseguiremos fazer isso com o uso de um 
evento especial da ListActivity, chamado onListItemClick).
Para conseguir cumprir esses procedimentos, altere o código da MainActivity.java do seu projeto 
para o exibido no quadro 12.
 
Pág. 51 de 95
QUADRO 12 – Código para MainActivity.java com suporte a ListView
package com.example.professores.listadecompras; 
 
import java.util.ArrayList; 
 
import android.app.ListActivity; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.ArrayAdapter; 
import android.widget.EditText; 
import android.widget.ListView; 
import android.widget.Toast; 
public class MainActivity extends ListActivity { 
 EditText edtProduto; 
 ArrayList<String>lista; 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
 setContentView(R.layout.activity _ main); 
 String[] produtos = new String[]{“Arroz”, “Feijão”, “Batata”}; 
lista = new ArrayList<String>(); 
for (int i = 0; i < produtos.length; ++i) { 
lista.add(produtos[i]); 
 } 
 ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this, 
 android.R.layout.simple _ list _ item _ 1, lista); 
 setListAdapter(adaptador); 
edtProduto = (EditText)findViewById(R.id.edtProduto); 
 } 
public void onClickAdicionar(View v) {
 
Pág. 52 de 95
 String produto = edtProduto.getText().toString(); 
lista.add(produto); 
 ArrayAdapter<String> adaptador = (ArrayAdapter<String>)getListAdapter(); 
 adaptador.notifyDataSetChanged(); 
edtProduto.setText(“”); 
 } 
@Override 
protected void onListItemClick(ListView l, View v, int position, long id) { 
 Toast.makeText(this, “Você selecionou: “ + lista.get(position), Toast.LENGTH _
SHORT).show(); 
 } 
}
android:layout _ alignRight=”@+id/edtProduto” 
android:layout _ alignEnd=”@+id/edtProduto”
android:onClick=”onClickAdicionar” />
<ListView 
android:layout _ width=”wrap _ content” 
android:layout _ height=”wrap _ content” 
android:id=”@android:id/list” 
android:layout _ below=”@+id/button” 
android:layout _ alignParentLeft=”true” 
android:layout _ alignParentStart=”true” /> 
</RelativeLayout>
O primeiro passo a ser feito é mudar a superclassede MainActivity de AppCompatActivity para 
ListActivity. Basta trocar o nome da superclasse após extends e adicionar o import adequado;
• Toda lista precisa ter uma fonte para seus dados, ou seja, os elementos que serão colocados 
na lista; por isso, declaramos na nossa classe um ArrayList de Strings denominado lista. 
Como usaremos o EditText edtProduto em mais de um método, também o colocamos como 
um campo global da classe;
• No onCreate, fazemos a inicialização da lista. Criamos um vetor comum de Strings (produtos) 
e depois adicionamos os seus elementos ao ArrayList lista. Para conectar os elementos do 
 
Pág. 53 de 95
ArrayList à lista do ListView, usamos um objeto do Android denominado ArrayAdapter. Criamos 
um chamado adaptador, e ao seu construtor passamos três parâmetros: uma referência ao 
contexto atual (this, ou seja, a própria Activity em que estamos criando o adaptador); o nome 
de um layout para a lista – neste caso, usamos um layout padrão do Android que contém 
apenas uma linha de texto por item da lista – simple_list_item_1; e, finalmente, o adaptador;
• Na penúltima linha do onCreate, o método setListAdapter configura o adaptador para a lista 
existente. Com isso, os itens já adicionados ao ArrayList já aparecerão no ListView;
• Por fim, no onCreate, criamos a ligação entre o edtProduto local na classe e ao existente na 
interface R .id .edtProduto;
• O método onClickAdicionar será executado quando o usuário tocar no botão criado na interface. 
Inicialmente, usamos a referência a edtProduto para obter o texto nele contido e armazenar 
na String produto. Obtemos, então, uma referência ao adaptador para chamar seu método 
notifyDataSetChanged(), que fará a atualização dos dados exibidos no ListView, já que mudamos 
a fonte dos dados do ListView (o ArrayList lista) acrescentando mais um produto;
• O método onListItemClick é um evento que ocorre quando um item da lista é tocado. Bastante 
útil, ele recebe quatro parâmetros. Um deles é particularmente útil para nós: o intposition, que 
traz o índice da linha tocada dentro da lista (0 para o primeiro até n-1 para o último, sendo n a 
quantidade de itens na lista). Como nossa lista está exibindo diretamente o conteúdo de um 
ArrayList, o position é exatamente o índice do elemento no ArrayList. Assim, exibimos uma 
mensagem rápida com Toast, mostrando o nome do item tocado, que é obtido diretamente 
do ArrayList.
SAIBA MAIS
A VERSATILIDADE DO onListItemClick
Este método pode ser usado para várias outras operações com a lista:
Excluir um item tocado;
Abrir uma próxima tela com mais informações do elemento tocado (veremos como abrir uma nova 
tela no próximo módulo);
Iniciar a alteração do item, em uma caixa de diálogo ou tela em que os dados podem ser alterados.
MÓDULO 4 – LAYOUTS E INTENTS
Construir uma boa interface de um aplicativo Android é muito mais do que escrever o código XML 
corretamente ou arrastar, soltar e configurar as propriedades dos widgets. O uso dos “containers” 
de widgets (os gerenciadores de layout) possibilita que os elementos permaneçam organizados 
 
Pág. 54 de 95
adequadamente na tela, até mesmo no caso de aparelhos com diferentes tamanhos de tela. Neste 
módulo, conheceremos um pouco mais sobre os gerenciadores de layout. A classe Intent, utilizada 
para realizar operações que envolvam atenção do sistema operacional, por exemplo, abrir novas 
janelas, também será abordada neste módulo.
AULA 6 – ORGANIZANDO A TELA COM GERENCIADORES DE LAYOUT
Há várias opções de gerenciadores de layout no Android SDK. Muitas delas podem ser simplesmente 
arrastadas para a tela por meio da palheta de widgets, como pode ser observado na figura 42.
FIGURA 42 – Gerenciadores de layout disponíveis na palheta de widgets
Fonte: Android Studio
Como você pode ver, há várias opções de layout.
Porém, a grande maioria dos aplicativos é construída com um destes dois: RelativeLayout e 
LinearLayout, que são, inclusive, os mais utilizados nos documentos de referência que a Google 
disponibiliza no developer.android.com.
Veremos agora um pouco mais sobre cada um destes dois, assim como as vantagens e 
desvantagens em utilizá-los.
 
Pág. 55 de 95
6.1. RelativeLayout
O layout relativo (RelativeLayout) é o padrão para construção de novas telas no Android. Ele faz 
com que os widgets sejam posicionados em relação a outro, ou em relação aos cantos e centro da 
tela. Assim, os widgets podem se adaptar adequadamente a mudanças na tela. Veja na figura 43 
um exemplo de uso do layout relativo.
FIGURA 43 – Exemplo de uso do RelativeLayout
Fonte: Android Studio
Você vê as linhas verdes na figura 43? Elas mostram o posicionamento relativo do widget 
selecionado. Por exemplo, o TextView contendo o texto Celsius está posicionado em relação aos 
lados superior e esquerdo da tela, assim como um pouco acima em relação ao TextView contendo 
o texto Fahrenheit. Agora veja na figura 44 o posicionamento do EditText à direita de Fahrenheit.
FIGURA 44 – Exemplo de uso do RelativeLayout
Fonte: Android Studio
 
Pág. 56 de 95
Podemos ver que o EditText está posicionado em relação aos dois TextView, ao EditText do 
Celsius e também ao botão.
Esse excesso de “relações” pode ser problemático: se movermos ou reposicionarmos apenas 
um widget, pode ocorrer uma “reação em cadeia” que modificará profundamente a interface. Em 
alguns casos, o reposicionamento automático para diferentes tamanhos de tela pode também não 
surtir o efeito desejado.
Para ter uma garantia maior da posição final dos widgets, diminuindo a liberdade no seu 
posicionamento, podemos utilizar o Linear Layout.
6.2. LinearLayout
Com o layout linear, podemos ter mais certeza com relação ao posicionamento final dos widgets 
em diferentes tamanhos de tela, assim como não correremos mais o risco de um reposicionamento 
de um widget alterar completamente a interface.
Há duas variações do Layout Linear: o vertical e o horizontal. Quando usamos o vertical, os 
widgets são colocados um abaixo do outro; quando usamos o horizontal, são colocados ao lado, 
em uma única linha. Veja a diferença entre eles na figura 45.
FIGURA 45 – Comparação entre Layout Linear Vertical (esquerda) e Horizontal (direita)
Fonte: Android Studio
Aparentemente, o uso do LinearLayout parece ser bem limitado; afinal, no vertical, (esquerda na 
figura 45) você pode apenas colocar um widget abaixo do outro, e no horizontal (direita na figura 
44), todos ficam na mesma linha, um ao lado do outro.
 
Pág. 57 de 95
Porém, você pode mesclar o uso do layout linear horizontal com o vertical e criar telas em um 
estilo tabela. Dê uma olhada no exemplo da figura 46.
FIGURA 46 – Uso do LayoutLinear horizontal combinado com o vertical
Fonte: Android Studio
Na figura 46, veja na Component Tree (no canto superior direito) que colocamos um Layout Linear 
Vertical com dois Layout Linear Horizontal empilhados, seguidos de um botão. Dentro dos dois 
layouts horizontais, colocamos, em linha, os TextViews e campos de entrada de texto necessários. 
A listagem deste exemplo de layout pode ser vista no quadro 13.
 
Pág. 58 de 95
QUADRO 13 – Código para arquivo XML de layout com Linear Layout
<?xml version=”1.0” encoding=”utf-8”?> 
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android” 
android:orientation=”vertical” android:layout _ width=”match _ parent” 
android:layout _ height=”match _ parent”> 
<LinearLayout 
android:orientation=”horizontal” 
android:layout _ width=”match _ parent” 
android:layout _ height=”wrap _ content”> 
<TextView 
android:layout _ width=”0dp” 
android:layout _ height=”wrap _ content” 
android:textAppearance=”?android:attr/textAppearanceLarge” 
android:text=”Celsius:” 
android:id=”@+id/textView3” 
android:layout _ weight=”1” 
android:gravity=”right” /> 
<EditText 
android:layout _ width=”0dp” 
android:layout _ height=”wrap _ content” 
android:inputType=”numberDecimal” 
android:ems=”10”android:id=”@+id/editText3” 
android:layout _ weight=”1”> 
<requestFocus/> 
</EditText> 
</LinearLayout> 
<LinearLayout 
android:orientation=”horizontal” 
android:layout _ width=”match _ parent”
 
Pág. 59 de 95
android:layout _ height=”wrap _ content”> 
<TextView 
android:layout _ width=”0dp” 
android:layout _ height=”wrap _ content” 
android:textAppearance=”?android:attr/textAppearanceLarge” 
android:text=”Fahrenheit:” 
android:id=”@+id/textView4” 
android:layout _ weight=”1” 
android:gravity=”right” /> 
<EditText 
android:layout _ width=”0dp” 
android:layout _ height=”wrap _ content” 
android:inputType=”numberDecimal” 
android:ems=”10” 
android:id=”@+id/editText4” 
android:layout _ weight=”1” /> 
</LinearLayout> 
<Button 
android:layout _ width=”match _ parent” 
android:layout _ height=”wrap _ content” 
android:text=”Converter” 
android:id=”@+id/button2” /> 
</LinearLayout>
6.3. Menus e Caixas de Diálogo
Para aplicativos novos, a Google recomenda o uso da ActionBar como menu dos aplicativos. A 
ActionBar é a barra existente no topo de um aplicativo Android (veja figura 47).
 
Pág. 60 de 95
FIGURA 47 – ActionBar (em destaque) em um aplicativo Android
Fonte: Android Studio
Para poder usar a ActionBar é necessário possuir um arquivo XML que define os itens que ela 
contém. Também é preciso possuir dois métodos específicos implementados no código da Activity. 
Você não precisa criar o arquivo XML e os métodos manualmente: para tê-los automaticamente, 
no momento de criação do seu projeto, escolha o modelo Blank Activity para sua tela inicial (veja 
a figura 22 na seção 3.3).
Os itens de menu da ActionBar são ações que devem ser definidas com a tag item, em um 
arquivo XML existente dentro da pasta res/menu. Todo novo projeto criado com o modelo de te;a 
Blank Activity já vem com um arquivo XML contendo um item de menu para abrir as preferências 
do aplicativo (caso existam). Veja seu conteúdo no quadro 14.
QUADRO 14 – Código para arquivo XML do arquivo de menu res/menu/menu_main.xml
<menu xmlns:android=”http://schemas.android.com/apk/res/android” 
xmlns:app=”http://schemas.android.com/apk/res-auto” 
xmlns:tools=”http://schemas.android.com/tools” 
tools:context=”com.example.professores.megasena.MainActivity”> 
<item 
android:id=”@+id/action _ settings” 
android:orderInCategory=”100” 
android:title=”@string/action _ settings” 
app:showAsAction=”never” /> 
</menu>
 
Pág. 61 de 95
Em seguida, o que acontecerá quando um item for tocado deverá ser programado no evento 
onOptionsItemSelected, dentro da Activity (veja o quadro 15).
QUADRO 15 – Código para o evento que trata o clique em cada um dos itens de menu na AppCompatActivity
@Override 
public boolean onOptionsItemSelected(MenuItem item) { 
int id = item.getItemId(); 
 
if (id == R.id.action _ settings) {
 Toast.makeText(this, “Você tocou no item das configurações!”,
 Toast.LENGTH _ LONG).show(); 
 // AQUI NESTE PONTO PODERÍAMOS ACRESCENTAR O CÓDIGO NECESSÁRIO PARA 
 // ABERTURA DA TELA DE CONFIGURAÇÕES DO APLICATIVO 
 
 return true; 
 } 
 
return super.onOptionsItemSelected(item); 
}
Para cada item criado no arquivo XML, é possível testar, dentro do onOptionsItemSelected, se ele 
foi pressionado e executar o procedimento adequado. No exemplo do quadro 15, apenas mostramos 
uma mensagem ao usuário. Veremos na próxima aula como abrir novas janelas – esse poderia ser 
o resultado final do clique do item de menu Settings.
No caso de novos itens, você pode adicionar outros else if ao código ou simplesmente trocar 
o uso de if por switch . . .case.
Uma caixa de diálogo pode ser criada facilmente no Android, por meio do uso da classe 
DialogFragment. Podem ser criados diálogos simples, com botões que o usuário pode utilizar para 
responder uma questão, por exemplo, ou diálogos mais sofisticados, com widgets como caixas de 
entrada de texto.
 
Pág. 62 de 95
Para criar um diálogo com DialogFragment, precisamos criar uma subclasse desta. Isso pode 
ser feito dentro da própria classe da Activity – afinal, Java permite criar classes dentro de classes! 
Veja um exemplo no quadro 16, que pode ser colocado dentro de uma Activity.
QUADRO 16 – Código para classe de criação de um diálogo, interna em uma Activity
public static class FecharDialogFragment extends DialogFragment { 
 
static FecharDialogFragment newInstance() { 
return new FecharDialogFragment(); 
 } 
 
@Override 
public Dialog onCreateDialog(Bundle savedInstanceState) { 
 
 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); 
 
 builder.setMessage(“Deseja fechar esta tela?”) 
 .setPositiveButton (“OK”, new DialogInterface.OnClickListener() { 
public void onClick(DialogInterface dialog, int id) { 
// USUÁRIO CLICOU EM OK 
 
} 
 }) 
 .setNegativeButton (“Cancelar”, new DialogInterface.OnClickListener() { 
public void onClick(DialogInterface dialog, int id) { 
// USUÁRIO CLICOU EM CANCELAR 
} 
 }); 
 
return builder.create(); 
 } 
}
Agora, você pode chamar o diálogo no ponto em que desejar da sua Activity (como em um clique 
de botão) instanciando a classe criada e chamando o método show() no objeto criado, como pode 
ser visto no quadro 17.
 
Pág. 63 de 95
QUADRO 17 – Código para exibir a caixa de diálogo criada no quadro 14
public void onClick(View view) {
 FecharDialogFragment fecharDialogFragment = FecharDialogFragment.newInstance();
 fecharDialogFragment.show(getSupportFragmentManager(), “dialog”);
}
 AULA 7 – INTENTS
 7.1. Definição da classe Intent
A classe Intent é usada quando desejamos realizar alguma ação que envolve outros componentes 
do aplicativo ou do sistema. Basicamente, é uma mensagem de solicitação, que será enviada a 
alguém requerendo, por exemplo, a abertura de uma janela, uma chamada telefônica ou a abertura 
do navegador em um determinado endereço.
 Provavelmente o uso mais comum de um Intent é a abertura de uma nova tela. Veja no diagrama 
da figura 48 como acontece esse processo.
FIGURA 48 – Abertura de uma nova tela (Activity) usando Intent
Fonte: <http://developer.android.com/guide/components/intents-fi lters.html>
A partir da tela inicial (Activity A), usamos o comando startActivity() com uma Intent para 
sinalizar ao Android que desejamos abrir uma nova tela. O sistema operacional abre então a Activity 
B indicada na Intent e passa a execução ao evento onCreate() nela existente.
 
Pág. 64 de 95
Veremos na próxima seção quais são os comandos necessários para realizar estas etapas.
7.2. Criando e abrindo uma nova tela com Intent
Antes de tudo, para que possamos abrir outra tela em um aplicativo Android, é preciso haver 
uma classe Activity e um layout XML para ela.
Embora esses dois arquivos possam ser criados individualmente, o Android Studio possui um 
assistente de criação de Activities que automatiza o processo de criação destes dois arquivos.
Para criar uma nova tela no seu aplicativo, clique com o botão direito do mouse sobre a pasta 
app do seu projeto e, no menu que será exibido, selecione File > New >Activity . Escolha o modelo 
para a nova tela – pode ser Empty Activity, como indicado na figura 49.
FIGURA 49 – Adicionando uma nova Activity ao projeto
Fonte: Android Studio
Em seguida (figura 50), dê um nome para sua nova Activity em Activity Name (procure sempre 
manter a palavra Activity ao final – é uma convenção dentro do Android nomear activities dessa 
forma). Note que à medida que você digita o nome da Activity, o nome do arquivo de layout (Layout 
Name) também muda de forma correspondente. Selecione o pacote adequado em Package name 
e clique em Finish.
 
Pág. 65 de 95
FIGURA 50 – Adicionando uma nova Activity ao projeto
Fonte: Android Studio
Perceba que agora você possui uma nova classe Java na pasta java (dentro do primeiro pacote 
de classes) do projeto e um novo arquivo de layout em res\layout! E não é só