Apostila Android

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

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. 5 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. 6 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. 7 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. 8 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. 9 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ção de tela em uso nos dispositivos Android, em Agosto de
2016
Fonte: <http://developer.android.com/about/dashboards/index.html>
Pág. 10 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. 11 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. 12 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. 13 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. 14 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. 15 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 qual está 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. 16 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. 17 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
Pág. 18 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
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. 19 de 95

FIGURA 13 – Finalizando o processo de instalação do Android Studio
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. 20 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
Na tela seguinte (figura 16), mantenha a opção Standard selecionada e clique em Next.
Pág. 21 de 95

FIGURA 16 – Selecionando a opção padrão para finalizar a configuração
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
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. 22 de 95

FIGURA 18 – Tela final da configuração exibindo mensagem de erro
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. 23 de 95

FIGURA 19 – Tela de boas-vindas do 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
Pág. 24 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
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. 25 de 95

FIGURA 22 – Escolhendo um modelo para a tela principal do aplicativo
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
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. 26 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
• À 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. 27 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. 28 de 95

FIGURA 25 – Botão da barra de ferramentas para abertura do AVD Manager
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
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. 29 de 95

FIGURA 27 – Configurações do novo dispositivo virtual Android
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. 30 de 95

FIGURA 28 – Escolhendo a imagem do Android a ser usada no AVD
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
O download será então iniciado. Quando estiver finalizado, clique no botão Finish (figura 30).
Pág. 31 de 95

FIGURA 30 – Aceitando os termos e iniciando o download
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
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. 32 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
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. 33 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:text=”Contar”
android:id=”@+id/button”
android:layout _ below=”@+id/txtContador”
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. 34 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. 35 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. 36 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
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. 37 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. 38 de 95

FIGURA 35 – Palheta de widgets do Android
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. 39 de 95

FIGURA 36 – Configurando widgets graficamente
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.
FIGURA 37 – Visualizando e editando a interface via XML
Pág. 40 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;
@Override
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. 41 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. 42 de 95

FIGURA 38 – Localização dos widgets EditText na palheta do 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. 43 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
É 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. 44 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. 45 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 semitransparente ter 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. 46 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:text=”Incluir”
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. 47 de 95

FIGURA 41 – Localização do widget ListView na palheta do 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. 48 de 95

QUADRO 11 – Exemplo de arquivo de layout com ListView, EditText e Button.

tools:context=”com.example.professores.listadecompras.MainActivity”>
<EditText
android:id=”@+id/edtProduto”
android:layout _ alignParentLeft=”true”
android:layout _ alignParentStart=”true”
android:layout _ alignParentRight=”true”
android:layout _ alignParentEnd=”true” />
<Button
android:text=”Incluir”
android:layout _ below=”@+id/edtProduto”
android:layout _ alignRight=”@+id/edtProduto”
android:layout _ alignEnd=”@+id/edtProduto”
Pág. 49 de 95

android:onClick=”onClickAdicionar” />
<ListView
android:id=”@android:id/list”
android:layout _ below=”@+id/button”
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. 50 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.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
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. 51 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:id=”@android:id/list”
android:layout _ below=”@+id/button”
android:layout _ alignParentStart=”true” />
</RelativeLayout>
O primeiro passo a ser feito é mudar a superclasse de 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. 52 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. 53 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
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. 54 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
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
Pág. 55 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)
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. 56 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
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. 57 de 95

QUADRO 13 – Código para arquivo XML de layout com Linear Layout

<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 _ height=”wrap _ content”>
<TextView
android:layout _ width=”0dp”
android:text=”Celsius:”
android:id=”@+id/textView3”
android:layout _ weight=”1”
android:gravity=”right” />
<EditText
android:inputType=”numberDecimal”
android:ems=”10”
android:id=”@+id/editText3”
android:layout _ weight=”1”>
<requestFocus/>
</EditText>
</LinearLayout>
<LinearLayout
android:orientation=”horizontal”
Pág. 58 de 95

android:layout _ height=”wrap _ content”>
<TextView
android:text=”Fahrenheit:”
android:id=”@+id/textView4”
android:layout _ weight=”1”
android:gravity=”right” />
<EditText
android:inputType=”numberDecimal”
android:ems=”10”
android:id=”@+id/editText4”
android:layout _ weight=”1” />
</LinearLayout>
<Button
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. 59 de 95

FIGURA 47 – ActionBar (em destaque) em um aplicativo Android
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”
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. 60 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. 61 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. 62 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-ﬁ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. 63 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
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. 64 de 95

FIGURA 50 – Adicionando uma nova Activity ao projeto
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ó isso: novas telas devem
ser declaradas no arquivo AndroidManifest.xml do projeto, e isso também já foi feito pelo assistente.
Supondo que você criou uma nova Activity chamada NovaActivity, como na figura 46, para abri-
la você deverá usar os comandos do quadro 18.
QUADRO 18 – Código para abrir uma nova tela (Activity)
Intent intent = new Intent(this, NovaActivity.class);

startActivity(intent);
É bastante simples: basta declarar um objeto da classe Intent, instanciá-lo e passar ao seu
construtor o contexto atual (this) e o nome da classe da Activity que desejamos abrir. Em seguida,
invocamos o método startActivity() passando o objeto intent como parâmetro.
7.3. Passando valores para uma nova tela

Quando usamos uma Intent para abrir novas telas, podemos também passar valores a elas.
Isso é feito com o método putExtra() do objeto Intent.
Existem várias sobrecargas deste método, para que possamos passar diferentes tipos de
valores, e todos eles recebem como primeiro parâmetro uma String que servirá como chave do
valor passado, seguindo a sintaxe putExtra(chave, valor).
Pág. 65 de 95

No exemplo do quadro 19, estamos passando um número double com uma chave denominada
valor e uma String com a chave nome.
QUADRO 19 – Código para passar valores à tela que será aberta

Intent intent = new Intent(this, NovaActivity.class);
intent.putExtra(“valor”, 200.5);
intent.putExtra(“nome”, “Anita”);
startActivity(intent);
Na Activity que será aberta, podemos obter estes valores no seu evento onCreate, como é
mostrado no quadro 20.
QUADRO 20 – Código para recuperar valores passados na nova tela aberta

@Override
setContentView(R.layout.activity _ nova);
Intent intent = getIntent();
double valor = intent.getExtras().getDouble(“valor”);
String nome = intent.getExtras().getString(“nome”);
É simples: primeiro, obtemos uma referência à Intent que abriu esta tela, com getIntent. Em
seguida, obtemos os parâmetros passados a ele com seu método getExtras() e extraímos dentro
deles os valores que queremos, usando um método getter adequado para os tipos de dados de cada
valor. Por exemplo, como “valor” foi passado como um número double, usamos getDouble; como
“nome” foi passado como String, usamos getString.
MÓDULO 5 – BANCO DE DADOS EM ANDROID

Os aplicativos que criamos até agora não possuem a capacidade de guardar dados entre as
suas execuções. Para que possamos manter dados em um aplicativo Android, temos de recorrer a
algum recurso que possibilite que estes fiquem gravados no dispositivo. A alternativa mais utilizada
é o banco de dados SQLite, existente em todo aparelho com o sistema operacional Android e que
pode gravar e obter dados rapidamente no próprio dispositivo – até mesmo no caso de um grande
Pág. 66 de 95
volume de dados. Neste módulo saberemos como utilizar o SQLite no nosso aplicativo Android para
salvar e posteriormente consultar dados.
AULA 8 – BANCO DE DADOS EM ANDROID
8.1. Banco de Dados SQLite

O SQLite é um sistema de gerenciamento de banco de dados compacto, escrito na forma de
uma biblioteca de funções em C. Com código-fonte aberto e distribuído em domínio público, pode
ser obtido gratuitamente no seu site oficial: http://www.sqlite.org.
Como o próprio nome dá a entender, o SQLite é pequeno: sua versão mais recente ocupa pouco
mais de 650 KB! Mas isso não quer dizer que ele seja pequeno na capacidade, já que pode lidar
com bancos de dados de até 140 Terabytes e que, segundo testes realizados, consegue realizar
cerca de 50.000 inclusões por segundo em um computador desktop padrão (de acordo com dados
disponíveis no site oficial).
Outra característica importante: para criar a estrutura e manipular os dados na tabela, são
usados comandos tipo-SQL, o que facilita bastante a adaptação e migração para o SQLite.
FIGURA 51 – Logotipo do SQLite
Fonte: https://sqlite.org/images/sqlite370_banner.gif
Por razões como as supracitadas, o SQLite é o banco de dados padrão não só dos aparelhos
com Android, mas também daqueles com iOS! Sim, o iPhone e o iPad também possuem o SQLite
instalado e usam o banco para armazenar boa parte dos dados dos seus aplicativos.
Apesar de a API do SQLite estar originalmente em C, a Google criou classes Java que abstraem
os principais comandos para manipulação do banco.
Pág. 67 de 95

Neste módulo, conheceremos as duas principais: SQLiteDatabase e SQLiteOpenHelper.
8.2. Criação do banco de dados

O primeiro passo para fazer com que seu aplicativo possa usar o SQLite é criar uma subclasse
de SQLiteOpenHelper. Esta classe existe para facilitar a abertura e, caso ainda não exista, criar o
banco de dados.
Basta criar uma classe Java básica herdando SQLiteOpenHelper e implementar o seu evento
onCreate, que será usado para criar a(s) tabela(s) do banco (somente quando ele ainda não tiver
sido criado).
No quadro 21 você pode ver um exemplo de classe para abrir e criar um banco de dados com
uma tabela para armazenar a lista de compras criada na seção 5.3.
Pág. 68 de 95

QUADRO 21 – Código para classe BancoListaOpenHelper

package com.example.professores.listadecomprassql;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class BancoListaOpenHelper extends SQLiteOpenHelper {
public BancoListaOpenHelper(Context contexto, String nome,
SQLiteDatabase.CursorFactory fabrica, int versao) {
super(contexto, nome, fabrica, versao);
@Override
public void onCreate(SQLiteDatabase db) {
String criarTabela = “CREATE TABLE produtos “ +
“( _ id INTEGER PRIMARY KEY AUTOINCREMENT, “ +
“nome TEXT);”;
db.execSQL(criarTabela);
db.execSQL(“INSERT INTO produtos (nome) “ +
“VALUES (‘Arroz’)”);
“VALUES (‘Feijão’)”);

“VALUES (‘Laranja’)”);
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
A nossa subclasse de SQLiteOpenHelper precisa possuir os três métodos existentes na listagem

do quadro 21: um construtor, o evento onCreate e o evento onUpdate. Este último só é usado quando
o banco precisar sofrer alguma atualização.
O onCreate é obrigatório, pois será executado quando o aplicativo tentar abrir um banco que
ainda não existe. Ou seja, é ele que faz a criação inicial da estrutura do banco a ser usado!
Pág. 69 de 95

No exemplo do quadro 21, executamos no banco de dados (por meio do objeto db da classe
SQLiteDatabase, recebido por onCreate) um comando SQL CREATE TABLE, para criar a estrutura
da tabela Produtos. Ela possui os seguintes campos:
• _id: o campo inteiro (INTEGER), chave primária (PRIMARY KEY), que será único para cada produto
e será gerado automaticamente (AUTOINCREMENT) como um número inteiro. Precisamos
usar este nome exato (_id) para facilitar a ligação da tabela com um ListView – falaremos
mais sobre isso depois.
• nome: um campo do tipo TEXT (equivalente à String ou VARCHAR em outros SGBDs) para
armazenar a descrição/nome do produto.
• quantidade: um campo inteiro (INTEGER) para guardar a quantidade a ser comprada do produto.
O comando é executado no banco por meio do método execSQL() do objeto db.
Em seguida, executamos mais três comandos SQL para inclusão (INSERT) de alguns produtos
de exemplo no banco, junto das suas respectivas quantidades.
SAIBA MAIS
Para saber mais sobre a sintaxe SQL e tipos de dados suportados pelo SQLite, acesse a
documentação oficial em http://www.sqlite.org/docs.html.
8.3. Criação da classe DAO para acesso aos dados

Como as operações comuns no banco de dados (inclusão, consulta, exclusão e alteração)
envolvem o uso de diversos métodos, e estes são sempre relativos a um determinado sistema, é
uma boa prática organizá-los em uma classe própria para a finalidade de manipulação dos dados
no banco.
Esta classe é comumente conhecida como classe DAO (Data Access Object), que é que uma
classe Java padrão que encapsula todos os procedimentos de manipulação dos dados, assim como
abertura e fechamento do banco.
Para utilizá-la no seu aplicativo, crie uma classe Java padrão e chame-a de Dao. Acrescente a
ela o código existente no quadro 22.
Pág. 70 de 95

QUADRO 22 – Código para classe Dao

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
public class Dao {
private static final String NOME _ DO _ BANCO = “ListaDeCompras.db”;
private SQLiteDatabase banco;
private BancoListaOpenHelper bancoOpenHelper;
public Dao(Context context) {
bancoOpenHelper = new BancoListaOpenHelper(context, NOME _ DO _ BANCO,
null, 1);
public void abrir() throws SQLException {
banco = bancoOpenHelper.getWritableDatabase();
public void fechar() {
if (banco != null)
banco.close();
}
public void inserirProduto(String nome) {
ContentValues novoProduto = new ContentValues();
novoProduto.put(“nome”, nome);
banco.insert(“produtos”, null, novoProduto);
public void alterarProduto(long id, String nome) {
ContentValues produtoAlterado = new ContentValues();
produtoAlterado.put(“nome”, nome);
Pág. 71 de 95

banco.update(“produtos”, produtoAlterado, “ _ id = “ + id, null);
public void removerProduto(long id) {
banco.delete(“produtos”, “ _ id = “ + id, null);
public Cursor obterTodosOsProdutos() {
return banco.query(“produtos”, null, null, null,
null, null, “nome”);
• Como na classe Dao realizaremos todo o acesso ao banco, precisamos ter dentro dela uma
instância de SQLiteDatabase e outra de BancoListaOpenHelper;
• O construtor desta classe recebe um Context como parâmetro. Ele chamará por sua vez o
construtor de BancoListaOpenHelper passando a ele: o contexto atual; uma String especificando
um nome para o arquivo de banco de dados; null no terceiro parâmetro, pois não usaremos
CursorFactory; e 1 no último parâmetro, sendo este o número de versão do banco. O objeto
instanciado ficará armazenado em bancoOpenHelper;
• O método abrir faz a obtenção do objeto SQLiteDatabase gravável que servirá de “ponte de
acesso” ao arquivo de banco de dados, por meio do método getWritableDatabase do openHelper;
assim, seu retorno deve ficar armazenado em um objeto SQLiteDatabase-banco;
• Já o método fechar realiza o fechamento de banco, caso este seja diferente de null (significando
que o mesmo foi aberto);
• O método inserirProduto é uma abstração para o método insert existente no objeto banco.
Passamos ao inserirProduto um nome de produto e uma quantidade, para serem inseridos
como um novo registro do banco. Um objeto da classe ContentValues chamado novoProduto
é então usado para fazer a correspondência entre os campos da tabela e os valores a serem
colocados neles, por meio do seu método put(campo, valor). Este objeto é então passado ao
método insert, junto do nome da tabela na qual o registro será incluído;
• A modificação de um produto na lista é feita com o método alterarProduto. Seu funcionamento
é muito parecido com inserirProduto, contudo, como estamos alterando os valores de um
produto existente, passamos ao alterarProduto o id do produto sendo modificado, junto dos
(possíveis) novos valores para nome e quantidade. Este id será usado para montar a cláusula
de condição de alteração (“_id = “ + id) no método update do objeto banco;
Pág. 72 de 95

• Para excluir um produto, usamos o método removerProduto, que recebe como parâmetro o id
do registro a ser excluído. Este id é então usado na condição de exclusão do método delete,
existente no objeto banco;
• Por fim, temos o método obterTodosOsProdutos. Ele retorna um objeto da classe Cursor do
Android, que é um ponteiro para um conjunto de registros.
Este cursor é criado por meio de uma consulta gerada com o método query, que faz um SELECT
no banco de acordo com os parâmetros que recebe, sendo eles, em ordem sequencial:
◊ O nome da tabela a ser consultada;
◊ O nome dos campos a serem retornados (null retorna todos);
◊ A condição WHERE de consulta; null indica que não há condição;
◊ Os valores para as condições de WHERE;
◊ Cláusula de agrupamento (GROUP BY em SQL);
◊ Condição de agrupamento (HAVING em SQL);
◊ Cláusula de ordenação (ORDER BY em SQL).
Agora, podemos voltar à Activity. Nela, utilizaremos estes métodos da classe Dao para fazer a
interação com o banco de dados.
Para poder mostrar os dados da tabela no ListView, usaremos uma nova classe: SimpleCursor
Adapter, o adaptador de listas usando cursores como fonte de dados.
8.4. Incluindo, excluindo e exibindo registros

A utilização da classe Dao dentro do código da Activity é bastante simples. Dê uma olhada no
código do quadro 23.
Pág. 73 de 95

QUADRO 23 – Código para MainActivity utilizando classe Dao

import android.app.ListActivity;
import android.support.v4.widget.SimpleCursorAdapter;
import android.widget.EditText;
import android.widget.ListView;
public class MainActivity extends ListActivity {
EditText edtProduto;
Dao dao;
@Override
dao = new Dao(this);
dao.abrir();
SimpleCursorAdapter adaptador = new SimpleCursorAdapter(
this,
android.R.layout.simple _ list _ item _ 2,
dao.obterTodosOsProdutos(),
new String[]{“ _ id”, “nome”},
new int[]{android.R.id.text1, android.R.id.text2},
0);
setListAdapter(adaptador);
edtProduto = (EditText)findViewById(R.id.edtProduto);
public void onClickAdicionar(View v) {
String produto = edtProduto.getText().toString();
dao.inserirProduto(produto);
Pág. 74 de 95

SimpleCursorAdapter adaptador = (SimpleCursorAdapter)getListAdapter();
adaptador.swapCursor(dao.obterTodosOsProdutos());
edtProduto.setText(“”);
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
dao.removerProduto(id);
SimpleCursorAdapter adaptador = (SimpleCursorAdapter)getListAdapter();
adaptador.swapCursor(dao.obterTodosOsProdutos());
@Override
protected void onDestroy() {
dao.fechar();
super.onDestroy();
• Comparando com a versão anterior, usando ArrayList para armazenar os dados, temos como
primeira mudança a declaração da variável global dao, objeto da classe Dao. Usaremos este
objeto para acessar os métodos da classe Dao dentro dos eventos da Activity;
• No onCreate, passamos a usar agora o SimpleCursorAdapter para conectar a lista aos dados.
Ele recebe como parâmetros:
◊ Uma referência ao contexto (this);
◊ O nome de um layout para cada linha da lista – neste caso, usamos o layout simple_list_
item_2 do Android, que exibe duas linhas de texto (a de cima com fonte grande e a de baixo
com fonte pequena);
◊ O cursor que trará os dados do banco – isso será feito pelo método obterTodosOsProdutos
da classe Dao;
◊ Um vetor de Strings com os nomes dos campos trazidos pelo cursor que serão exibidos
na lista;
Pág. 75 de 95

◊ Um vetor de ints com os ids dos widgets, no qual os campos do parâmetro anterior serão
colocados, respectivamente; android.R.id.text1 indica a linha grande de cima e android.R.id.
text2 indica a linha de baixo com fonte pequena;
◊ Valor 0, pois não usaremos os recursos ativados por esta flag.
• No onClickAdicionar, usamos agora o método inserirProduto para adicioná-lo ao banco. Em

seguida, o método swapCursor é usado para atualizar a lista;
• Quando o usuário tocar em um item da lista, onListItemClick chamará removerProduto na
classe Dao, fazendo a exclusão do item por meio do seu id – veja que o id é um dos parâmetros
recebidos pelo evento onListItemClick. Também usamos swapCursor para fazer um refresh
na lista;
• Nesta Activity, sobrescrevemos o evento onDestroy, que será executado quando a Activity for
destruída, para que possamos fechar o banco de dados.
MÓDULO 6 – VISÃO GERAL DE RECURSOS DO SDK

O Android SDK possui um conjunto enorme de APIs para que o desenvolvedor consiga utilizar
os recursos existentes nos smartphones e tablets equipados com o sistema operacional Android.
Vamos, neste módulo, conhecer um pouco sobre estas outras APIs e como você pode utilizá-las nos
seus aplicativos. Falaremos sobre uso de GPS e mapas do Google Maps, como consumir dados de
um Web Service e como acessar a câmera do aparelho para acesso a fotos e vídeos, assim como
a API para reprodução de arquivos de áudio.
AULA 9 – GPS, WEBSERVICES, CÂMERA E ÁUDIO/VÍDEO
9.1. Acessando longitude, latitude e altitude por meio do GPS do aparelho

Os smartphones modernos vêm equipados com um receptor de GPS, capaz de dar ao aparelho
seu posicionamento global em latitude e longitude.
Aliando os dados do GPS a um serviço de mapas, como o Google Maps, o usuário poder ter no
seu celular um dispositivo de localização e de planejamento de rotas e itinerários imprescindível.
No Android, os dados de localização são fornecidos pelos Location Services. O primeiro passo
para utilizá-los em um aplicativo é solicitar sua utilização quando o usuário iniciar o programa. Isso
Pág. 76 de 95

é feito adicionando a linha do quadro 24 ao arquivo AndroidManifest.xml (coloque-a logo antes da

tag <application>).
QUADRO 24 – Linha para utilização do Location Service no AndroidManifest.xml

<uses-permission android:name=”android.permission.ACCESS _ COARSE _ LOCATION”/>
Outro requisito importante: Nas novas versões do Android, o acesso aos serviços de localização
é feito pelo Google Play Services. Dessa forma, para que os recursos de localização funcionem
corretamente, é preciso que o aparelho do usuário tenha o Google Play instalado e atualizado.
Mais um requisito: para desenvolver usando o Google Play Services, é preciso instalar o pacote
necessário usando o SDK Manager. Para abri-lo, clique no botão da barra de ferramentas do Android
Studio indicado na figura 52.
FIGURA 52 – Abrindo o SDK Manager pelo Android Studio
Na janela que será mostrada, clique na aba SDK Tools e, logo abaixo, marque a caixa relativa ao
Google Play Services (figura 53). Clique então em OK para que ele seja baixado e instalado.
Pág. 77 de 95

FIGURA 53 – Instalando o Google Play Services para desenvolvimento
Depois de clicar em OK, será feito o download e instalação da biblioteca do Google Play Services.
Pode ser que seja solicitada a confirmação do download ou da licença de uso da biblioteca, bastando
aceitá-la para iniciar a instalação.
Abra o arquivo build.gradle (Module:app), localizado dentro da lista de componentes do projeto

(à esquerda no Android Studio), dentro de Gradle Scripts, e acrescente a linha em negrito no quadro
25 dentro do elemento dependencies do arquivo:
QUADRO 25 – Linha para utilização do Google Play Services no build.gradle

dependencies {
....
compile ‘com.google.android.gms:play-services:9.4.0’
Cumpridos todos estes requisitos, ainda é preciso que sejam implementados alguns eventos
na Activity, em que será feito o acesso aos serviços de localização. Veja o exemplo no quadro 26.
Pág. 78 de 95

QUADRO 26 – Activity contendo métodos para utilização dos Location Services

package com.example.professores.testelocation;
import android.content.pm.PackageManager;
import android.location.Location;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.widget.TextView;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.LocationServices;
public class MainActivity extends AppCompatActivity implements
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
GoogleApiClient googleApiClient;
@Override
if (googleApiClient == null) {
googleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
Pág. 79 de 95

protected void onStart() {
googleApiClient.connect();
super.onStart();
protected void onStop() {
googleApiClient.disconnect();
super.onStop();
public void onClick(View v) {
if (ActivityCompat.checkSelfPermission(this,
android.Manifest.permission.ACCESS _ COARSE _ LOCATION)
!= PackageManager.PERMISSION _ GRANTED) {
ActivityCompat.requestPermissions(this,
new String[] { android.Manifest.permission.ACCESS _ COARSE _ LOCATION},
0);
return;
Location localizacaoAtual = LocationServices.FusedLocationApi.getLastLocation(goo
gleApiClient);
if (localizacaoAtual != null) {
double latitude = localizacaoAtual.getLatitude();
double longitude = localizacaoAtual.getLongitude();
double altitude = localizacaoAtual.getAltitude();
TextView textView = (TextView) findViewById(R.id.textView);
String texto = “LATITUDE: “ + latitude + “\n” +
“LONGITUDE: “ + longitude + “\n” +
“ALTITUDE: “ + altitude;
Pág. 80 de 95

textView.setText(texto);
@Override
public void onConnected(@Nullable Bundle bundle) {
Toast.makeText(this, “CONECTADO ao Google Play Services”,
Toast.LENGTH _ SHORT).show();
@Override
public void onConnectionSuspended(int i) {
Toast.makeText(this, “Conexão ao Google Play Services SUSPENSA.”,
@Override
public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
Toast.makeText(this, “FALHA NA CONEXÃO ao Google Play Services”,
• Para poder usar os Location Services, a classe, logo na sua declaração, deve dizer que implementa
(usando a palavra chave implements) as interfaces: GoogleApiClient.ConnectionCallbacks
e GoogleApiClient.OnConnectionFailedListener
• Declaramos globalmente na classe um objeto da classe GoogleApiClient, que servirá como
nosso cliente de acesso ao Google Play Services;
• No evento onCreate da Activity, instanciamos o objeto googleApiClient;
• No evento onStart da Activity chamamos o método connect do objeto googleApiClient, que
fará a conexão ao serviço; de forma equivalente, chamamos o método disconnect no evento
onStop da Activity;
• Quando o usuário clicar no botão no qual está designado o método onClick, primeiramente
solicitaremos a permissão do usuário para acessar sua localização, se isso ainda tiver sido
feito (ActivityCompat.checkSelfPermission); em seguida, obteremos a última localização válida
usando o método getLastLocation do LocationServices, cujo retorno é armazenado em um
objeto da classe Location; desse objeto, podemos obter a latitude, longitude e altitude atual,
que exibimos ao usuário em um TextView;
Pág. 81 de 95

• Os métodos onConnectionFailed, onConnected e onConnectionSuspended devem ser

obrigatoriamente implementados para tratar, respectivamente, de falha na conexão, conexão
bem-sucedida e desconexão aos serviços de localização; sua existência na Activity é obrigatória,
mesmo que fiquem vazios.
SAIBA MAIS
EXIBINDO MAPAS
Para exibir a localização do usuário em um mapa do Google Maps, é preciso antes se registrar no
serviço, obter uma chave de acesso e depois adaptar seu aplicativo à API do Google Maps. Mais
detalhes em: <http://developer.android.com/google/play-services/maps.html>
9.2. Consumindo Web Services RESTful

A implementação da linguagem Java existente no Android traz duas classes que podem ser
utilizadas para realizar conexões a Web Services REST. Estas classes, pertencentes ao pacote java.
net, são as seguintes:
• URL: usada para representar o endereço a um recurso na Web, ou seja, um site ou Web Service;
• HttpUrlConnection: permite a realização de uma conexão a uma URL por meio do protocolo
HTTP.
Além delas, utilizaremos também uma classe do pacote org.json para poder extrair os dados
recebidos dos Web Services. O formato JSON é oriundo do JavaScript, e é utilizado para obtermos
uma representação em modo texto de objetos, com os dados no formato “chave” : “valor”. Um objeto
JSON é um conjunto de chaves e valores delimitados por { e }.
JSONObject: armazena os dados recebidos em formato texto como um objeto. Os

valores guardados nas chaves podem então ser retornados com métodos getters,
existentes para os tipos de dados comuns.
Para saber como usar estas classes para se conectar a um Web Service REST, veja o código
do quadro 27, com comentários explicando seu funcionamento.
Pág. 82 de 95

QUADRO 27 – Código de exemplo para conexão a um Web Service e recepção de dados em JSON
package net.querino.dicionario;
import android.os.AsyncTask;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
// Variável global da classe que vai armazenar a resposta recebida
// do Web Service, em formato JSON.
String respostaJSON;
@Override
public void onClick(View view) {
// Inicia a Thread que vai conectar ao Web Service
// e obter os dados JSON
new ConsultaWebService().execute(“”);
public class ConsultaWebService extends AsyncTask<String, Void, Boolean> {
HttpURLConnection urlConnection;
Pág. 83 de 95

@Override
protected Boolean doInBackground(String... args) {
// Este objeto StringBuilder será usada para armazenar o texto
// JSON que estiver sendo mandado pelo Web Service.
StringBuilder resultado = new StringBuilder();
try {
// MUITO IMPORTANTE: substitua o endereço a seguir pelo do Web
// Service que você vai usar, incluindo parâmetros e valores
URL url = new URL(“http://” +
“endereco _ para _ seu _ webservice/” +
“parametro=valor”
);
// Faz a conexão ao serviço
urlConnection = (HttpURLConnection)url.openConnection();
InputStream in = new
BufferedInputStream(urlConnection.getInputStream());
BufferedReader reader = new
BufferedReader(new InputStreamReader(in));
String linha;
// O laço a seguir vai lendo, linha a linha, a
// resposta do Web Service e guardando em builder.
while ((linha = reader.readLine()) != null) {
resultado.append(linha);
} catch (Exception e) {
// HOUVE ALGUM ERRO! }
// AVISE O USUÁRIO COM UM TOAST, PELO MENOS!!!
Pág. 84 de 95

e.printStackTrace();
finally {
// Ao encerrar a leitura dos dados em JSON, fecha a conexão
urlConnection.disconnect();
respostaJSON = resultado.toString();
return true;
@Override
protected void onPostExecute(Boolean result) {
JSONObject objetoJSON;
try {
objetoJSON = new JSONObject(respostaJSON);
// Aqui é o local onde você deverá usar o objetoJSON para
// conseguir os dados que precisa.
// Por exemplo, se o objeto tiver um valor string em uma
// chave denominada “texto”, você a obterá com:
// String texto = objetoJSON.getString(“texto”);
// Se tiver um valor double com um chave “saldo”:
// double saldo = objetoJSON.getDouble(“saldo”);
} catch (JSONException e) {
e.printStackTrace();
9.3. Utilizando a câmera para fotos e vídeo

O acesso à câmera do aparelho é realizado por uma Intent. Antes de usá-la, é preciso solicitar
a permissão de acesso à câmera incluindo a linha do quadro 28 ao AndroidManifest.xml.
Pág. 85 de 95

QUADRO 28 – Linha para utilização da câmera no AndroidManifest.xml

<uses-feature android:name=”android.hardware.camera” android:required=”true” />
Tirar e salvar a foto em um aparelho Android é um processo que envolve o uso de várias classes.
No código do quadro 29, temos uma Activity com um evento de clique de botão que abre a câmera
e salva a foto obtida no sistema de arquivos do Android.
QUADRO 29 – Código completo de uma Activity para tirar e salvar uma foto
package com.example.professores.cameraaudio;
import android.content.Intent;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
String caminhoParaFoto;
private File criarArquivoDaFoto() throws IOException {
String timeStamp = new SimpleDateFormat(“yyyyMMdd _ HHmmss”).format(new Date());
String nomeDoArquivoDaImagem = “JPEG _ ” + timeStamp + “ _ ”;
File pastaDeGravacao = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY _ PICTURES);
File imagem = File.createTempFile(nomeDoArquivoDaImagem, “.jpg”,
pastaDeGravacao);
Pág. 86 de 95

caminhoParaFoto = “file:” + imagem.getAbsolutePath();
return imagem;
@Override
public void onClick(View v) {
Intent intentParaTirarFoto = new Intent(MediaStore.ACTION _ IMAGE _ CAPTURE);
if (intentParaTirarFoto.resolveActivity(getPackageManager()) != null) {
File arquivo = null;
try {
arquivo = criarArquivoDaFoto();
} catch (IOException ex) {
Toast.makeText(this, “Falha ao gravar a foto.”, Toast.LENGTH _ LONG).show();
if (arquivo != null) {
intentParaTirarFoto.putExtra(MediaStore.EXTRA _ OUTPUT,
Uri.fromFile(arquivo));
startActivityForResult(intentParaTirarFoto, 1);
O processo de gravar um vídeo e visualizá-lo é bastante semelhante. A permissão adicionada

ao AndroidManifest.xml anteriormente (veja o quadro 29) também dá acesso à gravação de vídeo.
Veja um exemplo de como gravar e reproduzir um vídeo no código exibido no quadro 30.
Pág. 87 de 95

ACONTECEU
Em 2013, a NASA, agência espacial americana, lançou três satélites feitos com smarphones Android.
Os satélites possuíam o tamanho de uma caixa de 25 cm e custavam entre 3.500 e 7.000 dólares, o
que é um valor incrivelmente barato perto de um satélite convencional, que pode custar milhões!
Os satélites enviaram fotos e dados direto do espaço:
<http://exame.abril.com.br/ciencia/nasa-coloca-em-orbita-satelites-feitos-com-smartphones/>
QUADRO 30 – Código completo de uma Activity para gravar e exibir um vídeo

package com.example.professores.cameraaudio;
import android.content.Intent;
import android.net.Uri;
import android.provider.MediaStore;
import android.widget.VideoView;
public class VideoActivity extends AppCompatActivity {
VideoView videoView;
@Override
setContentView(R.layout.activity _ video);
videoView = (VideoView)findViewById(R.id.videoView);
}
public void onClickGravarVideo(View v) {
Intent takeVideoIntent =
new Intent(MediaStore.ACTION _ VIDEO _ CAPTURE);
Pág. 88 de 95

if (takeVideoIntent.resolveActivity(getPackageManager()) != null) {
startActivityForResult(takeVideoIntent, 1);
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 1 && resultCode == RESULT _ OK) {
Uri uriDoVideo = data.getData();
videoView.setVideoURI(uriDoVideo);
• Começamos declarando um objeto global denominado videoView, da classe VideoView. Ele

existe na nossa interface (quadro 31) e será a janela de exibição do vídeo;
• Quando o usuário tocar no botão, ativando o método onClickGravarVideo, usaremos uma Intent
para abrir a câmera, indicando que o usuário fará a gravação de um vídeo;
• O evento onActivityResult será executado quando o usuário terminar a gravação do vídeo e
fechar a câmera. Nele, colocamos o vídeo salvo para ser exibido no videoView.
Pág. 89 de 95

QUADRO 31 – Arquivo /res/layout/activity_vide.xml com a interface da VideoActivity

tools:context=”com.example.professores.cameraaudio.VideoActivity”>
<Button
android:text=”Gravar Vídeo”
android:id=”@+id/button2”
android:onClick=”onClickGravarVideo” />
<VideoView
android:id=”@+id/videoView”
android:layout _ below=”@+id/button2”
android:layout _ marginTop=”113dp” />
</RelativeLayout>
Pág. 90 de 95

9.4. Reproduzindo arquivos de áudio

Para reproduzir um arquivo de áudio no Android usamos a classe MediaPlayer. Trata-se de uma
classe bastante simples de usar, ao mesmo tempo em que possui diversos recursos.
Com a MediaPlayer, é possível reproduzir arquivos de áudio nos formatos suportados pelo
Android, que são: MP3, MP4, M4A, WAV, AAC, MIDI, FLAC e Ogg Vorbis (.ogg).
Você deverá acrescentar seus arquivos de áudio em uma pasta denominada raw, dentro da
pasta res, no seu projeto. Esta pasta não existe inicialmente; para criá-la, clique com o botão direito
do mouse sobre a pasta res do seu projeto e selecione New... > Folder. Forneça o nome raw para a
pasta e clique em Finish.
Criada a pasta, arraste seus arquivos de áudio para ela, lembrando de, ao soltar, selecionar a
opção Copy Files para que uma cópia do arquivo seja colocada no projeto.
Agora é simples: é só acrescentar as linhas de código no quadro 32 a algum evento da sua

Activity, substituindo arquivo pelo nome do seu arquivo para que o áudio seja reproduzido:
QUADRO 32 – Código para reproduzir um arquivo de áudio

public void onClickReproduzirAudio(View v) {
MediaPlayer mediaPlayer = MediaPlayer.create(this, R.raw.arquivo);
mediaPlayer.start();
}
CONSIDERAÇÕES FINAIS
Então é isso! Chegamos ao final de mais uma etapa deste curso. Parabéns!
Desta vez, conhecemos o empolgante universo do desenvolvimento de apps, os pequenos, mas

poderosos aplicativos criados para smartphones e tablets. Você aprendeu a desenvolver aplicações
para o sistema operacional mais popular do mercado, o Android, que, além de ser líder absoluto neste
segmento, apresenta outra grande vantagem para nós: os programas para ele são criados em Java!
Aproveitando boa parte do conhecimento em Java que você já havia adquirido, pudemos agora
transportá-los para uma nova plataforma, agregando as novidades e mudanças existentes em um
app Android.
Pág. 91 de 95

Como você pode perceber, um desenvolvedor Java experiente pode começar a criar aplicativos
Android em pouco tempo. Isso abre de imediato uma grande gama de oportunidades de desenvolvimento
de novos aplicativos, assim como a migração de outros já existentes para essa nova plataforma.
O mercado de aplicativos móveis está literalmente “pegando fogo” neste momento – por isso,
arregace as mangas, junte os conceitos aprendidos nesta disciplina com os que você já possui, “dê
asas” à sua imaginação e comece já a criar e publicar seus próprios programas.
Desejo a todos boa sorte e muito sucesso nos seus projetos “móveis”!
Prof. Querino
GLOSSÁRIO
Startups
Uma empresa de tecnologia que acaba de ser aberta, ainda em fase de desenvolvimento.
Disponível em: <https://pt.wikipedia.org/wiki/Startup>. Acesso em: 24 jan. 2017.
Formato Binário
Sistema utilizado por computadores, onde as informações são traduzidas em 0 e 1.
Disponível em: <https://pt.wikipedia.org/wiki/Sistema_de_numera%C3%A7%C3%A3o_

bin%C3%A1rio>. Acesso em: 24 jan. 2017.
Metadados
São os dados sobre outros dados. É a informação interpretada pelo computador que relaciona
um tipo de dado a outra informação, qualidade ou característica. Disponível em: <https://pt.wikipedia.
org/wiki/Metadados>. Acesso em: 24 jan. 2017.
Parser
Parser é a análise sintática em computação, o processo de analisar uma sequência de entrada

para determinar sua estrutura, transformando, por exemplo, um texto em uma estrutura de dados
Pág. 92 de 95

para processsamento. Disponível em: <https://pt.wikipedia.org/wiki/An%C3%A1lise_sint%C3%A1tica_

(computa%C3%A7%C3%A3o)>. Acesso em: 24 jan. 2017.
Emulador
É um software que reproduz um determiando ambiente para executar outros softwares, simulando
o comportamento de uma configuração de hardware ou sistemas específicos, permitindo que um
software criado para uma platforma específica funcione em outra diferente. Disponível em: <https://
pt.wikipedia.org/wiki/Emulador>. Acesso em: 24 jan. 2017.
Domínio
É um nome usado para localizar e identificar conjuntos de computadores na Internet. O endereço

de um site na Internet (www.exemplo.com.br) é um domínio, por exemplo. Ao acessar um site, o
nome do domínio é convertido numa sequência de números que é o endereço IP, utilizado pelo
computador para localizar a página. Disponível em: <https://pt.wikipedia.org/wiki/Dom%C3%ADnio>.
Acesso em: 24 jan. 2017.
Widget
Um widget é um componente da interface gráfica de um sistema operacional, como botões,

ícones, apps interativos etc. Disponível em: <https://pt.wikipedia.org/wiki/Widget>. Acesso em: 24
jan. 2017.
Interface
Interface é o conjunto de meios para adaptar dois sistemas com o objetivo de alcançar um
resultado que possui características comuns aos dois sistemas. São as ferramentas utilizadas para
uso e movimentação de qualquer sistema de informação. Disponível em: <https://pt.wikipedia.org/
wiki/Interface>. Acesso em: 24 jan. 2017.
Variável
Em programação, variável é um objeto que tem a hablidade de guardar e representar um valor ou

expressão. Disponível em: <https://pt.wikipedia.org/wiki/Vari%C3%A1vel_(programa%C3%A7%C3%A3o)>.
Acesso em: 24 jan. 2017.
Pág. 93 de 95

REFERÊNCIAS BIBLIOGRÁFICAS
ANDROID Tutorials. Vogella, 21 nov. 2012. Disponível em: <http://www.vogella.com/tutorials/android.

html>. Acesso em: 23 jan. 2017.
ARNOLD, K.; GOSLING, J.; HOLMES, D. A Linguagem de Programação Java. Porto Alegre: Bookman,
2007.
BLOCH, J. Effective Java. Upper Saddle River: Addison-Wesley, 2012.
DARWIN, I. Android cookbook. Sebastopol: O’Reilly Media, Inc., 2012.
DEITEL, H. et al. Android for Programmers: An App-Driven Approach. Upper Saddle River: Pearson
Education, 2012.
DEVELOPER ANDROID. These are the Android APIs. 2014. Disponível em: <http://developer.android.
com/reference/packages.html>. Acesso em: 20 ago. 2014.
FAWCETT, J.; QUIN, L.R.E. Beginning XML: 5th Edition. Indianapolis: John Wiley & Sons, Inc, 2012.
GOSLING, J.; MCGILTON, H. The Java Language Environment. 1997. Disponível em: <http://www.
oracle.com/technetwork/java/intro-141325.html>. Acesso em: 20 ago. 2014.
JAVA 7 API. Java™ Platform, Standard Edition 7 API Specification. 2014. Disponível em: <http://docs.
oracle.com/javase/7/docs/api/>. Acesso em: 20 set. 2014.
JAVA Tutorial. Oracle, 19 jul. 2014. Disponível em: <http://docs.oracle.com/javase/tutorial/>. Acesso

em: 23 jan. 2017.
MEIER, R. Professional Android 4 Application Development. Indianapolis: John Wiley & Sons, Inc.,
2012.
PHILLIPS, B.; HARDY, B. Android Programming: The Big Nerd Ranch Guide. Indianapolis: Pearson
Education, 2013.
PRESSMAN, R. S. Engenharia de Software. São Paulo: McGraw-Hill, 2010.
Pág. 94 de 95

QUERINO FILHO, L. C. Desenvolvendo seu Primeiro Aplicativo Android. São Paulo: Novatec, 2013.
Sites importantes:
http://developer.android.com/index.html
http://www.eclipse.org
http://www.sqlite.org
Pág. 95 de 95

Apostila Android

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apostila Android

Загружено:

Авторское право:

Доступные форматы

Profº.

Luiz Carlos Querino Filho

Módulo 1 – Introdução ao Android e XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Aula 1 – Fundamentos do Sistema Operacional Android . . . . . . . . . . . . . . . . . . . . . . . . 6

Aula 2 – Introdução ao XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Módulo 2 – Ambiente de Desenvolvimento Android . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Aula 3 – Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Módulo 3 – View e Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Aula 4 – Widgets Básicos e Definição de View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Aula 5 – Aprofundando o conhecimento sobre a classe Activity . . . . . . . . . . . . . . . . . 45

Módulo 4 – Layouts e Intents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Aula 6 – Organizando a tela com gerenciadores de layout . . . . . . . . . . . . . . . . . . . . . 54

Módulo 5 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Aula 8 – Banco de Dados em Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Módulo 6 – Visão Geral de Recursos do SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Aula 9 – GPS, WebServices, Câmera e Áudio/Vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Certamente você já conhece os fundamentos de programação na linguagem Java, que abrange

O sistema operacional Android é desenvolvido primariamente pela Google, a gigante mundial

Luiz Carlos Querino Filho

MÓDULO 1 – INTRODUÇÃO AO ANDROID E XML

AULA 1 – FUNDAMENTOS DO SISTEMA OPERACIONAL ANDROID

1.1. Características do Sistema Operacional Android

FIGURA 2 – Tela do Android 6.0.1 Marshmallow

Fonte: < https://pt.wikipedia.org/wiki/Android_Marshmallow#/media/File:Android_6.0-en.png >

FIGURA 3 – Codinomes das versões do Android

1.2. Os Dispositivos Móveis Android

• A diversidade de versões do Android: é possível encontrar hoje no mercado celulares com

FIGURA 4 – Estatística sobre as versões do Android em uso, em Agosto de 2016

O que isso significa para nós, desenvolvedores?

E QUANTO AO JAVA ME (ANTIGO J2ME)?

Mas não confunda os dois!

O Android é um sistema operacional completo, desenvolvido por um grupo de empresas lideradas

Fonte: Querino Filho (2013)

AULA 2 – INTRODUÇÃO AO XML

2.1. Conceitos básicos de XML (eXtensible Markup Language)

FIGURA 6 – World Wide Web Consortium

2.2. Manipulação de documentos XML

QUADRO 1 – Arquivo Texto

QUADRO 2 – Arquivo Texto Modificado

QUADRO 3 – Arquivo XML

<produto descricao=”Detergente”quantidade=”5” />

<produto descricao=”Farinha de Trigo”quantidade=”2” />

<produto descricao=”Sabão em Pó” quantidade=”4” />

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

2.3. APIs: DOM, SAX e TrAX

Para podermos usar os dados contidos em um arquivo XML em um programa, precisamos de

MÓDULO 2 – AMBIENTE DE DESENVOLVIMENTO ANDROID

AULA 3 – ANDROID STUDIO

3.1. Baixando e instalando o Android Studio

FIGURA 9 – Link para download do Android Studio

FIGURA 11 – Concordando com os termos e iniciando o download

Finalmente começará o download. No caso de instalação em sistema operacional Windows,

FIGURA 12 – Iniciando a instalação do Android Studio no Windows

O procedimento de instalação é simples e segue o padrão da maioria dos instaladores de

FIGURA 13 – Finalizando o processo de instalação do Android Studio

3.2. Primeiro contato com o Android Studio

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

FIGURA 15 – Fazendo as configurações finais do Android Studio

Fonte: Android Studio