Dispositivos Móveis

Programação para
Dispositivos Móveis
Gilson de Oliveira
Curso Técnico em Desenvolvimento de Sistemas

Educação a Distância
2018
2018
EXPEDIENTE
Professor Autor
Gilson de Oliveira
Design Educacional
Deyvid Souza Nascimento
Renata Marques de Otero
Revisão de Língua Portuguesa

Letícia Garcia
Diagramação
Jailson Miranda
Coordenação
Anderson Elias
Coordenação Executiva
George Bento Catunda
Terezinha Mônica Sinício Beltrão
Coordenação Geral
Paulo Fernando de Vasconcelos Dutra
Conteúdo produzido para os Cursos Técnicos da Secretaria Executiva de Educação

Profissional de Pernambuco, em convênio com o Ministério da Educação
(Rede e-Tec Brasil).
Janeiro, 2017
Dados Internacionais de Catalogação na Publicação (CIP) de acordo com ISDB
O48p
Oliveira, Gilson de.
Programação para Dispositivos Móveis: Curso Técnico em Desenvolvimento de Sistemas:
Educação a distância / Gilson de Oliveira. – Recife: Secretaria Executiva de Educação
Profissional de Pernambuco, 2018.
91 p.: il.
Inclui referências bibliográficas.

Material produzido em dezembro de 2016 através de convênio com o Ministério da
Educação (Rede e-Tec Brasil) e a Secretaria de Educação de Pernambuco.
1. Engenharia de Software. 2. Dispositivos Móveis. I. Oliveira, Gilson de. II. Título.
CDU – 02:141:005.6
Elaborado por Hugo Carlos Cavalcanti | CRB-4 2129
Índice para catálogo sistemático:
1.Engenharia de software
Sumário
Introdução .............................................................................................................................................. 6
1.Competência 01 | Apresentando a Classe Activity, Ciclo de Vida e Tipos de Activity ........................ 8
1.1 Activity........................................................................................................................................................ 8
1.2 Ciclo de vida de uma Activity ..................................................................................................................... 9
1.3 Navegação entre activities ....................................................................................................................... 14
1.3.1 Navegação simples de uma activity para outra .................................................................................... 14
1.3.2 Navegação entre telas com passagem de parâmetros ......................................................................... 16
1.4 ListActivity – uma activity diferente......................................................................................................... 18
2.Competência 02 | Intent ................................................................................................................... 22
2.1 Abrindo o browser e acessando um site específico ................................................................................. 22
2.2 Fazendo uma ligação para um número de telefone ................................................................................ 25
2.3 Solicitando ao google maps que exiba um local específico do mapa ...................................................... 28
2.4 Acessando contatos da agenda ................................................................................................................ 29
2.5 Retornando resultados de uma activity para outra através do método startActivityForResult ............. 30
2.6 Intent – Resumo ....................................................................................................................................... 33
3.Competência 03 | Conceitos de Interface Gráfica ............................................................................ 34
3.1 A classe View ............................................................................................................................................ 34
3.2 ViewGroup e gerenciadores de layout ..................................................................................................... 34
3.3 FrameLayout ............................................................................................................................................ 35
3.4 O famoso LinearLayout ............................................................................................................................ 39
3.5 RelativeLayout .......................................................................................................................................... 41
3.6 AbsoluteLayout (deprecated ou depreciado) .......................................................................................... 45
3.7 Resumo..................................................................................................................................................... 47
4.Competência 04 | Conhecendo os Conceitos de Interface Gráfica .................................................. 49
4.1 Especificando texto, cores e imagens da aplicação ................................................................................. 49

4.2 Arquivo com as mensagens da aplicação ................................................................................................. 50
4.3 Arquivo com as cores da aplicação .......................................................................................................... 51
4.4 Criando estilos .......................................................................................................................................... 52
4.5 Usando temas do Android ....................................................................................................................... 53
4.6 Definindo as dimensões dos componentes de layout ............................................................................. 55
4.7 Resumo..................................................................................................................................................... 56
5.Competência 05 | A Classe View Elementos Básicos ........................................................................ 58
5.1 TextView ................................................................................................................................................... 59
5.2 EditText .................................................................................................................................................... 61
5.3 Button e ImageButton .............................................................................................................................. 62
5.4 CheckBox .................................................................................................................................................. 65
5.5 RadioButton ............................................................................................................................................. 66
5.6 Spinner ..................................................................................................................................................... 68
5.7 ProgressDialog.......................................................................................................................................... 71
5.8 Toast ......................................................................................................................................................... 72
5.9 Resumo..................................................................................................................................................... 73
6.Competência 06 | Banco de Dados, SharedPreferences e APIs Importantes .................................. 74
6.1 Banco de dados ........................................................................................................................................ 74
6.2 SQLite ....................................................................................................................................................... 74
6.3 Preferências do usuário ........................................................................................................................... 75
6.4 API de Mapas ........................................................................................................................................... 77
6.5 GPS ........................................................................................................................................................... 77
6.6 Resumo..................................................................................................................................................... 78
7.Competência 07 | Publicando Aplicação na Google Play ................................................................. 79
7.1 Versionamento da sua app ...................................................................................................................... 79
7.2 Compatibilidade para instalação da aplicação ......................................................................................... 81
7.3 Assinando a aplicação com um certificado digital ................................................................................... 82

7.4 Assinando a aplicação para publicá-la no Google Play ............................................................................ 85
7.5 Publicando a sua aplicação na Google Play ............................................................................................. 86
Conclusão ............................................................................................................................................. 89
Referências ........................................................................................................................................... 90
Minicurrículo do Professor ................................................................................................................... 91
Gilson de Oliveira ................................................................................................................................. 91

Introdução
Neste caderno vamos aprender mais sobre o sistema operacional Android, suas
principais classes, características e comportamentos. A plataforma Android foi escolhida neste curso
por ser bastante difundida, madura, robusta e acessível, tanto para desenvolver quanto para um
usuário que deseja adquirir um equipamento que pode ser um tablet ou smartphone. Para iniciar o
desenvolvimento, não existem muitas restrições, não é preciso de um equipamento específico,
licença ou certificado de desenvolvimento, basta ter um computador (atendendo os requisitos
mínimos de processamento especificados pela ferramenta de desenvolvimento que você deseja
utilizar), fazer o download gratuito de uma IDE (Integrated Development Environment, que significa
ambiente de desenvolvimento integrado e se refere a ferramentas de desenvolvimento como
Eclipse ou Android Studio, por exemplo) e instalar o SDK (Software Development Kit) Android.
Dentre as três principais plataformas de desenvolvimento móvel, o Android é uma das
mais acessíveis no que diz respeito à aquisição de um exemplar. Existem smartphones de todos os
preços, os mais baratos custam em torno de 250,00 reais e os mais caros podem custar até milhares
de reais, por exemplo, os modelos top de linha da Samsung podem custar cerca de R$ 6.000. Tendo
um aparelho é possível você instalar e testar o seu aplicativo no próprio dispositivo e observar o seu
comportamento e layout, isso é bastante interessante, mas caso você não possua um smartphone,
você pode fazer uso do emulador que simula a utilização de um dispositivo no seu próprio
computador.
O Android é o sistema operacional (SO) mais utilizado no mundo. Em 2014, a GOOGLE
anunciou que existem mais de 1 bilhão de usuários Android ativos. Apesar de ter sido criado pela
GOOGLE, o Android é regido por uma licença de código aberto, ou seja, é permitido que você baixe
o código do sistema operacional Android e o modifique da maneira que você desejar. Essa prática
de modificar o SO Android é bastante comum e utilizada pela maioria das empresas. Dessa forma,
há uma combinação do código aberto disponibilizado com o código privado desenvolvido pela
empresa. Essas modificações no SO feitas pela empresa vão desde melhorias na interface, com
aumento de nitidez das imagens, brilho, performance, até a incorporação de aplicativos nativos da
empresa.
Falando em desenvolvimento de aplicativos para a plataforma Android de forma
autônoma, o GOOGLE possui a GOOGLE PLAY, que é a loja da empresa para a disponibilização e
venda de aplicativos para a plataforma Android. Caso você crie o seu próprio aplicativo, pode
6
vendê-lo na loja da GOOGLE ou mesmo disponibilizá-lo de forma gratuita e tentar ganhar dinheiro
através de anúncios e propagandas que a GOOGLE embute no seu aplicativo, caso você permita.
Existem vários casos de sucesso de pessoas jovens que criaram aplicativos, colocaram na
loja e ficaram ricas. O criador do Ant Smasher já teve o seu jogo baixado por mais de 30 milhões de
pessoas. O aplicativo é gratuito, mas rende mais de 3 milhões de dólares por ano apenas com
anúncios. O criador de Flappy Bird, um jogo bem simples, chegou a, no início de 2014, 50 mil
dólares por dia. Por que você não pode ser uma dessas pessoas?
Aprender uma linguagem de programação exige dedicação, persistência e curiosidade.
Dedicação e persistência para estudar o material disponibilizado e fazer os exercícios propostos,
curiosidade para ir atrás de novas informações, notícias, outros materiais e novos exercícios.
Quando terminar de estudar o material do curso, busque novos materiais, tutoriais e outros
exemplos em livros e na internet. O ser humano aprende por repetição, quanto mais você praticar,
mais você vai assimilar o conteúdo. A cada exemplo, tente entendê-lo e tente você mesmo fazer e
não fique apenas como espectador, dessa forma você criará suas próprias soluções.
Nos próximos capítulos vamos falar de algumas das classes mais importantes utilizadas
para o desenvolvimento em Android. Com relação à ferramenta de desenvolvimento (também
chamada tecnicamente de IDE - Integrated Development Environment) você pode tanto usar o
Eclipse (ADT – Android Development Tools) ou o Android Studio (mais recomendo).
Comercialmente, o Android Studio vem sendo cada vez mais usado, principalmente para novos
projetos. Para fazer o download do Android Studio, basta acessar o site
https://developer.android.com/studio/index.html?hl=pt-br e fazer o download da versão mais
recente. Caso você ainda não tenha o SDK Android, deve baixar o Android Studio com o SDK. Caso já
tenha, basta baixar apenas o Android Studio.
E então, vamos começar a nos divertir?
7
Competência 01
1.Competência 01 | Apresentando a Classe Activity, Ciclo de Vida e Tipos

de Activity
Vamos aprender neste capítulo o conceito de activity, como funciona o seu ciclo de vida,
como mudar de uma activity para outra. Aprenderemos também como trafegar informações entre
as telas da sua aplicação e falaremos da ListActivity, que é um tipo específico de activity.
Vamos começar!
1.1 Activity
Uma Activity é uma classe que herda de Android.app.Activity ou alguma subclasse
desta. Em geral, toda tela de uma aplicação em Android está associada a uma Activity e esta é
responsável por tratar todos os seus eventos como cliques de botão, seleção de checkbox, cliques
no menu e mudanças de tela, por exemplo.
Toda Activity implementa obrigatoriamente o método onCreate(bundle), responsável
por inicializar os elementos necessários para que a tela seja exibida para o usuário. Para isso, o
método setContentView(view) é chamado especificando-se a view que contém os elementos da
tela. Além disso, toda Activity deve ser declarada no arquivo AndroidManifest.xml da seguinte
forma:
<activity Android:name:”.MinhaActivity” />
Esse “.” antes do nome da sua Activity indica que ela está no mesmo pacote do projeto,
caso ela estivesse em um pacote diferente, o nome do pacote deveria ser especificado. Lembre-se
de escrever o nome da Activity corretamente, pois o compilador é case sensitive, ou seja, ele
diferencia as letras maiúsculas das minúsculas, dessa forma para ele “MinhaActivity” é diferente de
“minhaActivity”. Para ter certeza de que o nome e o pacote foram especificados corretamente,
segure a tecla control do seu teclado e passe o mouse em cima do nome da sua Activity, se o texto
ficar “clicável” indica que você pode chegar até a sua Activity apenas clicando, pois ela foi
encontrada no caminho especificado.
Bom, dito isso, lembre-se de que quando você desejar criar uma nova tela na sua
aplicação Android você precisará criar também uma nova Activity e esta necessariamente deverá
ser declarada no AndroidManifest.xml. Ela vai controlar os eventos e elementos da tela, que é
8
Competência 01
especificada no método setContentView(view), que já vimos anteriormente, este método recebe

como parâmetro uma referência para um arquivo XML que contém os elementos da sua interface.
1.2 Ciclo de vida de uma Activity
É bastante importante você entender o ciclo de vida de uma Activity para saber em qual
estado ela se encontra e para você poder controlar o comportamento da sua aplicação. Tenha em
mente o seguinte: quem cuida da execução do fluxo do ciclo de vida é o sistema operacional
Android, mas você pode customizar os estados (executando, temporariamente interrompida em
segundo plano e completamente destruída), por exemplo.
Vamos ver um exemplo prático da utilização e da importância do conhecimento e do
uso desses estados. Imagine que você tenha desenvolvido um jogo espetacular para Android e
enquanto o usuário está jogando ele recebe uma ligação, o que vai acontecer com o jogo? Bom, o
sistema operacional vai interromper o jogo e colocá-lo em segundo plano para que o usuário possa
atender a ligação. Ao encerrar a ligação a grande pergunta que resta é: o que irá acontecer com o
jogo? O jogo vai estar pausado? O jogo foi salvo? Bom, isso vai depender do que foi especificado
por você, desenvolvedor. O Android fornece toda a infraestrutura necessária para isso, basta você
entender o ciclo de vida da Activity.
9
Competência 01
A figura abaixo (figura 1) ilustra o fluxo do ciclo de vida de uma Activity e seus possíveis
estados.
Figura 1 - Ciclo de vida de uma activity

Fonte: O próprio autor.
Descrição: A figura mostra todas as fases do ciclo de vida de uma aplicação Android. Quando uma activity é
iniciada o seu ciclo de vida tem início e o método onCreate é executado, em seguida é executado o onStart e o
onResume. Caso outra activity seja iniciada, a atual é pausada, então, é executado o método onPause. Se a
activity anterior voltar a executar, ela chamará novamente o onResume, caso contrário, é chamado o método
onStop e em seguida pode ser chamado o onDestroy, que encerra a activity ou pode ser chamado o onRestart ,
se a activity voltar a executar ou caso ela tenha ido para segundo plano no onStop e for encerrada pelo SO. No
caso dela voltar a ser exibida, o método onCreate é chamado novamente.
Preste bastante atenção, pois agora iremos explicar cada um dos métodos que se
encontram no ciclo de vida de uma activity. É importante que você leia a descrição do método e vá
acompanhando o fluxo na figura 1.
10
Competência 01
É um método obrigatório, por isso deve estar presente em toda activity e é

executado apenas uma vez. Ele é responsável por criar a activity e chamar o
método setContentView(view) que faz a associação entre a activity e um
onCreate(bundle)
arquivo de interface específico (XML) que contém os elementos da tela que
serão exibidos para o usuário. Logo após a execução do onCreate(bundle) é
chamado o método onStart().
Esse método é chamado após a activity ser criada, bem como a sua view, ou
onStart()
seja, após o método onCreate(bundle). Sua view está prestes a ficar visível.
Como mostrado no fluxo acima, esse método também é chamado sempre
após o onRestart().
onRestart() Esse método é chamado caso sua activity tenha sido parada
temporariamente e esteja sendo iniciada novamente, então o Android
chama o onRestart() que logo em seguida chama o onStart().
onResume() Esse método é chamado quando a activity já está executando e está pronta
pra interagir com o usuário.
Caso o celular entre em modo de espera, hiberne, receba uma ligação ou a

onPause()
aplicação seja colocada em background o método onPause() é chamado.
Dessa forma, o desenvolvedor pode salvar algum estado ou informação que
está sendo usada pela aplicação.
onStop() É chamado quando a activity está sendo encerrada e já não está mais visível
para o usuário. Isso pode ocorrer quando a aplicação muda de uma activity
pra outra, num comportamento de transição de telas.
onDestroy() Encerra a execução de uma activity. O sistema operacional libera os recursos
alocados pela activity como valores de atributos e demais recursos.
Tabela 1 - Ciclo de vida de uma aplicação Android

Fonte: o autor
Descrição: Tabela informando os métodos do ciclo de vida de uma Activity, bem como a sua descrição de quando
ocorre.
A seguir mostrarei um exemplo do código de uma activity que implementa os métodos:
onCreate(bundle), onStart(), onRestart() e onResume() do ciclo de vida que mencionamos
anteriormente. Recomendo seguir o exemplo e implementar todos os métodos. Dessa forma, você
pode fazer seus próprios testes: colocar a aplicação em background, ligar para o seu celular,
encerrar a aplicação e ir vendo os métodos que são chamados através das mensagens de log que
serão exibidas na janela do LogCat. Para isso, você pode criar um projeto Android simples e
executá-lo usando o emulador do Android ou o seu próprio celular.
11
Competência 01
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.i(getLocalClassName(), "onCreate()");
TextView olaMundo = new TextView(this);

olaMundo.setText("Olá mundo! :)");
setContentView(olaMundo);
}
@Override
protected void onStart(){
super.onStart();
Log.i(getLocalClassName(), "onStart()");
}
@Override
protected void onRestart(){
super.onRestart();
Log.i(getLocalClassName(), "onRestart()");
}
@Override
protected void onResume(){
super.onResume();
Log.i(getLocalClassName(), "onResume()");
}
}
12
Competência 01
Quando eu executo a aplicação, meu LogCat mostra o seguinte:
Figura 2 - Impressão de logs no LogCat

Fonte: O autor.
Descrição: Está sendo mostrado um printscreen das informações exibidas no LogCat mostrando quais métodos foram
chamados a partir da exibição de uma Activity. No caso, está sendo exibido um print escrito onCreate(), onStart() e
onResume().
Note que é exibido o nome da activity (getLocalClassName()) e a mensagem que foi
especificada no segundo parâmetro, no caso o nome do método que está sendo chamado. O trecho
mais importante é o final, no caso:
…MainActivity: onCreate()
…MainActivity: onStart()
...MainActivity: onResume()
Quando se coloca em background, apertando o botão da casinha (home) do Android e
depois a se coloca em evidência novamente, é mostrado o seguinte:
...MainActivity: onRestart()
...MainActivity: onStart()
...onResume()
Note que o onCreate(bundle), como havíamos falado anteriormente, é chamado apenas
uma vez. No meu exemplo não inclui os métodos onPause(), onStop() e onDestroy(), coloque-os no
seu exemplo e me diga quais métodos foram chamados quando você clicou no botão home
(símbolo da casinha) e quando você encerrou a aplicação. Perceba que você apenas implementou
os métodos e não está chamando eles em lugar algum. Quem faz essa chamada é o próprio sistema
operacional Android.
Entender o ciclo de vida de uma activity é fundamental para você dominar o
desenvolvimento de aplicações Android. O conhecimento e domínio desses métodos são bastante
importantes principalmente para o desenvolvimento de jogos. Imagine que você está jogando e
recebe uma ligação ou a bateria acaba e o jogo não foi salvo e você tem apenas uma vida ou está
13
Competência 01
com o progresso bastante avançado, então o ideal seria que o jogo fosse salvo ao ser interrompido
ou mesmo pausado para que o usuário não seja prejudicado com interrupções externas e que
fogem do controle do usuário, mas não do desenvolvedor.
1.3 Navegação entre activities

Até agora vimos alguns conceitos do que é uma activity e para que ela é utilizada bem
como o seu ciclo de vida. Agora vamos criar outras activities e aprender como navegar de uma para
outra, tendo em mente que cada activity representa uma tela e a maioria dos aplicativos que
utilizamos possui um conjunto de telas diferentes, então para cada tela será criada uma nova
activity.
Para navegar entre activities (mudar de tela) você pode utilizar dois métodos diferentes:
ou você utiliza o startActivity(intent) ou o startActivityForResult(intent, codigo). Ambos utilizam uma
instância da classe Intent. Intent significa intenção, no nosso caso a nossa intenção é mudar de
activity, ou seja, navegar de uma tela para outra. Veremos com detalhes essa classe Intent no nosso
material.
O método startActivity simplesmente faz a mudança de uma tela para outra sem deixar
nenhum vínculo com a tela anterior, já o startActivityForResult passa um código como parâmetro
para que a segunda Activity saiba de onde veio a informação e possa retornar para esta uma outra
informação. Esse segundo método é usado quando a primeira tela precisa de um parâmetro da
segunda. Dessa forma, quando a segunda tela é encerrada, ela passa a informação para a tela que a
chamou.
1.3.1 Navegação simples de uma activity para outra
O código a seguir mostra como a partir de um clique de botão é possível abrir uma nova
tela (o botão ocupa a tela toda, mas não se preocupe com isso agora). Note que para isso você
precisa de uma segunda activity. Já que estamos navegando de uma tela para outra serão
necessárias duas activities para o exemplo. A primeira activity vamos chamar de MainActivity e a
segunda de SegundaTela.
14
Competência 01
Exemplo MainActivity
public class MainActivity extends Activity implements View.OnClickListener

{
@Override
Button olaMundo = new Button(this);

olaMundo.setText("Olá mundo! :)");
olaMundo.setOnClickListener(this);
setContentView(olaMundo);
}
public void onClick(View v) {

Intent tela2 = new Intent(this, SegundaTela.class);
startActivity(tela2);
}
}
Exemplo SegundaTela
public class SegundaTela extends Activity {

TextView tela2 = new TextView(this);

tela2.setText("Bem vindo a SegundaTela.");
setContentView(tela2);
}
}
Se você tiver essas duas activities criadas você vai conseguir rodar? Depende... Você
se lembrou de declarar essa sua nova activity no AndroidManifest.xml? Lembre-se de que toda nova
15
Competência 01
activity(tela) deve ser declarada no AndroidManisfest, caso você não faça isso o seu LogCat vai
exibir a seguinte mensagem de erro quando você clicar no botão na tentativa de mudar de tela:
FATAL EXCEPTION
Unable to find explicit activity class SegundaTela
have you declared this activity in your AndroidManifest.xml?
Perceba que ele exibe uma mensagem em inglês informando o porquê do erro,
traduzindo: “você declarou essa activity no seu AndroidManifest.xml?”. Para que isso não ocorra
adicione a seguinte linha no seu AndroidManifest.xml:
<activityAndroid:name=".SegundaTela" />
O que acontece com a primeira activity após a mudança para a segunda tela? Veja o que
foi impresso no LogCat a partir da implementação e impressão de log nos métodos do ciclo de vida
que aprendemos anteriormente. Implemente os métodos do ciclo de vida tanto para a primeira tela
quanto para a segunda e entenda o que acontece em ambas.
1.3.2 Navegação entre telas com passagem de parâmetros
Agora já sabemos como navegar de uma tela para outra, mas como enviar uma ou mais
informações da primeira tela para a segunda? Para isso, usaremos uma classe chamada Bundle que
é similar a uma HashTable (estrutura de dados do tipo chave valor). Ela faz uso do método
putString(chave, valor) para configurar as informações que serão passadas em formato de texto
para a próxima tela.
Agora faremos uma pequena modificação no exemplo anterior para ilustrar a passagem
de informações entre as telas (o código a seguir faz parte do conteúdo da classe MainActivity).

Bundle informacoes = new Bundle();
informacoes.putString("cargo","Professor");
informacoes.putString("nome","Gilson");
tela2.putExtras(informacoes);
}
16
Competência 01
No nosso exemplo utilizamos o método putString, mas a classe Bundle possui outras
opções caso você queira passar outro tipo primitivo como putBoolean, putChar, punInt, dentre
outras. Para obter a lista completa basta consultar o javadoc.
Já sabemos como passar as informações, agora precisamos saber como resgatá-las na
outra tela. Novamente vamos alterar o código que havíamos criado (o código a seguir faz parte do
conteúdo da classe SegundaTela).

TextView tela2 = new TextView(this);
Intent it = getIntent();
String cargo = "", nome = "";
if(it != null){
Bundle informacoes = it.getExtras();
if(informacoes != null){
cargo = informacoes.getString("cargo");
nome = informacoes.getString("nome");
}
}
tela2.setText("Bem vindo " + cargo + " " + nome);
setContentView(tela2);
}
Note que no onClick do botão da primeira tela (MainActivity) nós passamos o Intent
(chamado tela2) com as informações que desejamos transferir. Como o parâmetro do startActivity e
no onCreate da segunda tela (SegundaTela), nós resgatamos esse mesmo Intent (tela2) e extraímos
as informações que foram passadas através da chave “cargo” e “nome”, basicamente, foi isso que
fizemos.
Em toda linguagem de programação existem diferentes formas de se fazer a mesma
coisa, vai depender do seu conhecimento e da flexibilidade da mesma. Também poderíamos passar
as informações da seguinte forma:
17
Competência 01

tela2.putExtra("cargo", "Professor");
tela2.putExtra("nome","Gilson");
}
Veja que no exemplo acima nós omitimos a utilização Bundle e colocamos os

parâmetros diretamente no Intent. Da mesma maneira, para recuperar essas informações na
próxima tela, podemos novamente omitir a utilização da classe Bundle e fazer o seguinte:
cargo = it.getStringExtra("cargo");
nome = it.getStringExtra("nome");
1.4 ListActivity – uma activity diferente

A classe Activity é uma classe básica e simples que permite uma alta customização,
contudo existem outros tipos de Activities que são um pouco mais complexas, pois já apresentam
alguns comportamentos implícitos, como é o caso da classe ListActivity. Como o próprio nome já diz
é uma Activity utilizada para exibir uma lista de itens na vertical.
Esse tipo de activity já apresenta internamente um componente do tipo ListView,
responsável por desenhar uma lista vertical com uma barra de rolagem, se necessário. Além da
presença desse componente, o método setContentView(view) é chamado automaticamente pela
ListActivity, dessa forma o programador não precisa se preocupar com a view que será mostrada e
sim com os elementos que irão preencher a lista.
Agora como fazemos para criar essa lista de elementos? Bom, para isso será necessário
criar um objeto que implemente a classe ListAdapter que faz a ligação entre o componente
(ListView) e os valores que você deseja exibir na sua lista.
É importante que você entenda que você poderia criar uma Activity e adicionar um
ListView, ou você poderia usar diretamente uma ListActivity. Criando uma ListActivity você não
precisa interagir diretamente com o ListView. A ListActivity proporciona ao programador novos
métodos com o objetivo de facilitar tanto a criação quanto a manipulação da lista. Ai você pergunta:
“Professor, eu preciso conhecer todos os tipos de activity?”, a minha resposta é “Não!”. O meu
objetivo é mostrar que existem outros tipos de Activity e com o passar do tempo e à medida em
18
Competência 01
que você for adquirindo experiência vai acabar conhecendo outras classes de Activity. O objetivo
dessas outras classes é justamente facilitar a manipulação e a utilização dos componentes do
Android.
Agora, vamos colocar a mão na massa, vamos criar uma classe que estende de
ListActivity, preencher um array (conjunto) de objetos e exibir na tela, conforme demonstrado a
seguir:
public class MainActivity extends ListActivity {
@Override
String[] lista = new String[]{"Item 01", "Item 02"};

ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>
(this, Android.R.layout.simple_list_item_1, lista);
setListAdapter(arrayAdapter);
}
@Override
protected void onListItemClick
(ListView, View, int position, long id){
super.onListItemClick
(listView, view, position, id);
String itemSelecionado =
this.getListAdapter().getItem(position).toString();
Toast.makeText(this, "Item selecionado -> " + itemSelecionado,
Toast.LENGTH_LONG).show();
}
}
O método onListItemClick é um método da ListActivity utilizado para facilitar a

manipulação do ListView. Sempre que o usuário clicar em um elemento da lista esse método é
chamado automaticamente permitindo ao programador identificar qual objeto foi selecionado. No
exemplo acima, sempre que o usuário clicar em um item da lista nós exibimos um alerta através do
19
Competência 01
método show()da classe Toast com a mensagem “Item selecionado -> Item 01”, por exemplo. Caso
essa lista funcionasse como um menu, nós poderíamos identificar qual elemento foi clicado e ter
uma ação associada a cada item ou poderia ser usada apenas como uma lista de dados informativa.
Atenção para o parâmetro Android.R.layout.simple_list_item_1, ele
representa um layout de lista padrão predefinido pelo Android. Os layouts predefinidos ajudam
bastante quando se quer utilizar um layout simples, contudo para layouts mais complexos e
personalizados é necessário que o próprio desenvolvedor crie de acordo com a sua necessidade.
No nosso último exemplo nós criamos uma ListActivity com dois itens: “Item 01” e
“Item 02”, já que foi dada a ideia de criar um menu com o ListView da ListActivity. Vamos lá!? Já
temos uma lista com dois itens e já implementamos o método onListItemClick, a tarefa é a seguinte:
se o usuário clicar no “Item 01” nós vamos iniciar nova activity chamada CicloDeVidaActivity que vai
conter o nosso primeiro exemplo desse capítulo. Será uma activity simples com todos os métodos
do ciclo de vida implementados. Já se o usuário clicar no “Item 02” nós vamos chamar a activity
ItemClicadoActivity que recebe a informação do item clicado.
Já que não vamos criar nenhum item novo, então eu não preciso mexer no método
onCreate, eu só vou mexer no método onListItemClick, porque a única coisa que eu vou fazer é ter
uma ação diferente dependendo do item que for clicado, ok? Então, o método seria modificado da
seguinte forma:
@Override
protected void onListItemClick
(ListView, View, int position, long id){
switch (position){
case 0:
startActivity(new Intent(this, CicloDeVidaActivity.class));
break;
case 1:
Intent = new Intent(this, ItemClicadoActivity.class);
intent.putExtra("itemClicado",
this.getListAdapter().getItem(position).toString());
startActivity(intent);
break;
}}
20
Competência 01
Perceba que para identificar qual item foi clicado eu usei o parâmetro “position”, esse
parâmetro informa a posição do item clicado. O primeiro item é representado pela posição de
índice 0, o segundo item é representado pela posição de índice 1 e assim por diante.
No próximo capítulo abordaremos o conceito de Intent e veremos mais exemplos da sua
utilização, pois essa talvez seja a classe mais importante do Android. Lembre-se de que ela já foi
citada brevemente neste capítulo. Quando precisamos navegar de uma tela para outra, nós criamos
um Intent e passamos a tela para qual desejamos navegar como parâmetro e chamamos o método
startActivity(Intent).
21
Competência 02
2.Competência 02 | Intent
Neste capítulo aprenderemos mais sobre a classe Intent, que para muitos é o coração do
Android. Intent significa intenção, representa uma ação que a aplicação deseja executar. No
capítulo anterior, a intenção que tínhamos era a de mudar de uma tela para outra, mas poderíamos
ter a intenção de abrir o browser do celular, fazer uma ligação, abrir o GOOGLE PLAY para instalar
um aplicativo, enviar uma mensagem para o SO ou mesmo exibir um endereço ou rota no GOOGLE
MAPS.
Agora, aprenderemos diversas utilidades da classe Intent, por isso fique atento e se tiver
mais curiosidade busque mais informações na internet sobre as diversas formas de se utilizar um
Intent. Vamos aprender algumas delas.
2.1 Abrindo o browser e acessando um site específico

O Android já possui diversas ações padrões que podem ser requisitas pelo
desenvolvedor a qualquer momento. Dentre elas está a abertura de uma página web. Então, o
programador dirá para o Android: “Você pode abrir essa página para mim?”. E ele, como já possui
essa tarefa mapeada pelo sistema operacional dirá: “Sim, você que manda!”.
Vamos ver um exemplo a seguir de como através do clique de um botão podemos abrir
o buscador do Google:

{
@Override
Button abrirBrowser = new Button(this);

abrirBrowser.setText("Abrir o google.com");
setContentView(abrirBrowser);
abrirBrowser.setOnClickListener(this);
}
22
Competência 02
@Override
Uri endereco = Uri.parse("http://www.google.com");
Intent it = new Intent(Intent.ACTION_VIEW, endereco);
startActivity(it);
}
}
No código acima nós temos uma Activity chamada MainActivity que implementa a
interface View.OnClickListener. No método onCreate da Activity nós criamos um botão chamado
abrir Browser com o texto “Abrir o google.com” e, ao clicá-lo, nós chamamos o método onClick da
interface View.OnClickListener que foi sobrescrito pela nossa activity. Nesse método nós
instanciamos um objeto da classe URI onde especificamos o endereço web que desejamos abrir,
então criamos um Intent para sinalizar a intenção de abrir essa página (http://www.google.com),
por isso passamos o URI com essa informação como parâmetro do Intent e logo em seguida
chamamos o startActivity para executar o nosso Intent. No momento em que o startActivity é
chamado, o seu aplicativo envia uma mensagem para o SO Android para abrir o seu browser
padrão.
Note que não há uma diferença na utilização do Intent para uma ação local da sua
aplicação e uma ação do próprio sistema operacional Android, visto que tanto para mudar de tela
quanto para abrir o browser é chamado o método startActivity(Intent).
No exemplo anterior nós criamos um botão e, ao clicá-lo, nós abrimos o browser e
acessamos o endereço especificado no URI adicionado ao Intent. Agora vamos fazer um exemplo
um pouco mais incrementado. Vamos criar um xml de layout, vamos colocar um label, um campo
de texto para o usuário digitar um site e um botão em que, com um clique, nós abriremos o
browser e o endereço especificado.
Primeiro vamos criar o xml de layout:
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:orientation="vertical">
23
Competência 02
<TextView
Android:layout_height="wrap_content"
Android:text="Digite a URL" />
<EditText
Android:id="@+id/campoTextoEnderecoWeb"
Android:layout_height="wrap_content" />
<Button
Android:id="@+id/botaoCliqueAqui"
Android:layout_width="wrap_content"
Android:text="Clique aqui!" />
</LinearLayout>
Em seguida, criamos a activity que estará associada a esse xml de layout:

{
@Override
setContentView(R.layout.activity_main);
Button botaoCliqueAqui = (Button)

findViewById(R.id.botaoCliqueAqui);
botaoCliqueAqui.setOnClickListener(this);
}
public void onClick(View view){

EditText campoTextoEnderecoWeb = (EditText)
findViewById(R.id.campoTextoEnderecoWeb);
String enderecoWeb = campoTextoEnderecoWeb.getText().toString();
24
Competência 02
Uri = Uri.parse(enderecoWeb);
Intent it = new Intent(Intent.ACTION_VIEW, uri);
startActivity(it);
}
}
Até ai nenhuma novidade na parte da activity. Ao iniciá-la, o método onCreate é

chamado, especificamos a view que será mostrada através da chamada do método setContentView.
Depois, pegamos o botão através do seu id (R.id.botaoCliqueAqui) que foi especificado no
XML e associamos a ele o evento do clique e dizemos que esse evento foi implementado nessa
activity (this). O clique do botão contém o código que havíamos visto anteriormente, a diferença
é que o endereço web que antes era estático agora é dinâmico e é passado pelo EditText que está
no layout. Na hora de testar não se esqueça de digitar o endereço completo, por exemplo:
www.google.com, não esquecer do http://.
2.2 Fazendo uma ligação para um número de telefone

Agora vamos aprender como fazer uma ligação usando a classe Intent. Na sessão
anterior, para abrirmos o browser, usamos a ação Intent.ACTION_VIEW e informamos o URI com o
endereço web desejado. De forma similar, para fazer uma ligação, o Intent precisa ter a ação
Intent.ACTION_CALL mais o número do telefone para o qual desejamos ligar.
Existem aplicações que dão a opção ao usuário de fazer uma ligação pra uma central de
atendimento caso ele tenha algum problema na sua utilização. Por exemplo, imagine que você está
desenvolvimento uma aplicação que permite locar um carro de uma estação de origem para
entregá-lo numa estação de destino. Esse carro é movido à eletricidade e não à gasolina ou álcool
como os veículos comuns. No meio do seu percurso, a bateria do carro acaba ou você se envolve
em algum acidente. Assim, é importante que a aplicação disponibilize um número de emergência
para o qual o usuário poderá ligar. Esse número pode ser informado de modo que o usuário saia da
aplicação e digite para fazer a ligação ou clique em um botão e através desse clique a aplicação
envie uma ordem para o sistema operacional para efetuar a ligação. Vamos nos ater a essa última
opção.
25
Competência 02
Então, como faríamos para fazer uma ligação a partir do clique de um botão na nossa
aplicação? Vamos ver um exemplo de um XML de layout que contém um texto explicativo e um
botão que, ao clicá-lo, a ação será ligar para um número de emergência.

Android:orientation="vertical">
<TextView
Android:layout_margin="20dp"
Android:text="Caso você esteja tendo algum problema com a aplicação ligue
para emergência."/>
<Button
Android:text="Ligar para Emergência"
Android:onClick="acaoLigarParaEmergencia"/>
</LinearLayout>
Perceba que o elemento “Button” possui um atributo chamado Android:onClick e como

parâmetro desse elemento especificamos o nome do método presente na sua activity. Essa forma
de especificar e implementar a ação do botão é uma forma diferente da anterior que nós havíamos
visto, você se lembra? Antes, para associar uma ação ao clique do botão, nós colocamos um id no
XML do layout (Android:id="@+id/botaoCliqueAqui") do botão e na activity nós
pegamos esse botão pelo id (Button botaoCliqueAqui = (Button)
findViewById(R.id.botaoCliqueAqui)) e associamos a ele a sua respectiva ação
(botaoCliqueAqui.setOnClickListener(this)). Agora, nós fizemos diferente,
associamos a ação diretamente no XML de layout. Tenha em mente essas duas formas de
26
Competência 02
especificação da ação do botão, será importante você saber para poder dar manutenção num
sistema já existente ou para poder implementar sua própria aplicação.
Agora vamos ver como fica a activity!
@Override
}
public void acaoLigarParaEmergencia(View v) {

Uri telefone = Uri.parse("tel:988998899");
Intent it = new Intent(Intent.ACTION_CALL, telefone);
if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
return;
}
startActivity(it);
}
}
Antes de executar o código acima, você precisa abrir o arquivo AndroidManifest.xml e

adicionar uma permissão informando que a sua aplicação pode precisar fazer uma ligação. Então,
adicione a seguinte linha no seu AndroidManifest:
<uses-permission Android:name="Android.permission.CALL_PHONE" />
Caso você não coloque essa linha, a chamada ao método startActivity(it)

acusará o erro de permissão e você não poderá executar o código.
Observação: Existe uma ação parecida com a Intent.ACTION_CALL que é a
Intent.ACTION_DIAL, que ao invés de discar e fazer a ligação, apenas disca o número desejado, mas
espera o usuário fazer a confirmação para efetuar a ligação. Faça o teste você mesmo, substitua e
veja o que acontece.
27
Competência 02
2.3 Solicitando ao google maps que exiba um local específico do mapa

A classe Intent também pode ser usada para fazer com que o SO abra um aplicativo de
mapa como, por exemplo, o Google Maps e mostre uma determinada localização geográfica através
do seguinte código:
@Override
Uri uriGeografico =
Uri.parse("geo:0,0?q=Cidade+Universitária,Recife");
Intent it = new Intent(Intent.ACTION_VIEW, uriGeografico);
startActivity(it);
}
}
Perceba que nesse exemplo não será necessário o usuário fazer nenhuma ação, como
clicar no botão, basta ele entrar nessa activity para ela chamar outra activity mostrando a
localização especificada. Nesse exemplo nós estamos especificando um endereço, mas poderia ser
uma coordenada geográfica (latitude e longitude), nesse caso o objeto uriGeografico ficaria da
seguinte forma:
// Coordenadas do Palácio do Planalto, Brasília
Uri uriGeo = Uri.parse("geo:-15.7996165,-47.8591871");
Você pode colocar o seu endereço ou a sua coordenada e ver o Android localizá-la no
mapa, faça o teste! Além disso, você também pode exibir uma rota de um ponto de partida até um
destino específico, basta você determinar as coordenadas de origem e de destino em um serviço do
google maps, atribuir ao Uri e associá-lo ao Intent. Você pode pesquisar por esse exemplo na
internet e fazer o teste.
28
Competência 02
2.4 Acessando contatos da agenda

A classe Intent também pode ser usada pela aplicação para acessar a lista de contatos
do seu usuário. Para isso, a ação que utilizada é uma conhecida nossa, a Intent.ACTION_VIEW,
contudo o outro parâmetro é bem diferente. Para identificar o contato desejado é utilizado o seu
ID, por exemplo: “content://com.Android.contacts/contacts/ID”, onde esse ID varia para cada
contato da sua agenda.
A seguir vamos ver um exemplo de como fazer com que nossa aplicação busque por um
contato específico no momento em que o usuário clica em um botão. Nesse momento você já deve
saber como adicionar um botão na tela e como associar a ele seu respectivo método de onClick.
Você pode fazer isso através do XML ou criar um botão dinamicamente no onCreate da activity.
Aqui eu mostrarei apenas o conteúdo de como ficará o evento de clique do botão, ok?
Uri primeiroContato =
Uri.parse("content://com.Android.contacts/contacts/1");
Intent it = new Intent(Intent.ACTION_VIEW, primeiroContato);
startActivity(it);
Assim como para fazer uma ligação, para você poder acessar a agenda do celular do seu
usuário, no momento da instalação, é necessário que o seu APP solicite a permissão
READ_CONTACTS, então você pode precisar adicionar a seguinte linha no seu AndroidManifest.xml:
<uses-permissionAndroid:name="Android.permission.READ_CONTACTS"/>
ATENÇÃO!
Se você rodar o exemplo acima no emulador pode ser que não tenha
contato cadastrado e você pode se deparar com a seguinte mensagem:
“Invalid contact uir.”. Então, pra exercitar, eu recomendo você executar o
exemplo anterior no seu próprio celular, caso você tenha um dispositivo
Android.
29
Competência 02
Caso você não saiba o ID do usuário e queira visualizar toda a lista de contatos
cadastrados e deixar o usuário livre para escolher, basta você usar o mesmo Uri que usamos
anteriormente omitindo apenas o ID do contato e mudar a ação para Intent.ACTION_PICK. Assim, o
código do onClick modificado ficaria da seguinte forma:
Uri listaDeContatos =
Uri.parse("content://com.Android.contacts/contacts/");
Intent it = new Intent(Intent.ACTION_PICK, listaDeContatos);
startActivity(it);
Após a execução do método startActivity é enviada uma mensagem para o sistema

operacional e é aberta a lista de contatos do dono do dispositivo. Contudo, no momento em que
você clica em um contato qualquer a agenda fecha e retorna para activity anterior. Esse exemplo
não é muito útil, pois o método startActivity tem a função apenas de abrir uma nova activity, então,
quando queremos além de abrir um nova activity receber alguma informação que vem dela,
utilizamos o método starctActivityForResult(intent, código).
2.5 Retornando resultados de uma activity para outra através do método

startActivityForResult
Existem duas formas de mudar de uma activity para outra. A que nós vemos
constantemente faz apenas a mudança de activities através da chamada do método
startActivity(intent). A outra forma é através da chamada do método startActivityForResult(intent,
codigo) que é utilizada quando se quer recuperar alguma informação da tela que foi chamada na
tela que a chamou.
Vou explicar melhor, preste atenção! O método startActivityForResult(intent, código)
recebe 2 parâmetros. O primeiro é o intent, ou seja, é a intenção de abrir uma nova activity e o
segundo é um código, que é um valor usado para identificar a activity que será iniciada, esse código
é chamado de requestCode no Android. Esse mesmo código será enviado de volta quando a activity
aberta for finalizada juntamente com o resultado que se deseja recuperar.
30
Competência 02
Vamos ver um exemplo prático. Através de um clique no botão, vamos abrir a lista de
contatos da agenda, como aprendemos anteriormente, e vamos retornar as informações do
contato escolhido. Antes, quando clicávamos no contato, a activity se fechava e não fazíamos mais
nada com a informação do contato escolhido, na verdade nem a tínhamos ainda, essa informação
ficava perdida. Agora, chamando o método startActivityForResult no clique, nós podemos recuperar
essa informação quando a activity contendo a lista de contatos for fechada, veja o exemplo a seguir.

{
@Override
Button b = new Button(this);
b.setText("Abrir Agenda Telefonica");
b.setOnClickListener(this);
setContentView(b);
}
@Override
Uri listaDeContatos =
Uri.parse("content://com.Android.contacts/contacts/");
Intent it = new Intent(Intent.ACTION_PICK, listaDeContatos);
startActivityForResult(it, 10);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent
data) {
if(requestCode == 10) {
Uri = data.getData();
Cursor = getContentResolver().query(uri, null, null, null,
null);
cursor.moveToFirst();
int nameColumnIndex =
31
Competência 02
cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME)
;
String name = cursor.getString(nameColumnIndex);
Toast.makeText(this, "Contato: " + name,

Toast.LENGTH_SHORT).show();
}
}
}
}
}
Perceba que no nosso exemplo temos três métodos dos quais dois você já conhece e
está bem familiarizado, que são os métodos onCreate, método obrigatório da classe activity que é
chamado sempre que a activity é criada e o método onClick, que é associado ao clique do botão
através do código b.setOnClickListener(this);. Note que existe um método novo
chamado onActivityResult que é o método que é chamado assim que a activity que foi iniciada no
startActivityForResult é encerrada. O código, chamado requestCode, que passamos na chamada, é
retornado no onActivityResult para identificar qual activity foi encerrada, por isso a
checagem no if(requestCode == 10). Dessa forma, é feito o tratamento correto com a
informação esperada. Caso essa nossa activity não tivesse apenas um botão e fosse possível iniciar
mais de uma activity, essa verificação do if(requestCode == 10), faria mais sentido. O
importante é que você perceba que você enviou um código identificador e que esse código foi
retornado, possibilitando o programador saber de onde vem à informação desejada. A classe
Toast.makeText foi utilizada somente para exibir a mensagem com o nome do usuário. Você
também poderia exibir o número do contato ou qualquer outra informação retornada no Intent.
Se você for pesquisar vai ver que os métodos startActivity e startActivityForResult são
bem parecidos, então quando usar um ou outro? Se você quiser apenas mudar de uma tela para
outra sem se importar com o retorno use o starActivity, caso contrário use o startActivityForResult e
na activity que você chamou este método implemente o método onActivityResult.
Esses exemplos são bem simples e didáticos, você pode fazer seus próprios exemplos e
procurar exercícios e matérias complementares na internet.
32
Competência 02
2.6 Intent – Resumo

No decorrer desse capítulo vimos vários possíveis usos para a classe Intent. Ela pode ser
usada tanto para iniciar uma activity que você criou dentro da sua aplicação quanto para chamar
uma activity nativa do Android ou mesmo de outra aplicação e é isso que torna essa classe tão
interessante e especial.
Essa característica de poder se comunicar com outra aplicação é o ponto chave que
diferencia a classe Intent das demais classes Android. Devido a essa característica pode-se ter
inúmeras aplicabilidades, vai depender da utilidade e objetivo da sua aplicação. Imagine que uma
aplicação rode em background e devido a algum evento o usuário precisa ser notificado
urgentemente com um pop up ou uma mensagem de alerta. A aplicação pode detectar esse evento,
mesmo rodando em background, e sinalizar ao usuário a sua ocorrência.
Vamos a outro exemplo. Imagine que uma aplicação envia uma mensagem para o
celular com a intenção de autenticar o usuário da aplicação. A aplicação pode interceptar a
mensagem enviada para o dispositivo e já pegar o código de autenticação na mensagem. Isso
acontece bastante em aplicação de e-mail, que envia uma mensagem com código para o usuário
para ele pegar aquele número e se autenticar. Caso a aplicação seja móvel, ela pode interceptar a
mensagem e já passar para o próximo passo.
Outro exemplo clássico é a leitura do código de barras do celular. Você pode fazer com
que a sua aplicação faça uso do recurso da câmera digital do dispositivo para fazer uma leitura do
código de barras e fazer um pagamento ou ler um QRCode (Quick Response, é um código de barras
bidimensional que pode ser facilmente lido pela câmera da maioria dos dispositivos móveis), isso é
bem comum em aplicações de bancos. Ou ainda permitir ao usuário tirar uma foto e enviar ou
anexar na sua aplicação, como acontece no WhatsApp, por exemplo.
Existem outras aplicabilidades da classe Intent, aqui nós vimos apenas algumas delas. No
decorrer do nosso material continuaremos utilizando a classe Intent. No próximo capítulo,
falaremos sobre interface gráfica e aprofundaremos mais alguns conceitos.
33
Competência 03
3.Competência 03 | Conceitos de Interface Gráfica

Neste capítulo aprenderemos mais sobre os componentes de layout, como usá-los e
como organizá-los, apesar de já termos vistos alguns nos capítulos anteriores, como botões e blocos
de textos. No Android existem diversos gerenciadores de layout que podem organizar os elementos
verticalmente, horizontalmente ou mesmo posicionar em um local específico da tela (coordenadas x
e y). Mostraremos vários exemplos e falaremos detalhadamente dos principais componentes.
Vamos lá?
3.1 A classe View
Vamos começar a falar da classe Android.view.View que é considerada a classe mãe dos
componentes visuais do Android. Toda subclasse da classe View deve implementar o método
onDraw(Canvas) cuja função é desenhar o componente na tela. No Android já existem várias classes
que implementam a classe View, mas nada impede que você crie sua própria classe, estenda da
classe View e implemente o seu próprio comportamento para o método onDraw.
No Android nós podemos distinguir dois tipos de componentes: os widgets e os
gerenciadores de layout. O primeiro herda diretamente da classe View e são elementos mais
concisos como Button, TextView, Chronometer, ListView, ImageButton e ImageView, por exemplo.
O segundo tipo herda de ViewGroup e são chamados popularmente apenas de layout.
Nós vamos ver como usar widgets e como usar gerenciadores de layout e vamos ver a
diferença entre os diferentes tipos de gerenciadores. Preste atenção, porque é bastante importante
você saber como usá-los e como fica a dinâmica de organização dos elementos na tela com cada um
dos tipos de layout.
3.2 ViewGroup e gerenciadores de layout
Um gerenciador de layout, como o próprio nome já diz, é um componente visual

utilizado para organizar a disposição dos seus componentes na tela. A seguir, vamos ver uma tabela
com os principais tipos de ViewGroup, ou seja, diferentes classes do Android que herdam
nativamente de ViewGroup e ainda possuem comportamentos específicos e são bastante usadas.
34
Competência 03
COMPONENTE DESCRIÇÃO
É um componente utilizado quando se deseja
FrameLayout
preencher toda a tela do aparelho.
É utilizado quando se deseja organizar os seus
LinearLayout
componentes internos de forma horizontal ou vertical.
Juntamente com o LinearLayout é um dos
componentes mais utilizados. É usado quando se
deseja posicionar um componente de forma relativa a
RelativeLayout
outro. Por exemplo, o elemento “A” vai ficar abaixo do
“B”, ou acima ou ao lado, ou seja, a localização de “A”
vai depender da posição de “B”.
É uma espécie de contêiner onde a posição dos seus
AbsoluteLayout componentes é especificada através de coordenadas x
e y.
Tabela 2 - Tipos de ViewGroup
Fonte: o autor
Descrição: Tabela de tipos de ViewGroup com suas descrições e características.
Existem outras classes que também herdam de ViewGroup como GridLayout e

TableLayout, por exemplo, contudo nesse material vamos focar nesses quatro tipos principais.
Até aqui fizemos poucos exemplos utilizando arquivos de layout em XML. Em muitos
exemplos instanciamos os componentes dinamicamente e associamos a sua Activity
correspondente, mas a partir desse ponto utilizaremos bastante os arquivos de layout escritos em
XML, que é o mais comum de ser encontrado no mercado.
3.3 FrameLayout
Vamos começar pela classe mais simples dos gerenciadores de layout para você
entender melhor o seu conceito. Como vimos na tabelinha, anteriormente, o FrameLayout é um
componente utilizado quando se deseja mostrar algo na tela toda, como uma imagem de fundo que
pode ser uma marca d’água, por exemplo.
A princípio, o elemento que você colocar em um FrameLayout irá ocupar a posição
superior esquerda da tela e, dependendo do seu tamanho ou do que foi definido nos seus atributos,
pode ocupar toda a tela. Ainda assim é possível inserir outros elementos na tela de forma que os
elementos inseridos posteriormente fiquem por cima dos elementos anteriores, seguindo o
conceito de pilha, onde o último elemento fica por cima dos inseridos primeiro. Então, imagine que
você tem uma aplicação e deseja colocar no fundo uma imagem, você poderia usar um
35
Competência 03
FrameLayout onde seu primeiro elemento seria a sua imagem e os demais elementos seriam os
outros componentes da tela que seriam mostrados por cima da imagem, tornando a imagem um
background da tela.
Vamos agora ver na prática como funciona o FrameLayout! O exemplo a seguir é
composto de um FrameLayout contendo um ImageView e vamos ver as variações possíveis dos
atributos layout_widh e layout_height, que constituem a largura e a altura do FrameLayout,
respectivamente.

<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:background="#000000">
<ImageView
Android:src="@drawable/Android_mini"/>
</FrameLayout>
O código acima tem como saída a figura 3:
Figura 3 - Imagem do resultado da utilização do componente chamado FrameLayout

Fonte: O próprio autor
Descrição: Imagem sendo exibida no topo do lado esquerdo da tela com um fundo da tela do aplicativo cinza.
36
Competência 03
Perceba que tanto no elemento FrameLayout quanto no ImageView suas propriedades

layout_width e layout_height foram setadas como wrap_content. O que isso significa? Para o
FrameLayout significa que a largura e a altura ocuparão somente o tamanho necessário para exibir
o seu conteúdo interno, da mesma forma o ImageView ocupará apenas o tamanho necessário para
exibir a imagem Android_mini. Observe que a imagem Android_mini é transparente e o fundo preto
pertence ao FrameLayout. Com as propriedades de altura e largura setadas como wrap_content o
espaço ocupado pelo FrameLayout será o mesmo espaço ocupado pelo ImageView.
Caso você deseje que o seu FrameLayout ocupe toda a tela, basta mudar as
propriedades de largura e altura de wrap_content para match_parent, dessa forma o componente
irá ocupar todo o espaço designado ao pai (parent), ocupando assim a tela toda e não mais apenas
o espaço ocupado por seus elementos internos. Veja o exemplo a seguir:

<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:background="#000000">
<ImageView
</FrameLayout>
37
Competência 03
Figura 4 - Exemplo da utilização do atributo de background

Descrição: É o mesmo exemplo da imagem anterior, sendo adicionado o atributo chamado background. Dessa forma, a
imagem continua sendo exibida no topo do lado esquerdo, contudo o fundo da tela do aplicativo está preto com o
background sendo especificado através do valor em hexadecimal de #000000 que representa a cor preta.
O mesmo raciocínio é válido para o ImageView. Se quando eu coloco o tamanho do
FrameLayout para match_parent ele ocupa a tela toda, você imagina o que acontecerá se você
trocar o wrap_content dos atributos da imagem para match_parent? Teste você mesmo e veja o
que acontece!
É recomendado que a largura e Aaltura do layout principal ocupem a tela inteira. Logo,
as propriedades layout_width e layout_height devem ter os valores match_parent. Caso ache
necessário, para se certificar de que isso está ocorrendo, mude a cor do background do
componente para poder visualizá-lo. Do contrário ele será transparente e você poderá ficar na
dúvida se ele realmente está ocupando toda a tela.
Esses foram apenas alguns exemplos simples da utilização de um layout juntamente
com a explicação das propriedades de largura e altura. Como havíamos falado anteriormente, o
frame layout coloca os elementos internos empilhados devido a sua natureza de empilhar os
elementos internos, o último elemento a ser inserido ficará por cima dos elementos anteriores.
Então, no caso de você colocar outra ImageView abaixo da primeira com outra imagem, você
perceberá que a primeira imagem pode não ser exibida ou ficar por trás da última. Faça o teste!
Um FrameLayout pode ser usado para fazer uma aplicação definindo uma imagem de
fundo, fazendo com que esta imagem fique por trás do conteúdo da aplicação ou ainda pode fazer
uma tela e colocar como último elemento uma ProgressBar que, quando ativado, ficará por cima de
38
Competência 03
todos os elementos do layout, bloqueando as interações do usuário, fazendo com que ele espere o
processamento de um determinado processo, por exemplo.
Antes de começar a desenvolver uma tela, imagine como ela ficará para, então, você
poder selecionar o melhor layout de acordo com as suas necessidades.
3.4 O famoso LinearLayout

O LinearLayout é o gerenciador de layout mais utilizado, pois possui um conceito
bastante simples: o de organizar os seus componentes internos de forma sequencial na horizontal
ou na vertical. Toda classe de layout deve conter os atributos layout_width e layout_height para
especificar a largura e a altura do componente, respectivamente. Além desses atributos, o
LinearLayout também possui o atributo orientation, onde é possível especificar a orientação dos
seus componentes internos. Os valores desse atributo podem ser horizontal ou vertical, o default,
ou seja, se você não especificar o valor, os elementos serão exibidos horizontalmente. Veja o
exemplo a seguir.
Android:layout_height="match_parent">
<ImageView
<ImageView
Android:src="@drawable/Android_mini2"/>
</LinearLayout>
39
Competência 03
Figura 5 - Imagens representando o uso do componente de LinearLayout

Descrição: Duas imagens sendo exibidas lado a lado. A primeira está no topo do lado esquerdo e a segunda está
posicionada logo em seguida, ao lado direito da primeira. As imagens verdes estão inseridas num fundo branco.
Esse exemplo é semelhante ao exemplo do FrameLayout. Mudei apenas o tipo do

ViewGroup para LinearLayout, perceba que as imagens são exibidas uma ao lado da outra, ou seja, o
LinearLayout ocupa a tela toda, porque sua largura e altura foi especificada como match_parent e
os seus elementos internos são exibidos lado a lado, de forma sequencial, pois não foi especificado
o atributo orientation que por padrão é horizontal. Caso você tivesse especificado explicitamente
como vertical (Android:orientation="vertical"), o segundo ImageView seria
mostrado abaixo do primeiro, faça o teste!
Se você colocar mais componentes do que é possível exibir na tela, pode ser que esses
componentes não apareçam, no nosso exemplo anterior as duas ImageView apareceram na tela,
mas e se ao invés de duas fossem quatro, o que aconteceria? Bom, como sobrou um pouco de
espaço entre a segunda imagem e a margem direita, a terceira imagem seria redimensionada para
caber no espaço restante, contudo a quarta imagem não iria aparecer, pois não existe espaço
suficiente no layout para ela, então você só veria três imagens. Para visualizar a quarta imagem
você pode tentar colocar o seu dispositivo na horizontal, dessa forma a largura do layout irá
aumentar e será possível visualizar a outra imagem. Veja como ficariam os dois cenários descritos
na figura abaixo.
40
Competência 03
Figura 6 - a) Representa os quatro elementos onde só três aparecem e o terceiro aparece redimensionado para caber na
tela e a figura. b) Mostra as quatro imagens sendo exibidas com o telefone na horizontal.
Descrição: Existem duas imagens, uma imagem foi chamada de A e a outra de B. A imagem A representa a visão do
celular na vertical onde estão sendo exibidas três imagens. A primeira imagem encontra-se no topo, do lado esquerdo, e
a segunda está no topo do lado direito da primeira e assim por diante. As duas primeiras imagens estão com os
tamanhos originais, a terceira encontra-se com o tamanho reduzido para caber na tela e a quarta imagem não foi
exibida. A imagem B representa o celular na horizontal e mostra quatro imagens. As quatro imagens estão no topo da
tela a partir do lado esquerdo e todas as imagens estão com o mesmo tamanho. Após a quarta imagem ainda sobra um
pequeno espaço para acabar a tela do celular.
3.5 RelativeLayout
A classe RelativeLayout também é bastante utilizada, através dela é possível posicionar
um componente em relação ao outro. Como assim professor? Por exemplo, imagine que você tem
uma imagem no topo da sua tela, usando o RelativeLayout é possível você especificar que um
determinado elemento deve aparecer ao lado dessa imagem (o programador informa se é lado
direito ou lado esquerdo), acima dela ou abaixo dela.
Mas como dizer que um componente deve aparecer ao lado, abaixo ou acima de outro?
Primeiro, você precisa nomear (ou referenciar, que é o termo mais comum) especificando um ID
para cada componente da tela, assim o Android vai entender. Assim, por exemplo, você vai poder
dizer para o Android: eu quero que o componente A fique abaixo do componente B. Vamos ver
alguns atributos importantes que podem ser usados pelo RelativeLayout na tabela a seguir.
ATRIBUTO DESCRIÇÃO
Android:layout_below Posiciona o elemento abaixo de outro.
Android:layout_above Posiciona o elemento acima de outro.
Android:layout_toLeftOf Posiciona o elemento à esquerda de outro.
Android:layout_toRightOf Posiciona o elemento à direita de outro.
Utilizado para definir um espaço (margem) na
Android:layout_marginTop
parte superior (Top) do componente.
41
Competência 03

Android:layout_marginBottom
parte inferior (Bottom) do componente.
Android:layout_marginRight
parte direita (Right) do componente.
Android:layout_marginLeft
parte esquerda (Left) do componente.
Tabela 3 - Atributos do RelativeLayout

Fonte: o autor
Descrição: Tabela com os atributos de RelativeLayout que podem ser usados para posicionar os elementos na tela.
Agora que já aprendemos o conceito de RelativeLayout e vimos os atributos de

posicionamento que podem ter seus componentes internos, vamos ver um exemplo de um
formulário de cadastro com nome e senha e confirmação de senha fazendo o uso do
RelativeLayout.

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
<TextView
Android:id="@+id/txtViewDescricao"
Android:gravity="center"
Android:textSize="20dp"
Android:text="Formulário de cadastro de usuário" />
<TextView
Android:id="@+id/txtViewLogin"
Android:layout_width="155dp"
Android:layout_below="@+id/txtViewDescricao"
Android:layout_marginBottom="20dp"
Android:layout_marginLeft="15dp"
Android:text="Login" />
42
Competência 03
<EditText
Android:id="@+id/editTxtLogin"
Android:layout_alignTop="@+id/txtViewLogin"
Android:layout_toRightOf="@+id/txtViewLogin"
Android:background="@Android:drawable/editbox_background"
/>
<TextView
Android:id="@+id/txtViewSenha"
Android:layout_below="@+id/txtViewLogin"
Android:text="Senha" />
<EditText
Android:id="@+id/editTxtSenha"
Android:layout_alignTop="@+id/txtViewSenha"
Android:layout_toRightOf="@+id/txtViewSenha"
Android:password="true"
/>
<TextView
Android:id="@+id/txtViewConfirmacaoDeSenha"
Android:layout_below="@+id/editTxtSenha"
Android:text="Confirmação de senha" />
43
Competência 03
<EditText
Android:id="@+id/editTxtConfirmacaoDeSenha"
Android:layout_alignTop="@+id/txtViewConfirmacaoDeSenha"
Android:layout_toRightOf="@+id/txtViewConfirmacaoDeSenha"
Android:password="true"
/>
</RelativeLayout>
O código acima gera a imagem da figura 7:
Figura 7 - Imagem de um formulário de cadastro feito a partir da utilização do RelativeLayout.

Descrição: imagem de um formulário de uma aplicação com o celular na vertical. O título do formulário é “Formulário
de cadastro de usuário”. Possui três campos de texto, login, senha e confirmação de senha. O nome login vem logo
abaixo do título do formulário e ao lado existe um campo de texto para o login ser preenchido. Em seguida, o campo
senha e o campo de texto. Abaixo da senha existe o nome confirmação de senha e ao lado o campo de texto.
44
Competência 03
O RelativeLayout é um componente bastante usado e bem flexível. Para adicionar um

novo componente à tela, basta colocá-lo relativo a outro já existente, contudo, perceba que ao
fazer isso você vai aumentando a complexidade da sua tela. Imagine uma tela de cadastro com um
formulário contendo vários campos para o usuário preencher, para adicionar um novo campo ou
um novo componente no RelativeLayout pode não ser uma tarefa fácil, pois a adição de um novo
elemento impacta diretamente na posição de todos os outros podendo, inclusive, quebrar todo o
layout.
3.6 AbsoluteLayout (deprecated ou depreciado)
Agora, vamos falar um pouco da classe AbsoluteLayout. Apesar de ser considerada pelo
Google como uma classe deprecated, ela pode ser encontrada em algumas aplicações legados, ou
seja, aplicações antigas, e que ainda precisam de manutenção. Falaremos de AbsoluteLayout para
explicar o conceito de deprecated e, caso você se depare com esse tipo de classe, você vai saber
como ela funciona.
Deprecated é o nome que se dá a classes que foram descontinuadas, ou seja, classes
que existem, contudo o uso não é recomendado. Elas são consideradas perigosas, pois o seu uso
pode gerar um comportamento diferente do esperado pelo programador. O conceito de deprecated
é o mesmo para qualquer linguagem e não apenas para Android. Você vai encontrar classes
depracted em Java, Android, C/C++, C# e várias APIs que existem no mercado. Sempre que você vir
uma classe com o nome deprecated, não a utilize ou, se ela existir em um sistema que você esteja
dando manutenção, troque-a! Para todo código utilizando uma classe deprecated existe uma nova
forma de fazer aquela funcionalidade de maneira melhor e mais segura.
A classe AbsoluteLayout permite ao programador controlar as coordenadas exatas de
seus componentes, para isso basta especificar sua posição X e Y utilizando os atributos
Android:layout_x e Android:layout_y, respectivamente. Você entente qual é o problema de
especificar as posições exatas de um componente na tela? Cada equipamento tem um tamanho de
tela específico, existem equipamentos com telas menores e outros com telas maiores de diferentes
resoluções. Então, você especificar as coordenadas exatas dos componentes pode ser um problema,
o ideal é que independentemente do tamanho da tela os componentes se ajustem a ela
automaticamente.
45
Competência 03

<AbsoluteLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
<TextView
Android:id="@+id/txtViewDescricao"
Android:layout_x="20px"
Android:layout_y="10px"
Android:textSize="20dp"
Android:text="TÍTULO - Vamos ver agora um exemplo de AbsoluteLayout!" />
<TextView
Android:layout_x="450px"
Android:layout_y="250px"
Android:text="TEXTO 01 - Veja a posição desse texto no meu exemplo (veja o
print) e no seu celular ou emulador." />
</AbsoluteLayout>
46
Competência 03
Figura 8 - Exemplo da utilização do AbsoluteLayout

Fonte: o autor.
Descrição: A imagem mostra dois blocos de texto exemplificando a utilização do AbsoluteLayout onde foi especificado
as coordenadas dos seus elementos. O primeiro está sendo exibido ocupando três linhas a partir do canto superior
esquerdo da tela (na posição x igual 20 pixels e y igual a 10 pixels) e o sendo bloco de texto está sendo exibido abaixado
do primeiro, na posição x igual a 450 pixels e y igual a 250 pixels.
Agora execute o exemplo acima no seu celular ou emulador e verifique a posição dos
textos (TITULO e TEXTO 01). Pode ser que no seu dispositivo ou emulador o TEXTO 01 fique cortado,
pois você pode possuir um dispositivo com a resolução menor que o meu, ou que o TITULO no seu
dispositivo ou emulador tenha a disposição das palavras de forma diferente no seu teste. Pode ser
ainda que ocupe mais linhas ou menos linhas ou que a quebra de linha tenha sido feita de forma
diferente.
3.7 Resumo
Conforme vimos nas sessões anteriores deste capítulo, os gerenciadores de layout são
utilizados para organizar seus componentes internos. Você pode, inclusive, colocar um gerenciador
de layout dentro do outro, ou seja, você pode ter como elemento raiz um LinearLayout, por
exemplo, e dentro dele definir vários outros gerenciadores de layout.
Digamos que você tenha uma tela de formulário e cada item deva ficar um abaixo do
outro e ao final do formulário você tem dois botões, um para confirmar e outro para voltar ou
47
Competência 03
cancelar. Os itens de formulário estão dispostos um abaixo do outro, enquanto os botões deveriam
ficar lado a lado. Como você faria? Quais gerenciadores de layout você usaria? Uma opção é usar
um LinearLayout (como sendo o principal ou raiz ou root) com o orientation vertical para os campos
do formulário e dentro desse componente, por último, inserir outro LinearLayout (secundário)
definindo o atributo orientation como horizontal para os botões ficarem lado a lado. Faça o teste!
É importante você conhecer os diferentes tipos de gerenciadores de layout para
escolher o melhor para atender a sua necessidade. Não existe um componente melhor que o outro,
cada um foi criado para um propósito específico e cabe ao desenvolvedor fazer a escolha correta.
48
Competência 04
4.Competência 04 | Conhecendo os Conceitos de Interface Gráfica

A classe View é a principal classe de layout no Android. Ela é a classe responsável por
desenhar algo na tela. Nesse capítulo será mostrado como trabalhar com recursos de texto, cores,
estilos e imagens que serão exibidos na View e falaremos um pouco também da classe R, usada
para acessar esses recursos em qualquer lugar da aplicação.
4.1 Especificando texto, cores e imagens da aplicação

No Android a classe R é o ponto central de acesso a todos os recursos da aplicação seja
texto, cor ou imagem. Então, se você adicionar um arquivo XML na pasta de layout, para acessá-lo
basta fazer isso por meio da classe R, obedecendo a seguinte sintaxe R.layout.nome_do_arquivo.
De forma similar, outros arquivos também podem ser acessados. Quando um projeto no
Eclipse ou no Android Studio é criado automaticamente, surge o arquivo /res/values/strings.xml.
Esse arquivo pode conter várias mensagens que podem ser recuperadas nos arquivos de layout ou
mesmo nos códigos das classes em Java. Para acessar essas strings nos arquivos XML basta digitar
@string/nome_da_string.
Veja o exemplo do arquivo XML a seguir e veja como acessar o nome da aplicação
definido nele.
<resources>
<string name="app_name">ExemplosDeView</string>
</resources>
<activity
android:name=".MainActivity"
android:label="@string/app_name">
Isso é muito útil! Imagine que o programador defina uma mensagem no seu arquivo
strings.xml e use essa mensagem em diversos pontos da aplicação. Fazendo dessa forma a
mensagem encontra-se centralizada, ou seja, todos os pontos da aplicação fazem referência à
mesma string. Então, caso essa mensagem mude, basta você acessar o arquivo strings.xml e alterá-
49
Competência 04
la e automaticamente todos os locais que fazem referência a essa mensagem estarão com a sua
mensagem atualizada. Se o programador escrever essa mensagem de forma repetida em diversos
pontos, caso a mensagem mude, ele vai ter que mudar em todos os locais, tendo assim mais
trabalho.
A seguir veremos em detalhes como definir arquivos de cores, mensagens e estilos da
aplicação e como acessá-los e fazer uso do seu conteúdo.
4.2 Arquivo com as mensagens da aplicação
Vamos estudar agora mais detalhadamente o arquivo strings.xml criado por padrão
tanto no Eclipse quanto no Android Studio e usado para armazenar as mensagens do projeto.
Também é possível definir outros arquivos de mensagens desde que você siga o padrão e estrutura
esperados.
Por padrão, os arquivos de recursos devem iniciar com a tag <resources> e, no caso dos
arquivos de texto, dentro da tag resources podem existir várias tags do tipo <string>, onde o
programador define uma chave única, usada para acessar a informação e um valor associado a essa
chave. Vamos ver um exemplo:
<resources>
<string name="chave_01">Valor 1</string>
<string name="chave_02">Valor 2</string>
<string name="mensagem_sucesso">Operação realida com sucesso!</string>
<string name="mensagem_erro">Desculpe, ocorreu um erro.</string>
</resources>
Para essas mensagens dentro de uma classe Java basta usar a classe R. No caso, para
exibir a string com a chave chave_01 basta fazer R.string.chave_01. Se for necessário usar alguma
dessas mensagens em um arquivo de layout de tela, ou seja, num arquivo XML, a sintaxe muda um
pouco, então ficaria da seguinte forma @string/mensagem_sucesso.
50
Competência 04
4.3 Arquivo com as cores da aplicação

Da mesma forma que é criado o arquivo strings.xml por padrão, também é criado o
arquivo colors.xml (no Android Studio). Também pode ser criado outro arquivo com outro nome
desde que siga o padrão. Assim como no arquivo de mensagens, o arquivo de cores também deve
conter a tag <resources>, porém ao invés da tag string deve-se usar a tag color, como no exemplo a
seguir:

<resources>
<color name="colorPrimary">#3F51B5</color>
<color name="colorPrimaryDark">#303F9F</color>
<color name="colorAccent">#FF4081</color>
</resources>
Para usar uma cor no arquivo Java podemos usar a classe R obedecendo a sintaxe
R.color.nome_da_cor (ex: R.color.colorPrimary), já para utilizar no arquivo XML de layout a sintaxe
fica da seguinte forma @color/nome_da_cor (@color/colorAccent).
Aplicando esse conhecimento para colocar a cor em um TextView vamos especificar a
sua propriedade background:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="20dp"
android:background="@color/colorPrimary"
android:text="@string/mensagem_sucesso" />
Também poderia ter sido colocado o RGB diretamente no código, por exemplo,
android:background="#3F51B5". Contudo, é sempre recomendado utilizar o recurso em vez de
deixar as cores fixas (e mensagens) fixas no código, pois, como já foi citado, essa centralização
facilita a manutenção e torna a aplicação bem mais simples e fácil de entender.
51
Competência 04
4.4 Criando estilos

Você já fez alguma página em HTML? Se a sua resposta foi sim você com certeza já ouviu
falar em CSS, que são arquivos usados para definir o layout dos componentes de um arquivo HTML.
Assim como no HTML, no Android você também pode definir um arquivo (XML) de estilos, nele é
possível definir de uma só vez um determinado padrão de cor, tipos de fontes, imagens,
backgrounds e muitas outras propriedades e configurações de layout dos componentes da sua
aplicação.
Definido um XML de estilo você pode tanto usá-lo a partir de uma classe Java quanto de
um arquivo de layout. De forma similar ao arquivo de mensagens e cores, o arquivo de estilos deve
iniciar com a tag <resources> e deve ser seguido por tags <style>, onde você define um nome para
posteriormente acessá-lo, da seguinte forma, por exemplo, <style name=”nome_do_estilo”>. A
seguir vamos ver um exemplo real de um arquivo de estilo.
<resources>
<style name="MeuEstilo">
<item name="android:textSize">14dp</item>
<item name="android:textColor">#000000</item>
</style>
</resources>
Para aplicar esse estilo a partir da classe Java, basta acessar a famosa classe R da
seguinte forma R.style.nome_do_estilo. E, para invocar esse estilo em um arquivo XML de layout
basta fazê-lo assim @style/nome_do_estilo. No nosso exemplo, como o nome do estilo é
“MeuEstilo”, basta fazer a substituição da variável nome_do_estilo por “MeuEstilo” para aplicá-lo.
Note que a sintaxe da utilização do arquivo de mensagens, cores e estilos são bem
parecidas, pois todos são arquivos de recursos (por isso devem iniciar com a tag <resources>). Para
usar o arquivo de mensagens você vai fazer R.string, para o arquivo de cores R.color e para o
arquivo de estilo R.style.
52
Competência 04
4.5 Usando temas do Android

Um tema é um estilo que pode ser aplicado a uma activity ou a uma aplicação inteira.
Para customizar você pode usar a propriedade android:theme tanto na tag <application>, para
especificar o tema da aplicação como um todo, quanto na tag <activity>. Você encontra essas tags
no arquivo AndroidManifest.xml. Lembre-se de que sempre que você adicionar uma nova activity
você tem que declará-la nesse arquivo, assim como as permissões de acesso à internet e acesso à
câmera, por exemplo.
A seguir veremos um código representando um arquivo AndroidManifest.xml e sua
respectiva tela principal:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.gilsondeoliveira.exemplosdeview">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true">
<activity
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
</activity>
</application>
</manifest>
53
Competência 04
Figura 9 - Imagem representando o tema especificado no código anterior.

Descrição: Imagem com um label com o valor ExemplosDeView de cor branca e de fundo cinza escuro.
Existem outros temas padrões do Android como Theme.Light ( android:theme =

"@android:style / Theme.Light") e Theme.Dialog ( android:theme =
"@android:style / Theme.Dialog"). O primeiro tem uma aparência mais leve com fundo
branco e o segundo faz com que as telas da aplicação sejam exibidas na forma de janelas de
diálogo. Faça o teste!
Apesar do Android já prover esses diferentes temas, nada impede que o desenvolvedor
crie o seu próprio tema do zero ou mesmo estenda o tema que já existe e altere e adapte as
características desejadas. Para isso, basta você criar um style da seguinte forma:

<resources>
<color name="black">#000000</color>
<style name="MeuTema" parent="@android:style/Theme.Light">

<item name="android:windowBackground">@color/black</item>
</style>
</resources>
Note que foi especificado o tema que foi estendido ( parente = "@
android:style / Theme.Light") e o nome do novo tema (MeuTema) e dentro da tag style
54
Competência 04
é só você customizar o que deseja, no caso, a única coisa que foi mudada foi a cor da janela, ou seja,
ao invés de branca, agora ela será preta. Lembre-se de que se você criou um novo tema e é
necessário especificá-lo na tag <application> ou <activity>, no caso ficaria
(android:theme="@style/MeuTema"). Veja o antes e depois a seguir:
Figura 10 - Imagem mostrando a diferença entre 2 temas, o tema light já provido pelo Android e um tema customizado.
Fonte: o autor.
Descrição: A imagem mostra dois prints da mesma tela usando temas diferentes. O primeiro print mostra a tela com um
tema próprio do Android, disponível para qualquer usuário usar chamado Theme.Light. E a outra imagem mostra a
mesma tela com um tema diferente. Esse tema diferente é o Theme.Light, com o fundo modificado através de uma
customização.
Existem muitas aplicações que usam um tema personalizado, mas também existem
muitas outras que usam alguns dos temas já existentes no Android e que atendem muito bem
muitos projetos. Porém, é bastante importante saber que você pode utilizar os vários temas
disponibilizados pela plataforma e que você pode criar o próprio tema ou customizar um tema
existente.
4.6 Definindo as dimensões dos componentes de layout

É bastante comum na definição de altura e largura de elementos de layout utilizar
valores como match_parent e wrap_content (inclusive já usamos bastante até aqui). Entretanto,
também é possível definir valores específicos, ou seja, valores numéricos seguidos de uma notação
indicando a unidade de medida que está sendo usada como, por exemplo, 20px (pixels) ou 10mm
(milímetros). Assim, é possível controlar exatamente o tamanho do componente.
55
Competência 04
Para definir as dimensões no Android é possível usar as seguintes notações:

NOTAÇÃO DESCRIÇÃO
Especifica o número de Pixels que o componente irá
px (pixels)
ocupar na tela.
Inches significa polegadas, é uma medida baseada
in (inches)
no tamanho físico da tela.
mm (milímetros) Baseado no tamanho em milímetros da tela.
Corresponde a 1/72 de uma polegada, também
pt (pontos)
baseado no tamanho físico da tela.
Essa unidade é relacionada à resolução da tela. Por
dp(Density-independent exemplo, se a resolução da tela é de 160 dpi,
Pixels) significa que cada dp representa 1 pixel em um total
de 160. É a notação mais usada.
É parecido com o dp. Essa unidade é mais
recomendada para utiliza quando se quiser
sp especificar o tamanho de uma fonte, para que ela
seja automaticamente ajustada conforme a
resolução da tela do usuário.
Tabela 4 – Notações
Fonte: o autor
Descrição: Tabela que informa os diferentes tipos de notação para posicionamento e definição de tamanho de
componentes da tela com suas respectivas descrições.
Dentre as notações descritas, é importante perceber que utilizar a notação em pixels é

bastante perigoso, pois, dependendo da resolução do usuário, um componente pode ter tamanhos
diferentes, além de ser muito provável que você tenha problemas com a disposição e exibição
desses componentes. Dessa forma, o uso da notação em pixels não é recomendado e o mais
utilizado é o uso da notação em dp, já que os componentes se ajustam de acordo com a resolução
das telas dos usuários. É importante saber a diferença entre essas notações e quais as mais usadas e
recomendadas, uma vez que o maior problema que um desenvolvedor de aplicativos tem hoje é
criar aplicativos quem funcionem em diversos aparelhos com diferentes telas e resoluções,
incluindo smartphones e tablets.
4.7 Resumo
Nesse capítulo falamos sobre a famosa classe R e como fazemos para criar, definir e
acessar os arquivos que contêm as mensagens, cores e estilos da aplicação. Falamos também da
importância desses arquivos para a manutenção da aplicação através da centralização das
informações.
56
Competência 04
Vimos as diferentes formar de definir as dimensões dos componentes da tela de um

aplicativo Android e a importância de saber qual unidade de medida usar. É importante o
programador ter em mente esses conceitos, pois uma aplicação Android pode rodar em diferentes
tipos de dispositivos com resoluções de telas diferentes e, caso seja usada uma medida de
posicionamento ou tamanho incorreto ou não recomendado, pode ocasionar o mal funcionamento
da aplicação.
57
Competência 05
5.Competência 05 | A Classe View Elementos Básicos
A classe View é a classe base dos componentes visuais, responsável pela criação e
caracterização de qualquer componente gráfico em uma aplicação Android. Tanto os gerenciadores
de layout que vimos no capítulo anterior (que herdam de ViewGroup, que por sua vez herdam de
View) quanto os componentes que veremos a seguir, herdam da classe View e são utilizados para
montar o layout das telas de uma aplicação Android.
Muitas vezes chamamos uma View de componente ou elemento no contexto de uma tela da
aplicação. Toda subclasse de View implementa o método onDraw (Canvas canvas) que é
responsável por desenhar o componente na tela. Geralmente utilizamos componentes já prontos
do próprio Android como TextViews, Buttons, mas você também pode criar o seu próprio
componente, ou seja, sua própria View, basta criar uma classe que herde de View e implementar o
método onDraw (Canvas).
A seguir vamos ver os métodos mais comuns e importantes da classe View. Para a lista
completa de métodos fazer a leitura da documentação
(https://developer.android.com/reference/android/ view/View.html):
MÉTODO DESCRIÇÃO
Método responsável por desenhar o componente de
onDraw(Canvas)
layout na tela.
Método responsável por informar o espaçamento à
esquerda, acima, à direita e abaixo em pixels que
devem ser colocados na tela antes de inserir o
componente. Existe também uma propriedade que
pode ser definida no XML com essa mesma função
setPadding(esquerda, cima, direita, chamada android:padding onde você pode definir um
baixo) único valor e esse mesmo valor ser aplicado a todos os
parâmetros. Caso seja necessário informar um valor
diferente para cada espaçamento, basta usar os
atributos android:paddingLeft, android:paddingTop,
android:paddingRight e android:paddingBottom,
respectivamente.
58
Competência 05
O método setVisibility pode receber três valores

definidos pelas constantes View.VISIBLE,
View.INVISIBLE e View.GONE. A primeira constante,
como o nome já diz, faz com que o componente seja
exibido na tela, já as outras duas INVISIBLE e GONE
fazem com que o componente não seja exibido. A
diferença entre elas é que a constante
View.INVISIBLE não exibe o elemento, mas deixa o
espaço que ele usaria reservado na tela (em branco),
setVisibility(visibility)
enquanto que a constante View.GONE faz com que se
remova tanto o elemento quanto o espaço que ele
usaria da tela. No XML o método equivalente é o
android:visibility que pode receber os valores: visible,
invisible e gone. Por padrão, quando você criar uma
View ela será exibida na tela sem a necessidade de
ser especificada a visibilidade, contudo, esse método
é bastante usado quando se deseja criar telas
dinâmicas, principalmente formulários.
São métodos chamados pelo Android quando o
usuário pressiona uma tecla. Esses métodos são
onKeyDown(codigoDaTecla, evento) e
bastante usados para criar atalhos na aplicação. Você
onKeyUP(codigoDaTecla, evento)
também pode sobrescrever esses métodos na sua
activity para capturar as teclas digitadas pelo usuário.
Tabela 5 - Principais métodos da classe View

Fonte: o autor
Descrição: Tabela responsável por mostrar os principais métodos da classe View com seus respectivos parâmetros e
apresentar uma descrição do funcionamento dos métodos.
5.1 TextView
A classe TextView é uma das subclasses mais simples da classe View. Ela é responsável
por desenhar um texto (também chamado de label) na tela. Vamos ver alguns exemplos a seguir,
diferentes formas de usar um label:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
59
Competência 05
android:text="Hello World!" />
<TextView
android:autoLink="web"
android:text="http://www.google.com" />
<TextView
android:background="#0000ff"
android:textColor="#ffffff"
android:text="Texto branco (text_color) e fundo azul (background)" />
</LinearLayout>
Figura 11 - Exemplo de três TextViews com atributos diferentes.

Fonte: o autor.
Descrição: a imagem mostra três textos exemplificando o uso do componente TextView. No texto está escrito um Hello
World! Simples, sem nenhuma customização. O segundo mostra um link web www.google.com de cor rosa, que ao ser
clicado abre um browser. E o terceiro é um TextView em que a cor do texto foi modificada para branco e a cor do fundo
para azul.
60
Competência 05
5.2 EditText
A classe EditText é utilizada quando se deseja criar um campo onde o usuário irá digitar
informações de texto. Esse texto pode ser um texto normal (letras mais números), apenas números,
apenas letras ou mesmo senhas.
A classe EditText é bastante utilizada na criação de formulários. Vamos ver um exemplo
clássico da sua utilização através de um formulário de login e senha:

android:orientation="vertical"
android:layout_height="match_parent">
<TextView
android:text="Login:"/>
<EditText
android:textSize="20dp"/>
<TextView
android:text="Senha:"/>
<EditText
android:password="true"
android:textSize="20dp"/>
61
Competência 05
</LinearLayout>
Figura 12 - Exemplo de um formulário com utilização de dois campos de texto representados por dois EditText.
Fonte: o autor.
Descrição: a imagem mostra um texto com o valor Login: no canto esquerdo superior, abaixo está um campo de texto
que permite o usuário digitar o seu login. Abaixo do campo de texto do login está um texto com o valor Senha: e abaixo
do texto senha existe o seu respectivo campo de texto para o usuário digitar a senha.
Note que o segundo EditText representa um campo de senha definido pelo atributo
android:password que é usado para camuflar os caracteres que são escritos.
5.3 Button e ImageButton

Tanto a classe Button quanto a ImageButton são usadas para criação de botões. A
diferença como o próprio nome já diz, é que a classe ImageButton permite que esse botão seja
representado através de uma imagem.
A seguir veremos um exemplo com uma tela com dois botões, um Button e um
ImageButton.

android:orientation="vertical" android:layout_width="match_parent"
62
Competência 05
<Button
android:id="@+id/btn01"
android:text="Botão 01"/>
<ImageButton
android:id="@+id/imgBtn02"
android:src="@drawable/android_mini2"/>
</LinearLayout>
A classe MainActivity é responsável por controlar os eventos de clique dos botões,

tanto do ImageButton, quanto do Button.
public class MainActivity extends Activity{
@Override
setContentView(R.layout.button_image_button_layout);
Button btn01 = (Button) findViewById(R.id.btn01);

btn01.setOnClickListener(new View.OnClickListener() {
@Override
Toast.makeText(MainActivity.this, "Classe Button",
Toast.LENGTH_LONG).show();
}
});
ImageButton imgBtn02 = (ImageButton) findViewById(R.id.imgBtn02);

imgBtn02.setOnClickListener(new View.OnClickListener() {
@Override
63
Competência 05
Toast.makeText(MainActivity.this, "Classe ImageButton",

Toast.LENGTH_LONG).show();;
}
});
}
}
Observe que a imagem exibida no ImageButton é informada através do preenchimento

do atributo src, que informa onde a imagem se encontra (/app/src/main/res/drawable), dentro do
seu projeto. Você também poderia ter definido a imagem dinamicamente na classe MainActivity, a
imagem poderia ser uma imagem externa, da web (usar o método setImageURI(uri)).
A imagem a seguir mostra o exemplo anterior rodando e sendo clicado no ImageButton.
Figura 13 - Imagem representando a utilização da View Button e de um ImageButton

Fonte: o autor.
Descrição: a imagem exibe dois botões, um abaixo do outro. O primeiro botão é chamado de Botão 01 e o segundo
botão possui uma imagem como conteúdo.
Mais adiante, ainda neste capítulo veremos outros detalhes sobre a utilização da classe
Toast, responsável pela exibição de mensagens.
64
Competência 05
5.4 CheckBox
Um Checkbox no Android é um componente que, não só no Android como de modo
geral, pode possuir o estado de marcado ou desmarcado. Geralmente é usado quando se quer fazer
uma escolha mútua, que não seja mutuamente exclusiva. Por exemplo, imagine que existe um
formulário que pergunta quais tecnologias você domina ou conhece e existem várias opções:
Objective C, Java, Ruby, C/C++, se você conhecer mais de uma tecnologia o ideal é que o
componente usado para representar essas opções seja um checkbox. Para ilustrar esse cenário, veja
o exemplo a seguir.

android:orientation="vertical" android:layout_width="match_parent"
<TextView
android:text="Assinale as tecnologias que você já trabalhou:"/>
<LinearLayout
<CheckBox
android:text="Java"/>
<CheckBox
android:text="C/C++"/>
<CheckBox
65
Competência 05
android:text="C#"/>
<CheckBox
android:text="JavaScript"/>
</LinearLayout>
</LinearLayout>
O id definido no arquivo XML é usado para recuperar o checkbox no código Java,

dessa forma é possível verificar se o checkbox está marcado ou não. Isso é feito através do método
isChecked().
CheckBox chkBox = (CheckBox) findViewById(R.id.checkboxJava);

boolean checkboxSelecionado = chkBox.isChecked();
5.5 RadioButton
O componente RadioButton é usado quando dentre algumas opções o usuário só pode
escolher uma, ou seja, as opções são mutuamente exclusivas, não sendo possível ter mais de uma
resposta para a mesma pergunta. Por exemplo, o RadioButton é o componente mais usado quando
se deseja saber o sexo de um usuário, este pode ser masculino ou feminino, ou quando se quer
fazer uma pergunta cuja resposta é sim ou não.

<TextView
android:id="@+id/lblSexo"
66
Competência 05
android:text="Sexo:"/>
<RadioGroup
android:id="@+id/radioGroup"
android:layout_height="match_parent"
android:orientation="horizontal">
<RadioButton
android:id="@+id/radioM"
android:text="Masculino"/>
<RadioButton
android:id="@+id/radioF"
android:text="Feminino"/>
</RadioGroup>
</LinearLayout>
O RadioGroup indica que seus elementos internos são mutuamente exclusivos, quando
você escolher um RadioButton o outro vai ser automaticamente desmarcado. Para verificar se o
RadioButton está marcado você pode usar o método do RadioGroup chamado
getCheckedRadioButtonId() da seguinte forma:
RadioGroup radioGroup = (RadioGroup)findViewById(R.id.radioGroup);

boolean radioM_Checked = R.id.radioM == radioGroup.getCheckedRadioButtonId();
Caso o valor de radioM_Checked seja true indica que o RadioButton com o valor
Masculino está selecionado, da mesma forma pode-se fazer para o outro RadioButton. Vamos ver
como fica o layout do nosso exemplo:
67
Competência 05
Figura 14 - Exemplo da utilização do componente de RadioButton com o sexo: Masculino ou Feminino. Que são
mutualmente exclusivos.
Fonte: o autor.
Descrição: a imagem mostra um texto no canto superior esquerdo com o valor Sexo: e abaixo estão dois RadioButton
usadoS, geralmente, para representar escolhas que são mutuamente exclusivas, no caso os seus valores são masculinos
e femininos, que se encontram lado a lado na imagem.
5.6 Spinner
A classe Spinner no Android é responsável por desenhar na tela um combo box, ou seja,
um conjunto de opções. Para que o combo seja preenchido com uma lista é necessário a
implementação da classe SpinnerAdapter.
A seguir vamos ver um exemplo de um combo com uma lista de países e ao selecionar o
país a aplicação irá exibir a sua bandeira.

<TextView
android:text="Selecione um país:"/>
<Spinner
android:id="@+id/combobox"
68
Competência 05
android:layout_height="wrap_content"/>
<ImageView
android:id="@+id/imgPais"
android:layout_height="match_parent" />
</LinearLayout>
public class MainActivity extends Activity{
private int[] imagens = {R.drawable.brasil, R.drawable.eua,

R.drawable.inglaterra, R.drawable.franca,
R.drawable.canada};
private String[] paises = new String[]{"Brasil", "Estados Unidos",

"Inglaterra", "França", "Canada"};
@Override
setContentView(R.layout.spinner_layout);
final ImageView imgPais = (ImageView)findViewById(R.id.imgPais);

Spinner combobox = (Spinner) findViewById(R.id.combobox);
ArrayAdapter adaptador = new ArrayAdapter<String>
(this, android.R.layout.simple_spinner_item, paises);
adaptador.setDropDownViewResource(android.R.layout.simple_spinner_item);
combobox.setAdapter(adaptador);
combobox.setOnItemSelectedListener(new
AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view,
int position, long id) {
69
Competência 05
imgPais.setImageResource(imagens[position]);
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
}
});
}
}
Uma observação a ser feita a respeito desse exemplo é que, para exibir a imagem das
bandeiras corretamente, você primeiro deve baixá-las e colocá-las na pasta drawable. Sempre que
você quiser exibir uma imagem no seu app, você pode colocá-la nessa pasta e, para ter acesso a
essa imagem, basta digitar R.drawable.NOME_DA_IMAGEM sem a extensão do arquivo (.jpg, .png,
etc.). No caso, para você conseguir visualizar as diferentes bandeiras do exemplo, você teria que
fazer o download das imagens, colocar na pasta drawable e o nome das imagens teriam que ser
iguais ao nome correspondente aos elementos do array de inteiros.
Veja na figura 15 a seguir como ficou o nosso exemplo:
Figura 15 - Imagem que representa um exemplo da utilização de um Spinner que, ao mudarmos o nome do
país, muda também a imagem da bandeira que o representa.
Fonte: o autor.
70
Competência 05
Descrição: a imagem mostra dois prints de uma mesma tela, em ambas existe um texto com o valor
Selecionar um país: logo abaixo está um Spinner, também conhecido como ComboBox, que representa um
conjunto de opções, no caso um conjunto de países. Na primeira tela está selecionado no Spinner o valor
Brasil e abaixo está sendo exibida a bandeira. Na outra imagem está selecionado o país Canada e abaixo está
sendo exibida a bandeira canadense.
5.7 ProgressDialog
Você já deve ter visto muitas vezes no momento de abrir um software no carregamento ou no
processo de instalação a seguinte mensagem: “Por favor, aguarde...” ou “Aguarde, essa operação
pode demorar alguns minutos...”. No Android existe uma classe especialmente para isso, a classe
ProcessDialog, filha da classe Dialog.
A seguir veremos um exemplo bastante simples exibindo a mensagem “Por favor, aguarde...”.
ProgressDialog dialog = new ProgressDialog(this);

dialog.setTitle("Título da ProgressBar");
dialog.setMessage("Por favor, aguarde...");
dialog.setIndeterminate(true);
dialog.setCancelable(true);
dialog.show();
Colocando esse trecho de código acima, no onCreate da sua activity, será exibida uma janela de
progresso com o título e mensagem informados. A classe ProgressDialog é bastante usada quando
se deseja fazer um processamento que não se sabe quanto tempo irá durar, ou seja, o tempo é
indeterminado. Por exemplo, imagine que você queira que a sua aplicação exiba/carregue ou faça
um download de um documento PDF ou de uma imagem que se encontra na internet (o tempo de
resposta de requisições feitas utilizando a internet é indeterminado, depende muito da rede do
usuário). Enquanto esse processo está sendo executado, um alerta de progresso deve ser exibido na
tela (OBS: caso você esteja fazendo alguma operação que use a internet é necessário adicionar a
permissão no arquivo AndroidManisfest.xml).
71
Competência 05
Figura 16 - Exemplo da utilização do componente ProgressDialog

Fonte: o autor.
Descrição: a imagem mostra uma tela com um ProgressDialog sendo utilizado. No fundo da tela, por trás, existe o texto
“EXECUTANDO UM PROGRESS_DIALOG” e por cima está o ProgressDialog, que é uma caixa com o título “Título da
ProgressBar”, e abaixo está o texto Por favor, aguarde...
5.8 Toast
A classe Toast é usada para exibir alertas para o usuário, inclusive, nós já a usamos algumas vezes
aqui no nosso material para exibir algumas mensagens de feedback para o usuário. Normalmente,
os alertas exibidos duram pouco tempo, para isso utiliza-se a constante Toast.LENGTH_SHORT. Para
o alerta demorar mais, pode-se utilizar a constante Toast.LENGTH_LONG. A forma mais simples de
exibir um alerta é usando o método Toast.makeText(contexto, mensagem, tempo_de_duração).
A seguir veremos um exemplo da utilização da classe Toast:
Toast alerta = Toast.makeText(this, "Texto da mensagem", Toast. LENGTH_

LONG);
Esse tipo de alerta é o mais simples possível, caso você queira exibir um alerta mais complexo, com
72
Competência 05
uma interface gráfica mais rebuscada e customizada, você pode desenvolver a sua view e usar o
método toast.setView(view) para especificar a interface que você criou. Observe que o método
setView recebe uma View, e todos os elementos que vimos nesse capítulo e no anterior (o de
gerenciadores de layout) são filhos da classe View.
5.9 Resumo
Nesse capítulo vimos muitos elementos de layout que fazem parte da classe View, contudo, existem
vários outros. O importante é você conhecer os principais e à medida que você for tendo mais
experiência e for necessitando de elementos mais complexos você consultar a documentação ou
buscar outros exemplos e tutorias na internet que ajudem a usar esses novos elementos.
73
Competência 06
6.Competência 06 | Banco de Dados, SharedPreferences e APIs

Importantes
Neste capítulo falaremos sobre um possível banco de dados que podemos usar na nossa
aplicação Android, aprenderemos o conceito de SharedPreferences, o que é e pra que serve e
abordaremos algumas APIs importantes do Android que nos permite visualizar mapas, GPS e enviar
notificação.
6.1 Banco de dados

O Android tem integração com o SQLite que é um banco de dados bastante poderoso e
leve. Ele permite que a aplicação armazene as informações da sua aplicação normalmente. Embora
o armazenamento de informações por intermédio de um banco de dados seja a forma mais comum,
o Android possibilita que você também armazene suas informações em arquivos ou através de
estruturas simples do tipo chave valor.
6.2 SQLite
O SQLite pode ser baixado no site www.sqlite.odrg.
Quando você cria um banco de dados no SQLite ele fica na pasta:
/data/data/nome_do_pacote/databases/
Existem várias formas de se criar a sua base de dados. Você pode utilizar a API do
próprio Android para o SQLite, ou você pode usar um cliente do SQLite como o SQLite Expert
Personal ou qualquer outra ferramenta que se integre com o SQLite e permita você criar a sua base
de dados. Essas ferramentas também possuem interfaces gráficas que auxiliam na manipulação do
seu banco de dados ajudando a fazer select, insert, delete, criação de tabelas dentre outros
comandos, e utilizando o aplicativo do SQLite pelo console do emulador. Para mais detalhes acesse
www.sqlite.org/cli.html.
Por exemplo, para criar uma base de dados com o nome “ex1” e uma tabela chamada
“tbl1” usando o sqlite3, por linha de comando, basta digitar:
74
Competência 06
6.3 Preferências do usuário
Além da utilização do banco de dados para salvar algumas informações do usuário,

também é bastante usada uma classe chamada SharedPreferences. Essa classe funciona como uma
estrutura de dados chamada HaVshTable (ou tabela hash) que é uma estrutura do tipo chave valor.
Os valores armazenados são automaticamente persistidos para uma determinada aplicação. Caso a
aplicação seja encerrada e aberta posteriormente os valores armazenados continuaram salvos e
serão recuperados na próxima execução da sua aplicação.
Para recuperar a classe SharedPreferences basta chamar o método
getSharedPreferences (preferencia, modo). Vamos ver como fazer para armazenar as informações
no sharedPreferences e como recuperar essas informações.
O exemplo a seguir mostra como recuperar a classe SharedPreferences e como
recuperar o atributos “status”, caso não tenha sido atribuído, o valor padrão será false.
SharedPreferences sp = getSharedPreferences("NomeDaMinhaApp", 0);

boolean status = sp.getBoolean("status", false);
Para preencher o valor da variável “status”, no caso por ser um booleano, para se
especificar o valor usa-se o método putBoolean, vamos ver um exemplo:
SharedPreferences sp = getSharedPreferences("NomeDaMinhaApp", 0);

SharedPreferences.Editor editor = sp.edit();
editor.putBoolean("status", true);
editor.commit();
75
Competência 06
Note que no final existe o método commit(). Esse método é usado para efetuar a
modificação dos valores da classe SharedPreferences. Sem esse método as modificações não serão
aplicadas. Nesses dois exemplos foi mostrado como recuperar e salvar uma variável do tipo
booleano (true ou false), contudo você poderia salvar e recuperar variáveis de outros tipos como
mostra a figura 17.
Figura 17 – Seleção do método putBoolean.

Fonte: o autor.
Descrição: a imagem mostra como selecionar o método putBoolean que o SharedPreferences utiliza, além de outros
disponíveis.
Mesmo que você encerre a aplicação com valores de SharedPreferences já ajustados,

essas informações não serão perdidas, elas permanecem no aparelho e, quando a aplicação for
reiniciada, elas irão conter os valores salvos anteriormente.
Imagine que você tem uma aplicação como mostra a figura 18:
Figura 18 – Seleção da opção Orange.

Fonte: o autor.
Descrição: a imagem mostra como selecionar a opção Orange através do CheckBox.
Se no evento de clique do checkbox você salvar o status de clicado ou não na sua

SharedPreference, quando você fechar a aplicação e abrir novamente ele vai ter essa informação
salva, no caso, o checkbox já viria marcado. É bastante comum quando você abrir uma aplicação
76
Competência 06
você já vir logado, não é necessário você logar toda vez, pois muitas aplicações armazenam ou um
arquivo com um token de autenticação ou armazenam esse token no seu sharedPreferences e esse
token é usado nas demais requisições e validam o usuário logado. Esse armazenamento de token de
autenticação é uma prática bastante difundida, pois evita que sejam armazenados o login e senha
do usuário por questões de segurança.
6.4 API de Mapas

Existem muitas aplicações que usam mapas e chamam bastante a atenção dos usuários.
Essas aplicações são geralmente integradas com o Google Maps e algumas utilizam, inclusive,
recursos de GPS do dispositivo.
Com a utilização da API do Google Maps para Android é possível dar zoom no mapa e
escolher o tipo da visualização, se é rua ou satélite. É possível também desenhar imagens de
marcadores informando a localização de objetos ou mesmo do usuário na tela.
Para desenhar um mapa na tela utiliza-se a classe MapView (V1 da API de mapas,
descontinuado em dezembro de 2012), que é uma subclasse de View. Para baixar essa API é
necessário abrir o Android SDK Manager e fazer o download de um pacote chamado de Google
APIs. Ao fazer isso, você já pode utilizar a classe MapView no seu XML de layout.
Na V2 da API de mapas para fazer uso das suas funcionalidades é preciso baixar o pacote
do Google Play Services que se encontra também no Android SDK Manager. Além disso, é preciso
configurar o AndroidManifest.xml para dar acesso à internet e para receber as informações e os
dados da API de mapas. Após o registro das permissões, é preciso obter a chave dos mapas no
Google Cloud Plataform, onde o usuário obtém uma chave usada pelo Google para identificar qual
aplicação está requisitando as informações do mapa. Sem essa chave o mapa não é exibido.
6.5 GPS
A API de GPS utiliza o hardware do dispositivo para informar a localização do usuário.
Para utilização da API é preciso adicionar as permissões ACCESS_FINE_LOCATION e
ACCESS_COARSE_LOCATION no arquivo AndroidManifest.xml.
Para obter a localização do usuário através do GPS, basta implementar a interface
LocationListener na mesma activity que você está utilizando o mapa. Existem vários métodos nessa
77
Competência 06
interface, mas de um modo geral o método onLocationChanged(location) é o mais usado, ele é

disparado quando a localização do usuário muda.
6.6 Resumo
Neste capítulo, vimos diferentes formas de armazenar informações no Android e vimos
diferentes APIs que podem ser usadas nos mais diversos tipos de aplicações. Existem muitas outras
APIs, aqui só vimos algumas delas como possibilidades de enriquecermos ainda mais nossas
aplicações android, pois é importante saber que elas existem para caso você precise no futuro,
desta forma você já sabe como procurar e saber que existe algo que possa suprir sua necessidade
naquele momento.
78
Competência 07
7.Competência 07 | Publicando Aplicação na Google Play

Neste capítulo, veremos os passos necessários para publicar um aplicativo na loja do
Google, a famosa Google Play (play.google.com).
7.1 Versionamento da sua app

A primeira coisa que você tem que fazer antes de publicar o seu aplicativo é definir ou
atualizar a sua versão no arquivo AndroidManifest.xml da seguinte forma:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.gilsondeoliveira.publishingapp"
android:versionCode="1"
android:versionName="0.0.1-beta">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity
android:theme="@style/AppTheme.NoActionBar">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
</activity>
</application>
</manifest>
A propriedade versionCode é utilizada para atualizar a versão da aplicação no Google

Play, seu número deve ser sempre superior ao anterior. Já a tag android:versionName indica ao
79
Competência 07
usuário qual a versão da aplicação que ele possui instalada. Dessa forma, o usuário pode ter uma
versão anterior à versão da loja e ele pode identificar essa desatualização pelo nome da versão
apresentado através da tag versionName.
Caso você esteja usando o Android Studio, existe um arquivo chamado build.gradle que
fica em Gradle Scripts que contém as configurações de build da sua APK, nele, assim como no
AndroidManifest.xml você também pode definir o versionCode e o versionName da sua aplicação.
Existindo esse arquivo (no caso de você estar usando o Android Studio), ele tem prioridade sobre as
configurações de build do projeto, ou seja, caso você defina o versionName e versionCode no
AndroidManifest, mas o seu projeto também tenha o arquivo build.gradle, as informações que
serão usadas serão as informações contidas no build.grade, como mostra a figura 19. A seguir,
veremos onde fica esse arquivo na estrutura de um projeto criado pelo Android Studio e veremos
também o seu conteúdo, como mostra a figura 20.
Figura 19 - Estrutura de um projeto Android criado pelo Android Studio e localização do arquivo build.gradle
Fonte: o autor.
Descrição: a imagem mostra a estrutura de pastas de um projeto em Android criado no Android Studio e mostra onde o
arquivo build.gradle está localizado.
80
Competência 07
Figura 20 - Nome da versão e do código especificados no arquivo gradle.build

Fonte: o autor.
Descrição: a imagem mostra o conteúdo do arquivo gradle.build e está destacando o valor dos atributos versionCode
que está igual a 1 e o valor do atributo versionName que está igual a “1.0”.
7.2 Compatibilidade para instalação da aplicação
Outra configuração importante a que o desenvolvedor deve atentar na hora de gerar

uma build ou versão da sua aplicação é a compatibilidade da versão que ele deseja que a aplicação
rode. Dessa maneira, existe uma propriedade chamada minSdkVersion que especifica a menor
versão que a aplicação vai suportar, ou seja, é a versão a partir da qual a sua aplicação pode ser
instalada. Se a versão do Android for inferior a ela, a Google Play não vai permitir que o usuário
instale a aplicação. Existe também o atributo targetSdkVersion que especifica a última versão que a
sua aplicação pode ser instalada. Os exemplos a seguir mostram como especificar o minSdkVersion
e targetSdkVersion no AndroidManisfest e no arquivo build.gradle, respectivamente exibidos na
figura 21.
81
Competência 07
<manifest
...>
...
<uses-sdk android:minSdkVersion="10" android:targetSdkVersion="21" />
</manifest>
Figura 21 - Especificar as propriedades minSdkVersion e targetSdkVersion no arquivo build.gradle

Fonte: o autor
Descrição: imagem do conteúdo do arquivo build.gradle destaca o valor dos atributos minSdkVersion e
targetSdkVersion que estão com os valores 15 e 23 respectivamente.
7.3 Assinando a aplicação com um certificado digital
Para instalar a aplicação em um celular real ou no emulador é preciso que a sua

aplicação esteja assinada digitalmente. Quando você compila usando o modo Debug esse processo
é feito automaticamente pela sua IDE, seja ela o Eclipse ou Android Studio, de forma transparente.
Contudo para assinar uma APK para ir para a Google Play é necessário você gerar o seu próprio
certificado através do JDK, dessa forma você terá a sua chave privada e com ela poderá assinar APK
durante o build.
82
Competência 07
Existem vários artigos na internet mostrando como assinar a sua APK, seremos bem
objetivos aqui. Para gerar o seu certificado você precisa rodar um comando usando uma ferramenta
do Java chamada keytool. Essa ferramenta encontra-se na pasta bin da JDK que está instalada no
seu computador, por exemplo, C:\Program Files\Java\jdk1.8.0_101\bin, lá você encontra um
arquivo chamado keytool.exe. Abra o prompt de comando do Windows ou o Terminal do Linux ou
do seu Mac, e vá até essa pasta. Quando chegar nesse diretório digite o seguinte no terminal:
keytool –genkey –v –keystore nome_da_sua_chave.keystore –alias

nome_da_sua_chave –keyalg RSA –validity 10000
Observação: lembre-se de executar o terminal como administrador do sistema, pois a

chave será criada na mesma pasta. E por ser uma pasta do sistema, se você executar o terminal
normalmente pode ser que dê um erro de permissão negada ao tentar criar a chave.
Ao digitar o comando para a criação da chave privada, além de ser pedida uma senha
para o seu certificado (certifique-se de que você se lembrará dessa senha posteriormente), é pedida
uma série de outras informações como seu nome, unidade organizacional, sua empresa, localidade,
dentre outras, de acordo com a imagem abaixo. Ao final desse processo o seu certificado é criado.
Observe este processo na figura 22.
83
Competência 07
Figura 172 - Exemplo de como executar o comando e preencher as informações para geração de um certificado para
assinar a APK Android.
Fonte: o autor
Descrição: a imagem mostra o prompt do Windows, onde foi digitado o comando para a geração do certificado e as
demais perguntas que se seguem para que o certificado seja criado com sucesso.
Se você tiver usando o Android Studio, existe uma forma mais amigável de gerar esse
certificado. Basta ir no menu clicar em Build e depois em Generate Signed APK... Irá abrir uma
janela como a da figura 23:
Figura 183 - Gerando um certificado pelo Android Studio

Fonte: o autor.
Descrição: a imagem mostra a tela Generate Signed APK do Android Studio com todos os campos em branco antes do
certificado ser criado.
Basta você clicar no botão Create new... e preencher as informações e seu certificado
será criado.
Agora que temos a nossa chave privada podemos assinar a nossa aplicação.
84
Competência 07
7.4 Assinando a aplicação para publicá-la no Google Play
Após criar o certificado, basta usá-lo para assinar a sua APK. Mas como fazer isso? Para
assinar a sua APK usando o certificado que você criou, basta importá-lo no Android Studio clicando
no botão Choose existing..., digitar a sua senha e gerar a sua APK assinada clicando no botão Next,
como exibido na figura 24.
Figura 194 - Assinando APK com um certificado existente

Fonte: o autor.
Descrição: a imagem mostra a tela Generate Signed APK do Android Studio depois do certificado ser adicionado com
todas as informações preenchidas.
Quando você clicar no botão Next vai aparecer uma janela pedindo para você informar
o local onde você deseja que a sua APK assinada seja gerada, ao final do processo basta clicar em
Finish como mostra a figura 25.
85
Competência 07
Figura 205 - Processo final para geração da sua APK assinada

Fonte: o autor
Descrição: a imagem mostra a tela Generate Signed APK no seu estágio final, com o Build Type com
o valor release selecionado.
7.5 Publicando a sua aplicação na Google Play

Para publicar a sua aplicação na Google Play é um processo bem simples, basta entrar
no site https://play.google.com/apps/publish/. Se você já estiver logado já abrirá a página da
figura a seguir, caso contrário você precisará logar com a conta do Google, a qual a sua aplicação
estará associada. Veja a figura 26 a seguir.
86
Competência 07
Figura 216 - Tela de aceitação do contrato como desenvolvedor da Google Play

Fonte: o autor.
Descrição: a imagem mostra uma tela com informações da conta da Google do usuário que está logado, com o valor a
ser cobrado pela licença de desenvolvedor, com os termos de uso e um botão para continuar o pagamento.
São quatro passos para concluir o seu cadastro de desenvolvedor, o primeiro é fazer o
login com uma conta Google, depois aceitar os termos de uso do contrato (disponível em
https://play.google.com/about/developer-distribution-agreement.html), pagar 25 dólares e, por
fim, fornecer os detalhes da conta como é exibido na figura 27.
Figura 227 - Tela de pagamento, basta inserir o cartão de crédito e pagar 25 dólares.
Fonte: o autor
Descrição: a imagem mostra a tela com as informações do cartão de crédito juntamente com o valor da licença para o
pagamento.
Depois do pagamento confirmado e de fornecer as suas informações você já pode fazer

a publicação da sua aplicação. Basta preencher um formulário com uma breve descrição da sua
aplicação, enviar alguns screenshots. Depois de preencher as informações do APP basta fazer o
upload da APK assinada, escolher a categoria da aplicação e informar se ela é paga ou gratuita (em
aplicações pagas o Google Play fica com 30% do valor da aplicação por transação e o desenvolvedor
com os 70% restantes).
87
Competência 07
Depois de publicar a aplicação ela será disponibilizada quase que imediatamente na

Google Play e estará pronta para ser instalada. Lembre-se de que a cada nova versão da aplicação
que você subir é preciso incrementar os parâmetros do versionCode e do versionName, como falado
anteriormente. Assim, os usuários serão notificados sobre a existência de uma nova versão e que
eles podem fazer a atualização quando desejarem.
88
Conclusão
Conclusão
Finalizamos a disciplina de Android avançado do nosso curso. O objetivo desse curso foi
mostrar uma visão mais detalhada e aprofundada dos assuntos já abordados na disciplina básica de
Android, além de mostrar novos conceitos.
Alguns conceitos aqui foram abordados de forma bastante detalhada e aprofundada
como Activity e Intent, por exemplo, já outros foram abordados de forma mais superficial para você
saber que existe e quando alguém falar com você ou você precisar de algo você já saber como
pesquisar.
Muito do que aprendemos aqui requer dedicação e prática, pois é preciso entender o
conceito e praticá-lo para saber e ver com funciona. Existem muitos tutoriais na internet e bons
livros como o “Google Android: aprenda a criar aplicações para dispositivos móveis” de Ricardo
Lecheta, que é espetacular tanto no que se refere ao conteúdo quanto à didática.
Caso algum conceito não tenha ficado muito claro, volte e o releia, ou procure outra
fonte para entendê-lo e amadurecê-lo. É sempre bom você ter mais de um material de estudo, pois
caso você não entenda da forma que um professor escreveu um determinado conceito pode ser
que outro escreva de forma mais clara, numa linguagem mais natural.
Lembre-se de quanto mais você praticar e exercitar, mais o trabalho irá parecer fácil e
natural e mais experiente você ficará. Não perca tempo, pratique e durante esse processo divirta-
se!
Um grande abraço e boa sorte! =)
89
Referências
Referências
LECHATA, Ricardo R. Google Android: aprenda a criar aplicações para dispositivos móveis com o Android
SDK. São Paulo: Novatec, 2015.
90
Minicurrículo
Minicurrículo do Professor
Gilson de Oliveira
É formado em Ciência da Computação pela Universidade Federal de
Pernambuco, com mestrado em Ciência da Computação pela UFPE na
área de sistemas distribuídos. Atualmente é analista de sistemas senior
na empresa TECON Suape. Possui experiência com diversas tecnologias
(Android, Objective C, Java Web, .NET, AngularJS, dentre outras) e
plataformas (Desktop, Web, Mobile).
91

Dispositivos Móveis

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Dispositivos Móveis

Enviado por

Direitos autorais:

Formatos disponíveis

Programação para

Curso Técnico em Desenvolvimento de Sistemas

Revisão de Língua Portuguesa

Conteúdo produzido para os Cursos Técnicos da Secretaria Executiva de Educação

Inclui referências bibliográficas.

1. Engenharia de Software. 2. Dispositivos Móveis. I. Oliveira, Gilson de. II. Título.

Elaborado por Hugo Carlos Cavalcanti | CRB-4 2129

Índice para catálogo sistemático:

1.Competência 01 | Apresentando a Classe Activity, Ciclo de Vida e Tipos de Activity ........................ 8

1.2 Ciclo de vida de uma Activity ..................................................................................................................... 9

1.3 Navegação entre activities ....................................................................................................................... 14

1.3.1 Navegação simples de uma activity para outra .................................................................................... 14

1.3.2 Navegação entre telas com passagem de parâmetros ......................................................................... 16

1.4 ListActivity – uma activity diferente......................................................................................................... 18

2.Competência 02 | Intent ................................................................................................................... 22

2.1 Abrindo o browser e acessando um site específico ................................................................................. 22

2.2 Fazendo uma ligação para um número de telefone ................................................................................ 25

2.4 Acessando contatos da agenda ................................................................................................................ 29

2.6 Intent – Resumo ....................................................................................................................................... 33

3.Competência 03 | Conceitos de Interface Gráfica ............................................................................ 34

3.1 A classe View ............................................................................................................................................ 34

3.2 ViewGroup e gerenciadores de layout ..................................................................................................... 34

3.3 FrameLayout ............................................................................................................................................ 35

3.4 O famoso LinearLayout ............................................................................................................................ 39

3.5 RelativeLayout .......................................................................................................................................... 41

3.6 AbsoluteLayout (deprecated ou depreciado) .......................................................................................... 45

4.Competência 04 | Conhecendo os Conceitos de Interface Gráfica .................................................. 49

4.1 Especificando texto, cores e imagens da aplicação ................................................................................. 49

4.3 Arquivo com as cores da aplicação .......................................................................................................... 51

4.4 Criando estilos .......................................................................................................................................... 52

4.5 Usando temas do Android ....................................................................................................................... 53

4.6 Definindo as dimensões dos componentes de layout ............................................................................. 55

5.Competência 05 | A Classe View Elementos Básicos ........................................................................ 58

5.1 TextView ................................................................................................................................................... 59

5.2 EditText .................................................................................................................................................... 61

5.3 Button e ImageButton .............................................................................................................................. 62

5.4 CheckBox .................................................................................................................................................. 65

5.5 RadioButton ............................................................................................................................................. 66

5.6 Spinner ..................................................................................................................................................... 68

5.8 Toast ......................................................................................................................................................... 72

6.Competência 06 | Banco de Dados, SharedPreferences e APIs Importantes .................................. 74

6.1 Banco de dados ........................................................................................................................................ 74

6.2 SQLite ....................................................................................................................................................... 74

6.3 Preferências do usuário ........................................................................................................................... 75

6.4 API de Mapas ........................................................................................................................................... 77

6.5 GPS ........................................................................................................................................................... 77

7.Competência 07 | Publicando Aplicação na Google Play ................................................................. 79

7.1 Versionamento da sua app ...................................................................................................................... 79

7.2 Compatibilidade para instalação da aplicação ......................................................................................... 81

7.3 Assinando a aplicação com um certificado digital ................................................................................... 82

7.5 Publicando a sua aplicação na Google Play ............................................................................................. 86

Minicurrículo do Professor ................................................................................................................... 91

Gilson de Oliveira ................................................................................................................................. 91

1.Competência 01 | Apresentando a Classe Activity, Ciclo de Vida e Tipos

especificada no método setContentView(view), que já vimos anteriormente, este método recebe

1.2 Ciclo de vida de uma Activity

Figura 1 - Ciclo de vida de uma activity

É um método obrigatório, por isso deve estar presente em toda activity e é

Caso o celular entre em modo de espera, hiberne, receba uma ligação ou a

Tabela 1 - Ciclo de vida de uma aplicação Android

public class MainActivity extends Activity {

TextView olaMundo = new TextView(this);

Quando eu executo a aplicação, meu LogCat mostra o seguinte: